[Guest]

Bonjour

Je me suis remis, au 16 bits faisait un moment, dur dur, j'ai la tête qui se ramollie Pour faire la même conversion, j'ai pas trop optimiser , un simple petit test

Code : Tout sélectionner

;********************************************************************
; variables:      
;   NBHEXH contient le nombre en hexa 16bits (65535)
;   ASCII Table contient le resultat en ASCII
;   95 cycles machine occupe 44 octets
;********************************************************************
   
HEXA_ASCII:
   MOV   NBHEX,W2
   MOV   #0X2710,W4
   
   repeat  #17   
   DIV.U   W2,W4
   ADD.B   ASCII+4
   
   MOV   W1,W2
   MOV   #0X03E8,W4
   
   repeat  #17   
   DIV.U   W2,W4
   ADD.B   ASCII+3

   MOV   W1,W2
   MOV   #0X064,W4
   
   repeat  #17   
   DIV.U   W2,W4
   ADD.B   ASCII+2

   MOV   W1,W2
   MOV   #0X0A,W4
   
   repeat  #17   
   DIV.U   W2,W4
   ADD.B   ASCII+1
   
   MOV.B   W1,W0
   ADD.B   ASCII
   
   RETURN


Avec les divisions ça roule c'est surtout bien plus court en occupation, j'ai pas mis de commentaires, car c'est simple division addition avec la variable
je peux poster aussi poster une copie écran si quelqu'un est intéressé.

j'ai aussi fait la conversion atoi Paul si tu veux je la post

A+

[Guest]

Bonjour

ALLEZ pour encore un peu activer l'ASM
Bien sympa ta conversion,mais quand la conversion nous fait ressortir des zéros devant le 1er nombre signification du style 0x15FF nous donne pour la vision humaine: 05631 comment faire pour supprimer ce ZERO, alors la ahma nous avons plusieurs possibilités.Ici on se sert d'un pointeur car si c'est un nombre décimale ( et OUI un flottant doit faire une conversion flottant -> hexa)cela sera utile pour poser la virgule ou le point

Après bien sur ce spg est évolutif vers 24 bits 32 bits comme j'ai dis plus haut c'est un bon compromis vitesse espace mémoire

je vous donne le code

Code : Tout sélectionner

;********************************************************************
; variables:      
;   NBHEXH NBHEXL contient le nombre en hexa 16bits pour HEXA_ASCII_16
;   NBHEXL contient le nombre en hexa (8bits) pour HEXA_ASCII_8   
;   le resultat en ASCII dans tableau ASCII
;   un pointeur pointe sur le 1er chiffre sigificatif de la chaine      
;   220 cycles machine pour 0xFFFF occupe 142 octets   
;********************************************************************
   
HEXA_ASCII_16
          
   MOVLW   0X30 
   MOVWF   ASCII
   MOVWF   ASCII+1
   MOVWF   ASCII+2
   MOVWF   ASCII+3
   MOVWF   ASCII+4         ;init variable a 0 0x30 en hexa
   
   BCF   STATUS,DC
   
Dixmille   
   MOVLW   0x10
   SUBWF   NBHEX+1,F
   
   MOVLW   0x27
   SUBWFB   NBHEX,F         ;NBHEXH,NBHEXL-10 000
   BTFSS   STATUS,C      ; test depasemnt
   BRA   Mille         ; oui suiye a mille   
   INCF   ASCII,F         ;non dixmille +1
   BRA   Dixmille      ; et on retourne
   
;********************** millier *************************************

Mille   MOVLW   0X10
   ADDWF   NBHEX+1,F
   MOVLW   0X27
   ADDWFC   NBHEX,F         ;NBHEXH,NBHEXL+10 000
   
