cours_archi_2006-20071 (1).ppt

Architecture des Ordinateurs
IUT Informatique de Calais

IUT Informatique
Calais
Architecture des ordinateurs 2
Objectif du cours : Étude du fonctionnement interne de l’ordinateur
1ière partie : couple processeur / mémoire
• codage des nombres
• logique combinatoire
fonctions simples : addition …
• logique séquentielle
fonctions plus sophistiquées : mémoire ...
• introduction à l'assembleur
2ième partie : carte mère et périphériques
• carte mère : chipset, bus, connecteurs …
• périphériques d’entrée : clavier, souris …
• périphériques de sortie : écran, imprimante …
• périphériques d’entrée sortie : disque dur, modem ...
logique booléenne

IUT Informatique
Calais
8 TDs :
• manipulation de nombres binaires
• logique combinatoire
• logique séquentielle
8 TPs :
• programmation assembleur
2 DS + 1 contrôle TD + 1 contrôle TP
Période : 1er semestre (16 semaines)
16 Cours

IUT Informatique
Calais
1 Introduction
1.1 Objectif de la première partie du cours
Couple processeur / mémoire :
• utilisation des opérations logiques de base : ET, OU, NON
• niveaux logique et fonctionnel (circuits logiques et équations)
• réalisation d’unités de traitement primitives
• assemblage de ces unités pour préciser l’organisation de l’ordinateur

IUT Informatique
Calais
1.2 Historique de l’informatique
… agrémenté de quelques « phrases célèbres » en rouge …
Références :
– « Préhistoire et histoire des ordinateurs » de Robert Ligonnière, Robert
Laffont, 1987
– http://www.scedu.umontreal.ca/histoiredestec/histoire/tdmhiste.htm (offline ...)
– http://histoire.info.online.fr
– http://dmawww.epfl.ch/~delay/projet3 (offline ...)
1.2.1 Du manuel à la mécanique

IUT Informatique
Calais
L’homme a toujours cherché à s’aider pour le calcul :
-500 : premiers outils de calcul, l ’abaque et le boulier

IUT Informatique
Calais
-300 : Aristote définit la logique
1580-1617 : J. Napier invente les logarithmes + nombres décimaux
+ techniques de multiplication et division (bâtons de Napier)
1623 : Cylindres de Schickard ( + idée d ’utiliser des roues dentelées)
1673 : Disques de Morland

IUT Informatique
Calais
1624 : Schickard esquisse la première calculatrice
1642 : Blaise Pascal invente la pascaline

IUT Informatique
Calais

IUT Informatique
Calais
1694 : machine de Leibniz (multiplication et division)

IUT Informatique
Calais
1820 : C.X. Thomas invente l’arithmomètre (6 à 20 chiffres)
• 1 500 exemplaires vendus de 1823 à 1878

IUT Informatique
Calais
1937 : C. Herzstark invente la Curta
• Curta I : 80 000 exemplaires vendus de 1947 à 1970
• Curta II : 60 000 exemplaires vendus de 1954 à 1970

IUT Informatique
Calais
Historique de l ’informatique
1.2.2 De la mécanique à l’électromécanique

IUT Informatique
Calais
1833 : Babbage imagine une machine analytique contenant les concepts
d’unité de calcul, mémoire, registre et entrée des données par carte perforée
1840 : Ada Lovelace, collaboratrice de Babbage définit le principe
d’itérations successive dans l’exécution d’une opération et nomme ce
processus algorithme en l’honneur du mathématicien arabe Al Khowarizmi

IUT Informatique
Calais
1854 : Boole démontre que tout processus logique est décomposable en une
suite d’opérations logiques (ET, OU, NON) appliquées sur 2 états (0-1, V-F, ...)
1884 : H. Hollerith crée une tabulatrice à cartes perforées pour faire traiter le
recensement américain de 1890, c’est la 1ière machine à traiter l’information

IUT Informatique
Calais
1896 : H. Hollerith crée la firme Tabulating Machine Corporation
1904 : J. Fleming invente le premier tube à vide (la diode)
1907 : L.D. Forest invente la triode
1919 : Eccles et Jordan inventent le basculeur (flip-flop ou circuit bi-stable)
1924 : Tabulating Machine Corporation est renommée
International Business Machine

IUT Informatique
Calais
1937 : A.M. Turing résout des problèmes mathématiques à l’aide d ’une bande
de papier, de pions et d ’un trombone ! C’est la machine de Turing
1938 : Shannon dans sa thèse fait le parallèle entre circuit électrique et algèbre
booléenne. Il définit le chiffre binaire : bit (BInary digiT)
1938 : K. Zuse crée le Z1, ordinateur binaire programmable mécanique !
1939 : Z2, une partie de la mécanique est remplacée par des relais téléphoniques

IUT Informatique
Calais
1941 : J. Atanasoff et C. Berry créent le 1er calculateur binaire basé sur
l’algèbre de Boole. L’ABC est considéré comme le premier ordinateur mais
son programme n’est pas stocké en mémoire
1941 : Z3, premier calculateur avec programme enregistré. Mémoire : 64
nombres de 22 bits, puissance : 4 +/s ou 1 x en 4s

IUT Informatique
Calais
1943 : H. Aiken crée le Mark I calculateur électromécanique (3000 relais, 800km
de câbles) dont le fonctionnement est proche de la machine imaginée par
Babbage
1945 : un insecte coincé dans la Mark I bloque son fonctionnement. La
mathématicienne G.M. Hopper décide que tout ce qui arrêtera le bon
fonctionnement d ’un programme s’appellera BUG.
1945 : J. Von Neuman travaillant sur le projet ENIAC définit ce que devrait être
un ordinateur à programme enregistré : architecture de Von Neuman
1943 : Thomas Watson, IBM : « Je pense qu’il y a un marché mondial pour au
moins 5 ordinateurs. »

IUT Informatique
Calais
Historique de l ’informatique
1.2.3 L’électronique

IUT Informatique
Calais
1946 : P. Eckert et J. Mauchly créent l’ENIAC. Particularités : 18 000 tubes, 30
tonnes, 72 m2, 140 KW, 100 kHz, 330 x/s

IUT Informatique
Calais
1948 : Newman et Williams créent le Manchester Mark I. Particularité : mémoire à
tubes cathodiques
1950 : M.V. Wilkes invente l ’assembleur (avant on programmait en binaire)
1951 : G.M. Hopper invente le premier compilateur A0 générant un programme
binaire à partir d’un code source
1947 : invention du transistor dans les laboratoires de Bell Telephone
1953 : invention de la mémoire à tores de ferrite
1949 : revue Popular Mechanics : « Alors que le calculateur ENIAC est équipé de
18000 tubes à vide et pèse 30 tonnes, les futurs ordinateurs de l’an 2000 ne
devraient avoir que 1000 tubes à vide et ne peser que 1,5 tonnes. »

IUT Informatique
Calais
1956 : TRADIC le premier ordinateur à transistors par Bell amorce la seconde
génération d ’ordinateurs
1956 : 1er disque dur, le RAMAC 305 par IBM (50 disques de 61 cm - 5 Mo)
1957 : J. Backus d ’IBM crée le langage FORTRAN

IUT Informatique
Calais
1958 : 1er ordinateur commercial entièrement transistorisé par S. Cray

IUT Informatique
Calais
1958 : 1er circuit intégré par Texas Instruments
1958 : 1er modem par Bell
1958 : 1er jeu vidéo (très similaire au jeu pong par Atari en 1972)
1960 : langage Cobol
1962 : P. Dreyfus invente le mot informatique
1964 : langage Basic

IUT Informatique
Calais
1965 : G. Moore écrit que la densité des circuits intégrés doublera tous les 18
mois (loi de Moore)
1966 : première console de jeux vidéo, la Magnavox Odyssey I
1967 : plans de l’ARPANET (ancêtre de l ’internet)
1967 : premier lecteur de disquettes par IBM

IUT Informatique
Calais
1968 : D.C. Engelbart fait la démonstration d’un environnement graphique avec
fenêtres utilisant une souris.
1968 : langage Pascal
1969 : naissance d ’Unix grâce à K. Thompson et B. Kernighan
1970 : K. Thompson crée le langage B pour Unix
1968 : HP présente sa première calculatrice de bureau programmable, la HP 9100
(20 kg, 5000 $)

IUT Informatique
Calais
1971 : Intel vend le premier microprocesseur : Intel 4004 (4 bits, 108 kHz, 200$)
1971-1973 : transformation du langage B (interprété) en langage C (compilé)
1971 : Apparition de l’ordinateur Kenback-1 pour 750$ en kit !

IUT Informatique
Calais
1972 : R. Tomlinson crée un logiciel de courrier électronique pour ARPANET
1972 : premier langage orienté objet, SmallTalk
1972 : B. Gates et P. Allen fondent la compagnie Traf-O-Data
1973 : apparition du mot microcomputer (micro-ordinateur)
1975 : Traf-O-Data devient Micro-Soft
1976 : S. Jobs et S. Wozniak créent l ’Apple Computer et fondent Apple
1977 : Ken Olson, DEC : « Il n’y a aucune raison pour que tout le monde
veuille un ordinateur à la maison »

IUT Informatique
Calais
Avril 1981 : Xerox vend le Star 8010. Caractéristiques : Ram 1 Mo, DD 8 Mo,
interface Ethernet, interface graphique, souris 2 boutons, Drag&Drop, copier-
coller, menus contextuels, tableur, traitement de texte WYSIWYG, et messagerie
électronique. Problème : 17 000 $
Il faudra 10 ans à Apple et 15 ans à Microsoft pour faire aussi bien !

IUT Informatique
Calais
Août 1981 : IBM lance le 5150 Personal Computer. Caractéristiques : RAM
640Ko, lecteur de disquettes 5’’25, système PC-DOS 1.0 pour 3 000 $ (version
CGA 16 couleurs pour 6000 $). Windows 1.0 sortira en novembre 1985.
Il n’apporte rien de nouveau et pourtant ...
1981 : Bill Gates, Microsoft : « 640Ko devrait être suffisant pour tout le monde. »

IUT Informatique
Calais
Janvier 1983 : Apple lance le Lisa. Caractéristiques : µP 68000 à 5Mhz, 1 Mo
RAM, 2 Mo ROM, écran graphique 12’’ 720x364, 2 x 5’’25, DD 5 Mo avec
interface graphique et souris. 10 000 $
Janvier 1984 : Apple lance le Macintosh. Caractéristiques : µP 68000 à 8Mhz,
128Ko RAM, 64 Ko ROM, 3’’50, écran N&B 9’’ 512x384 avec interface
graphique et souris. 2 500 $
Loi de Wirth : « Les logiciels deviennent plus lents de manière plus rapide que
le matériel ne devient plus rapide. »

IUT Informatique
Calais
Historique de l’informatique
FIN

IUT Informatique
Calais
1.3 Positionnement du problème
On souhaite construire un ordinateur basé sur l’utilisation de la base 2
Problèmes :
• représentation des nombres
• réalisation des opérations arithmétiques :
• + et - : facile en entier et en réel
• x : plus dur ...
• / : efficacité difficile à obtenir en entier, ardu en réel
• séquenceur
• intégration

IUT Informatique
Calais
1.4 Principes fondamentaux
Tous les ordinateurs sont fondés sur les mêmes principes de base :
• programmes / données
• processeur / mémoire / périphériques
• informations codées en binaire
• traitements effectués en binaire
Pourquoi la base 2 ?
• Simple
• générale
Depuis l ’ENIAC, seule la technologie a changée :
lampe à vide - transistor - circuit intégré - microprocesseur
d ’où : plus rapide, plus petit, moins gourmand, plus fiable, moins coûteux

IUT Informatique
Calais
1.5 Définitions
Définition 1
Un processeur est un élément qui exécute des traitements. Les traitements à
exécuter sont indiqués par les instructions du programme exécuté. Les traitements
s’appliquent sur des données et fournissent également des résultats.
Définition 2
La mémoire centrale contient les programmes exécutés par le processeur
ainsi que les données du programme et ses résultats.
Processeur
Résultats
Programme
Données
Mémoire

IUT Informatique
Calais
2 Logique booléenne
2.1 Représentation des valeurs booléennes
• 0 : 0 volt = masse
• 1 : +5 volts = alimentation
2.2 Les portes logiques
2.2.1 Fonction NON (inverseur)
Elle donne le complémentaire d ’une valeur logique.
a s a s
symbole usuel symbole normalisé ANSI table de vérité
a
s
a
s 

 ,
:
Notation
a s
0 1
1 0
1

IUT Informatique
Calais
2.2.2 Fonction ET
Un ET est vrai si ses deux entrées sont vraies.
b
a s
a
b
s
&
b
a
s
b
a
s 

 ,
.
:
Notation
a b s
0 0 0
0 1 0
1 0 0
1 1 1
2.2.3 Fonction OU
Un OU est faux si ses deux entrées sont fausses.
a
b
s
b
a
s
b
a
s 


 ,
:
Notation
a b s
0 0 0
0 1 1
1 0 1
1 1 1
b
a s
1


IUT Informatique
Calais
2.2.4 Fonction NON-ET ou NAND
Un NON-ET est un ET complémenté. Son résultat est faux si ses deux
entrées sont vraies.
b
a s
a
b
s
&
b
a
s
b
a
s 

 ,
.
:
Notation
a b s
0 0 1
0 1 1
1 0 1
1 1 0
2.2.5 Fonction NON-OU ou NOR ou NI
Un NI est un OU complémenté. Son résultat est vrai si ses deux entrées
sont fausses.
a
b
s
b
a
s
b
a
s 


 ,
:
Notation
a b s
0 0 1
0 1 0
1 0 0
1 1 0
b
a s
1


IUT Informatique
Calais
2.2.6 Fonction OU-EXCLUSIF
Un OU-EXCLUSIF est vrai si ses deux entrées ont des valeurs différentes.
Il permet de « tester » si deux valeurs logiques sont différentes.
a
b
s
)
.
.
(
,
:
Notation b
a
b
a
b
a
b
a
s
b
a
s 






1

b
a s
a b s
0 0 0
0 1 1
1 0 1
1 1 0
2.2.7 Fonction NI-EXCLUSIF
Un NI-EXCLUSIF est vrai si ses deux entrées ont des valeurs égales. Il
permet de « tester » si deux valeurs logiques sont égales.
)
.
.
(
re
particuliè
notation
de
Pas b
a
b
a
b
a 


b
a s
a
b
s
1

a b s
0 0 1
0 1 0
1 0 0
1 1 1

IUT Informatique
Calais
2.2.8 Fonctions ET-multiple, OU-multiple, NON-ET-multiple et NI-multiple
Les fonctions ET, OU, NON-ET et NI (NON-OU) se généralisent facilement
à des fonctions ayant un nombre quelconque d ’entrées :
• ET-multiple : vrai (1) si toutes ses entrées sont vraies (1), faux (0) sinon
• OU-multiple : faux si toutes ses entrées sont fausses, vrai sinon
• NON-ET-multiple : faux si toutes ses entrées sont vraies, vrai sinon
• NI-multiple : vrai si toutes ses entrées sont fausses, vrai sinon

IUT Informatique
Calais
2.2.9 Porte trois-états
La porte trois-états agit en interrupteur.
Elle possède deux entrées et une sortie.
L ’une des entrées contrôle son activité. Si celle-ci vaut 1 alors l ’entrée a est
directement connectée à la sortie s, sinon elles sont déconnectées.
L ’état déconnecté n ’est pas un 0, on le nomme haute-impédance (noté Z).
a s
c
a s
c
ou a s
c
c a s
0 0 Z
0 1 Z
1 0 0
1 1 1
c a s
0 0 0
0 1 1
1 0 Z
1 1 Z

IUT Informatique
Calais
L ’intérêt de la porte trois-états est de pouvoir connecter directement deux fils
en évitant tout risque de court-circuit en utilisant un montage de barrière bi-
directionnelle ou transceiver.
c

IUT Informatique
Calais
2.2.10 Aspect matériel
Matériellement, les portes se présentent dans des circuits intégrés. Un circuit
en regroupe un certain nombre de même type.
Exemple : le 7400 comporte 4 portes NAND
13
14 8
9
10
11
12
2
1 7
6
5
4
3

IUT Informatique
Calais
Il faut un certain temps pour qu ’une porte logique réagisse à un changement
sur ses entrées : c’est le délai de propagation (environ 10 ns)
Chronogramme réel faisant apparaître ce délai :

1
s 0
1
b 0
1
a 0
délai de propagation
dans une porte ET
Une porte peut prendre en compte le valeur d’une entrée lorsqu’il y a un
changement d’état logique de cette entrée.
Changement d ’état = front :
• 0 à 1 : front montant
• 1 à 0 : front descendant

IUT Informatique
Calais
Le délai de propagation d'un circuit est le temps le plus long nécessaire pour
propager un front sur une des entrées vers une des sorties.
Exemple de calcul du délai de propagation :
t
b
a
c
s
15ns
NON-OU-EXCLUSIF à 3 entrées
15ns
OU-EXCLUSIF à 3 entrées
14ns
NON-OU à 3 entrées
14ns
NON-ET à 3 entrées
14ns
OU à 3 entrées
14ns
ET à 3 entrées
13ns
NON-OU-EXCLUSIF à 2 entrées
13ns
OU-EXCLUSIF à 2 entrées
12ns
NON-OU à 2 entrées
12ns
NON-ET à 2 entrées
12ns
OU à 2 entrées
12ns
ET à 2 entrées
10ns
NON (inverseur)
Délai de propagation :
b vers t : 10 + 12 + 12 = 34ns

IUT Informatique
Calais
Exemple de chronogramme :
Chronogrammes en TD : on supposera qu’il n’y a pas de délai de propagation
1
0
1
0
1
0
1
0
1
0
temps
t
b
a
c
s
i
j
s
j
i
b
a

IUT Informatique
Calais
2.3 Simplification d’une fonction logique
Pourquoi simplifier ?
• Équation plus lisible
• + facile à construire
• - cher
• + rapide
• - gourmand en énergie
• - de chaleur
Théorème 1
La porte NON-ET est universelle.
Théorème 2
La porte NI est universelle.

IUT Informatique
Calais
2.3.1 Théorèmes de Boole
1
-
-
1
1
-
0
-
0
.
-
.
-
1
.
-
0
0
.
-












a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
a
2.3.2 Formules de De Morgan
b
b




a
a.b
-
.
a
b
a
-

IUT Informatique
Calais
2.3.3 Autres propriétés
• ET est associatif et commutatif (comme la multiplication)
• OU est associatif et commutatif (comme l’addition)
• ET est distributive par rapport à OU (comme x par rapport à +)
2.4 Représentation des nombres
2.4.1 Utilisation d'une base quelconque et changement de base
Un nombre N en base B s'écrit :
NB = anan-1an-2 … a1a0 avec 0 ≤ ai ≤ B-1
Exemples : base 2 (binaire) : 011011100102 0 ≤ ai ≤ 1
base 8 (octal) : 12456764706208 0 ≤ ai ≤ 7
base 10 (décimal) : 97468205610 0 ≤ ai ≤ 9
base 16 (hexadécimal) : 3A5E8F16 0 ≤ ai ≤ F
chiffres hexadécimaux : 0 1 2 3 4 5 6 7 8 9 A B C D E F

IUT Informatique
Calais
Pour trouver la valeur décimale d'un nombre en base B :
N10=anBn + an-1Bn-1 + … + a2B2 + a1B1 + a0
Exemples : 10112 = 1×23 + 0×22 + 1×21 + 1 = 1110
2478 = 2×82 + 4×81 + 7 = 16710
2DB16 = 2×162 + 13×161 + 11 = 73110
Pour passer d'une base à une autre il est toujours possible de passer par la
base 10
Pour passer du binaire à une base de type 2n il suffit de regrouper les bits par
n de la droite vers la gauche afin de retrouver chaque chiffre en base 2n.
Exemples : soit 101101112 à représenter en
octal (8 = 23) : 10 110 111 2 = 2678
hexadécimal (16 = 24) : 1011 0111 2 = B716

IUT Informatique
Calais
2.4.2 Représentation des nombres binaires non signés
n bits permettent de représenter 2n valeurs différentes, donc les nombres
entiers positifs de 0 à 2n-1.
Exemple : sur 8 bits on peut représenter 28 = 256 valeurs différentes donc les
entiers de 0 à 255 (0000 0000 à 1111 1111).
2.4.3 Représentation des nombres binaires signés
Pour représenter des nombres entiers positifs et négatifs, on utilise la
représentation en complément à deux.
Pour un nombre entier positif, c’est sa représentation en base 2.
Pour un nombre entier négatif, on obtient sa représentation en 3 étapes :
étape 1 : calculer la représentation binaire de sa valeur absolue
étape 2 : complémenter tous les bits (0→1, 1→0)
étape 3 : ajouter 1 (additionner 1 au nombre obtenu)

IUT Informatique
Calais
-100 sur 8 bits ?
étape 1 : 01100100
étape 2 : 10011011
étape 3 : 10011100
Avec n bits on représentent les nombres entiers de -2n-1 à 2n-1-1.
La soustraction s’obtient en additionnant les représentations C2.
La représentation C2 n ’a de sens que si on précise qu’on l ’utilise pour ce
nombre, sinon -23 en C2 vaut 233 en binaire (233=256-23).
étape 1 : 00010111
étape 2 : 11101000
étape 3 : 11101001
Exemples : -23 sur 8 bits ?

IUT Informatique
Calais
Lorsque des opérations sont effectuées sur des nombres codés en
complément à 2, ceux-ci doivent impérativement être codés sur le même
nombre de bits.
0100
110
1010
4
-2
-6
0100
1110
10010
On ne tient pas compte de la retenue finale
Comment détecter un débordement ?
• si les nombres sont de signes différents, pas de problème
• si ils sont de même signe, le signe du résultat doit être le même, sinon il y
a débordement
0
4
6
10

IUT Informatique
Calais
2.4.4 Binaire Codé Décimal (BCD)
BCD permet de coder des nombres entiers positifs.
En BCD, on code chaque chiffre du nombre décimal sur 4 bits et on concatène
ces demi-octets.
Exemple : 4236 devient 0100 0010 0011 0110 en BCD
Avec 4n bits (ou m octets) on code les entiers de 0 à 10n-1 (ou 102m-1)
2.4.5 Représentation des nombres réels
En décimal on écrit par exemple :
52,467 = 5.101 + 2.100 + 4.10-1 + 6.10-2 + 7.10-3
De manière générale, dans la base b, on écrit :
an an-1…a0 , a-1 a-2 … a-p = anbn + an-1bn-1 + … + a0b0 + a-1b-1 + a-2b-2 + … + a-pb-
p

IUT Informatique
Calais
Par exemple en binaire :
10100101,011 = 1.27+1.25+1.22+1.20+1.2-2+1.2-3 = 165+1/4+1/8 = 165,375
Passage de la base 10 vers une base quelconque :
• pour la partie entière, on procède par divisions comme pour un entier
• la partie fractionnaire est multipliée par la base de manière successive en
conservant la partie entière et ce jusqu’à ce qu’elle devienne nulle ou que la
précision maximale soit atteinte.
Exemple 1 : 28,125
28  11100
0,125 * 2 = 0,25 0,25 * 2 = 0,5 0,5 * 2 = 1,0
0,125  0,001
28 2
0 14 2
0 7 2
1 3 2
1 1

IUT Informatique
Calais
Exemple 2 : 0,3
0,3 * 2 = 0,6 0,6 * 2 = 1,2 0,2 * 2 = 0,4 0,4 * 2 = 0,8 0,8 * 2 = 1,6
0,6 * 2 = 1,2 0,2 * 2 = 0,4 …
0,3  0,010011001100110011001100110011001…
Codage informatique des nombres réels selon la norme IEEE 754 :
Les nombres réels sont normalisés sous la forme 1,… * 2n puis codés sur
32bits.
• le 1er bit code le signe (0 pour + et 1 pour -)
• les 8 bits suivants codent l’exposant auquel on ajoute 127 (permet de coder
des exposants négatifs sans C2)
• les 23 derniers bits codent la partie fractionnaire du nombre (après la virgule)
mais si le 24ième bit est 1 alors on arrondit à la valeur supérieure (mantisse + 1)
seeeeeeeemmmmmmmmmmmmmmmmmmmmmmm

IUT Informatique
Calais
Exemple :
5,3  101,010011001100110011001100110011001…
• normalisation : 1,01010011001100110011001100110011001… * 22
• signe : 0
• exposant : 2 + 127 = 129 soit sur 8 bits 1000 0001
• mantisse sur 23 bits : 01010011001100110011001 mais le 24ième bit est 1
donc la mantisse est 01010011001100110011010
• codage final : 0100 0000 1010 1001 1001 1001 1001 1010
• de manière plus lisible en hexadécimal : 40 A9 99 9A
Remarques :
• l’exposant 0000 0000 signifie que le nombre est dénormalisé
• l’exposant 1111 1111 signifie que ce n’est pas un nombre (NaN)
• les exposant sont donc compris entre –126 et 127.

IUT Informatique
Calais
2.4.6 Unités de stockage
• unité de base : le bit (0 ou 1)
• unité usuelle : l'octet (1 octet = 8 bits)
• kilooctet : 1 ko = 1024 octets
• mégaoctet : 1 Mo = 1024 Ko
• gigaoctet : 1 Go = 1024 Mo
• téraoctet : 1 To = 1024 Go

IUT Informatique
Calais
3 Logique combinatoire
3.1 Introduction
Objet : étude des fonctions logiques du type x=f(a,b,c,…).
Note : le temps n’intervient pas dans l’équation.
La logique combinatoire permet la réalisation des fonctions de base d’un
ordinateur.
Définition 3 : entrée
Valeur logique fournie au circuit et à partir de laquelle est
déterminée la sortie du circuit.
Définition 4 : entrée de donnée
Entrée ayant un rôle de valeur à traiter par le circuit.

IUT Informatique
Calais
Définition 5 : entrée de contrôle
Entrée ayant un rôle de modification / spécification du
traitement réalisé par le circuit.
Définition 6 : sortie
Valeur logique résultat de l’activité du circuits sur ses entrées.
Remarque : similitude conception d’un programme / circuit logique
Étant donnés des entrées et les résultats qui doivent être
obtenus, on conçoit un programme ou un circuit logique passant des
unes aux autres.

IUT Informatique
Calais
3.2 Exemples de circuits combinatoire
3.2.1 Additionneur
Réalise l’addition de deux nombres entiers sur n bits.
Le résultat est fourni sur n+1 bits, le bit supplémentaire étant un bit de
retenue.
+
A
B
C=A+B

IUT Informatique
Calais
3.2.2 Multiplexeur et démultiplexeur
• Le multiplexeur transmet plusieurs signaux en
entrée sur un seul fil en sélectionnant une des
entrées à transmettre en sortie.
• Une entrée de contrôle réalise la sélection.
• 2n entrées de donnée n entrées de contrôle
• Les n bits de contrôle ( 0 à 2n-1 ) = numéro de
l’entrée à sélectionner
0
0
0
1
1
1
s
e0
e3
e2
e1
c1
c0
1 = e1

IUT Informatique
Calais
Démultiplexeur = rôle inverse du multiplexeur : choisir la sortie vers laquelle
transmettre l’entrée
s0
s3
s2
s1
e
c1 c0
1
0
= e

IUT Informatique
Calais
3.2.3 Décodeur et encodeur
• Décodeur : n entrées et 2n sorties
• Les n bits en entrée codent une valeur de 0 à 2n-1
• La sortie ayant ce numéro passe à 1 (les autres 0)
• Le décodeur est un élément essentiel dans la
réalisation de la mémoire.
s0
s3
s2
s1
e0
e1
e2
s4
s7
s6
s5
1
1
0
= 0
= 0
= 0
= 0
= 0
= 1
= 0
= 0

IUT Informatique
Calais
Encodeur : rôle inverse du décodeur
• 2n entrées et n sorties
• Une seule entrée est à 1
• Les n bits en sortie codent le numéro de
l’entrée qui est à 1
s0
e3
s2
s1
e0
e1
e2
e4
e7
e6
e5
1
0
0
0
0
0
0
0
= 0
= 1
= 1

IUT Informatique
Calais
À partir des spécification du circuit à réaliser :
1 identifier les entrées et les sorties du circuit en distinguant les entrées de
donnée des entrées de contrôle
2 donner la table de vérité de chacune des sorties en fonction des entrées
3 pour chacune des sorties, en fonction de la table de vérité, obtenir une
équation logique simplifiée au moyen d’un tableau de Karnaugh
4 dessiner le schéma logique du circuit
3.3 Méthodologie de réalisation d’un circuit combinatoire

IUT Informatique
Calais
ab 0 1
0 0 1
1 1 0
Entrées dans le même ordre
que dans la table de vérité
3.3.1 Tableau de Karnaugh
• permet de trouver l’équation logique d’une sortie d’un circuit en regroupant les
cases contenant la valeur 1
• obtenu à partir de la table de vérité
Exemples :
• 2 entrées : tableau de Karnaugh de s
a b s
0 0 0
0 1 1
1 0 1
1 1 0

IUT Informatique
Calais
a1a0b1b0 00 01 11 10
00 0 1 1 0
01 1 0 0 1
11 1 0 0 1
10 0 1 1 0
Entêtes de ligne et de colonnes
codées dans l’ordre croissant du
codage de Gray
• 4 entrées a1a0b1b0 (en fait 2 nombres A et B) : tableau de Karnaugh de s
a1 a0 b1 b0 s
0 0 0 0 0
0 0 0 1 1
0 0 1 0 0
0 0 1 1 1
0 1 0 0 1
0 1 0 1 0
0 1 1 0 1
0 1 1 1 0
1 0 0 0 0
1 0 0 1 1
1 0 1 0 0
1 0 1 1 1
1 1 0 0 1
1 1 0 1 0
1 1 1 0 1
1 1 1 1 0
Entrées
toujours
codées dans
l’ordre
croissant du
codage
binaire
(ici de
0000 à
1111)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

IUT Informatique
Calais
• Nombres croissants sur 3 bits selon ….
le codage binaire classique : on ajoute 1 à chaque fois
000 001 010 011 100 101 110 111
001:OK 000:NON
011:OK
010:OK 011:NON
000:NON
110:OK
111:OK 110:NON
101:OK
100:OK
le codage de Gray :
1) 2 nombres consécutifs ont un seul bit qui les différencie
2) Trouver le nombre suivant consiste à inverser le bit le plus à droite possible
(vérifier que le codage obtenu n’a pas déjà été utilisé par un nombre précédent)
000 001 011 010 110 111 101 100
• Remarque :
• Le premier et le dernier nombre ont également un seul bit qui les
différencie

