AVR Freaks

I would do (have done!) the BCD to 7-segment display conversion with a lookup table inside the AVR.

e.g.:

7SEG_LOOKUP:

.db 0b01110111   ; 0

.db 0b00010001   ; 1

.db 0b00111110   ; 2

(and so on)

Of course, the various bit patterns depend upon your displays and how they're wired up.  To access, just use:

ldi ZL, low(2*7SEG_LOOKUP)

ldi ZH, high(2*7SEG_LOOKUP)

add ZL, bcd_digit                           ; Where bcd_digit is a register containing the value (in BCD) you would like to display

adc ZH, zero                                  ; and 'zero' is a register containing the value $00

ldi temp, Z                                     ; and 'temp' is a high-side (16-31) register that you don't mind frying

out PORTB, temp                           ; and PORTB is where your LED display(s) are wired up to.

e.g.:

7SEG_LOOKUP:

.db 0b01110111   ; 0

.db 0b00010001   ; 1

.db 0b00111110   ; 2

(and so on)

Of course, the various bit patterns depend upon your displays and how they're wired up.  To access, just use:

ldi ZL, low(2*7SEG_LOOKUP)

ldi ZH, high(2*7SEG_LOOKUP)

add ZL, bcd_digit                           ; Where bcd_digit is a register containing the value (in BCD) you would like to display

adc ZH, zero                                  ; and 'zero' is a register containing the value $00

lpm temp, Z                                     ; and 'temp' is a high-side (16-31) register that you don't mind frying

out PORTB, temp                           ; and PORTB is where your LED display(s) are wired up to.

&c.

S.

PS - Yes, I know there's a code window.  Yes, I know how to click on the relevant icon.  I also know that it does not work here, so kwitcher bitchin' until the site admins fix it.  S.

Edited to remove spurious $, make it an lpm temp, and thank JS.  S,

I also know that it does not work here

JS 

This is a bit confusing.   That link is to an included tech note that was in the folder.    I see I forgot to change one of the register labels into the DAA code, which could lead to some other confusion.  I edited my post for future reference.

I have not take the time to look at the OP's code in detail.   This should be some fairly straightforward shifts and multiplies in the nybbles.   Three digits of BCD will take 2 bytes,  2 bytes of BCD take 1 byte.   If there are more than 2 digits then the 3rd digit carries into the next nybble.   So there will always be an nybble that is zero unless there is an overflow.  I would think that be the end of sequence flag.

On the other hand if leading or trailing zero suppression is required, then one is basically writing a printf function,  Which then starts detailing the itoa function.   This can be a simple table lookup that divides the digits by 1,10,100 as was done in the code of the late 1970s.  Advantage is this can work in any base.    Here is one that I converted from 68K assembly to AVR.  (the 68k opcodes are commented out) 

;********************
;*	 DCVT	    *
;********************
;Decimal and octal conversion subroutines
;D1 contains the input value
;A2 indexes the output result area
;D6 contains the control word as follows:
;
;      Bits 0-7 contains the fixed length number of characters
;      Bit  8 - set to suppress leading zeros if fixed length
;      Bit  9 - set for terminal output (else uses A2)
;      Bit 10 -
;      Bit 11 - set for byte size in D1
;      Bit 12 - set for word size in D1
;      Bit 13 -
;      Bit 14 - set for octal output
;      Bit 15 - set for hex output
;
;Registers modified are none unless A2 is used

DCVT:
;	SAVE	D0,D1,D3,D4,A1		; save registers
;	MOV	D6,D0			; control word to D0
	mov ARGL,D6_TMPL
	mov ARGH,D6_TMPH
	
;Set table index A1 for decimal, octal or hex output
;	LEA	A1,HCTBL		; set hex table index
	ldi ZL,low(HCTBL*2)
	ldi ZH,high(HCTBL*2)

;	TSTW	D0			; is it hex?
	tst ARGH
;	BMI	10$			;   yes
	brmi DCVT_10
	
;	LEA	A1,OCTBL		; set octal table index
	ldi ZL,low(OCTBL*2)
	ldi ZH,high(OCTBL*2)