Mil   MOVLW   0xE8
   SUBWF   NBHEX+1,F
   
   MOVLW   0x03         ; NBHEXH,NBHEXL-1 000
   SUBWFB   NBHEX,F         ;test debordement
   BTFSS   STATUS,C
   BRA   Cent         ;oui a cent
   INCF   ASCII+1,F      ; non mille +1
   BRA   Mil         ; on retourne

;*********************** centaines **********************************
      
Cent   MOVLW   0XE8
   ADDWF   NBHEX+1,F
   MOVLW   0X03
   ADDWFC   NBHEX,F         ;NBHEXH,NBHEXL+1 000
   
Cent1   MOVLW   0x64
   
Cent10   SUBWF   NBHEX+1,F      ;NBHEXL-100
   BTFSS   STATUS,C
   BRA   Cent2         ;test debordement oui
   INCF   ASCII+2,F      ;non cent+1
   BRA   Cent10         ; on retourne


Cent2   MOVLW   0x00         ;NBHEXH-100
   SUBWFB   NBHEX,F
   BTFSS   STATUS,C
   BRA   Dix         ;test debordement oui au dizaine
   INCF   ASCII+2,F      ;non cent+1
   BRA   Cent1         ;on retourne

;*********************** dizaine ************************************
   
Dix   MOVLW   0x64   
   ADDWF   NBHEX+1,F      ;NBHEXL+100
   
   MOVLW   0x0A
   
Dix1   SUBWF   NBHEX+1,F      ;NBHEXL-10
   BTFSS   STATUS,C
   BRA   Unit         ; test debordemnet oui unite
   INCF   ASCII+3,F      ;non dizaine+1
   BRA   Dix1         ; on retourne
           
Unit   ADDWF   NBHEX+1,W      ;NBHEXL+10
   ADDWF   ASCII+4,F      ; additionne unite

   CLRF   pHEX_ASCII
   
;*********************************   
   MOVLW   0X30
   CPFSEQ   ASCII
   BRA   Unit0
   INCF   pHEX_ASCII+1
   CPFSEQ   ASCII+1
   BRA   Unit0
   INCF   pHEX_ASCII+1
   CPFSEQ   ASCII+2
   BRA   Unit0
   INCF   pHEX_ASCII+1      ;recherche 1er nombre significatif
   CPFSEQ   ASCII+3
   BRA   Unit0
   INCF   pHEX_ASCII+1
Unit0   
   MOVLW   low ASCII
   ADDWF   pHEX_ASCII+1,F
   MOVLW   HIGH ASCII
   ADDWFC  pHEX_ASCII,F
   
   RETURN


la partie déclaration des variables

Code : Tout sélectionner

;*********************** Définitions variables en RAM *********
       CBLOCK   0x00
       pHEX_ASCII:d'2'      ;pointeur sur chaine hexa->ascii
       ASCII:d'5'         ;chaine
       NBHEX:d'2'         ; nombre hexa

       ENDC


si quelqu'un veut bien Faire la conversion pour un 16F il est le bien venu

A+

De nouveau bonne fête a vous tous

[Guest]

Pas de volontaire c'est triste....

ici le code pour un 16F

Code : Tout sélectionner

;********************************************************************
; variables:      
;   NBHEXH contient le nombre en hexa 16bits pour HEXA_ASCII_16   
;   le resultat en ASCII dans tableau ASCII
;   un pointeur pointe sur le 1er chiffre sigificatif de la chaine      
;   229 cycles machine pour 0XFFFF occupe 84 octets      
;********************************************************************
   
HEXA_ASCII_16
          
   MOVLW   0X30 
   MOVWF   ASCII
   MOVWF   ASCII+1
   MOVWF   ASCII+2
   MOVWF   ASCII+3
   MOVWF   ASCII+4         ;init variable a 0 0x30 en hexa
   
   BCF   STATUS,C
   
