hex til dec

Davs Søren.

De kunne evt. lave en trabvel med værdien for hver bit. og lade PIC kredsen finde ud af om hvilke bit der er aktive og derved lægge dem sammen. Men det kommer jo an på hvordan Deres resultat skulle se ud. Men det er en idé. og ret simple at programmere.

Med venlig hilsen Thias Russell

"Søren" skrev i en meddelelse news:XGfOa.3776$ snipped-for-privacy@news.getnet.dk...

konverterer

Jeg er ikke helt klar over om det er denne metode du nævner som den anden du kender, men her er den alligevel.

const unsigned short digitWeight[] = {1,10,100,1000,10000}; unsigned char currentDigit; unsigned short value = 46527; unsigned char digit = 5;

for(digit = 5;digit > 0;digit--) { currentDigit = 0; while(digitWeight[digit-1] >= value) { value = value - digitWeight[digit]; currentDigit++; } }

Ovenstående er blot et eksempel i C, på hvordan det kan gøres.

/Thomas

Søren skrev:

Man kan højest aflæse 3-5 værdier i sekundet, så det er begrænset hvor meget regnekraft du skal bruge.

Ivar

HKJ mener sikkert noget i denne stil. konverterer et 16 bit tal til 4 bcd cifre. det bliver brugt i en frekvenstæller (pic16f84)

;********************************************************************** tmr0low EQU 0x0E ; timer 0 low byte (used for conversion) tmr0high EQU 0x0F ; timer 0 high byte (used for conversion)

digit1000 EQU 0x10 ; digit 1 (1000's) digit100 EQU 0x11 ; digit 2 (100's) digit10 EQU 0x12 ; digit 3 (10's) digit1 EQU 0x13 ; digit 4 (1's)

divlow EQU 0x14 ; used for 16bit calculating divhigh EQU 0x15 ; used for 16bit calculating

;********************************************************************** add16 ; add a 16 bit value divhigh,divlow movf divlow, w ; to tmr0high,tmr0low addwf tmr0low, f ; movf divhigh, w ; btfsc STATUS, C ; incfsz divhigh, W ; addwf tmr0high, f ; Carry Set on overflow return ; ;********************************************************************** sub16 ; subtract a 16 bit value divhigh,divlow movf divlow, w ; from tmr0high,tmr0low subwf tmr0low, f ; movf divhigh, w ; btfss STATUS, C ; incfsz divhigh, W ; subwf tmr0high, f ; Carry Clear on overflow return ; ;********************************************************************** bin2bcd ; converts 16bit number to 4 bcd values clrf digit1000 ; init digits clrf digit100 ; clrf digit10 ; clrf digit1 ;

movlw 0x03 ; 1000's movwf divhigh ; movlw 0xE8 ; movwf divlow ; conv1000 call sub16 ; btfsc STATUS, C ; incf digit1000, f ; btfsc STATUS, C ; goto conv1000 ; call add16 ;

movlw 0x00 ; 100's movwf divhigh ; movlw 0x64 ; movwf divlow ; conv100 call sub16 ; btfsc STATUS, C ; incf digit100, f ; btfsc STATUS, C ; goto conv100 ; call add16 ;

movlw 0x00 ; 10's movwf divhigh ; movlw 0x0A ; movwf divlow ; conv10 call sub16 ; btfsc STATUS, C ; incf digit10, f ; btfsc STATUS, C ; goto conv10 ; call add16 ;

conv1 movf tmr0low, W ; 1's movwf digit1 ;

return ;**********************************************************************

det ser pænere ud i MPLAB. jeg har ikke regnet på tiden, men den er også afhængig af værdien på det binære tal.

- patrick

Jeps, men jeg ville ikke prøve at formulere det i PIC assembler.

Nogen grund til at bruge sub16 her?

hvis du siger at det skal gå hurtigt, hvorfor så ikke bruge assembler?

nemmere/dovenskab - denne del af koden er ikke tidskrittisk.

- patrick

Jeg har ikke modsat mig assembler, jeg skriver bare ikke i PIC assembler og jeg tror ikke min tilsvarende routine i AVR assembler ville være et godt eksempel, når der spørges efter routiner til PIC. Pseudo koden er noget lettere at læse end en ukendt assembler.

mange tak for hjælpen, jeg fandt en metode en hvor man divider med 10000,