µP et µC, une introductionx

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

µ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


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.


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.

Traitementautomatique

Informationsd'entrée

Informations,actions de sortie

SYSTEME A µP


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.

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.

Unité detraitement

C.A.N. C.N.A.

Entréeslogiques

Entréeanalogique

Sortieanalogique

Sortieslogiques

Système à µ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).

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 :

Fig. 4 : Cycle de base d’un microprocesseur

Un µP décrit en permanence le cycle décrit ci-contre. Ainsi, si on considère l’exemple de la figure 3, le µP :

• 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, • calcule l’adresse de l’instruction suivante Ad+1, • place Ad+1 sur le bus, exécute l’instruction 2, etc.

Remarque : le cycle décrit ici correspond à des µP simples. Certains µP peuvent, dans certains cas, exé-cuter une instruction pendant qu’ils recherchent la suivante (voir plus loin § Système minimum à archi-tecture Harvard). Il existe même des possibilités plus évoluées qui ne peuvent être traitées dans le cadre de cette introduction.

Instruction 1

Instruction 2

Instruction 3

Instruction 3

Instruction 4

Instruction 5

Ad

Ad+1

Ad+2

Ad+3

Ad+4

Ad+5

Instruction sur 2octets

Sens d'exécution

Recherche del'instruction à exécuter

en mémoire

Décodage et exécutionde

l'instruction

Calcul de l'adressede la

prochaine instruction

(cycle Fetch)


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 programme, donc pour obtenir la suite de codes correspondante est présentée ci-contre : L’écriture du programme et la traduction se font sur un micro-ordinateur. Le résultat est un fichier qui contient le code exécutable.

ANALYSE

Grandes lignes dulogiciel et du matériel

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-ment en mémoire on obtien-drait la suite de codes décrite figure 6. Le programme source, écrit en langage d'assemblage (assembly language), est constitué des mnémoniques et d'autres infor-mations présentées plus loin.

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 :

7A

40

00

Code de l'opération DEC

Adresse de la donnéeà décrémenter

(sur 16 bits - 2 octets)

Ad

Ad+1

Ad+2Instructionsur

3 octets

Mémoireprogramme


• à 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.

Fig. 7 : Architecture Von Neuman

Fig. 8 : Architecture Harvard

Unité centraleC.P.U.

Unité d'échanges

Mémoireinstructionsprogramme

& constantes+

mémoirevariables

Milieu extérieur

Système min à µP ou µC

UnitécentraleC.P.U.

Unité d'échanges

Mémoireinstructionsprogramme

& constantes

Milieu extérieur

Système min à µP ou µC

Mémoirevariables


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.

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 à 2 6553616 = 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.

Bus de contrôle

Mémoireprogramme

EPROM

Mémoiredonnées

RAMInterfaceparallèleµP

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WROE


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 les paragraphes suivants. Le fonctionnement pour une autre famille de µP est très proche à la diffé-rence des mnémoniques et codes opératoires. 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 programme pré-senté ci-contre.

8B

10

B7

ADDA #$109000h

9001h

9002h

40

00

7E

9003h

9004h

9005h

90

00

9006h

9007h

STAA $4000

JMP $A000

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

Fig. 11 : ADDA, recherche du code opération

Bus de contrôle

EPROM

Mémoiredonnées

RAMInterfaceparallèle

µPou CPUd'un µC

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WR

108B

9000h

OE


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

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).

Bus de contrôle

EPROM

Mémoiredonnées


µPou CPUd'un µC

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WR

108B

9001h

OE



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).

Fig. 14 : STAA, recherche du poids fort de l’adresse

9002h

Bus de contrôle

EPROM

Mémoiredonnées


µPou CPUd'un µC

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WROE

40B7

00

9003h

Bus de contrôle

EPROM

Mémoiredonnées


µPou CPUd'un µC

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WROE

40B7

00


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.

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 ligneWR 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.

9004h

Bus de contrôle

EPROM

Mémoiredonnées


µPou CPUd'un µC

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WROE

40B7

00

RD/WR=0

4000h

Bus de contrôle

EPROM

Mémoiredonnées

RAM

µPou CPUd'un µC

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WROE

