1ére Année Cycle ingénieur - ISA

COMPTE RENDU TRAVAUX PRATIQUES

Microprocesseurs
Electronique numérique

Encadré par :

Mr. EL ZERK Abdallah

Réalisé par :

TCHUENTE KOYOU CHRISTIAN JORDAN

ANNEE UNIVERSITAIRE 2021-2022

 TP MICROPROCESSEUR

TP1 : Initiation à l’assembleur et au EMU8086

I. Initiation à l’utilisation du logiciel EMU8086

Emu8086 est un émulateur visuel de microprocesseur d'Intel 8086. C’est un émulateur de codes
pour assembleurs. Le code peut être assemblé et exécuté sur l'émulateur en mode pas à pas, et
durant l'exécution on peut vérifier les registres, les drapeaux (flags) ainsi que les variables ou la
mémoire. Le programme peut aussi être exécuté et stoppé en tout temps. En plus de la
programmation bas-niveau, Emu8086 peut contrôler des dispositifs virtuels d'entrée/sortie.

1. Lancez l'environnement Emu8086 avec la Template « .com ».

2. Saisissez et exécutez le code suivant :

org 100h
MOV AX, 1234h
MOV BL, AH
MOV CL, AL
Ret
3. Pour exécuter le programme, cliquer sur emulate (ou appuyer sur F5).
4. Vous pouvez cliquer sur single step (ou appuyer sur F8) pour exécuter le
programme pas à pas.
5. Vous pouvez cliquer sur step back (ou appuyer sur F6) pour revenir en arrière.

2
TP MICROPROCESSEUR

6. Essayez, modifiez, expérimentez jusqu'à avoir les idées parfaitement claires sur le
fonctionnement de ce programme.

7. - Que fait l’instruction MOV ?

L’instruction MOV déplace une valeur d’un registre à un autre.

-Peut-on remplacer le registre CL par CX ?

Oui on peut remplacer, mais dans le cas de notre émulateur ça donne une erreur.

8. Que se passe-t-il si on enlève le ‘H’ après le 1234 ?

La valeur ou indice de AX sera affiché en décimale (par défaut) alors que le système la stocke
en hexadécimale.

9. Modifier le programme pour travailler uniquement avec des registres de 8bits.

org 100h
MOV AH, 12h
MOV AL, 34h
MOV BL, AH
MOV CL, AL
Ret

10. Ajouter l’instruction permettant de mettre le contenu de CL dans la case mémoire

d’adresse 200H.
org 100h
MOV AH, 12h
MOV AL, 34h

3
 TP MICROPROCESSEUR

MOV BL, AH
MOV CL, AL
MOV [200h], CL
Ret

II. Opérations Arithmétiques

Rechercher dans « l’aide » de ‘EMU8086’ l’instruction adéquate pour chacune des opérations
suivantes :

• Addition
• Soustraction
• Multiplication
• Division

1. Écrire quatre petits programmes pour tester chacune de ces instructions.

ADDITION SOUSTRACTION MULTIPLICATION DIVISION

Org 100h org 100h org 100h org 100h

Mov ax , 29h mov ax , 50h mov ax , 7h mov ax , 10h

Mov bx , 23h sub ax , 30h mov bx , 4h mov bx , 2h

Add bx , ax ret mul bx div bx

Ret ret ret

Pour avoir le résultat des différentes opérations, après écriture on appui sur emulate ensuite
sur single by step plusieurs fois.

Le résultat de la soustraction est situé dans la case AL et le résultat des autres opérations dans
la case BL

2. Modifier vos programmes pour faire les calculs sur des opérandes, écrits
manuellement dans les mémoires 200H et 210H, le résultat doit être enregistré
dans l’adresse 220H.

4
 TP MICROPROCESSEUR

Org 100h
Mov ax , 0h
Mov cx , 200h
Boucle:
Add ax , [cx]
Inc cx
Cmp cx , 209h
Jne Boucle
Ret .

3. Réécrire les programmes pour faire des calculs sur des opérandes de tailles 16bits.
ADDITION SOUSTRACTION MULTIPLICATION DIVISION
Org 100h org 100h org 100h org 100h
Mov ax , 0199h mov ax , 0150h mov ax , 07h mov ax , 80h
Mov bx , 7923h sub ax , 7930h mov bx , 14h mov bx , 9h
Add bx , ax ret mul bx div bx
Ret ret ret

