RAPPORT DES TRAVEAUX PRATIQUES SUR

LA PROGRAMMATION EN ASSEMBLEUR

Département :
Génie électrique
Filière :
Génie électrique et énergie renouvelable

TP1
Premier programme expérimental

Réalisé Par : Encadré Par :

▪ Hamza ELALOUANI ▪ A. RAIHANI

Année Universitaire 2023 – 2024

1
Table des matières :

I. Introduction ......................................................................................................................... 3
II. Objectifs du TP : ................................................................................................................. 3
III. Programme 1 : ................................................................................................................. 4
1. Programme simple : ........................................................................................................ 4
2. Programme optimisé : ..................................................................................................... 5
IV. Programme 3 : ................................................................................................................. 7
1. Exercices : ....................................................................................................................... 7
A. Affichage d’un caractère : ........................................................................................... 7
B. Affichage du caractère saisi :....................................................................................... 7
C. Affichage d’une chaine de caractères : ........................................................................ 8
D. Afficher chaine de caractères saisie : .......................................................................... 8
E. Inverse d’une chaine : .................................................................................................. 9
2. Applications : ................................................................................................................ 10
A. Application 1 : ........................................................................................................... 10
B. Application 2 : ........................................................................................................... 11
V. Conclusion :...................................................................................................................... 13

2
 I. Introduction
Ce TP, nous dédié à la programmation en assembleur. Dans le vaste paysage des langages
de programmation, l'assembleur se distingue en offrant un contrôle direct sur le
fonctionnement des processeurs. Ce langage bas niveau requiert une compréhension
approfondie du matériel informatique et nous permet de manipuler les ressources avec une
précision extrême.

Ce cours nous plongera dans les subtilités de l'assembleur, nous permettant de comprendre
comment les instructions sont exécutées par un processeur. Nous explorerons la syntaxe
concise et puissante de ce langage, les différentes opérations qu'il offre pour manipuler les
données, ainsi que les mécanismes de contrôle du flux d'exécution du programme.

À la fin de ce TP, nous serons en mesure de traduire des instructions simples en langage
assembleur, de saisir comment les données sont traitées au niveau le plus fondamental, et
d'appréhender les défis et les opportunités offerts par cette approche de programmation.
Objectifs du TP :
À la fin de ce TP, nous serons en mesure de comprendre et d'écrire des programmes simples
en langage assembleur, d'appréhender le fonctionnement du processeur à un niveau plus
proche du matériel, et de saisir l'importance cruciale de l'efficacité dans ce paradigme de
programmation.

Dans ce TP, nous avons réalisé les activités suivantes :

Présentation théorique : Nous avons commencé par une brève introduction sur le langage
assembleur, expliquant son fonctionnement et son utilisation dans le contrôle des
microprocesseurs.
Syntaxe et structure : Nous avons exploré la syntaxe de base du langage assembleur et
compris comment les instructions sont organisées.
Manipulation des données : Nous avons étudié les opérations de base pour manipuler les
données en assembleur, telles que les opérations arithmétiques et logiques.
Exercices pratiques : Des exercices pratiques ont été réalisés pour nous permettre
d'appliquer les concepts étudiés, résoudre des problèmes concrets et consolider notre
compréhension.

3
II. Programme 1 :

1. Programme simple :

Passons alors aux instructions, qui vont nous permettre d’additionner 5+3. Dans cet
exemple, nous allons travailler avec le registre de 8 bits noté DL : c’est l’octet de faible poids
du registre DX, ce dernier comprenant DH et DL). Nous l’avons choisi pour des commodités
d’affichage que nous vous expliquerons plus avant. On va ainsi :
 D’abord, loger la valeur 5 dans DL par l'instruction MOVE.
 Puis, additionner 3 au contenu de DL, qui était de 5. Le résultat sera bien
évidemment de 8, toujours dans DL.

Tout cela mène au programme ultrasimple suivant :

Code simple d’addition et affichage

Résultat du programme

4
 On voir que le contenu de l’octet DL est 56 en Décimal et on sait que 56 en décimale est
équivalent à 8 en ASCII

Code décimale vers ASCII

2. Programme optimisé :

Code avec segments

Contenu AX Contenu DX Résultat de somme

5
On voir qu’on a chargé 4C dans AH pour terminer le programme puis on charge la valeur de
nombre en AL et ajoutant la valeur de plus en a AL puis en met AL dans somme et somme
dans DL puis en faire une interruption pour l’affichage et on observe que AL et DL ont la
même valeur 56 Décimale équivalent a 8 en ASCII

Figure 9 : Résultat après le changement

Dans le programme précédant on a utilisé la somme avec 48 pour avoir la valeur décimale on
ASCII de la valeur, on a 9+5 = 12 si on ajoute 48 a 12 nous donne 60 ce qui équivalent a < on
ASCII
Pour résoudre ce problème on peut décaler et puis afficher les résultats.
On utilise ce code pour le teste de cette méthode :

Code de décalage

Résultat

6
III. Programme 3 :

1. Exercices :
A. Affichage d’un caractère :

Code affichage d’un caractère

B. Affichage du caractère saisi :

Résultat

Code d’affichage d’un caractère

7
C. Affichage d’une chaine de caractères :

Code pour Afficher une chaine de caractères

D. Afficher chaine de caractères saisie :

Code d’affichage d’une chaine saisie

8
 Résultat

E. Inverse d’une chaine :

Code d’affichage d’une chaine inverse

Résultat

9
 TEST

2. Applications :
A. Application 1 :
Ce code lit un caractère depuis l'entrée standard, teste si le caractère est un chiffre en
comparant son code ASCII avec les codes ASCII des chiffres ('0' à '9'). Si c'est un chiffre, il le
stocke dans la variable N1. Sinon, il affiche "N".

Code d’analyse de code ASCII

10
 Résultat

On voir lorsque on saisit un chiffre le programme stock ce chiffre dans BL ou on a notre

variable N1

Maintenant on voir que lorsque la saisie d’un caractère le programme stock le code ASCII du
caractère dans BL et puis afficher la lettre N pour nous informer que le code ASCII du
caractère saisi est différé de code de 0 à 9.
B. Application 2 :
Ce code lit les caractères saisis au clavier jusqu'à ce qu'un caractère non numérique soit entré
(par exemple, un retour à la ligne). Il convertit ensuite les caractères saisis en un nombre
décimal et stocke ce nombre dans la variable N1.

11
On observe que le dernier chiffre saisi est le bit stocker dans BL ce qui corresponde à la
variable N1

12
IV. Lorsque nous saisissons un caractère différent de 0 à 9, nous remarquons que le
programme interrompt la lecture et affiche "N" pour indiquer que nous avons saisi un
caractère, même si le dernier chiffre saisi est encore stocké dans N1.

V. Conclusion :
Ce TP sur l'assembleur nous a permis de comprendre et d'écrire des programmes simples en
assembleur, d'explorer le fonctionnement interne des processeurs et de manipuler
efficacement les ressources informatiques. Nous avons étudié la syntaxe, la structure et les
opérations de base de l'assembleur, et avons consolidé notre apprentissage par le biais
d'exercices pratiques. À la fin de ce TP, nous avons acquis la capacité de traduire des
instructions en assembleur, de comprendre le traitement des données au niveau matériel et
d'apprécier les avantages et les défis de cette approche de programmation.

13