Dixmille   
   MOVLW   0x10
   SUBWF   NBHEX+1,F
   BTFSS   STATUS,C
   DECF   NBHEX,F
   MOVLW   0x27
   SUBWF   NBHEX,F         ;NBHEXH,NBHEXL-10 000
   BTFSS   STATUS,C      ; test depasemnt
   GOTO   Mille         ; oui suie a mille   
   INCF   ASCII,F         ;non dixmille +1
   GOTO   Dixmille      ; et on retourne
   
;********************** millier *************************************
Mille   MOVLW   0X10
   ADDWF   NBHEX+1,F
   BTFSC   STATUS,C
   INCF   NBHEX,F
   MOVLW   0X27
   ADDWF   NBHEX,F         ;NBHEXH +10 000
   
Mil   MOVLW   0xE8
   SUBWF   NBHEX+1,F
   BTFSS   STATUS,C
   DECF   NBHEX,F
   MOVLW   0x03         ; NBHEX-1 000
   SUBWF   NBHEX,F         ;test débordement
   BTFSS   STATUS,C
   GOTO   Cent         ;oui a cent
   INCF   ASCII+1,F      ; non mille +1
   GOTO   Mil         ; on retourne

;*********************** centaines **********************************
Cent   MOVLW   0XE8
   ADDWF   NBHEX+1,F
   BTFSC   STATUS,C
   INCF   NBHEX
Centc   MOVLW   0X03
   ADDWF   NBHEX,F         ;NBHEX+1 000
   
Cent1   MOVLW   0x9C
   
Cent10   ADDWF   NBHEX+1,F      ;NBHEXL-100
   BTFSS   STATUS,C
   GOTO   Cent2         ;test débordement oui
   INCF   ASCII+2         ;non cent+1
   GOTO   Cent10         ; on retourne


Cent2   MOVLW   0xFF         ;NBHEXH-100
   ADDWF   NBHEX,F
   BTFSS   STATUS,C
   GOTO   Dix         ;test débordement oui au dizaine
   INCF   ASCII+2,      ;non cent+1
   GOTO   Cent1         ;on retourne

;*********************** dizaine ************************************
Dix   MOVLW   0X64
   ADDWF   NBHEX+1,F      ;+100
   
   MOVLW   0XF6
Dix1   ADDWF   NBHEX+1,F      ;-10
    BTFSS   STATUS, C   
    GOTO   Unit
    INCF   ASCII+3,F
   GOTO   Dix1
               
Unit   MOVLW   0XA
   ADDWF   NBHEX+1,W      ;NBHEXL+10
   ADDWF   ASCII+4,F      ;
   
;*********************************
   MOVLW   ASCII
   MOVWF   pHEX_ASCII
   
   MOVLW   0X30
   SUBWF   ASCII,W
   BTFSS   STATUS,Z
   RETURN
   INCF   pHEX_ASCII
   MOVLW   0X30
   SUBWF   ASCII+1,W
   BTFSS   STATUS,Z
   RETURN
   INCF   pHEX_ASCII
   MOVLW   0X30
   SUBWF   ASCII+2,W
   BTFSS   STATUS,Z
   RETURN
   INCF   pHEX_ASCII      ;recherche 1er nombre significatif
   MOVLW   0X30
   SUBWF   ASCII+3,W
   BTFSS   STATUS,Z
   RETURN
   INCF   pHEX_ASCII
   RETURN


A+

[Temps-x]

Bonjour à tous et à toutes,

si quelqu'un veut bien Faire la conversion pour un 16F il est le bien venu

Pour ton code maï, je comprends pas comment ça fonctionne, mais je vais y réfléchir.

Voici le mien

Ben moi, voila comment je fais, mais c'est pas beau à voir, mais sa fonctionne très bien, et je comprendre son fonctionnement.

Code : Tout sélectionner




;********************************************************************
;       res16 & res8 contient le nombre en hexa sur 16bits 
;********************************************************************

    CBLOCK 0x70            
      unité                   :1
      dizaine                 :1
      centaine                :1
      millième                :1  
      dix_millième            :1
      temps                   :1    
      tmps                    :1
      res8                    :1  
      res16                   :1  
    ENDC                