;	BTST	#14.,D0			; is it octal?
;	BNE	10$			;   yes
	sbrc ARGH,6
	rjmp DCVT_10
	
;	LEA	A1,DCTBL		; set decimal table index
	ldi ZL,low(DCTBL*2)
	ldi ZH,high(DCTBL*2)

;Put the table size into D4
DCVT_10:
;	MOV	(A1)+,D4		; pick up table size
	mov A1_TMPL,ZL
	mov A1_TMPH,ZH
	lpm
	adiw ZL,2
	mov idx,r0

;Set the input data into D3 and strip to word or byte as required
;	MOV	D1,D3			; get binary input
	; avr D1 = ACC,BCC,XL,XH is parameter
;	BTST	#11.,D0			; byte size data?
;	BEQ	15$			;   no
	sbrs ARGH,3
	rjmp DCVT_15
;	AND	#377,D3			; strip to byte data
	clr BCC
	clr XL
	clr XH

DCVT_15:
;	BTST	#12.,D0			; word size data?
;	BEQ	DCND			;   no
	sbrs ARGH,4
	rjmp DCND
;	AND	#177777,D3		; strip to word data
	clr XL
	clr XH

;Calculate value of next digit
DCND:	
	;CLR	D1			; preclear result
	clr D7_TMPL			; avr shadow D1 in r12-15

	lpm
	adiw ZL,1
	mov A6_TMPL,r0		; avr shadow internal to A6
	lpm
	adiw ZL,1
	mov A6_TMPH,r0
	lpm
	adiw ZL,1
	mov A6_Page,r0
	lpm
	adiw ZL,1
	mov A4_Page,r0
DCND_10:
;	CMP	D3,@A1			; compare to table value
	cp ACC,A6_TMPL
	cpc BCC,A6_TMPH
	cpc XL,A6_Page
	cpc XH,A4_Page

;	BLO	DCCZ
	brlo DCCZ

;	INCW	D1
	inc D7_TMPL

;	SUB	@A1,D3
	sub ACC,A6_TMPL
	sbc BCC,A6_TMPH
	sbc XL,A6_Page
	sbc XH,A4_Page

;	BR	10$
	rjmp DCND_10
	
;Check for digit of zero
DCCZ:	
;	TSTW	D1			; zero?
;	BNE	DCNZ			; nope
	cp D7_TMPL,zero
	brne DCNZ

;Digit is zero - check for zero suppress unless units digit
;Bypass if variable length in progress
;	CMP	D4,#1			; units digit?
;	BEQ	DCNZ			; yes - no suppress
	cpi idx,1
	breq DCNZ

;	TSTB	D0			; check for variable length
;	BEQ	DCDD
	tst ARGL
	breq DCDD

;	BTST	#8.,D0			; test control bit 0
;	BEQ	DCNZ			; no suppress if off
	sbrs ARGH,0
	rjmp DCNZ

;	MOV	#40,D1			; set space
	ldi c_tmp,32
	mov D7_TMPL,c_tmp
;	BR	DCRO
	rjmp DCRO

;Digit is not zero or it is zero in units position
;Make it ASCII and reset zero suppress bit
DCNZ:
;	CMPW	D1,#9.			; decimal digit?
	ldi c_tmp,9
	cp D7_TMPL,c_tmp
;	BLOS	10$			;   yes
	breq DCNZ_10
	brlt DCNZ_10

;	ADDW	#7,D1			; adjust for hex A-F
	ldi c_tmp,7
	add D7_TMPL,c_tmp

DCNZ_10:	
	;ADDW	#60,D1			; make ASCII for output
	ldi c_tmp,48
	add D7_TMPL,c_tmp

;	ANDW	#177377,D0		; reset zero suppress bit
	andi ARGH,0xFE

;Check for variable length output
;A digit has been detected so reset length if variable
;	TSTB	D0			; variable output length?
;	BNE	DCRO			; nope
	tst ARGL
	brne DCRO
;	OR	D4,D0			; reset for fixed length
	mov idx,ARGL

;Ready for output - bypass if fixed length is less
DCRO:	
;	CMPB	D0,D4			; check fixed length
;	BLO	DCDD			; bypass output if less
	cp ARGL,idx
	brlo DCDD

