Discussion :

[stanlagtan]

Salut a tous, j'essaie de faire un petit programme en assembleur qui permet de saisir et afficher les lettres de l'alphabet en hexadecimal, puis de convertir cette valeur hexadecimal en decimale.
En d'autre termes, je dois pouvoir saisir une lettre et afficher son code ascii en hexadecimal puis en decimal, exemple: lettre a = 61 (hexadecimal) et 97 (decimal).
je pense avoir fait correctement la conversion en Hexadecimale, cependant j'ai un debordement qui me fait avoir des caracteres bizarres et aussi j'e n'arrive pas trop bien a voir la valeur décimale. mon code est le suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
 
pile SEGMENT STACK
  	pile DW 500 dup(?)
pile ENDS    
 
 
data SEGMENT
	fort 	        DB ?
	faible 	DB ?
        msg DB 'et la value decimale est: ',0dh,0ah,'$'
 
data ENDS
 
	ASSUME DS:data, CS:code
 
code SEGMENT
 
	MOV ax, data
	MOV ds, ax
 
 
 start:	MOV AH,1	         ;Lecture et mise du caractère dans le registre al
	        INT 21h		
 
 
 	MOV AH,AL	;Mettre dans AH le caractère
	MOV CX,4 
   for:	SHR AH,1	;on deplace les 4 bits de poids faible vers la droite de sorte qu'il ne reste que les bits de poids fort dans AH
	loop for	        
 
        MOV bh,ah     ; on stock la valeur de ah pour usage ulterieur
 	CMP AH,09h	;Comparer AH avec 9
	JLE lab1	;Cas où AH <= 9 càd AH en hexa dans [0,9]
	ADD AH,07h	;Cas où AH > 9 càd AH en hexa dans [A,F]
 lab1:	ADD AH,30h	;Si AH<9 alors AH aura le code ASCII codé 
			;hexadecimale de AH càd '0','1',..,'9'
	AND AL,0Fh	;AL contient après cette operation les 4 bits 
			;de poids faible du code ASCII du caractère
         MOV bl, al       ; on stocke la valeur de al pour usage ulterieur
	CMP AL,09h	;Comparer AL avec 9
	JLE lab2	;Cas où AL <= 9 càd AL en hexa dans [0,9]
	ADD AL,07h	;Cas où AL > 9 càd AL en hexa dans [A,F]
 lab2:	ADD AL,30h	;Si AL<9 alors AL aura le code ASCII codé 
			;hexadecimale de AL càd '0','1',..,'9'
 
;##########AFFICHAGE HEXADECIMALE########
 
	MOV fort,AH	
	MOV faible,AL
 
	MOV Dx,0A0Dh	;instructions retour à la ligne
	MOV AH,02h
	INT 21h
 
	MOV DL,fort	;Affichage du poids fort
	MOV AH,02h
	INT 21h
 
	MOV DL,faible	;Affichage du poid faible
	MOV AH,02h
	INT 21h
;###############traitement et affichage decimale##########
        MOV dx, offset msg
        MOV ah, 09H
        INT 21H
 
        MOV ax, bx
        MOV cl, 10
        DIV cl
 
        MOV dh, ah
        MOV dl, 0
 
       ADD al, 30H
       MOV dl, al
       MOV ah, 2
       INT 21H
 
        ADD dh, 30H
        MOV dl, dh
        MOV ah, 2
         INT 21H
 
 
	MOV AH, 4Ch	;Sortie DOS
	INT 21h
 
 code ENDS
 END start

MERCI DE VOTRE AIDE.

[stanlagtan]

J'ai resoolu le probleme. j'ai un peu reecrit tout le code et ca donne ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
.model small
.stack 2000h
 
.data
        aff db 'Appuyez sur un caractere pour voir son code ASCII en hexadecimal et en decimal',0dh,0ah, '$'
        msg db 0dh,0ah, 'la valeur decimale est: ' ,'$'
        msg1 db 0dh,0ah, 'la valeur hexadecimale est: ','$'        
        fort             db ?
        faible           db ?
        lettre           db ?
 
 
 
.code 
 
        MOV AX, @DATA
        MOV DS, AX
 
;#############MEssage initial############
        MOV DX, OFFSET AFF
        MOV ah,09H
        INT 21H
 
 
;**************saisie*******
 
         mov ah,1                ; lecture au clavier du caractere
         int 21h                  ; mettre le caractere dans al
 
         mov lettre ,Al           ;on enregistre le caractere
         mov dx,offset msg1
         mov ah,09H
         int 21h
 
 
;*****TRAITEMENT************
 
        mov ah, al
        mov cx,4
   for: shr ah,1        ;apres cette boucle, ah contient les 4 bits de poids fort
        mov bh,ah       ; on stock dans bh
        loop for        ; du code ascii
 
 
 
        cmp ah, 09h
        jle lab1
        add ah, 07h       
 
lab1:   add ah, 30h
        and al, 0fh
        mov bl,al               ;les 4 bit faible dans bl
        cmp al,09h
        jle lab2
        add al,07h
lab2:   add al,30h
 
 
;**********affichage*******
 
 
 
        mov fort, ah
        mov faible, al
 
 
        mov dl, fort
        mov ah, 02h
        int 21h
 
        mov dl, faible
        mov ah, 02h
        int 21h
 
;######################affichage decimal###################
 
    mov dx,offset msg
    mov ah,09H
    int 21h
 
 
;************traitement2*******************
 
 
        mov al,lettre
 
        mov ah,0
 
        MOV CL, 10
        DIV CL
 
        MOV DH, AH
        MOV DL,0
 
 
 
        ADD aL, 30H
        MOV DL, aL
        MOV AH, 2
        INT 21H
 
 
        ADD DH, 30H
        MOV DL, DH
        MOV AH, 2 
        INT 21H
 
 
