Programmation embarquée

Introduction

La programmation embarquée contrôle un microcontrôleur intégré à un objet technique. Elle gère l'acquisition, le calcul, la communication et la commande d'actionneurs sous contraintes de mémoire, d'énergie et de temps.

Architectures et outils

• AVR (Arduino UNO, Nano) : 8 bits, 20 MHz, 2 kB SRAM.
• STM32 (Cortex-M0 à M7) : 32 bits, jusqu'à 550 MHz.
• ESP32 (Xtensa dual-core, Wi-Fi/Bluetooth) : très populaire IoT.
• RP2040 (Raspberry Pi Pico) : dual Cortex-M0+, PIO.

IDE et frameworks

• Arduino IDE, PlatformIO (VS Code), STM32CubeIDE.
• MicroPython, CircuitPython : Python simplifié pour µC (rapide à prototyper).
• Zephyr, FreeRTOS : systèmes d'exploitation temps réel embarqués.

Notions clés

• GPIO : entrées/sorties numériques.
• PWM : signal carré de rapport cyclique variable (variation vitesse, luminosité).
• ADC / DAC : conversion analogique.
• Interruptions : réponse événementielle prioritaire.
• Timers : mesure de durée, base de temps.

Structure d'un programme Arduino

void setup() {
  pinMode(2, INPUT_PULLUP);
  pinMode(13, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  int etat = digitalRead(2);
  digitalWrite(13, !etat);
  delay(100);
}

Communication série

• UART (Serial) : 9600, 115200 bauds.
• I2C : bus 2 fils (SDA, SCL), multi-esclaves.
• SPI : rapide (Mo/s), 4 fils (MOSI, MISO, SCK, CS).

Machine à états

Modélisation avec GRAFCET ou StateMachine : étapes + transitions + actions. Utile pour arrosage automatique, distributeur, portail.

Contraintes temps réel

• Hard real-time : dépassement fatal (airbag, ABS).
• Soft real-time : dépassement acceptable (streaming).
• Ordonnancement : Round-Robin, Preemptive (FreeRTOS).

Optimisation

• Sleep modes pour économiser l'énergie (ESP32 deep sleep 5 µA).
• DMA pour transferts sans CPU.
• Boucle non bloquante : éviter delay(), préférer millis().

Cas d'application

Serrure intelligente :

• Capteur biométrique (empreinte digital, I2C).
• Traitement STM32 avec liste d'utilisateurs (EEPROM).
• Notification via ESP32 (MQTT) au propriétaire.
• Servomoteur PWM pour déverrouiller.
• Historique horodaté sur SD Card.

Cadre réglementaire

• Marquage CE + norme radio ETSI EN 300 328 (2,4 GHz).
• Directive RED, ROHS.
• RGPD (art. 32) pour données biométriques.

Exemple chiffré 1 — cadencement d'une tâche périodique

Un régulateur PID doit tourner à 200 Hz, soit une période de 5 ms. Mesure au chronomètre logiciel : lecture capteur I2C 400 kHz (6 octets → $6\times9/400\,000 \approx 135$ µs), calcul PID en virgule flottante 40 µs, écriture PWM 5 µs → 180 µs de charge utile.

$\text{Taux d'occupation} = \frac{180}{5\,000} = 3{,}6\ \%$

Il reste 96 % du temps CPU pour la communication et l'IHM : la conception est viable. Au-delà de 70 % d'occupation, on perd le déterminisme.

Exemple chiffré 2 — PWM et résolution

Timer 16 bits sur horloge 72 MHz, PWM à 20 kHz :

$\text{ARR} = \frac{72 \times 10^6}{20 \times 10^3} - 1 = 3\,599$

Résolution : $\log_2(3\,600) = 11{,}8$ bits, soit un pas de rapport cyclique de 0,028 %. En passant à 100 kHz, ARR = 719 → 9,5 bits seulement : fréquence élevée et résolution fine s'opposent.

Exemple chiffré 3 — machine à états d'un portail automatisé

État	Condition de sortie	État suivant
REPOS	appui télécommande	OUVERTURE
OUVERTURE	fin de course haut OU t > 20 s	ATTENTE
ATTENTE	t > 8 s ET aucun obstacle	FERMETURE
FERMETURE	cellule coupée	OUVERTURE
FERMETURE	fin de course bas	REPOS

Le temporisateur logiciel utilise millis() ; la détection d'obstacle est câblée sur une interruption externe pour garantir un temps de réaction < 1 ms (contre jusqu'à 5 ms en scrutation).

Exemple chiffré 4 — empreinte mémoire

Firmware STM32F103 : 34 ko de Flash sur 64 ko (53 %), 9,2 ko de RAM sur 20 ko (46 %) dont 2 ko de pile. Règle de conception : garder ≥ 25 % de marge RAM pour absorber la pile en cas d'imbrication d'interruptions.

Points-clés à retenir

• Toute tâche temps réel se valide par un calcul de budget temps (WCET / période).
• Interruption pour l'urgent et le bref, boucle principale pour le reste : jamais de code long dans une ISR.
• Documenter le programme par une machine à états rend le comportement vérifiable et testable.