Cours 1SIN

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

AspectVon NeumannHarvard
MemoireUnique (programme + donnees)Separee (Flash / RAM)
BusUn seul busBus separes
PerformanceGoulot d'etranglementAcces parallele
ExemplesPC (x86, x64)AVR, PIC, ARM Cortex-M

2Types de Memoires

TypeVolatileVitesseCapacite typiqueUsage
SRAMOui~1 ns2 Ko - 64 MoCache L1/L2, registres
DRAMOui~10 ns4 - 64 GoRAM principale PC
Flash NORNon~100 ns lecture32 Ko - 4 MoCode microcontroleur
Flash NANDNon~25 us8 Go - 8 ToSSD, cles USB
EEPROMNon~5 ms ecriture256 o - 64 KoParametres, calibration
ROMNon~50 nsVariableBootloader, 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.

MicrocontroleurArchitectureFlashRAMFrequenceGPIOPrix
ATmega328PAVR 8 bits32 Ko2 Ko16 MHz23~2 EUR
ATtiny85AVR 8 bits8 Ko512 o20 MHz6~1 EUR
STM32F103ARM Cortex-M364 Ko20 Ko72 MHz37~3 EUR
STM32F407ARM Cortex-M4512 Ko192 Ko168 MHz82~8 EUR
ESP32Xtensa 32 bits4 Mo520 Ko240 MHz34~5 EUR
RP2040ARM Cortex-M0+2 Mo264 Ko133 MHz26~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

ProtocoleFilsVitesse maxDistancePeripheriques
UART2 (TX/RX)115200 bps< 15 m1 (point a point)
I2C2 (SDA/SCL)3.4 Mbps< 1 m127 (adresses 7 bits)
SPI4 (MOSI/MISO/SCK/CS)50+ Mbps< 1 m1 par CS (illimite)
1-Wire1 (DQ)16 kbps< 100 mIllimite (ID 64 bits)
CAN2 (CAN_H/CAN_L)1 Mbps< 40 m a 1Mbps110+ 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

  1. 1Architecture Von Neumann : memoire unique programme/donnees, goulot d'etranglement. Harvard separe les bus.
  2. 2Cycle Fetch-Decode-Execute : le CPU lit l'instruction, la decode, puis l'execute en boucle.
  3. 3Memoires : RAM volatile (SRAM rapide, DRAM dense), Flash/EEPROM non volatiles pour le programme.
  4. 4Microcontroleurs : CPU + memoire + peripheriques integres. ATmega328P (Arduino), STM32, ESP32.
  5. 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

Scientia