Conversion FLOTTANT -> HEXA

[Guest]

voici le code

Code : Tout sélectionner

;********************************************************************
; variables:      
;   NBFLOAT contient le nombre flottant en hexa 32bits
;   NBHEX le résultat sur 48 bits
;   2 variables temporaire pour boucles I et J
;      
;   PRÉCISION sur 8 bits
;   Gestion erreur:
;   0 ok, 1 nb infini et NaNs, 2 > 48bits
;      
;   144 octets de mémoire
;       ******************************************      
; Exemple de conversion:
;-  0.987654321 -> 0.98765430 en 479 cycles
;-  32600.9876543 -> 32600.9874022 en 643 cycles      
;*********************************************************************      
FLOAT_HEXA_32
       MOVLW   0X5
       MOVWF   N_2+3
       MOVWF   NBHEX+3
      
       MOVLW   0XF5
       MOVWF   N_2+2      ; charge la base de 1/2 sur 8bits
       MOVWF   NBHEX+2      ; et le résultat le 1 sous entendu
      
       MOVLW   0XE1
       MOVWF   N_2+1
       MOVWF   NBHEX+1
             
       MOVLW   0X00
       MOVWF   N_2
       MOVWF   NBHEX

       BCF       STATUS,C
       RLCF    NBFLOAT
       RLCF    NBFLOAT+1
       RLCF    NBFLOAT+2      ; on récupéré le signe
       RLCF    NBFLOAT+3
      
       BTFSS   STATUS,C
       BRA       EXPO      ; si négatif
       MOVLW   '-'
       MOVWF    SIGNE
      
;********************** Gestion erreur ******************************
EXPO       MOVLW   0XFE      ;2^e -1 e= exposant sur 8 bits
       SUBWF   NBFLOAT+3,W
       BNZ       EXPO1
       RETLW   1         ; NB infinie ou NaNs (pas un nombre)
;********************** Calcul exposant *****************************
EXPO1       MOVLW   0X7F
       SUBWF   NBFLOAT+3,W
        MOVWF   I
      
;******************** Calcul mantisse *****************************      
       MOVLW   .22         ;
       MOVWF   J

SIGNIF0       BCF       STATUS,C
       RRCF    N_2+3
       RRCF    N_2+2      ; base /2
       RRCF    N_2+1
       RRCF    N_2

       BCF       STATUS,C
      
       RLCF    NBFLOAT
       RLCF    NBFLOAT+1
       RLCF    NBFLOAT+2      ; rotation de la mantisse
      
       BTFSS  STATUS,C
       BRA       SIGNIF1
      
       MOVF    N_2,W
       ADDWF   NBHEX,F
      
       MOVF    N_2+1,W
       ADDWFC  NBHEX+1,F      ;NBNHEX=NBHEX+base
      
       MOVF    N_2+2,W
       ADDWFC  NBHEX+2,F
      
       MOVF    N_2+3,W
       ADDWFC  NBHEX+3,F
      
SIGNIF1       DECFSZ  J
       BRA       SIGNIF0
      

       BTFSC   I,7
       BRA       MANTISSE_N
      
;*********************** Flottant > 0 *******************************      
MANTISSE_P 
       BCF       STATUS,C
       RLCF    NBHEX
       RLCF    NBHEX+1
       RLCF    NBHEX+2
       RLCF    NBHEX+3
       RLCF    NBHEX+4
       RLCF    NBHEX+5      ;NBHEX * exposant
       BTFSC   STATUS,C
       RETLW   2         ;dépassement 48bits
      
       DECFSZ  I
       BRA       MANTISSE_P
      
       RETLW   0         ; retour sans erreur
      
;*********************** Flottant < 0 *******************************
MANTISSE_N
        NEGF    I
      
MANTISSE_N0 BCF       STATUS,C
      
       RRCF    NBHEX+4
       RRCF    NBHEX+3      ;NBHEX / exposant
       RRCF    NBHEX+2
       RRCF    NBHEX+1
       RRCF    NBHEX
      
       DECFSZ  I
       BRA       MANTISSE_N0      

       RETLW   0         ; pas erreur
      



