Exact match. Not showing close matches.
PICList
Thread
'[PIC] Divide by 10'
2006\02\22@085205
by
Jáhn Balázs
Hi,
I want a 8 bit number divide by 10 (ten).
I need the quotient and the remain.
Which is the fastest ASM code for pic 16f877?
Many thanks!!!
Balazs
___________________________________________________________________________
[origo] klikkbank lakossági számlacsomag havi 199 Ftért, bankkártya éves díj nélkül!
http://www.klikkbank.hu
2006\02\22@110923
by
Gerhard Fiedler
Jáhn Balázs wrote:
> I want a 8 bit number divide by 10 (ten).
> I need the quotient and the remain.
>
> Which is the fastest ASM code for pic 16f877?
I don't know, but I'd look at piclist.com first. Considering the history of
this list, I'm pretty sure there's a routine that is at least close to
optimal.
Gerhard
2006\02\22@114641
by
Spehro Pefhany

At 01:08 PM 2/22/2006 0300, you wrote:
>Jáhn Balázs wrote:
>
> > I want a 8 bit number divide by 10 (ten).
> > I need the quotient and the remain.
> >
> > Which is the fastest ASM code for pic 16f877?
>
>I don't know, but I'd look at piclist.com first. Considering the history of
>this list, I'm pretty sure there's a routine that is at least close to
>optimal.
>
>Gerhard
Or just use a LUT, if "fastest" is really the criterion. You can do quotient
and remainder in a single 14bit word, obviously, so only 3% of your memory
would be required for the table. Max quotient is 25 and maximum remainder is
9, so 6 and 4 bits respectively. With 8 bits allowed for the quotient, no
shifting would be required. This will work any divisor from 1 to 32
inclusive.
Best regards,
Spehro Pefhany "it's the network..." "The Journey is the reward"
spam_OUTspeffTakeThisOuTinterlog.com Info for manufacturers: http://www.trexon.com
Embedded software/hardware/analog Info for designers: http://www.speff.com
>> Inexpensive test equipment & parts http://search.ebay.com/_W0QQsassZspeff
2006\02\22@115642
by
Rolf
Jáhn Balázs wrote:
> Hi,
>
> I want a 8 bit number divide by 10 (ten).
> I need the quotient and the remain.
>
> Which is the fastest ASM code for pic 16f877?
>
> Many thanks!!!
>
> Balazs
>
> ___________________________________________________________________________
> [origo] klikkbank lakossági számlacsomag havi 199 Ftért, bankkártya éves díj nélkül!
> http://www.klikkbank.hu
>
>
>
>
Given that the dividend is only an 8 bit value to start with (stored in
W), and assuming it is in range 0255....
snippet puts quotient in "quotient", and remainder in W
movwf dividend ; w contains the dividend
clrf quotient
movlw 10
subwf dividend,f
btfss STATUS,0 ; check for positive (Carry bit).
goto $+3 ; result is negative
incf quotient,f
goto $4
addwf dividend,w
best case makes this 8 cycles, worst case is 25*6 + 8 = 158 cycles.
"average" is about 75 cycles.
Otherwise, have a look at app note 544 which may help...
http://ww1.microchip.com/downloads/en/appnotes/00544d.pdf
Rolf
P.S. I have not tested this code ....
2006\02\22@121014
by
Bob Axtell
Another way to ask this question is to ask for an
'8bit BIN to DEC' converter.
To perform the fastest possible 8bit BIN to DEC conversion:
Use variables TMP,TMP1,. W (entry value):
1. If W greater than 99, subtract off 100, incr TMP (to 1), otherwise
set tmp=0. The remainder is now in W.
2. If W is now greater than 99, increment TMP. Do NOT alter
W.
3. W is now 7 bits. Lookup W in a 128element RETLW table.
results: the ONES place is in the lower nibble of W, the TENS place
is in the upper nibble of W, the 100s place is in TMP.
The table is simply 128 RETLW elements; for the entry value
of h'10', the retlw value is h'16'; for an entry of h'63', the retlw
value is h'99'; for an entry of h'64', the retlw value is h'00', etc
etc.
This will be an example, W has the value on entry:
8Bin2Dec:
clrf tmp
addlw d'100' ;> 99?
btfss status,c
incf tmp,f ; =1 if > 99 (no overflow)
btfss tmp,0
addlw d'100' ; fix W if < 100.
addlw d'100' ; > 199?
btfss status,c
incf tmp,f ; =2 if > 199 (no overflow)
addlw d'100'
addwf pcl,f
retlw h'00' ;element 1 [000]
.
.
.
.
(n)
retlw h'27' ;element 128 [127]
This is the fastest code for all PIC16F, 12 words actually
executed, but uses 139 words of code space.
An alternative is to simply subtract 100s then subtract 10s.
uses LOTS of machine cycles, but is sparing of code space..
Bob
Jáhn Balázs wrote:
{Quote hidden}>Hi,
>
>I want a 8 bit number divide by 10 (ten).
>I need the quotient and the remain.
>
>Which is the fastest ASM code for pic 16f877?
>
>Many thanks!!!
>
>Balazs
>
>___________________________________________________________________________
>[origo] klikkbank lakossági számlacsomag havi 199 Ftért, bankkártya éves díj nélkül!
>
http://www.klikkbank.hu
>
>
>
>
>

