Exercice N°1 : Modes d'adressage

• Mov AX, 9 adressage immédiat

• Mov 9, AX impossible
• Mov AX, BX adressage de registre
• Mov AX, N1 adressage direct
• Mov AX, [BX] adressage direct
• Mov AX, [BX+2] adressage indexé

Exercice N°2 : Quelques programmes

1. Affichage de l'alphabet en majuscule

assume CS:Code
Code segment
main: mov DL,"A"
mov CX,26
mov AH,2
encore: int 21h
inc DL
Loop encore
mov ah,4Ch
int 21h
Code Ends
End main

2. Saisie et Affichage d'un caractère (caracter.asm)

assume CS:Code
Code segment
main: mov AH,1 ; saisie
int 21h ; le caractère lu arrive dans AL
mov DL, AL
mov AH,2 ; affichage
int 21h
mov ah,4Ch
int 21h
Code Ends
End main

3. Modifier le programme précédent pour qu'il fasse la saisie

et l'affichage tant que le caractère saisi est différent de ^d
(code ASCII 4)
assume CS:Code
Code segment
main: mov AH,1 ; saisie
int 21h ; le caractere lu arrive dans AL
Cmp AL, 4
JZ Fin ; si AL=4 alors Fini
mov DL, AL ; sinon :
mov AH,2 ; affichage
int 21h
jmp main ; et retour au debut
fin: mov ah,4Ch
int 21h
Code Ends
End main

4. Affichage d'un octet en binaire : afficher la valeur

contenue dans un registre 8 bits (BL).

L'idée est d'utiliser un masque BL AND 10000000 pour tester le

bit de gauche, et de décaler BL à gauche pour parcourir ainsi
tous les bits.
assume CS:Code
Code segment
main: mov BL, 10 ; on teste le programme avec BL=10
mov CX,8 ; compteur de boucle
masque: Test BL, 10000000b
JNZ bit1
bit0: Mov DL,"0"
jmp affiche
bit1: Mov DL,"1"
affiche: mov AH,2 ; affichage
int 21h
SHL BL,1
Loop masque
fin: mov ah,4Ch
int 21h
Code Ends
End main

5. Modifier le programme caracter.asm pour qu'il affiche (en

binaire) le code ASCII de
chaque caractère saisi.
assume CS:Code
Code segment
main: mov AH,1 ; saisie
int 21h ; le caractere lu arrive dans AL
Cmp AL, 4
JZ Fin ; si AL=4 alors Fini
mov BL, AL
mov CX,8 ; compteur de boucle
masque: Test BL, 10000000b
JNZ bit1
bit0: Mov DL,"0"
jmp affiche
bit1: Mov DL,"1"
affiche: mov AH,2 ; affichage d'un bit
int 21h
SHL BL,1
Loop masque ; fin de la boucle d'affichage des 8 bits
jmp main ; et retour au debut
fin: mov ah,4Ch
int 21h
Code Ends
End main

Exercice N°3 : Saisie au clavier d'un nombre décimal

Saisie au clavier d'un nombre décimal
Ecrire un programme qui lit un entier décimal au clavier et le
sauvegarde en mémoire dans
une variable de type octet N1. Pour cela, commencer par écrire
les programmes suivants :

1. Lire un caractère au clavier et tester si son code ASCII

est celui d'un chiffre. Si c'est le cas, ranger ce chiffre (et
non son code ASCII) dans N1, sinon afficher "N".
(oneread.asm)
1. Lire un caractère au clavier et tester si son code ASCII
est celui d'un chiffre. Si c'est le cas, ranger ce chiffre (et
non son code ASCII) dans N1, sinon afficher "N". (oneread.asm)
2. assume CS:Code
3. Code segment
4. main: mov AH,1 ; saisie
5. int 21h ; le caractere lu arrive dans AL
6. Cmp AL, "0"
7. JB pasbon ; si AL<"0" ce n'est pas un chiffre
8. Cmp AL,"9"
9. JA pasbon ; si AL>"9" ce n'est pas un chiffre
10. Sub AL,"0" ; sinon le chiffre= code ASCII-ASCII(0)
11. Mov N1, AL
12. jmp fin
13. pasbon: mov DL, "N"
14. mov AH,2 ; affichage de "N"
15. int 21h
16. fin: mov ah,4Ch
17. int 21h
18. Code Ends
End main
2. A partir du programme précédent, écrire un programme
(dixfois.asm) qui multiplie le nombre par 10 avant de le
ranger dans N1
Remplacer N1<- AL-"0" par N1<- (AL-"0")*10
Sub AL,"0" ; sinon le chiffre= code ASCII-ASCII(0)
SHL AL,1
Mov N1,AL
SHL AL,1
SHL AL,1
Add N1,AL

3. Ecrire maintenant un programme (numread.asm) qui lit un

nombre décimal au clavier et
le sauvegarde dans N1. La lecture s'arrête quand le caractère
lu n'est pas un chiffre (plus
besoin d'afficher "N"). On ne contrôlera pas le débordement de
capacité.
assume CS:Code, DS:Data
Data Segment
N1 db ?
Data Ends
Code segment
main: mov AX,Data
Mov DS,AX
Mov N1,0
lecture: mov AH,1 ; saisie
int 21h ; le caractere lu arrive dans AL
Cmp AL, "0"
JB fin
Cmp AL,"9"
JA fin
Sub AL,"0" ; sinon le chiffre= code ASCII-ASCII(0)
SHL N1,1 ; et N1 <- 10*N1 + AL
Mov BL,N1
SHL BL,1
SHL BL,1
Add N1,BL
Add N1,AL
jmp lecture
fin: mov ah,4Ch
int 21h
Code Ends
End main
Exercice N°4 : Parcours d'un tableau
Ecrire un programme (cherche.asm) qui parcourt un tableau
donné à la recherche d'un élément donné aussi à l'avance. (Le
programme sera ensuite testé sur un tableau de caractères, la
fin du tableau étant indiquée par un '$')
Pour cela, commencer par écrire les programmes suivants :

1. Parcours simple d'un tableau de caractère et affichage du

caractère correspondant
(parcours.asm).
1. Assume CS:Code, DS:Data ; version adressage direct
2. Data SEGMENT ; (version indexée entre
parenthèses)
3. C db "A"
4. Tab db "B","C","D","G","H","J","L","$"
5. Data ENDS
6.
7. Code SEGMENT
8. main : Mov AX, Data
9. Mov DS,AX
10. Mov AH, C
11. Mov SI, offset Tab ; (Mov SI, 0)
12. boucle: mov AH, [SI] ; (mov AH, Tab[SI])
13. cmp AH,"$"
14. je fin
15. aff: mov DL,AH
16. mov AH,2
17. int 21h
18. INC SI
19. jmp boucle
20. fin: Mov AH, 4Ch
21. Int 21h
22. Code ENDS
23. END main

2. Recherche d'un élément dans le tableau et affichage de

l'élément s'il est trouvé (rech-aff.asm)
1. Assume CS:Code, DS:Data
2. Data SEGMENT
3. C db "H"
4. Tab db "B","C","D","G","H","J","L","$"
5. Data ENDS
6. Code SEGMENT
7. main : Mov AX, Data
8. Mov DS,AX
9. Mov SI, 0
10. boucle: mov AH, Tab[SI]
11. cmp AH,"$"
12. je pas
13. aff: cmp AH,C
14. jne suite
15. mov DL,AH
16. mov AH,2
17. int 21h
18. jmp fini
19. suite: INC SI
20. jmp boucle
21. pas : mov DL,AH
22. mov AH,2