4. Indiquer dans un tableau le type d’adressage effectué.

TP2. Instructions de branchement et boucles

I. La comparaison et les sauts

L’opérateur CMP (compare) soustrait la source de la destination. Le résultat n'est pas mis dans
la destination. En effet cette instruction modifie uniquement les indicateurs.

Syntaxe : CMP Destination, source

Les instructions de branchements les plus utilisées :

 JA (« Jump if Above ») fait un saut au label spécifié si et seulement si le résultat de

la comparaison est positif.
 JB (« Jump if Below ») fait un saut au label spécifié si et seulement si le résultat de
la comparaison est négatif.

5
TP MICROPROCESSEUR

 JMP (« Jump ») fait un saut inconditionnel à l’étiquette spécifiée.

Mettre deux valeurs quelconques dans les registres AL et AH.

1. Écrire un programme pour qu’AH se retrouve toujours avec le maximum des

deux valeurs, c'est-à-dire que :
• Si AH < AL on permute AH et AL (en utilisant XCHG)
• Si AH > AL le programme ne change rien

org 100h
MOV AL, 17h
MOV AH, 10h
CMP AL, AH
JA max
Ret
max:
XCHG AL, AH
ret

2. Écrire un programme permettant de comparer AH avec AL.

• Si AH < AL mettre son contenu dans la case mémoire d’adresse [200H]

• Si AH > AL mettre son contenu dans la case mémoire d’adresse [210H]

Org 100h
MOV AL, 6h
MOV AH, 10h
CMP AL, AH
JB comp:
MOV [200h], AH
Ret
Comp:
MOV [200h], AH

6
 TP MICROPROCESSEUR

ret
3. Dans les mêmes programmes, faite varier les différentes instructions de
branchement conditionnels.
4. Commenter et expliquer les instructions et les résultats des programmes.

II. Les boucles

Mettre des valeurs quelconques dans les cases mémoires entre [200H] et [210H].

1. Que fait l’instruction Loop ?

l’instruction loop fait tourner le programme le nombre de fois affecté au registre
2. Écrire un programme assembleur qui permet de calculer la moyenne des valeurs
des cases mémoires entre [200H…210H].
org ax , 0h
Mov bx , 200h
Mov cx , 01h
Boucle :
Add ax , [bx]
Inc bx
Inc cx
Cmp bx , 205h
Jne Boucle
Div cx
Ret

3. Écrire un programme assembleur qui permet de chercher la valeur minimale des

cases mémoires entre [200H…210H].
Dans notre cas on va s’arrêter à 205h
Org 100h
Mov [200h] , 03h
Mov [201h] , 04h
Mov [202h] , 05h
Mov [203h] , 06h

7
TP MICROPROCESSEUR

Mov [204h] , 07h

Mov [205h] , 08h
Mov bx , 200h
Mov ah , [200h]
T:
Cmp bx , 205h
Jb Boucle
Div cx
Ret

Boucle :
Cmp [bx] , ah
Jb min
Inc bx
Jmp T

Min :
Mov ah , [bx]
Inc bx
Jmp T

4. Écrire un programme assembleur qui permet de chercher la valeur maximale des

cases mémoires entre [200H…210H].
Org 100h
Mov [200h] , 03h
Mov [201h] , 04h
Mov [202h] , 05h
Mov [203h] , 06h
Mov [204h] , 07h
Mov [205h] , 08h
Mov bx , 200h
Mov ah , [200h]
T:
Cmp bx , 205h
Jb Boucle
Div cx
Ret

Boucle :
Cmp [bx] , ah
Ja min
Inc bx
Jmp T

Min :
8
 TP MICROPROCESSEUR

Mov ah , [bx]
Inc bx
Jmp T

5. Commenter et expliquer les instructions et les résultats des programmes.

TP3. Feu de circulation ‘Traffic lights’

I. Les procédures avec le langage Assembleur

Une procédure est une suite d'instructions effectuant une action précise. La notion de procédure
en assembleur correspond à celle de fonction en langage C, ou de sous-programme dans d'autres
langages. Comme il a été déjà mentionné, en plus de la programmation bas niveau, Emu8086
peut contrôler des dispositifs virtuels d'entrée/sortie. L’objectif de ce TP donc est de contrôler
un dispositif virtuel d'entrée/sortie « Traffic lights ou feu de signalisation ».

1. Rappeler la syntaxe d’une procédure avec le langage Assembleur.

nom_proc PROC

(…)
ret
nom_proc ENDP
2. Écrire 2 procédures de temporisation tempo1 et tempo2 tel que la durée de la
première est plus grande que la deuxième.
tempo1 PROC
MOV CX, 500h
boucle1:
NOP
LOOP boucle1
ret
tempo1 ENDP
tempo2 PROC

9
 TP MICROPROCESSEUR

MOV CX, 100h

boucle2:
NOP
LOOP boucle2
ret
tempo2 ENDP

II. Application : Traffic lights

Un ensemble de périphériques sont disponibles virtuellement sous emu8086. Sous le menu
Virtual Drive de Emulator on peut accéder aux ports qui contrôlent ces périphériques. Pour faire
fonctionner un périphérique, il suffit d’écrire une commande sur son port qui apparait sur
l’image virtuelle associée. Les modules de « Traffic Lights » sont contrôlés par l’envoie d’une
donnée au port I/O numéro 4. Il s’agit d’un périphérique composé de 12 lampes : 4 vertes, 4
oranges (jaunes) et 4 rouges. On peut agir sur l’état de chaque lampe par positionner le bit
associé :

• La lampe est allumée, bit associé=1

• La lampe est éteinte, bit associé=0

Pour contrôler le périphérique qui est composé de 12 lampes, on envoie alors un mot sur le port.
Seuls les bits 0 à 11 de ce mot sont utilisés par le port, les autres bits sont ignorés. La situation
du périphérique indiquée sur la figure en dessus est obtenue avec l’envoie du code suivant sur
le port 4.

mov ax, 0000001100001100b

out 4, ax
1. Écrire un programme permettant de clignoter toutes les lampes jaunes du feu de
signalisation (mode nuit).
Org 100h
cmp bx,00h
je MODENUIT
JNE MODEJOUR
JMP MODEJOUR

MODENUIT:
mov ax,0000010010010010b
out 4,ax

10
 TP MICROPROCESSEUR

call tempo3

mov ax,0000000000000000b
out 4,ax
call tempo3

cmp bx,00h
je MODENUIT
JNE MODEJOUR
JMP MODENUIT

tempo3 PROC (temps tempo3 mode nuit)

mov cx,10h
boucle3:
dec cx
cmp cx,00h
jne boucle3
ret
tempo3 endp

ret

2. En utilisant les procédures de temporisation, écrire un programme assembleur

reflétant le fonctionnement réel des feux de circulation pendant la journée (mode
jour).
Org 100h
CMP bx,00h
je MODENUIT
jne MODEJOUR

MODEJOUR:
mov ax,0000001100001100b;allumer vert v et rouge H
out 4,ax
call tempo1 ;Temporisation(voir fin)

mov dh,05h ;Nbre de clitonage

clignoter1:
mov ax,0000001010001010b;allumer jaune
out 4,ax
call tempo2 ;Temporisation(voir fin)

mov ax,0000001000001000b;eteindre jaune

out 4,ax
call tempo2
DEC dh
CMP dh,00h
jne clignoter1 ;condition fin clignoter

11
TP MICROPROCESSEUR

mov ax,0000100001100001b;allumer vert H et rouge V

out 4,ax
call tempo1

mov dh,05h ;Nbre de clitonage

clignoter2:
mov ax,0000010001010001b;allumer jaune
out 4,ax
call tempo2

mov ax,0000000001000001b;eteindre jaune

out 4,ax
call tempo2
DEC dh
CMP dh,00h
jne clignoter2 ;condition fin clignoter2

cmp bx,00h
je MODENUIT
JNE MODEJOUR
JMP MODEJOUR

tempo1 proc
mov dl,3Ch ;temps tempo1 (3C-60 EN Decimal )
boucle1:
dec dl
cmp dl,00h
jne boucle1
ret
tempo1 endp
tempo2 proc
mov dl,1Eh ;temps tempo2 (1E-30 EN Decimal )
boucle2:
dec dl
cmp dl,00h
jne boucle2
ret

tempo2 endp

ret

12
 TP MICROPROCESSEUR

TP4. Contrôle d’un périphérique d’E/S : Robot

I. Introduction et cahier de charge du fonctionnement

Le robot est contrôlé en envoyant des données au port d'entrées / sorties 9.