Note: To protect our network,
attachments must be sent to
.....attachKILLspam@spam@engineer.cotse.net .
15208501673 USA/Canada
http://beam.to/azengineer
2006\02\22@124133
by
Bob Axtell
Spehro has it right to use the code access capability of the
F877 allows the LUT to handle all of it, i.e. 2 bits for 100s, 4
bits for tens, 4bits for ones places, a total of 10 bits. BUT, it uses
over 260 code words. Would run about 9 cycles to extract a
lookup value, however, faster than my earlier suggestion.
Bob
Bob Axtell wrote:
{Quote hidden}>Another way to ask this question is to ask for an
>'8bit BIN to DEC' converter.
>
>To perform the fastest possible 8bit BIN to DEC conversion:
>
>Use variables TMP,TMP1,. W (entry value):
>
>1. If W greater than 99, subtract off 100, incr TMP (to 1), otherwise
>set tmp=0. The remainder is now in W.
>
>2. If W is now greater than 99, increment TMP. Do NOT alter
>W.
>
>3. W is now 7 bits. Lookup W in a 128element RETLW table.
>results: the ONES place is in the lower nibble of W, the TENS place
>is in the upper nibble of W, the 100s place is in TMP.
>
>The table is simply 128 RETLW elements; for the entry value
>of h'10', the retlw value is h'16'; for an entry of h'63', the retlw
>value is h'99'; for an entry of h'64', the retlw value is h'00', etc
>etc.
>
>This will be an example, W has the value on entry:
>
>8Bin2Dec:
> clrf tmp
> addlw d'100' ;> 99?
> btfss status,c
> incf tmp,f ; =1 if > 99 (no overflow)
> btfss tmp,0
> addlw d'100' ; fix W if < 100.
> addlw d'100' ; > 199?
> btfss status,c
> incf tmp,f ; =2 if > 199 (no overflow)
> addlw d'100'
> addwf pcl,f
> retlw h'00' ;element 1 [000]
> .
> .
> .
> .
> (n)
> retlw h'27' ;element 128 [127]
>
>This is the fastest code for all PIC16F, 12 words actually
>executed, but uses 139 words of code space.
>
>An alternative is to simply subtract 100s then subtract 10s.
>uses LOTS of machine cycles, but is sparing of code space..
>
>
>Bob
>
>Jáhn Balázs wrote:
>
>
>
>>Hi,
>>
>>I want a 8 bit number divide by 10 (ten).
>>I need the quotient and the remain.
>>
>>Which is the fastest ASM code for pic 16f877?
>>
>>Many thanks!!!
>>
>>Balazs
>>
>>______
>>