;********************************************************************
;            Macro pour séparer les nombres des chiffres
;********************************************************************

decompose MACRO val1,val2
       
      movf val1,W                        
      movwf tmps

      movf val2,W      
      movwf temps

      movfw tmps
      sublw D'10'                         ; retir 10 de W
      btfsc STATUS,Z                      ; si le bit Z est à 1 on va à la ligne 1                                       
      goto $+D'4'                         ; si Z = 1 , résultat égal
      btfss STATUS,C                      ; si le bit C est à 0 on va à la ligne 1
      goto $+D'2'
      goto $+D'5'                         
      movlw D'10' 
      subwf tmps,F   
      incf temps,F  
      goto $-D'10'
   ENDM 

;********************************************************************
;                   début du programme principal
;********************************************************************

decode_lcd

; "16 bits"

      clrf unité
      clrf dizaine
      clrf centaine
      clrf millième
      clrf dix_millième

      btfsc res16,7
      goto $+D'2'
      goto $+D'11'            

      movlw D'3'                          ; 32768  
      addwf dix_millième,F
      movlw D'2'                          ;  2768  
      addwf millième,F
      movlw D'7'                          ;   768
      addwf centaine,F                 
      movlw D'6'                          ;    68
      addwf dizaine,F                 
      movlw D'8'                          ;     8
      addwf unité,F                 


      btfsc res16,6
      goto $+D'2'
      goto $+D'11'            

      movlw D'1'                          ; 16384  
      addwf dix_millième,F
      movlw D'6'                          ;  6384  
      addwf millième,F
      movlw D'3'                          ;   384
      addwf centaine,F                 
      movlw D'8'                          ;    84
      addwf dizaine,F                 
      movlw D'4'                          ;     4
      addwf unité,F                 


      btfsc res16,5
      goto $+D'2'
      goto $+D'9'            

      movlw D'8'                          ; 8192  
      addwf millième,F
      movlw D'1'                          ;  192
      addwf centaine,F                 
      movlw D'9'                          ;   92
      addwf dizaine,F                 
      movlw D'2'                          ;    2
      addwf unité,F                 


      btfsc res16,4
      goto $+D'2'
      goto $+D'9'            

      movlw D'4'                          ; 4096  
      addwf millième,F
      movlw D'0'                          ;  096
      addwf centaine,F                 
      movlw D'9'                          ;   96
      addwf dizaine,F                 
      movlw D'6'                          ;    6
      addwf unité,F                 


      btfsc res16,3
      goto $+D'2'
      goto $+D'9'            

      movlw D'2'                          ; 2048  
      addwf millième,F
      movlw D'0'                          ;  048
      addwf centaine,F                 
      movlw D'4'                          ;   48
      addwf dizaine,F                 
      movlw D'8'                          ;    8
      addwf unité,F                 


      btfsc res16,2
      goto $+D'2'
      goto $+D'9'            

      movlw D'1'                          ; 1024  
      addwf millième,F
      movlw D'0'                          ;  024
      addwf centaine,F                 
      movlw D'2'                          ;   24
      addwf dizaine,F                 
      movlw D'4'                          ;    4
      addwf unité,F                 


      btfsc res16,1
      goto $+D'2'
      goto $+D'7'            

      movlw D'5'                          ;  512
      addwf centaine,F                 
      movlw D'1'                          ;   12
      addwf dizaine,F                 
      movlw D'2'                          ;    2
      addwf unité,F                 


      btfsc res16,0
      goto $+D'2'
      goto $+D'7'            

      movlw D'2'                          ;  256
      addwf centaine,F                 
      movlw D'5'                          ;   56
      addwf dizaine,F                 
      movlw D'6'                          ;    6
      addwf unité,F                 

;********************************************************************************************** 

