>Hello!
>
>I need to implement some 24 bits and a 32 bits counter in my
>application, in Assembly.
>I'm not ready yet to go into PIC C.
>
>I have seen 16bit to BCD, from John Payson, but I couldn't find a way to
>expand it
>to 24 bit and 32 bits.
>
>Does anyone have such routines?
>
>I know I could use division by 10 and module 10, but if there's a more
>efficient way, I would prefer it.
>
>Thank you,
>Nuno Pedrosa.
>--
>----  ~~~~~~~  -------  Nuno Filipe Freitas Pedrosa
>--  ~~~~     ~~  -----  SIEMENS S.A. Portugal       TEL: +351 1 4242454
>-  ~~~~       ~~  ----  .....Nuno.PedrosaKILLspam@spam@icn.siemens.de
>-  ~~~~       ~~  ----  "MSWindows - Best run on a SlideShow"
>=======================================================================
>

>
> >
> > Hello!
> >
> > I need to implement some 24 bits and a 32 bits counter in my
> > application, in Assembly.
> > I'm not ready yet to go into PIC C.
> >
> > I have seen 16bit to BCD, from John Payson, but I couldn't find a way to
> > expand it
> > to 24 bit and 32 bits.
> >
> > Does anyone have such routines?
> >
> > I know I could use division by 10 and module 10, but if there's a more
> > efficient way, I would prefer it.
>
> The most efficient way is to count in packed BCD. It'll take 4 bytes for
> 24 bits (up to 16000000 and change) and 5 bytes for 32 bits.
>
> Here's how to count in packed BCD:
>
> 1) Start at the lowest byte. Add 1.
> 2) If the low nybble is A, do a BCD adjust by adding 6 to it.
> 3) If the high nybble is A, do another BCD adjust by adding h'60' to it.
> 4) Do the next higher byte if the carry is set.
>
> So for example if you have
> 00001999
> (note that this is 4 consecutive bytes in hexidecimal representing packed BCD)
> and you add 1
> 0000199A
> Since the low nybble is A, adjust by adding 6
> 000019A0
> Since the high nybble is A, adjust by adding 60
> 00001900
> Since the carry is set goto the next byte and add 1 to it.
> 00001A00
> Since the low nybble is A, adjust by adding 6
> 00002000
> And voila! there's the incremented value.
>
> Off the cuff is seems that using FSR/INDF and a tight loop could get this done
> fairly efficiently since the adjustment process is the same for each nybble
>
> Hope this helps,
>
> BAJ

> >The most efficient way is to count in packed BCD.
>
> Generally you are counting a lot and displaying the count only
> occasionally.  So it is more efficient to count in binary and convert for
> display purposes.  If you need to update the display after every count,
> it would make sense to count in BCD.  But if you need to do any math with
> the count, maybe binary would be better.  Of course, it is real simple to
> convert from BCD to binary if necessary.
>
> The PIC has a digit-carry flag which is useful for packed BCD operations.
>  The code below should add 1 to a BCD number.  I don't use BCD much at
> all so it may be wrong.
>
>         movlw   h'67'           ;66 + 1
>         addwf   bcd,f
>         movlw   0               ;assume no correction needed
>         skpdc                   ;Carry out of low digit: it's OK.
>         movlw   h'06'           ; correct the low digit
>         skpc                    ;Carry out of high digit means don't
>         iorlw   h'60'           ; correct the high digit
>         subwf   bcd,f           ;Fix digits that didn't roll
> over
>
> To carry the count into higher digits, look at the carry out of the first
> addition.  If it is set, then the higher digits need to be incremented
> too.  I don't know offhand if the carry out of the subtraction means
> anything useful.