40B7

00

Interfaceparallèle

registred'adresse4000h


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

Bus de contrôle

Mémoireprogramme

EPROM

Mémoiredonnées

RAMInterfaceparallèleCPU

Bus de donnée

Décodeurd'adresse

CS1 CS2

Bus d'adresse données

RDWR

RDWR

Bus d'adresse instructions

Bus d'instruction

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 programme présenté ci-contre

C10

10F

026

40h

41h

42h

A8043h

MOVLW 0x10 (C: code instruction, 10: opérande)

ADDWF 0x15,W MOVWF 0x06

GOTO 0x80

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.


Bus de contrôle

Mémoiredonnées


Bus de donnée

Décodeurd'adresse

CS1 CS2


RDWR

RDWR


Bus d'instruction

10FC10

40h

C10h

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.

Bus de contrôle

Mémoiredonnées


Bus de donnée

Décodeurd'adresse

CS1 CS2


RDWR

RDWR


Bus d'instruction

C10

41h

10Fh

Ecriture dans W

10Fh

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.

Bus de contrôle

Interfaceparallèle

CPU

Bus de donnée

Décodeurd'adresse

CS1 CS2


RDWR

RDWR


Bus d'instruction

C10

42h

026h

addition entre Wet le bus de donnéerésultat dans W

10Fh026

15h

xx

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.

Bus de contrôle

Mémoiredonnées

RAMCPU

Bus de donnée

Décodeurd'adresse

CS1 CS2


RDWR

RDWR


Bus d'instruction

026

43h

A80h

A80

06h

yy

Registred'adresse

06h

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).

Bus de contrôle

Mémoiredonnées


Bus de donnée

Décodeurd'adresse

CS1 CS2


RDWR

RDWR


Bus d'instruction

80h

zzz

zzz

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.


RegistreInstructionSéquenceur

Unité deTraitement

Unité deGetion

Mémoire

PartieCommande

PartieOpérative

BusdeContrôle

Busd'adresse

BusdeDonné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 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 :

• à un accumulateur • au bus de données externe

Fig. 25 : UAL et accumulateurs

A B

U.A.L.


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.

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) chargement de A dans l’U.A.L.

b) décalage c) stockage du résultat

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.).

A B22

10 A B

32

32

A B1001 0100

1001 0100

A B1001 0100

1001 0100 0

A B0010 1000

01010 1000


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

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

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.,

Bus de contrôle

EPROM

Mémoiredonnées


68HC11

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WR

3D

AFFFh

OE

PC

IR

A B

Séq

uen

ceu

r

AFFF

3D

E7 5A

Bus de contrôle

EPROM

Mémoiredonnées


68HC11

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WR

5A3D

B000h

OE

PC

IR

A B

Séq

uenc

eur

B000

3D

E7


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.

Bus de contrôle

EPROM

Mémoiredonnées


68HC11

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WR

5A3D

OE

PC

IR

A BS

éque

nce

ur

3D

BD

BD

B001


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-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 (Operation Code –OP-),

• et d’une quantité numérique Qn optionnelle.

n bits

COP Qn (accès aux opérandes)

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 à 1 octet (ex. CLRA), Qn n’existe pas

b) instruction à 2 octets (ex. ORAA #$20)

c) instruction à 3 octets (ex. SUBA $C570)

Octet 1

4 F

COP

Octet 1 Octet 2

8 A 2 0

COP Qn

Octet 1 Octet 2 Octet 3

B 0 C 5 7 0

COP Qn Mise à 0 de A OU logique entre A et

l’opérande 20h. COP=8Ah représente l’opération ORA, Qn représente directement l’opérande, soit 20h.

soustrait la donnée (l’opérande) stockée à l’adresse C570h de l’accumulateur. COP=B0h, Qn, sur 2 octets, représente l’adresse de l’opérande.

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)

011 10 9 8 7 6 5 4 3 2 1

constanteCOP

011 10 9 8 7 6 5 4 3 2 1

1 1 1 0 0 0 01 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 réserve pour sauvegarder des données tempo-raires. La pile est toujours associée au registre pointeur de pile (interne au µP) ou stack poin-ter SP qui pointe le premier emplacement libre de la pile. Ci-contre, représentation d’une pile : Avec certains µC (PIC par exemple), la pile est une zone mémoire particulière de taille fixe