Les valeurs qui peuvent être envoyées sont résumées dans le tableau suivant :
Valeur décimal Valeur binaire Action
0 00000000 Ne rien faire
1 00000001 Avancer
2 00000010 Tourner à gauche
3 00000011 Tourner à droite
4 00000100 Examiner*
5 00000101 Allumer la lampe
6 00000110 Eteindre la lampe

(*) : Examiner un objet (obstacle) en utilisant un capteur. Lorsque le robot termine cette tâche,
le résultat est mis dans le registre ‘data’ et le bit 0 du registre statuts est mis à 1.

Le second port (port 10) est un registre de données ‘data’. Ce registre est mis à jour après que
le robot ait terminé l’examen de l’obstacle :

13
 TP MICROPROCESSEUR

Valeur décimale Valeur binaire Type d’obstacle

255 11111111 Mur
0 00000000 Rien
7 00000111 Lampe allumée

8 00001000 Lampe éteinte

Le port 11 est un registre d'état. On lit les valeurs de ce port pour déterminer l'état du robot.
Chaque bit de ce robot a une propriété spécifique :
Numéro de bit Description
0 0 lorsqu'il n'y a pas de nouvelles données dans le registre de
données, 1 quand il y a de nouvelles données dans le registre de
données.

1 0 lorsque le robot est prêt pour la commande suivante, 1 lorsque

le Robot est occupé (en train d’effectuer une tâche).

2 0 lorsqu'il n'y a pas d'erreur lors de l'exécution de la dernière

commande, 1 lorsqu'il y a une erreur sur l'exécution de la
commande (lorsque le robot ne peut pas terminer la tâche :
déplacer, tourner, examiner, allumer / éteindre la lampe).

II. Travail demandé

1. En se référant à ce qui a été précédemment expliqué, écrire des procédures pour
les différentes actions et taches à exécuter par le robot (avancer, tourner,
examiner, allumer lampe, éteindre lampe, …).
AV proc ;Procédure d'avancer le robot
mov ax,0h
out 9,ax
mov ax,00000001b
out 9,ax
ret
AV endp

TG proc ;Procédure de tourner le robot à gauche

mov ax,0h
out 9,ax
mov ax,00000010b
out 9,ax
ret

14
TP MICROPROCESSEUR

TG endp

TD proc ;Procédure de tourner le robot à droite

mov ax,0h
out 9,ax
mov ax,00000011b
out 9,ax
ret
TD endp

Ex proc ;Procédure d'examiner le robot

mov ax,0h
out 9,ax
mov ax,00000100b
out 9,ax
ret
Ex endp

NRF PROC procédure pour ne rien faire

mov ax,00000000b
out 9, ax
ret
NRF endp

On proc ;Procédure d'allumer la lampe

mov ax,0h
out 9,ax
mov ax,00000111b
out 9,ax
ret
On endp

Off proc ;Procédure d'éteindre la lampe

mov ax,0h
out 9,ax
mov ax,00001000b
out 9,ax
ret
Off endp

2. On se propose de contrôler le robot comme suit :

• Examiner l’environnement • Avancer s’il n’y a pas d’obstacle

• S’il y a obstacle :
 Mur, tourner à droite.

15
 TP MICROPROCESSEUR

 Lampe éteinte, allumer la lampe et tourner à gauche.

 Lampe allumée, éteindre la lampe et tourner à gauche.
• Reprendre le cycle.

3. Donner l’organigramme général reflétant le fonctionnement.

4. Ecrire un code assembleur permettant de contrôler le robot selon le

fonctionnement proposé.

org 100h

Test1: ;examine s'il y a un mur et ensuite tourne à droite

call Ex
in ax,10
cmp al,255
je tdd
jmp Test2

Test2: ; examine s'il est devant la lampe éteinte ou allumée et il l’allume ou l’éteint
call Test3 ;ensuite il tourne à gauche
in ax,10
cmp al,8
je onn
jmp offf
ret

Test3:
in ax,10
cmp al,0
je avv
ret

onn: ;l’étiquette pour allumer une lampe puis tourner à gauche

call On
call TG
jmp Test2

offf: ;l’étiquette pour éteindre une lampe puis tourner à gauche

call Off
call TG
jmp Test2

avv: ; l’étiquette pour avancer

16
 TP MICROPROCESSEUR

Call AV
jmp Test1

tdd: l’étiquette pour tourner à droite

Call TD
jmp Test1

ret

17