Note: To protect our network,
attachments must be sent to
attachKILLspamengineer.cotse.net .
15208501673 USA/Canada
http://beam.to/azengineer
2006\02\22@132400
by
Bill Freeman
Jáhn Balázs writes:
> I want a 8 bit number divide by 10 (ten).
> I need the quotient and the remain.
>
> Which is the fastest ASM code for pic 16f877?
For an 8 bit dividend a look up table is practical. Since you
want the remainder, two look up tables. You won't get faster than
that. If you also care about code space, then things get more
interesting.
Bill
2006\02\22@144117
by
Byron A Jeff
On Wed, Feb 22, 2006 at 02:50:53PM +0100, J?hn Bal?zs wrote:
> Hi,
>
> I want a 8 bit number divide by 10 (ten).
> I need the quotient and the remain.
>
> Which is the fastest ASM code for pic 16f877?
Simple. Table lookup. Costs 512 instructions for the RETLWs and 2 or so
instructions for the setup for the jump. Something along the lines of:
org 0x01ff ; Start on instruction short of 256 instruction
; boundary. How can this be done in a
; relocatable fashion?
div10q: addwf PCL,F
retlw 0 ; 0/10 = 0
retlw 0 ; 1/10 = 0
; ... up to 9 then
retlw 1 ; 10/10 = 1
retlw 1 ; 11/11 = 1
and so forth.
BAJ
2006\02\22@144352
by
Byron A Jeff
On Wed, Feb 22, 2006 at 11:58:26AM 0500, Rolf wrote:
{Quote hidden}> J?hn Bal?zs wrote:
> > Hi,
> >
> > I want a 8 bit number divide by 10 (ten).
> > I need the quotient and the remain.
> >
> > Which is the fastest ASM code for pic 16f877?
> >
> > Many thanks!!!
> >
> > Balazs
> >
> > ___________________________________________________________________________
> > [origo] klikkbank lakoss?gi sz?mlacsomag havi 199 Ft?rt, bankk?rtya ?ves d?j n?lk?l!
> >
http://www.klikkbank.hu
> >
> >
> >
> >
> Given that the dividend is only an 8 bit value to start with (stored in
> W), and assuming it is in range 0255....
> snippet puts quotient in "quotient", and remainder in W
>
> movwf dividend ; w contains the dividend
> clrf quotient
> movlw 10
> subwf dividend,f
> btfss STATUS,0 ; check for positive (Carry bit).
> goto $+3 ; result is negative
> incf quotient,f
> goto $4
> addwf dividend,w
>
>
> best case makes this 8 cycles, worst case is 25*6 + 8 = 158 cycles.
> "average" is about 75 cycles.
I would suggest that this would not qualify as "fast". A lookup table
encoded either as RETLWs or as instructions would have an average and best
time of better than 8 cycles.
BAJ
2006\02\22@150153
by
David VanHorn
This is a good illustration of how you need to know the machine "guts" to
know how best to implement something, and a good illustration of how higher
level languages would hide that from you.
2006\02\22@154521
by
Maarten Hofman
Rochester, 22 februari 2006.
I know this wasn't part of the original question, but in some cases
you might want to approximate the result, to get a fast result with
minimum memory usage. A possible approximation could be to multiply by
3/32 (or 13/128 for enhanced accuracy).
Such a multiplication could be done by:
3/32: result = (x+8)>>4 + (x+16)>>5 (mean error: 0.80, max: 2)
13/128: result = (x+8)>>4 + (x+16)>>5 + (x+64)>>7 (mean error: 0.34, max: 1)
Or, if you wish to reduce the additions due to rounding:
3/32: result = (x>>3 + x>>4 + 1)>>2 (mean error: 1.05, max: 3)
13/128: result = (x>>3 + x>>4 + x>>6 + 1)>>2 (mean error: 0.34, max: 1)
Greetings,
Maarten Hofman.
2006\02\23@055028
by
Chris Emerson
On Wed, Feb 22, 2006 at 10:41:34AM 0700, Bob Axtell wrote:
> Spehro has it right to use the code access capability of the
> F877 allows the LUT to handle all of it, i.e. 2 bits for 100s, 4
> bits for tens, 4bits for ones places, a total of 10 bits. BUT, it uses
> over 260 code words. Would run about 9 cycles to extract a
> lookup value, however, faster than my earlier suggestion.
As a compromise you could save about half that space (at the cost of a
few cycles) by first rightshifting, dividing by 5 using a halfsize
LUT, and adding the LSB back into the remainder at the end.
Chris
2006\02\23@090551
by
Jáhn Balázs
Bob Axtell wrote:
>Another way to ask this question is to ask for an
>'8bit BIN to DEC' converter.
I wasn't carefull, and I don't tell everything sorry.
In my variable there are only 00h63h (0d99d). And I want divide it by
10... I tought there is a very simple method, but I don't know it.
So, it seems the fastest method is the the LOOKUP table, it takes a few
cycles but more than 100 rows, the shortest (row) method is more than
100 cycles.
Balazs
___________________________________________________________________________
[origo] klikkbank lakossági számlacsomag havi 199 Ftért, bankkártya éves díj nélkül!
http://www.klikkbank.hu
2006\02\23@090707
by
Byron A Jeff
On Thu, Feb 23, 2006 at 10:50:27AM +0000, Chris Emerson wrote:
> On Wed, Feb 22, 2006 at 10:41:34AM 0700, Bob Axtell wrote:
> > Spehro has it right to use the code access capability of the
> > F877 allows the LUT to handle all of it, i.e. 2 bits for 100s, 4
> > bits for tens, 4bits for ones places, a total of 10 bits. BUT, it uses
> > over 260 code words. Would run about 9 cycles to extract a
> > lookup value, however, faster than my earlier suggestion.
>
> As a compromise you could save about half that space (at the cost of a
> few cycles) by first rightshifting, dividing by 5 using a halfsize
> LUT, and adding the LSB back into the remainder at the end.
I didn't see anything the original spec that indicated that compromise was
necessary. The OP threw out the word fastest. Space be damned! ;)
BAJ
2006\02\23@094831
by
Peter van Hoof
 Original Message 
{Quote hidden}>I wasn't carefull, and I don't tell everything sorry.
>In my variable there are only 00h63h (0d99d). And I want divide it by
>10... I tought there is a very simple method, but I don't know it.
>So, it seems the fastest method is the the LOOKUP table, it takes a few
>cycles but more than 100 rows, the shortest (row) method is more than
>100 cycles.
>Balazs
look at app note an544
www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1824&appnote=en011088
there are 4 ways described to do this without tables
fastest: Binary to BCD (8 bit) 10 words 62 cycles 1 byte scratch unused
Peter van Hoof
2006\02\23@105432
by
Bill Freeman

