[Link], D.

Gaffé 1

Université de Nice-Sophia Antipolis

DEUG Math-Info - Seconde année
premier semestre

Électronique Numérique

Cours
C. Belleudy, [Link]́

version 1.2
2 Électronique Numérique
Chapitre 1

Les mémoires

1.1 Introduction
La somme d’informations que doit traiter tout système automatique nécessite l’utilisation de cir-
cuits ayant la capacité de conserver des données soit figées, soit volatiles. Ces circuits capables de
recevoir et de restituer les informations portent le nom de MEMOIRE.

1.1.1 Définitions et schéma fonctionnel

Mémoire : Unité Fonctionnelle qui peut recevoir, conserver et restituer des informations.

Cellule mémoire : Plus petite subdivision d’une mémoire dans laquelle un élément d’information
a été ou peut être introduit, dans laquelle il est ou peut être conservé et de laquelle il peut être extrait.
Il existe différentes technologies de cellule qui caractérisent d’ailleurs la catégorie de mémoires as-
sociée. Conceptuellement, on representera souvent une cellule mémoire par un registre 1 n bits c’est
à dire n bascules D synchronisée sur la même horloge. Les n bits caractérisent le format de donnée
que l’on peut mémoriser : Historiquement 8 bits (un octet), on trouve aujourd’hui des mémoires de
16,32 voire 64 bits. Ils sont notés Dn , Dn−1 , . . . , D0 .

D D Q D D Q D D Q
7 7 6 6 0 0

+
Q n =D n quand H=1
H +
Q =Q sinon
n n

F IG . 1.1 – représentation d’une cellule mémoire élémentaire 8 bits

Information volatile : Information dont le contenu est perdu lorsque les tensions d’alimentation
ne sont plus appliquées ou, dans le cas, d’une mémoire à fonctionnement dynamique lorsque les cel-
lules mémoires ne sont pas rafraı̂chies correctement.

1
cf. cours de première année, second semestre

3
4 Électronique Numérique

Chaque mémoire contient un grand nombre de cellules élémentaires. Pour sélectionner une cel-
lule particulière parmi les autres, on identifie chaque cellule par un numéro unique que l’on appelle
adresse (comme une adresse postale). Cette adresse est elle-même codée en binaire et est notée
An , An−1 , . . . , A0 . Bien-sur, plus la mémoire a une capacité importante, plus n est grand. Atten-
tion, la taille de la cellule mémoire est totalement indépendante de celle de l’adresse. Pour spécifier
complètement une mémoire, il est bien indispensable de donner les deux paramètres ; par exemple :
32k x 8 caractérise une mémoire contenant 32768 cellules de 8 bits chacune.

Les cellules élémentaires mises à la suite forment un tableau (espace mémoire). Chaque ligne
correspond à une adresse unique. Toutes les adresses transitent par les mêmes fils qui forment le bus
d’adresse Toutes les données écrites dans les cellules élémentaires transitent également par un réseau
unique de fils appellé bus de données en écriture. Il existe symétriquement le bus de données en
lecture qui est souvent commun avec le précédent, on parle alors de bus de données bidirectionnel.
Le sens de transfert est alors défini par le signal supplémentaire R/W et la validation par cs (bus de
contrôle).

adresse 0 0 0 0 1 0 1 1 0

adresse 1 1 1 0 0 0 1 0 0

An
décodeur

CS

A0 R/W

bus d’adresses
n
adresse 2 -1

D7 D0

bus de données

F IG . 1.2 – mémoire et bus

1.1.2 Les différentes catégories de mémoires

Les mémoires se divisent principalement en deux catégories :
– les mémoires vives (RAM : Random Access Memory) à lecture et écriture possibles,
– les mémoires mortes (ROM : Read Only Memory, PROM, EPROM, EEPROM) à lecture seule-
ment.
[Link], [Link]́ 5

Il existe plusieurs types de mémoires mortes :

– ROM (Read Only Memory) : L’écriture est faite, dans ces mémoires, de manière définitive par
le fabricant ; l’utilisateur ne peut que lire son contenu.
– PROM (Programmable Read Only Memory) : l’utilisateur écrit le contenu de la mémoire à
l’aide d’un programmateur de mémoires ; après cette opération, le contenu y est écrit définitivement
et ne peut plus être modifié ; il ne peut qu’être lu. Les cellules élémentaires sont constituées de
fusibles.
– EPROM (Erasable Programmable Read Only Memory) : le contenu de la mémoire peut être
effacé à l’aide de rayons ultra-violets, ce qui permet une nouvelle programmation.
– EEPROM (Electrically Erasable Programmable Read Only Memory) : le contenu de la mémoire
peut être effacé électriquement.

De même, il existe plusieurs types de mémoire vive :

– SRAM (Static RAM) : Chaque case d’une cellule élémentaire est composée physiquement de
deux transitors en tête-bêche qui se contrôlent mutuellement. La cellule obtenue à deux états
électriques stables et se comporte comme une bascule RS. Cet état est perdu à chaque coupure
électrique...
– DRAM (Dynamic RAM) : Chaque cellule élémentaire contient un condensateur qui se charge
ou non suivant la donnée à mémoriser. La DRAM commute plus rapidement que la SRAM. Par
contre les condensateurs des DRAM se déchargent tout seul ce qui nécessite un rafraı̂chissement
très fréquent de toutes les données pour ne pas les perdre 2 !

1.2 Décodage d’adresses

1.2.1 Système à une seule mémoire

Chaque mémoire doit être capable d’atteindre n’importe quelle cellule élémentaire via son adresse.
Pour cela elle doit contenir la logique combinatoire nécessaire.

Si nous y regardons de plus près, ce système logique doit sélectionner une de ses sorties parmi n
en fonction d’un nombre binaire en entrée. C’est exactement la définition du démultiplexeur 1 vers
n vue en première année !

2
Ces aspects technologiques ont une grosse incidence sur les performances : il faut savoir par exemple que le proces-
seur du ZX81 passait plus de 90de son temps à rafraı̂chir sa DRAM !
6 Électronique Numérique

