HOW TO EXTRACT DIGITS FROM 16-BIT COUNTER?

HI GENTS,
i'M HAVING ISSUES WITH MY ALGORITHM TO EXTRACT DIGITS FROM 16-BITS COUNTER. I WILL APPRECIATE IF YOU COULD HELP ME FIGURE OUT WHAT IS WRONG WITH IT, OR SUGGEST AN ALTERNATIVE. BASICALLY, I HAVE A DECLARED A 16-BIT COUNTER. COUNTER LOW COUNT FROM 0 TO 255 AND ROLLER OVER AND INCREMENT COUNTER HIGH. I THEN CALLED A SUBROUTINE TO EXTRACT THE RESPECTIVE DIGITS I.E. THOUSANDTH, HUNDREDTH, TENTHS, ONETH. FOR SOME REASONS, THE EXTRACTOR FUNCTION/SUBROUTINE DOES NOT FUNCTION AS EXPECTED. HERE IT'S BELOW. THANK YOU FOR YOUR HELP IN ADVANCE.

;************************************************* ************************************************* 
; SHARED VARIABLES DECLARATION 
;************************************************* ************************************************* 
DIG_SHR_VARS UDATA_SHR 0X20
THOUSANDTH RES 1 ;RESERVE ONE BYTE AT ADDRESS 20
HUNDREDTH RES 1 ;RESERVE ONE BYTE AT ADDRESS 21
TENTH RES 1 ;RESERVE ONE BYTE AT ADDRESS 22
ONETH RES 1 ;RESERVE ONE BYTE AT ADDRESS 23 
COUNTER RES 2 ;RESERVE TWO BYTES ADDRESS 23-24 
;************************************************* ************************************************* 
;EXTRACTING DIGITS FROM 16-BIT COUNTER
;************************************************* *************************************************
DIGIT_FROM_WORD
               MOVF COUNTER + 1,W ;GET HIGHER BYTE
               BTFSS STATUS, Z ;IS THE HIGHER BYTE ZER0?
               GOTO EXTRACT_HUNDTH ;YES, GO TO EXTRACT LOW BYTE 
EXTRACT_THOUDTH ;EXTRACT HIGHER BYTE DIGIT 
               INCF THOUSANDTH,F
               DECF COUNTER + 1,F ;DECREMENT HIGHER BYTE BY 1
               CLRW ;CLEAR WORKING REGISTER
               ADDLW .256 ;ADD 256
               IORWF COUNTER,F
               MOVLW .100
               GOTO CARRY_SET 
               
EXTRACT_HUNDTH
               MOVF COUNTER,W ;GET LOWER BYTE 
               MOVWF TEMP ;SAVE IN TEMP 
               MOVLW .100 
CARRY_SET
               INCF HUNDREDTH ;INCREMENT THE HUNDREDTH 
               SUBWF TEMP,W ;HUNDREDTH - 100 = 0?
               BTFSC STATUS,C ;CARRY CLEARED, SKIP NEXT LINE
               GOTO CARRY_SET ;HUNDREDTH > 100 
               DECF HUNDREDTH,F
               ADDWF TEMP,F 
               MOVF COUNTER+1,F ;CHECK IF COUNTER+1 = 0
               BFTSC STATUS,Z ;IS COUNTER+1 EQUAL TO 0 
               GOTO EXTRACT_THOUDTH ; NO
                                  
EXTRACT_TENTH
               MOVLW .10 
               INCF TENTH ;INCREMENT THE HUNDREDTH 
               SUBWF TEMP,W ;HUNDREDTH - 100 = 0?
               BTFSC STATUS,C ;CARRY CLEARED, SKIP NEXT LINE
               GOTO EXTRACT_TENTH ;HUNDREDTH > 100
               DECF TENTH,F
               ADDWF TEMP,F 
EXTRACT_ONETH
               MOVF TEMP,W
               MOVWF ONETH ;SAVE RESULT IN ONETH REGISTER 
               RETURN
;************************************************* ************************************************* 
MAIN ;INITIALIZE VARIABLES TO ZER0 HERE 
            ;CLRF THOUSANDTH 
            ;CLRF HUNDREDTH
            ;CLRF TENTH 
            ;CLRF ONETH
            ;CLRF COUNTER
            ;CLRF COUNTER+1

FOREVER
             INCF COUNTER,F ;INCREMENT LOW COUNT
             MOVF COUNTER,W
             BTFSC STATUS,Z ;CHECK IF LOW COUNT IS ROLLED OVER TO 0 
             INCF COUNTER+1,F ;YES, INCREMENT HIGHER COUNT 
              
             CALL DIGIT_FROM_WORD ;EXTRACT DIGITS
             ;CALL DISPLAY THOUSANDS
             ;DISPLAY HUNDRETHS
             ;DISPLAY TENTHS
             ;DISPLAY ONETH
             ;CALL DELAY_250MS ;WAIT 250 MILISECONDS
             GOTO FOREVER 
;************************************************* ************************************************* 

