Architecture des Systemes Numeriques
Processeurs, memoires, bus et microcontroleurs
Objectifs pedagogiques
- Comprendre l'architecture Von Neumann et Harvard
- Identifier les composants : CPU, RAM, ROM, bus, registres
- Maitriser le cycle Fetch-Decode-Execute du processeur
- Programmer un microcontroleur (Arduino, STM32, ESP32)
Introduction : Le coeur du numerique
Exemple concret : Votre smartphone
Votre smartphone contient un SoC (System on Chip) qui integre un processeur ARM Cortex (2.8 GHz, 8 coeurs), une GPU, 8 Go de RAM LPDDR5, et 256 Go de stockage UFS 3.1. Tout communique via des bus internes a plusieurs milliards de transferts par seconde !
L'architecture d'un systeme numerique definit l'organisation physique et logique des composants qui le constituent. Comprendre cette architecture est fondamental pour programmer efficacement les systemes embarques.
1Architecture Von Neumann
L'architecture Von Neumann (1945) est la base de tous les ordinateurs modernes. Elle utilise une memoire unique pour le programme et les donnees.
+-----------------------------------------------------+
| PROCESSEUR (CPU) |
| +--------------+ +--------------+ +-----------+ |
| | UAL | | Registres | | Unite de | |
| | (Calculs) | | PC, ACC, R0 | | Controle | |
| | +,-,*,AND | | R1, R2, SP | | (CU) | |
| +--------------+ +--------------+ +-----------+ |
+-----------------------+-----------------------------+
|
+---------------+---------------+
| Bus Adresses | Bus Donnees | Bus Controle
| (20 bits) | (32 bits) | (R/W, IRQ)
+---------------+---------------+
|
+-----------------------+-----------------------------+
| MEMOIRE |
| Programme + Donnees (meme espace) |
| Adresses : 0x00000000 a 0xFFFFFFFF (32 bits) |
| = 4 Go adressables |
+-----------------------------------------------------+Cycle Fetch-Decode-Execute
Le processeur execute en permanence ce cycle pour chaque instruction :
1. FETCH
Lecture de l'instruction en memoire a l'adresse pointee par PC (Program Counter)
IR = MEM[PC]
2. DECODE
Decodage de l'instruction : quel operation ? quels operandes ?
ADD R1, R2 ?
3. EXECUTE
Execution par l'UAL et stockage du resultat. PC incremente.
R1 = R1 + R2; PC++
Goulot Von Neumann : Le CPU ne peut pas lire une instruction ET une donnee en meme temps (un seul bus memoire). Solution : architecture Harvard avec bus separes.
Comparaison Von Neumann vs Harvard
| Aspect | Von Neumann | Harvard |
|---|---|---|
| Memoire | Unique (programme + donnees) | Separee (Flash / RAM) |
| Bus | Un seul bus | Bus separes |
| Performance | Goulot d'etranglement | Acces parallele |
| Exemples | PC (x86, x64) | AVR, PIC, ARM Cortex-M |
2Types de Memoires
| Type | Volatile | Vitesse | Capacite typique | Usage |
|---|---|---|---|---|
| SRAM | Oui | ~1 ns | 2 Ko - 64 Mo | Cache L1/L2, registres |
| DRAM | Oui | ~10 ns | 4 - 64 Go | RAM principale PC |
| Flash NOR | Non | ~100 ns lecture | 32 Ko - 4 Mo | Code microcontroleur |
| Flash NAND | Non | ~25 us | 8 Go - 8 To | SSD, cles USB |
| EEPROM | Non | ~5 ms ecriture | 256 o - 64 Ko | Parametres, calibration |
| ROM | Non | ~50 ns | Variable | Bootloader, BIOS |
Calcul de capacite memoire
// Formule de calcul
Capacite = 2^n x m bits
ou n = nombre de bits d'adresse
m = largeur du bus de donnees
// Exemple 1 : Bus 16 bits adresse, 8 bits donnees
C = 2^16 x 8 bits = 65 536 x 8 bits = 524 288 bits = 64 Ko
// Exemple 2 : Bus 32 bits adresse, 32 bits donnees
C = 2^32 x 32 bits = 4 294 967 296 x 32 bits = 4 Go x 4 = 16 Go
// Mais on compte en octets : 2^32 = 4 Go adressables
// Exemple 3 : ATmega328P (Arduino UNO)
Flash : 32 Ko (15 bits adresse interne)
SRAM : 2 Ko (11 bits adresse)
EEPROM: 1 Ko (10 bits adresse)
Attention aux unites : 1 Ko = 1024 octets (binaire) vs 1 kB = 1000 octets (decimal). Les fabricants de SSD utilisent souvent le decimal, d'ou un SSD "500 Go" qui n'affiche que 465 Go dans Windows !
3Microcontroleurs
Un microcontroleur integre CPU + memoire + peripheriques sur une seule puce. C'est le coeur des systemes embarques : domotique, automobile, IoT, robotique.
| Microcontroleur | Architecture | Flash | RAM | Frequence | GPIO | Prix |
|---|---|---|---|---|---|---|
| ATmega328P | AVR 8 bits | 32 Ko | 2 Ko | 16 MHz | 23 | ~2 EUR |
| ATtiny85 | AVR 8 bits | 8 Ko | 512 o | 20 MHz | 6 | ~1 EUR |
| STM32F103 | ARM Cortex-M3 | 64 Ko | 20 Ko | 72 MHz | 37 | ~3 EUR |
| STM32F407 | ARM Cortex-M4 | 512 Ko | 192 Ko | 168 MHz | 82 | ~8 EUR |
| ESP32 | Xtensa 32 bits | 4 Mo | 520 Ko | 240 MHz | 34 | ~5 EUR |
| RP2040 | ARM Cortex-M0+ | 2 Mo | 264 Ko | 133 MHz | 26 | ~4 EUR |
Exemple Arduino : Blink avec commentaires memoire
// Programme Blink - Arduino UNO (ATmega328P)
// Utilise : ~930 octets Flash (2%) et ~9 octets RAM (0%)
void setup() {
// Configuration du pin 13 en sortie
// Registre DDRB (Data Direction Register B)
pinMode(13, OUTPUT); // DDRB |= (1 << PB5)
}
void loop() {
// Ecriture dans PORTB pour allumer la LED
digitalWrite(13, HIGH); // PORTB |= (1 << PB5)
delay(500); // 500 ms ON
// Eteindre la LED
digitalWrite(13, LOW); // PORTB &= ~(1 << PB5)
delay(500); // 500 ms OFF
}
Exemple STM32 : Acces direct aux registres
// STM32F103 - Blink LED PC13 (niveau registre)
// Plus rapide et compact que HAL
#include "stm32f1xx.h"
int main(void) {
// Activer horloge GPIOC (bit 4 de RCC_APB2ENR)
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN;
// Configurer PC13 en sortie push-pull 2 MHz
// CRH controle pins 8-15, MODE13[1:0]=10, CNF13[1:0]=00
GPIOC->CRH &= ~(0xF << 20); // Clear bits 20-23
GPIOC->CRH |= (0x2 << 20); // Output 2 MHz
while(1) {
GPIOC->BSRR = GPIO_BSRR_BR13; // Reset = LED ON (logique inversee)
for(volatile int i = 0; i < 500000; i++);
GPIOC->BSRR = GPIO_BSRR_BS13; // Set = LED OFF
for(volatile int i = 0; i < 500000; i++);
}
}
4Bus de Communication
Bus d'adresses
- Selectionne la case memoire
- Unidirectionnel (CPU vers memoire)
- Largeur : 16, 20, 32 bits
- 2^20 = 1 Mo adressable
Bus de donnees
- Transporte les donnees
- Bidirectionnel
- Largeur : 8, 16, 32, 64 bits
- Determine la "taille du mot"
Bus de controle
- R/W : Read/Write
- IRQ : Interruption
- RESET, CLK, CS
- Synchronise les echanges
Protocoles de communication serie
| Protocole | Fils | Vitesse max | Distance | Peripheriques |
|---|---|---|---|---|
| UART | 2 (TX/RX) | 115200 bps | < 15 m | 1 (point a point) |
| I2C | 2 (SDA/SCL) | 3.4 Mbps | < 1 m | 127 (adresses 7 bits) |
| SPI | 4 (MOSI/MISO/SCK/CS) | 50+ Mbps | < 1 m | 1 par CS (illimite) |
| 1-Wire | 1 (DQ) | 16 kbps | < 100 m | Illimite (ID 64 bits) |
| CAN | 2 (CAN_H/CAN_L) | 1 Mbps | < 40 m a 1Mbps | 110+ noeuds |
Exemple I2C : Scanner d'adresses
// Scanner I2C - Detecte tous les peripheriques connectes
#include <Wire.h>
void setup() {
Wire.begin(); // Initialise I2C en maitre
Serial.begin(115200); // 115200 bauds pour debug
}
void loop() {
Serial.println("Scan I2C...");
for(byte addr = 1; addr < 127; addr++) {
Wire.beginTransmission(addr);
byte error = Wire.endTransmission();
if(error == 0) {
Serial.print("Trouve: 0x");
if(addr < 16) Serial.print("0");
Serial.println(addr, HEX);
// 0x27 = LCD, 0x3C = OLED, 0x68 = RTC/MPU6050
}
}
delay(5000);
}
Resume en 5 points cles
- 1Architecture Von Neumann : memoire unique programme/donnees, goulot d'etranglement. Harvard separe les bus.
- 2Cycle Fetch-Decode-Execute : le CPU lit l'instruction, la decode, puis l'execute en boucle.
- 3Memoires : RAM volatile (SRAM rapide, DRAM dense), Flash/EEPROM non volatiles pour le programme.
- 4Microcontroleurs : CPU + memoire + peripheriques integres. ATmega328P (Arduino), STM32, ESP32.
- 5Bus serie : UART (debug), I2C (capteurs, multi-esclaves), SPI (rapide, ecrans, SD).
Mini-Quiz
Question 1 : Quelle est la difference entre RAM et Flash ?
a) RAM est plus rapide
b) RAM est volatile, Flash conserve les donnees sans alimentation
c) Flash a plus de capacite
Reponse : b) La RAM perd ses donnees a la mise hors tension, la Flash les conserve
Question 2 : Combien de memoire peut adresser un bus 20 bits ?
a) 20 Ko
b) 1 Mo (2^20 = 1 048 576 adresses)
c) 1 Go
Reponse : b) 2^20 = 1 048 576 = 1 Mo adressable
Question 3 : Quel protocole utilise 2 fils SDA/SCL et supporte plusieurs esclaves ?
a) UART
b) SPI
c) I2C
Reponse : c) I2C utilise 2 fils et adresse jusqu'a 127 peripheriques
Question 4 : Quelle phase du cycle CPU lit l'instruction en memoire ?
a) Execute
b) Decode
c) Fetch
Reponse : c) Fetch lit l'instruction a l'adresse pointee par PC
Question 5 : Quel microcontroleur integre WiFi et Bluetooth nativement ?
a) ATmega328P
b) STM32F103
c) ESP32
Reponse : c) L'ESP32 integre WiFi 2.4 GHz et Bluetooth 4.2/BLE
