ES6 · AU 2025/2026 · Série I

Systèmes à Microprocesseur

Exercice 1 — Concepts Fondamentaux · Cours Interactif


Aller vers l'Exercice 2
1

Éléments principaux d'un système à microprocesseur

📌 Réponse Un système à microprocesseur est composé de 5 éléments principaux interconnectés via des bus : le microprocesseur, l'horloge, les mémoires (ROM/RAM), les interfaces E/S, et les bus (données, adresses, contrôle).
🖥️ Schéma interactif — Survolez chaque bloc pour en savoir plus
BUS D'ADRESSES (A0–An) BUS DE DONNÉES (D0–D7) BUS DE CONTRÔLE ⏱ OSCILLATEUR / HORLOGE µP MICROPROCESSEUR Unité de Commande PC · RI · Pile Unité de Traitement UAL · ACC · RE CLK ← ROM Programmes Données fixes Flash/EEPROM RAM Données temp. Pile, Variables SRAM/DRAM INTERFACES E/S Clavier Souris Imprimante Écran Capteurs… GPIO/UART/SPI

↑ Cliquez sur chaque bloc du schéma pour afficher sa description

2

Rôle de l'Unité de Commande et de l'Unité de Traitement

🎛️
Unité de Commande
UC — Control Unit
Rôle principal Séquencer et coordonner le déroulement des instructions. Elle lit l'instruction, la décode, et génère les signaux de contrôle pour activer les bons composants.
Registres associés
PC RI Pile
⚡
Unité de Traitement
UT — Datapath
Rôle principal Effectuer le traitement réel des données : opérations arithmétiques (+, −, ×, ÷) et logiques (AND, OR, NOT, XOR) sur les opérandes fournis par l'UC.
Registres associés
UAL Accumulateur Registre d'état
💡 Analogie pour mieux comprendre
🧠
UC = Chef d'orchestre
Dirige, coordonne, donne les ordres mais ne joue pas lui-même.
🎻
UT = Les musiciens
Exécutent réellement la musique (traitent les données).
3

Rôle des registres et composants internes

🔢
Compteur de programme (PC) UC ▼

Rôle : Stocke l'adresse mémoire de la prochaine instruction à exécuter.

Après chaque fetch, le PC s'incrémente automatiquement (PC ← PC + taille_instruction) pour pointer vers l'instruction suivante.

En cas de CALL ou de saut (JUMP), le PC est mis à jour avec la nouvelle adresse cible.

📋
Registre d'instruction (RI) UC ▼

Rôle : Stocke temporairement l'instruction machine en cours de traitement.

Une fois l'instruction récupérée depuis la mémoire (fetch), elle est placée dans le RI pour être décodée par l'UC.

Contenu typique : code opération (opcode) + éventuels opérandes.

🚦
Registre d'état (RE / PSW) UT ▼

Rôle : Contient des bits d'indicateurs (flags) reflétant l'état du processeur après chaque opération de l'UAL.

Principaux flags :

Z (Zero) : résultat = 0  |  N (Négatif) : résultat < 0  |  C (Carry) : retenue  |  V (oVerflow) : débordement

Utilisé par les instructions conditionnelles (JZ, JNZ, JC…)

➕
Accumulateur (ACC / A) UT ▼

Rôle : Registre principal de l'UT : stocke les opérandes et les résultats des opérations arithmétiques et logiques.

C'est le registre de travail central. La plupart des instructions opèrent sur ou avec l'accumulateur.