SPBas de la pile

Haut de la pile

RAM

Donnée 0

Donnée 1

Ad

Ad-1

Ad-2

Ad-3

Ad-4

Ad-5

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.


a) état de la pile après sauvegarde d’un nou-

velle donnée (ex : registre) b) état de la pile après sauvegarde automa-

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.

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 On dispose d’une RAM de 512 octets, on choi-sit de réserver les 256 octets inférieurs à des données tandis que les 256 octets supérieurs sont réservés à la pile. Remarque La pile progresse vers le haut au fur et à me-sure des empilages. Par conséquent si plus de 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).

Fig. 36 : Exemple d’initialisation de la pile

Donnée 2

SP

Bas de la pile

Haut de la pile

Donnée 0

Donnée 1

Ad

Ad-1

Ad-2

Ad-3

Ad-4

Ad-5

Donnée 2

PC1

PC2

SP

Bas de la pile

Haut de la pile

Donnée 0

Donnée 1

Ad

Ad-1

Ad-2

Ad-3

Ad-4

Ad-5

Donnée 2

SP

Bas de la pile

Haut de la pile

Donnée 0

Donnée 1

Ad

Ad-1

Ad-2

Ad-3

Ad-4

Ad-5

SP 01FFhBas de la pile

0100h00FFh

0000h

256octets de

pile

256octets dedonnées

RAM


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 programme principal instruction d’appel du sous programme avec l’adresse de début de ce sous-programme Saut au sous programme Exécution du sous programme N dépend du µC. Avec un PIC, N = 1.

appel SP d'adresse 3000h



1000h

MEMOIRE PROGRAMMEadresses

1200h

1400h

1500h

1200h+N

1200h+N

1500h+N

3000h 1ère instruction SP

retour au programme appelant

1

2

3

1

23

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 68HC11

en langage d'assemblage 80C196

appel sous programme, placé dans le programme principal

JSR NomProgramme* (Jump to SubRoutine)

CALL NomProgramme

retour au programme principal, place en fin de sous pro-gramme

RTS (ReTurn from Subroutine)

RET (RETurn)

* 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é.


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)

B A

Exécution de A

Programmeen cours

tEvénement

extérieur(appel de B)

Fin de B

A

Exécution de B

Exécution de A

B : programme d'interruption

A : programme principal


10.3.2 DEROULEMENT SIMPLIFIE D’UNE PROCEDURE D’INTERRUPTION

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.

EXECUTION DE AEVENEMENT

INST 1INST 2

Instruction de retour au programme principal(RTI pour le 68HC11)

EXECUTION DE A

Exécution de l'instruction en coursSauvegarde automatique du compteur programme(adresse de retour pour suite de A)Sauvegarde automatique des registresAppel du programme d'interruption

Exécution duprogrammed'interruption

Restitution automatique des registresRestitution automatique du compteur programme


• 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

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-

unitéd'échangeinterne 1

unitéd'échangeinterne 2

...

CPU

entréesd'inter-ruption

µC

INT1INT2INT3INT4

unitéd'échange

1

unitéd'échange

2

...

µP

entréesd'inter-ruption

Système à µP

INT1INT2


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 d’interruption masquables

un bit d’un registre de contrôle dans un µP ou 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 vectorisée

Après une RàZ le µP effectue un certain nombre d’opérations puis dépose sur le 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-torisée

Après la RàZ, le µP effectue un certain nombre d’opérations puis charge le con-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

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.

PORT D'UNEINTERFACE

Périphé-rique

adresses

données

contrôle

donnée prêteà transmettre

donnée lue

DONNEE

µC ou système à µP

demanded'interruption


Émission de données Réception 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é.

Registre à décalage

Entrée parallèlevenant du bus de données

horloge

Sortie sérieRegistre à décalage

Sortie parallèlevers le bus de données

horloge

Entrée série


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.

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é-vues pour que les échanges se fassent avec l’horloge délivrée par le circuit maître. A chaque période d’horloge :

• une donnée est envoyée du maître vers l’esclave

