TD Systèmes à µp et à µc — Série I

Exercice 1 : Systèmes à microprocesseur (mode présentation interactive)

1) Éléments principaux d’un système à microprocesseur

À retenir : un système à µp = CPU + horloge + mémoires + bus + interfaces E/S.

Astuce : clique sur un élément pour le mettre en évidence

Réponse (liste structurée)

  • Microprocesseur (CPU) : exécute les instructions et traite les données.
  • Horloge : synchronise toutes les opérations (rythme du système).
  • Mémoires : stockent programmes et données (ROM/Flash, RAM, cache…).
  • Bus : transportent adresses, données et signaux de contrôle.
  • Interfaces Entrées/Sorties (E/S) : relient clavier, afficheur, capteurs, réseau, etc.

Schéma global (interactif)

BUS (Adresse • Données • Contrôle) Microprocesseur (CPU) UC + UT (ALU, registres…) Exécute instructions Horloge Synchronise le système Mémoires ROM / Flash Programme (souvent) RAM Données temporaires Interfaces E/S GPIO, UART, SPI, I²C, USB… Capteurs / Clavier Entrées Périphériques Écran, moteur, réseau, stockage… Afficheur / Actionneurs Sorties Schéma générique : CPU ↔ Bus ↔ Mémoires / E/S — Horloge synchronise.

Le BUS regroupe généralement : bus d’adresses, bus de données, bus de contrôle.

2) Rôle de l’Unité de Commande (UC) et de l’Unité de Traitement (UT)

UC = “chef d’orchestre”, UT = “calcul et manipulation des données”.

Clique : UC vs UT

Réponse attendue

  • Unité de commande (UC) : séquence le déroulement des instructions (orchestration).
  • Unité de traitement (UT) : traite les données (opérations arithmétiques/logiques, registres de travail).

Mémo : UC “séquencer”, UT “traitement des données”.

Schéma interne CPU (interactif)

Microprocesseur (CPU) Unité de Commande (UC) Séquencement & contrôle Fetch / Decode Génère signaux de contrôle lecture/écriture, sélection, etc. Unité de Traitement (UT) Calcul & registres UAL (ALU) Registres de travail accumulateur, flags, etc. signaux ↔ données UC contrôle “quoi faire et quand”, UT réalise “les opérations sur les données”.

Mémo : UC = contrôle ; UT = calcul.

3) Rôle des registres / UAL / pile — et leur unité (UC ou UT)

Clique sur une ligne pour afficher un rappel rapide.

Tableau + aide interactive

Tableau de synthèse

Composant Rôle Unité
Compteur de programme (PC) Stocke l’adresse de la prochaine instruction à exécuter UC
Registre d’instruction (IR) Stocke temporairement l’instruction machine en cours de traitement UC
Registre d’état (Flags) Indique l’état du processeur / résultat des opérations (flags) UT
Accumulateur Stocke opérandes et résultats des opérations arithmétiques et logiques UT
Pile (Stack) Stocke des données critiques (adresse de retour CALL/RET, etc.) UC
UAL (ALU) Exécute les opérations arithmétiques et logiques UT

Conseil : PC & IR = “pilotage”, ALU/accumulateur/flags = “calcul”.

Mini-illustration : “où ça se place ?”

CPU Unité de Commande (UC) PC (Compteur de programme) IR (Registre d’instruction) Pile (Stack) CALL/RET, interruptions… Unité de Traitement (UT) UAL (ALU) Accumulateur Registre d’état (Flags) Z, C, N, V… contrôle ↔ calcul L’idée : UC pilote la séquence, UT réalise les opérations et met à jour les flags.

Rappel express (utile en examen)

  • PC : “où est la prochaine instruction ?” → UC
  • IR : “quelle instruction je traite ?” → UC
  • Pile : “où revenir après CALL ?” → UC
  • UAL + Accu + Flags : “je calcule et je mémorise le résultat” → UT

4) Différences clés : CISC vs RISC • Harvard vs Von Neumann • Classique vs Pipeline

Compare “philosophie d’instructions”, “organisation mémoire”, et “mode d’exécution”.

Comparaisons + pipeline
CISC instructions complexes
  • Instructions souvent longues et puissantes (une instruction = plusieurs micro-étapes).
  • Objectif historique : réduire le nombre d’instructions (au prix de complexité matérielle).
RISC instructions simples
  • Instructions simples, souvent de durée plus régulière.
  • Objectif : vitesse matérielle et exécution efficace (souvent pipeline-friendly).

Harvard vs Von Neumann (schéma interactif)

Von Neumann Mémoire unique Instructions + Données CPU bus partagé même bus Harvard Mémoire instructions Mémoire données CPU bus séparés Von Neumann : 1 mémoire partagée • Harvard : mémoires séparées (instr/données).

Classique vs Pipeline (animation + “cycle”)

Classique : une instruction à la fois.
Pipeline : plusieurs instructions avancent en parallèle (Fetch/Decode/Execute).

Étapes Fetch Decode Execute Classique Pipeline I1 : Fetch I1 : Decode I1 : Execute I2 : Fetch I2 : Decode I2 : Execute I1 I2 I3 Cycle 1 I1 est en Fetch

Lecture “cycle par cycle” : à chaque cycle, une instruction avance d’une étape.

5) Les 3 phases principales d’exécution d’une instruction

Fetch → Decode → Execute (et on recommence pour l’instruction suivante).

Clique sur une phase

Réponse attendue

  1. Recherche (Fetch) de l’instruction en mémoire
  2. Décodage (Decode) par l’unité de commande
  3. Exécution (Execute) de l’opération

Mini-méthode pour expliquer aux étudiants

  • Fetch : “je lis la consigne”
  • Decode : “je comprends ce que je dois faire”
  • Execute : “je fais l’action (calcul, lecture/écriture, saut…)”

Animation + explication (interactif)

Fetch Lire l’instruction depuis la mémoire Decode Interpréter par l’UC Execute Réaliser l’action ALU / mémoire / saut… Clique sur une phase Tu verras une explication courte et claire ici.

Ces 3 étapes : fetch, decode, execute.

Navigation : ←/→ • ou boutons • 5 diapos