Y0
Y1
E Yi Yi = E si S=i
Y2 −2n

Y2 n −1

S S
n−1 0

F IG . 1.3 – Rappel : démultiplexeur 1 vers n

L’entrée du DEMUX est reliée au signal d’activation global de la mémoire cs. Chaque sortie
sert d’horloge de validation pour la cellule sélectionnée. Bien-sur, n bits d’adresses nécessitent un
démultiplexeur à 2n sorties.

A l’inverse, les données en lecture sont remultiplexées pour converger vers un bus unique (non
représenté sur le schéma qui suit).

Remarque : En pratique, les signaux d’activation sont souvent actifs niveau bas d’ou leur nom cs
pour ChipSelect.

D0

D7
D7 D6 D0
D D D

x8

D7 D6 D0
D D D
DEMUX

1 −> 65536
cs

x 65536

D7 D6 D0
D D D

A15 A0

F IG . 1.4 – Structure interne d’une mémoire 64K x 8

[Link], [Link]́ 7

1.2.2 Système à plusieurs mémoires, espace d’adressage

Dans la réalité, un système à microprocesseurs possède toujours plusieurs mémoires séparées (au
moins une RAM et une ROM). Cet ensemble est vu comme une mémoire unique globale par le micro-
processeur et est appelé espace d’adressage.

Comme le bus de données est commun à toutes les mémoires, il est indispensable d’ajouter des
composants logiques pour activer une mémoire à la fois en fonction de l’adresse qui nous intéresse.
Cette tâche est classiquement dévolue à des démultiplexeurs spéciaux appelés décodeurs donc le rôle
est d’activer le bon cs.

Une autre façon de l’expliquer, consiste à remarquer que tout démultiplexeur 1 → 2 n peut être
remplacé par deux démultiplexeur 1 → 2n−1 et d’un démultiplexeur 1 → 2. Il est donc toujours
possible de remplacer une mémoire unique à un seul démux. interne par une mémoire unique à trois
démux. internes, puis par deux mémoires plus petites (dont chacune contient un démux local) et un
démultiplexeur externe.

An−1

ROM
A0

cs
0

DEMUX
cs
1 −> 2

1 An−1

RAM
A0
An

cs

F IG . 1.5 – Partitionnement de l’espace d’adressage

Classiquement, on utilise les lignes d’adresse hautes pour sélectionner un boitier mémoire plu-
tot qu’un autre et conserver ainsi la numérotation des lignes basses. Le nombre de lignes d’adresses
qui attaque le démultiplexeur définit le nombre de plage mémoire différente. La première adresse de
chaque plage est appellée “adresse de base”. Chaque plage a la même taille et couvre au minimum
l’espace d’adressage de la mémoire locale.

L’exemple qui suit montre l’organisation d’un espace d’adressage 16 bits (64k). Les adresses sont
exprimées en hexa (regroupement des adresses par 4) pour plus de concision.
8 Électronique Numérique

A13 D7
RAM
A0
16k
D0
cs

A13 D7
RAM
A0
16k
D0
0 cs

DEMUX A13 D7
cs
1 −> 4 RAM
1 A0
16k
D0
cs
A15 A14
A13 D7
ROM
A0
16k
D0
cs

F IG . 1.6 – Organisation d’un espace mémoire 64k

plan mémoire associé :

A15 A14 A13 A12 A11 A10 A9 A8 ... A0

RAM 0 0 0 0 0 0 0 0 ... 0 $0000
.. ..
1 . .
0 0 1 1 1 1 1 1 ... 1 $3FFF
RAM 0 1 0 0 0 0 0 0 ... 0 $4000
.. ..
2 . .
0 1 1 1 1 1 1 1 ... 1 $7FFF
RAM 1 0 0 0 0 0 0 0 ... 0 $8000
.. ..
3 . .
1 0 1 1 1 1 1 1 ... 1 $BFFF
1 1 0 0 0 0 0 0 ... 0 $C000
.. ..
ROM . .
1 1 1 1 1 1 1 1 ... 1 $FFFF

Les démultiplexeurs peuvent être cascadés. Les sorties peuvent être recombinées. Dans ce cas il ap-
parait des sous-plages de taille plus petite ...
[Link], [Link]́ 9

A12 D7
RAM
A0
8k
D0
cs

A13 D7
RAM
00
DEMUX A0
16k
01
1 −> 4 D0
10 cs
0
DEMUX 11 A12 D7

cs 1 −> 2 RAM
1 A0
8k
A14 A13
D0
cs

A15
A14 D7
ROM
A0
32k
D0
cs

F IG . 1.7 – Autre organisation d’un espace mémoire 64k

plan mémoire associé :

A15 A14 A13 A12 A11 A10 A9 A8 ... A0

RAM 0 0 0 0 0 0 0 0 ... 0 $0000
.. .. ..
1 . . .
0 0 0 1 1 1 1 1 ... 1 $1FFF
0 0 1 0 0 0 0 0 ... 0 $2000
.. .. ..
. . .
RAM 0 0 1 1 1 1 1 1 ... 1 $3FFF
2 0 1 0 0 0 0 0 0 ... 0 $4000
.. .. ..
. . .
0 1 0 1 1 1 1 1 ... 1 $5FFF
RAM 0 1 1 0 0 0 0 0 ... 0 $6000
.. .. ..
3 . . .
0 1 1 1 1 1 1 1 ... 1 $7FFF
1 0 0 0 0 0 0 0 ... 0 $8000
..
ROM .
1 1 1 1 1 1 1 1 ... 1 $FFFF
10 Électronique Numérique

Remarque 1 : Une plage peut être plus grande que la mémoire associée si celle-ci ne possède pas
assez de bits d’adresses : dans ce cas la mémoire voit plusieurs adresses différentes comme une seule
et même adresse. On parle alors “d’adresse mirroir”.

A13

RAM
A0

cs
0

DEMUX
cs
1 −> 2
1 A14

ROM
A0
A15

cs

