Newsgroup: it.hobby.elettronica.digitale
Titolo: Aggiustamento bin/BCD su conversione A/D del PIC16F876

Salve a tutti
Il progetto di Futura Elettronica prevede l'aggiustamento decimale sulla
conversione A/D a 8 bit perchč utilizza solo gli 8 bit piů significativi.
A me serve tutta la conversione, quindi 10 bit che equivale a 1024
combinazioni.
Qualcuno conosce una routine per convertire il il numero 1024 contenuto in
due registri HByte e LByte in quattro cifre BCD.
Greazie per eventuali aiuti.
Cordiali saluti,
Alessandro Gregori

 ha scritto nel
messaggio news:8vdcgc$42k$1...@lacerta.tiscalinet.it...


 due registri HByte e LByte in quattro cifre BCD.
L'ho usata in un frequenzimetro fatto da me... ho preso quella scritta 
dalla microchip e l'ho espansa x lavorare a 24 bit... non capisco come 
faccia ma... funziona! :-)))
Come vedi ridurla x lavorare a 10 bit e' semplicissimo.
;B2_BCD		Converte il numero binario contenuto in TMR, in BCD
B2_BCD		bcf	STATUS,0		;clear the carry bit
		movlw	24
		movwf	b2bcount
		clrf	R0
		clrf	R1
		clrf	R2
		clrf	R3
loop16		rlf	TMR, F
		rlf	TMR+1, F
		rlf	TMR+2, F
		rlf	R3, F
		rlf	R2, F
		rlf	R1, F
		rlf	R0, F
		decfsz	b2bcount, F
		goto	adjDEC
		clrf	FSR
		RETLW	0
adjDEC		movlw	R3
		movwf	FSR
		call	adjBCD
		movlw	R2
		movwf	FSR
		call	adjBCD
		movlw	R1
		movwf	FSR
		call	adjBCD
		movlw	R0
		movwf	FSR
		call	adjBCD
		goto	loop16
adjBCD		movlw	3
		addwf	0,W
		movwf	b2btemp
		btfsc	b2btemp,3		;test if result > 7
		movwf	0
		movlw	0x30
		addwf	0,W
		movwf	b2btemp
		btfsc	b2btemp,7		;test if result > 7
		movwf	0 		;save as MSD
		RETLW	0
---
                              /"\              
  _/                          \ /
 _/   _/_/ _/_/ _/_/           X  ASCII RIBBON CAMPAIGN      
_/_/ _/_/ _/   _/_/           / \ AGAINST HTML MAIL
Lorenzo Raschi
Togliere #NOSPAM# dall'indirizzo email per rispondermi
ICQ #48357220
Per favore non utilizzate ne' tag html ne' accentate. Grazie.

faccia ma... funziona! :-)))
--------------------------------------------------
A simple algorithm to convert binary to BCD is:
1. Add 3 to every BCD nibble that's >=5
2. Shift left
Repeat n times where n is the number of bits.
(here n=8)
Example:  Convert $F9 to BCD
                    F    9
0000 0000 0000 : 1111 1001
0000 0000 0001 : 1111 0010  (shift left)
0000 0000 0011 : 1110 0100  (shift left)
0000 0000 0111 : 1100 1000  (shift left)
0000 0000 1010 : 1100 1000  (add 3)
0000 0001 0101 : 1001 0000  (shift left)
0000 0001 1000 : 1001 0000  (add 3)
0000 0011 0001 : 0010 0000  (shift left)
0000 0110 0010 : 0100 0000  (shift left)
0000 1001 0010 : 0100 0000  (add 3)
0001 0010 0100 : 1000 0000  (shift left)
0010 0100 1001 : 0000 0000  (shift left)
   2    4    9
And the left now holds BCD 249.
--------------------------------------------
allora, ho gia' postato questa soluzione, ed il tuo programma
praticamente la implementa, anche se forse si potrebbe fare con meno
istruzioni.
A destra dei : c'e' il numero binario (qui un solo byte per
semplicita') a sinistra dei : "cresce" il numero BCD. In pratica l'
algoritmo calcola in "BCD" il peso di ciascun bit del numero binario a
destra, cioe' l' ottavo bit "pesa" 128, il settimo "pesa" 64 ecc
ecc... 
In pratica nei 3 nibble alla sinistra attuiamo una moltiplicazione per
2 sommando il riporto dal nibble vicino (quello immediatamente a
destra) ovvero nelle 3 cifre BCD a sinistra facciamo uno shift con
"aggiustamento decimale", nel byte a sinistra facciamo un normale
shift binario. 
(Il trucco di sommare 3 ad ogni nibble >=5 serve a fare un
"aggiustamento decimale"  cioe' genera un riporto al nibble successivo
quando, al successivo shift, il risultato dovesse essere >=10).
Se convertissimo 128 (cioe' 10000000 b) l' "uno" in testa sarebbe
shiftato al primo colpo, e poi nei successivi sette cicli lo
moltiplicheremmo per due 7 volte, 2^7=128, che risultera' espresso in
BCD, avendo applicato tutte le volte l'"aggiustamento decimale".
Capito l' esempio non e' difficile immaginare cosa succede se il
numero fosse diverso: il sesto bit "esce" un ciclo dopo, quindi e'
moltiplicato per 2^6=64, il quinto per 2^5=32 ecc ecc, fino al bit
meno significativo che e' semplicemente sommato al risultato BCD.
La routine si puo' ampliare a piacere, basta aumentare sia il numero
dei bit che il numero di loop.

(here n=8)
Questo algoritmo si chiama SOMMA3 (almeno l'ho
sempre visto chiamare cosi'), e' molto elegante e
facilmente espandibile. L'ho usato anch'io su tutti i
micro con con cui ho lavorato.
Pero' per convertire numeri binari corti, puo' essere
piu' efficente il metodo, molto piu' grezzo, delle divisioni
con sottrazioni ripetute.
Per esempio, per convertire un numero di 13 bit,
si sottrae 0x3E8 (=mille decimale) dal numero binario
per tante volte finche' e' possibile. Poi si ripete lo stesso
procedimento con 0x64 (cento) e 0xA (dieci). I numeri
delle iterazioni di ogni ciclo di sottrazioni saranno le
varie cifre decimali. Ovviamente la cifra delle unita'
e' cio' che resta dopo il ciclo delle sottrazioni del dieci
e non necessita di essere convertita.
Luigi