Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

  1. #1
    Nouveau membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2016
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 24
    Localisation : Haïti

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : juin 2016
    Messages : 23
    Points : 28
    Points
    28

    Par défaut conversion ascii en hexa puis en decimal

    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.

  2. #2
    Nouveau membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2016
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 24
    Localisation : Haïti

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : juin 2016
    Messages : 23
    Points : 28
    Points
    28

    Par défaut

    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!

  3. #3
    Membre habitué

    Homme Profil pro
    Retraité
    Inscrit en
    mars 2015
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 68
    Localisation : France, Loiret (Centre)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : mars 2015
    Messages : 44
    Points : 170
    Points
    170

    Par défaut Version améliorée

    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 !

  4. #4
    Nouveau membre du Club
    Homme Profil pro
    Développeur informatique
    Inscrit en
    juin 2016
    Messages
    23
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 24
    Localisation : Haïti

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : juin 2016
    Messages : 23
    Points : 28
    Points
    28

    Par défaut

    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.

  5. #5
    Membre habitué

    Homme Profil pro
    Retraité
    Inscrit en
    mars 2015
    Messages
    44
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 68
    Localisation : France, Loiret (Centre)

    Informations professionnelles :
    Activité : Retraité

    Informations forums :
    Inscription : mars 2015
    Messages : 44
    Points : 170
    Points
    170

    Par défaut Quelques correctifs

    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.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Conversion Ascii vers Hexa
    Par Alckolo dans le forum C#
    Réponses: 4
    Dernier message: 14/11/2011, 12h20
  2. conversion ascii en hexa
    Par flo_987 dans le forum C++Builder
    Réponses: 1
    Dernier message: 21/05/2010, 15h34
  3. Conversion ASCII vers Hexa
    Par PtiBruno dans le forum C
    Réponses: 3
    Dernier message: 25/02/2008, 09h40
  4. conversion ascii to hexa
    Par Invité(e) dans le forum C
    Réponses: 16
    Dernier message: 30/03/2007, 10h11
  5. conversion : (Ascii en hexa) => nombre
    Par tut dans le forum C++
    Réponses: 3
    Dernier message: 21/04/2004, 14h44

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo