Microchipi ujupunkti teisendamine

[andreie]

Vs: Microchipi ujupunkti teisendamine

Keeles "C":

sprintf(buffer, "%4.2f", ujukomaarv);

Pseudoassembleris analoogne näidis (cdecl calling convention):

buffer:         bytes(80)
ujukomaarv:  bytes(4)
formaat:      "%4.2f"
       push ujukomaarv[3]
       push ujukomaarv[2]
       push ujukomaarv[1]
       push ujukomaarv[0]
       push formaat
       push buffer
       call sprintf
       add stack_pointer, tambov

Äkki aitab edasi. Ma olen ka üritan mikrokontrollerite peal ujukoma vältida, aga kui mõnikord on palju lihtsam ja proseauru on, siis miks mitte.

[A.R.]

Vs: Microchipi ujupunkti teisendamine

Aga kui alustaks lõpust!

Mida indikaator näitab kui tulems on näiteks 10,1?
Kas 1 0, 1 0 0 või 0 0 0 1 0?
Seega, mitu kohta on Su indikaatoril ja kas punkti kasutad või ei?

Mis vahemikus see tulemus seal on?

Kui pikk sul koma on, mitu baiti?
4x8? 2x16? 6x8? 7X8?
Mantiss on 8?

Kas alamprogrammid on olemas?
Võrdlus, lahutamine?
Konstandid: 10, 100, 1000, 10000?

Üks tuhat üksteist võib rohkem küsida kui sada tarka vastata.
Ütleb vana sõna

[felch]

Vs: Microchipi ujupunkti teisendamine

Aga kui alustaks lõpust!

Mida indikaator näitab kui tulems on näiteks 10,1?
Kas 1 0, 1 0 0 või 0 0 0 1 0?
Seega, mitu kohta on Su indikaatoril ja kas punkti kasutad või ei?

Saan esitada mõistliku arvu kohti. Mõistlik selle järgi, mida mõõdan. Veetaset üle 1 koma ei tasu esitada (ja andur ei anna ka). Vooluhulka (vesi) võiks kuvada 2 kohaga peale koma sest mõõdan tegelikult perioodi ja sealt arvutan. Mõni teine arvutatud parameeter tahaks ehk samuti 2 kohta.
Mõte oli, et otsiksin konverteeritd tulemusest koma ja siis selle ning suuruse olemuse järgi valiks, kuidas kuvada. Praegu aga pean ette aimama kuhu koma panna ja kuidas kuvada. Saab ka nii aga oleks ju mugavam kasutada universaalset teisenduse algoritmi.

[A.R.]

Vs: Microchipi ujupunkti teisendamine

Saan esitada mõistliku arvu kohti. Mõistlik .....
Mõte oli, et otsiksin konverteeritd tulemusest koma ja siis selle ning suuruse olemuse järgi valiks, kuidas kuvada. Praegu aga pean ette aimama kuhu koma panna ja kuidas kuvada.

Ära aima. Koma on liikuvas komas täpselt esimese biti taga.
Arv on 1,xxxxxxx

Nüüd oligi see esimene küsimus et kui suur see arv võib olla maximaalselt.
Ei hakka ju iga uue arvu korral uut displayd ehitama. Või kuidas?

Kui täisosa kuni 256 siis lükkame selle 1.
esimese baidi paremasse otsa (arestades mantissi)
kui max on 65536 siis las ta minna 2. baidi paremasse otsa
Ja meil on üks või kaks baiti selle arvu TÄISOSA täisarvuna.
Teisendame BCD ja esitame. Viimasele punkt juurde.

Lahutame algusearvst täisosa, saame komakohad.
Palju neid vaja on?
2, korrutame 100-ga ja teeme sama mis enne.
3. korrutame 1000-ga ja ....

Aga mis ma ikka lobisen, vaata:

http://www.atarimagazines.com/compute/issue9/020_1_A_BCD_TO_FLOATING-POINT_BINARY_ROUTINE.php

Seal lõpus, suurte tähtedega.
Skeem ja puha.

Kas see pole see?

if(see==0) then "floating point to BCD"
Sulgudega 7, ilma 53600 vastust.

[felch]

Vs: Microchipi ujupunkti teisendamine

Tänud heade soovituste eest. Nende põhjal kirjutasin säärase teisendaja:

; *************************************************************************************************************
; ******* teisendab float A-registrist ASCII_buf'i scientific kujule (e aste) *********************************
; kui ZERO=1, oli tulemus 0 ja pole vaja pikalt kuvada
; *************************************************************************************************************
flo_asc:        clrf    komakohad
                bcf        negatiivne
                movf    AEXP,W                    ; kas 0 ?
                btfsc    ZERO
                goto    floasc_zero
flo_negchk:        btfss    AARGB0,.7                ; kas negatiivne ?
                goto    flo_pos                    ; ei
                bsf        negatiivne                ; lipp
                bcf        AARGB0,.7                ; teeme positiivseks
flo_pos:        movlw    0x82                    ; arv > 10 ?
                cpfsgt    AEXP
                goto    flo_pos1
                goto    flo_gt_ten                ; AEXP > 0x82 -> arv > 10
flo_pos1:        movlw    0x20
                cpfslt    AARGB0
                goto    flo_gt_ten
flo_lt_ten:        movlw    0x7F                    ; arv > 1 ?
                cpfslt    AEXP
                goto    flo_lt_ten1
                goto    flo_lt_one                ; AEXP < 0x7F
flo_lt_ten1:    movlw    0x0
                cpfsgt    AARGB0
                goto    flo_lt_one
                goto    flo_gt_one
flo_lt_one:        movlw    0x82                    ; *10 kuni >1
                movwf    BEXP
                movlw    0x20    
                movwf    BARGB0
                clrf    BARGB1
                clrf    BARGB2
                call    FPM32
                decf    komakohad,F
                goto    flo_lt_ten
flo_gt_ten:        movlw    0x82                    ; / 10 kuni < 10
                movwf    BEXP
                movlw    0x20    
                movwf    BARGB0
                clrf    BARGB1
                clrf    BARGB2
                call    FPD32
                incf    komakohad,F
                goto    flo_pos
flo_gt_one:        call    float_ascii                ; teisenda nagu tavaliselt
                movlw    '+'                        ; kirjuta märk
                btfsc    negatiivne
                movlw    '-'
                movwf    ASCII_buf+.0            ; tõsta numbrid õigesse kohta
                movff    ASCII_buf+.7,ASCII_buf+.1
                movlw    '.'                        ; koma
                movwf    ASCII_buf+.2
                movff    ASCII_buf+.8,ASCII_buf+.3
                movff    ASCII_buf+.9,ASCII_buf+.4
                movff    ASCII_buf+.10,ASCII_buf+.5
;                movlw    ' '                        ; eraldaja
;                movwf    ASCII_buf+.6
                movlw    'E'                        ; eksponendi sümbol
                movwf    ASCII_buf+.6
                movlw    '+'                        ; eksponendi märk
                btfsc    komakohad,.7
                movlw    '-'
                movwf    ASCII_buf+.7
                btfss    komakohad,.7
                goto    floasc_exponent
                comf    komakohad,F
                incf    komakohad,F
floasc_exponent:movf    komakohad,W                ; eksponent ise
                call    HEX2BIN
                movff    abi_H,ASCII_buf+.8
                movff    abi_L,ASCII_buf+.9                
                bcf        ZERO
                return            
floasc_zero:
                movlw    ' '
                movwf    ASCII_buf+.0            ; märki ei kirjuta kui arv = 0
                movlw    '0'
                movwf    ASCII_buf+.1            ;
                movlw    '.'    
                movwf    ASCII_buf+.2        
                movlw    '0'
                movwf    ASCII_buf+.3
                movlw    'E'
                movwf    ASCII_buf+.4
                movlw    '+'
                movwf    ASCII_buf+.5
                movlw    '0'
                movwf    ASCII_buf+.6
                movlw    '0'
                movwf    ASCII_buf+.7
                movlw    '0'
                movwf    ASCII_buf+.8
                movlw    '0'
                movwf    ASCII_buf+.9
                bsf        ZERO
                return

Koodis olev "float_ascii" on Microchipi enese teisendaja (jagab pidevalt 10-ga). Minu kood lihtsalt valmistab numbri ette ja siis korjab tulemuse kokku. Algses float...is on sig_figure võetud 4 ja tulemusi lastakse kirjutada puhvri otsa.