ON 20060126@11:49:18 AM at page:
http://www.piclist.com/microchip/math/div/index.htm#38742.2436574074
James Newton[JMN-EFP-786] published post 38742.2436574074
james@ind-interface.co.uk shares this code:
The archive on this page links to 2 divide 24 by 8 routines.
-PICList post "24bit by 16bit Division" (actually 24 / 8)
-PICList post "Divide 24/8 routine" ASM embedded in C
During testing I discovered that high numbers cause the wrong
answers to be calculated (eg 0xF00000 / 0xFD = wrong answer)
I wrote my own routine which is Nikolai's 24 bits by 16,
modified to divide by 8 bits, remainder is also 8 bits:
;***********************************************************
;Unsigned 24 bit by 8 bit divide routine
;
; Inputs:
; Dividend - x,x+1,x+2 (x+2 - most significant!)
; Divisor - y
; Temporary:
; Counter - counter
; Output:
; Quotient - x,x+1,x+2 (x+2 - most significant!)
; Remainder - x+3
;
; Size: 17
; Timing: 342 cycles (including call and return)
;
; This is basically Nikolai Golovchenko's 24 by 16 bit
; divide routine, with some instructions removed to
; optimise it for an 8 bit divide.
; Thanks to Nikolai for the original post.
;
; James Hillman, 2 December 2005
;***********************************************************
FXD248U:
CLRF x+3 ;remainder
MOVLW d'24'
MOVWF counter
LOOPU248
RLF x,W ;shift dividend left to move next bit to remainder
RLF x+1,F ;
RLF x+2,F ;
RLF x+3,F ;shift carry (next dividend bit) into remainder
RLF x,F ;finish shifting the dividend and save carry in x.0,
;since remainder can be 9 bit long in some cases
;This bit will also serve as the next result bit.
MOVF y,W ;substract divisor from 8-bit remainder
SUBWF x+3,F
;here we also need to take into account the 9th bit of remainder, which
;is in x.0. If we don't have a borrow after subtracting from
;8 bits of remainder, then there is no borrow regardless of 9th bit
;value. But, if we have the borrow, then that will depend on 9th bit
;value. If it is 1, then no final borrow will occur. If it is 0, borrow
;will occur. These values match the borrow flag polarity.
BTFSC STATUS,0 ;if no borrow after 8 bit subtraction
BSF x,0 ;then there is no borrow in result. Overwrite
;x.0 with 1 to indicate no borrow.
;if borrow did occur, x.0 already
;holds the final borrow value (0-borrow,
;1-no borrow)
BTFSS x,0 ;if no borrow after 9-bit subtraction
ADDWF x+3,F ;restore remainder. (w contains the value
;subtracted from it previously)
DECFSZ counter,F
GOTO LOOPU248
RETURN
|Delete 'P-' before: '' but after: 'James Ashley Hillman of Industrial Interface Research Ltd shares this code:
The archive on this page links to 2 divide 24 by 8 routines.
-PICList post "24bit by 16bit Division" (actually 24 / 8)
-PICList post "Divide 24/8 routine" ASM embedded in C
During testing I discovered that high numbers cause the wrong
answers to be calculated (eg 0xF00000 / 0xFD = wrong answer)
I wrote my own routine which is Nikolai's 24 bits by 16,
modified to divide by 8 bits, remainder is also 8 bits:
;***********************************************************
;Unsigned 24 bit by 8 bit divide routine
;
; Inputs:
; Dividend - x,x+1,x+2 (x+2 - most significant!)
; Divisor - y
; Temporary:
; Counter - counter
; Output:
; Quotient - x,x+1,x+2 (x+2 - most significant!)
; Remainder - x+3
;
; Size: 17
; Timing: 342 cycles (including call and return)
;
; This is basically Nikolai Golovchenko's 24 by 16 bit
; divide routine, with some instructions removed to
; optimise it for an 8 bit divide.
; Thanks to Nikolai for the original post.
;
; James Hillman, 2 December 2005
;***********************************************************
FXD248U:
CLRF x+3 ;remainder
MOVLW d'24'
MOVWF counter
LOOPU248
RLF x,W ;shift dividend left to move next bit to remainder
RLF x+1,F ;
RLF x+2,F ;
RLF x+3,F ;shift carry (next dividend bit) into remainder
RLF x,F ;finish shifting the dividend and save carry in x.0,
;since remainder can be 9 bit long in some cases
;This bit will also serve as the next result bit.
MOVF y,W ;substract divisor from 8-bit remainder
SUBWF x+3,F
;here we also need to take into account the 9th bit of remainder, which
;is in x.0. If we don't have a borrow after subtracting from
;8 bits of remainder, then there is no borrow regardless of 9th bit
;value. But, if we have the borrow, then that will depend on 9th bit
;value. If it is 1, then no final borrow will occur. If it is 0, borrow
;will occur. These values match the borrow flag polarity.
BTFSC STATUS,0 ;if no borrow after 8 bit subtraction
BSF x,0 ;then there is no borrow in result. Overwrite
;x.0 with 1 to indicate no borrow.
;if borrow did occur, x.0 already
;holds the final borrow value (0-borrow,
;1-no borrow)
BTFSS x,0 ;if no borrow after 9-bit subtraction
ADDWF x+3,F ;restore remainder. (w contains the value
;subtracted from it previously)
DECFSZ counter,F
GOTO LOOPU248
RETURN
|Delete 'P-' before: '' but after: 'james@ind-interface.co.uk shares this code:
The archive on this page links to 2 divide 24 by 8 routines.
-PICList post "24bit by 16bit Division" (actually 24 / 8)
-PICList post "Divide 24/8 routine" ASM embedded in C
During testing I discovered that high numbers cause the wrong
answers to be calculated (eg 0xF00000 / 0xFD = wrong answer)
I wrote my own routine which is Nikolai's 24 bits by 16,
modified to divide by 8 bits, remainder is also 8 bits:
;***********************************************************
;Unsigned 24 bit by 8 bit divide routine
;
; Inputs:
; Dividend - x,x+1,x+2 (x+2 - most significant!)
; Divisor - y
; Temporary:
; Counter - counter
; Output:
; Quotient - x,x+1,x+2 (x+2 - most significant!)
; Remainder - x+3
;
; Size: 17
; Timing: 342 cycles (including call and return)
;
; This is basically Nikolai Golovchenko's 24 by 16 bit
; divide routine, with some instructions removed to
; optimise it for an 8 bit divide.
; Thanks to Nikolai for the original post.
;
; James Hillman, 2 December 2005
;***********************************************************
FXD248U:
CLRF x+3 ;remainder
MOVLW d'24'
MOVWF counter
LOOPU248
RLF x,W ;shift dividend left to move next bit to remainder
RLF x+1,F ;
RLF x+2,F ;
RLF x+3,F ;shift carry (next dividend bit) into remainder
RLF x,F ;finish shifting the dividend and save carry in x.0,
;since remainder can be 9 bit long in some cases
;This bit will also serve as the next result bit.
MOVF y,W ;substract divisor from 8-bit remainder
SUBWF x+3,F
;here we also need to take into account the 9th bit of remainder, which
;is in x.0. If we don't have a borrow after subtracting from
;8 bits of remainder, then there is no borrow regardless of 9th bit
;value. But, if we have the borrow, then that will depend on 9th bit
;value. If it is 1, then no final borrow will occur. If it is 0, borrow
;will occur. These values match the borrow flag polarity.
BTFSC STATUS,0 ;if no borrow after 8 bit subtraction
BSF x,0 ;then there is no borrow in result. Overwrite
;x.0 with 1 to indicate no borrow.
;if borrow did occur, x.0 already
;holds the final borrow value (0-borrow,
;1-no borrow)
BTFSS x,0 ;if no borrow after 9-bit subtraction
ADDWF x+3,F ;restore remainder. (w contains the value
;subtracted from it previously)
DECFSZ counter,F
GOTO LOOPU248
RETURN
'
ON 20060126 at page:
http://www.massmind.org/techref/microchip/math/div/index.htm
someone[--] edited the page. Difference:
"R:\bak\H\techref\microchip\math\div\index.htm.20060126.dif"