;	BTST	#9.,D0			; terminal output?
;	BEQ	10$			;   no - use A2
	SBRC ARGH,1
	rjmp DCRO_10
	mov D6_TMPL,D7_TMPL
	rcall TOTCHR	;D1			; output to terminal
	;BR	DCDD
	rjmp DCDD
	
DCRO_10:
;	MOVB	D1,(A2)+		; output the digit
	st Y+,D7_TMPL

;Digit done - check for all digits processed
DCDD:	
;	ADD	#4,A1			; bump table index
;	ldi c_tmp,4
;	add A1_TMPL,c_tmp
;	add A1_TMPH,zero
;	adiw ZL,4
	
;	DEC	D4			; decrement digit count
	dec idx
;	BNE	DCND			; loop if not last digit
	brne DCND
	
;End of processing - restore registers and exit
;	REST	D0,D1,D3,D4,A1	 	; restore registers
;	RTE
	ret

;Table for decimal conversion
DCTBL:	.dw	10
	.dd	1000000000
	.dd	100000000
	.dd	10000000
	.dd	1000000
	.dd	100000
	.dd	10000
	.dd	1000
	.dd	100
	.dd	10
	.dd	1

;Table for octal conversion
OCTBL:	.dw	11
	.dd	1073741824
	.dd	134217728
	.dd	16777216
	.dd	2097152
	.dd	262144
	.dd	32768
	.dd	4096
	.dd	512
	.dd	64
	.dd	8
	.dd	1

;Table for hex conversion
HCTBL:	.dw	8
	.dd		0x10000000
	.dd		0x1000000
	.dd		0x100000
	.dd		0x10000
	.dd		0x1000
	.dd		0x100
	.dd		0x10
	.dd		0x1	

Why are you worried about execution time? The function will be called less than 100 times per second, so any potential savings won’t amount to much. Rule #1 get the code working first. Then think about optimising.

The code I gave in #17 will do the job in less than 100 clk.

The code at the end of my link will do a full 16 -> 5 digit in max 68 clk and if you remove the code for finding the first digit it's about 40 clk.

And as a say in #11 if it only 3 digit in can be done in about 25-30 clk for an optimal routine.

All this is without formatting!

How do you want to show 8?

008  no formating

__8 (_ indicate off)

_8_ centered

8__ looks best if at the end of a text

So that mean that you will show 8  as 008 (most people prefer not to show the two zeros ) 

I think Nietzsche is dead so God probably does not care what the comments are.

In post #22 I gave code that does base conversion which only uses subtractions from a table.   Does not get much simpler than that.  Sure the code looks a bit long, becouse it is for two different ASM mnuemonics and has comments that explain it.   This is a general purpose function.  You can distill out only the parts needed.   The table and the subtraction.  I could have pulled the function from the basic interpreter which is basically the same thing.

If you really are concerned about cycles and not code space you can do an unrolled loop.  This is no calls or returns or indexes.   You count each instruction and branch.  Then you need to figure out if skip or branch instructions is better for the compares.   In an unrolled loop if you are only interested in 3 digits, you have 10 subtracts by 100, then 10 subtracts by 10 and 10 subtracts by 1.  Count the subtracts, Exit is on underflow past zero (negative) to the next digit.  The worse case is the number 9 9 9 the best case is 0 0 0.  The resulting numbers will be in the index (counter) registers for each digit.  There is a lot of old process control code for 8080, Z80, 8051, that uses this method. 

Software divide is better for library systems and CISC processes that have hardware divisions when implementing printf(). This uses a lot of abstraction layers, to keep the code universal across platforms and languages.  There might be ways of working with fixed point divisions, which are academic, 0x1/0xA is a repeating fraction, otherwise this would be a more popular method.  This leaves subtraction loops (like the ASM200 tech note) or subdivision such as the DAA function which subdivides into compare to 10 and subtraction (inverse) addition of 6. since 10x6 = 16.

