Bienvenue aux nouveaux arrivants sur FantasPic !

- Pensez à lire les règles durant votre visite, il n'y en a pas beaucoup, mais encore faut-il les respecter .
- N’hésitez pas à faire des remarques et/ou suggestions sur le Forum, dans le but de l'améliorer et de rendre vos prochaines visites plus agréables.
- Vous pouvez regarder votre "panneau de l'utilisateur" afin de configurer vos préférences.
- Un passage par "l'utilisation du forum" est recommandé pour connaître les fonctionnalités du forum.

--- L’équipe FantasPic ---
Forum général sur l'Assembleur !

Modérateur : mazertoc

conversion hexa->ascii 16bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#31 Message par Guest » sam. 27 août 2016 14:34

Bonjour

c'est très bien tout cela, encore :bravo:

donc plaisir de lire ce code

A+

conversion hexa->ascii 16bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1650
Enregistré en : juillet 2016
Localisation : Terre

#32 Message par Temps-x » sam. 27 août 2016 18:07

Bonsoir maï,

Et voici

Code : Tout sélectionner


decode_lcd

; "16 bits"

      clrf unite                
      clrf dizaine              
      clrf centaine             
      clrf millieme             
      clrf dix_millieme         

      btfss res16
,7
      goto 
$+D'11'            

      movlw D
'3'                          ; 32768  
      addwf dix_millieme
,F
      movlw D
'2'                          ;  2768  
      addwf millieme
,F
      movlw D
'7'                          ;   768
      addwf centaine
,F                 
      movlw D
'6'                          ;    68
      addwf dizaine
,F                 
      movlw D
'8'                          ;     8
      addwf unite
,F                 


      btfss res16
,6
      goto 
$+D'11'            

      movlw D
'1'                          ; 16384  
      addwf dix_millieme
,F
      movlw D
'6'                          ;  6384  
      addwf millieme
,F
      movlw D
'3'                          ;   384
      addwf centaine
,F                 
      movlw D
'8'                          ;    84
      addwf dizaine
,F                 
      movlw D
'4'                          ;     4
      addwf unite
,F                 


      btfss res16
,5
      goto 
$+D'9'            

      movlw D
'8'                          ; 8192  
      addwf millieme
,F
      movlw D
'1'                          ;  192
      addwf centaine
,F                 
      movlw D
'9'                          ;   92
      addwf dizaine
,F                 
      movlw D
'2'                          ;    2
      addwf unite
,F                 


      btfss res16
,4
      goto 
$+D'9'            

      movlw D
'4'                          ; 4096  
      addwf millieme
,F
      movlw D
'0'                          ;  096
      addwf centaine
,F                 
      movlw D
'9'                          ;   96
      addwf dizaine
,F                 
      movlw D
'6'                          ;    6
      addwf unite
,F                 


      btfss res16
,3
      goto 
$+D'9'            

      movlw D
'2'                          ; 2048  
      addwf millieme
,F
      movlw D
'0'                          ;  048
      addwf centaine
,F                 
      movlw D
'4'                          ;   48
      addwf dizaine
,F                 
      movlw D
'8'                          ;    8
      addwf unite
,F                 


      btfss res16
,2
      goto 
$+D'9'            

      movlw D
'1'                          ; 1024  
      addwf millieme
,F
      movlw D
'0'                          ;  024
      addwf centaine
,F                 
      movlw D
'2'                          ;   24
      addwf dizaine
,F                 
      movlw D
'4'                          ;    4
      addwf unite
,F                 


      btfss res16
,1
      goto 
$+D'7'            

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


      btfss res16
,0
      goto 
$+D'7'            

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

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

; "8 bits"

      btfss res8,7
      goto 
$+D'7'            

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


      btfss res8
,6
      goto 
$+D'5'            

      movlw D
'6'                          ;   64
      addwf dizaine
,F                 
      movlw D
'4'                          ;    4
      addwf unite
,F                 


      btfss res8
,5
      goto 
$+D'5'            

      movlw D
'3'                          ;   32
      addwf dizaine
,F                 
      movlw D
'2'                          ;    2
      addwf unite
,F                 

      btfss res8
,4
      goto 
$+D'5'            

      movlw D
'1'                          ;   16
      addwf dizaine
,F                    
      movlw D
'6'                          ;    6
      addwf unite
,F                 

      movlw B
'00001111'     
      andwf res8
,W    

      addwf unite
,F                    

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

total_unite
      movfw unite
      movwf tmps    
      movfw dizaine
    
      call decompose  

      movwf dizaine
      movfw tmps
      movwf unite