Jáhn Balázs writes:
> In my variable there are only 00h63h (0d99d). And I want divide it by
> 10... I tought there is a very simple method, but I don't know it.
>
> So, it seems the fastest method is the the LOOKUP table, it takes a few
> cycles but more than 100 rows, the shortest (row) method is more than
> 100 cycles.
Here's an intermediate speed, and intermediate program store
use, version, between LUT versions and shift and loop versions in both
dimensions.
Since you know that the dividend is less than 100:
div10 movwf rem ; Assumes called with dividend in W, and that
clrf quo ; bank selection is allready set for access to
movlw D'80' ; rem and quo.
subwf rem,W ; rem >= 80?
BNC div10a ; No (rem80 borrowed)
movwf rem ; Remove 80 from rem (could have subwf rem,F)
bsf quo,3 ; "add" 8 to quotient
div10a movlw D'40'
subwf rem,W ; What's left in rem >= 40?
BNC div10b
movwf rem
bsf quo,2 ; "add" 4 to quotient
div10b movlw D'20'
subwf rem,W
BNC div10c
movwf rem
bsf quo,1
div10c movlw D'10'
subwf rem,W
BNC div10d
movwf rem
bsf quo,0
div10d ; Quotiend now in quo, remainder in rem
swapf quo,W ; One way to return is as BCD, quotient to high
iorwf rem,W ; nibble and the remainder in the low nibble.
return
The time for everything, including call and return, is max 32
cycles, min 28 cycles (28 plus the number of one bits in the quotiend).
If you don't want it as a subroutine, and you're happy to read your
results from rem and quo, and the dividend is already in a file register
that you're happy to use as rem, then the range, still including the
clearing of quo, is 21 to 25 cycles.
Except for the hack of creating a two digit BCD return value,
and interpreting the quotiend as binary, rathern than BCD, this
actually works for dividends up to 159. If you want dividends up to
the whole unsigned byte (255), you could include a compare with 160
stage before the compare with 80 stage. The extra stage adds 6 cycles
if it sets the bit and 5 if it doesn't. If you want a BCD quotient,
then use 100 instead of 160 to work for dividends up to 199, or add
both a 200 and 100 section for dividends up to 255.
Bill
2006\02\23@110834
by
Scott Dattalo