but 432 is bigger than a byte! so no easy DIV way on a 8 bitter ! (first line of #33)

ok it was rain so I had some time to look at it.

First some code based on the code in #17

;max 92 clk
        movw    r24,r16 ; only needed if to save org.
        ldi     r20, -1 
L0:     inc     r20
        subi    r24, low(100)           ;-100
        sbci    r25, high(100)
        brcc    L0
        ldi     r19, 10 
L1:     dec     r19
        subi    r24, -10                ;+10
        brcs    L1
	mov     r18,r24 ; only needed if number in order

an optimized version

;max 53 clk
        movw    r24,r16 ; only needed if to save org.
        ldi     r20, 0 
L0:     subi    r20, -4
        subi    r24, low(400)           ;-400
        sbci    r25, high(400)
        brcc    L0
L0a:	dec	r20
        subi    r24, low(-100)           ;+100
        sbci    r25, high(-100)
	brcs	L0a
        ldi     r19, 0 
L1:     subi    r19, -4
        subi    r24, 40                ;-40
        brcc    L1
L1a:	dec     r19
    	subi	r24,-10			;+10
	brcs	L1a

	mov     r18,r24 ; only needed if number in order

And then a faster using HW mul

;max 31 clk
					;input 0-999 in r17:r16 out r22:r21:r20
	movw		r24,r16		;copy number
	add		r24,r24		;*2
	adc		r25,r25
	sbrc		r25,2		;if number >=512 guess one higher
	inc		r25
	mov		r22,r25		;first 100 digit guess
	inc		r25		;add one so guess can be to high
	ldi		r18,100
	mul		r18,r25		;r1:r0 == 0 100 200 300 500 600 700 or 800
	movw	        r24,r16		;get a new copy
	sub		r24,r0		;sub 0 100 200 300 500 600 700 or 800 from number
	sbc		r25,r1
	brcs	        L0  		;if negativ done with 100
	sub		r24,r18		;else sub 100 and inc guess
	inc		r22
	brcs	        L0	    	;if negativ done with 100
	sub		r24,r18		;else sub 100 and inc guess
	inc		r22
					;now correct 100 digit
L0:	add		r24,r18		;make reminder back to 0-99
	ldi		r18,26		;divide with 10 by mul with 26/256 
	mul		r24,r18
	movw	        r20,r0
	sbrs	        r24,6		;if >=64 sub 20 (mul 26 is a tad to big)
	rjmp	        L1
	subi	        r20,20
	sbci	        r21,0
					;now correct 10 digit
L1:	ldi		r18,10		;mul reminder with 10
	mul		r20,r18
	mov		r20,r1		;now last digit correct

I'm sure it can be done faster but I think it's hard to cut of 5 clk (with code, not a problem with a LUT)

And yes this is like a crossword for me. I know it's not needed for OP

Here is an algorithm I use, I'll illustrate in C so it's easier to understand. In this case it's packed BCD because I'm having trouble wrestling the compiler to make it work with 32 bit ints.

But I just want to show the algorithm.

#include <stdio.h>
#include <stdint.h>
uint16_t bin2bcd (uint16_t);

int main (void) {
        for (uint16_t i = 0, bcd; i <= 999; i++) {
                bcd = bin2bcd(i);
                printf("0x%03x \n", bcd);
        }
}

#define BASE 10
#define MAGIC 41				/* 41 = BASE*4096/1000 rounded up; 4096 = 3 nibbles; 1000 = numbers in the 0-999 range */
uint16_t bin2bcd (uint16_t bin) {
        uint16_t bcd;
        bin *= MAGIC;
        bcd = (bin & 0xF000) >> 4;		/* store 100s digit */
        bin &= 0x0FFF;				/* mask only remainder nibbles */
        bin *= BASE;				/* get 10s digit in most significant nibble */
        bcd |= (bin & 0xF000) >> 8;		/* store 10s digit */
        bin &= 0x0FFF;				/* mask only remainder nibbles */
        bin *= BASE;		        	/* get 1s digit in most significant nibble */
        bcd |= (bin & 0xF000) >> 12;		/* store 1s digit */
        return bcd;
}

You can paste this in an online compiler like https://www.onlinegdb.com/online... to see the output.

Yeah, it's somewhat slower than your method. The advantage is that it executes in constant time, that's useful sometimes.

Nice

first which format is the output you want? (bin or BCD)

but I guess just take El Tangas's solution that is somewhere here that make 16 bit to BCD in 45-48 (I can't remember) and use the formula, and then make the adjustment.    