There is so many things wrong with OP's routine that I wouldn't ever attend to fix it.  @OP: search for binary to BCD conversion.

ah ah please tell us how

You can cut the execution time down if you write the shift/add loop in assembler.

Oh yes so it is!! I guess i'll have to look at it now to see why it's taking so long.

Hi
 

schmity
125us to execute or extract 16-bit counter to 5-digit on a micro running 20MHz external clock. Since that execution time is unacceptable to me, I'm working currently on using "divide and mod" algorithm to see if I can reduce execution time.
Thanks.

How did you manage to spend 125uS <=> 625 ASM instructions cycles in that?
As for the DIV / MOD algorithm, I guess it will take you a lot more time than the shift-add3.
The digit extraction is a convertion from binary to decimal, as 10 is not a power of 2 the division will allways take a long time.
 
By my experience a DIV/MOD is allways much slower than the SHIT-ADD3.
But I might be missing some math trick, so I'm waiting to see and learn.
 
Best regards
Jorge
 
 
 

Hi,
In this thread, there is a project containing a 16 bit binary to BCD conversion used in preparing values for display. http://www.microchip.com/forums/FindPost/852526 
It is using a "shift and add3" algorithm as found in some old Microchip assembler demo.
As inline assembler in XC8 for PIC16, it use nearly 900 instruction cycles including C function call overhead,
so is no improvement over what schmity have already been using,
but is still much better than C library "utoa(...)" function which have been seen to use between 3300 cycles and 8600 instruction cycles.
 
In the original post in this thread, schmity seem not to try to do general division.
Instead doing repeated subtraction using precalculated constants for powers of 10,
it could be possible to get away with 36 (or maybe 41) subtractions in the worst case,
and less in average.
 
With the following code in C, it has been possible to run a test over all 16 bit values
with average 433 instruction cycles including loop and call overhead.

/*
 * Unsigned Binary to Decimal conversion.
 */
void uBin16_Dec(unsigned char* sptr, unsigned int Arg)
{
    *sptr = 0;
    while (Arg >= 10000)
    {    Arg -= 10000;
       *sptr += 1;
    }
    sptr++;
    *sptr = 0;
    while (Arg >= 1000)
    {    Arg -= 1000;
       *sptr += 1;
    }
    sptr++;
    *sptr = 0;
    while (Arg >= 100)
    {    Arg -= 100;
       *sptr += 1;
    }
    sptr++;
    *sptr = 0;
    while (Arg >= 10)
    {    Arg -= 10;
       *sptr += 1;
    }
    sptr++;
    *sptr = (unsigned char)Arg;
}  

 
Regards,
   Mysil
 
Code edited to correct program bugs.
   Mysil

 
this C code is a variant of double dabble for 31 bit
it can be reduced to 16 bit changing W=0x8000.
I show it as an idea for conversion in assembler.
 

uint32_t double_dabble (uint32_t Fbin) //max 99,999,999
{ uint32_t Fbcd, W=0x40000000;
while (W) {
Fbcd +=(((Fbcd+0x33333333)&0x88888888)>>3)*3; Fbcd<<=1 ;
if (Fbin&W) Fbcd++;
W >>=1 ; }
return Fbcd;
}

GENTS, SORRY I DIDN'T POST THE CODE UTILIZING DOUBLE DABBLE. HERE IT'S.

;*******************************************************************************
; BINARY TO BCD CONVERSION
; IMPLEMENTATION OF DOUBLE DABBLY ALGORITHM
;*******************************************************************************
LCD_CONV_BIN2BCD
              MOVF LCD_POINT,W
              MOVWF LCD_TEMP_LO ;GET LOWER BYTE
              MOVF LCD_POINT + 1, W
              MOVWF LCD_TEMP_HI ;GET LOWER BYTE

              CLRF BCD_LOBYTE ;HOLDS BCD FOR ONES AND TENS
              CLRF BCD_LOBYTE + 1 ;HOLDS BCD FOR HUNDS AND THOUS
              CLRF BCD_TENTS ;HOLDS BCD FOR TEN THOUSANDS
              CLRF BCD_WORKING

             MOVLW D'03'
             MOVWF BCD_BITCNT
BCD_INIT_SHIFT BCF STATUS,C ;CLEAR CARRY BIT
               RLF LCD_TEMP_LO,W
               RLF LCD_TEMP_LO,F ;ROTATE BINARY NUMBER LEFT 3 TIMES
               RLF LCD_TEMP_HI,F ;ROTATE BINARY NUMBER LEFT 3 TIMES
               RLF BCD_LOBYTE,F ;NO, JUST ROTATE LEFT
               DECFSZ BCD_BITCNT ,F ;DECREMENT COUNTER
               GOTO BCD_INIT_SHIFT

               MOVLW D'13'
               MOVWF BCD_BITCNT
               BCF STATUS,C ;RLF LCD_TEMP_LO,W
