Programmation assembleur avec DEBUG

République Tunisienne
Ministère de l’Enseignement
Supérieur
Institut Supérieur des Etudes
Technologiques de Mahdia
Fascicule de Travaux Pratiques
Microprocesseurs
3ème niveau Informatique Industrielle
MOHAMED ALI KAMMOUN
Année Universitaire : 2006-2007
Version : 2.0
AVANT-PROPOS
Organisation des séances de travaux pratiques
Ce manuel rassemble une série d’exercices pratiques ayant pour but de permettre à l’étudiant
de mieux comprendre les implications pratiques de son cours de Microprocesseurs. L’accent y
est mis sur l’utilisation pratique du langage assembleur pour la conception de quelques
algorithmes simples tournants sur un microprocesseur de type i80x86. L’assembleur est en
effet un langage largement répandu depuis bien longtemps, et y reste aujourd’hui, autant dans
les universités que dans les centres de recherche et développement, ainsi que dans l’industrie.
L’ouvrage est divisé en 6 laboratoires. Les laboratoires ont pour objet de fournir aux étudiant
un certains nombres d’informations qui leurs sera utiles pour débuter leurs projets de fin
d’étude dont un nombre important est consacré à l’étude de des principes de programmation
en assembleur. Le but de ces TP est de stimuler l’intérêt de l’étudiant pour l’usage du langage
assembleur en traduisant quelques algorithmes classiques, à travers une démarche de synthèse
plutôt que par le biais de travaux d’analyse. Il ne s’agit donc pas ici d’illustrer le cours, mais
bien de le mettre en pratique.
Dans cette perspective, les laboratoires préparent l’étudiant à acquérir une certaine pratique de
manipuler le langage assembleur, en le dotant d’un ensemble d’outils : débogage, instructions,
manipulation des registres internes, adressages, etc.…. On y aborde donc les problèmes
suivants :
1. Débogage
2. Programmation assembleur simple avec l’environnement NASM
3. Programmation assembleur avancée : adressage
4. Programmation assembleur avancée : programmation graphique
5. Programmation avec l’environnement TASM
6. Pratique de l’assembleur pour la programmation de l’interface parallèle i8255
Appréciation du travail de l’étudiant
L’étudiant sera coté en fonction de son niveau de participation aux séances de laboratoires,
ainsi que de la qualité (fond et forme) de ses comptes-rendus. Ce rapport devra expliciter le
plus clairement possible :
• Les techniques utilisées : principe, structure, prévision des problèmes à résoudre pour
la mise en œuvre ;
• Les détails des modules implémentés sous la forme de fonctions ;
• Une analyse des résultats fournis.
Table des matières
TP N° 1 : PROGRAMMATION ASSEMBLEUR AVEC DEBUG ................................................................................. 2
I.
BUT DU TP.................................................................................................................................................. 2
II.
PRESENTATION DE DEBUG .................................................................................................................. 2
II.1. ASSEMBLEUR SUR PC AVEC DEBUG .......................................................................................................... 2
II.2. JEU D’INSTRUCTIONS DU PENTIUM .............................................................................................................. 2
III.
UTILISATION DU DEBUG.................................................................................................................. 3
IV.
EXERCICES ........................................................................................................................................... 4
TP N° 2 : PROGRAMMATION ASSEMBLEUR AVEC NASM.................................................................................... 6
I.
BUT DU TP.................................................................................................................................................. 6
II.
PRESENTATION DE NASM .................................................................................................................... 6
II.1. QU'EST CE QUE NASM ?.............................................................................................................................. 6
II.2. STRUCTURE D'UN PROGRAMME ASSEMBLEUR .............................................................................................. 6
II.3. EDITION D'UN PROGRAMME ......................................................................................................................... 6
II.4. DECLARATION DE VARIABLES DANS LE SEGMENT DE DONNEES ................................................................... 8
II.5. UTILISATION DES VARIABLES DANS LE PROGRAMME ................................................................................... 8
II.6. DEFINITION D'ETIQUETTES ........................................................................................................................... 8
III.
EXERCICES ........................................................................................................................................... 9
Exercice 1:..................................................................................................................................................... 9
Exercice 2: Utilisation de l'interruption $21 en mode 9................................................................................ 9
Exercice 3:..................................................................................................................................................... 9
TP N° 3 : PROGRAMMATION ASSEMBLEUR AVEC NASM : ADRESSAGE.......................................................... 11
I.
BUT DU TP................................................................................................................................................ 11
II.
RAPPELS................................................................................................................................................... 11
III.
EXERCICES ......................................................................................................................................... 11
Exercice 1:................................................................................................................................................... 11
Exercice 2:................................................................................................................................................... 11
Exercice 3:................................................................................................................................................... 11
Exercice 4: Tri d'un tableau ........................................................................................................................ 11
TP N° 4 : PROGRAMMATION ASSEMBLEUR GRAPHIQUE EN MODE MCGA..................................................... 14
I.
BUT DU TP................................................................................................................................................ 14
II.
PRESENTATION DU MODE MCGA .................................................................................................... 14
III.
ACCES AU MODE MCGA ................................................................................................................. 14
IV.
ACCES AUX PIXELS.......................................................................................................................... 14
V.
EXERCICES.............................................................................................................................................. 15
Exercice 1:................................................................................................................................................... 15
Exercice 2:................................................................................................................................................... 15
Exercice 3: (pour les meilleur(e)s) .............................................................................................................. 15
Exercice 4: (pour les meilleur(e)s des meilleur(e)s).................................................................................... 16
TP N° 5 : PROGRAMMATION ASSEMBLEUR AVEC TASM .................................................................................. 18
I.
BUT DU TP................................................................................................................................................ 18
II.
PRESENTATION DU TURBO ASSEMBLEUR ................................................................................... 18
III.
STRUCTURE D’UN PROGRAMME EN TASM ............................................................................. 18
IV.
EDITION ET EXECUTION D’UN PROGRAMME AVEC TASM................................................ 19
V.
EXERCICES.............................................................................................................................................. 20
Exercice 1:................................................................................................................................................... 20
Exercice 2:................................................................................................................................................... 20
Exercice 3:................................................................................................................................................... 20
Exercice 4 :.................................................................................................................................................. 20
TP N° 6 : PROGRAMMATION ASSEMBLEUR D’UNE INTERFACE D’ENTREE/SORTIE : LE I8255 .................. 22
I.
BUT DU TP................................................................................................................................................ 22
II.
PRESENTATION...................................................................................................................................... 22
III.
PPI 8255................................................................................................................................................. 22
III.1. FONCTIONS DES BROCHES ........................................................................................................................ 22
III.2. LE CONTROLE DES GROUPES ..................................................................................................................... 23
III.3. LA SELECTION DES MODES ....................................................................................................................... 23
IV.
MANIPULATION ................................................................................................................................ 25
IV.1. EXEMPLE DE PROGRAMMATION ............................................................................................................... 25
VI.2. PROGRAMMATION DE L’INTERFACE 8255................................................................................................. 26
ANNEXE ................................................................................................................................................................. 27
Programmation assembleur avec DEBUG
Objectifs :
L’objectif de cette manipulation est d’introduire les principes de la programmation
assembleur selon les instructions du 8086. On utilisera pour cela DEBUG comme outil pour
la création de quelques programmes simples en partant de l’architecture du 8086 et de la
manipulation simple des données à travers ses registres internes.
Matériels utilisés :
-
Un PC ou compatible.
Logiciels :
-
Microsoft Windows.
-
DEBUG.
Durée :
3H00mn
Med Ali KAMMOUN
Programmation assembleur avec DEBUG
TP N° 1 : Programmation Assembleur avec
DEBUG
I.But du TP
Se familiariser avec le langage assembleur sur PC avec DEBUG.
II.Présentation de DEBUG
II.1. Assembleur sur PC avec DEBUG
Le Pentium est le successeur du 80486 de la famille Intel. Il s’oriente vers les techniques des architectures RISC
(Reduced Instruction Set Computer). Il adopte des instructions simples câblées sur silicium, une architecture
superscalaire avec deux pipelines, il travaille en appliquant le concept des branchements prédictifs. Il fait appel à
des caches spécialisés instructions et données. Mais il est toujours un processeur CISC (Complexe Instruction
Set Computer.
Dans ce TP nous allons nous intéresser à l’utilisateur du DEBUG, un outil permettant de suivre de près
l’exécution d’un programme, et à mieux maîtriser l’architecture et le jeu d’instructions du Pentium.
II.2. Jeu d’instructions du Pentium
Le jeu d’instruction du Pentium dérive de ses prédécesseurs 40486 et le 80386. Ceci permet de garder la
compatibilité des systèmes. Nous citons ci-dessous les instructions les plus utilisées :
Code
Instructions de transfert
MOV
PUSH
POP
Instructions arithmétiques
ADD
INC
SUB
DEC
CMP
MUL
DIV
Instructions logiques
AND
OR
XOR
NOT
Instructions de branchement
conditionnel
JE
JNE
ISET Mahdia
Fonction
Exemple
signification
Déplacement
d’opérande
Chargement dans la
pile
Extraction de la pile
MOV AH,09
AH :=09
PUSH AX
Charger AX dans la pile
POP BX
Charger le sommet de la
pile dans BX
Addition
Incrémenter de 1
Soustraction
Décrémenter de 1
Comparaison
Multiplication
Division
ADD AX,3
INC AX
SUB CX,5
DEC AX
CMP CX,3
MUL AX,7
DIV AX,9
AX :=AX+3
AX :=AX+1
CX :=CX-5
AX :=AX-1
Comparer CX avec 3
ET logique
OU logique
OU exclusif
Inversion logique
AND AX,BX
OR AX,BX
XOR AX,BX
NOT AX
AX=AX and BX
AX =AX or BX
AX=AX xor BX
AX=not AX
Saut si égal
Saut si non égal
JE étiquette
JNE étiquette
Informatique Industrielle 3ème niveau
2
Med Ali KAMMOUN
Code
Branchement inconditionnel
et appel de procédures
JMP
LOOP
CALL
RET
Instructions
d’entrées/sorties
IN
OUT
Instructions pour adresses
LEA
Programmation assembleur avec DEBUG
Fonction
Exemple
signification
Branchement
inconditionnel
Boucle
JMP étiquette
IP :=étiquette si
branchement court
LOOP
étiquette
CALL proc
RET
Appel de procédures
Retour de procédure
IP :=adresse de procédure
IP :=adresse de retour
Entrée d’opérante
Sortie d’opérande
Charger l’adresse
effective
AX :=adresse de l’étiquette
III.Utilisation du DEBUG
On appelle DEBUG pour suivre l’exécution d’un programme déjà édité dans un fichier ou pour éditer un
nouveau programme. Pour appeler Debug, placez-vous sous DOS et tapez :
C:\>DEBUG
Tout programme chargé est placé en mémoire dans un segment approprié. Un déplacement de 100H par rapport
au début du segment indique l’adresse de départ. Il faut la mentionner au Debug.
C:\>DEBUG
-A 100
Debug sélectionne une adresse pour votre programme. Il l’affiche et lui ajoute votre déplacement.
Q1 : Quelle est l’adresse de segment choisie par votre Debug ?
Pour un segment d’adresse 21CB et un déplacement de 100, l’adresse réelle de la première instruction de votre
programme est égale (21CB0H+100H).
Q2 : Quelle est l’adresse du début de programme choisie par votre Debug ?
Pour éditer un programme on procède comme suit :
C:\>DEBUG
-A 100
21CB :0100 MOV DL,3F
21CB :0102 MOV AH,2
21CB:0104 INT 21H
21CB:0106 INT 20H
21CB:0108
Les deux instructions “MOV AH,2” et “INT 21H” permettent l’affichage du caractère dont le code ASCII est
stocké dans DL. Pour exécuter le programme on effectue :
-G
?
Fin normale du programme
Q3 : Ecrire un programme qui permet d’afficher le caractère A.
ISET Mahdia
Informatique Industrielle 3ème niveau
3
Med Ali KAMMOUN
Programmation assembleur avec DEBUG
Pour savoir le contenu d’une zone mémoire on utilise la commande U (Unassembler).
- U 100 107
21CB :0100 B23F MOV DL,3F
21CB :0102 B402 MOV AH,2
21CB:0104 CD21 INT 21H
21CB:0106 CD20 INT 20H
Q4 : Analyser et décoder les instructions MOV et INT.
Pour sauvegarder le travail effectué dans un fichier TP1.com, on utilise les commandes suivantes :
-N TP1.com
-R CX
CX 000
:8
-R BX
BX 000
:
-W
-Q
C:\>
Les deux registres CX et BX indiquent la taille du programme à sauvegarder. Dans ce cas il s’agit de 8 octets à
partir de l’adresse de départ (100).
Pour exécuter le programme on doit taper le nom du fichier :
C:\>TP1
?
C:\>
IV.Exercices
1.
Ecrire un programme « TP1-1.COM » qui affiche toutes les lettres minuscules.
2.
Ecrire un programme « TP1-2.COM » qui affiche toutes les lettres majuscules.
3.
Ecrire un programme « TP1-3.COM » qui affiche tous les chiffres de 0 à 9.
4.
Désassembler le programme « TP1-3.COM ».
5.
Afficher l’état des registres en utilisant la commande
-R
6.
Exécuter le programme pas par pas en utilisant la commande
-T
7.
Relancer l’exécution du programme en utilisant la commande
-G 100
8.
Lancer l’exécution d’une portion du programme en utilisant
-G=100 106
9.
Faire un vidage de la mémoire (DUMP) en utilisant la commande
-D 100
10.
Modifier la case mémoire d’adresse « xxxx :0101 »
-E 101
xxxx :0101 xx.41
11.
Faire un dump mémoire pour visualiser la date du BIOS
D F000 :FFF0
12.
Ecrire un programme qui affiche un message à l’écran.
ISET Mahdia
Informatique Industrielle 3ème niveau
4
Programmation assembleur avec NASM
Objectifs :
L’objectif de cette manipulation est de familiariser l’étudiant à l’environnement de
programmation assembleur NASMIDE. On utilisera cet outil pour créer des programmes
avancés basés surtout sur des instructions de branchement conditionnel et inconditionnel.
Matériels utilisés :
-
Un PC ou compatible.
Logiciels :
-
Microsoft Windows.
-
NASMIDE.
Durée :
3H00mn
Med Ali KAMMOUN
Programmation assembleur avec NASM
TP N° 2 : Programmation Assembleur avec
NASM
I. But du TP
Se familiariser avec assembleur freeware NASM associé à l'éditeur syntaxique NASMIDE.
II.Présentation de NASM
II.1. Qu'est ce que NASM ?
NASM (http://kent.dl.sourceforge.net/sourceforge/nasm/nsm09838.zip) est un assembleur 80x86 libre
d'utilisation. NASMIDE (http://www.inglenook.co.uk/rob/index.html ) est un environnement de développement
spécialement développé pour travailler avec NASM sous DOS. (Il existe également une version de NASMIDE
sous Windows permettant de développer des programmes en assembleur 32 bits).
II.2. Structure d'un programme assembleur
Un programme en assembleur commence en général par la définition des données puis ensuite par le code.
Il s'agit tout d'abord de préciser à l'assembleur si on va écrire du code 16 bits ou 32 bits. Dans notre cas, nous
générerons du code 16 bits en précisant la directive [BITS 16]. Il faut ensuite préciser l'adresse du programme
dans le segment de code en utilisant la directive [ORG 0x100]. (0x100 signifie que 100 est un nombre en
hexadécimal)
Ensuite, il faut préciser par [SEGMENT .data] que l'on va définir des variables et constantes dans le segment de
données.
La directive [SEGMENT .text] permet ensuite d'introduire les instructions du programme en langage
assembleur.
II.3. Edition d'un programme
Vérifier que les options suivantes sont configurées dans le menu options|assembler
ISET Mahdia
Informatique Industrielle 3ème niveau
6
Med Ali KAMMOUN
Programmation assembleur avec NASM
Vérifier que les options suivantes sont configurées dans le menu options|directories
Editer le programme qui affiche un caractère A à l'écran (le même celui du TP 1). (Attention, int 21
s'écrit maintenant int 0x21 ou int $21)
Appuyer sur la touche F2 pour sauver le programme.
Appuyer simultanément sur les touches alt + F9 pour assembler le programme.
Une fenêtre d'erreur doit normalement indiquer qu'aucune erreur n'est survenue.
-
Appuyer simultanément sur les touches Ctrl + F9 pour exécuter le programme.
ISET Mahdia
Informatique Industrielle 3ème niveau
7
Med Ali KAMMOUN
Programmation assembleur avec NASM
En résumé, attention au format des constantes numériques:
100
100h
0x100
$100
10000100b
Æ
Æ
Æ
Æ
Æ
décimal
hexadécimal
hexadécimal aussi
hexadécimal également mais le premier caractère doit être un chiffre
binaire
II.4. Déclaration de variables dans le segment de données
Il est possible de définir des variables de type caractère, chaîne de caractères, entier, entier long, réel,.. grâce à
des pseudo instructions.
Déclaration de variables entières de type octet: db
nb
db
$10
tab
db
1, 2 ,3 ,4 ,5 ,6 ,7 ,8 ,10
message
db
'bonjour les IUP GSI TI',13,10,'$'
(13 Æ retour chariot, 10 Æ ligne suivante, $ Æ fin de chaîne de caractères)
Déclaration de variables entières de type mot: dd
R
dd
1024
Déclaration de variables en virgule flottante: dd, dq, dt
A
B
C
D
pi
dd
dd
dd
dq
dt
1.2
1.e10
1.e+10
1.e-10
3.141592353589793238462
II.5. Utilisation des variables dans le programme
r
Exemple:
db
40
mov al, [r]
mov [r], cl
ÂIl est impossible d'affecter une variable directement à une autre variable, il faut obligatoirement passer
par un registre.
ÂIl est également impossible d'affecter une constante directement à une variable, il faut également passer
par un registre.
II.6. Définition d'étiquettes
Contrairement à DEBUG, il est possible de définir des étiquettes vers lesquelles certaines instructions pourraient
se brancher. Ceci évite le comptage laborieux des octets lorsqu'il s'agit de réaliser un saut dans le programme.
Une étiquette se déclare par un nom de taille inférieure à 8 caractères et se terminant par « : »
Exemple:
BOUCLE:
ISET Mahdia
ADD AX,CX
; Ax = Ax + Cx
.
.
.
JNE BOUCLE ; jump if not equal
Informatique Industrielle 3ème niveau
8
Med Ali KAMMOUN
Programmation assembleur avec NASM
III. Exercices
Exercice 1:
1)
Faire l'organigramme du programme qui calcule la somme des 11 premiers entiers
(0 + 1 + 2 +…+ 10 +11). Ecrire ensuite le programme en assembleur 8086. On utilisera pour cela l’instruction
MOV, CMP, JNE, ADD, DEC ou INC… On utilisera une variable R pour stocker le résultat et une variable N
pour stocker le nombre 11.
2)
Afficher ensuite le résultat à l'écran en utilisant l'interruption $21 puis déduire en fonction du caractère
affiché la valeur numérique du résultat.
3)
Même exercice mais en utilisant l'instruction LOOP
Exercice 2: Utilisation de l'interruption $21 en mode 9
L'interruption $21 avec ah à 9 permet d'afficher des chaînes de caractères qui se terminent par le caractère 13, 10
,'$'. (13 Æ retour chariot, 10 Æ ligne suivante, $ Æ fin de chaîne de caractères)
Pour cela, il faut définir un message avec la pseudo instruction db (voir explications de db) en terminant ce
message par 13, 10, '$'.
Il faut ensuite affecter au registre dx l'adresse de ce message (mov dx, mess où mess est le nom donné au
message).
Ecrire un programme qui affiche dix fois à l'écran le message suivant avec retour à la ligne et saut de ligne:
« Si je travaille bien en TP, je deviendrai un dieu de l'assembleur et le prof sera fier de moi »
Exercice 3:
Concevoir une application qui réalise le produit de deux nombres A = 100 et B = 170. Les nombres A et B sont
codés sur 8 bits chacun.
• Quelle instruction faut il utiliser ?
• Où se trouvent les opérandes ?
• Où se trouve le résultat de l'opération.
• Afficher les octets du registre contenant le résultat de l'opération.
• Déduire le résultat numérique à partir des caractères affichés.
Mêmes questions mais avec des nombres A et B de 16 bits. Prendre A = 1642 et B = 10.
Essayer avec A=3227 et B=5.
Comment apparaît le résultat ?
Comment faire pour que des caractères imprimables apparaissent tout le temps ?
ISET Mahdia
Informatique Industrielle 3ème niveau
9
Programmation assembleur avec NASM :
adressage
Objectifs :
L’objectif de ce T.P. est d’introduire les principes de la manipulation des données complexes
à travers des programmes assembleurs avancés. On utilisera pour cela NASMIDE comme
outil pour la création de quelques programmes basés sur le principe d’adressage « basé
indexé ». Ce principe sera utilisé pour manipuler les éléments des tableaux et des chaînes de
caractères. A la fin de cette manipulation, l’étudiant devra traduire un algorithme de tri que
l’on appliquera sur une chaîne de caractère.
Matériels utilisés :
-
Un PC ou compatible.
Logiciels :
-
Microsoft Windows.
-
NASMIDE.
Durée :
1ère partie : 3H00mn
2ème partie : 1H30mn
Med Ali KAMMOUN
Programmation assembleur avec NASM : adressage
TP N° 3 : Programmation Assembleur avec
NASM : adressage
I. But du TP
Maîtriser les différents types d'adressage, notamment pour accéder aux éléments de tableaux.
II.Rappels
Pour adresser les différents éléments d'un tableau, il faut utiliser l'adressage indexé basé en prenant le registre
BX comme base et le registre DI ou SI comme indexe. Pour mettre la base du tableau (déplacement du tableau
dans le segment de données) dans BX, il suffit d'écrire :
MOV BX, nom du tableau.
Ensuite l'adressage indexé basé s'utilise de la manière suivante:
MOV AL, [BX+SI]
; mettre le SI ème élément du tableau dans le registre AL
Où SI représente la position de l'élément du tableau que l'on veut atteindre.
III.Exercices
Exercice 1:
Soit le tableau suivant:
tab
db
5, 30, 20, 1,11, 8
Faire le somme des 6 éléments de ce tableau et mettre le résultat dans une variable S. Afficher le résultat à
l'écran, en déduire la valeur numérique.
Exercice 2:
Ecrire une application qui compte le nombre de lettres 'e' dans une phrase quelconque (50 caractères minimum)
se terminant par le caractère '$'.
- Représenter l'organigramme.
- Mettre le résultat dans le registre dl et ajouter 32.
Imprimer le caractère à l'écran et vérifier si le caractère qui apparaît est cohérent
Exercice 3:
Définir une chaîne de caractères de longueur au moins 50 caractères se terminant par '$'.
Réaliser une application (organigramme + programme) qui remplace toutes les lettres d'un type donné par un
autre type (par exemple tous les 'e' par des 'a').
On entrera les deux lettres au clavier en utilisant l'interruption 21,8.
Les saisies clavier seront précédées d'un message du type 'Remplacer:' et 'par:'
Exercice 4: Tri d'un tableau
Soit le tableau tab suivant:
Soit l'algorithme suivant:
ISET Mahdia
5, 8, 1, 7, 6
Informatique Industrielle 3ème niveau 11
Med Ali KAMMOUN
Programmation assembleur avec NASM : adressage
iÅ0
jÅ1
nÅ5
tant que i < n-1
tant que j <n
Si tab[i]>tab[j] alors Permuter(tab,i,j)
j = j +1
fin tant que
i = i+1
j = i+1
fin tant que
Appliquer l'algorithme suivant au tableau tab en remplissant le tableau d'état suivant:
Etape
i
j
tab[0]
tab[1]
tab[2]
tab[3]
tab[4]
Soit la chaîne de caractères suivante:
message db "le but de ce probleme est de trier par ordre croissant de code ASCII cette chaîne de caractere"
- Ecrire le programme qui tri par ordre croissant de code ASCII la chaîne précédente.
- On prendra SI pour l'index i et DI pour l'index j.
On affichera le résultat grâce à l'interruption $21, 9.
ISET Mahdia
Informatique Industrielle 3ème niveau 12
Programmation assembleur graphique en
mode MCGA
Objectifs :
L’objectif de cette manipulation est de présenter les principes de la programmation graphique
en utilisant le langage assembleur. A la fin de cette manipulation, l’étudiant sera capable de
produire des formes géométriques complexes, en manipulant directement la mémoire vidéo,
par des programmes en assembleur.
Matériels utilisés :
-
Un PC ou compatible.
Logiciels :
-
Microsoft Windows.
-
NASMIDE.
Durée :
6H00mn
Med Ali KAMMOUN
Programmation assembleur graphique en mode MCGA
TP N° 4 : Programmation Assembleur
Graphique en mode MCGA
I.But du TP
Programmer l'affichage en mode Graphique MCGA.
II.Présentation du mode MCGA
Le mode MCGA est un mode graphique créé par IBM. Sa particularité est de posséder 256 couleurs et une
définition de 320 pixels par 200 pixels. De ce fait, chaque pixel est représenté par un octet. La mémoire écran est
donc représentée par 320*200*1 octets contigus (64000).
320
318 319
0 1 2 3 4 5 6 7
. . . . . .
. . . . . .
.
.
320 321
200
III.Accès au mode MCGA
Pour accéder au mode MCGA, nous allons utiliser les interruptions logicielles du BIOS. L'interruption du BIOS
est l'interruption 0x10 et la fonction qui permet de choisir son mode vidéo est la fonction 0. Dans cette fonction
il faut préciser le mode vidéo que l'on désire. Le mode correspondant au MCGA est le mode 0x13.
En résumé pour activer le mode MCGA il faut:
- ahÅ 0
- al Å 0x13
- Appel de l'interruption 0x10
Pour se remettre en mode texte à la fin du programme, on utilisera le mode 0x03.
- ahÅ 0
- al Å 0x03
- Appel de l'interruption 0x10
IV.Accès aux pixels
Pour accéder à un pixel, il faut écrire dans la mémoire vidéo du mode MCGA. Cette mémoire vidéo commence
à l'adresse 0xa000 et s'étend sur 64000 octets.
Pour accéder à un pixel de coordonnées x, y, x ∈ 0,319 et y ∈ 0,199 il faut donc accéder à la mémoire
vidéo d'adresse y*320+x.
La couleur de ce pixel dépendra de l'octet que l'on écrira à l'adresse du pixel. La couleur associée à une valeur de
l'octet est définie dans une palette qu'il est également possible de modifier. Mais ceci est une autre histoire …
Pour écrire à l'adresse 0xA000 + déplacement, il faut utiliser l'extra segment ES associé à un déplacement
représenté par BX. On peut éventuellement ajouter à tout cela un déplacement fixe ou variable avec les registres
SI et DI.
[
ISET Mahdia
]
[
]
Informatique Industrielle 3ème niveau 14
Med Ali KAMMOUN
Programmation assembleur graphique en mode MCGA
Exemple:
mov ax,0xa000
mov es,ax
mov dl, 0xaa
mov bx, 160
mov [es:bx], dl
; on écrit à l'adresse 0xa000 + 160
ou
mov bx, 160
mov [es:bx + 320], dl
; on écrit à l'adresse 0xa000 + 160 +320
ou
mov bx, 160
mov si, 320
mov [es:bx + si], dl
; on écrit à l'adresse 0xa000 + 160 +320
ou
mov bx, 160
mov si, 320
mov [es:bx + si + 640], dl
; on écrit à l'adresse 0xa000 + 160 +320 +640
V.Exercices
Exercice 1:
-
Allumer le pixel de coordonnées (200,100) avec la couleur de code 0x32.
Allumer les 256 premiers pixels leur associant une couleur variant de 0 à 255.
Même question mais en augmentant l'épaisseur du trait (5 lignes).
Même question mais sur toute la hauteur de l'écran (cf figure suivante).
Exercice 2:
- Encadrer l'écran avec un cadre d'épaisseur 5 pixels de la couleur de votre choix
- Quadriller l'écran avec une ligne de 5 pixels d'épaisseur et un espacement de 10 pixels entre les lignes.
Exercice 3: (pour les meilleur(e)s)
- Ecrire un programme qui déplace un motif rectangulaire (8*6 pixels) en bas de la fenêtre de gauche Ædroite,
de droite Æ gauche, … tant qu'aucune touche n'est appuyée.
- L'affichage et l'effacement devront se faire avec un ou exclusif pour ne pas effacer ce qui se trouve
éventuellement déjà sur l'écran.
ISET Mahdia
Informatique Industrielle 3ème niveau 15
Med Ali KAMMOUN
Programmation assembleur graphique en mode MCGA
- Le test de l'appui d'une touche se fera en utilisant l'interruption 0x16 (voir annexe)
- Les variables à utiliser seront les suivantes:
- Entre chaque affichage, il est nécessaire (au moins sur les Pentiums) de générer une temporisation. Pour cela
on écrira un sous-programme de temporisation simple du type:
tempo:
tt:
mov cx,0xffff
nop
loop tt
ret
- Pour déplacer le motif vers la gauche ou vers la droite, on utilisera une variable delta qui prendra la valeur 1
ou –1 selon le sens du déplacement. Cette variable servira d'incrément pour afficher la position suivante du
motif.
- Il faudra tester si on arrive au niveau de la limite supérieure droite (320-L) pour donner à delta la valeur –1 et
tester la limite inférieure gauche (0) pour mettre delta à +1.
Exercice 4: (pour les meilleur(e)s des meilleur(e)s)
- Ecrire un Casse brique en assembleur 8086 (raquette + balle + briques).
Rq:
Vous pouvez utiliser: INT 16,1 - Get Keyboard Status
AH = 01
On return:
ZF = 0 if a key pressed (even Ctrl-Break)
AX = 0 if no scan code is available
AH = ~scan code~ ; AL = ASCII character or zero if special function key
ISET Mahdia
Informatique Industrielle 3ème niveau 16
Programmation assembleur avec TASM
Objectifs :
L’objectif de cette manipulation est d’introduire les principes de la programmation
assembleur selon la syntaxe TASM. On utilisera pour cela Turbo-ASM de Borland comme
outil pour la création de quelques programmes simples.
Matériels utilisés :
-
Un PC ou compatible.
Logiciels :
-
Microsoft Windows.
-
TASM.
Durée :
3H00mn
Med Ali KAMMOUN
Programmation assembleur avec TASM
TP N° 5 : Programmation Assembleur avec
TASM
I. But du TP
Programmer en langage assembleur avec Turbo ASM
II.Présentation du Turbo Assembleur
Turbo assembleur est un compilateur-assembleur qui transforme un fichier texte contenant des instructions
assembleurs (mnémoniques) en code binaire pour être exécuter sous un PC x86 (ou compatible).
Il faut donc éditer le fichier source dans l’éditeur de texte compris, sauvegarder, puis assembler (on dit assembler
plutôt que compiler ; mot réservée aux langages haut niveau comme le C ou Pascal). Une documentation
indépendante est à votre disposition sur Turbo ASM
III.Structure d’un programme en TASM
Comme dans tout programme le fichier source doit être saisi de manière rigoureuse. Chaque définition et chaque
instruction doivent ainsi s'écrire sur une nouvelle ligne (pour que l'assembleur puisse différencier les différentes
instructions) Le fichier source contient:
1. Un nom du programme sous TITLE sui vie d’un nom. Cette partie est facultative.
2. Une partie pour déclarer une pile qui est définie dans le segment de pile délimité par les directives
SEGMENT STACK et ENDS
3. Des définitions de données déclarées par des directives. Celles-ci sont regroupées dans le segment de données
délimité par les directives SEGMENT et ENDS
4. Puis sont placées les instructions (qui sont en quelque sorte le coeur du programme), la première devant être
précédée d'une étiquette, c'est-à-dire par un nom qu'on lui donne. Celles-ci sont regroupées dans le segment
d'instructions délimité par les directives SEGMENT et ENDS
5. Enfin, le fichier doit être terminé par la directive END suivi du nom de l'étiquette de la première instruction
(pour permettre au compilateur de connaître la première instruction à exécuter (Les points-virgules marquent le
début des commentaires, c'est-à-dire que tous les caractères situés à droite d'un point virgule seront ignorés)
Voici à quoi ressemble un fichier source (fichier .ASM):
TITLE nom_programme
Pile SEGMENT Stack;
Pile ENDS
DATA SEGMENT
; Déclarer ici les données
DATA ENDS
CODE SEGMENT
ASSUME DS:DATA,CS:CODE
DebutCode:
; Mettez ici le code de votre programme
CODE ENDS
ISET Mahdia
Informatique Industrielle 3ème niveau 18
Med Ali KAMMOUN
END
Programmation assembleur avec TASM
DebutCode
Exemple :
;***********************************
;* A F I C H A I N . A S M
*
;****************************TA 2.0*
TITLE AFICHAIN
Pile SEGMENT Stack;
Pile ENDS
Data SEGMENT
ChaineDonnees DB
'Ce texte est dans le segment des donnees.$'
Data ENDS
CODE SEGMENT
ASSUME DS:Data,CS:CODE
DebutCode:
mov
bx,Data
mov
ds,bx
;fait pointer DS sur le segment .DATA
mov
dx,OFFSET ChaineDonnees
;fait pointer DX sur le d‚placement de
;ChaineDonnees dans le segment .DATA
mov
ah,9
;fonction d'affichage de chaŒne du DOS
int
21h
;appel de la fonction
mov
ah,4ch
;fonction de d‚sactivation de programme
;du DOS
int
21h
;appel du DOS
CODE ENDS
END DebutCode
IV.Edition et exécution d’un programme avec TASM
L'algorithme pour la résolution du problème posé étant établi, la première étape consiste à créer le fichier
contenant le programme source en langage Assembleur en utilisant pour cela tout éditeur de texte: EDIT de
MS/DOS ou l'éditeur inclus dans le compilateur Pascal ou C, ... Ce fichier doit avoir l'extension .ASM. Pour
assembler ce programmer et en faire un module objet, il faut utiliser un assembleur: MASM de Microsoft ou
TASM de Borland.
Si le fichier source est TOTO.ASM, l'assembleur créera le fichier TOTO.OBJ, et optionnellement les fichiers
TOTO.LST et TOTO.CRF.
Le fichier TOTO.OBJ contient le code binaire du programme. Ce code n'est pas encore exécutable. Il le sera
après l'édition de liens.
La sortie du fichier TOTO.LST sur écran ou imprimante indique pour chaque ligne du programme source le code
généré, l'adresse relative des instructions ou de la zone mémoire générée et un message d'erreur
éventuellement.
A la fin de l'assemblage, l'assembleur affiche un message qui indique le nombre d'avertissements (WARNINGS)
qui pourraient donner un mauvais fonctionnement du programme et le nombre d'erreurs graves (SEVERE
ERRORS). Corriger les erreurs et refaire l'assemblage s'il y a lieu.
L'étape suivante est l'édition de liens que nous demandons en exécutant LINK TOTO. L'éditeur de liens crée le
fichier TOTO.EXE qui contient le module objet exécutable et le fichier TOTO.MAP qui contient la liste des
symboles globaux. On peut soumettre plusieurs modules objet en entrée de noms TOTO.OBJ, TITI.OBJ et
TATA.OBJ, en appelant l'éditeur de liens par LINK TOTO TITI TATA.
Enfin l'exécution du programme sera lancée en tapant TOTO (sous le contrôle de MS/DOS).
La mise au point du programme peut être faite à l'aide du programme de mise au point DEBUG en tapant
DEBUG TOTO.EXE. Il existe d'autres programmes de mise au point qui sont TurboDebugger fourni avec le
compilateur C, CodeView plus complets que DEBUG, mais ce dernier a l'avantage d'être fourni avec MS/DOS).
ISET Mahdia
Informatique Industrielle 3ème niveau 19
Med Ali KAMMOUN
Programmation assembleur avec TASM
V.Exercices
Exercice 1:
- Dressez l’organigramme d’un programme qui affiche le message ‘Salut tout le monde’ sur l’écran. Traduisez
l’organigramme en programme et vérifiez son bon fonctionnement.
- Modifier le programme précédant en affichant le même message 10 fois. Commencez par dresser
l’organigramme.
Exercice 2:
- Dressez l’organigramme d’un programme qui vous pose la question : « Somme-nous l’après midi ? » (O/N). Si
vous tapez ‘O’ il vous affiche « Bon après midi », sinon il vous affiche « Bonjour ».
- Traduisez l’organigramme en programme assembleur sous TASM.
Exercice 3:
- Dressez l’organigramme d’un programme qui lit un caractère minuscule au clavier et le convertit en
majuscule.
- Transformer l’organigramme en programme sous TASM.
Exercice 4 :
- Dressez l’organigramme d’un programme qui affiche la forme suivante
‘*
*’
**
**
*** ***
********
L’utilisation d’une boucle est obligatoire.
Transformer l’organigramme en programme sous TASM.
ISET Mahdia
Informatique Industrielle 3ème niveau 20
Programmation assembleur d’une interface
d’Entrée/Sortie : le i8255
Objectifs :
L’objectif de cette manipulation est de présenter à l’étudiant les principes de la
programmation de l’interface parallèle 8255. L’expérimentation porte sur un port parallèle
implémenté sur le Kit MTS-86C et est piloté par un 8255. Le rôle de l’étudiant est de
manipuler ce port en écrivant des codes en assembleur permettant de commander des diodes
ou recevoir des informations depuis des boutons poussoirs.
Matériels utilisés :
-
Le Kit MTS-86C.
-
Un PC ou compatible doté d’un port de communication série.
Logiciels :
-
Microsoft Windows
-
Hyper Terminal
Durée :
1ère étape : 3H00mn
Med Ali KAMMOUN
Programmation assembleur d’une interface d’Entrée/Sortie : le i8255
TP N° 6 : Programmation Assembleur d’une
interface d’Entrée/Sortie : le i8255
I.But du TP
Le but de cette manipulation est de se familiariser avec l’utilisation de l’interface de communication parallèle
8255 intégrée au système MTS-86C.
II.Présentation
Les échanges entre le microprocesseur et son environnement externe (clavier, écran, imprimante,…) se font à
l’aide de circuits d’interface appelés souvent « coupleurs d’Entrées/Sortie ». Ces échanges peuvent être effectués
en parallèle ou en série.
Dans le cadre de cette manipulation, nous allons utilisé un coupleur pour liaison parallèle de la famille 8200 de
Intel : il s’agit du PPI (Programmable Peripheral Interface) 8255.
III.PPI 8255
Le Intel 8255 est une interface programmable d’entrée/sortie destiné à l’utilisation avec les microprocesseurs
Intel. Elle possède 24 pins d’entrées/sorties programmable par deux groupes de 12 pins chacun et elle peut être
utilisée en 3 modes.
Dans le premier mode (MODE 0), chaque groupe de 12 pins peut être programmé par lot de 4 broches en entrée
ou en sortie. Dans le (MODE 1), le deuxième mode, chaque groupe peut être programmé de sorte que 8 lignes
soient configurées en entrées ou en sorties. Le troisième mode, (MODE 2), est un mode bidirectionnel où 8
lignes sont utilisées comme bus bidirectionnel.
III.1. Fonctions des broches
Data Bus Buffer
Ce bus bidirectionnel à 3 états est utilisé pour interfacer le 8255 au bus du système. Les données sont transmises
et reçues via le buffer suivant l’instruction de input ou de output générée par le microprocesseur. Le Control
Word et les informations de configuration sont aussi transmis via ce bus.
Read/Write et Control logic
La fonction de ce bloc est de gérer tous les transferts, internes et externes, des données, de contrôle ou du Status
Words.
__
CS
Cette broche, active à l’état bas, permet la communication entre le 8255 et le CPU.
__
RD
Cette broche, active à l’état bas, permet au 8255 de transférer les données ou les informations de configurations
au CPU via le data bus.
__
WR
ISET Mahdia
Informatique Industrielle 3ème niveau 22
Med Ali KAMMOUN
Programmation assembleur d’une interface d’Entrée/Sortie : le i8255
Cette broche, active à l’état bas, permet au microprocesseur d’envoyer des données ou le Control Words vers le
8255.
A0 et A1
Ces broches d’entrées, conjuguées aux broches WR et RD, contrôlent la sélection des ports (A, B ou C) ou du
registre du Control Word.
A1
A0
__
__
__
RD
WR
CS
Opérations d’Input (Lire)
0
0
0
1
0
Port A->Data Bus
0
1
0
1
0
Port B->Data Bus
1
0
0
1
0
Port C->Data Bus
Opérations d’Output (Ecrire)
0
0
1
0
0
Data Bus -> Port A
0
1
1
0
0
Data Bus -> Port B
1
0
1
0
0
Data Bus -> Port C
1
1
1
0
0
Data Bus -> Control
Fonctions de désactivation
x
x
x
x
1
Data Bus -> 3 états
1
1
0
1
0
Condition illégale
x
x
1
1
0
Data Bus -> 3 états
III.2. Le contrôle des groupes
Le CPU envoie un Control Word vers le 8255 pour configurer les ports. Le Control Word contient des
informations comme : le mode, le bit set, le bit reset, etc.…
Chaque bloc de contrôle (Groupe A et Groupe B) accepte les commandes depuis le Read/Write Control logic, et
reçoit le Control Word depuis le bus interne des données et envoie les commandes au port qui lui est associé.
Le Groupe A de Contrôle --- Port A et Port C (de poids fort) [C7-C4].
Le Groupe B de Contrôle --- Port B et Port C (de poids faible) [C3-C0].
III.3. La sélection des modes
Il existe 3 modes d’utilisation de l’interface 8255 : Le Mode 0, le Mode 1 et le Mode 2.
Quand l’entrée RESET est à l’état haut, tous les ports sont configurés en entrée. Si l’entrée RESET est
désactivée, l’interface 8255 garde son état (en entrée) sans aucune initialisation préalable.
Les modes des ports A et B peuvent être configurés séparément. Cependant le port C est divisé en deux groupes
configurés suivants les besoins des ports A et B.
ISET Mahdia
Informatique Industrielle 3ème niveau 23
Med Ali KAMMOUN
Programmation assembleur d’une interface d’Entrée/Sortie : le i8255
Format du Control Word en MODE 0
Format du Control Word en MODE 1
ISET Mahdia
Informatique Industrielle 3ème niveau 24
Med Ali KAMMOUN
Programmation assembleur d’une interface d’Entrée/Sortie : le i8255
Format du Control Word en MODE 2
IV.Manipulation
Le système MTS-86C dispose de 3 interfaces parallèles programmable 8255. L’interface n°3 (PPI-3) est utilisée
pour l’expérimentation et elle est connectée aux diodes et aux boutons SW suivant les schémas électroniques
disponible en annexe.
D’après ces schémas, le port A est donc connecté aux boutons SW et le port B est connecté aux diodes via les
circuits 74LS240.
IV.1. Exemple de programmation
Supposons que l’on veut écrire un programme en assembleur qui nous permet d’allumer la diode LED en
appuyant sur le bouton SW correspondant.
Le programme s’écrit alors comme suit :
CNT3 EQU 3FD6H; Assignation des adresses des ports
APORT3 EQU 3FD0H
BPORT3 EQU 3FD2H
CODE SEGMENT
ASSUME CS:CODE,DS:CODE
ORG 0
START : MOV SP,4000H
MOV AL,90H
MOV DX,CNT3
OUT DX,AL
ISET Mahdia
; Configuration du Stack Pointer
; Configuration du Control Word du 8255
;(Port A=Input, Port B et C=Output)
;Configuration du port de sortie
; Ecriture du Control Word
Informatique Industrielle 3ème niveau 25
Med Ali KAMMOUN
Programmation assembleur d’une interface d’Entrée/Sortie : le i8255
J1:
; Configuration du port d’entrée
; Faire entrer les données
; Inverser le signal
; Configuration du port de sortie
; Faire sortir les données
; Reboucler vers J1
MOV DX,APORT3
IN AL,DX
NOT AL
MOV DX,BPORT3
OUT DX,AL
JMP J1
CODE ENDS
END START
-Tester le bon fonctionnement du programme précédant sur la carte MTS-86C.
VI.2. Programmation de l’interface 8255
•
•
•
Ecrire un programme permettant d’allumer toutes les LEDS.
Ecrire un programme permettant d’afficher le nombre hexadécimal 95 sur les 8 LEDS.
Ecrire un programme permettant d’alterner l’allumage des diodes de droite à gauche en continu (On
allume les 4 diodes de droite puis de gauche et on reprend).
ISET Mahdia
Informatique Industrielle 3ème niveau 26
Med Ali KAMMOUN
Travaux pratiques Microprocesseurs
Annexe
ASCII Table (7-bit)
Decimal Octal Hex
Binaire
Valeur
--------------------------------------------------------------------------------------
063
077
03F 00111111
?
064
100
040 01000000
@
000
000
000 00000000
NUL
(Null char.)
065
101
041 01000001
A
001
001
001 00000001
SOH
(Start of Header)
066
102
042 01000010
B
002
002
002 00000010
STX
(Start of Text)
067
103
043 01000011
C
003
003
003 00000011
ETX
(End of Text)
068
104
044 01000100
D
004
004
004 00000100
EOT
(End of Transmission)
069
105
045 01000101
E
005
005
005 00000101
ENQ
(Enquiry)
070
106
046 01000110
F
006
006
006 00000110
ACK
(Acknowledgment)
071
107
047 01000111
G
007
007
007 00000111
BEL
(Bell)
072
110
048 01001000
H
008
010
008 00001000
BS
(Backspace)
073
111
049 01001001
I
009
011
009 00001001
HT
(Horizontal Tab)
074
112
04A 01001010
J
010
012
00A 00001010
LF
(Line Feed)
075
113
04B 01001011
K
011
013
00B 00001011
VT
(Vertical Tab)
076
114
04C 01001100
L
012
014
00C 00001100
FF
(Form Feed)
077
115
04D 01001101
M
013
015
00D 00001101
CR
(Carriage Return)
078
116
04E 01001110
N
014
016
00E 00001110
SO
(Serial In)(Shift Out)
079
117
04F 01001111
O
015
017
00F 00001111
SI
(Serial Out)(Shift Out)
080
120
050 01010000
P
016
020
010 00010000
DLE
(Data Link Escape)
081
121
051 01010001
Q
017
021
011 00010001
DC1 (XON) (Device Control 1)
082
122
052 01010010
R
018
022
012 00010010
DC2
083
123
053 01010011
S
019
023
013 00010011
DC3 (XOFF)(Device Control 3)
084
124
054 01010100
T
020
024
014 00010100
DC4
085
125
055 01010101
U
021
025
015 00010101
NAK
(Negative Acknowledgement)
086
126
056 01010110
V
022
026
016 00010110
SYN
(Synchronous Idle)
087
127
057 01011111
W
023
027
017 00010111
ETB
(End of Trans. Block)
088
130
058 01011000
X
024
030
018 00011000
CAN
025
031
019 00011001
EM
026
032
01A 00011010
SUB
027
033
01B 00011011
ESC
028
034
01C 00011100
FS
029
035
01D 00011101
GS
030
036
01E 00011110
031
037
01F 00011111
032
040
020 00100000
SP
033
041
021 00100001
!
034
042
022 00100010
035
043
036
(Device Control 2)
(Device Control 4)
(Cancel)
089
131
059 01011001
Y
090
132
05A 01011010
Z
(Substitute)
091
133
05B 01011011
[
(Escape)
092
134
05C 01011100
\
(File Separator)
093
135
05D 01011101
]
(Group Separator)
094
136
05E 01011110
^
RS
(Request to Send)
095
137
05F 01011111
_
US
(Unit Separator)
096
140
060 01100000
`
(Space)
097
141
061 01100001
a
098
142
062 01100010
b
"
099
143
063 01100011
c
023 00100011
#
100
144
064 01100100
d
044
024 00100100
$
101
145
065 01100101
e
037
045
025 00100101
%
102
146
066 01100110
f
038
046
026 00100110
&
103
147
067 01100111
g
039
047
027 00100111
'
104
150
068 01101000
h
040
050
028 00101000
(
105
151
069 01101001
i
041
051
029 00101001
)
106
152
06A 01101010
j
042
052
02A 00101010
*
107
153
06B 01101011
k
043
053
02B 00101011
+
108
154
06C 01101100
l
044
054
02C 00101100
,
109
155
06D 01101101
m
045
055
02D 00101101
-
110
156
06E 01101110
n
046
056
02E 00101110
.
111
157
06F 01101111
o
047
057
02F 00101111
/
112
160
070 01110000
p
048
060
030 00110000
0
113
161
071 01110001
q
049
061
031 00110001
1
114
162
072 01110010
r
050
062
032 00110010
2
115
163
073 01110011
s
051
063
033 00110011
3
116
164
074 01110100
t
052
064
034 00110100
4
117
165
075 01110101
u
053
065
035 00110101
5
118
166
076 01110110
v
054
066
036 00110110
6
119
167
077 01110111
w
055
067
037 00110111
7
120
170
078 01111000
x
056
070
038 00111000
8
121
171
079 01111001
y
057
071
039 00111001
9
122
172
07A 01111010
z
058
072
03A 00111010
:
123
173
07B 01111011
{
059
073
03B 00111011
;
124
174
07C 01111100
|
060
074
03C 00111100
<
125
175
07D 01111101
}
061
075
03D 00111101
=
126
176
07E 01111110
~
062
076
03E 00111110
>
127
177
07F 01111111
DEL
ISET Mahdia
(End of Medium)
Informatique Industrielle 3ème niveau 27