total_dizaine
      movfw dizaine
      movwf tmps    
      movfw centaine
    
      call decompose  

      movwf centaine
      movfw tmps
      movwf dizaine

total_centaine
      movfw centaine
      movwf tmps    
      movfw millieme
    
      call decompose  

      movwf millieme
      movfw tmps
      movwf centaine


total_millieme
      movfw millieme
      movwf tmps    
      movfw dix_millieme
    
      call decompose  

      movwf dix_millieme
      movfw tmps
      movwf millieme 

      movlw D
'48'  

      addwf unite
,F
      addwf dizaine
,F
      addwf centaine
,F
      addwf millieme
,F
      addwf dix_millieme
,F

fin
      goto fin      

;**********************************************************************************************
;
                                       sous programme
;**********************************************************************************************
decompose 
      
      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'

      movfw temps
 return    

      END       


Je sais pas pourquoi ça fonctionne pas

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'  

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



On a gagné au niveau des octets, 48 octets en moins, avec un sous programme, si je me suis pas trompé.

je vais voir, si je peux encore le faire maigrir :lol: humour!! l'été on aime être bien mince.

A+
Modifié en dernier par Temps-x le sam. 27 août 2016 19:43, modifié 2 fois.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

conversion hexa->ascii 16bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#33 Message par Guest » sam. 27 août 2016 18:25

juste un petit truc qui est simple évite les $-2 ou $+9 car celui qui te relit est obligé de recompte pour voir les sauts pause un label comme ici

tient sur le meme note c'est pour du 18F c'est du hexa->BCD reste plus conversion BCD->ascii

Code : Tout sélectionner

;********************************************************************
; variables:      
;   NBHEX contient le nombre en hexa 16bits
;   le resultat en BCD sur 3 octets      
;   140 cycles machine pour 0xFFFF occupe 274 octets
      
;********************************************************************
HEXA_BCD_16   
   btfss   NBHEX+1,7
   bra   ici           
      
   movlw   0x68
   movwf   BCD
   movlw   0x27
   movwf   BCD1         ;32768
   movlw   0x03
   movwf   BCD2
   
ici   btfss   NBHEX+1,6
   bra   ici1
   
   movlw   0x84
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x63
   addwfc   BCD1,w         ;16384
   DAW
   movwf   BCD1
   
   movlw   0x1
   addwfc   BCD2,F
   
ici1    btfss   NBHEX+1,5
   bra   ici2

   movlw   0x92
   addwf   BCD,W                   
   DAW
   movwf   BCD
   
   movlw   0x81
   addwfc   BCD1,w         ;8192
   DAW
   movwf   BCD1
   
   movlw   0x0
   addwfc   BCD2,F
   
ici2   btfss   NBHEX+1,4
   bra   ici3
           
   movlw   0x96
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x40
   addwfc   BCD1,w         ;4096
   DAW
   movwf   BCD1
   
   movlw   0x0
   addwfc   BCD2,F

ici3   btfss   NBHEX+1,3
   bra   ici4
   
   movlw   0x48
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x20
   addwfc   BCD1,w         ;2048
   DAW
   movwf   BCD1
   
ici4   btfss   NBHEX+1,2
   bra   ici5
   
   movlw   0x24
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x10
   addwfc   BCD1,w         ;1024
   DAW
   movwf   BCD1
   
ici5   btfss   NBHEX+1,1
   bra   ici6
   
   movlw   0x12
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x05
   addwfc   BCD1,w         ;512
   DAW
   movwf   BCD1
   
ici6   btfss   NBHEX+1,0
   bra   ici7
   
   movlw   0x56
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x02
   addwfc   BCD1,w         ;256
   DAW
   movwf   BCD1
   
ici7   btfss   NBHEX,7
   bra   ici8
   
   movlw   0x28
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x1
   addwfc   BCD1,w         ;128
   DAW
   movwf   BCD1
   
ici8   btfss   NBHEX,6
   bra   ici9

   movlw   0x64
   addwf   BCD,W
   DAW
   movwf   BCD
   
   movlw   0x0
   addwfc   BCD1,f         ;64
   
ici9   btfss   NBHEX,5
   bra   ici10
   
   movlw   0x32
   addwf   BCD,W
   DAW
   movwf   BCD

   movlw   0x0
   addwfc   BCD1,f         ;32
   
ici10   btfss   NBHEX,4
   bra   ici11
   
   movlw   0x16
   addwf   BCD,W         ;16
   DAW
   movwf   BCD
   