Exemple : ADD A, B → A ← A + B (résultat stocké dans l'accumulateur)

🗂️
Pile (Stack) UC ▼

Rôle : Zone mémoire LIFO (Last In First Out) qui stocke temporairement l'adresse de retour lors d'un appel de sous-programme (CALL/RET).

Également utilisée pour sauvegarder les registres lors d'interruptions.

Le Stack Pointer (SP) pointe toujours vers le sommet de la pile.

🔬
UAL — Unité Arithmétique et Logique UT ▼

Rôle : Exécute les opérations arithmétiques (+, −, ×, ÷, comparaison) et les opérations logiques (AND, OR, XOR, NOT, décalages).

Elle reçoit ses opérandes depuis les registres (ACC, etc.) et renvoie le résultat dans l'accumulateur en mettant à jour les flags du registre d'état.

C'est le composant qui effectue réellement le "calcul".

4

Différences entre architectures

⚙️ CISC vs RISC
CISC Instructions complexes et nombreuses. Chaque instruction peut faire plusieurs opérations. Moins d'instructions au total en mémoire.
Ex: x86, x86-64
RISC Instructions simples, rapides, de taille fixe. Chaque instruction fait une seule chose. Nécessite plus d'instructions pour une même tâche.
Ex: ARM, MIPS, RISC-V
Différence clé : CISC favorise la densité de code (logiciel compact), RISC favorise la vitesse matérielle (pipeline efficace, CPI ≈ 1).
🏛️ Harvard vs Von Neumann
Von Neumann Une seule mémoire partagée pour les instructions ET les données. Un seul bus = goulot d'étranglement (Bottleneck de Von Neumann).
Ex: PC classique
Harvard Mémoires séparées pour instructions et données. Deux bus distincts = accès simultané possible → plus rapide.
Ex: PIC, AVR, DSP
Différence clé : Harvard sépare physiquement les espaces mémoire → accès parallèles possibles, idéal pour les microcontrôleurs et le traitement temps réel.
🚂 Architecture Classique vs Pipeline
Classique (scalaire) Une instruction est entièrement terminée avant de commencer la suivante. Simple mais lent : beaucoup de temps "gaspillé".
Pipeline Plusieurs instructions en cours simultanément, chacune à une étape différente (Fetch → Decode → Execute). Comme une chaîne de montage !
Visualisation : 4 instructions, 3 étapes (F=Fetch, D=Decode, E=Execute)
Cycle →
C1
C2
C3
C4
C5
C6
❌ Classique (12 cycles)
Instr. I1
F
D
E
·
·
·
·
·
·
·
·
·
Instr. I2
·
·
·
F
D
E
·
·
·
·
·
·
Instr. I3
·
·
·
·
·
·
F
D
E
·
·
·
Instr. I4
·
·
·
·
·
·
·
·
·
F
D
E
✅ Pipeline (6 cycles — gain ≈ 2×)
Instr. I1
F
D
E
·
·
·
Instr. I2
·
F
D
E
·
·
Instr. I3
·
·
F
D
E
·
Instr. I4
·
·
·
F
D
E
Différence clé : Le pipeline permet d'avoir plusieurs instructions actives simultanément, augmentant significativement le débit (throughput). Idéal pour RISC avec instructions de durée uniforme.
5

Les 3 phases d'exécution d'une instruction

Phase 1
📡
FETCH
Recherche / Lecture
Fetch (Recherche)
Le microprocesseur lit l'instruction à l'adresse pointée par le PC en mémoire.

MAR ← PC
MDR ← Mémoire[MAR]
RI ← MDR
PC ← PC + 1
→
Phase 2
🔍
DECODE
Décodage
Decode (Décodage)
L'UC analyse le code opération (opcode) dans le RI pour identifier quelle opération effectuer et quels opérandes utiliser.
→
Phase 3
⚙️
EXECUTE
Exécution
Execute (Exécution)
L'UAL effectue l'opération identifiée, met à jour le registre d'état (flags), et stocke le résultat dans l'accumulateur ou en mémoire.

↑ Survolez chaque étape pour voir les détails

🔄 Cycle Fetch-Decode-Execute en détail
① FETCH MAR ← PC MDR ← Mém[MAR] RI ← MDR PC ← PC + 1 Lit l'instruction RI ② DECODE Analyse l'opcode Identifie opérandes Génère signaux de contrôle Interprète l'instruction ctrl ③ EXECUTE UAL effectue l'opération MAJ flags Résultat → ACC Effectue le calcul Recommence pour l'instruction suivante…
📘 Exemple concret : instruction ADD A, B
① Fetch
Le µP va chercher en mémoire l'instruction ADD A,B à l'adresse indiquée par PC.
② Decode
L'UC identifie le code opération = Addition, et les opérandes = registres A et B.
③ Execute
L'UAL calcule A ← A + B. Le résultat est stocké dans A. Les flags Z, N, C sont mis à jour.