On Thu, 20060223 at 06:48 0800, Peter van Hoof wrote:
> look at app note an544
> http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1824&appnote=en011088
>
>
> there are 4 ways described to do this without tables
> fastest: Binary to BCD (8 bit) 10 words 62 cycles 1 byte scratch unused
When Peter says that the fastest way to solve this problem without tables
takes 62 cycles, what he really means is that the fastest way an544 solves
this problem takes 62 cycles. Of course, there are faster nontable
solutions out there. One in particular takes 18 cycles.
SWAPF bin, W ;w = A0*16+A1
ADDWF bin, W ;w = A0+A1
ANDLW 00001111b ;w = A0+A1 % 16
SKPNDC ;if A0+A1 > 16
ADDLW 0x16 ; w += 16
SKPNDC ;if w % 16 > 10
ADDLW 0x06 ; w += 6
ADDLW 0x06 ;w += 6
SKPDC ;if w < 10
ADDLW 0x06 ; w = 6
BTFSC bin,4
ADDLW 0x16  1 + 0x6
SKPDC
ADDLW 0x06
BTFSC bin, 5
ADDLW 0x30
BTFSC bin, 6
ADDLW 0x60
; result is in W
This was adapted from:
www.piclist.com/techref/microchip/math/radix/b2bhp8b3d.htm
And the algorithm is described:
http://www.piclist.com/techref/method/math/radixs.htm
Scott
2006\02\23@124351
by
Bob Axtell
Jáhn Balázs wrote:
{Quote hidden}>Bob Axtell wrote:
>
>
>
>>Another way to ask this question is to ask for an
>>'8bit BIN to DEC' converter.
>>
>>
>
>I wasn't carefull, and I don't tell everything sorry.
>
>In my variable there are only 00h63h (0d99d). And I want divide it by
>10... I tought there is a very simple method, but I don't know it.
>
>So, it seems the fastest method is the the LOOKUP table, it takes a few
>cycles but more than 100 rows, the shortest (row) method is more than
>100 cycles.
>
>Balazs
>
>___________________________________________________________________________
>[origo] klikkbank lakossági számlacsomag havi 199 Ftért, bankkártya éves díj nélkül!
>
http://www.klikkbank.hu
>
>
>
>
>
Exactly Correct, John.

Note: To protect our network,
attachments must be sent to
.....attachKILLspam.....engineer.cotse.net .
15208501673 USA/Canada
http://beam.to/azengineer
2006\02\23@130330
by
Dmitriy Kiryashov

Two straighforward approached conversions.
( both out of head, not tested though )
Might try to optimize it later :)
; byte/10 : x is original number
; y is result, w is remain
clrf y
movfw x
addlw D'160' ;getting two bits of hundreds
rlf y,F
btfss y,0
addlw D'160'
addlw D'80'
rlf y,F
btfss y,0
addlw D'80'
addlw D'40'
rlf y,F
btfss y,0
addlw D'40'
addlw D'20'
rlf y,F
btfss y,0
addlw D'20'
addlw D'10'
rlf y,F
btfss y,0
addlw D'10'
; hex2bcd : x is original number
; y has hunds and tens, W has ones left
clrf y
movfw x
addlw D'200' ;getting two bits of hundreds
rlf y,F
btfss y,0
addlw D'200'
addlw D'100'
rlf y,F
btfss y,0
addlw D'100'
addlw D'80' ;getting four bits of tens
rlf y,F
btfss y,0
addlw D'80'
addlw D'40'
rlf y,F
btfss y,0
addlw D'40'
addlw D'20'
rlf y,F
btfss y,0
addlw D'20'
addlw D'10'
rlf y,F
btfss y,0
addlw D'10'
Code space can be squeezed as
clrf y
movlw const_1
call convert
movlw const_2
call convert
;...
convert
subwf x,F
rlf y,F
btfss y,0
addwf x,F
return
WBR Dmitriy.
JÂhn BalÂzs wrote:
{Quote hidden}>
> Hi,
>
> I want a 8 bit number divide by 10 (ten).
> I need the quotient and the remain.
>
> Which is the fastest ASM code for pic 16f877?
>
> Many thanks!!!
>
> Balazs
>
> ___________________________________________________________________________
> [origo] klikkbank lakossági számlacsomag havi 199 Ftért, bankkártya éves díj nélkül!
>
http://www.klikkbank.hu
>
>
2006\02\23@134448
by
James Newton, Host
> I want a 8 bit number divide by 10 (ten).
> I need the quotient and the remain.
>
> Which is the fastest ASM code for pic 16f877?
Multiply by 1/10
<www.piclist.com/cgibin/constdivmul.exe?Acc=ACC&Bits=8&endian=little
&Const=.1&ConstErr=0.5&Temp=TEMP&cpu=pic16>
; ACC = ACC * 0.1
; Temp = TEMP
; ACC size = 8 bits
; Error = 0.5 %
; Bytes order = little endian
; Round = no
; ALGORITHM:
; Clear accumulator
; Add input / 16 to accumulator
; Add input / 32 to accumulator
; Add input / 256 to accumulator
; Add input / 512 to accumulator
; Move accumulator to result
;
; Approximated constant: 0.0996094, Error: 0.390625 %
; Input: ACC0, 8 bits
; Output: ACC0, 5 bits
; Code size: 17 instructions
cblock
ACC0
endc
;copy accumulator to temporary
movf ACC0, w
;shift accumulator right 1 times
clrc
rrf ACC0, f
;add temporary to accumulator
addwf ACC0, f
;shift accumulator right 3 times
rrf ACC0, f
clrc
rrf ACC0, f
clrc
rrf ACC0, f
;add temporary to accumulator
addwf ACC0, f
;shift accumulator right 1 times
rrf ACC0, f
;add temporary to accumulator
addwf ACC0, f
;shift accumulator right 4 times
swapf ACC0, w
andlw 0x0F
movwf ACC0
skpnc
bsf ACC0, 4
; Generated by http://www.piclist.com/cgibin/constdivmul.exe (1May2002 version)
; Thu Feb 23 18:29:05 2006 GMT
See also:
<www.piclist.org/techref/postbot.asp?by=time&id=piclist\1996\06\11\16
0057a>
http://www.piclist.com/techref/microchip/math/div/index.htm