Nous avons fait le tour des conversions dans ce sens la, Il va de soit pour faire du flottant->ascii il faudra modifier la conversion hexa-ascii 16bits et la passer sous 48bits et prévoir un arrondi et pose de la virgule.mais la je vous laisse un peu faire Si vous voulez vraiment utiliser des flottants

A+

[Guest]

Bonsoir

Voici la version µC 16 bits, pour ce que cela intéresse.Bien sur plus rapide et moins d'occupation mémoire. Toujours pareils s'il y a une âme charitable, pour faire cela en 16F pas de problème

Code : Tout sélectionner

;********************************************************************
; variables:      
;   NBFLOAT contient le nombre flottant en hexa 32bits
;   NBHEX le resultat sur 48 bits
;      
;   PRECISION sur 8 bits
;   Gestion erreur:
;   0 ok, 1 nb infini et NaNs, 2 > 48bits
;      
;   70 octets de memoire
;       ******************************************      
; Exemple de conversion:
;-  0.987654321 -> 0.98765430 en 313 cycles
;-  32600.9876543 -> 32600.9874022 en 421 cycles      
;*********************************************************************      
   
FLOAT_HEXA_32:
       MOV       #NBHEX,W3   ; on charge le pointeur

;********************************************************************
       MOV       #0X05F5,W0
       MOV       #0XE100,W1
       MOV.D   W0,W8      ;N_2
      
       MOV       W0,NBHEX+2      ;NBHEX
       MOV       W1,NBHEX      ;NBHEX

       BCLR    SR,#0      

       RLC       NBFLOAT
       RLC       NBFLOAT+2      ; on recupere le signe
      
       BRA       NC, EXPO      ; si negatif
       MOV.B   '-',WREG
       MOV.B   WREG,SIGNE
      
;********************** Gestion erreur ******************************
EXPO:      
        MOV       #0XFE,W0
       SUB.B   NBFLOAT+3,WREG   ;2^e -1 e= exposant sur 8 bit
      
       BRA       NZ,EXPO1
       RETLW.B   #0x1,W0      ; NB infinie ou NaNs (pas un nombre)
      
;********************** Calcul exposant *****************************
EXPO1:      
       MOV       #0X7F,W0 
       SUB.B   NBFLOAT+3,WREG
       MOV       W0,W2
;      
;******************** Calcul mantisse *****************************
       DO       #22,ENDFIN0      ; sur precision de 23 bITS
      
       BCLR    SR,#0
       RRC       W8,W8
       RRC       W9,W9      ; division /2 valeur mantisse 1/X
      
       BCLR    SR,#0      
       RLC       NBFLOAT
       RLC.B   NBFLOAT+2      ;flotant code sur 32 BITS
      
       BRA       NC,Float1
   
       ADD.W   W9,[W3],[W3++]
       ADDC.W  W8,[W3],[W3++]
       MOV       #NBHEX,W3
Float1:      
      NOP
ENDFIN0:
       NOP
   
       BTSC   W2,#7
       BRA      MANTISSE_N
;      
;*********************** Flottant > 0 *******************************      
MANTISSE_P:
       DEC       W2,W2

       DO       W2,ENDFIN1
       BCLR    SR,#0
       RLC       NBHEX
       RLC       NBHEX+2      ;NBHEX * exposant
       RLC       NBHEX+4      
       BRA       NC,MANT
       RETLW.B #0x2,W0      ;depassement 48bits
      
MANT:      
      NOP
ENDFIN1:
       NOP
       RETLW.B #0,W0      ; retour sans erreur
;      
;*********************** Flottant < 0 *******************************
MANTISSE_N:
       NEG.B  W2,W2
       DEC.B  W2,W2

       DO      W2,ENDFIN2
       BCLR   SR,#0
       RRC    NBHEX+4
       RRC    NBHEX+2      ;NBHEX / exposant
       RRC    NBHEX
 ENDFIN2:
       NOP
       RETLW.B #0,W0      ;pas erreur



j'ai modifie le code sans variable et on gagne en mémoire et vitesse
A+