F IG . 1.8 – décodage incomplet

Sur le schéma qui précède, la RAM réagit de la même manière à la présentation des adresses
$0000 et $4000 car elle est insensible au bit A14 . De même toute donnée dont l’adresse est comprise
entre $0000 et $3FFF se reverra entre $4000 et $7FFF.

Remarque 2 : La multiplication des mémoires est également intéressante lorsque le bus de données
est plus grand que celui des mémoires disponibles. On connecte alors plusieurs mémoires identiques
sur les mêmes adresses et le même cs de telle sorte que chacune prenne une partie du bus de données :
par exemple D0-D7,D8-D15 pour un bus de données 16 bits et des mémoires 8 bits de données.
D15

D8

D7

D0
D7

D0

D7

D0

2k x 8 2k x 8
A10

A0

cs

A10

A0

cs

F IG . 1.9 – mémoire équivalente 2k x 16

[Link], [Link]́ 11

1.3 Mémoire et implémentation d’une fonction boolénne

Dans beaucoups d’applications, on utilise les mémoires pour synthétiser des fonctions boolénnes.
Ceci vient de l’organisation interne d’une mémoire. Si nous reprenons le schéma 1.1.1, nous pouvons
considérer la mémoire comme un tableau dont l’indice serait l’adresse de la case sélectionnée.

Or toute fonction boolénne peut être complêtement spécifiée par une table de vérité ; chaque ligne
correspondant à une combinaison unique des entrées.

Il suffit donc d’affecter chaque bit d’adresse de la mémoire à une entrée et d’écrire à chaque
adresse An , ...A0 l’image f (An , ...A0 ).

adresse 0 0 0 0 1 0 1 1 0
a b c f(a,b,c)
adresse 1 1 1 0 0 0 1 0 0
0 0 0 1
An 0 0 1 0
0 1 0 0
décodeur

CS 0 1 1 1
1 0 0 1
A0 R/W 1 0 1 1
1 1 0 0
bus d’adresses
n 1 1 1 1
adresse 2 −1

D7 D0

bus de données

F IG . 1.10 – bijection entre mémoire et table de vérité

En fait, une mémoire possède plusieurs bits de données : Dans le cas d’une mémoire 8 bits, on
pourra synthétiser 8 fonctions indépendantes simutanément ...

Remarque : A la main, cette solution est pratique tant que le nombre d’entrée est faible, mais
devient rapidement laborieuse pour n > 4 car il faut écrire 2n lignes !
12 Électronique Numérique
Chapitre 2

Représentation des systèmes séquentiels

déclenchés par horloge

2.1 Rappel sur les compteurs synchrones

Plutot que de faire de la paraphrase ici, reportez-nous au cours d’ Électronique Numérique du
second semestre de l’année dernière, chapitre 6 p.27 à 30.