James Newton: PICList webmaster/Admin
EraseMEjamesnewtonspam_OUTTakeThisOuTpiclist.com 16196520593 phone
http://www.piclist.com/member/JMNEFP786
PIC/PICList FAQ: http://www.piclist.com
2006\02\23@151950
by
Peter
On Thu, 23 Feb 2006, Chris Emerson wrote:
{Quote hidden}> On Wed, Feb 22, 2006 at 10:41:34AM 0700, Bob Axtell wrote:
>> Spehro has it right to use the code access capability of the
>> F877 allows the LUT to handle all of it, i.e. 2 bits for 100s, 4
>> bits for tens, 4bits for ones places, a total of 10 bits. BUT, it uses
>> over 260 code words. Would run about 9 cycles to extract a
>> lookup value, however, faster than my earlier suggestion.
>
> As a compromise you could save about half that space (at the cost of a
> few cycles) by first rightshifting, dividing by 5 using a halfsize
> LUT, and adding the LSB back into the remainder at the end.
N/10 = N/8  N/32 + N/128 (  N/640 ... )
The terms before the parentheses are enough for 8 bits.
Peter
2006\02\23@154120
by
Peter

part 1 967 bytes contenttype:TEXT/PLAIN; CHARSET=XUNKNOWN; FORMAT=flowed (decoded quotedprintable)
On Thu, 23 Feb 2006, [ISO88592] Jáhn Balázs wrote:
> Bob Axtell wrote:
>
>> Another way to ask this question is to ask for an
>> '8bit BIN to DEC' converter.
>
> I wasn't carefull, and I don't tell everything sorry.
>
> In my variable there are only 00h63h (0d99d). And I want divide it by
> 10... I tought there is a very simple method, but I don't know it.
N/10 = N/8  N/32 + N/128
; untested code, isochronous, 13 clocks (11 if FN_GT_127 is
; undefined)
; input is Fn, output is Fy, Fn emerges divided by four
swapf Fn,w ; W = Fn/16
andlw 0x0F
movwf Fy ; Fy = N/16
rrf Fy,f ; Fy = N/32
comf Fy,f
incf Fy,f ; Fy =  N/32
#ifdef FN_GT_127
btfsc Fn,7
incf Fy,f ; Fy =  Fn/32 + Fn/128
#endif
rrf Fn,f
rrf Fn,f
rrf Fn,w
andlw 0x1F ; W = Fn/8
addwf Fy,f ; Fy = Fn/8  Fn/32 + Fn/128
I am sure that one of the geniuses will optimize this.
Peter
part 2 35 bytes contenttype:text/plain; charset="usascii"
(decoded 7bit)
2006\02\23@165521
by
Scott Dattalo
James Newton, Host wrote:
>>I want a 8 bit number divide by 10 (ten).
>>I need the quotient and the remain.
>>
>>Which is the fastest ASM code for pic 16f877?
>
>
> Multiply by 1/10
<snip>
What about the remainder? Peter's solution has a similar problem.
Scott
2006\02\23@172450
by
William Chops Westfield
On Feb 23, 2006, at 12:41 PM, Peter wrote:
>
> N/10 = N/8  N/32 + N/128
>
I believe the original posting said that he needed the remainder
as well...
BillW
2006\02\23@173032
by
Spehro Pefhany
At 01:55 PM 2/23/2006 0800, you wrote:
>James Newton, Host wrote:
> >>I want a 8 bit number divide by 10 (ten).
> >>I need the quotient and the remain.
> >>
> >>Which is the fastest ASM code for pic 16f877?
> >
> >
> > Multiply by 1/10
>
><snip>
>
>What about the remainder? Peter's solution has a similar problem.
>
>Scott
Scott's method gives the exact quotient and remainder packed in a single byte
in just 18 cycles. I suspect that's unbeatable (without a LUT). And it is
just a special case of his routine in the piclist source code library.
Best regards,
Spehro Pefhany "it's the network..." "The Journey is the reward"
speffspam_OUTinterlog.com Info for manufacturers: http://www.trexon.com
Embedded software/hardware/analog Info for designers: http://www.speff.com
>> Inexpensive test equipment & parts http://search.ebay.com/_W0QQsassZspeff
2006\02\23@174710
by
James Newton, Host
Scott Dattalo Sent: 2006 Feb 23, Thu 13:55
>
> James Newton, Host wrote:
> >>I want a 8 bit number divide by 10 (ten).
> >>I need the quotient and the remain.
> >>
> >>Which is the fastest ASM code for pic 16f877?
> >
> >
> > Multiply by 1/10
>
> <snip>
>
> What about the remainder? Peter's solution has a similar problem.
>
Oops. Yep, the OP did say remainder was needed. Looks like your solution is
optimal. The only problem with it is that I can't understand how it works.
<grin> The comments stop around the point where the comments are really
starting to get necessary...
Just for the record, here is Scott's solution again:
> {Original Message removed}
2006\02\24@082837
by
Jáhn Balázs
Scott Dattalo wrote
>Of course, there are faster nontable
>solutions out there. One in particular takes 18 cycles.
Scott, it's perfect for me, thank you!
And thank you for everybody who "sad" any tip for me. :)
Thanks
Balazs
___________________________________________________________________________
[origo] klikkbank lakossági számlacsomag havi 199 Ftért, bankkártya éves díj nélkül!
http://www.klikkbank.hu
2006\02\24@121516
by
Peter
On Thu, 23 Feb 2006, Scott Dattalo wrote:
> What about the remainder? Peter's solution has a similar problem.
I missed that requirement ... and your excellent solution (I see
digests).
Peter
2006\02\25@044807
by
Dmitriy Kiryashov