ici11   btfss   NBHEX,3
   bra   ici12
   
   movlw   0x8
   addwf   BCD,W         ;8
   DAW
   movwf   BCD
   
ici12   btfss   NBHEX,2
   bra   ici13
   
   movlw   0x04
   addwf   BCD,W         ;4
   DAW
   movwf   BCD
   
ici13   btfss   NBHEX,1
   bra   ici14
   
   movlw   0x02
   addwf   BCD,F         ;2
   
ici14   btfss   NBHEX,0
   bra   ici15
   
   movlw   0x1
   addwf   BCD,F         ;1

ici15   Return


A+
Modifié en dernier par Anonymous le sam. 27 août 2016 18:39, modifié 1 fois.

conversion hexa->ascii 16bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#34 Message par Guest » sam. 27 août 2016 18:37

je viens de voir que tu as passé a la trap, la retenue suite a une addition. Regarde comment je fais, pour faire passer la retenu sur un 16F .
c'est pour cela que tu as une erreur tu sais te servir de debug sous MPLAB ?????

Va être dur de faire plus court et plus rapide, :lol: je précise bien ET

A+

conversion hexa->ascii 16bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1650
Enregistré en : juillet 2016
Localisation : Terre

#35 Message par Temps-x » sam. 27 août 2016 19:33

+1 Bien vue, effectivement, j'ai fait une boulet :oops: , je sais me servir de de debug sous MPLAB, mais sa change rien au problème
le résultat reste erroné.

Code : Tout sélectionner


      movlw D
'48'  

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


J'ai réparé dans le poste #33, merci de ton intervention

A+
Modifié en dernier par Temps-x le sam. 27 août 2016 19:42, modifié 1 fois.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

conversion hexa->ascii 16bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#36 Message par Guest » sam. 27 août 2016 19:39

avec ton algorithme il n'y a que 2+1 qui fonctionne, car si tu fais 49(1)+50(2) cela fait 99 et non pas 53 comme dans ma conversion HEXA->BCD elle n'est valable que pour 1+2

si je vais trop vite tu m’arrête :wink: car bien souvent je suis dans mon truc ...

conversion hexa->ascii 16bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1650
Enregistré en : juillet 2016
Localisation : Terre

#37 Message par Temps-x » sam. 27 août 2016 19:44

avec ton algorithme il n'y a que 2+1 qui fonctionne, car si tu fais 49(1)+50(2) cela fait 99 et non pas 53 comme dans ma conversion HEXA->BCD elle n'est valable que pour 1+2


Je viens de comprendre ce que tu veux me dire, je suis un peu lent d'esprit, donc on est obligé de remettre les variables a zéro au départ.

je vais y réfléchir, pour supprimer c'est 5 octets :furieux:

Car j'ai vue, dans ta source, que tu fais une soustraction, en retirant 0X30, qui corresponds au zéro, je trouve que c'est ingénieux.
Modifié en dernier par Temps-x le sam. 27 août 2016 19:57, modifié 3 fois.
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

conversion hexa->ascii 16bits
Guest
Confirmé
Confirmé
Messages : 800
Enregistré en : mars 2017

#38 Message par Guest » sam. 27 août 2016 19:49

c'est pas grave, je suis un peu comme toi .Parfois c'est la devant moi et je ne le vois pas, car toujours dans ma logique .C'est pour cela qu'il est parfois utile de passer la main :lol:

conversion hexa->ascii 16bits
Temps-x
Avatar de l’utilisateur
Expert
Expert
Messages : 1650
Enregistré en : juillet 2016
Localisation : Terre

#39 Message par Temps-x » sam. 27 août 2016 19:55

Il y a pas à dire, dans la programmation de langage bas niveau, il faut beaucoup de matière gris :lol:
:roll: Les requins, c'est comme le langage ASM, c'est le sommet de la chaîne alimentaire. :wink:

conversion hexa->ascii 16bits
Claudius
Avatar de l’utilisateur
Passioné
Passioné
Messages : 232
Âge : 65
Enregistré en : septembre 2015
Localisation : ELANCOURT (78 - YVELINES)
Contact :

#40 Message par Claudius » sam. 27 août 2016 19:58

Bonsoir,

Je ne sais plus si je vous ai déjà donné ce lien: PIC Microcontoller Radix Conversion Math Methods
avec notamment: Binary to BCD unpacked 16 bit to 5 digit

Personnellement, je fais mon marché dans ces routines que j'intègre complètement ou partiellement après un test exhaustif de tous les cas de conversions...

Cordialement, A+
--
Claudius


Retourner vers « Langage ASM »

Qui est en ligne

Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 14 invités