; "8 bits"

      btfsc res8,7
      goto $+D'2'
      goto $+D'7'            

      movlw D'1'                          ;  128
      addwf centaine,F                 
      movlw D'2'                          ;   28
      addwf dizaine,F                 
      movlw D'8'                          ;    8
      addwf unité,F                 


      btfsc res8,6
      goto $+D'2'
      goto $+D'5'            

      movlw D'6'                          ;   64
      addwf dizaine,F                 
      movlw D'4'                          ;    4
      addwf unité,F                 


      btfsc res8,5
      goto $+D'2'
      goto $+D'5'            

      movlw D'3'                          ;   32
      addwf dizaine,F                 
      movlw D'2'                          ;    2
      addwf unité,F                 


      btfsc res8,4
      goto $+D'2'
      goto $+D'5'            

      movlw D'1'                          ;   16
      addwf dizaine,F                    
      movlw D'6'                          ;    6
      addwf unité,F                 


      btfsc res8,3
      goto $+D'2'
      goto $+D'3'            

      movlw D'8'                          ;    8
      addwf unité,F                 


      btfsc res8,2
      goto $+D'2'
      goto $+D'3'            

      movlw D'4'                          ;    4
      addwf unité,F                 


      btfsc res8,1
      goto $+D'2'
      goto $+D'3'            

      movlw D'2'                          ;    2
      addwf unité,F                 


      btfsc res8,0
      goto $+D'2'
      goto $+D'3'            

      movlw D'1'                          ;    1
      addwf unité,F                    

;********************************************************************************************** 

total_unité
      decompose unité,dizaine                     ; appelle à la Macro 
      movf tmps,W
      movwf unité

      movf temps,W
      movwf dizaine
total_dizaine
      decompose dizaine,centaine                  ; appelle à la Macro 
      movf tmps,W
      movwf dizaine

      movf temps,W
      movwf centaine
total_centaine
      decompose centaine, millième                ; appelle à la Macro 
      movf tmps,W
      movwf centaine

      movf temps,W
      movwf millième
total_millième
      decompose millième,dix_millième              ; appelle à la Macro 
      movf tmps,W
      movwf millième

      movf temps,W
      movwf dix_millième

      movlw D'48'                         ; corespond au zéro 

      addwf unité,F
      addwf dizaine,F
      addwf centaine,F
      addwf millième,F
      addwf dix_millième,F

      return



il est assez gros, je le reconnais.

A+

[Guest]

bonsoir Temps-x

il est assez gros, je le reconnais.

mais la tu peux raccourcir un peu NON ?

Code : Tout sélectionner

      btfsc res16,7
      goto $+D'2'
      goto $+D'11'           


Comme cela

Code : Tout sélectionner

      BTFSS res16,7
      goto Suite
      movlw D'1'                          ; 16384 
      addwf dix_millième,F
      movlw D'6'                          ;  6384 
      addwf millième,F
      movlw D'3'                          ;   384
      addwf centaine,F                 
      movlw D'8'                          ;    84
      addwf dizaine,F                 
      movlw D'4'                          ;     4
      addwf unité,F                 
Suite         


Pour faire une comparaison de code il est bon de donner cycles machine(pour la valeur max ici 0XFFFF) et occupation mémoire

Pour Mon code, le principe est simple voir sous 16bits ,succession de division . sous 8 bits des soustractions

NB/10 000 quotient ->Ascii reste dans NB
NB/1 000 quotient -> Ascii+1 reste dans NB
NB/100 quotient -> Asccii+2 reste dans NB
NB/10 quotient -> Ascii+3 reste dans Ascii+4

A+

PS: avec ton code on est a 417 cycles et 224 octets pour 0xFFFF en modifiant le test on passe a 401 cycles et 208 octets

[Temps-x]

Bonjour à tous et à toutes,

Bonsoir maï

Maintenant, je regarderai avant écriture, j'ai trouvé un moyen de le raccourci un peu,