IUT Informatique
Calais
• Pourquoi le codage de Gray pour les tableaux de Karnaugh ?
Le codage des entrées de 2 cases voisines ont un seul bit qui les différencie, dans
ce cas l’équation leur correspondant se simplifie
Important : La première et la dernière case de chaque ligne et de chaque colonne
sont également considérée comme voisine (un seul bit différencie leur codage)
• exemples
a1a0b1b0 00 01 11 10
00 0 0 0 0
01 0 0 0 1
11 0 0 0 1
10 0 0 0 0
0
1
0
1
1
0
1
0
0
1
0
1
0
1
0
1 )
( b
b
a
a
a
b
b
a
b
b
a
a
b
b
a
a
s 




a1a0b1b0 00 01 11 10
00 0 0 0 0
01 0 0 0 0
11 1 0 0 1
10 0 0 0 0
0
0
1 b
a
a
s 

IUT Informatique
Calais
• Plus le regroupement de cases voisines est grand, plus l’équation résultante est
simple
• Exemples de groupements de 4 cases voisines :
a1a0b1b0 00 01 11 10
00 0 1 0 0
01 0 1 0 0
11 0 1 0 0
10 0 1 0 0
0
1b
b
s 
a1a0b1b0 00 01 11 10
00 1 1 0 0
01 0 0 0 0
11 0 0 0 0
10 1 1 0 0
a1a0b1b0 00 01 11 10
00 0 0 0 0
01 0 1 1 0
11 0 1 1 0
10 0 0 0 0
a1a0b1b0 00 01 11 10
00 1 0 0 1
01 0 0 0 0
11 0 0 0 0
10 1 0 0 1
0
0b
a
s 
1
0b
a
s  0
0b
a
s 

IUT Informatique
Calais
• Exemples de groupements de 8 cases voisines :
a1a0b1b0 00 01 11 10
00 1 0 0 1
01 1 0 0 1
11 1 0 0 1
10 1 0 0 1
a1a0b1b0 00 01 11 10
00 0 0 0 0
01 1 1 1 1
11 1 1 1 1
10 0 0 0 0
0
a
s  0
b
s 
• Les groupements ne se font que par 2n cases (2, 4, 8, 16, …)
• Un groupement de 2n cases est valide ssi chaque case du groupement a n voisins
dans ce groupement
• Exemples de groupements non valides :
a1a0b1b0 00 01 11 10
00 0 0 0 0
01 0 1 1 0
11 0 1 0 0
10 0 1 0 0
a1a0b1b0 00 01 11 10
00 0 0 0 1
01 1 1 1 0
11 1 1 1 0
10 0 0 0 0
22 cases dont 2 n’ont
qu’1 voisin
6 cases (pas une
puissance de 2)
a1a0b1b0 00 01 11 10
00 0 1 1 0
01 1 1 1 0
11 1 1 1 0
10 0 0 0 0
23 cases dont 5 n’ont que
2 voisins et une en a 4

IUT Informatique
Calais
• Les cases contenant 1 peuvent être utilisées plusieurs fois par des groupements
différents pour reconstituer l’équation de la sortie
• Il y a généralement de nombreuses solutions possibles, mais chercher les plus
grands groupements permet de trouver les plus simples
• Exemples complets :
a1a0b1b0 00 01 11 10
00 0 0 0 0
01 1 0 1 1
11 1 1 1 1
10 0 0 0 0
a1a0b1b0 00 01 11 10
00 0 0 0 1
01 0 1 1 0
11 1 1 1 0
10 0 0 0 0
0
1
0
1
0
0
1
0
1 b
b
a
a
b
a
b
a
a
s 


)
( 0
1
1
0
0
0
1
0
0
1 b
b
a
a
b
a
b
a
a
a
s 






IUT Informatique
Calais
a1a0b1b0 00 01 11 10
00 0 0 1 1
01 0 0 1 1
11 1 1 0 0
10 0 0 1 1
a1a0b1b0 00 01 11 10
00 0 0 1 1
01 0 0 1 1
11 1 1 0 0
10 0 0 1 1
• Dans les exercices, toujours entourer les groupements utilisés dans le tableau de
Karnaugh et indiquer leur correspondance avec un des termes de l’équation (par
une couleur ou un numéro)
• De même, toujours tenter de simplifier l’équation finale
• groupement OU EXCLUSIF :
• alors que le OU correspond à l’union de plusieurs groupements, le OU
EXCLUSIF correspond à l’union moins l’intersection de 2 groupements
• exemples :
1
0
1
0
1
1
1
0
1
0
1
1
1
0
1
1
0
1
1
1
0
1
)
(
b
a
a
a
a
b
b
a
a
a
a
b
b
a
a
b
a
b
a
b
a
a
s











IUT Informatique
Calais
a1a0b1b0 00 01 11 10
00 0 1 0 0
01 0 1 0 0
11 1 0 1 1
10 0 1 0 0
a1a0b1b0 00 01 11 10
00 0 0 0 1
01 0 0 0 0
11 0 0 0 0
10 1 1 1 0
a1a0b1b0 00 01 11 10
00 0 0 1 0
01 0 0 0 1
11 0 0 0 1
10 0 0 1 0
a1a0b1b0 00 01 11 10
00 1 0 1 0
01 0 0 0 0
11 0 0 0 0
10 1 0 0 1
0
1
0
1 b
b
a
a
s 
 0
1
1
0 b
b
b
a
s 

0
1
0
1
0 a
a
b
b
a
s 
 1
0
1
0
0 b
a
a
b
a
s 


IUT Informatique
Calais
3.4 Étude de quelques circuits combinatoires
3.4.1 Semi-additionneur » 1 bit
Table de vérité de la sortie s :
problème 1+1=10 donc 2 bits nécessaires
Deuxième sortie pour la retenue r :
a b s
0 0 0
0 1 1
1 0 1
1 1 0
b
a
s
a b r
0 0 0
0 1 0
1 0 0
1 1 1
ab
r
b
a
s 

 ,
:
simples
équations
r

IUT Informatique
Calais
3.4.2 Additionneur sur 2 bits
en entrée : 2 nombres sur deux bits a1a0 et b1b0
en sortie : s1s0 et la retenue r
a1 a0 b1 b0 r s1 s0
0 0 0 0 0 0 0
0 0 0 1 0 0 1
0 0 1 0 0 1 0
0 0 1 1 0 1 1
0 1 0 0 0 0 1
0 1 0 1 0 1 0
0 1 1 0 0 1 1
0 1 1 1 1 0 0
1 0 0 0 0 1 0
1 0 0 1 0 1 1
1 0 1 0 1 0 0
1 0 1 1 1 0 1
1 1 0 0 0 1 1
1 1 0 1 1 0 0
1 1 1 0 1 0 1
1 1 1 1 1 1 0
Remarques :
• entrées à gauche
• sorties à droite
• bits dans l'ordre
pour lire les nombres

IUT Informatique
Calais
Tableau de Karnaugh de s0 :
a1 a0 b1 b0 r s1 s0
0 0 0 0 0 0 0
0 0 0 1 0 0 1
0 0 1 0 0 1 0
0 0 1 1 0 1 1
0 1 0 0 0 0 1
0 1 0 1 0 1 0
0 1 1 0 0 1 1
0 1 1 1 1 0 0
1 0 0 0 0 1 0
1 0 0 1 0 1 1
1 0 1 0 1 0 0
1 0 1 1 1 0 1
1 1 0 0 0 1 1
1 1 0 1 1 0 0
1 1 1 0 1 0 1
1 1 1 1 1 1 0
a1a0b1b0 00 01 11 10
00 0 1 1 0
01 1 0 0 1
11 1 0 0 1
10 0 1 1 0

IUT Informatique
Calais
a1 a0 b1 b0 r s1 s0
0 0 0 0 0 0 0
0 0 0 1 0 0 1
0 0 1 0 0 1 0
0 0 1 1 0 1 1
0 1 0 0 0 0 1
0 1 0 1 0 1 0
0 1 1 0 0 1 1
0 1 1 1 1 0 0
1 0 0 0 0 1 0
1 0 0 1 0 1 1
1 0 1 0 1 0 0
1 0 1 1 1 0 1
1 1 0 0 0 1 1
1 1 0 1 1 0 0
1 1 1 0 1 0 1
1 1 1 1 1 1 0
a1a0b1b0 00 01 11 10
00 0 1 1 0
01 1 0 0 1
11 1 0 0 1
10 0 1 1 0
0
0
0 a
b
s 

IUT Informatique
Calais
0
0
0
0
0 b
a
a
b
s 

a1 a0 b1 b0 r s1 s0
0 0 0 0 0 0 0
0 0 0 1 0 0 1
0 0 1 0 0 1 0
0 0 1 1 0 1 1
0 1 0 0 0 0 1
0 1 0 1 0 1 0
0 1 1 0 0 1 1
0 1 1 1 1 0 0
1 0 0 0 0 1 0
1 0 0 1 0 1 1
1 0 1 0 1 0 0
1 0 1 1 1 0 1
1 1 0 0 0 1 1
1 1 0 1 1 0 0
1 1 1 0 1 0 1
1 1 1 1 1 1 0
a1a0b1b0 00 01 11 10
00 0 1 1 0
01 1 0 0 1
11 1 0 0 1
10 0 1 1 0
0
0
0 b
a
s 


IUT Informatique
Calais
a1 a0 b1 b0 r s1 s0
0 0 0 0 0 0 0
0 0 0 1 0 0 1
0 0 1 0 0 1 0
0 0 1 1 0 1 1
0 1 0 0 0 0 1
0 1 0 1 0 1 0
0 1 1 0 0 1 1
0 1 1 1 1 0 0
1 0 0 0 0 1 0
1 0 0 1 0 1 1
1 0 1 0 1 0 0
1 0 1 1 1 0 1
1 1 0 0 0 1 1
1 1 0 1 1 0 0
1 1 1 0 1 0 1
1 1 1 1 1 1 0
a1a0b1b0 00 01 11 10
00 0 0 1 1
01 0 1 0 1
11 1 0 1 0
10 1 1 0 0
1
0
1
1 .
. b
a
a
s  1
0
1 .
. b
a
a
 0
1
1 .
. b
b
a
 0
1
1 .
. b
b
a
 0
1
0
1 .
.
. b
b
a
a
 0
1
0
1 .
.
. b
b
a
a


IUT Informatique
Calais
a1a0b1b0 00 01 11 10
00 0 0 1 1
01 0 1 0 1
11 1 0 1 0
10 1 1 0 0
1
0
1
1 .
. b
a
a
s  1
0
1 .
. b
a
a
 0
1
1 .
. b
b
a
 0
1
1 .
. b
b
a
 0
1
0
1 .
.
. b
b
a
a
 0
1
0
1 .
.
. b
b
a
a

)
(
)
(
)
( 1
1
0
0
1
1
0
1
1
0
1 b
a
b
a
b
a
b
b
a
a
s 





)
(
)
.( 1
1
0
0
1
1
0
0
1 b
a
b
a
b
a
b
a
s 



)
( 1
1
0
0
1 b
a
b
a
s 


)
.
.
( 1
1
1
1
0
1 b
a
b
a
a
s 
 )
.
.
( 1
1
1
1
0 b
a
b
a
b 
 )
.
.
( 1
1
1
1
0
0 b
a
b
a
b
a 

)
(
)
).(
( 1
1
0
0
1
1
0
0
1 b
a
b
a
b
a
b
a
s 





IUT Informatique
Calais
Tableau de Karnaugh de r :
a1a0b1b0 00 01 11 10
00 0 0 0 0
01 0 0 1 0
11 0 1 1 1
10 0 0 1 1
a1 a0 b1 b0 r s1 s0
0 0 0 0 0 0 0
0 0 0 1 0 0 1
0 0 1 0 0 1 0
0 0 1 1 0 1 1
0 1 0 0 0 0 1
0 1 0 1 0 1 0
0 1 1 0 0 1 1
0 1 1 1 1 0 0
1 0 0 0 0 1 0
1 0 0 1 0 1 1
1 0 1 0 1 0 0
1 0 1 1 1 0 1
1 1 0 0 0 1 1
1 1 0 1 1 0 0
1 1 1 0 1 0 1
1 1 1 1 1 1 0
1
1.a
b
r  0
0
1 .
. a
b
b
 0
0
1 .
. b
a
a

)
(
.
. 1
1
0
0
1
1 a
b
b
a
a
b
r 



IUT Informatique
Calais
• même raisonnement que précédemment : laborieux
• idée : combinaison de plusieurs circuits travaillant sur 1 bit
• avantages : plus facile à réaliser, travail avec une taille de n bits (n quelconque),
conception plus claire, meilleur méthodologie, schéma logique plus clair,
réalisation matérielle du circuit plus simple.
• Circuit primitif : additionneur 1 bit complet
• prise en compte de la retenue précédente :
3.4.3 additionneur complet sur des données de taille quelconque
0 1 1 1 1 1 0
0010 1011
+ 1011 0110
1110 0001

IUT Informatique
Calais
Table de vérité :
a b c r s
0 0 0 0 0
0 0 1 0 1
0 1 0 0 1
0 1 1 1 0
1 0 0 0 1
1 0 1 1 0
1 1 0 1 0
1 1 1 1 1
Tableau de Karnaugh pour r :
abc 00 01 11 10
0 0 0 1 0
1 0 1 1 1
ab
bc
ac
r 


Tableau de Karnaugh pour s :
abc 00 01 11 10
0 0 1 0 1
1 1 0 1 0
c
b
a
s 



IUT Informatique
Calais
ab
bc
ac
r 


c
b
a
s 


b
a
s
r
c
Schéma logique :

IUT Informatique
Calais
Schéma logique d'un additionneur 4 bits constitué d'additionneurs complets :
r
S
0
A B

IUT Informatique
Calais
3.4.4 Unité logique
• deux entrées A et B sur n bits et une sortie S résultat d’une opération logique
• le choix de l’opération est fixé par c1c0 :
• les valeurs de A et B ne sont pas exprimées dans le tableau car elles n’ont
pas d’intérêt ici
• utilisation de n circuits sur 1 bit pour réaliser le circuits sur n bits
c1 c0 s
0 0
0 1
1 0
1 1 A
B
A
B
A
B
A.

IUT Informatique
Calais
Circuit logique sur 1 bit :
table de vérité : (la même mais sur des données 1 bit)
On peut faire le schéma directement à partir de l’équation mais ...
c1 c0 s
0 0
0 1
1 0
1 1 a
b
a 
b
a 
b
a.
a
c
c
b
a
c
c
b
a
c
c
b
a
c
c
s 0
1
0
1
0
1
0
1 )
(
.
.
.
.
)
(
. 






IUT Informatique
Calais
… il vaut mieux utiliser un multiplexeur :
s
c1
c0
a
b

IUT Informatique
Calais
Schéma logique d’une UL sur 4 bits en combinant 4 UL 1 bit :
S
A B
c1
c0

IUT Informatique
Calais
3.4.5 Décaleur
Remarque :
• un décalage à gauche d’un nombre entier positif représenté en binaire
correspond à une multiplication par deux
• un décalage à droite d’un nombre entier positif représenté en binaire correspond
à une division par deux
Pour un décaleur sur n bits, le iième bit du résultat est soit le bit i-1 soit le bit
i+1 de l’entrée.
décalage à gauche : entrée : 0110 0110
sortie : 1100 1100 si = ei-1
décalage à droite : entrée : 0110 0110
sortie : 0011 0011 si = ei+1
bit 7 bit 0

IUT Informatique
Calais
Le circuit primitif a donc deux entrées e1 et e0 qui sont respectivement les bits
i+1 et i-1 de l’entrée E pour le circuit logique sur n bits.
Il a également une entrée de contrôle indiquant un décalage à droite (c=0) ou à
gauche (c=1).
0
1 ce
e
c
s 

c s
0 e1
1 e0
s
c
e1
e0

IUT Informatique
Calais
Schéma logique du circuit de décalage sur 4 bits :
0
0
c
S
A

IUT Informatique
Calais
• on suppose que le nombre BCD est composé de deux chiffres codés sur 2x4 bits
• pour convertir ce nombre en binaire, il suffit de multiplier le chiffre des dizaines
d par 10 et ajouter le chiffre des unités u : s = 10d + u
• on sait faire l’addition mais on ne sait pas multiplier par 10 …
• … mais décaler une donnée binaire d’une position vers la gauche correspond à
une multiplication par deux …
• donc on décompose 10d en 8d + 2d ( x8 = 3 décalages à gauche )
3.4.6 Conversion BCD en binaire

IUT Informatique
Calais
Schéma logique d’un convertisseur BCD en binaire :
S
+
+
E
0
0
0

IUT Informatique
Calais
3.4.7 Test de validité d’un code BCD
• en entrée une donnée sur 4 bits qui est censée représenter un chiffre en BCD et
en sortie 1 si c’est le cas, 0 sinon ( si les 4 bits ont une valeur > 9 )
• soit b3b2b1b0 les 4 bis en entrée et s la sortie
1
2
3 .b
b
b
s 

b3 b2 b1 b0 s
0 0 0 0 1
0 0 0 1 1
0 0 1 0 1
0 0 1 1 1
0 1 0 0 1
0 1 0 1 1
0 1 1 0 1
0 1 1 1 1
1 0 0 0 1
1 0 0 1 1
1 0 1 x 0
1 1 x x 0
s
b2
b1
b3
b3 b2 b1 b0 s
0 x x x 1
1 0 0 x 1

IUT Informatique
Calais
3.4.8 Comparateur : A = B
• un comparateur sur n bits avec n comparateurs sur 1 bit
• comparateur sur 1 bit : OU-EXCLUSIF ( 1 si les deux entrées sont différentes )
• on compare tous les bits 1 à 1 puis on fait un OU sur les résultats :
s
A B

IUT Informatique
Calais
3.4.9 Comparateur : A < B (nombres signés)
• A et B sont codés en complément à 2
• si A et B sont de signes différents, le nombre positif est le plus grand
• si A et B sont de même signe, on utilise le comparateur de nombres positifs
Pourquoi la comparaison fonctionne pour deux nombres négatifs ?
• codage C2 sur 4 bits :
0 1 2 … 7 8 9 … 15
0000 0001 0010 … 0111 1000 1001 … 1111
0 1 2 … 7 -8 -7 … -1

IUT Informatique
Calais
4 Logique séquentielle
4.1 Introduction
4.1.1 Objet
Étude des fonctions logiques du type x(t)=f(entrées,t-1).
Note : le temps intervient dans l’équation.
Grâce à la logique séquentielle, on peut réaliser un circuit de mémorisation
et concevoir complètement un processeur.
Du point de vue du programmeur :
• logique combinatoire = opération arithmétiques et logiques simple
(addition, soustraction, et, ou, décalage, rotation, comparaison)
• logique séquentielle = fonctionnalités nécessitant de mémoriser des données
(affectation, structures de contrôle, séquencement des instructions)

IUT Informatique
Calais
4.1.2 Quelques définitions
Définition 7 : Un état d’un circuit est une configuration des sorties de
ce circuit.
Les n états d’un circuit sont numérotés de 0 à n-1.
• Exemple : une bascule (définie plus loin) possède deux états ; un
circuit composé de 2 bascules à 4 états différents ; un circuit composé
de m bascules a 2m états différents.
Définition 8 : Une transition est un changement d’état.
Définition 9 : Le graphe de transitions d’un circuit est un graphe dont
les nœuds sont les états possible du circuit, les arcs les transitions
possibles.

IUT Informatique
Calais
4.1.3 L’oscillateur (ou horloge)
L'oscillateur est l'élément permettant l'introduction de la notion de temps
dans les circuits.
Il est symbolisé par :
Un oscillateur permet d’obtenir un signal carré ayant une fréquence bien
précise, constante au cours du temps et qui peut être élevée (plusieurs
centaines de Mhz).
L’oscillateur le plus simple est une simple porte inverseur bouclant sur
elle-même :

IUT Informatique
Calais
La fréquence d’oscillation est fixée par le délai de propagation dans la
porte.
Dans un ordinateur, l’oscillateur rythmant ses activités est constitué d’un
quartz.
Le quartz vibre naturellement, avec une grande précision et une grande
constance au cours du temps, quand on lui applique un courant oscillant.
Le quartz vibre à sa fréquence propre qui dépend de sa taille et de la façon
dont il a été taillé.
À partir d’un quartz, on obtient des fréquences sous-multiples à l’aide de
diviseurs de fréquence réalisés à l’aide de compteurs (voir TDs).

IUT Informatique
Calais
4.2 Les bascules
La bascule est l’élément fondamental de la logique séquentielle.
Elle possède 2 états (0 ou 1).
On peut lire l’état d’une bascule et on peut l’écrire (affecter l’état voulu).
Typiquement, une bascule aura deux entrées et une sortie :
• une entrée de contrôle indiquant si l’on veut lire ou écrire l’état interne
de la bascule ;
• une entrée de donnée utilisée dans le cas d’une écriture spécifiant la
valeur à écrire dans la bascule ;
• une sortie sur laquelle l’état courant de la bascule peut être lu.

IUT Informatique
Calais
Bascule D :
L’entrée de contrôle v indique si l’on veut lire ou écrire une valeur.
Si un front apparaît sur v, la donnée présente sur e est écrite sur s, sinon la
sortie n’est pas modifiée.
v
e
s
s

IUT Informatique
Calais
Détection d’un front montant sur v :
Le front est détecté grâce au délai de propagation dans la porte NON.
v
a
b
s
1
1
Front descendant ? ET NI
a
b s
v

IUT Informatique
Calais
0 1
v
e
s
s
v
e
s
1 0
0
1
1
0
1
0
1
1
1
0
0
0
1

IUT Informatique
Calais
Schéma d’une bascule D déclenchant sur front montant :
s
s’
e
v
Schéma d’une bascule D déclenchant sur front descendant :
s
s’
e
v

IUT Informatique
Calais
4.3 La fonction mémoire
Une bascule est un élément de mémorisation de 1 bit (ou point-mémoire).
L’entrée de contrôle joue le rôle de signal de lecture/écriture (noté r/w).
Un ensemble de bascules est utilisé pour réaliser un registre ou une mémoire.
4.3.1 Le registre
C’est un circuit capable de mémoriser 1 mot.
Les registres sont situés dans le processeur et constituent donc une mémoire
locale au processeur.
Lorsqu’on programme en assembleur, on accède directement aux registres
du processeur (certains registres nécessaires au fonctionnement ne sont pas
accessibles au programmeur).
Un registre de m bits est simplement constitué de m bascules.

IUT Informatique
Calais
Un registre 3 bits :
D D D
Bus de données
Signal
d’écriture

IUT Informatique
Calais
Un mot de m bits est mémorisé dans un ensemble de m bascules.
Une mémoire de n mots de m bits est réalisée à l’aide de nm bascules.
Étant donné une adresse, un décodeur sélectionne un mot dans la mémoire,
c’est-à-dire les bascules constituant les bits du mot à accéder.
Un signal d’écriture indique si le contenu du mot-mémoire est modifié
(opération d’écriture en mémoire) ou consulté (opération de lecture).
4.3.2 La mémoire

IUT Informatique
Calais
Mémoire de 4 mots de 3 bits :
Bus de données
D D D
D D D
D D D
D D D
Bus
d’adresses
Signal
d’écriture

IUT Informatique
Calais
Bus de données
D D D
D D D
D D D
D D D
Bus
d’adresses
Signal
d’écriture

IUT Informatique
Calais
La fonction mémoire recouvre la notion de « variable » et d’« affectation »
en programmation.
Une variable simple (de type entier ou caractère) est un mot-mémoire et est
stockée dans un registre ou contenu dans une mémoire.
L’adresse de ce mot correspond au nom donné à la variable dans le
programme.
L’une des tâches du compilateur consiste donc a associer à chaque variable
une adresse en mémoire, ou un registre.
Remarque : point de vue du programmeur

IUT Informatique
Calais
4.4 Compteurs
4.4.1 Objet
Un compteur est un circuit logique qui cycle parmi tous ses états possibles,
toujours de la même manière.
Pour tout état, il n’existe qu’une seule transition qui l’atteint et une seule
qui le quitte. Le graphe de transition est donc un simple cycle.
Les états du circuit sont matérialisés par des bascules, et les transitions sont
ponctuées par les fronts d’une horloge.
Exemple simple : le feu tricolore
• 3 états : vert allumé, orange allumé, rouge allumé ;
• cycle perpétuel entre ces 3 états, toujours dans le même ordre.

IUT Informatique
Calais
Nombre d’états du compteur  nombre de bascules nécessaires.
Pour un circuit à n états (de 0 à n-1), il faut au minimum log2(n-1)
bascules ( x dénote le plus petit entier supérieur ou égal à x).
Remarque : c’est aussi le nombre de bits nécessaires au codage du nombre
n-1 en binaire.
Lorsque le nombre d’états d’un compteur n’est pas une puissance de 2,
certains états du circuit ne seront pas utilisés.
Exemple : compteur à 5 états  nombre de bascules ?
3 (8 états codables donc 3 états inutilisés)
4.4.2 Conception d’un compteur

IUT Informatique
Calais
4.4.2.1 Compteur à 2n états
Réalisons un compteur de 0 à 7 : il y a 8 états donc 3 bascules sont
nécessaires (D0, D1 et D2).
Table de transitions :
0
0
0
0
1
1
1
7
1
1
1
7
0
1
1
6
0
1
1
6
1
0
1
5
1
0
1
5
0
0
1
4
0
0
1
4
1
1
0
3
1
1
0
3
0
1
0
2
0
1
0
2
1
0
0
1
1
0
0
1
0
0
0
0
D0
D1
D2
Etat
D0
D1
D2
Etat
t+1
t

IUT Informatique
Calais
Pour , on a le tableau de Karnaugh :
1
2

t
D
1
1

t
D
1
0

t
D
)
.
( 0
1
2
1
2 D
D
D
Dt



0
1
1
1 D
D
Dt



0
1
0 D
Dt


1
0
1
1
1
0
1
0
0
0
10
11
01
00
D2D1D0
1
0
1
0
1
1
0
1
0
0
10
11
01
00
D2D1D0
1
0
0
1
1
1
0
0
1
0
10
11
01
00
D2D1D0

IUT Informatique
Calais
D’où le schéma du compteur de 0 à 7 :
0
0
0
1
1
1
1
0
0
1
0
1
0
1
1
0
0
1
D2
D1
D0
D0
D1
D2
D2 D1 D0

IUT Informatique
Calais
4.4.2.2 Compteur à un nombre quelconque d’états
Réalisons un compteur de 0 à 9 : il y a 10 états donc 4 bascules sont
nécessaires (D0, D1, D2 et D3).
4 bascules permettent de coder 16 états, donc 6 seront inutilisées.
X
X
X
X
X
1
1
1
1
15
X
X
X
X
X
0
1
1
1
14
X
X
X
X
X
1
0
1
1
13
X
X
X
X
X
0
0
1
1
12
X
X
X
X
X
1
1
0
1
11
X
X
X
X
X
0
1
0
1
10
0
0
0
0
0
1
0
0
1
9
1
0
0
1
9
0
0
0
1
8
0
0
0
1
8
1
1
1
0
7
1
1
1
0
7
0
1
1
0
6
0
1
1
0
6
1
0
1
0
5
1
0
1
0
5
0
0
1
0
4
0
0
1
0
4
1
1
0
0
3
1
1
0
0
3
0
1
0
0
2
0
1
0
0
2
1
0
0
0
1
1
0
0
0
1
0
0
0
0
0
D0
D1
D2
D3
Etat
D0
D1
D2
D3
Etat
t+1
t

IUT Informatique
Calais
0
1
2
3
0
1
3 D
D
D
D
D
Dt



Tableau de Karnaugh de D3
t+1 :
X
X
X
X
X
1
1
1
1
15
X
X
X
X
X
0
1
1
1
14
X
X
X
X
X
1
0
1
1
13
X
X
X
X
X
0
0
1
1
12
X
X
X
X
X
1
1
0
1
11
X
X
X
X
X
0
1
0
1
10
0
0
0
0
0
1
0
0
1
9
1
0
0
1
9
0
0
0
1
8
0
0
0
1
8
1
1
1
0
7
1
1
1
0
7
0
1
1
0
6
0
1
1
0
6
1
0
1
0
5
1
0
1
0
5
0
0
1
0
4
0
0
1
0
4
1
1
0
0
3
1
1
0
0
3
0
1
0
0
2
0
1
0
0
2
1
0
0
0
1
1
0
0
0
1
0
0
0
0
0
D0
D1
D2
D3
Etat
D0
D1
D2
D3
Etat
t+1
t
0
1
0
0
01
X
X
X
X
11
X
X
0
1
10
0
0
0
0
00
10
11
01
00
D3D2D1D0

IUT Informatique
Calais
t+1 :
X
X
X
X
X
1
1
1
1
15
X
X
X
X
X
0
1
1
1
14
X
X
X
X
X
1
0
1
1
13
X
X
X
X
X
0
0
1
1
12
X
X
X
X
X
1
1
0
1
11
X
X
X
X
X
0
1
0
1
10
0
0
0
0
0
1
0
0
1
9
1
0
0
1
9
0
0
0
1
8
0
0
0
1
8
1
1
1
0
7
1
1
1
0
7
0
1
1
0
6
0
1
1
0
6
1
0
1
0
5
1
0
1
0
5
0
0
1
0
4
0
0
1
0
4
1
1
0
0
3
1
1
0
0
3
0
1
0
0
2
0
1
0
0
2
1
0
0
0
1
1
0
0
0
1
0
0
0
0
0
D0
D1
D2
D3
Etat
D0
D1
D2
D3
Etat
t+1
t
1
0
1
1
01
X
X
X
X
11
0
X
0
0
10
0
1
0
0
00
10
11
01
00
D3D2D1D0
)
(
)
(
)
(
0
1
2
1
2
2
0
1
0
1
2
1
2
2
0
1
0
1
2
1
2
D
D
D
D
D
D
D
D
D
D
D
D
D
D
D
D
D
D
t
t
t











IUT Informatique
Calais
t+1:
X
X
X
X
X
1
1
1
1
15
X
X
X
X
X
0
1
1
1
14
X
X
X
X
X
1
0
1
1
13
X
X
X
X
X
0
0
1
1
12
X
X
X
X
X
1
1
0
1
11
X
X
X
X
X
0
1
0
1
10
0
0
0
0
0
1
0
0
1
9
1
0
0
1
9
0
0
0
1
8
0
0
0
1
8
1
1
1
0
7
1
1
1
0
7
0
1
1
0
6
0
1
1
0
6
1
0
1
0
5
1
0
1
0
5
0
0
1
0
4
0
0
1
0
4
1
1
0
0
3
1
1
0
0
3
0
1
0
0
2
0
1
0
0
2
1
0
0
0
1
1
0
0
0
1
0
0
0
0
0
D0
D1
D2
D3
Etat
D0
D1
D2
D3
Etat
t+1
t
1
0
1
0
01
X
X
X
X
11
X
X
0
0
10
1
0
1
0
00
10
11
01
00
D3D2D1D0
)
( 0
1
3
1
1 D
D
D
Dt




IUT Informatique
Calais
t+1:
X
X
X
X
X
1
1
1
1
15
X
X
X
X
X
0
1
1
1
14
X
X
X
X
X
1
0
1
1
13
X
X
X
X
X
0
0
1
1
12
X
X
X
X
X
1
1
0
1
11
X
X
X
X
X
0
1
0
1
10
0
0
0
0
0
1
0
0
1
9
1
0
0
1
9
0
0
0
1
8
0
0
0
1
8
1
1
1
0
7
1
1
1
0
7
0
1
1
0
6
0
1
1
0
6
1
0
1
0
5
1
0
1
0
5
0
0
1
0
4
0
0
1
0
4
1
1
0
0
3
1
1
0
0
3
0
1
0
0
2
0
1
0
0
2
1
0
0
0
1
1
0
0
0
1
0
0
0
0
0
D0
D1
D2
D3
Etat
D0
D1
D2
D3
Etat
t+1
t
1
0
0
1
01
X
X
X
X
11
X
X
0
1
10
1
0
0
1
00
10
11
01
00
D3D2D1D0
0
1
0 D
Dt



IUT Informatique
Calais
Problème : Les 4 équations ne suffisent pas.
Étant donné que tous les états ne sont pas utilisés, il faut bien initialiser le
circuit pour ne pas démarrer dans un état non utilisé.
• Modifier la table de transition pour faire évoluer les états non utilisés vers
l’état 0. C’est-à-dire changer tous les X en 0 dans la table. Il faut alors
refaire les tableaux de Karnaugh et les équations.
A faire en exercice ...
2 solutions :
• Ajouter un signal d’initialisation pour démarrer à l’état 0 :


















.
)
(
))
(
(
)
(
0
1
0
0
1
3
1
1
0
1
2
1
2
0
1
2
3
0
1
3
init
D
D
init
D
D
D
D
init
D
D
D
D
init
D
D
D
D
D
D
t
t
t
t

IUT Informatique
Calais
Schéma d’un compteur de 0 à 9 avec initialisation :
D2
D1
D0
init
D1
D2
D3 D2 D1
D3
D3
D0
D0


















.
)
(
))
(
(
)
(
0
1
0
0
1
3
1
1
0
1
2
1
2
0
1
2
3
0
1
3
init
D
D
init
D
D
D
D
init
D
D
D
D
init
D
D
D
D
D
D
t
t
t
t

IUT Informatique
Calais
4.4.3 Feux tricolores
4.4.3.1 Feux tricolores français
Un feu tricolore est un compteur.
Le graphe de transitions est le suivant :
vert
0
orange
1
rouge
2

IUT Informatique
Calais
Le graphe a 3 états numérotés de 0 à 2.
Le nombre 2 se code 10 en binaire (2 bits) donc il y aura 2 bascules dans
ce circuit.
vert
0
orange
1
rouge
2







0
1
1
0
0
1
1
1
.
.
D
D
D
D
D
D
t
t
La table de transitions s’obtient directement à partir du graphe de
transitions :
D1 D0 D1 D0
0 0 0 1
0 1 1 0
1 0 0 0
1 1 0 0
t t+1

IUT Informatique
Calais
À partir des équations issues de la table de transitions, on dessine le circuit :







0
1
1
0
0
1
1
1
.
.
D
D
D
D
D
D
t
t
D1
D0
D0
D1
D1 D0

IUT Informatique
Calais
Comment allumer les différents feux à partir des valeurs de D0 et de D1 ?
On utilise un décodeur :
s0
s3
s2
s1
e0
e1
e2
s4
s7
s6
s5

IUT Informatique
Calais
4.4.3.2 Feux tricolores scandinaves ou du royaume-uni
Cycle : vert, orange, rouge, orange, vert, ...
Contrairement aux feux type français, un état ne correspond pas à une
couleur allumée.
C’est un compteur à 4 états (0 à 3), donc il faut bascules pour le circuit.
2
Graphe de transition :
vert
0
orange
1
rouge
2
rouge
orange
3

IUT Informatique
Calais








0
1
0
0
1
1
1
D
D
D
D
D
t
t
D1 D0 D1 D0
0 0 0 1
0 1 1 0
1 0 1 1
1 1 0 0
t t+1
vert
0
orange
1
rouge
2
rouge
orange
3

IUT Informatique
Calais








0
1
0
0
1
1
1
D
D
D
D
D
t
t
D1
D0
D0
D1
D1 D0

IUT Informatique
Calais
4.4.4 Point de vue du programmeur
Un compteur peut déclencher des actions les unes après les autres.
Son rôle est donc de déclencher la réalisation d’une séquence
d’instructions d’un programme.
Un compteur est capable de réaliser un cycle d’activités un nombre fixé de
fois.
C’est un circuit capable de contrôler une boucle pour ; l’indice de la boucle
est alors la valeur courante du compteur.

IUT Informatique
Calais
4.5 Automates
4.5.1 Un exemple pour commencer
Un feux tricolore peut avoir 2 types de fonctionnement différents :
• de jour : vert, orange, rouge, vert, ... ;
• de nuit : orange, éteint, orange, éteint, ...
Dans ce cas il y a 2 cycles de fonctionnements différents :
impossible à réaliser avec un compteur.
Automates

IUT Informatique
Calais
4.5.2 Introduction
Un automate est un circuit logique pouvant être dans un certain nombre
d’états.
Plusieurs transitions peuvent entrer ou sortir d’un même état.
Étant dans un certain état, la transition à effectuer est sélectionnée en
fonction de signaux de contrôle.
En fait, du point de vue du graphe de transitions, il est composé de
plusieurs cycles entrelacés.

IUT Informatique
Calais
4.5.3 Méthodologie de conception d’un automate
1. Déterminer les cycles d’actions de l’automate et les numéroter (0 à m).
2. En déduire le nombre de signaux de contrôle (nb. bits pour coder m bin.)
3. Déterminer les états de l’automate.
4. Déterminer le nombre de bascules nécessaires à la réalisation de
l’automate : pour n états c’est le nombre de bits pour coder n-1 en binaire.
5. Tracer le graphe de transitions de l’automate.
6. En déduire la table de transitions.
7. Pour chacune des bascules, déterminer l’équation logique de son entrée
à l’aide d’un tableau de Karnaugh.
8. Faire le schéma logique de l’automate.
Cette méthode n’est pas adaptée dans le cas où le nombre de cycles est
infini.
Dans ce cas, on essaie de concevoir directement le graphe de transitions.

IUT Informatique
Calais
L’objectif d’un automate est de séquencer des actions.
Ces actions peuvent être déclenchées de 2 manières différentes :
1. Soit une action (ou des actions) est associée à un état.
C’est-à-dire que tant que l’automate est dans cet état, l’action est réalisée.
2. Soit une action (ou des actions) est associée à une transition (l’automate
arrive ou quitte un état).
Une transition entraîne un front (montant ou descendant selon que l’on
atteint ou que l’on quitte un état) qui déclenche une action.
Ce mode de fonctionnement est utilisé lorsque l’on veut seulement
déclencher une action, c’est-à-dire émettre une impulsion.

IUT Informatique
Calais
4.5.4 Feux tricolores (suite)
Un feux tricolore peut avoir 2 types de fonctionnement différents :
• de jour : vert, orange, rouge, vert, ... ;
• de nuit : orange, éteint, orange, éteint, ...
2 cycles différents donc 1 bit pour les différencier.
On le note c et on choisit c=0 de jour et c=1 de nuit.
On a 4 états possibles :
• état 0 : vert allumé (le reste éteint) ;
• état 1 : orange allumé (le reste éteint) ;
• état 2 : rouge allumé (le reste éteint) ;
• état 3 : tout éteint.
4 états donc 2 bascules nécessaires.

IUT Informatique
Calais
Initialisation du cycle de jour
Initialisation du cycle de nuit
vert
0
orange
1
rouge
2
éteint
3
c D1 D0 D1 D0
0 0 0 0 1
0 0 1 1 0
0 1 0 0 0
0 1 1 0 0
1 0 0 0 1
1 0 1 1 1
1 1 0 0 1
1 1 1 0 1
t t+1
0
0
0
1
1

IUT Informatique
Calais
c D1 D0 D1 D0
0 0 0 0 1
0 0 1 1 0
0 1 0 0 0
0 1 1 0 0
1 0 0 0 1
1 0 1 1 1
1 1 0 0 1
1 1 1 0 1
t t+1
0
0
1
0
1
0
0
1
0
0
10
11
01
00
cD1D0
1
1
1
1
1
0
0
0
1
0
10
11
01
00
cD1D0








c
D
D
D
D
D
D
t
t
0
1
1
0
0
1
1
1
.
.

IUT Informatique
Calais








c
D
D
D
D
D
D
t
t
0
1
1
0
0
1
1
1
.
.
D1
D0
D0
D1
D1 D0
c

IUT Informatique
Calais
4.5.5 Distributeur de café
On veut réaliser un automate contrôlant un distributeur de café.
On suppose qu’il distribue du café, avec ou sans sucre, avec ou sans lait.
Il y a donc 4 fonctionnement possibles :
1. fournir du café noir ;
2. fournir du café sucré ;
3. fournir du café au lait ;
4. fournir du café au lait sucré.

IUT Informatique
Calais
Les cycles sont numérotés de 0 à 3 (2 bits de codage) :
00 : gobelet, café lyophilisé, eau ;
01 : gobelet, café lyophilisé, sucre, mélangeur, eau ;
10 : gobelet, café lyophilisé, lait lyophilisé, eau ;
11 : gobelet, café lyophilisé, sucre, mélangeur, lait lyophilisé, eau.
On définit les états (certaines actions peuvent être regroupées) :
état 0 : repos (attente d’une commande de boisson)
état 1 : commande de boisson déclenchée
état 2 : donne un gobelet
état 3 : donne du café lyophilisé
état 4 : donne du sucre et un mélangeur
état 5 : donne du lait lyophilisé
état 6 : donne de l’eau
Il y a 7 états (0 à 6) donc 3 bascules seront nécessaires.
Ces 4 cas correspondent à 4 cycles différents du distributeur.

IUT Informatique
Calais
Graphe de transitions :
0
1
2
3
4
5
6
gobelet
café lyophilisé
sucre et mélangeur
lait
eau
0,1,2,3
0
0,1,2,3 0,1,2,3
0,1,2,3
1,3
1
2
2,3
3

IUT Informatique
Calais
0
1
2
3
4
5
6
gobelet
café lyophilisé
sucre et mélangeur
lait
eau
t t+1 t t+1
c1c0 D2D1D0 D2D1D0 c1c0 D2D1D0 D2D1D0
00 000 001 10 000 001
00 001 010 10 001 010
00 010 011 10 010 011
00 011 110 10 011 101
00 100 xxx 10 100 xxx
00 101 xxx 10 101 110
00 110 000 10 110 000
00 111 xxx 10 111 xxx
01 000 001 11 000 001
01 001 010 11 001 010
01 010 011 11 010 011
01 011 100 11 011 100
01 100 110 11 100 101
01 101 xxx 11 101 110
01 110 000 11 110 000
01 111 xxx 11 111 xxx
0,1,2,3
0
0,1,2,3 0,1,2,3
0,1,2,3
1
1
2
2,3
3

IUT Informatique
Calais
c1c0D2D1D0 000 001 011 010 110 111 101 100
00 0 1 1 1 0 x x x
01 0 1 0 1 0 x x 1
11 0 1 0 1 0 x 1 0
10 0 1 0 1 0 x 1 x
c1c0D2D1D0 000 001 011 010 110 111 101 100
00 0 0 1 0 0 x x x
01 0 0 1 0 0 x x 1
11 0 0 1 0 0 x 1 1
10 0 0 1 0 0 x 1 x
t t+1 t t+1
c1c0 D2D1D0 D2D1D0 c1c0 D2D1D0 D2D1D0
00 000 001 10 000 001
00 001 010 10 001 010
00 010 011 10 010 011
00 011 110 10 011 101
00 100 xxx 10 100 xxx
00 101 xxx 10 101 110
00 110 000 10 110 000
00 111 xxx 10 111 xxx
01 000 001 11 000 001
01 001 010 11 001 010
01 010 011 11 010 011
01 011 100 11 011 100
01 100 110 11 100 101
01 101 xxx 11 101 110
01 110 000 11 110 000
01 111 xxx 11 111 xxx
c1c0D2D1D0 000 001 011 010 110 111 101 100
00 1 0 0 1 0 x x x
01 1 0 0 1 0 x x 0
11 1 0 0 1 0 x 0 1
10 1 0 1 1 0 x 0 x

















.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
2
0
1
0
1
1
0
2
1
0
1
2
0
1
1
2
1
0
1
2
0
1
1
1
1
2
0
1
1
2
D
D
c
c
D
D
c
D
D
D
D
D
c
c
D
D
c
D
D
D
D
D
D
D
D
D
D
D
t
t
t

IUT Informatique
Calais

















.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
2
0
1
0
1
1
0
2
1
0
1
2
0
1
1
2
1
0
1
2
0
1
1
1
1
2
0
1
1
2
D
D
c
c
D
D
c
D
D
D
D
D
c
c
D
D
c
D
D
D
D
D
D
D
D
D
D
D
t
t
t
D2
D1
D0
D1
D2
D2 D1
c0
c0
D0
D0
c1
c1

IUT Informatique
Calais
L’automate que l’on vient de réaliser est incomplet, que manque-t-il ?
l'initialisation !
Faut-il initialiser à l'aide d'un signal init ou remplacer les X par des 0 dans
la table de transitions et refaire les équations et le circuit ?
Il est impératif d'utiliser un signal init parce que :
• le signal init permet de toujours démarrer à l'état 0 (état de repos) ;
• remplacer les X par des 0 permet seulement de revenir à l'état 0
lorsqu'on démarre dans un état non géré par l'automate. Mais il
est possible de démarrer dans n'importe quel état valide de l'automate !
Exemple lorsque les X sont remplacées par des 0 dans les tables :
• feux tricolores : le feux peut démarrer au rouge, au vert ou à l'orange,
ça ne pose aucun problème ;
• distributeur de café : il peut démarrer à l'état 3, c'est-à-dire donner du
café etc. ..., alors que l'on vient seulement de brancher le distributeur !

IUT Informatique
Calais

















.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
2
0
1
0
1
1
0
2
1
0
1
2
0
1
1
2
1
0
1
2
0
1
1
1
1
2
0
1
1
2
D
D
c
c
D
D
c
D
D
D
D
D
c
c
D
D
c
D
D
D
D
D
D
D
D
D
D
D
t
t
t
D2
D1
D0
D1
D2
D2 D1
c0
c0
D0
D0
c1
c1
init
init
init
init
( )
( )
( )

IUT Informatique
Calais
L’automate que l’on vient de réaliser contrôle les activités du distributeur.
Mais il est intéressant de regarder l’interfaçage avec :
• le circuit donneur d’ordres ;
• le circuit servant les boissons.
La commande des boissons se fait au travers d’un clavier à 4 touches, une
pour chaque boisson :
• c : café ;
• cs : café sucré ;
• cl : café au lait ;
• cls : café au lait sucré.
La distribution se fera grâce à des organes électro-mécaniques fournissant
les différents éléments nécessaires (gobelet, ...).

IUT Informatique
Calais
encodeur
décodeur
c1
c0
c
cs
cl
cls
D2
D1
D0
gobelet
café
sucre et mélang.
lait
eau
Interfaçage de l’automate du distributeur de café :
Remarques :
• Le clavier n’émet que des impulsions, il faut donc mémoriser c0 et
c1 une fois générés : une impulsion quelconque déclenche le passage à
l’état 1 et en même temps l’écriture de 2 bascules mémorisant c0 et c1.
• Le séquencement des opérations de distribution doit être temporisé,
puis arrêté au retour à l’état de repos (0)
? ?

IUT Informatique
Calais
4.5.6 Registre à décalage
En combinant le circuit à décalage de la section 3.4.5 et un registre, on
obtient un élément couramment rencontré, un registre à décalage.
C’est un registre dans lequel on peut écrire une donnée, la lire, et la décaler
directement dans le registre.
D
c0
c1
w
D D D
0 0
e3 e2 e1 e0

IUT Informatique
Calais
À chaque entrée de donnée des bascules est envoyé un fil du bus de
données et les sorties des 2 bascules l’entourant.
En fonction d’un signal de commande (c1c0), un multiplexeur sélectionne
l’une de ces trois données pour l’écrire dans la bascule :







droite
à
décalage
valeur
nouvelle
gauche
à
décalage
0
1
0
1
0
1
c
c
c
c
c
c
D
c0
c1
w
D D D
0 0
e3 e2 e1 e0

IUT Informatique
Calais
Lorsque l’on doit transmettre une donnée, il est courant d’utiliser un seul
fil et d’envoyer les bits de donnée à la queue-leu-leu : c’est le principe de
la liaison série.
De même on voudrait pouvoir recevoir plusieurs bits les uns après les
autres sur le même fil et reconstituer une donnée de plusieurs bits.
Comment faire ?
On utilise un registre à décalage.
Émission : la donnée est présente dans le registre à décalage et le fil de
transmission est la sortie de la dernière bascule. Il suffit alors, le registre
étant en mode lecture, d’effectuer à chaque impulsion d’horloge un
décalage à droite.
4.5.7 Sérialiseur / désérialiseur de données

IUT Informatique
Calais
Réception ?
registre à décalage
4 bits
registre à décalage
4 bits
0 1 1 0 x x x x
0 0 1 1 0 x x x
0 0 0 1 1 0 x x
0 0 0 0 1 1 0 x
0 0 0 0 0 1 1 0
Comment ne pas perdre la donnée après émission ?
Décalages à gauche
La sortie du registre est également connectée à sa propre entrée
• Associé à un automate dirigeant un compteur et 2 registres, on peut
réaliser un registre à décalage d’un nombre quelconque de positions (utile
pour multiplier ou diviser par 2n)

IUT Informatique
Calais
4.5.8 Multiplicateur
La multiplication de 2 nombres binaires non signés se résume à des
additions et à des décalages :
En base 10 :
1 1
x 1 3
3 3
1 1
1 4 3
En binaire non signé :
1 0 1 1 multiplicande
x 1 1 0 1 multiplicateur
1 0 1 1
0 0 0 0
1 0 1 1
1 0 1 1
1 0 0 0 1 1 1 1 produit

IUT Informatique
Calais
Cette façon de procéder consiste à examiner les bits successifs du
multiplicateur, en commençant par le bit de poids faible.
1 0 1 1
0 0 0 0
1 0 1 1
1 0 1 1
1 0 0 0 1 1 1 1 produit
Si ce bit est à 1, on recopie le multiplicande.
Si ce bit est à 0, on inscrit des 0.

IUT Informatique
Calais
Par rapport à la ligne précédente, les nombres qui sont écrits sont décalés
d’un rang vers la gauche.
1 0 1 1
0 0 0 0
1 0 1 1
1 0 1 1
1 0 0 0 1 1 1 1 produit
Lorsque tous les bits du multiplicateur ont été examinés, on les additionne
pour obtenir le produit.
Les additionneurs binaires ne traitent que 2 nombres à la fois, donc au lieu
d’additionner toutes les lignes en une fois, on les additionne 2 à 2 et on
inscrit les sommes intermédiaires dans un registre : l’accumulateur.
+

IUT Informatique
Calais
1 0 1 1 bit du multiplicateur à 1 ; additionner le multiplicande
à l’accumulateur et décaler le multiplicande à gauche
0 0 0 0 bit du multiplicateur à 0 ;
décaler le multiplicande à gauche
1 0 1 1 0 0 bit du multiplicateur à 1 ; additionner le multiplicande
1 0 1 1 0 0 0 bit du multiplicateur à 1 ; additionner le multiplicande
1 0 0 0 1 1 1 1 produit
00000000
00001011
00001011
00010110
00001011
00101100
00110111
01011000
10001111
10110000
10001111
accumulateur
multiplicande

IUT Informatique
Calais
pour i de 0 à n-1 faire
si MT ^ 1 = 1 alors
RES  RES + MD
fsi
décaler MD d’un bit vers la gauche
décaler MT d’un bit vers la droite
fpour
C’est l’algorithme standard de multiplication tel qu’il est enseigné à l’école
primaire.
L’algorithme utilisé est le suivant (n est la taille des données) :

IUT Informatique
Calais
• un registre à décalage sur n bits pour MT ;
• un registre à décalage sur 2n bits pour MD ;
• un registre 2n bits pour RES ;
• un compteur à n états qui va compter les itérations de la boucle pour ;
• un additionneur 2n bits ;
• un séquenceur qui coordonne les activités de tout ces circuits.
Le multiplicateur se compose des éléments suivants :

IUT Informatique
Calais
initialisation du circuit, c’est-à-dire le compteur et RES ;
• addition de MD à RES ;
• décalage de MT ;
• décalage de MD ;
• arrêter le traitement quand il est fini.
On en déduit les états du séquenceur :
0. inactivité du multiplicateur ;
1. test du bit de poids faible de MT ;
2. décalage de MD et MT ;
3. test du compteur d’itérations.
Le séquenceur doit déclencher les différentes actions à l’intérieur de
la boucle et contrôler la réalisation de la boucle :

IUT Informatique
Calais
0. inactivité du multiplicateur ;
1. test du bit de poids faible de MT ;
2. décalage de MD et MT ;
3. test du compteur d’itérations.
Transition de l’état 0 à l’état 1 : il faut déclencher l’initialisation du circuit.
Transition de l’état 1 à l’état 2 : selon la valeur du bit de poids faible de
MT, il y a addition ou non de MD à RES.
Transition de l’état 2 à l’état 3 : décalage de MT et MD et incrémentation
du compteur.

IUT Informatique
Calais
Signaux reçus :
• INIT : init. du séquenceur
• cpt : valeur courante du décompteur
• f : bit de poids faible de MT
Signaux émis :
• init : init. du décompteur
• reset : RES à 0
• wR : signal d’écriture dans RES
• wT : signal d’écriture dans MT
• wD : signal d’écriture dans MD
• dT : décalage droite MT
• dD : décalage gauche MD
• iC : signal décrémentation décompteur
0
1
2
3
init, reset, wT, wD
f
f
wR
dT, dD, iC
cpt non nul
cpt = 0
INIT

IUT Informatique
Calais
décompteur
de n à 0
init IC
séquenceur
INIT
init dD dT wR IC
reset
wT wD
MT
wT
dT
RES
reset
wR
MD
wD
dD

IUT Informatique
Calais
La conception est très simple :
• si les deux nombres sont négatif :
• on multiplie leurs compléments à deux
• si l’un des deux est négatif :
• on multiplie son complément à deux par l’autre nombre
• on calcul ensuite le complément à deux du résultat pour rétablir le
signe.
Multiplication de nombres signés (en complément à deux) :

IUT Informatique
Calais
Schéma de principe :
1x1
1x1
multiplicateur de
nombres positifs
x/-x

IUT Informatique
Calais
La multiplication, contrairement à l’addition, nécessite de savoir si les
nombres en entrée sont des nombres signés ou pas.
• En assembleur il y a donc deux instructions disponibles pour la
multiplication : l’une signée, l’autre non signée.
• Comme vous l’avez remarqué, la multiplication est une opération bien
plus complexe à réaliser qu’une addition.
• En fait, les premiers microprocesseurs ne disposaient pas d’instruction
de multiplication ; elle devait être programmée en assembleur.
Remarques :

IUT Informatique
Calais
On a vu :
• bascule
• registre
• mémoire
• compteur
• automate
: élément de base de la logique séquentielle
: mémoire la plus interne au processeur
: en fait il y en a de nombreux types (cache, vidéo ...)
: pour la gestion de boucles de programmes
: pour le séquencement des actions
On a réalisé un circuit nécessitant tout ce qui a été vu :
• multiplication
En fait, tout ce qui est nécessaire à la réalisation d’un processeur est
maintenant connu.
4.5.9 Conclusion
Pour terminer le chapitre sur la logique séquentielle :

IUT Informatique
Calais
5 Le processeur
5.1 Introduction
Un microprocesseur est constitué par un assemblage de circuits exécutant
les fonctions de l’unité centrale de traitement d’un micro-ordinateur.
En anglais : CPU = central processing unit.
Définition :
Un microprocesseur est un circuit logique capable, après identification d’une
séquence d’instructions, d’effectuer des traitements de l’information.

IUT Informatique
Calais
Ce que doit savoir faire un ordinateur :
Problème à résoudre Résolu par
acquisition des données périphériques : clavier, souris, CD,
disque, disquette, scanner, caméra ...
mémorisation des données, du
programme à exécuter, des
calculs intermédiaires ...
mémoire centrale et registres,
éventuellement disque
réalisation des calculs UAL = unité arithmétique et logique
échanges de données bus internes et externes, unité E/S
synchronisation des opérations horloge et unité de contrôle
coordination de toutes les
activités (calculs en cours, bon
fonctionnement, transferts avec
les périphériques ...)
microprocesseurs et contrôleurs
dédiés

IUT Informatique
Calais
• unité de contrôle, de commande et de synchronisation ;
• unité arithmétique et logique
• mémoire et registres internes
• unité d’entrées/sorties
• bus internes
UAL
Mémoire interne
et registres
E/S
UC
Un microprocesseur est un circuit contenant les unités suivantes :

IUT Informatique
Calais
5.2 Bus internes
Définition :
Un bus est un ensemble de fils qui transportent (en parallèle ou en série)
une information d’un composant à l’autre.
• Mode parallèle : autant de fils que le mot transporté contient de bits.
• Transporter mot sur un bus de taille inférieure : multiplexage
• 3 types de bus rencontrés :
• bus de données
• bus d’adresse
• bus de contrôle
• Les bus se distinguent par :
• largeur
• vitesse

IUT Informatique
Calais
5.3 UAL
• Circuits nécessaires pour les opérations arithmétiques et logiques
étudiés dans les chapitres précédents
• En fonction de l’opération sélectionnée :
• fournit le résultat
• met à jour un registre d’état pour contrôler si
• résultat = 0
• résultat positif / négatif
• débordement
• retenue
• …

IUT Informatique
Calais
5.4 Mémoire et registres
• Le microprocesseur contient plusieurs registres et mémoire stockant
données et instructions
• La taille des registres est fonction du type de processeur
• Les registres permettent d’accélérer la vitesse de traitement
• Ils peuvent être synchronisés avec l’UAL

IUT Informatique
Calais
5.5 Entrées / sorties
• But : échanger des informations avec l’extérieur (nécessaire au
fonctionnement du CPU)
Unité d’entrées/
sorties (E/S)
Intérieur du processeur Extérieur du processeur
Bus de donnée
Bus d’adresse
Bus de commande
• L’unité d’E/S assure les liaisons entre bus internes et bus externes
• Les bus d’adresse est unidirectionnel

IUT Informatique
Calais
5.6 Unité de commande
• « Chef d’orchestre » qui pilote et synchronise les unités du processeur
• Elle est pilotée par une horloge et permet de cadencer l’exécution des
instructions du programme :
• mise en service des circuits concernés (verrous)
• activation des communications (verrous + cellules de commutation)
Définition :
Un verrou est un circuit à n sorties, n entrées de données et une entrée de
contrôle. L’entrée de contrôle autorise ou interdit le transfert des données
vers les sorties.
• Il existe des verrous unidirectionnels (ei si) et des verrous
bidirectionnels (ei si)

IUT Informatique
Calais
• Exemple : verrou unidirectionnel simple 4 bits
• Exemple : transfert du contenu de 2 registres en parallèle :
Registre 0 Registre 1
Verrou
e0
e1
D
D
D
D
transfert
transfert
R0 R1
Schéma de principe
e3
e2
e1
e0
1
0
0
0
0
0
s3
s2
s1
s0
Transfert
e0
e1
e2
e3
transfert
s0
s1
s2
s3

IUT Informatique
Calais
Définition :
Une cellule de commutation (simple) est un circuit à 2 sorties, 2 entrées de
données et une entrée de contrôle. L’entrée de contrôle modifie l’ordre de
connexion des entrées de données aux sorties.
• Il existe des cellules unidirectionnels (ei si) et des cellules
bidirectionnelles (ei si)
Exemple : cellule de commutation simple 1 bit
e0
e1
s0
s1
c
e1
e0
1
e0
e1
0
s1
s0
c

IUT Informatique
Calais
5.7 Modèle de Von Neumann
En 1945 J. Von Neumann (1903-1957) définit les bases de l’architecture des
calculateurs modernes.
• unification des différentes représentations utilisées grâce au codage en
binaire (algèbre de Boole)
• mémorisation des résultats intermédiaires mais surtout des opérations elles-
mêmes
• représentation des opérations élémentaires à effectuer (désignées par
« instructions »)
• ces instructions sont regroupées en « programmes »
• les programmes sont stockés en mémoire (plusieurs exécutions possibles)
• la rupture de séquence donne un « pouvoir de décision » à la machine en
fonction des résultats intermédiaires sans intervention humaine

IUT Informatique
Calais
5.7.1 Principe général de fonctionnement du microprocesseur
Pour exécuter un programme, le microprocesseur effectue cycliquement :
• lecture d’un code d’instruction en mémoire (fetch)
• reconnaissance de ce code, ou décodage (decode)
• exécution d’un ordre élémentaire (execute)
• positionnement sur le code de l’instruction suivante du programme
En plus de l’accumulateur il faut d’autres registres pour le fonctionnement
du microprocesseur :
• compteur ordinal (pointe sur l’instruction suivante immédiate)
• registre d’instruction
• registre d’état
• registre de sommet de pile (adresse de retour pour les sous-programmes)
• registres à usage plus général (adresse, donnée, buffer, …)

IUT Informatique
Calais
5.7.2 Séquencement des instructions
Une instruction est découpée en plusieurs micro-opérations / micro-
commandes
1. Lire l’instruction
2. Calculer l’adresse de la prochaine instruction, incrémenter le CO
3. Décoder l’opération
4. Calculer les adresses des opérandes si nécessaire
5. Lire les opérandes éventuelles depuis la mémoire
6. Exécuter l’instruction
7. Calculer l’adresse du résultat
8. Ranger le résultat en mémoire

IUT Informatique
Calais
5.7.3 Instruction
Définition :
Une instruction est un ordre élémentaire exécutable par un microprocesseur
donné (en un certain nombre de cycle d’horloge).
Définition :
Ces instructions sont spécifique à un microprocesseur et leur nombre est
limité. Leur ensemble constitue le jeu d’instruction du microprocesseur.
Classification des instructions :
• instructions de transfert
• instructions arithmétiques
• instructions logiques
• instructions de commande
• instructions d’entrée/sortie

IUT Informatique
Calais
Les instructions peuvent affecter ou utiliser le contenu d’un ou plusieurs
mot-mémoire, un ou plusieurs registres, ou aucun d’entre-eux.
Définition :
Un opérande est un élément de la mémoire concerné par l’exécution d’une
instruction donnée.
On distingue 3 principaux types d’instruction :
• sans opérandes
• monadiques (un opérande)
• dyadiques (deux opérandes)
Un code est associé à chaque instruction d’un programme (code-instruction).
En général on a :
code opération opérande 1 opérande 2

IUT Informatique
Calais
Définition :
Un mnémonique est une abréviation permettant de se rappeler du code et de
la fonction d’une instruction. Le langage assembleur est directement basé
sur ces mnémoniques.
Définition :
Un programme est une liste de codes-instructions implantés en mémoire et
permettant de résoudre un problème prédéterminé.

IUT Informatique
Calais
5.8 Réalisation d'une unité de commande
5.8.1 UC micro-programmée
Les différentes phases (chargement, exécution ...) correspondent à des
micro-opérations déclenchées pour exécuter l'instruction.
code-instruction séquence de micro-opérations
déclenche
Idée : mémoire non-volatile (nanomémoire)
code-instruction adresse séquence de micro-opérations
décodage
Avantages :
• changer le micro-programme = changer les possibilités du microprocesseur
• ajout, correction, custom-design facile (pas de modification des circuits)
Inconvénients :
• nécessite un séquenceur de micro-inst. + accès mémoire : ralentissement

IUT Informatique
Calais
5.8.2 UC câblée
L'UC est entièrement réalisée sous forme d'un seul circuit logique
séquentiel.
Avantages :
• + rapide que l'UC micro-programmée
• + simple à réaliser et moins de place sur la puce SI jeu d'instruction pas
trop important
Inconvénients :
• circuit rapidement complexe quand le jeu d'instruction augmente
• ajout, modification, suppression d'une instruction : modification complète
du circuit logique

IUT Informatique
Calais
UC micro-programmée
lente
évolutive
jeu d'instructions important
pas (trop) de problème de réalisation
UC câblée
rapide
non évolutive
jeu d'instruction réduit
sinon réalisation = usine à gaz
micro-processeurs lents
disposant d'un jeu d'instruction complet
contenant éventuellement des
instructions complexes
processeurs CISC
Complex Instruction Set Computer
micro-processeurs (très) rapides
disposant d'un jeu d'instruction réduit
contenant des instructions simples
et peu nombreuses
processeurs RISC
Reduced Instruction Set Computer

IUT Informatique
Calais
• micro-noyau RISC : très compact, très performant, stable dans le temps
• + unité de contrôle micro-programmée utilisant non pas la nanomémoire,
mais le(s) micro-noyau(x)
• cette solution cumule les avantages sans (trop de) perte de vitesse
d'horloge
Les processeurs construits par Intel et AMD utilisent un compromis
décodeur d'instructions
code opération opérande 1 opérande 2
séquenceur cablé, µprogrammé ou hybride
Microcommandes : UAL, verrous, cellules de commutation
Registre
instruction
horloge
externe
• schéma de principe d'une UC simple :

IUT Informatique
Calais
5.8.3 Rôle de l'UC / échanges sur un bus
• Communication sur un bus : 1 seul émetteur et 1 seul récepteur connectés
Les autres composants ne doivent pas accéder au bus.
• l'UC bloque l'accès au bus aux composants non concernés à l'aide de
verrous ... mais composants internes ET externes
• l'UC agit sur des verrous externes au travers de l'unité E/S
• donc l'UC pilote à la fois l'accès aux bus internes au microprocesseur mais
également aux bus externes

IUT Informatique
Calais
5.9 Critères de puissance d'un microprocesseur
• vitesses d'horloge interne et externe (sur les bus externes)
• largeur du bus de donnée : taille des mots manipulés en une instruction
• largeur du bus d'adresse : taille de la mémoire gérée
• nombre de registres et de mémoires internes (caches, buffers, ...) qui
réduisent le nombre d'accès en mémoire centrale
• nombre d'instructions et complexité du jeu d'instructions
• nombre de microcommandes exécutées en séquence : + il y en a + il faut
de cycles pour exécuter une instruction, mais une UC simple supporte une
fréquence rapide donc compromis.
• nombre de microcommandes déclenchées en parallèle : duplication
d'unités fonctionnelles pouvant travailler en même temps ... + complexe
mais + performant
• ...

IUT Informatique
Calais
6 La mémoire
6.1 Définitions
• La mémoire centrale est un ensemble de registres dotés d'une structure
d'accès permettant l'échange entre les registres et les organes extérieurs.
• La capacité d'une mémoire est le nombre de bits que l'on peut mémoriser
dans cette mémoire.
• Le temps d'accès mémoire est le délai qui s'écoule entre une requête de
lecture et la disponibilité de l'information correspondante.
• On appelle emplacement accessible Ei (ou zone de stockage accessible)
l'emplacement unique sur lequel une opération de lecture ou d'écriture est
possible à l'instant t.

IUT Informatique
Calais
6.2 Types de mémoire
Un premier mode de classification des mémoires peut se faire selon la
structure d'accès dont elles sont dotées.
Il existe 3 familles de structures :
• mémoires séquentielles (ruban perforé, bande magnétique, ...)
• mémoires adressables (mémoire centrale, ...)
• mémoires associatives (sélection par le contenu / prédicat, ...)

IUT Informatique
Calais
6.2.1 Mémoires séquentielles
Définition :
Une mémoire séquentielle est une mémoire telle que si l'accès à l'instant t à
porté sur l'emplacement Ei alors l'accès à l'instant t+1 porte obligatoirement
sur l'emplacement Ei+1 ou Ei-1 (notion d'accès séquentiel).
Définition :
Une pile est une mémoire séquentielle dont les déplacements (Ei Ei+1 ou
Ei Ei-1) sont liés respectivement à la commande d'écriture ou de lecture.
écrire (empiler)
Ei
occupé vide
Ei Ei+1
écrire dans Ei+1
lire (dépiler)
Ei
occupé vide
Ei Ei-1
lire dans Ei

IUT Informatique
Calais
Application au microprocesseur :
Le microprocesseur utilise une pile pour mémoriser les adresses de retour
lors d’appels à des sous-programmes ou à des routines d’interruption.
vide
occupé
sommet de pile
fond de pile

IUT Informatique
Calais
6.2.2 Mémoires adressables
Définition :
Une mémoire adressable (appelée également à accès direct, à accès
aléatoire - RAM, ou à accès sélectif) est un ensemble de zones de stockage
complété par un mécanisme de sélection capable d’établir l’accès sur
chacune d’elles en un temps indépendant de la position.
• l’accès nécessite de désigner la position sélectionné par une adresse
• le microprocesseur agit sur le contenu de la mémoire par 2 opérations :
• écriture en mémoire : transfère un mot binaire dans un mot mémoire
d’adresse i. La valeur précédemment stockée à l’adresse i est perdue,
« écrasée » par la nouvelle valeur
• lecture en mémoire : délivre une copie du mot binaire stocké à
l’adresse i. La lecture ne modifie pas la valeur du mot en mémoire.

IUT Informatique
Calais
ROM / RAM :
• ROM (Read Only Memory) ou MEM (Mémoire Morte) : mémoire à
lecture seule
• RAM (Random Access Memory) ou MEV (Mémoire Vive) : mémoire à
accès aléatoire (lecture / écriture)
Les mémoire RAM sont dites « volatiles » car l’information stockée
disparaît lorsque l’on coupe l’alimentation.
On peut également distinguer :
• UVPROM, EEPROM : programmable par l’utilisateur
• PROM à fusibles / jonctions : programmable une seule fois
• RAM série : à accès série
• RAM statique / dynamique : selon le type de rafraîchissement
• ROM + masque : programmable en usine
• …

IUT Informatique
Calais
Familles et sous-familles de mémoires adressables :
Principales mémoires
adressables
Mémoires mortes Mémoires vives
ROM masque PROM utilisateur RAM
statiques
RAM
dynamiques
Associatives
(caches)
PROM fusibles EPROM ou PROM
effaçable
OTPROM ou EPROM
programmable une fois
UVPROM ou PROM
effaçable aux UV
EEPROM ou PROM
effaçable électriquement
par octet
EEPROM flash effaçable
électriquement par bloc

IUT Informatique
Calais
Espace d'adressage :
• la taille des mots binaires représentant les adresses limite le nombre de
mots auxquels le microprocesseur peut accéder. Si les adresses sont codées
sur m bits alors "l'espace d'adressage" est de 2m mots-mémoire
• dans cet espace d'adressage il faut prévoir non seulement l'accès à la
RAM, mais aussi à la ROM et aux E/S
• exemple : espace d'adressage d'une RAM de M mots, d'une ROM de N
mots et d'un espace mémoire réservé aux entrées sorties
mot 0
mot 1
...
mot M-1
mot M
...
...
mot M+N-1
...
...
...
0
1
...
M-1
M
...
...
M+N-1
M+N
...
2m-1
adresses
RAM
ROM
E/S

IUT Informatique
Calais
• il existe deux méthodes principales pour désigner une adresse :
• linéaire : mots numérotés de 0 à 2m-1
• segmentée : adresse = < n° segment , déplacement >
• pour réaliser cet espace d'adressage il est nécessaire d'utiliser tout un
ensemble de circuits déjà étudiés :
• décodeurs
• multiplexeurs
• démultiplexeurs
• ...

IUT Informatique
Calais
Aspect matériel :
• le temps d’accès à ces mémoires varie de quelques nanosecondes à
quelques dizaines de nanosecondes
• la mémoire se présente sous forme de boîtiers de différentes capacités et
adressant une certaine taille de mots (1K mots de 1 bit, 256K mots de 8 bits,
1M mots de 32 bits, …)
• chaque boîtier dispose (en général) des broches suivantes :
• une broche de sélection : CS (chip select)
• une broche de lecture/écriture : R/W (read/write) pour les RAM
• broches d0, …, d7, … pour les données
• broches a0, …, a7, … pour les adresses
• éventuellement une broche OE (output enable) de connexion (logique
3 états) des sorties vers l’extérieur (bus de donnée)
• 2 broches pour l’alimentation électrique

IUT Informatique
Calais
6.2.3 Mémoires associatives :
• la mémoire cache est une mémoire associative présente dans tous les
ordinateurs personnels qui a pour but d’accélérer l’accès aux données (pour
tout type de mémoire)
• son principe repose sur un certain nombre de remarques :
1. Les accès mémoire freinent les microprocesseurs : pendant le temps que
dure un accès en lecture à la mémoire centrale, celui-ci pourrait exécuter
plusieurs instructions
2. Le temps d'accès à la mémoire est fonction de sa technologie et de sa
capacité (à cause du décodage des adresses)
3. Le coût de la mémoire est inversement corrélé à sa vitesse
4. Pendant l'exécution d'un programme, de nombreux accès mémoire
concernent un petit nombre d'adresses, au moins pendant un certain temps
(variables, boucles, ...)

IUT Informatique
Calais
Idée de la mémoire cache :
• si l'on arrive à accélérer l'accès à ses quelques adresses utilisées de
manière répétitive on va du même coup accélérer l'exécution du programme
• puisqu'il n'y a que quelques adresses concernées, on peut utiliser une
mémoire de faible capacité mais à faible temps d'accès pour les stocker.
• Même si le coût de ce type de mémoire est élevé, si on l'utilise en petite
quantité, le coût de la machine va augmenter peu mais le rapport
efficacité/prix va lui augmenter fortement
• important : à ces mémoires caches sont associés des algorithmes chargés
de gérer son contenu de manière efficace
• hiérarchie des mémoires rencontrées dans un ordinateur :
Type
registre
cache
primaire
secondaire
O(capacité)
Octets
Ko/Mo
Mo/Go
Go/To
O(temps d'accès) en ns
1
<5
10
8000

IUT Informatique
Calais
6.3 RAM dynamique et RAM statique
Définition :
Une RAM est dite statique (SRAM) si l’information est conservée en
l’absence de signaux de commandes.
Définition :
Une RAM est dite dynamique (DRAM) si l’information ne peut être
conservée que par l’application répétée de signaux de commande
(rafraîchissement de la mémoire)
• la cellule élémentaire d’une SRAM est constituée de 4 transistor MOS
formant une sorte de bascule RS (différente de la bascule D)
• la cellule élémentaire d’une DRAM est constituée d’un seul transistor
MOS jouant le rôle de condensateur : la donnée est stockée sous forme de
charge dans une capacité. Mais le courant de fuite entraîne la nécessité de
recharger le condensateur : rafraîchissement (toutes les 2-4 ms)

cours_archi_2006-20071 (1).ppt

cours_archi_2006-20071 (1).ppt

Recommandé

Recommandé

Contenu connexe

Similaire à cours_archi_2006-20071 (1).ppt

Similaire à cours_archi_2006-20071 (1).ppt (20)

Dernier

Dernier (9)

cours_archi_2006-20071 (1).ppt