I think you mean this thread: https://www.avrfreaks.net/commen...

If you happen to have $F0 lying around in a register, 'and' and 'swap' is faster than four right-shifts.  S.

but you asked for 16 bit ?!

first the 16x16 you only "save" the high byte because 54429 is 8 times bigger than wanted so the reminder is placed in 3 bytes.(but you save)

But if you MUL the 3 bytes with 20 (not 10) the result will have a shift of 4th bit and then the reminder should be placed correct (perhaps some of the top bits needs to be and'ed off).

And perhaps the value at the lowest byte is so small that it isn't needed.

but there is an other "real" problem what about 65535! a correct rounding will give 0 it 16bit !!!  

And it could be faster with a more sloppy value of 1/10  (perhaps the reminder have to be found as x-(1/10x*10) )

I don't think AVR Studio will let you do that.  Even if it did, it would do horrible things to the label listing(s).  Yeah, the alternative isn't much fun either, labels with suffixes of 'aaa' and 'bbb' get to be par for the course, but at least they're unique.  S.

nice work a thing to remember

I checked it with this code: (for all combinations )

	MOVW  r24, r16
	SBRC  r25, 7
	SUBI  r25, 100 ; no carry
	SBRC  r25, 0
	SUBI  r25, -5 ; no carry
	ADD   r24, r25
	BRCC  L0
	SUBI  r24, -6  ; no carry
L0:
	LDI   r25, 26
	MUL   r24, r25
	LDI   r25, 10
	MUL   R1, r25
	SUB   r24, R0
	BRCC  L1
	SUBI  r24, -10
L1: ; SL=sou:rce % 10  R1=0

Do you have an assembler that "eat" 1f ?

I always wanted to make one where + was 1f and ++ 2f etc.

UPS I see I'm late with this

Add:

And perhaps this is one for the compiler it make a mul with 0xCCCD from a lib and then some shifts.(a lot of shifts because it also solve the /)

That's very clever code. I had already tried to use 26 as "magic number", since it aligns the result to 8 bits (shift not needed). But some numbers were generating rounding errors:

uint8_t reduce (uint16_t);
uint8_t units (uint8_t);

int main()
{
    for (uint16_t i = 0; i < 65535; i++) {
        if ((i%10) != units(reduce(i))){
            printf("%d %d \n", i, units(reduce(i)));
        }
    }
}

uint8_t units (uint8_t reduced){
    reduced = (reduced * 26) & 0xFF;
    reduced = (reduced * 10) >> 8;
    return reduced;
}

uint8_t reduce (uint16_t bin) {
    uint8_t h_sign = (bin >> 8) & 0x01;		/* save sign of high bit for later */
    bin = (bin >> 8) + (bin & 0xFF);		/* reduction round 1 */
    bin = (bin & 0x1F) + ((bin >> 4) & 0x1E);	/* reduction round 2 */
    bin += h_sign ? 5 : 0;			/* if h was odd, add 5 to correct */
    return bin;
}

 Output of errors is:

57854 5
58364 5
58874 5
59384 5
59894 5
60404 5
60914 5
61424 5
61934 5
62444 5
62954 5
63464 5
63974 5
64484 5
64994 5
65504 5
65534 5

These are all large numbers. So by subtracting 100 to numbers with the high bit set, this problem is solved (I would probably subtract 120, which is the largest multiple of 10 smaller than 128).

Very nice code indeed.

Ah, I see it, in this part:

	sbrs	        r24,6
	rjmp	        L0
	subi            r20,20
	sbci	        r21,0

Yeah, it's the same thing

I also used the "adjustment technique" many years ago for a x86 algo: https://board.flatassembler.net/...

It allowed me to save one "mul" compared to the base code. But mul is usually more expensive in x86 CPUs than in AVR (naturally, since it's 32/64 bit), sot it is usually worthwhile to get rid of them, in AVR not so much.

what does the code state !

17 cycles will do for 16-bit mod 10: