P Et C, Une Introductionx

µP ET µC : UNE INTRODUCTION
1 OBJET DE CE DOCUMENT ............................................................................................. 6

2 MICROPROCESSEUR ET SYSTEME A MICROPROCESSEUR ....................................... 6
2.1 Généralités .................................................................................................................................. 6
2.1.1 Microprocesseur ou µP .................................................................................................................. 6
2.1.2 Système à µP..................................................................................................................................... 6
2.1.3 Microprocesseur (µP) / microcontrôleur (µC) .......................................................................... 7
2.2 Acquisition, restitution de l’information : entrées/sorties (E/S) d’un système à µP .......... 8
3 PRINCIPE DE FONCTIONNEMENT D’UN SYSTEME A µP ........................................... 8
3.1 Instruction, programme ............................................................................................................. 8
3.2 Exécution du programme .......................................................................................................... 9
4 FLUX DE CONCEPTION ................................................................................................ 10
4.1 Obtention du code binaire ...................................................................................................... 10
Traducteur .............................................................................................................................................................. 10
Assembleur (Assembler en anglais) ................................................................................................................. 10
Compilateur ........................................................................................................................................................... 11
4.2 Essais / Mise au point............................................................................................................... 11
4.2.1 Essais matériels : Solution à émulateur .....................................................................................11
4.2.2 Essais matériels : Autres solutions ..............................................................................................12
4.3 Programmation ......................................................................................................................... 12
5 STRUCTURE D’UN SYSTEME MINIMUM A µP ........................................................... 12
5.1 Les constituants d’un système minimum à µP ...................................................................... 12
5.2 Les 2 architectures d’un système à µP ................................................................................... 13
6 SYSTEME MINIMUM A ARCHITECTURE VON NEUMAN ......................................... 14
6.1 Structure d’un système minimum .......................................................................................... 14
6.2 Fonctionnement simplifié du système minimum.................................................................. 15
6.2.1 Addition ...........................................................................................................................................15
Recherche de l’instruction ................................................................................................................................. 15
Exécution de l’instruction ................................................................................................................................... 16
Calcul de l’adresse de l’instruction suivante .................................................................................................. 16
6.2.2 Transfert d’une donnée du µP vers l’extérieur ........................................................................16
Exécution de l’instruction ................................................................................................................................... 17
Calcul de l’adresse de l’instruction suivante .................................................................................................. 18
6.2.3 Saut à une adresse.........................................................................................................................19
Exécution de l’instruction et calcul de l’adresse de l’instruction suivante .............................................. 19
7 SYSTEME MINIMUM A ARCHITECTURE HARVARD .................................................. 19
7.1 Structure d'un système minimum ........................................................................................... 19
7.2 Fonctionnement simplifié ........................................................................................................ 20
7.2.1 Transfert de la constante dans le registre W ...........................................................................20
7.2.2 Transfert constante / exécution -- Addition / Recherche du code .....................................21
7.2.3 Addition / Exécution -- Transfert / Recherche du code ......................................................22
µP et µC : une introduction P. Morenton 09/10/09 1

7.2.4 Transfert / Exécution – Saut / Recherche du code ................................................................22
7.2.5 Saut / Exécution .............................................................................................................................23
8 ÉLEMENTS DE LA STRUCTURE INTERNE D’UN MICROPROCESSEUR .................... 23
8.1 Organisation interne simplifiée d’un µP ............................................................................... 23
8.2 Unité Arithmétique et Logique (UAL) et registres associés ................................................ 24
8.2.1 Rôle de l’UAL..................................................................................................................................24
8.2.2 Résultat de la dernière opération / Bits d’état ........................................................................25
8.2.3 Opérande(s) et résultat de l’opération / REgistres Associés ................................................25
8.2.4 Exemples de fonctionnement d’UAL d’un µP Motorola.......................................................25
Addition .................................................................................................................................................................. 26
Décalage sur un mot binaire ............................................................................................................................. 26
8.3 Séquenceur ................................................................................................................................ 26
8.3.1 Horloge du séquenceur ...............................................................................................................27
8.3.2 durée d’exécution d’une instruction / Cycle machine..........................................................27
8.3.3 Exemple de décomposition en cycle machine .......................................................................27
1er cycle machine ................................................................................................................................................ 28
2ème cycle machine............................................................................................................................................ 28
8.4 Quelques registres .................................................................................................................... 29
Registre d’adresse ................................................................................................................................................ 29
Compteur Ordinal (CO) ..................................................................................................................................... 29
Registre Instruction (RI)....................................................................................................................................... 30
9 LES INSTRUCTIONS ET LES MODES D’ADRESSAGE ................................................. 30
9.1 Catégories d’instructions ......................................................................................................... 30
9.2 Nombres d’opérandes .............................................................................................................. 30
9.3 Jeux d’instructions reduit / etendu ......................................................................................... 31
9.4 Format des instructions............................................................................................................ 31
9.5 Modes d’adressage ................................................................................................................... 32
9.5.1 Écriture des instructions et des modes d’adressage langage d'assemblage .....................33
9.5.2 Quelques exemples de modes d’adressage ............................................................................33
Adressage inhérent ou implicite ...................................................................................................................... 33
Adressage immédiat ............................................................................................................................................ 34
Adressage relatif ................................................................................................................................................... 34
Adressage indexé et utilisation de tableau ..................................................................................................... 34
Adressage étendu (Motorola) ........................................................................................................................... 34
Adressage registre (Intel) .................................................................................................................................... 35
10 DEROULEMENT D’UN PROGRAMME ...................................................................... 35
10.1 La pile et le déroulement d’un programme ........................................................................ 35
10.2 Déroulement normal.............................................................................................................. 37
10.2.1 Déroulement simplifié lors de l’appel d’un sous programme ...........................................37
10.2.2 Déroulement détaillé ..................................................................................................................38
10.2.3 Écriture et appel de sous programme dans le programme source ..................................38
10.3 Interruption ............................................................................................................................. 38
10.3.1 Présentation ..................................................................................................................................38
10.3.2 Déroulement Simplifié d’une procédure d’interruption .....................................................40
10.3.3 Déroulement détaillé ..................................................................................................................40
10.3.4 identification des sources d’interruption ...............................................................................41
10.3.5 Prise en compte des interruptions...........................................................................................42
10.3.6 Traitement des interruptions / Imbrication des interruptions ...........................................42

10.3.7 Priorité des interruptions ...........................................................................................................43
Détermination de la priorité d’une interruption ........................................................................................... 43
10.3.8 Les interruptions dans le programme source .......................................................................43
10.3.9 Acquittement d’une interruption .............................................................................................43
10.4 Lancement du programme et réinitialisation...................................................................... 44
10.4.1 Commande externe de la RàZ .................................................................................................44
10.4.2 Adresse de départ du programme principal .........................................................................44
10.5 Surveillance du déroulement du programme : le chien de garde .................................... 45
Chien de garde externe ...................................................................................................................................... 45
Chien de garde interne ....................................................................................................................................... 45
11 STRUCTURE INTERNE / MODELE LOGICIEL D’UN µP OU CPU D’UN µC .......... 45
11.1 Structure interne..................................................................................................................... 46
11.2 Modèle logiciel ....................................................................................................................... 47
12 LES PRINCIPALES INTERFACES D’UN µP.................................................................. 47
12.1 Introduction ............................................................................................................................ 47
12.2 Connexion d’un boîtier d’interface ...................................................................................... 48
12.3 Interfaces d’E/S parallèle ....................................................................................................... 48
12.3.1 Échanges sans protocole de communication .......................................................................48
12.3.2 Échanges avec protocoles de communication .....................................................................49
12.4 Interfaces séries ...................................................................................................................... 49
12.4.1 Généralités ....................................................................................................................................49
12.4.2 Interfaces séries asynchrones ...................................................................................................50
12.4.3 Interfaces série synchrones .......................................................................................................51
12.5 Convertisseur Analogique Numérique (CAN) .................................................................... 52
12.5.1 CAN dans un système à µP ......................................................................................................52
12.5.2 CAN intégré d’un µC ..................................................................................................................52
12.5.3 CAN externe pour un µC ..........................................................................................................52
12.6 Convertisseur Numérique Analogique (CNA) .................................................................... 52
12.6.1 CNA dans un système à µP ......................................................................................................52
12.6.2 CNA dans un µC .........................................................................................................................52
12.6.3 CNA externe pour un µC ..........................................................................................................53
12.7 COMPTEUR-Temporisateur (Timer)..................................................................................... 53
13 STRUCTURE MATERIELLE D’UN SYSTEME A µP/µC ................................................ 54
13.1 Bus d’adresses et bus de données ........................................................................................ 54
13.1.1 Mode « circuit seul » / mode étendu ......................................................................................54
13.1.2 Multiplexage adresses/données ..............................................................................................54
13.2 Composants annexes au µP ou µC et connexions ............................................................. 55
14 STRUCTURE DU PROGRAMME SOURCE EN LANGAGE D’ASSEMBLAGE ........... 57
14.1 Généralités .............................................................................................................................. 57
14.2 Exemple de structure d’un fichier source ............................................................................ 58
Structure de la section programme ................................................................................................................. 58
15 RESUME ........................................................................................................................ 59
15.1 Généralités .............................................................................................................................. 59
15.2 Flux de conception ................................................................................................................. 59

15.3 Système minimum .................................................................................................................. 60
15.4 Éléments de la structure interne d’un µP ............................................................................ 60
15.4.1 Jeu d’instructions .........................................................................................................................61
15.4.2 Modes d’adressage .....................................................................................................................61
15.5 Déroulement d’un programme ........................................................................................... 62
15.5.1 La pile .............................................................................................................................................62
15.5.2 Déroulement normal ..................................................................................................................62
15.5.3 Interruption ...................................................................................................................................63

Table des illustrations
Fig. 1 : Système à microprocesseur ............................................................................................................... 7

Fig. 2 : Exemple de système avec ses E/S ..................................................................................................... 8
Fig. 3 : Rangement des instructions dans la mémoire programme ......................................................... 9
Fig. 4 : Cycle de base d’un microprocesseur ............................................................................................... 9
Fig. 5 : Conception d’un programme ...........................................................................................................10
Fig. 6 : Codes correspondant à l’instruction DEC $4000 du 68HC11 .................................................11
Fig. 7 : Architecture Von Neuman ................................................................................................................13
Fig. 8 : Architecture Harvard ..........................................................................................................................13
Fig. 9 : Système minimum à µP......................................................................................................................14
Fig. 10 : Premier exemple de programme ..................................................................................................15
Fig. 11 : ADDA, recherche du code opération ..........................................................................................15
Fig. 12 : ADDA, recherche de l’opérande ..................................................................................................16
Fig. 13 : STAA, recherche du code opération ............................................................................................17
Fig. 14 : STAA, recherche du poids fort de l’adresse................................................................................17
Fig. 15 : STAA, recherche du poids faible de l’adresse ............................................................................18
Fig. 16 : STAA, exécution de l’instruction ...................................................................................................18
Fig. 17 Système minimum Harvard...............................................................................................................19
Fig. 18 exemple de programme ....................................................................................................................20
Fig. 19 MOVLW, recherche du code instruction ......................................................................................21
Fig. 20 : ADDWF, recherche du code instruction / MOVLW, exécution ...........................................21
Fig. 21 : MOWF, recherche du code instruction / ADDWF, exécution ..............................................22
Fig. 22 : GOTO, recherche / MOVWF, exécution ...................................................................................22
Fig. 23 : GOTO, exécution .............................................................................................................................23
Fig. 24 : structure d'un µP ...............................................................................................................................24
Fig. 25 : UAL et accumulateurs .....................................................................................................................25
Fig. 26 : Addition de l’accumulateur et d’une donnée ............................................................................26
Fig. 27 : Décalage à gauche de l’accumulateur.........................................................................................26
Fig. 28 : Recherche du code opération .......................................................................................................28
Fig. 29 : Recherche de l’opérande ................................................................................................................28
Fig. 30 : Calcul puis stockage du résultat ....................................................................................................29
Fig. 31 : Codage d’une instruction................................................................................................................31
Fig. 32 : Format des instructions dans les µP 8 bits ..................................................................................32
Fig. 33 : exemple de pile .................................................................................................................................35
Fig. 34 : État de la pile après empilement ...................................................................................................36
Fig. 35 : État de la pile après récupération automatique du PC ............................................................36
Fig. 36 : Exemple d’initialisation de la pile ..................................................................................................36
Fig. 37 : Principe d’une interruption .............................................................................................................39
Fig. 38 : Sauvegarde puis restitution du contexte de A ...........................................................................40
Fig. 39 : liaisons de demandes d’interrupion dans µC .............................................................................41
Fig. 40 : liaisons de demandes d’interruption dans un système à µP ...................................................41
Fig. 41 : Structure interne simplifiée du 80186 d’Intel .............................................................................46
Fig. 42 : modèle logiciel CPU 68HC11 .......................................................................................................47
Fig. 43 : Liaisons avec poignée de main entre interface et périphérique ............................................49
Fig. 44 : Émission / réception de données série ........................................................................................50
Fig. 45 : Transmission avec horloge réception correcte et incorrecte .................................................51
Fig. 46 : liaison série synchrone.....................................................................................................................51
Fig. 47 : 2 modes de fonctionnement étendu du 80C196 .....................................................................55
Fig. 48 : bus adresses/données et sigaux de contrôle du 80C196 .......................................................55
Fig. 49 : 68HC11 en mode étendu avec mémoire externe ....................................................................56

MICROPROCESSEURS ET MICROCONTROLEURS :
UNE INTRODUCTION
1 OBJET DE CE DOCUMENT
Ce document est un support de cours à destination d'un public d'électroniciens. Il permet

d’introduire progressivement les différentes notions pour la compréhension du fonctionnement
d’un système à microprocesseur (ou microcontrôleur) simple (8 bits ou 16 bits –voir § 5.1). Il ne
s’agit pas d’un document synthétique.
Ce document est orienté pour permettre par la suite une mise en œuvre d’un système à µP.
Ce document a été initialement rédigé pour servir dans 2 cas :
• introduction à l'étude des µPs et µCs en classe de STS électronique. Dans ce cas, certaines
parties du document ne sont pas utilisées.
• support de révision pour formation post BTS. Certaines parties du document donnent
quelques indications pour un approfondissement ultérieur.
Des TPs et TDs complémentaires assurent une bonne assimilation. Seule la 1ère partie de ce do-
cument nécessite une lecture linéaire. Le reste est à lire en partie en fonction des TPs envisagés,
avec retours en arrière pour « approfondissement » ultérieur.
2 MICROPROCESSEUR ET SYSTEME A MICROPROCESSEUR
2.1 GENERALITES
2.1.1 MICROPROCESSEUR OU µP
Un microprocesseur ou µP est un composant (un circuit intégré) né du développement de

l’informatique et de l’électronique. Il comprend plusieurs unités fonctionnelles autrefois réalisées
par de nombreux composants dans les anciens ordinateurs ou actuellement par quelques com-
posants dans les ordinateurs récents d’assez grande puissance.
L’emploi du µP ne se limite pas aux ordinateurs. Les µPs et d’autres composants intégrant
quelques fonctions supplémentaires, les microcontrôleurs ou µCs, sont employés pour les con-
trôles de processus industriels et les applications embarquées ou enfouies (embedded) (automo-
bile, photocopieur, …).
Un µP est capable d’enchaîner automatiquement des opérations arithmétiques, logiques, etc. sur
des données binaires. L’enchaînement de ces opérations est commandé par un programme en-
registré dans une mémoire.
2.1.2 SYSTEME A µP
Un système à µP permet de réaliser un traitement automatique de l’information ; le terme « in-

formation » devant être compris comme « élément significatif » : parole, image, mesure d’une
grandeur physique, etc. Un système à µP comprend le µP proprement dit et des composants
annexes.

Informations Traitement Informations,actions
d'entrée automatique de sortie
SYSTEME A µP
Fig. 1 : Système à microprocesseur
Un système à µP procède périodiquement à une acquisition d’information, un traitement auto-

matique de cette information puis à sa restitution.
Exemples
Balance électronique
• acquisition : prix au kg (Pkg) saisi à partir d’un clavier, masse de l’article (M) issue d’un cap-
teur et d'un conditionnement (amplification, …)
• traitement : calcul du prix à payer (P) P = M × Pkg
• restitution : affichage de la masse, du prix au kg et du prix à payer, etc.
Asservissement en vitesse d’un moteur

• acquisition : vitesse souhaitée (consigne Ω C ) et vitesse réelle du moteur ( Ω )
• traitement : calcul de la commande à appliquer au moteur en fonction de la différence
ε = Ω − ΩC
• restitution : pilotage de l’interface de puissance de commande du moteur.
2.1.3 MICROPROCESSEUR (µP) / MICROCONTROLEUR (µC)
Au début de la commercialisation des µPs, un système minimum était obligatoirement constitué

de plusieurs circuits intégrés.
Les µCs sont apparus ensuite, lorsque l’intégration des composants a fait des progrès. Actuelle-
ment, dans un circuit intégré, un µC regroupe l’équivalent d’un système à µP dans un même
boîtier. Un système à µP peut être constitué de nombreux composants (mémoires, etc.) ; il est
facilement extensible. Les constituants d'un µC sont figés1.
Les µCs sont plutôt dédiés aux applications qui ne nécessitent pas une grande quantité de cal-
culs complexes, mais qui demandent beaucoup de manipulations d’entrées / sorties. C’est le cas
des contrôles de processus, tel que par exemple le contrôle des organes d’une photocopieuse.
Les systèmes à µP sont plutôt réservés pour les applications demandant beaucoup de traitement
de l’information et assez peu de gestion d’entrées / sorties. Les ordinateurs sont réalisés avec des
systèmes à µP.
1
Certains µCs actuels ont des modes de fonctionnement qui les rapprochent des µCs : on peut
rajouter des composants externes comme avec un système à µP. La distinction µP / µC n'est pas
toujours très marquée.

2.2 ACQUISITION, RESTITUTION DE L’INFORMATION : ENTREES/SORTIES (E/S)
D’UN SYSTEME A µP
Un système à µP n’a d’utilité que s’il peut échanger des informations avec le milieu extérieur ; il
dispose donc d’entrées/sorties (notées E/S).
Un système à µP comprend une unité de traitement dont les E/S sont de type binaire (0/1). Le
cœur de cette unité est le µP. En général les E/S sont groupées par paquet, ou mot (fréquem-
ment de 8 bits) ; on parle alors de port d’E/S.
Un port 8 bits peut correspondre à plusieurs E/S (état d’un poussoir, d’un détecteur de passage,
commande d’un relais, etc.) ou à une seule information codée sur 8 bits (mesure de la vitesse
d’un moteur issue d’un C.A.N. par exemple).
Pour traiter d’informations analogiques, un système à µP doit posséder des convertisseurs (Con-
vertisseur Analogique Numérique -CAN- et Convertisseur Numérique Analogique –CNA-),
comme sur la figure suivante.
Système à µP
Entrées Sorties
logiques logiques
Unité de
traitement
Entrée Sortie
analogique C.A.N. C.N.A. analogique
Fig. 2 : Exemple de système avec ses E/S
3 PRINCIPE DE FONCTIONNEMENT D’UN SYSTEME A µP
3.1 INSTRUCTION, PROGRAMME
Le traitement automatique de l’information consiste en l’exécution par le µP d’une suite de

tâches élémentaires appelée instructions. L’ensemble de ces instructions constitue le pro-
gramme.
Prenons l’exemple de l’asservissement de vitesse présenté précédemment. Le programme cor-
respondant, très simplifié, ressemble à ce qui suit :
• acquérir le mot représentatif (octet) de la consigne (ici la vitesse de rotation désirée),
• acquérir le mot représentatif de la vitesse réelle du moteur,
• soustraire l’octet représentatif de la vitesse de l’octet de la consigne,
• multiplier le résultat par 32 (c’est un exemple),
• envoyer le résultat de la multiplication sur la sortie de commande du moteur,
Chacune des lignes précédentes correspond à une instruction.
En pratique, chaque type de µP peut comprendre un ensemble limité d’instructions parfaitement

définies ; on parle de jeu d’instructions du µP. A chacune de ces instructions correspond un
code (sur un ou plusieurs mots mémoire) connu du µP.

Le µP est donc obligatoirement associé à une mémoire (mémoire programme) qui contient les
codes des instructions à exécuter rangés dans des mots mémoires à des adresses successives
(sauf en cas de rupture de séquence).
Ad+5 Instruction 5
Ad+4 Instruction 4
Instruction sur 2 Ad+3 Instruction 3 Sens d'exécution

octets
Ad+2 Instruction 3
Ad+1 Instruction 2
Ad Instruction 1
Fig. 3 : Rangement des instructions dans la mémoire programme
Si le programme est « figé », on emploie une mémoire de type ROM ; au contraire si ce dernier
doit être changé régulièrement comme c’est le cas pour les logiciels d’applications des micro-
ordinateurs on utilise une RAM dans laquelle on charge au préalable (à partir d’une disquette par
exemple) les codes du programme.
La mémoire programme d’un µC est souvent de petite taille (qqs kO ou qqs dizaines de kO),
alors que celle associée à un µP peut être très importante (plusieurs MO ou beaucoup plus).
3.2 EXECUTION DU PROGRAMME
Une fois le programme placé dans la mémoire associée au µP, le µP fonctionne de la façon sui-
vante :
Un µP décrit en permanence le cycle décrit ci-

contre. Ainsi, si on considère l’exemple de la figure
Recherche de
l'instruction à exécuter (cycle Fetch) 3, le µP :
en mémoire • place l’adresse Ad sur le bus d’adresses (voir
plus loin) et lit l’octet ainsi adressé en ROM,
• exécute l’instruction correspondante,
Décodage et exécution
de • calcule l’adresse de l’instruction suivante Ad+1,
l'instruction • place Ad+1 sur le bus, exécute l’instruction 2,
etc.
Calcul de l'adresse
de la Remarque : le cycle décrit ici correspond à des µP
prochaine instruction
simples. Certains µP peuvent, dans certains cas, exé-
cuter une instruction pendant qu’ils recherchent la
suivante (voir plus loin § Système minimum à archi-
Fig. 4 : Cycle de base d’un microprocesseur
tecture Harvard). Il existe même des possibilités plus
évoluées qui ne peuvent être traitées dans le cadre
de cette introduction.

4 FLUX DE CONCEPTION
La conception d’un ensemble comprenant un système à µP ou un µC peut se décomposer en 3

parties :
• obtention du code à placer en mémoire programme à partir du cahier des charges
• essais / mise au point
• programmation industrielle de la mémoire associée au µP ou interne au µC
Chacune de ces trois parties est brièvement mentionnée ici. Chacune fait l’objet de développe-
ment dans un autre document.
4.1 OBTENTION DU CODE BINAIRE
Le code placé en mémoire est dit code exécutable ou code binaire ou encore code objet.
La démarche simplifiée suivie pour concevoir un ANALYSE

programme, donc pour obtenir la suite de codes
correspondante est présentée ci-contre :
L’écriture du programme et la traduction se font Grandes lignes du

sur un micro-ordinateur. Le résultat est un fichier logiciel et du matériel
qui contient le code exécutable.
Ecriture du programme SOURCE

dans un langage (C, Pascal, etc.)
Traducteur (assembleur
ou compilateur)
Code exécutable
Fig. 5 : Conception d’un programme
Traducteur
Terme général pour désigner un logiciel capable de traduire le SOURCE (écrit dans un langage
« facilement » compréhensible par le programmeur) en un fichier EXECUTABLE compréhensible
par le µP.
Assembleur (Assembler en anglais)
Traducteur pour langage basé directement sur le jeu d’instruction du µP. A chaque instruction du
µP correspond un mnémonique. Celui-ci est en général la contraction du ou des mots désignant
l’action exercée par l’instruction. Le mnémonique permet donc d’évoquer facilement ce que

réalise l’instruction. Le langage de programmation utilisé est le langage d'assemblage (Assembly
language).
Par exemple, en langage d'assemblage 68HC11 (microcontrôleur 8 bits de MOTOROLA) la ligne
suivante :
DEC $4000
signifie : décrémenter (d’où le mnémonique DEC) la donnée enregistrée à l’adresse 4000h.
Après assemblage puis charge- Mémoire
ment en mémoire on obtien- programme
drait la suite de codes décrite
figure 6.
Le programme source, écrit en Adresse de la donnée

Ad+2 00 à décrémenter
langage d'assemblage (assembly Instruction (sur 16 bits - 2 octets)
language), est constitué des sur Ad+1 40
3 octets
mnémoniques et d'autres infor- Ad 7A
mations présentées plus loin.
Code de l'opération DEC
Fig. 6 : Codes correspondant à l’instruction DEC $4000 du 68HC11

Remarque : On utilise fréquemment le terme « assembleur » à la place de « langage d'assem-
blage ». On dira alors un programme écrit en assembleur.
Chaque µP à ses instructions propres et donc des mnémoniques différents si bien qu’un pro-
gramme écrit en assembleur ne peut être directement utilisé avec un µP autre que celui pour
lequel il a été écrit.
Compilateur
Traducteur pour langage indépendant du jeu d’instruction (C, Pascal, FORTRAN, etc.). Par
exemple, en C l’opération précédente pourrait s’écrire :
DATA = DATA - 1;
avec DATA (nom donné à la donnée) enregistrée à l’adresse 4000h. Cette écriture est bien in-
dépendante du µP choisi et peu être compilée aussi bien pour un 68HC11 (elle produit alors les
codes précédents), que pour un 8031, qu’un pentium, etc.
4.2 ESSAIS / MISE AU POINT
Après avoir obtenu le code exécutable, il existe plusieurs possibilités pour la mise au point.
On commence généralement par vérifier que le logiciel est correct d'un point de vue fonction-
nel, avec un logiciel de simulation sur ordinateur, puis on procède aux essais avec le matériel.
4.2.1 ESSAIS MATERIELS : SOLUTION A EMULATEUR
C’est la solution la plus performante et la plus utilisée industriellement pour des µP 8/16 bits (et
même plus).
Lors de la phase de mise au point, le programme n’est pas directement chargé dans la mémoire
associée au µP ou dans la mémoire interne du µC, mais il est placé dans un outil chargé de se
substituer à cette mémoire et de remplacer le µP ou µC. Il est alors possible de procéder à
l’exécution contrôlée du programme.
On appelle émulateur l’outil de mise au point. Il est constitué d’un boîtier qui se connecte :

• à une sonde qui remplace le µP ou µC sur le système cible. La sonde s’enfiche sur le support
de CI dans lequel vient normalement prendre place le µP ou le µC.
• à un micro-ordinateur qui, avec le logiciel approprié, permet de contrôler le fonctionnement
de l’émulateur. Plusieurs commandes permettent une exécution contrôlée du programme,
fonctionnement en pas à pas, affichage de valeurs de registres internes du système, …
4.2.2 ESSAIS MATERIELS : AUTRES SOLUTIONS
Il existe des solutions moins performantes pour les µP 8/16 bits (carte d’évaluation, kit pédago-
gique…).
Avec le déboguage in situ, le µC dispose alors de connexions spéciales pour une liaison série
avec un PC et des ressources nécessaires pour une exécution par partie du programme (point
d’arrêt). Cette possibilité commence à se développer sur des µCs récents. La mémoire pro-
gramme est d’abord programmée par la liaison série. Puis les commandes de déboguage sont
envoyées par cette même liaison. Le déboguage in situ n’est possible qu’avec des µC intégrant
de la mémoire flash facile à programmer et reprogrammer depuis l’ordinateur de déboguage.
4.3 PROGRAMMATION
Selon la quantité de production souhaitée, on utilise un des types de mémoire suivants :

• ROM par masquage : programmation lors de la fabrication. Pour les très grosses quantités.
• ROM OTP programmable par l’utilisateur.
• EPROM programmable par l’utilisateur.
• EEPROM programmable par l’utilisateur.
Pour les 3 derniers types, la programmation s’effectue avec un programmateur de mémoire.
5 STRUCTURE D’UN SYSTEME MINIMUM A µP
On appelle système minimum à µP l’ensemble comprenant le µP et les composants indispen-

sables à son fonctionnement. Cet ensemble est inclus dans tout µC.
5.1 LES CONSTITUANTS D’UN SYSTEME MINIMUM A µP
Nous avons vu que le microprocesseur doit pouvoir lire le code des instructions en mémoire,
acquérir des données, les traiter puis les restituer.
Un système minimum à µP est constitué de :
• une unité d’échanges : les interfaces d’E/S,

• une unité centrale de traitement (CPU - Central Processing Unit) : le µP ou une partie du µC.
C’est elle qui calcule les adresses des instructions, des données à utiliser, effectue les traite-
ments indiqués par les instructions, …
• une unité de stockage du programme et des données : les mémoires.
L’unité d’échange est vue par l’unité centrale comme un ensemble de registres accessibles. Les
informations vers l’extérieur transitent par certains de ces registres.

Les différentes unités sont réunies par des canaux d’échanges : les bus.
Les bus permettent de véhiculer :
• les adresses des instructions, des données et des registres des périphériques d’E/S (unité
d’échange)
• les instructions du programme pour l’unité centrale de traitement
• les constantes figées dans le programme
• les variables provenant de l’unité d’échange
• les variables, provenant de calculs intermédiaires, stockées dans une mémoire temporaire
(RAM)
Pour que toutes les informations puissent circuler correctement entre toutes les unités, des si-
gnaux de contrôles regroupés sous le nom de bus de contrôle sont utilisés.
5.2 LES 2 ARCHITECTURES D’UN SYSTEME A µP
Pour l’organisation des différentes unités, il existe deux architectures :

• l’architecture Von Neuman (du nom d’un des savants qui contribua à la mise au point d’un
des tout premiers ordinateurs). C’est la plus courante. Les instructions, les constantes et les
variables circulent sur le même bus appelé bus de données
• l’architecture Harvard. Les instructions et les constantes circulent sur un bus différent de ce-
lui utilisé pour les variables (provenant des E/S ou de calculs). Ce type d’architecture est uti-
lisé sur des µC qui ont connu un très grand développement ces dernières années : les PIC
de Microchip
Les avantages et les inconvénients de ces deux architectures sont mentionnées plus loin, après le
fonctionnement de systèmes avec ces 2 architectures et après présentations des jeux d'instruc-
tions (voir § Les instructions et les modes d'adressage / Jeux d'instructions réduit / étendu).
Dans les applications embarquées, le programme est figé et par conséquent stocké dans une
mémoire de type ROM tandis qu’une RAM permet de stocker des résultats intermédiaires de
calcul, des données temporaires, etc.
Les figures ci-dessous représentent, de façon très simplifiée, les architectures Von Neuman et
Harvard. Les différents bus ne sont pas distingués.
Mémoire Mémoire Mémoire

Unité centrale instructions variables Unité instructions
C.P.U. programme centrale programme
& constantes C.P.U. & constantes
+
mémoire
variables
Unité d'échanges Unité d'échanges
Système min à µP ou µC Système min à µP ou µC
Milieu extérieur Milieu extérieur

Fig. 7 : Architecture Von Neuman Fig. 8 : Architecture Harvard

6 SYSTEME MINIMUM A ARCHITECTURE VON NEUMAN
6.1 STRUCTURE D’UN SYSTEME MINIMUM

Seule la structure des systèmes les plus simples est présentée ici.
Bus de contrôle Décodeur

d'adresse
Bus d'adresse
CS1 CS2 CS3
Mémoire Mémoire
Interface
µP programme données
parallèle
EPROM RAM
OE RD/WR RD/WR
Bus de donnée
Fig. 9 : Système minimum à µP
Le µP utilise le même canal d’échange pour lire les instructions et acquérir (lire) et restituer
(écrire) des données : le bus de données. La taille de ce bus est une des caractéristiques princi-
pales des µP et µC.
Les tailles les plus courantes des bus de données sont :

• 8 bits pour les petites applications embarquées (ex 68HC11, 8051, …)
• 16 bits pour les applications embarquées de moyenne complexité (ex 68HC16, 80196, …)
• 32 bits, 64 bits pour les gros calculateurs, les ordinateurs (et même certaines consoles de
jeux grand public)
Les adresses délivrées par le µP sont véhiculées par le bus d’adresses (16 bits pour le 68HC11
ce qui correspond à 216 = 65536 adresses). La taille de bus d’adresse est en général en relation
avec celle du bus de données.
Remarque : Certains µPs utilisent, pour réduire le nombre de broches utilisées pour le bus
d’adresses et le bus de données, une technique qui sera présentée plus loin.

6.2 FONCTIONNEMENT SIMPLIFIE DU SYSTEME MINIMUM
Le fonctionnement est présenté dans ses grandes

lignes au travers de quelques exemples
d’instructions pour un système organisé autour
d’un µP ou µC Motorola 8 bits (6809, 68HC11,
…). Une étude plus détaillée sera présentée dans 9007h 00
les paragraphes suivants. Le fonctionnement pour 9006h 90 JMP $A000
une autre famille de µP est très proche à la diffé- 9005h 7E
rence des mnémoniques et codes opératoires. 9004h 00
9003h 40 STAA $4000
On suppose que :
B7
• la mémoire est programmée 9002h
• le µC a effectué un certain nombre de tâches 9001h 10
ADDA #$10
• le µC est prêt à exécuter le programme pré- 9000h 8B
senté ci-contre.
Fig. 10 : Premier exemple de programme
6.2.1 ADDITION
Le µC commence par exécuter l’instruction

ADDA #$10
pour laquelle le contenu d’un registre A (interne au µC) est additionné au nombre 10h et le ré-
sultat rangé dans A. On suppose que le code de l’instruction à exécuter est rangé à l’adresse
9000h et que le nombre 10h est rangé en 9001h.
Recherche de l’instruction

d'adresse
9000h Bus d'adresse
CS1 CS2 CS3
µP
Mémoire
ou CPU 10 données Interface
parallèle
d'un µC 8B RAM
EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 11 : ADDA, recherche du code opération

Le µC va chercher l’instruction en plaçant son adresse, ici 9000h, sur le bus d’adresse. Le déco-
deur active CS1, seule l’EPROM est sélectionnée; les autres circuits ont leurs sorties en état
haute impédance. Le contenu de la position mémoire adressée (8Bh qui est le code de
l’instruction ADDA) est placé sur le bus de données et lu par le µC.
Exécution de l’instruction

d'adresse
9001h Bus d'adresse
CS1 CS2 CS3
µP
Mémoire
parallèle
d'un µC 8B RAM
EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 12 : ADDA, recherche de l’opérande
Le µC reconnaît le code de l’instruction ADDA (décodage) et sait alors qu’il doit additionner A
avec le contenu de l’adresse suivante.
Le µC va alors chercher le nombre à additionner en délivrant l’adresse mémoire qui suit immé-
diatement celle où était rangé le code opération. Tout se passe comme précédemment et la
donnée 10h est transférée dans le microcontrôleur via le bus de données.
Enfin, le µC additionne A et 10h en interne puis stocke le résultat dans A.
Calcul de l’adresse de l’instruction suivante
Ici 9002h.
6.2.2 TRANSFERT D’UNE DONNEE DU µP VERS L’EXTERIEUR
Le µC exécute l’instruction suivante

STAA $4000
pour laquelle le contenu du registre A est transféré vers l’extérieur via un registre de l’interface
parallèle (localisé à l’adresse 4000h).


d'adresse
9002h Bus d'adresse
CS1 CS2 CS3
µP
00 Mémoire
parallèle
d'un µC B7 RAM
EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 13 : STAA, recherche du code opération
Tout se passe comme pour l’exemple précédent. Le µC place l’adresse d’enregistrement de

l’instruction, ici 9002h, sur le bus d’adresses; le décodeur active CS1 et le code opération est
transmis au µC.
Exécution de l’instruction
Le µC reconnaît l’instruction, il sait désormais qu’il doit successivement aller chercher le poids
fort de l’adresse de stockage de A (40h) puis le poids faible de cette adresse (00h).

d'adresse
9003h Bus d'adresse
CS1 CS2 CS3
µP
00 Mémoire
parallèle
d'un µC B7 RAM
EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 14 : STAA, recherche du poids fort de l’adresse

d'adresse
9004h Bus d'adresse
CS1 CS2 CS3
µP
00 Mémoire
parallèle
d'un µC B7 RAM
EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 15 : STAA, recherche du poids faible de l’adresse
Le µC a maintenant en sa possession toutes les informations nécessaires à l’exécution de

l’instruction à proprement parler : il connaît l’action à réaliser, ici transférer A vers l’extérieur, et il
connaît l’adresse de la destination, 4000h.

d'adresse
4000h Bus d'adresse registre

d'adresse
CS1 CS2 CS3 4000h
µP
00 Mémoire
ou CPU 40 données
d'un µC B7 RAM
Interface
EPROM parallèle
OE RD/WR RD/WR=0
Bus de donnée
Fig. 16 : STAA, exécution de l’instruction
Le µC place alors 4000h sur le bus d’adresses, place A sur le bus de données et fait une de-
mande d’écriture de donnée (activation d’une ligne WR en général). Ceci a pour effet
d’enregistrer A dans un registre de l’interface parallèle et de permettre sa sortie vers l’extérieur
(pour commander un afficheur 7 segments par exemple).
Calcul de l’adresse de l’instruction suivante
Ici 9005h.

6.2.3 SAUT A UNE ADRESSE
Le µC exécute alors l’instruction

JMP $A000
qui permet de sauter directement à l’instruction enregistrée à l’adresse A000h
Comme précédemment, le µC acquiert le code de l’instruction (7Eh pour JMP).
Exécution de l’instruction et calcul de l’adresse de l’instruction suivante
Le µC va chercher l’adresse du saut, ici A000h. L’adresse de la prochaine instruction est forcée à
A000h (au lieu de 9008h comme on pourrait le supposer). Lors du cycle suivant, l’exécution du
programme reprendra donc à l’instruction rangée à cette adresse.
7 SYSTEME MINIMUM A ARCHITECTURE HARVARD
7.1 STRUCTURE D'UN SYSTEME MINIMUM

Seule la structure correspondant à un µC extrêmement simple est présentée ici
Décodeur
d'adresse
Bus d'adresse instructions Bus d'adresse données
CS1 CS2
Mémoire Mémoire
programme Interface
EPROM
CPU données
parallèle
RAM
RD RD
WR WR
Bus d'instruction Bus de donnée
Bus de contrôle
Fig. 17 Système minimum Harvard
La CPU utilise 2 canaux d'échange pour lire les instructions et acquérir (lire) et restituer (écrire)
les données : le bus instruction ou bus programme et le bus de donnée. Les tailles de ces bus
sont en général différentes.
La taille la plus courante du bus de données pour un µC est de 8 bits.

Les deux bus distincts programme et donnée permettent de réaliser simultanément une re-
cherche d'une instruction et l'exécution de l'instruction précédente.

7.2 FONCTIONNEMENT SIMPLIFIE
Le fonctionnement est présenté dans ces grandes lignes au travers de quelques instructions d'un
PIC 16C5x de Microchip. Le fonctionnement pour un autre µC est très proche, à la différence
des mnémoniques et des codes opératoires.
La mémoire programme est organisée en mots de 12 bits. Le bus de donnée est de 8 bits.
Un mot en mémoire programme contient à la fois le code opératoire et l'opérande si c'est une
constante ou des informations sur l'adresse de l'opérande s'il s'agit d'une variable.
On suppose que :
• la mémoire est programmée
• le µC a effectué un certain
nombre de tâches
• le µC est prêt à exécuter le
43h A80 GOTO 0x80
programme présenté ci-
contre 42h 026 MOVWF 0x06
10F ADDWF 0x15,W
41h
40h C10 MOVLW 0x10 (C: code instruction, 10: opérande)
Fig. 18 exemple de programme
Ce programme permet d'effectuer une addition d'une variable contenue dans un registre
d'adresse 15h avec la constante 10h, de ranger le résultat sur la sortie d'un port d'adresse 06h
puis de sauter à l'adresse programme 80h.
Une addition doit nécessairement se faire avec un opérande dans un registre W (équivalent de
l'accumulateur dans d'autres µP/µC) et l'autre dans un registre quelconque. On a choisi ici le
registre d'adresse 15h. Il faut donc avec de réaliser l'addition ranger la constante 10h dans le
registre W.
7.2.1 TRANSFERT DE LA CONSTANTE DANS LE REGISTRE W
On utilise l'instruction MOVLW 10h (MOVe Litteral [ici 10] to W). Le code en mémoire pro-
gramme est C10 soit 1100 0001 0000. Les 4 MSB correspond au code de l'instruction, les 8 LSB
correspondent à la constante.
En une seule le lecture de la mémoire programme, le µC a le code de l'instruction et la constante

nécessaire pour exécuter l'instruction.

Décodeur
d'adresse

40h CS1 CS2
Mémoire
Interface
10F CPU données
parallèle
C10 RAM
RD RD
C10h WR WR
Bus de contrôle
Fig. 19 MOVLW, recherche du code instruction
Pendant qu'il effectue la lecture de l'instruction, le µC exécute l'instruction qu'il a précédemment
lue (non représenté ci-dessus).
7.2.2 TRANSFERT CONSTANTE / EXECUTION -- ADDITION / RECHERCHE DU CODE
Pendant qu'elle écrit la valeur de la constante précédemment lue dans W, la CPU recherche le
code de l'instruction suivante.
ADDWF 15h,W permet d'additionner la valeur contenue dans W (10h) à la valeur contenue
dans le registre d'adresse 15h.
Décodeur
d'adresse

41h CS1 CS2
Ecriture dans W
Mémoire
Interface
10Fh CPU données
parallèle
C10 RAM
RD RD
10Fh WR WR
Bus de contrôle
Fig. 20 : ADDWF, recherche du code instruction / MOVLW, exécution
Les informations sur le bus d'instruction correspondent au code de l'instruction et à l'adresse de

l'opérande à utiliser pour l'exécution.

7.2.3 ADDITION / EXECUTION -- TRANSFERT / RECHERCHE DU CODE
Le µC utilise les 2 bus d'adresse simultanément. D'un côté, il recherche le code de l'instruction
suivante à l'adresse 42h, d'un autre côté il recherche l'opérande à l'adresse 15h. Cette dernière
adresse était placée avec le code de l'instruction précédente.
Décodeur
d'adresse
Bus d'adresse instructions 15h Bus d'adresse données

42h CS1 CS2
addition entre W
et le bus de donnée
026 résultat dans W
xx Interface
10Fh parallèle
C10
CPU
RD RD
026h WR WR
Bus de contrôle
Fig. 21 : MOWF, recherche du code instruction / ADDWF, exécution
MVWF 06h permet de transférer le contenu de W dans un registre d'adresse 6 qui correspond à
un port de sortie.
7.2.4 TRANSFERT / EXECUTION – SAUT / RECHERCHE DU CODE
Le µC utilise les 2 bus d'adresse simultanément. D'un côté, il recherche le code de l'instruction
suivante à l'adresse 43h, d'un autre côté il transfère le contenu de W à l'adresse 06h. Cette der-
nière adresse était placée avec le code de l'instruction précédente.
Décodeur
d'adresse

06h Registre
43h CS1 CS2 d'adresse
06h
Mémoire yy
A80 CPU données
026 RAM
RD RD
A80h WR WR
Bus de contrôle
Fig. 22 : GOTO, recherche / MOVWF, exécution

GOTO 80h permet de continuer le programme à partir de l'adresse indiquée.
7.2.5 SAUT / EXECUTION
L'exécution de l'instruction revient à rechercher la nouvelle instruction à l'adresse contenue avec

le code du saut (précédente instruction).
Décodeur
d'adresse

80h CS1 CS2
Mémoire
Interface
CPU données
parallèle
zzz RAM
RD RD
zzz WR WR
Bus de contrôle
Fig. 23 : GOTO, exécution
8 ÉLEMENTS DE LA STRUCTURE INTERNE D’UN MICROPROCESSEUR
8.1 ORGANISATION INTERNE SIMPLIFIEE D’UN µP
Le microprocesseur renferme tous les circuits logiques qui permettent de rechercher, décoder et
exécuter automatiquement les instructions logées en mémoire.
Le µP peut être considéré comme un automate composé de deux ensembles :

• la partie opérative. Elle permet d’effectuer les opérations arithmétiques et logiques sur les
données ainsi que de calculer l’adresse mémoire des instructions ou des données
• la partie commande. Elle est notamment composée d’un registre instruction où est stocké le
code de l’instruction à exécuter. Ce registre est associé à un séquenceur chargé de délivrer
l’ensemble des signaux internes nécessaires au fonctionnement de la partie opérative du µP
La figure ci-dessous donne une représentation d'un µP (ou de l'unité centrale de traitement d'un
µC) à architecture Von Neuman.

Partie Registre
Commande Séquenceur Instruction
Busde
Contrôle
Partie Unité de Unité de Bus
Opérative Traitement Getion d'adresse
Mémoire Busde
Donnée
Fig. 24 : structure d'un µP
La partie opérative est réalisée avec une Unité Arithmétique et Logique (UAL ou ULA ou en
anglais ALU pour Arithmetic Logic Unit) et des registres dont certains sont associés à des comp-
teurs, …
Le rôle du séquenceur est décrit plus loin, après une première approche lors du fonctionnement
de l’UAL.
Les informations entre les registres, l’UAL, … sont échangées par l’intermédiaire de bus internes
qu’on nomme aussi chemins de données internes. Les informations sont acheminées d’un en-
droit à un autre et mémorisées grâce aux signaux de contrôle délivrés par le séquenceur piloté
par un signal d’horloge.
8.2 UNITE ARITHMETIQUE ET LOGIQUE (UAL) ET REGISTRES ASSOCIES
8.2.1 ROLE DE L’UAL
C’est l’organe de calcul du microprocesseur : il permet d’effectuer des opérations arithmétiques

et logiques.
L’opération à réaliser est déterminée par un mot de commande appliqué à l’UAL à partir du
code de l’instruction rangée dans le registre instruction.
L’UAL peut effectuer les opérations suivantes (en gras italique les opérations réalisées par la
grande majorité des µP) :
• opérations arithmétiques (les mots manipulés sont représentatifs de nombres)
addition en base 2
addition en DCB
soustraction
incrémentation, décrémentation
multiplication, division
comparaison entre 2 nombres
• opérations logiques
opérations de base sur des mots binaires non, et, ou, ou exclusif
décalage et rotation

8.2.2 RESULTAT DE LA DERNIERE OPERATION / BITS D’ETAT
A l’UAL est associé un registre qui contient des bits donnant des informations sur le résultat de la
dernière opération. Ces bits sont appelés bits d’état (status bits) ou drapeaux (flags). La grande
majorité des µP disposent des informations suivantes :
• résultat égal à 0
• résultat négatif (MSB à 1)
• retenue
• dépassement de capacité
Le registre contenant les bits d’état peut aussi contenir des bits réservés à d’autres usages.
Le nom de ce registre dépend des constructeurs. Quelques exemples de noms :
• registre d’état (status register). Nom utilisé si le registre n’a que cette seule utilité
• registre code condition (Code Condition Register). Chez Motorola ; ce registre contient des
bits réservés à d’autres usages
• mot d’état du programme (Program Status Word). Chez Intel ; ce registre contient des bits
réservés à d’autres usages
8.2.3 OPERANDE(S) ET RESULTAT DE L’OPERATION / REGISTRES ASSOCIES
Le ou les opérandes sont rangés dans un (ou plusieurs) registre(s) interne(s) du µP ou de l’unité
centrale du µC ou en mémoire externe.
Pour les opérations à un opérande (complémentation, décrémentation, mise à 0, …), l’opérande

peut être :
• dans un registre interne. L’opérande a été auparavant chargé dans ce registre depuis la mé-
moire ou l’unité d’échange.
• ou en mémoire externe.
Dans les opérations à 2 opérandes (addition, et logique, …) :

• un des opérandes est dans un registre interne et l’autre opérande est en mémoire externe
• ou les 2 opérandes sont dans des registres internes.
Selon les µP ou µC, le résultat de l’opération est rangé :

• nécessairement dans le registre interne qui contenait un des opérandes (qui est « écrasé »).
Dans ce cas le µP dispose d’un (ou deux) registre(s) spécialisé(s) pour contenir le (ou les)
opérande(s) et le résultat de l’opération. Ce(s) registre(s) se nomme(nt) : accumulateur (µP
Motorola, …), registre de travail W (PIC de MicroChip)
• ou dans un des registres internes généraux, si le µP ne dispose pas de registre spécialisé
8.2.4 EXEMPLES DE FONCTIONNEMENT D’UAL D’UN µP MOTOROLA
La figure suivante représente un ALU et 2 registres spécialisés, les A B

accumulateurs A et B, d’un µP Motorola. Ce qui suit est facilement
transposable à un autre µP ou µC.
Chaque entrée de l’UAL peut être connectée :
U.A.L.
• à un accumulateur
• au bus de données externe Fig. 25 : UAL et accumulateurs

La sortie de l’UAL est connectée à un des 2 accumulateurs.
Ces connexions se font à l’aide de bus internes (non représentés) que l’on peut aiguiller.
Un des rôles du séquenceur mentionné plus haut est de commander tous les aiguillages néces-
saires, durant l’exécution d’une instruction.
Addition
On désire réaliser une addition entre le contenu de l’accumulateur A et une constante rangée en
mémoire programme.
La ligne de programme en assembleur est :
ADDA #$10
le contenu de A, par exemple 22h, est additionné à la donnée 10h qui provient du bus de don-
nées. Lorsque l’opération est terminée, l’ancien contenu de A est remplacé par le résultat, ici
32h.
10
A B
A B
32
22
32
Fig. 26 : Addition de l’accumulateur et d’une donnée
Décalage sur un mot binaire
On peut également opérer un décalage à gauche de A avec l’instruction

ASLA (qui signifie Arithmetic Shift Left A)
Si on suppose que A contient initialement 94h soit 10010100b alors le résultat du décalage est
00101000b soit 28h.
A B A B A B
1001 0100 1001 0100 0010 1000
1001 0100 1001 0100 0 01010 1000
a) chargement de A dans b) décalage c) stockage du résultat

l’U.A.L.
Fig. 27 : Décalage à gauche de l’accumulateur
8.3 SEQUENCEUR
Nous avons vu que le microprocesseur recherche puis exécute automatiquement les instructions
stockées en mémoire. L’enchaînement de ces opérations est commandé par un circuit séquen-
tiel. Le séquenceur a déjà été introduit dans les exemples sur l’ULA.
Le séquenceur génère :
• les signaux du bus de commande ( RD,WR , etc.),
• les signaux internes aux µP (gestion des registres, de l’A.L.U., aiguillages des bus internes,
etc.).

Le séquenceur est réalisé avec une structure qui comprend une mémoire ROM intégrée. Celle-ci
contient des micro-instructions (à ne pas confondre avec les instructions contenues dans la mé-
moire programme). La mémoire des micro-instructions n’est pas accessible à l’utilisateur. Cha-
cune des phases décrites en 5.2) nécessite plusieurs micro-instructions et donc plusieurs cycles
d’horloge.
8.3.1 HORLOGE DU SEQUENCEUR
Les signaux (externes et internes) produits par le séquenceur sont synchrones d’un signal
d’horloge produit par un oscillateur.
L’oscillateur peut être :
• à quartz. C’est le cas le plus fréquent. Il peut être constitué de :
une « circuiterie » interne au µP et un quartz externe.
un oscillateur externe comprenant son quartz et son électronique
• à réseau RC. On rencontre ce cas avec des µC bon marché où la durée précise d’exécution
d’une instruction n’a pas beaucoup d’importance.
8.3.2 DUREE D’EXECUTION D’UNE INSTRUCTION / CYCLE MACHINE
Le temps d’exécution d’une instruction s’exprime en « cycles machine » ; un cycle machine cor-
respondant à un nombre entier de périodes de l’horloge. Selon les constructeurs de µP, on utilise
les termes « cycles machine » (CPU cycle) ou « durée d’état » (state time).
A chacune des phases décrites en 5.2) correspond en général un cycle machine. Pour la durée
de chaque phase, on rencontre 2 cas :
• la durée de chaque phase est fixe. C’est le cas le plus fréquent avec des µP et µC relative-
ment lent (cycle machine > qqs centaines de ns)
• la durée d’une phase comportant un accès à une mémoire ou à une unité d’échange externe
est variable, pour permettre des accès à des organes rapides ou lents. En général c’est l’état
d’une broche externe du µP/µC qui détermine s’il faut ou non rajouter des cycles d’horloge.
Par exemple avec un 80C196 avec un quartz de 20 MHz, lors d’un accès à une mémoire
EPROM de temps d’accès élevé, il faut générer une impulsion sur l’entrée READY du µC
pour augmenter la durée de la phase de lecture en insérant des états d’attente (wait state)
dans le cycle machine.
Lorsque la durée de chaque phase est fixe, le constructeur donne pour chaque instruction, sa
durée d’exécution exprimée en cycles machine.
Exemple de durée d’exécution d’une instruction
Pour un 68HC11, la durée de chaque phase (recherche instruction en mémoire, exécution) est
fixe. Un cycle machine correspond à 4 périodes d’horloge. Les instructions durent de 2 à 6
cycles machines. Avec un quartz à 8MHz, un cycle machine dure 500ns ; une instruction est
exécutée en 1 à 3µs.
8.3.3 EXEMPLE DE DECOMPOSITION EN CYCLE MACHINE
Dans l’exemple suivant, la décomposition en cycles correspond aux cycles de recherche et

d’exécution. Il n’en est pas toujours ainsi.
On utilise un µP type 6809. Le microprocesseur va exécuter l’instruction
EOR #$5A

pour laquelle un OU EXCLUSIF est réalisé entre le contenu de l’accumulateur A (E7h par
exemple) et la donnée 5Ah ; le résultat stocké dans A.
On suppose que le code opération est rangé à l’adresse AFFFh. On note (R) le contenu d’un
registre.
1er cycle machine

d'adresse
AFFFh Bus d'adresse
68HC11 CS1 CS2 CS3

PC
Séquenceur
AFFF
A B Mémoire
E7 5A données Interface
RAM parallèle
3D
IR
3D EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 28 : Recherche du code opération
- (PC) est placé sur le bus d’adresses,

- Le registre instruction est chargé avec le code de l’instruction EOR, (IR) = 3Dh,
- (IR) est décodé et le µP sait qu’il doit aller chercher l’opérande à l’adresse suivante,
- PC⇐ (PC)+1.
2ème cycle machine

d'adresse
B000h Bus d'adresse
68HC11 CS1 CS2 CS3

PC
Séquenceur
B000
A B Mémoire
E7 5A données Interface
RAM parallèle
3D
IR
3D EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 29 : Recherche de l’opérande
- (PC) est placé sur le bus,

- La donnée 5Ah est transférée vers l’U.A.L.,

d'adresse
Bus d'adresse
68HC11 CS1 CS2 CS3

PC
Séquenceur
B001
A B Mémoire
BD 5A données Interface
RAM parallèle
3D
IR BD
3D
EPROM
OE RD/WR RD/WR
Bus de donnée
Fig. 30 : Calcul puis stockage du résultat
- le µC exécute l’opération est stocke le résultat dans l’accumulateur,

- puis le PC est préparé pour l’instruction suivante PC ⇐ (PC)+1.
Durant ce 2ème cycle, il y a eu plusieurs phases gérées par le séquenceur.
L’exécution complète de l’instruction dure 2 cycles machine.
8.4 QUELQUES REGISTRES
Un microprocesseur contient des registres (8, 16, 32 voire 64 bits) qui lui permettent de mémo-
riser les informations nécessaires à son bon fonctionnement. Toutes les données et adresses ma-
nipulées par le µP transitent par ces registres.
Leur nombre est variable d’un µP à l’autre. Il n’est possible de les présenter dans leur ensemble
qu’après avoir vu d’autres parties (déroulement d’un programme, modes d’adressage, …)
Quelques registres, fondamentaux, sont dans sur tous les composants. Certains ont déjà été pré-
sentés précédemment.
Registre d’adresse
Il contient l’adresse déposée sur le bus d’adresses. Elle peut correspondre à l’adresse d’une ins-
truction, d’une constante, d’une variable, d’un registre d’une unité d’échange, … Dans certains
cas, le contenu du compteur ordinal est transféré dans ce registre
Compteur Ordinal (CO)
Ce registre, également appelé Compteur Programme (Program Counter -PC) contient l’adresse
de l’instruction à exécuter. Le contenu de CO est placé sur le bus d’adresses, via le registre
d’adresse, pendant le cycle de recherche de l’instruction en mémoire (cycle Fetch) puis il est
automatiquement incrémenté afin de pointer la prochaine instruction.

Registre Instruction (RI)
Il contient le code de l’instruction à exécuter. Ce code est celui qui vient d’être lu en mémoire
programme. La logique de décodage d’instruction du µP analyse le contenu de RI pour détermi-
ner la tâche à effectuer. Le séquenceur est commandé à partir de RI.
Remarque : On a vu comment, sur un µP de type 6809 ou 68HC11, certaines instructions per-

mettent d’accéder aux registres. Par exemple l’instruction ADDA permet d’additionner une va-
leur à A, JMP permet de forcer le contenu de CO donc de « sauter » à une instruction donnée,
etc.
En revanche, RI n’est pas accessible au programmeur.
9 LES INSTRUCTIONS ET LES MODES D’ADRESSAGE
Le jeu d’instruction d’un µP/µC permet d’assurer un modèle de calcul universel. Tous les µP/µC
disposent donc de catégories d’instructions communes et dans ces catégories des instructions
similaires.
9.1 CATEGORIES D’INSTRUCTIONS
Bien que chaque microprocesseur ait un jeu d’instruction propre, il est toujours possible de clas-
ser ses instructions dans une des 4 catégories suivantes :
a) Les instructions de transfert :

- Mémoire ⇔ Accumulateur ou registre,
- Accumulateur ou registre ⇔ accumulateur ou registre.
b) Les instructions de traitement : +, -, x, ET, OU, décalages, etc.
c) Les instructions de branchement ou rupture de séquence :

- branchement inconditionnel,
- branchement conditionnel (en fonction des registres ou des drapeaux - flags).
d) Les instructions de gestion de l’U.C. : interruptions, modes STOP, WAIT, etc. (voir suite).
9.2 NOMBRES D’OPERANDES
Les instructions peuvent nécessiter 0, 1 ou 2 opérandes. Par exemple la décrémentation d’un

registre ne nécessite qu’un opérande ; une addition nécessite 2 opérandes.
Le résultat peut être rangé à la place d’un des opérandes ou non.
On appelle référence la désignation d’un opérande ou du résultat, que ce soit un numéro de
registre ou une adresse en mémoire. Le nombre de références peut être identique ou non au
nombre d’opérandes selon que le résultat est obligatoirement rangé au même emplacement
qu’un des opérandes ou non.
Exemple : pour une opération du type résultat opérande1 opération opérande2
avec un 68HC11 le résultat est au même emplacement que l’opérande1 (un des accumu-
lateurs)
avec un 80C196, il est possible de ranger le résultat dans un emplacement distinct de
ceux des 2 opérandes.
Les µPs/µCs peuvent être à 2 références max (ex 68HC11) ou 3 références max (ex 80C196).

9.3 JEUX D’INSTRUCTIONS REDUIT / ETENDU
La plupart des µPs et µCs disposent d’un jeu d’instruction assez étendu (plusieurs dizaines).
Une analyse statistique des programmes pour ces µPs et µCs montre qu’ils n’utilisent principale-
ment qu’un nombre réduit d’instructions parmi toutes celles disponibles.
Pour diminuer le temps d’exécution des programmes, certains constructeurs ont développé des
µPs et µCs d’une grande rapidité d’exécution. Presque toutes les instructions peuvent s’exécuter
en un seul cycle machine. En contrepartie, ils ne disposent que d’un jeu d’instruction réduit. Ceci
est possible grâce à l'architecture Harvard (voir plus haut). Les instructions peu fréquemment
utilisées avec les µPs et µCs à jeu d’instruction étendu sont ici réalisées avec plusieurs instruc-
tions. Globalement, le temps d’exécution est cependant plus court.
Les µPs et µCs peuvent donc se classer en :

• CISC (Complete Instruction Set Computer) : jeu d’instruction étendu
• RISC (Reduced Instruction Set Computer) : jeu d’instruction réduit et grande vitesse
d’exécution (grâce à une architecture Harvard)
9.4 FORMAT DES INSTRUCTIONS
Il est inutile à l'utilisateur de connaître le format des instructions, car leurs codes sont produits
automatiquement dans la phase de traduction (compilation ou assemblage). Ce qui suit est très
succinct et donné pour information.
Une instruction peut être codée sur un ou plu- n bits

sieurs mots (en général des octets). Dans beau-
coup de µPs, le code de l’instruction se compose :
• du code opération COP ou code opératoire COP Qn (accès aux opérandes)
(Operation Code –OP-),
• et d’une quantité numérique Qn optionnelle. Fig. 31 : Codage d’une instruction
Le COP indique le type d’opération à effectuer (par exemple une addition, un transfert, etc.)
tandis que le nombre Qn permet d’accéder aux opérandes (s’il y en a !) de l’instruction
Dans les microprocesseurs 8 bits, le COP est codé sur un octet tandis que le nombre d’octets
réservés à Qn est variable.
Dans les µCs d’architecture Harvard de type PIC (Microchip), le COP et Qn tiennent sur un mot
de 12 à 14 bits selon les µCs

Exemples de codages d’instructions pour un µP 6809 de Motorola
a) instruction à b) instruction à 2 octets (ex. c) instruction à 3 octets (ex. SUBA $C570)

1 octet (ex. ORAA #$20)
CLRA), Qn
n’existe pas
Octet 1 Octet 1 Octet 2 Octet 1 Octet 2 Octet 3
4 F 8 A 2 0 B 0 C 5 7 0
COP COP Qn COP Qn

Mise à 0 de A OU logique entre A et soustrait la donnée (l’opérande) stockée à
l’opérande 20h. COP=8Ah l’adresse C570h de l’accumulateur.
représente l’opération ORA, COP=B0h, Qn, sur 2 octets, représente
Qn représente directement l’adresse de l’opérande.
l’opérande, soit 20h.
Fig. 32 : Format des instructions dans les µP 8 bits
Exemple de codage d'instruction pour un µC PIC 16C5x de MicroChip
Le nombre de bits réservés pour le code opératoire dépend du type d'instruction.
Instructions sur des constantes Exemple : ANDLW 20h (ET entre W et 20h =
0010 0000b)
11 10 9 8 7 6 5 4 3 2 1 0 11 10 9 8 7 6 5 4 3 2 1 0
COP constante 1 1 1 0 0 0 1 0 0 0 0 0
9.5 MODES D’ADRESSAGE
On a vu dans les exemples précédents que la quantité Qn peut, suivant le cas, aussi bien repré-
senter l’opérande, que son adresse en mémoire, etc.
En pratique, pour une même instruction, la façon d’accéder aux opérandes dépend du mode
d’adressage (MA) utilisé. Le mode d’adressage est codé dans le COP. Ce codage dépend du µP
et n’intéresse pas l’utilisateur. Le COP est automatiquement généré à partir du mnémonique lors
de la phase d’assemblage ou de compilation.
Selon les instructions, il peut y avoir un ou plusieurs modes d’adressage possibles. Une instruc-
tion de mise à 0 d’un registre spécifié correspond seulement au COP. Pour une instruction
d’addition, le premier opérande est dans un registre et le 2ème opérande peut-être placé à plu-
sieurs endroits (constante dans la mémoire programme, variable dans un registre interne, va-
riable dans la mémoire des variables). Il y donc plusieurs modes d’adressage possibles pour
l’addition.
Les modes d’adressages possibles dépendent des µPs et µCs. Néanmoins tous disposent de pos-
sibilités de base décrites plus loin.
Certains modes d’adressage sont prévus pour un accès aux données organisées de certaines
façons. Ci-dessous, on montre que le mode d’adressage indexé permet d’utiliser des tableaux.
Voir § 8.5.2 / Adressage indexé et utilisation de tableau.
Les emplois de tous les modes d’adressage ne peuvent être décrits dans cette introduction.

9.5.1 ÉCRITURE DES INSTRUCTIONS ET DES MODES D’ADRESSAGE LANGAGE D'AS-
SEMBLAGE
En général une instruction complète s’écrit avec son mnémonique qui ne dépend pas du mode
d’adressage suivi de la ou des références (emplacement du résultat, opérande(s) ou emplace-
ment(s) du ou des opérandes)
ex : en langage d'assemblage 68HC11,

ANDA #%0110 1111 signifie effectuer un ET logique entre contenu de A et 0110
1111. Le résultat est rangé dans A (2 références et 2 opérandes : A, 0110 1111)
ANDA $4000 signifie effectuer un ET logique entre contenu de A et le contenu de
l’adresse 4000h. Le résultat est rangé dans A.
ex : en langage d'assemblage 80C196,

ANDB 20h, 30h,#0110 1111b signifie effectuer un ET logique portant sur des mots
de 8 bits (B : Byte) entre le contenu du registre d’adresse 30h et 0110 1111. Le ré-
sultat est rangé dans le registre d’adresse 20h (3 références et 2 opérandes)
Pour les µC d’architecture Harvard de type PIC (Microchip), chacun des mnémoniques (peu
nombreux) correspond à un mode d’adressage.
ex : en langage d'assemblage PIC,
ANDLW 0110 1111b signifie effectuer un ET logique entre le contenu du registre W
et 0111 1111 (« litteral ») AND Litteral and W
ANDWF 0011b,0 signifie effectuer un ET logique entre le contenu du registre W et
le contenu du registre f d’adresse 0011, le résultat est rangé dans le registre f de dé-
part (dernier 0)
Les différents modes d’adressage sont mentionnés par les règles d’écritures propres à chaque
assembleur spécifique à un µP ou µC.
9.5.2 QUELQUES EXEMPLES DE MODES D’ADRESSAGE
Les modes d’adressages possibles dépendent des µPs et µCs. Pour connaître les modes
d’adressage de chaque µP ou µC, il faut se référer à sa documentation technique détaillée.
Les 3 premiers modes d’adressage de la liste ci-dessous se retrouvent dans tous les µPs. Les
modes d’adressage suivant sont quelques exemples parmi ceux disponibles sur les µPs/µCs des
familles Intel ou Motorola.
Certains constructeurs utilisent le terme adresse effective (EA Effective Address) pour désigner
l’adresse véhiculée sur le bus d’adresse qui correspond à l’emplacement mémoire ou au registre
qui contient l’opérande.
Adressage inhérent ou implicite
Le mnémonique et le code opératoire qui le traduit contient toute l’information pour l’instruction
à exécuter
Exemples (68HC11) : CLRA, NOP, etc.

Adressage immédiat
L’opérande est une constante qui est donnée sur la ligne de l’instruction (après le mnémonique
et la ou les autres références éventuelles). En mémoire, on trouve donc le code opératoire suivi
l’opérande (après le codage des éventuelles autres références).
Lorsqu’il y a plusieurs opérandes, le mode d’adressage immédiat ne concerne qu’un opérande.
La constante est dans Qn.
Exemples (68HC11) : LDAA #$B0Qn = B0h et le caractère # indique qu’il s’agit du mode
d’adressage immédiat.
Adressage relatif
Ce mode d’adressage est utilisé pour les sauts et les branchements. Il n’est parfois pas mention-
né dans la documentation des µPs qui en disposent, car son emploi est transparent à l’utilisateur
en langage d'assemblage. En effet il est employé avec des instructions du type « SAUT eti-
quette », avec « etiquette » placée en début de ligne de programme à atteindre. Après assem-
blage, « etiquette » sera remplacée par le déplacement à ajouter à l’adresse de l’instruction de
saut pour atteindre l’adresse de l’instruction désirée. Le déplacement peut être positif ou négatif.
Adressage indexé et utilisation de tableau
Ce mode d’adressage a de nombreuses variantes. Il permet, entre autres, d’accéder aux élé-
ments d’un tableau. Un tableau est constitué de plusieurs éléments avec un seul nom. Ce nom
correspond à l’adresse de début du tableau.
L’adresse effective de l’opérande est égale à une base + un déplacement. Le registre d’index
peut contenir le déplacement par rapport au début du tableau nécessaire pour atteindre un élé-
ment de ce tableau. La base est alors l’adresse de début du tableau.
Le registre d’index est un registre interne au µP ou à la CPU du µC qui peut être spécifique ou au
contraire un registre général utilisé pour cet emploi.
Exemples :
Intel 80C196 : LD AX, Table[BX] ; charger (LoaD) le registre AX avec l’opérande dont
l’adresse effective est égale à l’adresse de début du tableau Table + le contenu du registre BX
(registre général qui contient le déplacement).
Pour savoir comment est défini le nom Table, voir le §13 et plus particulièrement le § 13.2.
Motorola 68HC11 : ADDA Table,X ; ajouter au contenu de A l’opérande d’adresse effective
égale à l’adresse de début du tableau Table + le contenu du registre X (registre d’index spéci-
fique)
Pour savoir comment est défini le nom Table, voir le §13 et plus particulièrement le § 13.2.
Adressage étendu (Motorola)
L’adresse effective de l’opérande suit le mnémonique. Si l’adresse effective est sur 16 bits, dans
la mémoire, l’adresse effective est rangée dans les 2 octets qui suivent le code opératoire.
Qn correspond donc à l’adresse effective.
Exemple : LDAA $C000Qn = C000h.

Adressage registre (Intel)
Les opérandes sont dans des registres internes du µP/µC, le résultat de l’opération est lui aussi
dans un registre.
Exemple : ADD AX, BX, CX signifie additionner les contenus des registres BX et CX et placer
le résultat dans AX
10 DEROULEMENT D’UN PROGRAMME
Les différentes étapes rencontrées lors du déroulement d’un programme sont :

• lancement après la mise sous tension ou une réinitialisation
• déroulement normal
• interruption sur événement extérieur
• modes de fonctionnement spéciaux (test après fabrication, arrêt, …). Ces modes ne sont pas
traités dans cette introduction
Lors du déroulement d’un programme il est nécessaire de mémoriser certains registres dans une
zone de la RAM avec un fonctionnement particulier : la pile.
10.1 LA PILE ET LE DEROULEMENT D’UN PROGRAMME
Dans les phases décrites § 9.2 et suivants, le µP va devoir sauvegarder automatiquement puis
récupérer certains registres. L’utilisateur peut lui aussi procéder de façon identique à une sauve-
garde ou restitution automatique à l’aide d’instructions spécifiques.
La pile est une zone de RAM que l’utilisateur Ad-5

réserve pour sauvegarder des données tempo-
Ad-4
raires. La pile est toujours associée au registre
pointeur de pile (interne au µP) ou stack poin- Ad-3
ter SP qui pointe le premier emplacement libre Haut de la pile Ad-2
de la pile. Ci-contre, représentation d’une pile : Donnée 1
Ad-1 SP
Bas de la pile Ad Donnée 0
Avec certains µC (PIC par exemple), la pile est
une zone mémoire particulière de taille fixe RAM
Fig. 33 : exemple de pile
La sauvegarde d’une donnée sur la pile peut s’effectuer automatiquement (voir §9.2 et suivants)
ou à l’aide d’une instruction écrite par le programmeur.
La sauvegarde d’une donnée s’effectue comme suit :

• le µP place sur le bus d’adresse le contenu de SP et la donnée à sauvegarder sur le bus de
données. La donnée est stockée (empilée) sur le sommet de la pile par une écriture,
• SP est automatiquement décrémenté pour pointer le prochain emplacement libre.

Ad-5 Haut de la pile Ad-5 SP
Ad-4 Ad-4 PC2
Haut de la pile Ad-3 SP Ad-3 PC1
Ad-2 Donnée 2 Ad-2 Donnée 2
Ad-1 Donnée 1 Ad-1 Donnée 1
Bas de la pile Ad Donnée 0 Bas de la pile Ad Donnée 0
a) état de la pile après sauvegarde d’un nou- b) état de la pile après sauvegarde automa-
velle donnée (ex : registre) tique du compteur programme PC
(PC1 (8bits) + PC2 (8bits) = PC (16 bits):
Fig. 34 : État de la pile après empilement
La récupération d’une donnée sur la pile peut être elle aussi automatique ou réalisée avec une
instruction programmée par le programmeur.
Ad-5
Ad-4
Haut de la pile Ad-3 SP
Ad-2 Donnée 2
Ad-1 Donnée 1
Bas de la pile Ad Donnée 0
Fig. 35 : État de la pile après récupération automatique du PC
On voit que la dernière donnée récupérée est nécessairement le dernière donnée enregistrée
sur la pile d’où l’appellation LIFO (Last In, First Out) pour ce type de mémoire.
C’est l’utilisateur qui fixe la zone de RAM affectée à la pile en utilisant une instruction
d’initialisation du pointeur de pile (chargement de la valeur du bas de la pile qui est l’adresse la
plus haute) à l’aide d’une instruction spécifique.
Avec certains µCs (PIC par exemple), l’utilisateur n’a pas accès au pointeur de pile. La gestion de la
pile est toujours automatique.
Exemple d’utilisation 0000h

On dispose d’une RAM de 512 octets, on choi- 256
octets de
sit de réserver les 256 octets inférieurs à des données
données tandis que les 256 octets supérieurs 00FFh
sont réservés à la pile. 0100h
256
octets de
pile
Remarque Bas de la pile 01FFh SP
La pile progresse vers le haut au fur et à me- RAM
sure des empilages. Par conséquent si plus de
Fig. 36 : Exemple d’initialisation de la pile
256 octets, pour l’exemple précédent, sont
empilés successivement, les données enregis-
trées dans la zone de RAM située sous la pile
peuvent être écrasées : il y a débordement de
la pile (stack overflow).

10.2 DEROULEMENT NORMAL
En général, on décompose un programme complexe en plusieurs programmes plus simples et

d’usage général.
Quelques-uns des avantages de la décomposition en sous-programmes sont :
• mise au point facilitée
• maintenance plus facile
• taille du programme plus courte si un sous programme est utilisé à plusieurs endroits
Un programme est donc composé d’un programme principal et de sous-programmes.
10.2.1 DEROULEMENT SIMPLIFIE LORS DE L’APPEL D’UN SOUS PROGRAMME
Après son implantation dans la mémoire programme d’un système à µP/µC, le déroulement sim-
plifié d’un programme & sous programme est montré sur la figure suivante :
exécution d’une partie du MEMOIRE PROGRAMME

adresses
programme principal 1000h
instruction d’appel du sous

1
programme avec l’adresse de 1200h appel SP d'adresse 3000h
début de ce sous-programme 1200h+N
2
Saut au sous programme 1400h appel SP d'adresse 3000h
1200h+N
Exécution du sous programme
3
1500h appel SP d'adresse 3000h
1500h+N
N dépend du µC. Avec un
PIC, N = 1.
3000h 1ère instruction SP
3 2
retour au programme appelant 1
On voit que l’adresse de retour au programme appelant est différente pour les 3 exécutions du
sous programme. Cette adresse est mémorisée dans une zone mémoire particulière : la pile.
Lorsqu’un sous programme appelle un autre sous programme, la pile contient 2 adresses de re-
tour.
La gestion de la pile est automatique. Avec la plupart des µPs/µCs, il ne faut pas oublier
d’initialiser le pointeur de pile. Avec un PIC, il n’y a pas de pointeur de pile.
Avec un PIC 16F876/877, la pile ne peut contenir que 8 adresses de retour.
Les ressources du µP (registres, …) utilisées lors de l’exécution du programme principal et d’un

sous programme sont les mêmes. Il est nécessaire de sauvegarder les registres modifiés par le
sous programmes dont les contenus sont utilisés dans la suite du programme principal.
La pile est utilisée pour sauvegarder les informations précédentes.

L’adresse de retour (contenu du compteur programme) et les registres sauvegardés constituent
le contexte.
10.2.2 DEROULEMENT DETAILLE
• exécution d’une partie du programme principal

• instruction d’appel du sous programme avec l’adresse de début de ce sous-programme le
µP effectue sauvegarde dans la pile de l’adresse de retour au programme principal (empi-
lage). Cette opération prend plusieurs cycles. Elle est effectuée de façon automatique et
transparente à l’utilisateur.
• le µP place sur le bus d’adresse l’adresse du début du sous programme et recherche le 1er
code opératoire. L’exécution du sous programme commence. Les premières instructions
peuvent permettre une sauvegarde de certains registres en RAM.
• exécution du sous programme. Les dernières instructions peuvent permettre une récupéra-
tion des registres sauvegardés
• en fin de sous programme, instruction de retour au programme principal le µP récupère
dans la pile l’adresse de retour au programme principal (dépilage).
• le µP place sur le bus d’adresse l’adresse de la suite du programme principal et recherche le
code opératoire de l’instruction. L’exécution de la suite du programme principal a lieu.
Le pointeur de pile doit impérativement avoir été initialisé en tout début de programme princi-
pal.
10.2.3 ÉCRITURE ET APPEL DE SOUS PROGRAMME DANS LE PROGRAMME SOURCE
Ces opérations sont très faciles. Avec l’utilisation d’étiquettes, il n’y a même pas besoin de con-
naître l’adresse physique exacte de l’emplacement d’un sous programme. Voir le § Structure
d’un programme source.
Il ne faut pas oublier d’initialiser le pointeur de pile.
Exemples
en langage d'assemblage en langage d'assemblage
68HC11 80C196
appel sous programme, placé JSR NomProgramme* CALL NomProgramme
dans le programme principal (Jump to SubRoutine)
retour au programme principal, RTS RET

place en fin de sous pro- (ReTurn from Subroutine) (RETurn)
gramme
* NomProgramme est traduit lors de l'assemblage par l'adresse de début du sous programme
10.3 INTERRUPTION
10.3.1 PRESENTATION
Le µP exécute les instructions en séquence. Souvent, il est nécessaire d’interrompre un pro-

gramme sur réception d’un signal externe imprévisible (par exemple un poussoir enfoncé par un
opérateur).
Un autre programme, dit gestionnaire d’interruption (interrupt handler) ou programme de trai-
tement d’interruption (Interrupt Service Routine, ISR) ou plus simplement programme
d’interruption, associé à l’appel est alors exécuté.

A : programme principal
Programme
en cours
B : programme d'interruption
Exécution de B
Exécution de A Exécution de A
A B A
t
Evénement Fin de B
extérieur
(appel de B)
Fig. 37 : Principe d’une interruption
Une fois que l’interruption à été servie (exécutée) le programme principal reprend son cours à
partir de l’endroit où il a été interrompu.
Remarque
• A peut être interrompu à n’importe quel instant par B (événement imprévisible),
• A et B utilisent les mêmes registres de l’U.C.,
2 possibilités selon les µP / µC :

• tous les registres sont sauvegardés automatiquement avant le début du programme
d’interruption puis restitués avant le retour au programme principal. Ceci n’est possible
qu’avec des µP / µC avec peu de registres internes (ex : 68HC11)
• seul le compteur programme est sauvegardé puis restitué (ex : PIC). Le programmeur doit
prendre soin de sauvegarder puis restituer les registres qu’il va modifier.
Il est indispensable de mémoriser l’adresse de l’instruction à exécuter dans le programme princi-

pal lors du retour du programme d’interruption. Cette mémorisation s’effectue dans la pile.
Les interruptions sont utilisées :

• Avec les unités d’échanges pour la gestion des échanges. Ex : sur une liaison avec un péri-
phérique lent (tel qu’une imprimante), l’accusé de réception de ce dernier à l’envoi d’une
donnée peut déclencher une interruption. Le traitement de celle-ci consiste à envoyer une
nouvelle donnée. Avant que le périphérique accuse réception, le µP a le temps de faire
autre chose.
• Avec des interfaces d’un µP (internes dans le cas d’un µC) tels que temporisateur, … (voir
plus loin)

10.3.2 DEROULEMENT SIMPLIFIE D’UNE PROCEDURE D’INTERRUPTION
EXECUTION DE A
EVENEMENT
Exécution de l'instruction en cours
Sauvegarde automatique du compteur programme
(adresse de retour pour suite de A)
Sauvegarde automatique des registres
Appel du programme d'interruption
INST 1
INST 2
Exécution du
programme
d'interruption
Instruction de retour au programme principal
(RTI pour le 68HC11)
Restitution automatique des registres

Restitution automatique du compteur programme
EXECUTION DE A
Fig. 38 : Sauvegarde puis restitution du contexte de A
On note une certaine similitude entre les sous-programmes et les routines d’interruption mais
pour les interruptions :
• l’appel est déclenché par un événement externe,
• la sauvegarde des registres est indispensable (sur certain µP ou µC comme le 68HC11 cette
sauvegarde ainsi que la restitution des registres est automatique).
Les registres et le compteur programme sont sauvegardés dans la pile. La procédure est transpa-
rente à l’utilisateur qui doit cependant s’assurer du bon fonctionnement de la pile.
10.3.3 DEROULEMENT DETAILLE
• lorsqu’une demande d’interruption intervient, le µP termine l’instruction en cours

• le µP inhibe les autres demandes d’interruption
• le µP sauvegarde dans la pile le compteur programme et avec certains µP/µC tous les re-
gistres (empilage)
• le µP place sur le bus d’adresse l’adresse du début du programme d’interruption. 2 façons
de procéder :
le µP charge dans le compteur programme le contenu d’une zone mémoire programme
(2 octets pour une adresse sur 16 bits) parfaitement définie qui est fonction de
l’interruption demandée. Ce contenu correspond à l’adresse de début du programme
d’interruption. Ces opérations prennent plusieurs cycles et sont transparentes à
l’utilisateur. Ce mécanisme correspond à la vectorisation des interruptions. A chaque in-
terruption correspond un vecteur d’interruption. (mécanisme utilisé par le 68HC11, le
80C196, etc.)
le µP place sur le bus d’adresse une adresse unique pour toutes les sources
d’interruptions (ex : sur un PIC, l’adresse est 4). L’utilisateur doit écrire dans son pro-
gramme d’interruption des instructions pour rechercher la source de l’interruption.
• après avoir placé sur son bus d’adresse l’adresse du programme d’interruption qu’il vient de
charger, le µP recherche le code opératoire de la 1ère instruction. Le programme
d’interruption s’exécute ensuite.

• en fin de programme d’interruption, une instruction demande le retour au programme
principal
• le µP récupère depuis la pile tous les registres (avec certains µP/µC uniquement) et le
compteur programme (dépilage).
• le µP autorise les autres demandes d’interruption
• le µP place sur le bus d’adresse la valeur récupérée et recherche le code de la prochaine ins-
truction
• l’exécution du programme en cours avant l’interruption se poursuit
10.3.4 IDENTIFICATION DES SOURCES D’INTERRUPTION
Les sources d’interruption sont :

• les unités d’échanges et périphériques, … connectées en externe au µP (cas d’un système à
µP) ou internes au µC. Ceci permet, par exemple, de demander une interruption dès qu’une
nouvelle information a été appliquée en entrée d’une unité d’échange
• des événements tels que front ou état appliqués directement sur le µP ou la CPU du µC sans
passer par une unité d’échange
Les connexions pour les demandes d’interruption sont réalisées de la façon suivante :
Représentation simplifiée pour les interruptions (bus, mémoires, … non représentés)

pour un µC pour un système à µP
unité unité
d'échange entrées d'échange
entrées INT1 interne 1 d'inter-
INT1 1
d'inter- INT2 ruption
INT2
INT3
ruption INT4
unité unité
d'échange d'échange
interne 2 2
CPU µP
... ...
µC Système à µP
Fig. 39 : liaisons de demandes d’interruption dans µC Fig. 40 : liaisons de demandes d’interruption dans un
système à µP
Dans le système à µP de l’exemple, une demande d’interruption provoquée par l’unité 1 ou

l’unité 2 ou une autre unité active l’entrée d’interruption INT2.
Un µC peut reconnaître chaque source d’interruption. A chacune de ces sources, on peut attri-
buer un programme d’interruption différent. L’identification d’une source d’interruption permet
de lui affecter une priorité. Un µC peut disposer d’un grand nombre de sources d’interruption
identifiable (ex : 21 pour le 68HC11).
La plupart des µPs et les CPUs de certains µCs disposent d’assez peu d’entrées d’interruption (2
à 4), alors qu’il y a souvent plus de sources d’interruption. La CPU d’un PIC ne dispose que de 2
entrées d’interruption.
Il n’est pas possible d’identifier directement chaque source d’interruption. Dans l’exemple pré-
cédent, lorsqu’une unité d’échange demande une interruption, c’est l’entrée INT2 qui est acti-

vée. Le programme d’interruption associé devra recherche l’unité qui a demandé l’interruption,
en lisant successivement leurs registres internes d’état.
Pour qu’un µP puisse identifier rapidement une source d’interruption, il faut lui adjoindre un cir-
cuit spécialisé, le contrôleur d’interruption.
10.3.5 PRISE EN COMPTE DES INTERRUPTIONS
Certaines interruptions peuvent être masquées, c’est-à-dire qu’elles ne sont pas prises en
compte.
Pour les interruptions masquables, l’autorisation ou l’inhibition peut se faire :

• globalement
• individuellement
autorisation / inhibition interruption contrôle

globale, pour toutes les sources un bit d’un registre de contrôle dans un µP ou
d’interruption masquables la CPU d’un µC
individuelle un bit dédié à chaque interruption dans un
registre de contrôle dans un µP ou la CPU
d’un µC
Remarque : certains µCs (tel le PIC) ont 3 niveaux : autorisation globale, autorisation pour tous les
périphériques, autorisation individuelle
Les demandes d'interruptions peuvent être mémorisables ou non. Si une demande intervient un
court instant puis disparaît et n'est pas mémorisée, elle n'est pas prise en compte si les interrup-
tions sont masquées. Si elle est mémorisée, elle sera prise en compte et servie dès que les inter-
ruptions seront autorisées.
10.3.6 TRAITEMENT DES INTERRUPTIONS / IMBRICATION DES INTERRUPTIONS
En plus de ce qui est indiqué en 9.3.2 et 9.3.3, lors du traitement d'une interruption, le µP inhibe
globalement toute demande d'interruption masquable, par positionnement d’un bit dans un re-
gistre de contrôle. Ceci permet d'éviter qu'une nouvelle interruption intervienne de façon indési-
rable lors du traitement d'une interruption précédente. En fin d'interruption, les interruptions sont
de nouveau globalement autorisées.
Le programmeur a le choix de prévoir la possibilité d'interruptions imbriquées, en validant globa-

lement les interruptions à l'aide d'une instruction dans le programme d'interruption.
Le programme est dans ce cas beaucoup plus difficile à concevoir. Attention au risque de dé-
bordement de pile

10.3.7 PRIORITE DES INTERRUPTIONS
La plupart des µPs/µCs permettent d’établir des priorités entre interruptions. Certains µCs n’ont
pas de priorité entre les interruptions (ex : PIC).
La priorité des interruptions intervient lorsque plusieurs demandes d'interruptions sont en attente
de traitement. Ceci correspond à plusieurs cas :
• le programme est en déroulement normal et plusieurs demandes surviennent avant leur prise
en compte (fin de l'instruction en cours).
• une interruption est en cours de traitement avec inhibition globale des nouvelles demandes
d'interruptions et plusieurs demandes surviennent avant la fin du traitement.
L'interruption en attente servie en 1ère est la plus prioritaire.
Détermination de la priorité d’une interruption
Dans un µC, l’ordre de priorité est fixé par le constructeur. Quelques fois, il est possible à
l’utilisateur de modifier un ordre de priorité par défaut, en écrivant un mot dans un registre de
configuration.
Dans un système à µP, il n’existe une priorité qu’entre les quelques entrées d’interruption dispo-
nibles. Dans le cas où il y a de nombreuses unités d’échange, il est possible de fixer un ordre de
priorité en intercalant un circuit spécialisé, un contrôleur d’interruption, entre le µP et les unités
d’échange, …
10.3.8 LES INTERRUPTIONS DANS LE PROGRAMME SOURCE
Avec des interruptions vectorisées (cas le plus fréquent), le programmeur doit écrire les pro-
grammes d’interruption, et remplir la zone mémoire qui contient les vecteurs d’interruption
(adresses de début des sous programmes d’interruption). Ceci s’effectue de façon très simple au
niveau de l’écriture du programme source, avec l’emploi d’étiquette qui permet de ne pas con-
naître l’adresse physique exacte de début d’un programme d’interruption. Voir § sur la structure
du programme source.
La zone mémoire des vecteurs d’interruption est donnée dans la documentation technique des
µPs ou µCs.
Avec des interruptions non vectorisées et une adresse unique pour toutes les sources
d’interruption (ex PIC), le programmeur doit écrire le programme d’interruption à partir de
l’adresse mentionnée dans la documentation. Le programme d’interruption doit commencer par
rechercher la source de l’interruption.
10.3.9 ACQUITTEMENT D’UNE INTERRUPTION
Lorsqu’une demande d’interruption survient un bit spécifique (« flag ») à cette demande est posi-
tionné dans un registre d’état. C’est ce bit qui entraîne le traitement de l’interruption.
En fin de traitement d’une interruption, il faut replacer le bit dans son état initial pour éviter que
le µP/µC ne reparte en interruption : c’est l’acquittement de l’interruption.

10.4 LANCEMENT DU PROGRAMME ET REINITIALISATION
Le lancement d’un programme après la mise sous tension ou après une réinitialisation suite à un
défaut est souvent appelé procédure de RàZ ou RESET. Selon les µPs ou µCs cette procédure
s’apparente ou non à une interruption.
La RàZ est utilisée pour :

• charger un certains nombre de registres internes à des valeurs par défaut. Parmi ces registres,
on trouve des registres de configuration
• forcer le µP ou µC à démarrer l’exécution du programme à une certaine adresse (l’adresse de
départ).
La RàZ peut être commandée :

• par une broche externe souvent notée RESET (sur tous les µP et µC)
• par une instruction spécifique
• par une instruction illégale (mauvais code opératoire)
• par un chien de garde interne (voir § suivant)
La broche RESET est souvent bi-directionnelle : un état actif appliqué de l’extérieur effectue une
RàZ, si une RàZ est commandée en interne (ex : instruction illégale) cette broche est forcée à
son état actif pour commander les périphériques externes qui sont connectés. Cette possibilité
est due à la structure interne pour la broche : une entrée câblée sur une sortie drain ouvert
commandée par la RAZ interne.
10.4.1 COMMANDE EXTERNE DE LA RAZ
La broche RESET est utilisée en entrée.

La commande externe de RàZ peut être effectuée :
• automatiquement à la mise sous tension
• par un circuit externe de détection de défaut (ex : tension d’alimentation insuffisante pour
garantir un bon fonctionnement)
• par une action manuelle sur une touche ou un bouton-poussoir (le dernier recours lorsque
plus rien ne fonctionne !)
Pour un fonctionnement correct de la commande externe au moment de la mise sous tension, il

faut souvent imposer un état actif suffisamment longtemps après l’établissement de la tension
d’alimentation. La réalisation consiste souvent en un circuit RC connecté sur la broche RESET.
10.4.2 ADRESSE DE DEPART DU PROGRAMME PRINCIPAL
L’adresse de départ peut être vectorisée ou non selon les µP/µC.
Adresse non Après une RàZ le µP effectue un certain nombre d’opérations puis dépose sur le
vectorisée bus d’adresse une adresse prédéfinie et recherche le 1er code opératoire. Le pro-
gramme s’exécute.
Par exemple le 80C196 délivre l’adresse 2080h après un RESET

Adresse vec- Après la RàZ, le µP effectue un certain nombre d’opérations puis charge le con-
torisée tenu d’une zone mémoire dans le registre d’adresse. Ce contenu correspond à
l’adresse de départ du programme principal ; il est sur 2 octets (dans 2 empla-
cements mémoire) pour un registre d’adresse de 16 bits. Cette opération dure
quelques cycles et est transparente au programmeur. Le contenu de la zone
mémoire est l’adresse de départ ou vecteur du RESET
Le µP dépose ensuite le contenu du registre d’adresse sur le bus d’adresse et
recherche le 1er code opératoire. Le programme s’exécute.
Exemple : le 68HC11 charge dans son registre d’adresse le contenu des adresses
mémoire FFFEh et FFFFh
Remarque : Certains µP/µC font la distinction entre les différentes commandes de RàZ et dispo-
sent d’un vecteur pour chaque RàZ.
10.5 SURVEILLANCE DU DEROULEMENT DU PROGRAMME : LE CHIEN DE GARDE
Le chien de garde (watch dog) permet de surveiller le bon déroulement d’un programme de la
façon suivante :
• en fonctionnement normal, le programmeur a inséré régulièrement des instructions dans son
programme pour que des actions soient effectuées à intervalles de temps assez réguliers.
Ces actions bloquent le dispositif de RàZ
• lors d’une erreur dans le déroulement du programme (« plantage »), les actions n’ont plus
lieu ou à des intervalles de temps trop espacés. La RàZ intervient alors.
Le chien de garde peut être interne ou externe.
Chien de garde externe
Un chien de garde externe est souvent constitué d’un monostable redéclenchable. Les actions
du programme consistent en des fronts appliqués sur l’entrée d’horloge, via une unité d’échange.
La sortie du monostable est connectée à l’entrée de RESET.
Chien de garde interne
Un chien de garde interne est souvent constitué d’un compteur ou d’un décompteur dont les
sorties évoluent en permanence au rythme d’une horloge interne. Les actions du programme
consistent à écrire un (ou plusieurs) mots dans un registre de contrôle pour réinitialiser le conte-
nu du compteur. En l’absence de réinitialisation, lorsque le contenu passe par une valeur prédé-
terminée (ex 0), une RàZ intervient. Les actions du programme doivent empêcher au compteur
d’atteindre la valeur prédéterminée.
Le chien de garde interne peut être mis en service ou non par programmation d’un bit d’un re-
gistre interne.
Le chien de garde étant commandé avec une horloge issue de l’oscillateur à quartz, si cette hor-
loge a un dysfonctionnement, le chien de garde ne fonctionne plus. Certains µC ont en complé-
ment un circuit de surveillance de l’horloge.
11 STRUCTURE INTERNE / MODELE LOGICIEL D’UN µP OU CPU D’UN µC

11.1 STRUCTURE INTERNE
Les structures internes détaillées des µP varient assez fortement d’un constructeur à l’autre, no-
tamment à cause de la présence ou non de registres spécialisés (accumulateur, …) et des diffé-
rentes façons de gérer la mémoire (modes d’adressage).
Les structures internes des µPs sont souvent très complexes, aussi les constructeurs ne donnent
dans leurs notices techniques que des structures très simplifiées. Celles-ci permettent d’avoir une
vue d’ensemble des registres disponibles mais ne sont pas faites pour une compréhension du
fonctionnement interne (qui est inutile à l’utilisateur).
Exemple de structure interne : 80186 d’Intel
Fig. 41 : Structure interne simplifiée du 80186 d’Intel
A modifier
Dans l’unité d’exécution (partie opérative mentionnée précédemment), on retrouve quelques-
uns des éléments mentionnés en 6): l’ALU, le registre d’état. A est l’accumulateur principal ; B, C
et D peuvent avoir de multiples fonctions. SP est le pointeur de pile ; les registres BP, SI, DI sont
liés au mode d’adressage.
Pour la partie d’interfaçage avec le bus, le registre IS joue un peu le rôle du compteur
programme. Les registres CS, DS, ES, SS sont liés aux modes d’adressage. L’adresse est ici
déterminée en effectuant la somme de 2 registres avec le sommateur Σ.

11.2 MODELE LOGICIEL
La structure interne, même simplifiée, n’est que de peu d’utilité pour l’utilisateur. Certains
constructeurs ne donnent dans leur notice technique que le modèle logiciel ou modèle du
programmeur.
Exemple de modèle logiciel : CPU du 68HC11
Fig. 42 : modèle logiciel CPU 68HC11
Les registres qui apparaissent ici ont tous été décrits précédemment. Le registre « condition
codes » est un registre d’état associé aux accumulateurs A et B et un registre de contrôle pour
les interruptions.
12 LES PRINCIPALES INTERFACES D’UN µP
12.1 INTRODUCTION
Les circuits d’interface ont 2 utilités : la communication avec le monde extérieur, quelques fois
via d’autres circuits, et la communication entre systèmes à µP ou µC. Les circuits d’interface cor-
respondent aux unités d’échange mentionnées au § 4.
On ne traitera ici que des interfaces les plus usuelles qu’on rencontre dans beaucoup de sys-
tèmes à µP et µC.
Les interfaces sont composées de registres accessibles par le µP. C’est à travers ces registres que
s’effectuent les opérations d’entrées/sorties. Ces interfaces peuvent être perçues de deux façons
différentes selon les constructeurs :
• les boîtiers d’E/S sont traités comme des boîtiers mémoire de n adresses (1 par registre) (ex :
µP Motorola de la famille 6800, ... µC de la famille HC11, ...). Les inconvénients consistent
en une perte de place de l’espace d’adressage.
• les E/S correspondent à des instructions spéciales et à des signaux permettant de différen-
cier les transferts mémoires des E/S (ex : pour certains µP Intel). Les avantages sont
l’utilisation d’instructions plus rapides car plus courtes pour les E/S. Les inconvénients sont

une plus grande complexité matérielle et la mobilisation de broches du µP pour les signaux
d’E/S spécifiques.
Chaque interface est constituée, du point de vue de l’utilisateur, de :

• un ou plusieurs registres de contrôle (control register) permettant de définir son fonction-
nement
• un registre d’état (status register) donnant des indications sur le déroulement des opérations
• un ou plusieurs registres permettant le transfert des données, généralement appelés re-
gistres de données (data register) ou registres d’entrée / sortie (input / output register).
Chaque registre a une adresse spécifique.
12.2 CONNEXION D’UN BOITIER D’INTERFACE
Dans un système à µP, un boîtier d’interface se connecte de la même façon qu’un boîtier mé-
moire, sauf en ce qui concerne quelques signaux spécifiques dans certains cas. Voir la figure du
§ 5.1).
Dans un µC, les interfaces sont incluses. Toutefois si on veut accroître leur nombre, il est possible
de le faire avec certains µC. Pour que ceci soit réalisable, le µC doit pouvoir fonctionner en
mode étendu (voir plus loin). Dans ce cas tous les bus sont disponibles, comme sur un µP. On
allie alors les avantages du µP et du µC
12.3 INTERFACES D’E/S PARALLELE
Les échanges avec l’extérieur se font par mots de même taille que le bus de données du µP.
Ce sont les interfaces les plus répandues et les plus simples à mettre en œuvre.
Dans un système à µP, un boîtier d’interface // permet en général d’assurer des échanges avec
plusieurs mots. A chaque mot correspond un port.
Dans de nombreux cas, à chaque port sont associées des broches de contrôle qui seront dé-
crites par la suite pour la gestion des échanges. Ces broches peuvent avoir plusieurs fonctions.
Les échanges peuvent s’effectuer avec ou sans protocole de communication. Les échanges peu-
vent s’effectuer soit dans un sens soit dans l’autre, après programmation du port (écriture d’un
mot dans un registre de contrôle). Quelques fois les échanges peuvent être bidirectionnels avec
nécessairement des signaux pour un protocole de communication.
Après programmation, l’envoi d’une donnée à l’extérieur se fait par écriture dans le registre de
sortie, la lecture d’une donnée de l’extérieur s’effectue par lecture du registre d’entrée.
12.3.1 ÉCHANGES SANS PROTOCOLE DE COMMUNICATION
Les interfaces de ce type sont les plus simples à mettre en œuvre. Les échanges s’effectuent soit
dans un sens, soit dans l’autre.
Le µP envoie des données vers l’extérieur sans se soucier de savoir si elles sont correctement
reçues. De même le µP lit les données de l’extérieur sans savoir si l’organe transmetteur les a
correctement envoyées.
Exemple : Le port E du 68HC11 est utilisable en port parallèle d’entrée sans possibilité de proto-
cole d’échange.

12.3.2 ÉCHANGES AVEC PROTOCOLES DE COMMUNICATION
Il existe plusieurs possibilités. Nous n’aborderons qu’un exemple.

A chaque port sont associés des signaux pour la gestion des échanges. Ce type d’échange et les
signaux nécessaires sont dits « poignée de main » (handshake).
Exemple de Protocole pour des échanges unidirectionnels
donnée prête
à transmettre
adresses
données PORT D'UNE Périphé-
INTERFACE rique
contrôle DONNEE
demande
d'interruption donnée lue
µC ou système à µP
Fig. 43 : Liaisons avec poignée de main entre interface et périphérique
• le µP écrit des données dans le registre de sortie du port activation de la broche « don-
née prêtre à transmettre »
• le périphérique lit la donnée et active la broche « donnée lue ».
• l’activation de la broche « donnée lue » entraîne :
la modification d’un bit d’état d’un registre associé au port
la transmission d’une demande d’interruption (si elle a été autorisée)
la désactivation de la broche « donnée prête à transmettre »
• le µP ou la CPU du µC peut présenter une nouvelle donnée, après avoir auparavant lu le re-
gistre contenant le bit d’état pour réinitialiser celui-ci et annuler la demande d’interruption.
Le fonctionnement pour l’autre sens de fonctionnement se déduit facilement de ce qui pré-

cède.
Pour les différents fonctionnements possibles, se référer à la documentation de chaque inter-
face ou µC.
12.4 INTERFACES SERIES
12.4.1 GENERALITES
Pour réduire le nombre de fils, on utilise des liaisons série : les données sont envoyées bit par bit
sur un fil. Dans ce cas les liaisons minimales sont : un fil pour le transfert des informations dans
un sens, un fil pour le transfert dans l’autre sens, un fil pour la masse. Certaines liaisons séries
nécessitent plus de fils, comme nous le verrons par la suite.
Le µP délivrant les données sous forme parallèle (par mot de la taille du bus de données), il est
nécessaire d’utiliser un circuit d’interface parallèle/série, plus simplement appelé interface série.
Le centre d’un tel circuit est un registre à décalage.

Émission de données Réception de données
horloge horloge
Sortie série Entrée série

Registre à décalage Registre à décalage
Entrée parallèle Sortie parallèle

venant du bus de données vers le bus de données
Fig. 44 : Émission / réception de données série
La sortie série (émetteur) ou l’entrée série (récepteur) s’effectue à la cadence d’une horloge (1
bit par période d’horloge).
L’horloge est souvent générée de façon interne, à partir de l’oscillateur à quartz du µP ou µC.
Il existe souvent plusieurs options de fonctionnement. Le choix retenu s’effectue par écriture
d’un mot dans un (ou plusieurs) registre(s) de contrôle de l’interface série.
Après programmation, l’envoi d’un mot s’effectue par une écriture dans le registre de sortie ; la
lecture d’un mot reçu s’effectue par lecture du registre d’entrée. Pour effectuer ces opérations
aux bonnes dates, on peut utiliser les interruptions générées par une fin d’émission ou de récep-
tion (voir § 10.3)
Il est indispensable que le front de l’horloge qui commande le décalage en réception ait lieu
lorsque le bit transmis est valide, c’est-à-dire suffisamment longtemps après le changement d’état
du bit précédent et suffisamment longtemps avant le changement d’état du bit suivant.
La communication entre récepteur nécessite que les horloges soient :

• de même fréquence et synchrones
• ou de fréquences quasi identiques et quasiment synchrones durant le temps utile de la
communication
Selon que l’on adopte une solution ou l’autre, on obtient 2 types de liaisons :
• Les liaisons synchrones : la transmission est faite au rythme d’un signal d’horloge transmis
avec les données. Les paquets de données (un paquet = un mot de la taille du bus de don-
nées) peuvent être envoyés les uns à la suite des autres, sans temps mort, de manière conti-
nue.
• Les liaisons asynchrones : la transmission est faite de façon discontinue par paquet. Chaque
paquet est de longueur constante et il est repéré par un code de début et de fin. Durant la
transmission d’un paquet, le récepteur génère une horloge de fréquence quasi identique à
celle de l’émetteur, avec les fronts actifs pour le décalage correctement placés par rapport
aux données. En général, l’émetteur et le récepteur doivent avoir été programmés pour
fonctionner à la même vitesse de transmission.
12.4.2 INTERFACES SERIES ASYNCHRONES
Elles sont très utilisées en informatique. Les ports série des ordinateurs PC sont de ce type, à la
norme RS232. Beaucoup de µC intègrent une interface de ce type, mais ne sont toutefois pas
compatibles sur les niveaux de tension. Il suffit d’ajouter un circuit externe pour assurer cette
compatibilité.

Comme l’horloge n’est pas transmise, il faut que l’horloge de réception soit correctement calée
par rapport à l’horloge d’émission. La figure ci-dessous montre une transmission avec une hor-
loge de réception correctement calée par rapport à l’horloge d’émission et avec une horloge de
réception incorrecte.
H
émission
données t
transmises
0 1 1 0 1 0 0 1
H t
réception
correcte
H 0 1 1 0 1 0 0 1 données lues t
réception
mauvaire t
0 1 1 ? 0 0 1 1 données lues
Fig. 45 : Transmission avec horloge réception correcte et incorrecte
Pour synchroniser l’horloge réception sur celle d’émission, le mot à transmettre est encadré d’un
bit de début et d’un bit de fin. Le mécanisme de synchronisation est transparent à l’utilisateur.
La norme RS232 permet plusieurs options et plusieurs vitesses de transmission. Un registre de

contrôle est donc associé à l’interface série asynchrone pour la programmation de la configura-
tion désirée.
Les connexions de la norme RS232 comprennent en plus des liaisons pour les données des si-
gnaux de contrôle des échanges. Les interfaces série ne gèrent généralement pas ces signaux.
Voir documentation de la norme RS232.
12.4.3 INTERFACES SERIE SYNCHRONES
Elles sont utilisées pour :

• la communication entre 2 µCs
• la communication entre 1 µC et un circuit tel que horloge temps réel, mémoire, …
Les informations peuvent être échangées avec des débits élevés et très peu de fils de liaisons.
Les informations sont véhiculées en continu, sans qu’il soit nécessaire de placer des bits de dé-
part et d’arrêt, comme avec une liaison asynchrone. Les échanges se font entre un maître et un
ou plusieurs esclaves.
Les interfaces série synchrones sont pré- données

vues pour que les échanges se fassent Esclave
avec l’horloge délivrée par le circuit Maître H trans- (ex: horloge
maître. A chaque période d’horloge : (ex: µC) mission temps réel
• une donnée est envoyée du maître -heure, date-)
vers l’esclave données
• une donnée est retournée de Fig. 46 : liaison série synchrone
l’esclave vers le maître

Toutes les données échangées n’ont pas toujours une signification (ex : lorsque le maître veut
uniquement écrire dans un registre de l’esclave, ce qui est retourné n’a aucune importance). Un
protocole très strict est à respecter.
Il n’existe pas de normes pour les échanges série synchrones, les associations de circuits via une
liaison série synchrone ne sont souvent possibles qu’entre membres d’une même famille chez un
même constructeur.
Une interface synchrone peut se programmer (vitesse de transmission, position des fronts de
l’horloge par rapport aux données) en écrivant dans son registre de contrôle.
12.5 CONVERTISSEUR ANALOGIQUE NUMERIQUE (CAN)
12.5.1 CAN DANS UN SYSTEME A µP
Il y a 2 possibilités pour la connexion d’un CAN :

• directement sur le bus, comme un autre boîtier. Le CAN est spécialement prévu pour cette
utilisation et possède un registre de sortie 3 états et des signaux pour le contrôle de la con-
version compatibles avec les signaux du bus de contrôle du µP.
• au travers d’une interface parallèle ou une interface série.
12.5.2 CAN INTEGRE D’UN µC
Les CAN intégrés sont à approximations successives. Le lancement d’une conversion s’effectue
simplement en écrivant dans un registre de contrôle. La conversion est précédée d’une phase
d’échantillonnage blocage. Il est donc inutile de placer en externe un échantillonneur bloqueur.
Voir la documentation des µC. Un multiplexeur est souvent placé avant le CAN. La voie à con-
vertir est choisie par programmation.
12.5.3 CAN EXTERNE POUR UN µC
Cette solution n’est à retenir que pour quelques cas particuliers : augmentation de la résolution
par rapport au CAN interne, famille de µC sans CAN (rare), …
Si le µC travaille en mode « circuit seul », la connexion d’un CAN à accès parallèle sur un port
occupe beaucoup de liaison (8 pour un CAN 8 bits, plus des signaux de contrôle du fonction-
nement). Pour diminuer le nombre de liaisons nécessaires, les CAN à accès série sont les plus
utilisés. Ils ne nécessitent que 2 ou 3 liaisons et peuvent se connecter sur le port série synchrone
ou sur des sorties d’un port parallèle. Dans ce dernier cas, le signal d’horloge est créé par logi-
ciel.
12.6 CONVERTISSEUR NUMERIQUE ANALOGIQUE (CNA)
12.6.1 CNA DANS UN SYSTEME A µP
Il y a 2 possibilités pour la connexion d’un CNA :

• directement sur les bus, comme un autre boîtier. Le CNA est spécialement prévu pour cette
utilisation et il a dans ce cas un registre de mémorisation interne.
• au travers une interface parallèle ou une interface série
12.6.2 CNA DANS UN µC

Ils sont rarement intégrés dans un µC. Certains µC (ex : 80C196) intègrent un générateur de si-
gnaux rectangulaires modulés en largeur d’impulsion (MLI ou PWM, Pulse Width Modulation). Il
est possible de réaliser un convertisseur analogique numérique en plaçant en sortie de ce con-
vertisseur un filtre passe bas qui ne laisse passer que la valeur moyenne.
Pour plus de détail, voir documentation des µC disposant de cette possibilité.
12.6.3 CNA EXTERNE POUR UN µC
Si le µC travaille en mode « circuit seul », la connexion d’un CNA à accès parallèle sur un port
occupe beaucoup de liaison (8 pour un CNA 8 bits, plus éventuellement des signaux de contrôle
du fonctionnement). Pour diminuer le nombre de liaisons nécessaires, les CNA à accès série se
développent de plus en plus. Ils ne nécessitent que 2 ou 3 liaisons et peuvent se connecter sur le
port série synchrone ou sur des sorties d’un port parallèle. Dans ce dernier cas, le signal
d’horloge est créé par logiciel.
12.7 COMPTEUR-TEMPORISATEUR (TIMER)
Un compteur temporisateur permet de :

• dater des événements extérieurs. Il permet donc de mesurer des intervalles de temps entre
2 événements (fronts d’un signal). Ceci nécessite un calcul réalisé par le logiciel.
• produire des événements extérieurs (impulsions, signaux périodiques, …)
Un compteur temporisateur dispose de :

• une ou plusieurs entrées spécifiques pour la datation d’événements externes
• une ou plusieurs sorties spécifiques pour la production de signaux
Il existe plusieurs types de temporisateurs. Tous sont bâtis autour d’un compteur ou d’un dé-
compteur qui s’incrémente au rythme d’une horloge la plupart du temps issue de l’oscillateur à
quartz du µP ou µC. La fréquence de cette horloge dépend du quartz et d’un mot de contrôle
écrit dans un registre de contrôle.
Selon les interfaces (externes pour un système à µP ou internes dans un µC), le compteur peut
fonctionner :
• en permanence (mode « free running »)
• uniquement après une validation (externe ou par écriture dans un registre de contrôle).
Dans ce cas, il est aussi possible d’initialiser la valeur du compteur
L’utilisation de compteur « free running » complique un peu le logiciel. Il n’est pas possible dans
cette introduction de détailler cette partie sur les « timers » qui sont les interfaces dont la mise en
œuvre est la moins facile.
Voici juste un exemple de la façon de procéder pour effectuer une mesure d’intervalle de temps.
Exemple :
On désire effectuer une mesure d’intervalle de temps entre un front montant et un front descen-
dant sur un signal externe. Le timer utilise un compteur « free running ».
En simplifiant, les opérations à effectuer sont :

• programmation du timer (fréquence de l’horloge du compteur, entrée à utiliser, front à
prendre en compte, …)
• au front montant, copie automatique du contenu du compteur dans un registre spécifique
• par logiciel (procédure d’interruption par exemple), recopie du registre spécifique dans un
emplacement mémoire. Le contenu du compteur C1 correspond à la date t1.

• reprogrammation éventuelle du timer (attente d’un nouveau front, …)
• au front descendant, copie automatique du contenu du compteur dans un registre spéci-
fique. Le contenu correspond à C2.
• par logiciel, calcul de t2-t1. L’intervalle de temps mesuré vaut (C2-C1)T, avec T= période de
l’horloge du compteur.
Pour cette procédure, il faut de plus s’assurer que le contenu du compteur n’est jamais passé par
0 (débordement)
13 STRUCTURE MATERIELLE D’UN SYSTEME A µP/µC
La structure assez détaillée ne peut être introduite qu’après explication sur les bus d’adresses et
de données.
13.1 BUS D’ADRESSES ET BUS DE DONNEES
Ces bus sont disponibles sur les µP.

Pour les µC, ces bus peuvent :
• ne jamais être disponibles (bus internes uniquement). Le µC travaille uniquement en mode
« circuit seul » (Single chip). (Il faut cependant lui rajouter quelques composants externes
pour qu’il fonctionne)
• être disponibles ou non. Dans le 1er cas, ils sont sortis sur des broches à la place
d’interfaces internes ; dans le 2ème cas, on peut disposer normalement des interfaces. Lors-
que les bus sont disponibles, on peut rajouter des circuits externes, tels des circuits mé-
moires pour étendre les capacités du µC. Le µC peut travailler en mode « single chip » ou en
mode étendu (extended).
Ces bus complets nécessitent beaucoup de connexions. Il est possible de diminuer le nombre de
broches à utiliser avec la technique du multiplexage temporel.
13.1.1 MODE « CIRCUIT SEUL » / MODE ETENDU
Selon les µC, le choix s’effectue à l’aide d’une ou plusieurs entrées de sélection de mode.
Pour certains µP, il est possible de récupérer les ports d’interfaces parallèles pris par les bus de
données et d’adresses en plaçant un circuit externe spécifique. On dispose ainsi de l’équivalent
d’un µC complet avec tous ces ports + ses bus de données et d’adresses.
13.1.2 MULTIPLEXAGE ADRESSES/DONNEES
Pour diminuer le nombre de broches utilisées, on utilise les même broches pour acheminer
adresses et données, à des dates différentes. Un (ou plusieurs) circuit(s) de mémorisation est
(sont) nécessaire(s) pour qu’une à date donnée, on dispose de la totalité des bus.
Selon les µC une partie du bus de données ou sa totalité est multiplexée avec le bus d’adresse

Exemple :
Le µC 80C196 peut fonctionner, en mode étendu, dans les cas suivants
80C196 Bus de contrôle 80C196 Bus de contrôle
PORT 4 Bus d'adresses de poids fort 8 bits

Bus d'adresses 16 bits
PORT 3 Bus de données 16 bits
PORT 4 multiplexés
Bus d'adresses de poids faible 8bits
PORT 3 Bus de données 8 bits
multiplexés
Après démultiplexage, les bus d’adresses Après démultiplexage, le bus d’adresses a 16 bits et
et de données ont 16 bits le bus de données a 8 bits
Fig. 47 : 2 modes de fonctionnement étendu du 80C196
Les chronogrammes des bus et des signaux de contrôle sont les suivants :
ALE ALE
(Adress (Adress
Latch Latch
Enable) Enable)
Donnée Poids faible
AD0-15 Adresse AD0-7 Donnée
de l'adresse
AD8-15 Poids fort

de l'adresse
Fig. 48 : bus adresses/données et sigaux de contrôle du 80C196
Les informations présentes dans la 1ère partie du cycle (adresse complète ou bits de poids faible
de l’adresse) doivent être mémorisées sur le front descendant de ALE (Address Latch Enable).
Ceci est facilement réalisable avec un (ou 2) registre(s) de type verrou D (74xx373). Dans la 2ème
partie du cycle :
• dans le cas du bus 8 bits
la partie haute de l’adresse est disponible en AD8-15
la partie basse est disponible en sortie du circuit de mémorisation externe
la donnée est disponible en AD0-7
• dans le cas de bus 16 bits
l’adresse est disponible en sortie du circuit de mémorisation
la donnée est disponible en AD0-15
13.2 COMPOSANTS ANNEXES AU µP OU µC ET CONNEXIONS
Par rapport aux schémas fonctionnels du §5, il faut toujours rajouter :

• les alimentations des circuits, avec des condensateurs de découplage
• le circuit d’horloge pour le séquenceur du µP ou µC. Il est aussi utilisé pour certaines inter-
faces
• le circuit d’initialisation à la mise sous tension ou rénitialisation après défaut (baisse de la
tension d’alimentation, …)

• les connexions des entrées d’interruption
Dans certains cas, il faut aussi rajouter :

• les tensions de références pour le convertisseur A/N et N/A
• les connexions pour les modes de fonctionnement, …
Exemple : schéma pour un µC 68HC11 en mode étendu avec tous les composants nécessaires.
Ici une mémoire EPROM de 8ko est utilisée en externe.
Fig. 49 : 68HC11 en mode étendu avec mémoire externe
On distingue tous les composants et liaisons mentionnés plus haut, avec notamment :
• le circuit MC34064 d’initialisation à la mise sous tension et de réinitialisation en cas de
baisse de la tension d’alimentation
• les tensions de référence pour le CAN VRH et VRL ainsi que leur découplage
• les liaisons pour fixer le mode (ici mode étendu), avec MODA et MODB
Certaines broches sont connectées à des résistances de tirage pour que leurs potentiels soient
fixés. Ces broches restent utilisables.
Certaines broches ont une double fonction choisie par programmation. Par exemple, PE/AN
correspond soit à un port // soit aux entrées analogiques pour le CAN.
Les adresses et les données sont sorties sur des bus externes. Les poids faibles des adresses sont
multiplexés avec les données. Le circuit 74HC373 permet de mémoriser les poids faibles des
adresses.

Une mémoire programme de 8 koctets a été placée en externe. Le décodage d’adresse est réali-
sé par une porte Nand à partir d’A13 et A15. Une autre porte Nand est utilisée pour élaborer le
signal /OE à partir des signaux de contrôle R//W et E.
Les résistances de tirage sur le bus de données ne sont pas indispensables.
14 STRUCTURE DU PROGRAMME SOURCE EN LANGAGE D’ASSEMBLAGE
14.1 GENERALITES
Un langage d’assemblage est un langage dont chaque ligne correspond à :

• une instruction du µP/µC
• une directive d’assemblage (ordre donné au compilateur)
• un commentaire
Le programme source peut se décomposer en grandes sections qui sont parfois repérées par des
mots clés dans certaines syntaxes.
Un programme source comprend :

• la partie programme proprement dite. Le programme se décompose en :
programme principal,
sous-programmes et
programmes d’interruptions.
Cette partie est traduite par du code exécutable lors de la compilation ou de l’assemblage.
• la partie pour le placement de constantes en mémoire (ex : valeurs des vecteurs
d’interruption). Cette partie n’est pas traduite par du code exécutable, mais elle permet de
placer des valeurs en mémoire (par le programmateur, le simulateur ou l’émulateur).
• une partie pour la déclaration de variables avec réservation de mémoire en RAM Une dé-
claration permet d’affecter un nom symbolique à un emplacement mémoire ; ce nom est en-
suite utilisé dans le reste du programme.
• une partie pour l’affectation de noms symboliques à des constantes. Ceci permet de rendre
plus lisible un programme en employant ces noms symboliques. Un nom symbolique peut
représenter une adresse d’un registre, une constante, …. Cette partie n’est pas traduite par du
code exécutable.
• d’autres parties qui ne peuvent être précisées dans le cadre de cette introduction
Les différentes sections d’un programme source peuvent être

• sur un seul fichier
• sur plusieurs fichiers. Cette solution permet une conception modulaire. Une partie déjà écrite
peut être récupérée dans un nouveau travail
L’appel des différents fichiers peut se faire par des directives dans les fichiers eux-mêmes ou lors
de la phase qui suit la compilation ou l’assemblage, l’édition de lien.
Les adresses de départ du programme principal et des sous-programmes peuvent être fixées
dans le fichier qui contient ces programmes ou bien fixée lors de l’édition de lien. Si les adresses
ne sont pas fixées dés le départ, on dit que les programmes sont relogeables.
Pour plus de détail voir document sur la compilation, l’assemblage et l’édition de liens.

14.2 EXEMPLE DE STRUCTURE D’UN FICHIER SOURCE
Ce fichier exemple en langage d’assemblage contient toutes les sections.

Les directives d’assemblage, qui ne sont pas traduites par du code exécutable, sont soulignées.
Ces directives ne correspondent à aucune directive d’un assembleur existant. Leurs noms ont été
fixés pour qu’elles soient facilement compréhensibles.
Il n’y a pas dans cet exemple de mot-clé pour chacune des sections.
Texte du programme source Commentaires

PORTA EGALE 1000h équivalences symboliques. Lors de
PORTB EGALE 1004h l’assemblage, PORTA sera remplacé par
PORTE EGALE 100Ah 1000h
…
ADRESSE_COURANTE F000h Fixe l’adresse courante. Ce qui suit (ici
le programme) sera rangé en mémoire
à partir de cette adresse.
instructions du programme, 1 mnémonique par ligne le programme est constitué du pro-
gramme principal et de sous-
programmes.
ADRESSE_COURANTE FFD6h (zone PROM) ProgInter1 est l’adresse de début du
REMPLIR_AVEC DOUBLE_OCTET ProgInter1 programme d’interruption pour une
REMPLIR_AVEC DOUBLE_OCTET ProgInter2 interface. Elle est placée dans la mé-
… moire programmes aux adresses FFD6
et FFD7. ProgInter2 est placée aux
adresses FFD8 et FFD9, …
ADRESSE_COURANTE 0000h (zone RAM) lorsque le programme a besoin de ma-
Var1 RESERVER OCTET 1 nipuler Var1, il suffit d’utiliser ce nom
Var2 RESERVER OCTET 2 symbolique pour désigner son empla-
… cement mémoire. Var1 nécessite un
octet en mémoire, Var2 en nécessite 2.
Structure de la section programme
L’emploi d’étiquettes permet à l’utilisateur de s’affranchir des adresses exactes des instructions
pour les sauts, branchements conditionnels, appels de sous programmes.
ADRESSE_COURANTE F000h Adresse de début du programme

1ère instruction du prog. principal
2ème instruction
..
Rep1 nème instruction la nème instruction est repérée par une étiquette (Rep1) qui
… correspond à son adresse
…
SI RESULTAT=0, SAUT Rep1 SI RESULTAT=0, SAUT est une instruction. Rep1 corres-
… pond à l’adresse de branchement. L’utilisateur n’a pas à
… connaître l’adresse exacte de la nème instruction.
APPEL SousProg1 APPEL est l’instruction d’appel de SousProg1. L’utilisateur
… n’a pas à connaître l’adresse exacte de la 1ère instruction
… dernière instruction du prog. princ. de SousProg1
SousProg1 1ère instruction SousProg1 est une étiquette qui correspond à une

2ème instruction adresse. Celle-ci est déterminée lors de la phase
… d’assemblage.
…
dernière instruction du sous-prog.
ProgInter1 1ère instruction ProgInter1 est une étiquette qui correspond à une
2ème instruction adresse. Celle-ci est déterminée lors de la phase
… d’assemblage. ProgInter1 peut être utilisée pour placer le
…dernière instruction du prog. vecteur d’interruption en mémoire.
d’inter.
15 RESUME
15.1 GENERALITES
Un système à µP ou un µC permet de réaliser un traitement automatique de l’information ou

traitement de données.
Un système à µP est constitué d’un µP, qui réalise les traitements, et d’autres circuits intégrés
indispensables. Un µC regroupe tous ces éléments en un seul boîtier ; l’équivalent du µP est ap-
pelé unité centrale de traitement (Central Process Unit, CPU).
Un système à µP ou un µC est constitué d’une unité de traitement qui ne comprend que des
entrées binaires (0/1). Pour le traitement d’informations analogiques, il faut des CAN et CNA.
Le µP (ou CPU d’un µC) exécute une suite d’instructions qui constituent le programme rangé
dans une mémoire associée, à des adresses déterminées. Chaque µP possède un jeu
d’instruction.
Une fois le programme placé dans la mémoire associée, le µP :

• recherche l’instruction à exécuter à une adresse de la mémoire
• décode et exécute l’instruction
• calcule l’adresse de la prochaine instruction
15.2 FLUX DE CONCEPTION
• obtention du code à placer en mémoire à partir

d’un programme écrit avec des mnémoniques puis assemblé
d’un programme écrit dans un langage de haut niveau (C, …) puis compilé
• essais / mise au point : le µP et sa mémoire programme associée ou le µC est remplacé par
un émulateur qui permet une exécution contrôlée du programme
• programmation de la mémoire programme

15.3 SYSTEME MINIMUM
Un système minimum est constitué de :

• une unité d’échange : les interfaces d’E/S. Elles sont vues comme un ensemble de registres
accessibles.
• une unité centrale de traitement CPU
• une unité de stockage : les mémoires
Les unités sont interconnectées par des bus. L’architecture la plus courante est de type Von
Neuman. Dans ce cas, on dispose de :
• un bus de données sur lequel sont véhiculés :
les codes des instructions
les données (constantes, variables)
des informations pour le calcul des adresses
• un bus d’adresses sur lequel sont véhiculées les adresses des mémoires et des différents re-
gistres des interfaces
• un bus de contrôle qui comprend tous les signaux nécessaires pour la gestion des échanges

d'adresse
Bus d'adresse
CS1 CS2 CS3
Mémoire Mémoire
Interface
µP programme données
parallèle
EPROM RAM
OE RD/WR RD/WR
Bus de donnée
15.4 ÉLEMENTS DE LA STRUCTURE INTERNE D’UN µP
Les traitements sont réalisés avec l’unité arithmétique et logique (Arithmetic Logic Unit, ALU).
Les traitements sont :
• opérations arithmétiques (addition en base 2, soustraction, incrémentation, …)
• opérations logiques (ET, OU, OU exclusif, décalages, rotations, …)
Un registre associé à l’ALU contient des bits d’états qui renseignent sur le résultat de la dernière
opération (=0, >0, <0, dépassement de capacité, …)
Pour certains µP, un ou 2 accumulateurs contiennent toujours un des opérandes et le résultat de

l’opération.
Un µP contient un séquenceur, commandé par une horloge (généralement à partir d’un quartz),
qui permet de générer toutes les commandes internes nécessaires au déroulement.
Les registres internes d’un µP permettent de mémorisation temporairement des données et ils
sont aussi utilisés pour l’adressage.

Les principaux registres sont :
• accumulateur
• registre d’adresse
• compteur ordinal
• registre instruction
• registre d’index (pour l’adressage indexé)
• registre pointeur de pile
15.4.1 JEU D’INSTRUCTIONS
2 types de µP / µC :
• CISC : (Complet Instruction Set Computer) : jeu d’instruction étendu
• RISC : (Reduced Instruction Set Computer) : jeu d’instruction réduit et grande vitesse
d’exécution (grâce à une architecture particulière Harvard)
Les grandes catégories d’instructions sont :

• Instructions de transfert entre les registres internes et les registres ou emplacements mé-
moire externes
• Instructions de traitement (+, -, ET, OU, décalages, etc.)
• Instructions de branchement et de rupture de séquence : branchement inconditionnel ou
conditionnel (en fonction des bits d’états)
15.4.2 MODES D’ADRESSAGE
Le mode d’adressage concerne la façon dont est désigné l’opérande. Il se traduit par certaines
règles d’écriture au niveau des mnémoniques et des opérandes.
Ex : Avec la syntaxe assembleur Motorola pour µP / µC 8 bit

les modes d’adressages ne changent pas le mnémonique d’une instruction. Seules changent les
écritures de l’opérande ou des informations pour déterminer son adresse.
mode commentaire exemple exemple

d’adressage écriture en explication
assembleur
inhérent ou instruction sans opérande CLRA (CleaR A)
implicite ou avec opérande connu
avec mnémonique
immédiat opérande immédiatement LDAA #$10 LoaD A = mettre dans A ;
après le mnémonique (en # est la marque de
mémoire programme après l’adressage immédiat.
le code opératoire). Mettre 10 (en hexa) dans
A
étendu l’opérande est désigné par LDAA $4000 Mettre dans A le contenu
son adresse complète de l’adresse 4000 (en
hexa)

indexé l’opérande est désigné par LDAA 4,X Mettre dans A le contenu
son adresse égale au conte- de l’adresse égale à (X)+4
nu d’un registre d’index +
une valeur (ici directement
spécifiée)
15.5 DEROULEMENT D’UN PROGRAMME
Différentes étapes rencontrées lors du déroulement d’un programme

• lancement après la mise sous tension ou une réinitialisation
• déroulement normal : programme principal + sous programmes
• interruption sur événement extérieur
Lors du déroulement d’un programme, il est nécessaire de mémoriser certains registres dans une
zone de RAM avec un fonctionnement particulier : la pile
15.5.1 LA PILE
La pile est une zone de RAM utilisée pour sauvegarder des données temporaires. Elle est gérée à
l’aide d’un pointeur de pile contenu dans un registre interne au µP (Stack Pointer SP). Celui-ci
désigne l’emplacement libre de la pile pour une sauvegarde de donnée.
La sauvegarde d’une donnée dans la pile peut s’effectuer automatiquement lors de certaines
étapes du déroulement d’un programme ou à l’aide d’une instruction écrite par le programmeur.
Lors d’un enregistrement, la donnée est empilée (placée sur le haut de la pile)
Lors d’une restitution, la donnée est dépilée (retirée du haut de la pile)
Le pointeur de pile est automatiquement géré par le µP. L’utilisateur doit uniquement spécifier le
bas de la pile (adresse haute) avec une instruction particulière. L’utilisateur ne peut directement
imposer une limite au haut de la pile, à l’aide d’une instruction particulière par exemple.
15.5.2 DEROULEMENT NORMAL
Un programme est composé d’un programme principal et de sous programmes.

Le déroulement du programme est le suivant :
• exécution de la 1ère partie du programme principal (PP), appel sous programme 1 (SP1)
• exécution SP1, retour au PP
• exécution 2ème partie PP, appel SP2
• exécution SP2, retour au PP
• exécution 3ème partie PP
• …
L’appel d’un sous programme se fait avec une instruction spécifique suivie de l’adresse du sous
programme.
Le retour au programme principal se fait avec une instruction spécifique, placée en fin de sous
programme.

Lors de l’appel d’un sous programme, l’adresse de retour au programme principal est mémorisée
dans la pile. Lors du retour d’un sous programme, l’adresse de retour est rechargée dans le re-
gistre d’adresse depuis la pile. Ces opérations sont automatiques et transparentes à l’utilisateur.
Le pointeur de pile doit impérativement avoir été initialisé en début de programme.
15.5.3 INTERRUPTION
Une interruption permet d’interrompre le déroulement normal d’un programme pour exécuter
un programme d’interruption. Une demande d’interruption est liée à un événement extérieur.
Emploi : Unités d’échanges (interfaces), …
Ex : un événement extérieur indique au µP, via une interface, qu’une imprimante a bien reçu le
caractère transmis. Le programme d’interruption peut alors procéder à un nouvel envoi.

P Et C, Une Introductionx

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

P Et C, Une Introductionx

Загружено:

Авторское право:

Доступные форматы

µP ET µC : UNE INTRODUCTION

1 OBJET DE CE DOCUMENT ............................................................................................. 6

µP et µC : une introduction P. Morenton 09/10/09 1

µP et µC : une introduction P. Morenton 09/10/09 2

µP et µC : une introduction P. Morenton 09/10/09 3

µP et µC : une introduction P. Morenton 09/10/09 4

Fig. 1 : Système à microprocesseur ............................................................................................................... 7

µP et µC : une introduction P. Morenton 09/10/09 5

Ce document est un support de cours à destination d'un public d'électroniciens. Il permet

2 MICROPROCESSEUR ET SYSTEME A MICROPROCESSEUR

Un microprocesseur ou µP est un composant (un circuit intégré) né du développement de

Un système à µP permet de réaliser un traitement automatique de l’information ; le terme « in-

µP et µC : une introduction P. Morenton 09/10/09 6

Fig. 1 : Système à microprocesseur

Un système à µP procède périodiquement à une acquisition d’information, un traitement auto-

Asservissement en vitesse d’un moteur

2.1.3 MICROPROCESSEUR (µP) / MICROCONTROLEUR (µC)

Au début de la commercialisation des µPs, un système minimum était obligatoirement constitué

µP et µC : une introduction P. Morenton 09/10/09 7

Fig. 2 : Exemple de système avec ses E/S

3 PRINCIPE DE FONCTIONNEMENT D’UN SYSTEME A µP

3.1 INSTRUCTION, PROGRAMME

Le traitement automatique de l’information consiste en l’exécution par le µP d’une suite de

Chacune des lignes précédentes correspond à une instruction.

En pratique, chaque type de µP peut comprendre un ensemble limité d’instructions parfaitement

µP et µC : une introduction P. Morenton 09/10/09 8

Instruction sur 2 Ad+3 Instruction 3 Sens d'exécution

Fig. 3 : Rangement des instructions dans la mémoire programme

3.2 EXECUTION DU PROGRAMME

Un µP décrit en permanence le cycle décrit ci-

µP et µC : une introduction P. Morenton 09/10/09 9

La conception d’un ensemble comprenant un système à µP ou un µC peut se décomposer en 3

4.1 OBTENTION DU CODE BINAIRE

La démarche simplifiée suivie pour concevoir un ANALYSE

L’écriture du programme et la traduction se font Grandes lignes du

Ecriture du programme SOURCE

Fig. 5 : Conception d’un programme

Assembleur (Assembler en anglais)

µP et µC : une introduction P. Morenton 09/10/09 10

Le programme source, écrit en Adresse de la donnée

Fig. 6 : Codes correspondant à l’instruction DEC $4000 du 68HC11

4.2 ESSAIS / MISE AU POINT

4.2.1 ESSAIS MATERIELS : SOLUTION A EMULATEUR

µP et µC : une introduction P. Morenton 09/10/09 11

4.2.2 ESSAIS MATERIELS : AUTRES SOLUTIONS

Selon la quantité de production souhaitée, on utilise un des types de mémoire suivants :

5 STRUCTURE D’UN SYSTEME MINIMUM A µP

On appelle système minimum à µP l’ensemble comprenant le µP et les composants indispen-

5.1 LES CONSTITUANTS D’UN SYSTEME MINIMUM A µP

Un système minimum à µP est constitué de :

• une unité d’échanges : les interfaces d’E/S,

µP et µC : une introduction P. Morenton 09/10/09 12

5.2 LES 2 ARCHITECTURES D’UN SYSTEME A µP

Pour l’organisation des différentes unités, il existe deux architectures :

Mémoire Mémoire Mémoire

Système min à µP ou µC Système min à µP ou µC

Milieu extérieur Milieu extérieur

µP et µC : une introduction P. Morenton 09/10/09 13

6.1 STRUCTURE D’UN SYSTEME MINIMUM

Bus de contrôle Décodeur

CS1 CS2 CS3

Fig. 9 : Système minimum à µP

Les tailles les plus courantes des bus de données sont :