([Link]

2.2 Structure générale d’un système séquentiel synchrone

2.2.1 Présentation
Tout système séquentiel synchrone est composé :
– d’un bloc mémoire qui matérialise les états internes et qui contient généralement des bascules
JK ou D.
– d’un premier bloc combinatoire qui est chargé de déterminer les états futurs.

– d’un second bloc combinatoire qui calcule la valeur des sorties.

Le terme synchrone vient du fait que toutes les variables d’états changent simultanément sur le front
d’horloge (registre) pour former le nouvel état.

2.2.2 Machines de Mealy et de Moore

Machine de Moore :
Dans le cas particulier où la valeur des sorties ne dépend que de l’état interne, on parle de machine de
Moore.
Machine de Mealy :
Le cas général, dans lequel les sorties dépendent effectivement de l’état interne du système et des
entrées s’appelle une machine de Mealy

13
14 Électronique Numérique

Em
E0
Sp
F
S0
Sp
F
S
0

Em
+ E +
0
Qn Qn
G + G +
Q0 Q0

Qn Qn

Q0 Q0
H H

MEALY MOORE

2.3 Description du fonctionnement d’un système séquentiel

2.3.1 Description par un graphe
Le graphe décrit sous une forme géométrique l’automate d’états du comportement du système :
– les noeuds du graphe représentent les états internes du système ,dans le cas d’une machine de
Moore, ils portent également les sorties associés.
– les flèches portent la combinaison des variables d’entrées assurant la transition vers les états
suivants. Dans le cas d’une machine de Mealy, elles portent également l’état des sorties.
Ce type de graphe est appellé “graphe de transition”, “graphe de fluence” ou “graphe d’état” sui-
vant le domaine scientifique.

Exemple 1 : Les compteurs vu l’année dernière sont en fait un cas particulier de machine de Moore
ou la fonction F est l’identité (les sorties sont directement les états du système). Considérons ainsi un
compteur modulo 4 doté d’une commande d’incrémentation. Le graphe d’états associé à ce système
est présenté figure 2.3.1. Il comporte quatre états internes codable par deux variables d’état Q 1 , Q0 et
une entrée incr. Ici, les sorties S0 et S1 sont directement les variables d’état S0 = Q0 et S1 = Q1 .

0 0 0 0
entrées
1 1 1
00 01 10 11 X Y
incr

F IG . 2.1 – Modélisation du compteur

[Link], [Link]́ 15

En rêgle générale, sur les systèmes synchrones le codage des états n’a pas d’importance 1 . On
le choisira après coup de telle sorte qu’il simplifie les équations des sorties et de changement d’état.
Dans un premier temps, on identifiera juste les états par des lettres.

0 0 0 0
entrées
1 1 1
A B C D X Y
incr

Complètons maintenant ce compteurs par trois sorties : valeur S du compteurs sur deux bits et T
signal de fin de cycle. Nous obtenons deux graphes différents suivant le choix de synthèse (Mealy ou
Moore).

0 0 0 0
entrées
1 1 C 1 D X Y
A B
000 001 010 111 Sorties Sorties
incr

1 Sorties=TS 1S 0

MOORE

0/000 0/001 0/010 0/111

entrées/sorties
1/001 1/010 1/111
A B C D X Y
incr/TS S
1 0

1/000

MEALY

Exemple 2 : En Informatique, vous avez peut être déjà étudié des “graphe de transition” capable de
reconnaitre les expressions régulières. Il sagit bien de la même notion de systèmes séquentiels.

Considérons par exemple, l’expression régulière écrite avec la notation de Keene : (a|b) ∗abb
Cette expression peut être reconnue par l’automate suivant en synthèse de Moore :

1
Ce n’est pas du tout le cas sur les systèmes asynchrones où l’on se rapprochera le plus possible d’un codage de Gray
pour éviter de tomber dans des états non prévus !
16 Électronique Numérique

a a

a b b D
A B C
a OK

a
b b

On remarque que cet automate est non déterministe car l’occurence de a peut laisser l’automate
dans l’état A ou l’amener dans l’état B. Or notre finalité est de synthétiser physiquement les automates.
Donc nous lui préfèrerons la version déterministe suivante :

a 0

a b b D A 0 B 1 C 1 D
A B C
a OK 0 0 0 0 1

a 0
b a 1 0

b E 1
E
codage de a,b et OK 0

b 1

Remarque sur la notation des transitions

Il existe deux manières différentes de noter les transitions d’un automate.

– La “notation liste” consiste à donner l’état des variables qui permettent la transition : ainsi
“01” signifie que la première variable (ex. a) doit être à 0 et la seconde (b) à 1 pour transiter.

– La “notation équationnel” consiste à donner l’équation logique entre les variables qui ca-
ractérise la transition. Pour le même exemple cela donnerait a.b. Cette notation est souvent
préférée à la première car elle n’impose pas d’ordre des variables.

La figure qui suit montre différents exemples d’équivalence entre les deux notations :
[Link], [Link]́ 17

notation liste notation

ab
équationnelle

10 a.b

0X a

X1 b

XX 1

1X
a+b

X1

2.3.2 Description par la table de changement d’état

L’évolution du système est décrite par une table de changement d’ états où l’on note pour chaque
combinaison d’état interne et d’entrée, le nouvel état et les sorties correspondantes. Si nous reprenons
l’exemple précédent du compteur à quatre états, nous obtenons les tables présentées ci-dessous.

Dans le cas de Moore, on peut isoler les sorties dans une table de correspondance à part car un
état stabilisé impose toujours la même combinaison de sortie indépendement des entrées.

Etats internes incr=0 incr=1

A A/000 B/001
B B/001 C/010
C C/010 D/011
D D/011 A/000
MEALY

Etats internes incr=0 incr=1 Etats internes S3S2S1

A A B A 000
B B C B 001
C C D C 010
D D A D 111

MOORE
18 Électronique Numérique
Chapitre 3

Synthèse de systèmes séquentiels synchrones

3.1 Synthèse directe de Mealy ou de Moore

Em
E0
Sp
F
S0
Sp
F
S
0

Em
+ E +
0
Qn Qn
G + G +
Q0 Q0

Qn Qn

Q0 Q0
H H

MEALY MOORE

L’objectif de ce travail de synthèse est de déterminer les équations logiques des fonctions F et G
des machines de Mealy ou de Moore. Cela revient à :

– d’une part déterminer les équations de chaque entrée des bascules afin de conditionner leurs
évolutions lors de la prochaine impulsion d’horloge. C’est la même problèmatique que la
syntèse des compteurs vu l’année dernière : à un instant t, quelles sont les valeurs à appli-
quer aux entrées pour qu’à l’impulsion d’horloge suivante l’état prenne la valeur spécifiée par
l’automate ;

– d’autre part déterminer les équations des sorties en fonction de l’état seul (machine de Moore)
ou de l’état et des entrées (machine de Mealy).

19
20 Électronique Numérique

3.1.1 Synthèse des équations d’états futurs

Dans un premier temps, on établit la table de vérité qui traduit la commutation des états. Les
entrées de la table représentent l’état présent du compteur et les entrées externes alors que les sorties
représentent l’état futur.

A titre d’exemple, considérons l’automate suivant :

00 / 00 11 / 00

10 / 10 01 / 01 e1e0 / S 1S 0

11 / 01
0x / 10 B C
x0 / 00

10 / 10 x1 / 01
1x / 00
D E

1x / 00 0x / 01

De cet automate, nous pouvons extraire la table de changement d’état aussi appelée table
d’évolution :
état e1 .e0 e1 .e0 e1 .e0 e1 .e0
A A /S1 , S0 C /S1 , S0 B / S 1 , S0 A / S 1 , S0
B B /S1 , S0 B /S1 , S0 D / S 1 , S0 A / S 1 , S0
C B /S1 , S0 E /S1 , S0 B / S 1 , S0 E / S 1 , S0
D E /S1 , S0 E /S1 , S0 E / S 1 , S0 E / S 1 , S0
E E /S1 , S0 E /S1 , S0 D / S 1 , S0 D / S 1 , S0

On numérote en binaire tous les états. Ici, il y a 5 états différents, d’où trois bits nécessaires :
Q2 ,Q1 ,Q0 .

Voici un codage possible :

A 000
B 001
C 010
D 011
E 100
Le codage n’a pas d’importance a priori. Il a juste une incidence sur la complexité des équations
d‘état et des sorties obtenues (cf. 3e cycle universitaire !). Pour une question d’initialisation correcte
à la mise sous tension du système, nous choisirons tout de même A → 000 ou A → 111.
[Link], [Link]́ 21

Nous pouvons maintenant établir la table de vérité associée aux fonctions Q + () :

Q2 Q1 Q0 e1 e0 Q2 + Q1 + Q0 +
0 0 0 0 0 A→A 0 0 0
0 0 0 0 1 A→C 0 1 0
0 0 0 1 0 A→B 0 0 1
0 0 0 1 1 A→A 0 0 0
0 0 1 0 0 B→B 0 0 1
0 0 1 0 1 B→B 0 0 1
0 0 1 1 0 B→D 0 1 1
0 0 1 1 1 B→A 0 0 0
0 1 0 0 0 C→B 0 0 1
0 1 0 0 1 C→E 1 0 0
0 1 0 1 0 C→B 0 0 1
0 1 0 1 1 C→E 1 0 0
0 1 1 0 0 D→E 1 0 0
0 1 1 0 1 D→E 1 0 0
0 1 1 1 0 D→E 1 0 0
0 1 1 1 1 D→E 1 0 0
1 0 0 0 0 E→E 1 0 0
1 0 0 0 1 E→E 1 0 0
1 0 0 1 0 E→D 0 1 1
1 0 0 1 1 E→D 0 1 1
1 1 x x x - x x x
1 x 1 x x - x x x

De cette table de vérité, on déduit par Karnaugh les équations logiques des variables d’état :

Q0 + = Q2 .e1 + Q1 .Q0 .e0 + Q1 .Q0 .e1 + Q1 .Q0 .e0 + Q1 .Q0 .e1 .e0
Q1 + = Q2 .e1 + Q1 .Q0 .e1 .e0 + Q2 .Q1 .Q0 .e1 .e0
Q2 + = Q1 .Q0 .e0 + Q1 .Q0 + Q2 .e1

Finalement, pour obtenir les expressions des entrées des bascules, il faut (comme en première
année) procéder par identification avec l’expression de la bascule considérée :

– Q+ = J.Q + K.Q pour une bascule JK

– Q+ = D pour une bascule D (trivial !)

22 Électronique Numérique

3.1.2 Synthèse des sorties (Mealy)

De la table d’évolution et de l’encodage des états, on en déduit la table de vérité des sorties. En
effet, pour un état de départ connu et une combinaison des entrées connue, le système génère toujours
les mêmes sorties.

Sur notre exemple, cela donne :

Q2 Q1 Q0 e1 e0 S1 S0
0 0 0 0 0 0 0
0 0 0 0 1 0 1
0 0 0 1 0 1 0
0 0 0 1 1 0 0
0 0 1 0 0 1 0
0 0 1 0 1 1 0
0 0 1 1 0 1 0
0 0 1 1 1 0 1
0 1 0 0 0 0 0
0 1 0 0 1 0 1
0 1 0 1 0 0 0
0 1 0 1 1 0 1
0 1 1 0 0 0 0
0 1 1 0 1 0 0
0 1 1 1 0 0 0
0 1 1 1 1 0 0
1 0 0 0 0 0 1
1 0 0 0 1 0 1
1 0 0 1 0 0 0
1 0 0 1 1 0 0
1 1 x x x x x
1 x 1 x x x x

Après simplification par Karnaugh, nous obtenons :

S1 = Q1 .Q0 .e1 + Q2 .Q1 .e1 .e0

S0 = Q1 .Q0 .e1 .e0 + Q2 .e1 .e0 + Q1 .Q0 .e0 + Q0 .e1 .e0
[Link], [Link]́ 23

3.1.3 Synthèse des sorties (Moore)

En synthèse de Moore, les sorties ne dépendent que de l’état atteint. Considérons cet exemple
assez proche du précédent :

00 11

10 01 e 1e 0

11
B C
0x
S1 S0
x0

10 x1
1x
D E
S1 S0

1x 0x

Aux sorties près, la table d’évolution est identique à la précédente :

état e1 .e0 e1 .e0 e1 .e0 e1 .e0

A A C B A
B B B D A
C B E B E
D E E E E
E E E D D

Donc si nous prenons le même codage des états nous obtiendrons les mêmes équations de chan-
gement détat.

Q0 + = Q2 .e1 + Q1 .Q0 .e0 + Q1 .Q0 .e1 + Q1 .Q0 .e0 + Q1 .Q0 .e1 .e0
Q1 + = Q2 .e1 + Q1 .Q0 .e1 .e0 + Q2 .Q1 .e1 .e0
Q2 + = Q1 .Q0 .e0 + Q1 .Q0 + Q2 .e1

Par contre, il est nécessaire d’établir pour les sorties la table de correspondance avec les états.

état S1 S0
A 0 0
B 1 0
C 0 1
D 1 0
E 0 1
24 Électronique Numérique

Puis la table de vérité associée :

Q2 Q1 Q0 S1 S0
0 0 0 0 0
0 0 1 1 0
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 1 x x x
1 x 1 x x

et enfin les équations des sorties via Karnaugh :

S1 = Q 0
S0 = Q2 + Q1 .Q0

3.2 Synthèse de Mealy ou Moore par méthode de Marcus

Rappelons que l’objectif de la méthode de Marcus (vue en première année) est de déterminer la
table de vérité des entrées des bascules afin d’obtenir leur expression minimale.

Dans un premier temps, on établit comme précédemment la table d’évolution associé à l’auto-
mate. A partir de cette dernière et de la table de fonctionnement de la bascule utilisée, on construit un
autre tableau où les sorties représentent les valeurs à appliquer aux entrées des bascules. Le rôle de la
table de fonctionnement est de donner la valeur des entrées à appliquer pour les quatre cas possibles
d’évolutions de la bascule considérée.

Dans le cas d’une bascule JK, cette table est (rappel de 1e année) :

Q Q+ J K
0 0 0 x
0 1 1 x
1 0 x 1
1 1 x 0

Si nous considérons l’automate suivant en synthèse de Moore :

0
entrée e
A sortie OK
0
1
1
C 1
B
OK

0
[Link], [Link]́ 25

Nous obtenons la table d’évolution suivante :

état e e
A A B
B A C
C B A

qui devient après codage des états (A → 00, B → 01,C → 10) la table de vérité :

Q1 Q0 e Q+1 Q+0
0 0 0 0 0
0 0 1 0 1
0 1 0 0 0
0 1 1 1 0
1 0 0 0 1
1 0 1 0 0
1 1 0 x x
1 1 1 x x

Nous allons maintenant étendre cette table avec celle de fonctionnement :

Q1 Q0 e Q+1 Q+0 J1 K1 J0 K0
0 0 0 0 0 0 x 0 x
0 0 1 0 1 0 x 1 x
0 1 0 0 0 0 x x 1
0 1 1 1 0 1 x x 1
1 0 0 0 1 x 1 1 x
1 0 1 0 0 x 1 0 x
1 1 0 x x x x x x
1 1 1 x x x x x x

et déterminer les équations associées :

J1 = Q1 .e
K1 = 1
J0 = Q1 .e + Q1 .e
K0 = 1

Ces tables nous permettent de déduire aisément les équations logiques des entrées des bascules. Il
y a deux fois plus de Karnaughs à dessiner, mais ils contiennent beaucoup plus d’indifférents ...

La synthèse des sorties restent identique.

26 Électronique Numérique

3.3 Le problème des états et des cycles parasites

L’année dernière, nous avions vu que les compteurs pouvaient se trouver dans un état non spécifié
au départ. Les équations de changement d’état se trouvant également valable pour ces états, les comp-
teurs risquaient de reboucler sur eux-même (état puit) ou de tomber sur un cycle anormal (cycle
parasite).

Ce problème reste vrai dans le cas général : Après synthèse, il faut “dérouler” les équations de
changement détat sur tous les états non spécifiés et regarder le comportement du système.

Sur le premier exemple de ce chapitre nous obtenons ainsi :

Q2 Q1 Q0 e1 e0 Q2 + Q1 + Q0 +
0 0 0 0 0 A→A 0 0 0
0 0 0 0 1 A→C 0 1 0
0 0 0 1 0 A→B 0 0 1
0 0 0 1 1 A→A 0 0 0
0 0 1 0 0 B→B 0 0 1
0 0 1 0 1 B→B 0 0 1
0 0 1 1 0 B→D 0 1 1
0 0 1 1 1 B→A 0 0 0
0 1 0 0 0 C→B 0 0 1
0 1 0 0 1 C→E 1 0 0
0 1 0 1 0 C→B 0 0 1
0 1 0 1 1 C→E 1 0 0
0 1 1 0 0 D→E 1 0 0
0 1 1 0 1 D→E 1 0 0
0 1 1 1 0 D→E 1 0 0
0 1 1 1 1 D→E 1 0 0
1 0 0 0 0 E→E 1 0 0
1 0 0 0 1 E→E 1 0 0
1 0 0 1 0 E→D 0 1 1
1 0 0 1 1 E→D 0 1 1
1 0 1 0 0 - 1 0 1
1 0 1 0 1 - 1 0 1
1 0 1 1 0 - 0 1 1
1 0 1 1 1 - 0 1 1
1 1 0 0 0 - 1 0 1
1 1 0 0 1 - 1 0 0
1 1 0 1 0 - 0 1 1
1 1 0 1 1 - 1 1 1
1 1 1 0 0 - 1 0 0
1 1 1 0 1 - 1 0 0
1 1 1 1 0 - 1 1 1
1 1 1 1 1 - 1 1 1

et le graphe complété :
[Link], [Link]́ 27

00 / 00 11 / 00

000

10 / 10 01 / 01

11 / 01
0x / 10 001 010
x0 / 00

0x 10 / 10 x1 / 01
1x / 00
1x
101 011 100

00 10 1x / 00 0x / 01
01
110

11

111
0x
1x

Sur ce graphe, nous voyons que le système peut localement se bloquer suivant les entrées, mais il
finit toujours par tomber dans un état spécifié.

Dans l’absolue, il faudrait également regarder l’incidence des états parasites sur les sorties !

3.4 Cas particulier des séquenceurs simples

Nous avons l’année dernière 1 qu’un séquenceur était un compteur auquel nous avions adjoint un
décodeur ; les sorties du décodeur pouvant ensuite se recombiner :

ligne n−1
action k
n
compteur

décodeur

n −> 2

action k’

n
ligne 0
séquenceur

En fait, un séquenceur de base est une machine de Moore, qui a la propriété de ne posséder qu’un
cycle (celui du compteur sous-jacent) et aucune d’entrée.
1
second semestre, chapitre 7
28 Électronique Numérique

Action 1

Action n

Nous pouvons donc le synthétiser directement sans se référer au décodeur et le résultat obtenu
sera identique. D’ailleurs l’étude de la partie purement séquentielle est celle du compteur !

Mais nous pouvons également concevoir des séquenceurs plus complexe ou le cycle dépend d’une
ou plusieurs entrées.

Voici l’exemple d’un feu rouge avec appel piéton :

R
1
x
x

O R

1 0
x

V V
0

Le cycle normal est R,R,V,V,O. Mais l’appel pı́éton peut conduire aux deux cycles plus courts :
R,R ou à R,R,V,O.
Chapitre 4

Premiers pas dans l’architecture des

microprocesseurs

4.1 Introduction
Lorsqu’on désire effectuer la synthèse d’un système séquentiel, plusieurs solutions s’offrent en
fonction de la taille de l’application, du nombre d’exemplaires à fournir et du suivi du produit. Si
l’application est de faible complexité, il est préférable d’utiliser une solution câblée, car sa vitesse
est toujours plus rapide. Si de plus le nombre d’exemplaire à produire est grand, on s’orientera vers
la conception d’un circuit spécialisé (ASIC : Application Specific Integrated Circuits). Par contre,
si l’application est complexe et susceptible de subir des évolutions, l’utilisation de composants pro-
grammables (au sens informatique) est fortement conseillé : microprocesseurs et séquenceurs pro-
grammables.

4.2 Les différents type de séquenceurs

4.2.1 Séquenceur câblé
Un séquenceur est à la base un compteur, qui active à chaque coup d’horloge, zero, une ou
plusieurs actions particulières. Pour simplifier la réalisation technique, on utilise classiquement un
décodeur dont chaque ligne est activée en séquence.

action 1
n
compteur

décodeur

n -> 2

n n
action 2

F IG . 4.1 – Structure d’un séquenceur câblé

29
30 Électronique Numérique

Bien sûr, ce séquenceur peut être directement conçu comme une machine de Moore.

4.2.2 Séquenceur programmables ou microprogrammé

Contrairement à leurs homologues câblés qui effectuent toujours la mème séquence, les séquenceurs
programmables interrogent en permanence une mémoire (par exemple RAM) pour déterminer :

– quelle séquence ils doivent executer,

– la valeur de l’adresse suivante ou se trouve la prochaine séquence

adresse

compteur décodeur

commandes

F IG . 4.2 – Structure d’un séquenceur programmable

Ce type de séquenceur présente un avantage sur le précédent du fait que l’on peut modifier le fonc-
tionnement du système dans une large mesure en inscrivant un nouveau contenu dans la mémoire, sans
toucher au câblage. Afin de constituer une partie commande entièrement microprogrammée, on in-
clut dans la mémoire les commandes à fournir à l’unité de traitement. Cette mémoire est alors appelé
mémoire de programme. Elle est associe à un compteur spécifique : le Compteur Programme CP (ou
PC en englais) dont elle contient également les différentes adresses de saut. Chaque case mémoire est
appelée instruction.

En général, le compteur programme doit être capable d’executer un certain nombre de tâches par
exemple :

– rester dans sa position dans l’attente d’un événement extexne,

– s’incrémenter pour passer à l’instruction suivante,
– s’initialiser à zéro pour permettre de démarrer au début du programme,
– modifier son contenu pour permettre un saut dans le programme.
[Link], [Link]́ 31

autorisation de comptage

remise à 0 chargement

entrées sorties

compteur

H
F IG . 4.3 – Description externe du compteur programme

Pratiquement tous les compteurs du commerce ont ces possibilités. A chaque adresse fournie
par le compteur, correspond une instruction du programme. Cette instruction est décrite en binaire
sous forme d’un mot de n bits. Ce dernier est partagé en zone ou champs spécifique à chaque bloc
fonctionnel qui en est destinataire.

code opération adresse de saut Commandes

F IG . 4.4 – Les différents champs d’une instruction

L’instruction fournie par la mémoire de programme comprend :

– un champs réservé au code opération (“opcode”) qui permet de commander en autre la fonction
du compteur,
– un champs adresse qui contient l’adresse de saut du programme. Cette adresse correspond alors
à l’adresse de chargement du compteur,
– un champs commandes destinées à la partie traitement.
Afin de donner encore plus de souplesse au système dont on effectue la synthèse, la partie traite-
ment peut être rendue programmable en utilisant des composants comme les UALs (Unités Arithmétique
et Logiques) et les FPUs (Floating Point Unit).

4.3 Caractéristiques générales des microprocesseurs

4.3.1 Historique
En 1972, Moore a l’idée de regrouper sur un seul circuit, le séquenceur programmable, le comp-
teur de programme, une UAL et un registre de donnée en laissant uniquement à l’extérieur la mémoire :
Le premier microprocesseur était né.
Pour industrialiser ce nouveau concept de composant électronique il crée INTEL, petite société
de 10 personnes qui a certainement disparu aujourd’hui ...
32 Électronique Numérique

L’explosion que l’on connait est lié à la vocation universelles des microprocesseurs. Le nombre
de fonctions qu’ils réalisent est très étendu, ce qui les rend apte à traiter n’importe quelle application,
sous réserve des contraintes de vitesse.

4.3.2 Systèmes à microprocesseur

La structure générale d’un système à microprocesseur se compose :
– du microprocesseur avec éventuellement quelques circuits auxiliaires : génération d’horloge,
registres tampons ...
– une mémoire vive pour manipuler les données et programmes,
– des périphériques d’entrée/sortie, où l’information circule en parallèle ou en série.

environnement

périphériques mémoires

adresses

données

controle

micro-processeur horloge

F IG . 4.5 – Architecture à microprocesseur

Le constructeur fournit la liste des fonctions réalisées par le microprocesseur et les commandes à
appliquer à ce dernier pour les accomplir. Le concepteur peut alors :
– soit établir manuellement l’enchainement des fonctions à réaliser à partir de l’organigramme et
placer cette séquence de code en mémoire,
– soit implémenter le système dans un langage évolué qui puisse être compilé (c’est à dire traduit
dans la séquence de code précédente) de manière automatique.

4.4 Exemple d’architecture interne

4.4.1 Schéma interne
Le schéma qui suit est un exemple d’architecture de microprocesseur 8 bits de données, 8 bits
d’adresses. Il est basé sur l’utilisation de deux registres accumulateurs AL, BL, d’une UAL, d’un comp-
teur et surtout d’un séquenceur qui joue le rôle de chef d’orchestre par la génération de toutes les
horloges secondaires (suivant les opcodes à traiter).
[Link], [Link]́ 33

0
registre intermédiaire 8 MUX
de donnees 2 −> 1 1

8
8
registres
bus
0 données

CCR
equal
MUX
2 −> 1

UAL
AL
8
8
0 11
8
8 10
8 8
BL 01
bus
8 MUX
adresse
opcode 4 −> 1
compteur 8
00
programme

load BL
registre equal
d’instruction load AL

5 5 load CCR

adrREG
Séquenceur

opcode
selectREG

incPC

loadPC 2
select adr

R/W

memCS

load instruction
load data
H
RESET

F IG . 4.6 – Architecture interne

34 Électronique Numérique

4.4.2 Automate de comportement du séquenceur

Le séquenceur peut se représenter lui-même sous forme d’un automate particulier. Sa forme
diffère d’un processeur à l’autre, mais il comporte toujours trois parties bien distinctes :

– chargement de l’opcode,
– traitement du mode d’adressage,
– traitement de l’instruction associée à l’opcode et au mode d’adressage.

La figure suivante montre l’automate dédié à notre exemple :

t1
chargement
opcode
t2

t3 t6

t4 t5

t9
traitement
t7 t8 t10

du mode
t11

d’adressage

t12

t13 t14

t15

t18 t19
t16 t17

traitement

de l’instruction
t21 t22
t20 t23
t24

F IG . 4.7 – Architecture interne

Chaque transition est associée à un ensemble d’action à réaliser (tableau suivant) :

[Link], [Link]́ 35

t Conditions Action t Condition Action

1 equal = x select adr = 00 2 equal = x select adr
opcode = xxxxx load instruction = 0 opcode = xxxxx load instruction = 1
R/W = 1 R/W = 1
memory CS = 0 memory CS = 0
3 equal = x load instruction = 0 4 equal = x load instruction = 0
opcode = xx100 selectREG = 1 opcode = xxx000 selectREG = 0
R/W = 1 R/W = 1
memory CS = 1 memory CS = 1
adrREG = 1 adrREG = 1
load data = 0 load data = 0
...
7 equal = x load instruction = 0 8 equal = x load instruction = 0
opcode = xxxxx selectREG = 1 opcode = xxxxx selectREG = 0
R/W = 1 R/W = 1
memory CS = 1 memory CS = 1
adrREG = 1 adrREG = 1
load data = 1 load data = 1
...
36 Électronique Numérique

4.4.3 Jeu d’instruction du processeur

Chaque instruction du processeur nécessite un ou deux octets. Le premier octet contient toujours
l’opcode. Le second octet contient une constante ou une adresse mémoire suivant le type d’adressage
demandé.

Dans cet exemple, l’opcode occupe 5 bits : 3 bits sont réservés pour le type d’instruction, 2 bits
servent à définir le mode d’adressage de chargement

OPCODE
0 0 0 x x x y y

non utilises type d’instruction mode d’adressage

Pour vous familiariser avec vos futurs enseignements d’assembleur, nous avons pris une syntaxe
du jeu d’instruction proche du Pentium.

opcode(432) syntaxe description exemple

000 mov AL, ... chargement de AL mov AL,0
001 mov BL, ... chargement de BL mov BL,[10]
010 add AL, ... addition sur AL add AL,3
011 cmp AL, ... comparaison de AL cmp AL,[BL]
100 je adresse saut si egal je 20
101 jne adresse saut si différent jne 20
110 jmp adresse saut jmp 20
111 mov [BL], ... sauvegarde en memoire mov[BL], AL

opcode(10) syntaxe description

00 BL registre BL
01 [BL] adressage indirect
10 constante adressage immediat
11 constante adressage direct

par exemple 00001010 01111111 s’écrit add AL,127.

Cela signifie : AL ← AL(ancienne valeur) + 127.

Remarques :
Ce processeur a deux opcodes particuliers qui ne respectent pas les tableaux précédents.
– 00000100 qui s’écrit mov BL,AL
– 00011100 qui s’écrit mov [BL],AL
les opérations de comparaison cmp permettent de positionner le bit equal du registre CCR, lui
même utilisé par les instructions je et jne.

Les transparents suivants montre comment l’instruction add AL,3 est traitée par le processeur :
[Link], [Link]́ 37
38 Électronique Numérique
[Link], [Link]́ 39

4.5 Exemple de programme

Grâce au compteur programme, le processeur va maintenant pouvoir executer des squences d’ins-
tructions, mise à bout b̀out en mémoire. Le compteur s’incrémentera de 1 ou de 2 suivant la taille de
l’instruction traitée ou chargera une nouvelle adresse d’execution jmp.

Pour argumenter notre propos, considérons l’exemple suivant : On veux calculer la somme des
éléments d’un tableau. Ce code peut s’écrire simplement en langage C.

somme = 0;
for (n=0; n!= 10; n++)
{
somme = somme + tab[n];
}

En supposant que “somme” est rangée en mémoire à l’adresse 255, “n” à l’adresse 254 et “tab”
(tableau de 10 octets) à l’adresse 200, un compilateur C pourrait générer de manière automatique et
systématique le code pour notre processeur.
40 Électronique Numérique

Par exemple l’affectation :

somme = XXX

s’écrie toujours quel que soit la constante XXX de la manière suivante :

mov AL, XXX

mov BL, 255
mov [BL], AL

De ce fait, la compilation du programme précédent génère le code suivant :

# adresse de depart du programme: 0

mov AL, 0
mov BL, 255
mov [BL], AL # somme = 0
mov BL, 254
mov [BL], AL # n = 0

mov AL, [254]

cmp AL, 10 # si n == 10
je 33 # alors allez a l’adresse 33
add AL, 200 # formation de l’adresse
mov BL,AL # de tab[n]
mov AL, [255]
add AL, [BL]
mov BL, [255]
mov [BL], AL # somme <-- somme + tab[n]
mov AL, [254]
add AL, 1
mov BL, [254]
mov [BL], AL # n <-- n + 1
jmp 8 # allez a l’adresse 8 (c.a.d : 6 ieme ligne)
# adresse de fin: 33
[Link], [Link]́ 41

qui est écrit en réalité en binaire (code machine) pour être compris par le processeur :

adresse instruction
0 00000010 00000000
2 00000110 11111111
4 00011100
5 00000110 11111110
7 00011100

8 00000011 11111110
10 00001110 00000101
12 00010010 00100001
14 00001010 11001000
16 00000100
17 00000011 11111111
19 00011100
20 00000011 11111110
22 00001010 00000001
24 00000110 11111110
26 00011100
27 00011010 00001000

Pour simplifier1 , chaque ligne d’origine est toujours traduite par le même groupe d’instructions
assembleurs, (donc de codes machine). Ceci a l’avantage d’être systématique, mais à l’inconvénient
de générer fréquement du code inutile ou redondant. Après cette phase, il est donc indispensable
d’optimiser le code produit pour réduire les temps d’execution et la mémoire utilisée.

4.6 Conclusion
La conception avec microprocesseur simplifie notre étude car nous partons d’éléments connus.
Il reste cependant à concevoir des équipements spécifiques de l’application. La richesse richesse des
possibilités d’un microprocesseur permet d’offrir à l’utilisateur des prestations de plus haut niveau.
Mais l’utilisation de ce type de composants nécessite un personnel qualifié donc par conséquent un
gros effort de formation.

1
en fait ce serait plutot chaque structure ou constructeur du langage