Hi Scott.
I believe input value range for hex is limited to 0..99d for procedure
shown in your post and there is straight coded solution with 18 clocks
as well for that case ( I'm getting so lazy I guess .. :)
; hex2bcd : x is original number
; y has tens, W has ones left
movfw x
clrf y ;we can even reuse x here..
addlw D'80' ;getting four bits of tens
rlf y,F
btfss y,0
addlw D'80'
addlw D'40'
rlf y,F
btfss y,0
addlw D'40'
addlw D'20'
rlf y,F
btfss y,0
addlw D'20'
addlw D'10'
rlf y,F
btfss y,0
addlw D'10'
>From the other hand if we scale it up ( extra 8 clocks/words see the
previous post ) to get hundreds as well converted it will be 2 clocks
/words shorter than procedure discussed at :
http://www.piclist.com/techref/microchip/math/radix/b2bhp8b3d.htm
WBR Dmitry.
Scott Dattalo wrote:
{Quote hidden}>
> On Thu, 20060223 at 06:48 0800, Peter van Hoof wrote:
>
> > look at app note an544
> > www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1824&appnote=en011088
> >
> >
> > there are 4 ways described to do this without tables
> > fastest: Binary to BCD (8 bit) 10 words 62 cycles 1 byte scratch unused
>
> When Peter says that the fastest way to solve this problem without tables
> takes 62 cycles, what he really means is that the fastest way an544 solves
> this problem takes 62 cycles. Of course, there are faster nontable
> solutions out there. One in particular takes 18 cycles.
>
> SWAPF bin, W ;w = A0*16+A1
> ADDWF bin, W ;w = A0+A1
> ANDLW 00001111b ;w = A0+A1 % 16
> SKPNDC ;if A0+A1 > 16
> ADDLW 0x16 ; w += 16
> SKPNDC ;if w % 16 > 10
> ADDLW 0x06 ; w += 6
> ADDLW 0x06 ;w += 6
> SKPDC ;if w < 10
> ADDLW 0x06 ; w = 6
>
> BTFSC bin,4
> ADDLW 0x16  1 + 0x6
> SKPDC
> ADDLW 0x06
>
> BTFSC bin, 5
> ADDLW 0x30
>
> BTFSC bin, 6
> ADDLW 0x60
>
> ; result is in W
>
> This was adapted from:
> www.piclist.com/techref/microchip/math/radix/b2bhp8b3d.htm
> And the algorithm is described:
> www.piclist.com/techref/method/math/radixs.htm
>
> Scott
2006\02\25@132401
by
Scott Dattalo
On Sat, 20060225 at 04:28 0500, Dmitriy Kiryashov wrote:
> Hi Scott.
>
> I believe input value range for hex is limited to 0..99d for procedure
> shown in your post and there is straight coded solution with 18 clocks
> as well for that case ( I'm getting so lazy I guess .. :)
Yes Dmitriy, you must be getting lazy. Why can't you squeeze this down to
12 instructions? :)
I like your solution better than mine, because it's a) shorter and b)
easier to understand!
Scott
2006\02\27@035451
by
Dmitriy Kiryashov

Hi Scott.
16 perhaps ? :)
Scott Dattalo wrote:
{Quote hidden}>
> One in particular takes 18 cycles.
>
> SWAPF bin, W ;w = A0*16+A1
> ADDWF bin, W ;w = A0+A1
> ANDLW 00001111b ;w = A0+A1 % 16
> SKPNDC ;if A0+A1 > 16
> ADDLW 0x16 ; w += 16
>> SKPNDC ;if w % 16 > 10
>> ADDLW 0x06 ; w += 6
With input value in range 00..63h(99.) I don't see the reason
why second skpndc check is required ? When dc flag is generated
in first instance maximum resulting value is 0x5 + 0xF = 0x14
I think these two lines can be safely omitted.
WBR Dmitry.
PS.
And final steps 0x40 > 0x60 and 0x20 > 0x30
are begging for some optimization as well. :)
{Quote hidden}> ADDLW 0x06 ;w += 6
> SKPDC ;if w < 10
> ADDLW 0x06 ; w = 6
>
> BTFSC bin,4
> ADDLW 0x16  1 + 0x6
> SKPDC
> ADDLW 0x06
>
> BTFSC bin, 5
> ADDLW 0x30
>
> BTFSC bin, 6
> ADDLW 0x60
>
> ; result is in W
>
> This was adapted from:
> www.piclist.com/techref/microchip/math/radix/b2bhp8b3d.htm
> And the algorithm is described:
> www.piclist.com/techref/method/math/radixs.htm
>
> Scott
> 
2006\02\28@022745
by
Dmitriy Kiryashov

Hi folks.
Scott inspired me how to shrink it down to 14 clocks/words :)
My intuition says it would be quite difficult to squize it down
to golden number of 12 :) ( perhaps some other time .. ) so I'm
leaving it the way it is now.
;input value <bin> are in range 0 .. 99d, result in W.
rrf bin,W ;0x40 > 0x60 , 0x20 > 0x30
andlw 0x30
addwf bin,W
movwf temp
swapf bin,W
btfsc bin,4
addlw 5 ;max <= 5 + 5
andlw 0x0F
addwf temp,W
skpndc
addlw 6
addlw 6
skpdc
addlw 6
WBR Dmitry.
Scott Dattalo wrote:
{Quote hidden}>
> On Sat, 20060225 at 04:28 0500, Dmitriy Kiryashov wrote:
> > Hi Scott.
> >
> > I believe input value range for hex is limited to 0..99d for procedure
> > shown in your post and there is straight coded solution with 18 clocks
> > as well for that case ( I'm getting so lazy I guess .. :)
>
> Yes Dmitriy, you must be getting lazy. Why can't you squeeze this down to
> 12 instructions? :)
>
> I like your solution better than mine, because it's a) shorter and b)
> easier to understand!
>
> Scott
>
> 
More... (looser matching)
 Last day of these posts
 In 2006
, 2007 only
 Today
 New search...