PS: avec ton code on est a 417 cycles et 224 octets pour 0xFFFF en modifiant le test on passe a 401 cycles et 208 octets

Code : Tout sélectionner



; Pour le mode 8 bits, les 4 dernier bits du poids faible

       bcf res8,7 
       bcf res8,6     
       bcf res8,5
       bcf res8,4     
              
      movfw res8
      addwf unite,F



En modifiant le code, je passe à 386 cycles et 198 octets.

Il est évident, pour une comparaison, on donne la valeur maxi ( D'65535' )

Il reste toujours assez gros, Je vais le compresser en format ZIP


Ton code et le meilleur.

A+

[Guest]

Bonsoir Temps-x

pour ta persévérance:
- Un dans la suite de ton code qui a bien maigris
-Pour avoir choisi la difficulté plutôt que de prendre des briques (lib)et un arduino

Perso bien content de trouver, enfin un répondant, car un peu seul en ASM ,bon je fais aussi du C, mais comme déjà dit, c'est pas ma tasse de thé.
plaisir de te lire et

A+

[Temps-x]

Bonjour à tous et à toutes,

Bonsoir maï

je pense que je peux le faire maigrir encore, au niveau de la macros.

Oui, comme tu l'as compris, j'aime pas prendre des choses toutes faites, comme les librairies, j'aime bien comprendre avant d'appliquer, je
suis comme ça.

Arduino, il faut pas mon parler, c'est le seule moyen de rien apprendre, c'est vraiment commercial, à 100%

Moi aussi, je suis content d'avoir une personne qui est capable de me dire, on peu faire mieux, regarde ça, ça permets d'évoluer.

Je fais que de de l'assembleur, pour les microcontrôleurs, je voie pas l’intérêt d'utiliser autre langage, qui sont des dérivées des
bibliothèques écrit en ASM.

Comme tu as pu le constater, et même si mon code et plus gros que le tiens, ça vient de moi, c'est mes idées, j'ai pas
copié, et c'est ça qui conte le plus pour moi.

A+

[Guest]

Bonsoir Temps_x

Tu peux encore faire plus court et rapide

faire:

Code : Tout sélectionner

 
       MOVLW 0B'00001111     
       ANDWF res8     


au lieu de:

Code : Tout sélectionner

       bcf res8,7
       bcf res8,6     
       bcf res8,5
       bcf res8,4     


pour ta macro regarder du cote du jeu instruction DAW ajustement décimale du registre W (18F)

plaisir de te lire et

A+

[Temps-x]

Bonjour à tous et à toutes,

Bonsoir maï,

Je voulais le faire, mes je savais pas comment faire, et tu viens de me le montrer.

c'est pas maï que tu aurais du choisir, mais, Maître

je m'incline, devant ton savoir, je viens de trouver une méthode qui va faire chuter la taille de beaucoup,
on devrais approcher les 140 octets.

La macro réécrit le code lors de l'assemblage, un sous programme le fait pas, donc au lieu d'appeler 4 fois la macros, il suffit
d'écrire le sous programme, et de faire appelle à elle 4 fois.

D'autre part dans ton code j'ai vue une petite astuce, que je peux comprendre

Code : Tout sélectionner


       
; au lieu de faire cela

      clrf unité                ; 1 octet
      clrf dizaine              ; 1 octet
      clrf centaine             ; 1 octet
      clrf millième             ; 1 octet
      clrf dix_millième         ; 1 octet

; autant le faire au début ça économise 5 octets

      movlw D'48'  
      addwf unité,F
      addwf dizaine,F
      addwf centaine,F
      addwf millième,F
      addwf dix_millième,F



je suis à 135 octets, va ton arrivé à la même taille que toi ?

Je mets le code avec le sous programme, quand j'aurais le temps de l'écrire, car je suis très pris en ce moments.

pour avoir fait maigrir mon code .

A+