;*************fin de programme**************
 
       mov ah,4ch
       int 21h
 
end

MERCI!

[Invité]

N'ayant pas d'assembleur sous la main, je n'ai pas eu la possibilité de tester ton programme dont je ne doute pas qu'il fonctionne. Néanmoins, j'aimerais attirer ton attention sur sa lisibilité et sur les techniques à employer en pareil cas :
1) les fonctions de décalage de bits à droite ou à gauche peuvent directement effectuer le décalage du nombre de bits souhaité sans recourir à une boucle. Ainsi, l'instruction SHR AL,4 effectue-t-elle un décalage de 4 bits à droite
2) la traduction du contenu d'un registre ou d'un emplacement mémoire en décimal à l'affichage nécessite une boucle de divisions par 10. L'algorithme proposé ici est ultra-classique.
3) Plutôt que de "ramer" pour constituer un caractère hexa, il est souvent plus judicieux de constituer une table et de convertir directement le chiffre avec XLATB.
4) La fonction 4Ch de l'INT 21h est généralement spécifiée avec un code d'erreur dans AL. Le plus souvent, ce code est nul et l'on trouve donc : MOV AX, 4C00h

Voici donc comment tout cela s'articule. Le seul problème est que je n'ai pas pu tester cette version :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
.model small
.stack 2000h
 
.data
        aff db 'Appuyez sur un caractere pour voir son code ASCII en hexadecimal et en decimal',0dh,0ah, '$'
	TableHex	db '0123456789ABCDEF'
        msg db 0dh,0ah, 'la valeur decimale est: '
	nombre	db 5 dup (0)		; 5 zéros consécutifs
        msg1 db 0dh,0ah, 'la valeur hexadecimale est: '
	nombre1	db 5 dup (0)		; 5 zéros consécutifs        
        lettre           db ?
 
.code 
 
        MOV AX, @DATA
        MOV DS, AX
 
;############# Message initial ############
        MOV DX, OFFSET AFF
        MOV ah,09H
        INT 21H
 
 
;************** Saisie au clavier *******
 
        mov ah,1                ; lecture au clavier du caractere
        int 21h                 ; mettre le caractere dans al
	mov lettre ,al          ; on enregistre le caractere
 
;========= Calcul de la valeur hexa =========
 
	mov  bx, offset TableHex
	mov  di,offset nombre1
	push ax
	;--- quartet haut
	shr  al,4
	xlatb			; conversion hexa
	stosb			; mise en mémoire quartet haut
	;--- quartet bas
	pop  ax
	and  al,0Fh		; on ne conserve que les bits du quartet bas
	xlatb			; conversion hexa
	stosb			; mise en mémoire quartet bas
	;--- $ pour terminer la chaîne
	mov  al,'$'
	stosb			; mise en mémoire '$'
 
;========= Calcul de la valeur décimale =========
 
	mov  al,lettre
	xor  ah,ah		; AH = 0
	mov  bx,10
	xor  cx,cx
	mov  di,offset nombre
 
;--- Divisions par 10 successives pour obtenir un résultat affichable
 
BcleAscii:
	xor  dx,dx 		; dx = 0 (car c'est la partie haute du dividende)
	div  bx			; division par 10 de DX:AX
	push dx			; on stocke le reste en pile
	inc  cx			; on compte le nombre d'empilages
	or ax,ax		; si le quotient est nul, on arrête
	jnz  BcleAscii
 
;--- Restitution de la pile dans le buffer
 
BcleBuffer:
	pop  ax
	add  al,30h	; conversion en ASCII
	stosb
	loop BcleBuffer
 
;--- Symbole '$' à la fin du buffer
	mov  al,'$'
	stosb
 
;========= Affichage des résultats =========
 
       	mov dx,offset msg1	; affichage de la valeur hexa
        mov ah,09H
        int 21h
 
        mov dx,offset msg	; affichage de la valeur décimale
        mov ah,09H
        int 21h 
 
 
;*************fin de programme**************
 
       mov ax,4c00h		; sortie avec code zéro
       int 21h
 
end

A ta disposition si tu souhaites avoir des précisions !

[stanlagtan]

Merci de ta reponse.
J'ai essaye ton code, il me donne une erreur, on me dit que le

shr al, 4

pose probleme. j'ai reessayé avec la boucle de mon code , il n'y a pas de probleme. cependant les resultats escomptés ne sont pas apparus, seulement des caracteres bizarres a la place ou devraient se trouver les valeurs hexa et decimales.

PS: le shr al, 4, pourquoi ca fonctionne pas, le

shl al, 4

fonctionne et le

shr ah,4

aussi.

[Invité]

Désolé pour ces approximations. L'impossibilité de tester moi-même m'empêche de livrer du travail propre.

Première erreur (et de taille...)
J'ai oublié que nous sommes en mémoire segmentée. De ce fait, il faut que le registre de segment ES soit égal à DS. Pour cela, mettre MOV ES,AX après le MOV DS,AX. Pourquoi cela ? Eh bien à cause de l'instruction STOSB qui copie le contenu de AL dans ES:[DI] puis incrémente ensuite automatiquement la valeur de DI. En ne fixant pas ES, l'adresse mémoire visée est... improbable.

Deuxième erreur
En l'absence de ma doc, je ne comprends pas bien l'erreur constatée sur SHR AL,4. Il y a plusieurs palliatifs :
1) faire comme tu l'as prévu mais ce n'est pas habituel bien que correct
2) faire MOV CL,4, puis SHR AL,CL (ce qui ressemble à ta formulation)
3) faire 4 SHR AL,1 successifs (configuration fréquemment employée par les programmeurs)

J'espère que ça marchera ainsi mais je reste à ta disposition en cas de problème supplémentaire.