BCD_CHECK_REM MOVF BCD_LOBYTE,W
               ANDLW H'0F' ;CHECK LOWER NIBLE TO SEE IF GREATER THAN 4
               SUBLW H'04'
               BTFSC STATUS,C
               GOTO BCD_CHECK_TENS
               MOVLW H'03'
               ADDWF BCD_LOBYTE,F ;ADD 3 TO IT IF TRUE
BCD_CHECK_TENS MOVF BCD_LOBYTE,W
               ANDLW H'F0' ;CHECK LOWER NIBLE TO SEE IF GREATER THAN 4
               SUBLW H'40'
               BTFSC STATUS,C
               GOTO BCD_CHCK_HUNDS
               MOVLW H'30' ;ADD 30h TO HIGH BYTE NIBBLE
               ADDWF BCD_LOBYTE,F
BCD_CHCK_HUNDS MOVF BCD_LOBYTE+1,W
               ANDLW H'0F' ;CHECK LOWER NIBLE TO SEE IF GREATER THAN 4
               SUBLW H'04'
               BTFSC STATUS,C
               GOTO BCD_CHCK_THOUS
               MOVLW H'03'
               ADDWF BCD_LOBYTE+1,F ;ADD 3 TO IT IF TRUE
BCD_CHCK_THOUS MOVF BCD_LOBYTE+1,W
               ANDLW H'F0' ;CHECK LOWER NIBLE TO SEE IF GREATER THAN 4
               SUBLW H'40' ;FORMERLY 50h
               BTFSC STATUS,C
               GOTO BCD_CHCK_TENTS
               MOVLW H'30' ;ADD 30h TO HIGH BYTE NIBBLE
               ADDWF BCD_LOBYTE + 1,F
BCD_CHCK_TENTS MOVF BCD_TENTS,W
               ANDLW H'0F' ;CHECK LOWER NIBLE TO SEE IF GREATER THAN 4
               SUBLW H'04'
               BTFSC STATUS,C
               GOTO BCD_SHIFT_BITS ;CARRY IS SET, ROTATE REGISTERS THROUGH CARRY BIT
               MOVLW H'03'
               ADDWF BCD_TENTS,F ;ADD 3 TO IT IF TRUE
BCD_SHIFT_BITS RLF LCD_TEMP_LO,F ;ROTATE TEMP LOW REMAINING BIT INTO CARRY BIT AND CHECK IT'S ONE
               RLF LCD_TEMP_HI,F ;ROTATE TEMP LOW REMAINING BIT INTO CARRY BIT AND CHECK IT'S ONE
               RLF BCD_LOBYTE,F
               RLF BCD_LOBYTE + 1,F
               RLF BCD_TENTS,F
BCD_CHECK_CNTS DECFSZ BCD_BITCNT,F ;DECREMENT COUNTER
               GOTO BCD_CHECK_REM
               MOVF BCD_LOBYTE,W
               ANDLW H'0F' ;GRAB LOWER NIBBLE
               ADDLW H'30' ;CONVERT TO ASCII
               MOVWF LCD_ONES ;SAVE IN LCD_ONES REG
               ;CLRW
               SWAPF BCD_LOBYTE,W ;GRAB THE HIGHER NIBBLE
               ANDLW H'0F' ;EXTRACT THE NIBBLE
               ADDLW H'30' ;CONVERT TO ASCII
               MOVWF LCD_TENS ;SAVE IN TENS REG
               MOVF BCD_LOBYTE + 1,W ;GRAB HIGHER BYTE LOWER NIBBLE
               ANDLW H'0F' ;EXTRACT THE LOWER NIBBLE
               ADDLW H'30' ;CONVERT TO ASCII
               MOVWF LCD_HUNDS ;SAVE IN HUNDS REG
               ;CLRW
               SWAPF BCD_LOBYTE + 1,W ;GRAB HIGHER BTYE HIGHER NIBBLE AND CONVERT O LOWER NIBBLE
               ANDLW H'0F' ;EXTRACT LOWER NIBBLE
               ADDLW H'30' ;CONVERT TO ASCII
               MOVWF LCD_THOUS ;SAVE IN THOUS REG
               MOVF BCD_TENTS,W ;GET TENS LOWER NIBBLE
               ANDLW H'0F' ;EXTRACT THE LOWER NIBBLE
               ADDLW H'30' ;CONVERT TO ASCII
               MOVWF LCD_TENTS ;SAVE IN TENTS REG
      RETURN
;*******************************************************************************

Hi
 
Wow, I'm saving this one for future reference.
Somehow this algorithm makes me remember the DAA (decimal adjust accumulator) of the Intel80xx range of processors.
 
As a matter of fact is the first time I heard (see) the term "Double Dabble".
I've been using this algorithm, under the name of "SHIFT/ADD3" since around 1981, when I was at the University learning i8085 ASM on an Intel SDK-85.
 
I think that using integer division by 10 will take more time since we need to run a 16bit by 8bit division at least 4 times, to extract the 5 digits.
Or am I missing something here?
 
 
Best regards
Jorge