• une donnée est retournée de l’esclave vers le maître

Fig. 46 : liaison série synchrone

t

t

t

t

0 1 1 10 0 0

0 1 1 10 0 0

0 1 1 0 0 1?

1

1

1

Hémission

donnéestransmises

Hréceptioncorrecte

Hréceptionmauvaire

données lues

données lues

Maître(ex: µC)

Esclave(ex: horlogetemps réel

-heure, date-)

données

données

H trans-mission


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

Après démultiplexage, les bus d’adresses

et de données ont 16 bits

Après démultiplexage, le bus d’adresses a 16 bits et

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 :

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, …)

Bus de contrôle

Bus d'adresses 16 bitsBus de données 16 bitsmultiplexés

80C196

PORT 3PORT 4

Bus d'adresses de poids fort 8 bits

Bus d'adresses de poids faible 8bitsBus de données 8 bitsmultiplexés

80C196

PORT 3

PORT 4

Bus de contrôle

Adresse Donnée

ALE(AdressLatchEnable)

AD0-15 DonnéePoids faiblede l'adresse

Poids fortde l'adresse

ALE(AdressLatchEnable)

AD0-7

AD8-15


• 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 PORTB EGALE 1004h PORTE EGALE 100Ah …

équivalences symboliques. Lors de l’assemblage, PORTA sera remplacé par 1000h

ADRESSE_COURANTE F000h instructions du programme, 1 mnémonique par ligne

Fixe l’adresse courante. Ce qui suit (ici le programme) sera rangé en mémoire à partir de cette adresse. le programme est constitué du pro-gramme principal et de sous-programmes.

ADRESSE_COURANTE FFD6h (zone PROM) REMPLIR_AVEC DOUBLE_OCTET ProgInter1 REMPLIR_AVEC DOUBLE_OCTET ProgInter2 …

ProgInter1 est l’adresse de début du programme d’interruption pour une 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) Var1 RESERVER OCTET 1 Var2 RESERVER OCTET 2 …

lorsque le programme a besoin de ma-nipuler Var1, il suffit d’utiliser ce nom 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 1ère instruction du prog. principal 2ème instruction .. Rep1 nème instruction … … SI RESULTAT=0, SAUT Rep1 … … APPEL SousProg1 … … dernière instruction du prog. princ. SousProg1 1ère instruction

Adresse de début du programme la nème instruction est repérée par une étiquette (Rep1) qui correspond à son adresse 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 est l’instruction d’appel de SousProg1. L’utilisateur n’a pas à connaître l’adresse exacte de la 1ère instruction de SousProg1 SousProg1 est une étiquette qui correspond à une


2ème instruction … … dernière instruction du sous-prog. ProgInter1 1ère instruction 2ème instruction … …dernière instruction du prog. d’inter.

adresse. Celle-ci est déterminée lors de la phase d’assemblage. ProgInter1 est une étiquette qui correspond à une adresse. Celle-ci est déterminée lors de la phase d’assemblage. ProgInter1 peut être utilisée pour placer le vecteur d’interruption en mémoire.

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

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.

Bus de contrôle

Mémoireprogramme

EPROM

Mémoiredonnées

RAMInterfaceparallèleµP

Bus de donnée

Décodeurd'adresse

CS1 CS2 CS3

Bus d'adresse

RD/WR RD/WROE


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 d’adressage

commentaire exemple écriture en assembleur

exemple explication

inhérent ou implicite

instruction sans opérande ou avec opérande connu avec mnémonique

CLRA (CleaR A)

immédiat opérande immédiatement après le mnémonique (en mémoire programme après le code opératoire).

LDAA #$10 LoaD A = mettre dans A ; # est la marque de l’adressage immédiat. Mettre 10 (en hexa) dans A

étendu l’opérande est désigné par son adresse complète

LDAA $4000 Mettre dans A le contenu de l’adresse 4000 (en hexa)


indexé l’opérande est désigné par son adresse égale au conte-nu d’un registre d’index + une valeur (ici directement spécifiée)

LDAA 4,X Mettre dans A le contenu de l’adresse égale à (X)+4

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.

Documents

µP et µC, une introductionx