Exercice N1 : Modes d'adressage

Mov
Mov
Mov
Mov
Mov
Mov

AX, 9 adressage immdiat

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

Exercice N2 : 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 caractre (caracter.asm)
assume CS:Code
Code segment
main: mov AH,1 ; saisie
int 21h ; le caractre 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 prcdent pour qu'il fasse la saisie
et l'affichage tant que le caractre saisi est diffrent 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'ide est d'utiliser un masque BL AND 10000000 pour tester le
bit de gauche, et de dcaler 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 caractre 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 N3 : Saisie au clavier d'un nombre dcimal
Saisie au clavier d'un nombre dcimal
Ecrire un programme qui lit un entier dcimal au clavier et le
sauvegarde en mmoire dans
une variable de type octet N1. Pour cela, commencer par crire
les programmes suivants :
1. Lire un caractre 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 caractre 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 prcdent, 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 dcimal au clavier et
le sauvegarde dans N1. La lecture s'arrte quand le caractre
lu n'est pas un chiffre (plus
besoin d'afficher "N"). On ne contrlera pas le dbordement 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 N4 : Parcours d'un tableau

Ecrire un programme (cherche.asm) qui parcourt un tableau
donn la recherche d'un lment donn aussi l'avance. (Le
programme sera ensuite test sur un tableau de caractres, la
fin du tableau tant indique par un '$')
Pour cela, commencer par crire les programmes suivants :
1. Parcours simple d'un tableau de caractre et affichage du
caractre correspondant
(parcours.asm).
1. Assume CS:Code, DS:Data ; version adressage direct
2. Data SEGMENT ; (version indexe entre
parenthses)
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 lment dans le tableau et affichage de
l'lment 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