- 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 ---
Modérateur : mazertoc
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+
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
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+
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+
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
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+
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+
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+
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+
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+
Retourner vers « Langage ASM »
Qui est en ligne
Utilisateurs parcourant ce forum : Aucun utilisateur enregistré et 51 invités