Thursday, September 24, 2026

Microcontroleur STM32F4

bts eii · seconde année · module systèmes embarqués

Microcontrôleur STM32F4 — Cours Complet

De l'architecture ARM Cortex-M4 jusqu'au bus CAN, en passant par les GPIO, timers, ADC, DAC, USART, I2C et SPI. Des extraits de code HAL + registres prêts à compiler sur une carte Nucleo ou Discovery.

12 chapitres STM32F4xx · Cortex-M4F HAL + registres Cours 48 h · TP 24 h 100% hors-ligne

1. Introduction aux systèmes embarqués

Objectifs du chapitre

  • Définir un système embarqué et ses caractéristiques
  • Distinguer microprocesseur et microcontrôleur
  • Identifier les domaines d'application des systèmes embarqués
  • Connaître les critères de choix d'un microcontrôleur
1.1 Définition d'un système embarqué

Un système embarqué (embedded system) est un système électronique et informatique autonome, dédié à une tâche spécifique, souvent en temps réel, intégré au sein d'un équipement plus large. Il combine du matériel (hardware) et du logiciel (software) pour réaliser une fonction précise.

Caractéristiques principales :

  • Dédié : conçu pour une application spécifique (contrairement à un PC généraliste)
  • Autonome : fonctionne sans intervention humaine permanente
  • Temps réel : doit répondre dans des délais déterminés et garantis
  • Contraint : ressources limitées (mémoire, puissance, énergie)
  • Fiable : fonctionnement continu et robuste requis
  • Intégré : fait partie d'un système plus large

Exemples de systèmes embarqués :

🚗

Automobile

ABS, airbag, injection, GPS, tableau de bord

📱

Téléphonie

Smartphones, modems, routeurs

🏥

Médical

Pacemaker, IRM, moniteurs

✈️

Aéronautique

Pilote automatique, contrôle moteur

🏭

Industriel

Automates, robots, capteurs

🏠

Domotique

Thermostats, alarmes, IoT

1.2 Architecture d'un système embarqué

Un système embarqué typique est composé de plusieurs éléments interconnectés :

Schéma bloc — système embarqué
┌─────────────────────────────────────────────────────────────────────┐
│                        SYSTÈME EMBARQUÉ                              │
├─────────────────────────────────────────────────────────────────────┤
│                                                                      │
│  ┌──────────────┐    ┌─────────────────────────────────────────┐    │
│  │   CAPTEURS   │───▶│          UNITÉ DE TRAITEMENT            │    │
│  │  (Entrées)   │    │  ┌─────────────────────────────────┐   │    │
│  │              │    │  │     MICROCONTRÔLEUR / CPU        │   │    │
│  │ - Température│    │  │  ┌───────┐ ┌───────┐ ┌───────┐ │   │    │
│  │ - Pression   │    │  │  │  CPU  │ │  RAM  │ │ Flash │ │   │    │
│  │ - Position   │    │  │  └───────┘ └───────┘ └───────┘ │   │    │
│  │ - Lumière    │    │  │  ┌───────┐ ┌───────┐ ┌───────┐ │   │    │
│  │ - Boutons    │    │  │  │ Timer │ │  ADC  │ │ UART  │ │   │    │
│  └──────────────┘    │  │  └───────┘ └───────┘ └───────┘ │   │    │
│                      │  └─────────────────────────────────┘   │    │
│  ┌──────────────┐    │                                        │    │
│  │ ACTIONNEURS  │◀───│         LOGICIEL EMBARQUÉ              │    │
│  │  (Sorties)   │    │  ┌─────────────────────────────────┐   │    │
│  │              │    │  │  - Système d'exploitation (RTOS) │   │    │
│  │ - Moteurs    │    │  │  - Drivers / Pilotes             │   │    │
│  │ - LEDs       │    │  │  - Application                   │   │    │
│  │ - Afficheurs │    │  └─────────────────────────────────┘   │    │
│  │ - Relais     │    └─────────────────────────────────────────┘    │
│  └──────────────┘                                                    │
│                                                                      │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │                    ALIMENTATION                                │   │
│  │            Batterie / Secteur / Énergie solaire               │   │
│  └──────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────┘
1.3 Microprocesseur vs Microcontrôleur

Il est essentiel de distinguer ces deux composants fondamentaux :

CritèreMicroprocesseur (µP)Microcontrôleur (µC)
DéfinitionUnité centrale de traitement seuleSystème complet sur une puce (SoC)
Composants intégrésCPU uniquementCPU + RAM + Flash + Périphériques
MémoireExterne (sur carte mère)Interne (intégrée)
PériphériquesExternes (chipsets)Intégrés (GPIO, ADC, UART, etc.)
PuissanceÉlevée (GHz, multi-cœurs)Modérée (MHz à quelques GHz)
ConsommationÉlevée (10-150 W)Faible (µA à quelques mA)
CoûtÉlevé (+ carte mère)Faible (0,5 € à 20 €)
ApplicationsPC, serveurs, calcul intensifEmbarqué, IoT, contrôle
ExemplesIntel Core, AMD Ryzen, ARM Cortex-ASTM32, PIC, AVR, ESP32
Règle pratique : pour une application embarquée, on privilégie un microcontrôleur car il intègre tout le nécessaire sur une seule puce : processeur, mémoire et périphériques. Cela réduit le coût, la taille du circuit et la consommation énergétique.
1.4 Critères de choix d'un microcontrôleur

Le choix d'un microcontrôleur pour un projet embarqué dépend de nombreux facteurs :

Critères techniques :

  • Architecture : 8, 16 ou 32 bits selon la complexité des calculs
  • Fréquence : de quelques MHz à plusieurs centaines de MHz
  • Mémoire Flash : stockage du programme (Ko à Mo)
  • Mémoire RAM : variables et pile d'exécution (Ko à centaines de Ko)
  • Nombre de GPIO : entrées/sorties disponibles
  • Périphériques : ADC, DAC, UART, SPI, I2C, CAN, USB, Ethernet
  • Timers : nombre et résolution
  • Interruptions : nombre de sources et niveaux de priorité
  • DMA : transfert de données sans CPU

Critères pratiques :

  • Consommation : critique pour applications sur batterie
  • Tension d'alimentation : 1,8 V · 3,3 V · 5 V
  • Boîtier : DIP, QFP, BGA selon le montage
  • Température de fonctionnement : industriel (-40 °C à +85 °C)
  • Outils de développement : IDE, débogueur, programmateur
  • Documentation et communauté : support technique
  • Prix et disponibilité : approvisionnement

Principales familles de microcontrôleurs :

FamilleFabricantArchitecturePoints forts
STM32STMicroelectronicsARM Cortex-MLarge gamme, outils gratuits, écosystème riche
PICMicrochipPropriétaireSimplicité, faible coût, XC compilers
AVRMicrochip (ex-Atmel)RISC 8 bitsArduino, simple, bien documenté
ESP32EspressifXtensa / RISC-VWiFi/Bluetooth intégré, IoT
LPCNXPARM Cortex-MPerformance, USB, Ethernet
MSP430Texas InstrumentsRISC 16 bitsUltra basse consommation
1.5 Introduction à la famille STM32

La famille STM32 de STMicroelectronics est l'une des plus populaires pour les applications embarquées professionnelles. Elle offre une gamme complète basée sur les cœurs ARM Cortex-M.

Gammes STM32 :

GammeCœurFréquencePositionnement
STM32F0Cortex-M048 MHzEntrée de gamme, remplacement 8 bits
STM32F1Cortex-M372 MHzUsage général, mainstream
STM32F3Cortex-M472 MHzMixed-signal, ADC haute résolution
STM32F4Cortex-M4F180 MHzHaute performance, DSP, FPU
STM32F7Cortex-M7216 MHzTrès haute performance
STM32H7Cortex-M7480 MHzPerformance maximale
STM32L0/L4/L5Cortex-M0+/M4/M3332-110 MHzUltra basse consommation
STM32G0/G4Cortex-M0+/M464-170 MHzNouvelle génération mainstream
Focus du cours : STM32F4. Ce cours se concentre sur la famille STM32F4, basée sur le cœur ARM Cortex-M4 avec unité de calcul flottant (FPU). C'est la gamme haute performance la plus utilisée dans l'industrie et l'enseignement.

2. ARM Cortex-M3/M4

Objectifs du chapitre

  • Comprendre l'architecture ARM et ses avantages
  • Connaître les caractéristiques des cœurs Cortex-M3 et Cortex-M4
  • Maîtriser l'organisation des registres et modes de fonctionnement
  • Comprendre le jeu d'instructions Thumb-2
2.1 Présentation d'ARM

ARM (Advanced RISC Machines) est une société britannique qui conçoit des architectures de processeurs. ARM ne fabrique pas de puces mais vend des licences de ses designs aux fabricants (STMicroelectronics, NXP, Texas Instruments, etc.).

Avantages de l'architecture ARM :

  • RISC : jeu d'instructions réduit et optimisé
  • Efficacité énergétique : excellent rapport performance/consommation
  • Scalabilité : du microcontrôleur au serveur
  • Écosystème : outils, documentation, communauté immenses
  • Standardisation : code portable entre fabricants

Familles de cœurs ARM :

FamilleCœursApplications
Cortex-AA5, A7, A9, A53, A72, A76…Smartphones, tablettes, serveurs
Cortex-RR4, R5, R7, R8…Temps réel critique (automobile, disques durs)
Cortex-MM0, M0+, M3, M4, M7, M23, M33…Microcontrôleurs, embarqué, IoT
2.2 Architecture Cortex-M3 et Cortex-M4

Les cœurs Cortex-M3 et Cortex-M4 sont les plus utilisés dans les microcontrôleurs 32 bits professionnels.

Comparaison Cortex-M3 vs Cortex-M4 :

CaractéristiqueCortex-M3Cortex-M4
ArchitectureARMv7-MARMv7E-M
Pipeline3 étages3 étages
Jeu d'instructionsThumb / Thumb-2Thumb / Thumb-2 + DSP
FPUNonOptionnelle (simple précision)
Instructions DSPNonOui (SIMD, MAC)
Performance1,25 DMIPS/MHz1,25 DMIPS/MHz (+ DSP/FPU)
InterruptionsJusqu'à 240Jusqu'à 240
FPU (Floating Point Unit). L'unité de calcul en virgule flottante permet d'effectuer des opérations sur des nombres décimaux (float) directement en matériel, beaucoup plus rapidement qu'en logiciel. Indispensable pour le traitement du signal, les calculs scientifiques et le contrôle moteur.
DSP (Digital Signal Processing). Les instructions DSP permettent d'effectuer des opérations de traitement du signal (filtrage, FFT…) de manière optimisée : multiplication-accumulation (MAC), opérations SIMD sur des données 16 bits empaquetées.
2.3 Pipeline et exécution des instructions

Le Cortex-M4 utilise un pipeline à 3 étages qui permet d'exécuter plusieurs instructions en parallèle :

Pipeline 3 étages du Cortex-M4
        Cycle 1    Cycle 2    Cycle 3    Cycle 4    Cycle 5    Cycle 6
        ┌──────┐   ┌──────┐   ┌──────┐
Inst 1  │ FETCH│──▶│DECODE│──▶│EXECUTE│
        └──────┘   └──────┘   └──────┘
                   ┌──────┐   ┌──────┐   ┌──────┐
Inst 2             │ FETCH│──▶│DECODE│──▶│EXECUTE│
                   └──────┘   └──────┘   └──────┘
                              ┌──────┐   ┌──────┐   ┌──────┐
Inst 3                        │ FETCH│──▶│DECODE│──▶│EXECUTE│
                              └──────┘   └──────┘   └──────┘
                                         ┌──────┐   ┌──────┐   ┌──────┐
Inst 4                                   │ FETCH│──▶│DECODE│──▶│EXECUTE│
                                         └──────┘   └──────┘   └──────┘

FETCH   : lecture de l'instruction depuis la mémoire
DECODE  : décodage de l'instruction et lecture des opérandes
EXECUTE : exécution de l'opération et écriture du résultat

Grâce au pipeline, une instruction peut être exécutée à chaque cycle d'horloge (en régime permanent), permettant d'atteindre environ 1,25 DMIPS/MHz.

2.4 Registres du processeur

Le Cortex-M4 dispose de 16 registres de 32 bits accessibles directement par le programmeur :

Registres du Cortex-M4
┌─────────────────────────────────────────────────────────────┐
│                    REGISTRES CORTEX-M4                       │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   R0  ─────────┐                                             │
│   R1  ─────────┤                                             │
│   R2  ─────────┤    Registres généraux                       │
│   R3  ─────────┤    (usage libre, paramètres fonctions)      │
│   R4  ─────────┤                                             │
│   R5  ─────────┤                                             │
│   R6  ─────────┤                                             │
│   R7  ─────────┤                                             │
│   R8  ─────────┤                                             │
│   R9  ─────────┤                                             │
│   R10 ─────────┤                                             │
│   R11 ─────────┘                                             │
│                                                              │
│   R12 ──────────── IP  (Intra-Procedure scratch register)    │
│   R13 ──────────── SP  (Stack Pointer)                       │
│   R14 ──────────── LR  (Link Register - adresse retour)      │
│   R15 ──────────── PC  (Program Counter)                     │
│                                                              │
├─────────────────────────────────────────────────────────────┤
│                   REGISTRES SPÉCIAUX                         │
├─────────────────────────────────────────────────────────────┤
│   xPSR ─────────── Program Status Register                   │
│   PRIMASK ──────── Masque interruptions (niveau 1)           │
│   FAULTMASK ────── Masque fautes (niveau 2)                  │
│   BASEPRI ──────── Priorité de base des interruptions        │
│   CONTROL ──────── Contrôle du stack et privilèges           │
│                                                              │
├─────────────────────────────────────────────────────────────┤
│                   REGISTRES FPU (si présent)                 │
├─────────────────────────────────────────────────────────────┤
│   S0-S31 ───────── 32 registres simple précision (32 bits)   │
│   D0-D15 ───────── 16 registres double précision (64 bits)   │
│   FPSCR ────────── Floating-Point Status and Control         │
└─────────────────────────────────────────────────────────────┘

Registres spéciaux importants :

  • PC (R15) : contient l'adresse de l'instruction en cours + 4 (à cause du pipeline)
  • SP (R13) : pointeur de pile, deux piles possibles (MSP et PSP)
  • LR (R14) : stocke l'adresse de retour lors d'un appel de fonction
  • xPSR : contient les flags (N, Z, C, V) et le numéro d'exception
2.5 Modes de fonctionnement

Le Cortex-M4 possède deux modes d'exécution et deux niveaux de privilège :

Modes d'exécution :

  • Thread Mode : mode normal d'exécution du programme principal
  • Handler Mode : mode d'exécution des gestionnaires d'interruption

Niveaux de privilège :

  • Privileged : accès complet à toutes les ressources
  • Unprivileged : accès restreint (protection mémoire possible)
Basculement Thread ↔ Handler
                    RESET
                       │
                       ▼
            ┌─────────────────────┐
            │    THREAD MODE      │
            │    (Privileged)     │◀─────────────────┐
            │                     │                  │
            │  Programme principal│                  │
            └─────────┬───────────┘                  │
                      │                              │
                      │ Interruption                 │ Retour
                      │                              │
                      ▼                              │
            ┌─────────────────────┐                  │
            │    HANDLER MODE     │                  │
            │    (Privileged)     │──────────────────┘
            │                     │
            │ Routine interruption│
            └─────────────────────┘
2.6 Jeu d'instructions Thumb-2

Le Cortex-M4 utilise exclusivement le jeu d'instructions Thumb-2, qui combine des instructions 16 bits et 32 bits pour optimiser la densité du code et les performances.

Avantages de Thumb-2 :

  • Densité de code : instructions 16 bits pour les opérations courantes
  • Performance : instructions 32 bits pour les opérations complexes
  • Pas de changement de mode : contrairement aux anciens ARM
  • Alignement flexible : code aligné sur 16 bits
instructions_thumb2.sassembleur ARM
; Instructions arithmétiques
ADD  R0, R1, R2      ; R0 = R1 + R2
SUB  R0, R1, #10     ; R0 = R1 - 10
MUL  R0, R1, R2      ; R0 = R1 × R2
MLA  R0, R1, R2, R3  ; R0 = R1 × R2 + R3 (Multiply-Accumulate)

; Instructions logiques
AND  R0, R1, R2      ; R0 = R1 AND R2
ORR  R0, R1, R2      ; R0 = R1 OR R2
EOR  R0, R1, R2      ; R0 = R1 XOR R2
BIC  R0, R1, R2      ; R0 = R1 AND (NOT R2) — Bit Clear

; Instructions de décalage
LSL  R0, R1, #3      ; R0 = R1 << 3 (décalage gauche)
LSR  R0, R1, #3      ; R0 = R1 >> 3 (décalage droite logique)
ASR  R0, R1, #3      ; R0 = R1 >> 3 (décalage droite arithmétique)

; Instructions mémoire
LDR  R0, [R1]        ; charger 32 bits depuis l'adresse R1
STR  R0, [R1]        ; stocker R0 à l'adresse R1
LDRB R0, [R1]        ; charger 8 bits (byte)
LDRH R0, [R1]        ; charger 16 bits (half-word)

; Instructions de branchement
B    label           ; branchement inconditionnel
BEQ  label           ; branchement si égal (Z=1)
BNE  label           ; branchement si différent (Z=0)
BL   fonction        ; appel de fonction (sauvegarde LR)
BX   LR              ; retour de fonction
2.7 Le NVIC (Nested Vectored Interrupt Controller)

Le NVIC est le contrôleur d'interruptions intégré au cœur Cortex-M. Il gère toutes les interruptions du système de manière efficace et déterministe.

Caractéristiques du NVIC :

  • Jusqu'à 240 interruptions externes configurables
  • 16 niveaux de priorité programmables (0 = plus haute)
  • Interruptions imbriquées (nested) automatiques
  • Tail-chaining : enchaînement optimisé des interruptions
  • Late arrival : préemption pendant l'empilement
  • Latence déterministe : 12 cycles pour entrer dans le handler

Table des vecteurs d'interruption — elle se trouve au début de la mémoire Flash (adresse 0x00000000) et contient les adresses des handlers :

OffsetVecteurDescription
0x0000Initial SPValeur initiale du Stack Pointer
0x0004ResetAdresse du handler Reset
0x0008NMINon-Maskable Interrupt
0x000CHardFaultErreur matérielle grave
0x0010MemManageErreur de protection mémoire
0x0014BusFaultErreur de bus
0x0018UsageFaultInstruction invalide
0x002CSVCallAppel système (SVC)
0x0038PendSVPending Service Call
0x003CSysTickTimer système
0x0040+IRQ0, IRQ1…Interruptions périphériques

3. Architecture du STM32F4xx

Objectifs du chapitre

  • Comprendre l'architecture interne du STM32F4
  • Maîtriser la cartographie mémoire et les bus
  • Connaître le système d'horloge (RCC)
  • Identifier les périphériques disponibles
3.1 Vue d'ensemble du STM32F4

Le STM32F4 est un microcontrôleur complet intégrant de nombreux périphériques autour du cœur Cortex-M4 :

⚡

168-180 MHz

Fréquence CPU maximale

💾

1-2 Mo Flash

Mémoire programme

🧠

192-256 Ko SRAM

Mémoire données

📍

82-140 GPIO

Entrées / Sorties

🔢

FPU + DSP

Calcul flottant et signal

🔌

3,3 V

Alimentation (5 V tolérant)

Périphériques intégrés typiques (STM32F407) :

  • Timers : 2 avancés (TIM1, TIM8), 4 généraux 32 bits (TIM2, TIM5), 6 généraux 16 bits, 2 basiques
  • Communication : 4 USART, 2 UART, 3 SPI, 3 I2C, 2 CAN, 1 USB OTG
  • Analogique : 3 ADC 12 bits (24 canaux), 2 DAC 12 bits
  • DMA : 2 contrôleurs DMA (16 canaux total)
  • Autres : RTC, Watchdog, CRC, RNG (générateur aléatoire)
3.2 Diagramme bloc simplifié
Architecture interne du STM32F4xx
┌────────────────────────────────────────────────────────────────────────────┐
│                           STM32F4xx ARCHITECTURE                            │
├────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │                        ARM CORTEX-M4 CORE                            │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────────────────┐ │   │
│  │  │   CPU    │  │   FPU    │  │   MPU    │  │        NVIC          │ │   │
│  │  │ 168 MHz  │  │  Float   │  │ Protect  │  │   240 interrupts     │ │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └──────────────────────┘ │   │
│  └─────────────────────────────┬───────────────────────────────────────┘   │
│                                │                                            │
│  ══════════════════════════════╪════════════════════════════════════════   │
│              AHB Bus Matrix    │   (Advanced High-performance Bus)          │
│  ══════════════════════════════╪════════════════════════════════════════   │
│         │              │       │        │              │                    │
│    ┌────▼────┐   ┌─────▼─────┐ │  ┌─────▼─────┐  ┌────▼────┐              │
│    │  FLASH  │   │   SRAM    │ │  │   DMA1    │  │  DMA2   │              │
│    │  1-2 Mo │   │ 192-256Ko │ │  │ 8 streams │  │8 streams│              │
│    └─────────┘   └───────────┘ │  └───────────┘  └─────────┘              │
│                                │                                            │
│  ══════════════════════════════╪════════════════════════════════════════   │
│              AHB1              │                    AHB2                    │
│  ══════════════════════════════╪════════════════════════════════════════   │
│    │    │    │    │            │        │        │        │                │
│  ┌─▼─┐┌─▼─┐┌─▼─┐┌─▼─┐         │      ┌─▼──┐  ┌──▼──┐  ┌──▼──┐            │
│  │PA ││PB ││PC ││...│  GPIO    │      │USB │  │ RNG │  │DCMI │            │
│  └───┘└───┘└───┘└───┘         │      │OTG │  │     │  │     │            │
│                                │      └────┘  └─────┘  └─────┘            │
│  ══════════════════════════════╪════════════════════════════════════════   │
│              APB1 (42 MHz max) │              APB2 (84 MHz max)            │
│  ══════════════════════════════╪════════════════════════════════════════   │
│    │     │     │     │         │     │      │      │      │                │
│  ┌─▼──┐┌─▼──┐┌─▼──┐┌─▼──┐     │  ┌──▼──┐┌──▼──┐┌──▼──┐┌──▼──┐            │
│  │TIM2││UART││I2C1││SPI2│     │  │TIM1 ││USART││ SPI1││ ADC │            │
│  │-7  ││2-5 ││-3  ││-3  │     │  │TIM8 ││1,6  ││     ││1-3  │            │
│  └────┘└────┘└────┘└────┘     │  └─────┘└─────┘└─────┘└─────┘            │
│                    │           │                                            │
│                 ┌──▼──┐        │                                            │
│                 │ CAN │        │                                            │
│                 │ DAC │        │                                            │
│                 └─────┘        │                                            │
└────────────────────────────────────────────────────────────────────────────┘
3.3 Cartographie mémoire

L'espace d'adressage du Cortex-M4 est de 4 Go (32 bits), divisé en régions prédéfinies :

Carte mémoire du STM32F4
   Adresse          Taille      Région                    Contenu
┌──────────────┬─────────────┬────────────────────────────────────────┐
│ 0xFFFFFFFF   │             │                                        │
│              │   512 Mo    │  Vendor-specific                       │
│ 0xE0100000   │             │                                        │
├──────────────┼─────────────┼────────────────────────────────────────┤
│ 0xE00FFFFF   │             │  Private Peripheral Bus                │
│              │    1 Mo     │  (NVIC, SysTick, Debug)                │
│ 0xE0000000   │             │  Registres système Cortex-M            │
├──────────────┼─────────────┼────────────────────────────────────────┤
│ 0xDFFFFFFF   │             │                                        │
│              │   512 Mo    │  External Device                       │
│ 0xA0000000   │             │  (mémoire externe FSMC)                │
├──────────────┼─────────────┼────────────────────────────────────────┤
│ 0x9FFFFFFF   │             │                                        │
│              │   1 Go      │  External RAM                          │
│ 0x60000000   │             │  (SDRAM externe si présent)            │
├──────────────┼─────────────┼────────────────────────────────────────┤
│ 0x5FFFFFFF   │             │  AHB2 Peripherals                      │
│              │             │  (USB OTG, RNG, DCMI)                  │
│ 0x50000000   │   512 Mo    │                                        │
├──────────────┤ Periph.     ├────────────────────────────────────────┤
│ 0x4FFFFFFF   │             │  AHB1 Peripherals                      │
│              │             │  (GPIO, DMA, RCC, Flash)               │
│ 0x40020000   │             │                                        │
├──────────────┤             ├────────────────────────────────────────┤
│ 0x4001FFFF   │             │  APB2 Peripherals                      │
│              │             │  (USART1, SPI1, TIM1, ADC)             │
│ 0x40010000   │             │                                        │
├──────────────┤             ├────────────────────────────────────────┤
│ 0x4000FFFF   │             │  APB1 Peripherals                      │
│              │             │  (TIM2-7, UART, I2C, SPI2/3, CAN, DAC) │
│ 0x40000000   │             │                                        │
├──────────────┼─────────────┼────────────────────────────────────────┤
│ 0x3FFFFFFF   │             │                                        │
│              │   512 Mo    │  SRAM (données, variables)             │
│ 0x20000000   │             │  192 Ko pour F407                      │
├──────────────┼─────────────┼────────────────────────────────────────┤
│ 0x1FFFFFFF   │             │                                        │
│              │   512 Mo    │  Code (Flash, System memory)           │
│ 0x08000000   │             │  Programme utilisateur                 │
├──────────────┤             ├────────────────────────────────────────┤
│ 0x00000000   │             │  Aliased selon BOOT pins               │
└──────────────┴─────────────┴────────────────────────────────────────┘
Adresses importantes à retenir.
  • 0x08000000 : début de la Flash (programme)
  • 0x20000000 : début de la SRAM (données)
  • 0x40000000 : début des périphériques
  • 0xE0000000 : registres système Cortex-M
3.4 Système d'horloge (RCC)

Le RCC (Reset and Clock Control) gère toutes les horloges du système. Une bonne compréhension est essentielle car chaque périphérique nécessite que son horloge soit activée.

Sources d'horloge :

SourceNomFréquenceCaractéristiques
HSIHigh Speed Internal16 MHzRC interne, moins précis, démarrage rapide
HSEHigh Speed External4-26 MHzQuartz externe, très précis, utilisé pour PLL
LSILow Speed Internal32 kHzRC interne, pour watchdog et RTC
LSELow Speed External32,768 kHzQuartz externe, RTC précis
PLLPhase Locked LoopJusqu'à 180 MHzMultiplie la fréquence HSI ou HSE

Configuration PLL. Le PLL permet d'atteindre des fréquences élevées à partir de l'oscillateur. La formule est :

pll_config.cC / HAL
/* Formules de calcul du PLL */

f_VCO  = f_input × (PLLN / PLLM)    // fréquence VCO interne
f_PLL  = f_VCO  / PLLP                // horloge système (SYSCLK)
f_USB  = f_VCO  / PLLQ                // horloge USB (doit être 48 MHz)

/* Contraintes */
- PLLM : 2 à 63   (diviseur d'entrée)
- PLLN : 50 à 432 (multiplicateur)
- PLLP : 2, 4, 6 ou 8 (diviseur sortie principale)
- PLLQ : 2 à 15   (diviseur USB/SDIO)
- f_VCO doit être entre 100 MHz et 432 MHz

/* Exemple : HSE = 8 MHz → SYSCLK = 168 MHz */
PLLM = 8     // 8 MHz / 8 = 1 MHz (entrée PLL)
PLLN = 336   // 1 MHz × 336 = 336 MHz (VCO)
PLLP = 2     // 336 MHz / 2 = 168 MHz (SYSCLK)
PLLQ = 7     // 336 MHz / 7 = 48 MHz (USB)

Arbre d'horloge simplifié :

Clock tree STM32F4
   HSI (16 MHz) ─────┐
                     │    ┌─────┐
   HSE (8 MHz) ──────┴───▶│ PLL │────▶ PLLCLK (168 MHz)
                          └─────┘          │
                                           ▼
                                    ┌────────────┐
   HSI ─────────────────────────────┤  SW (MUX)  ├───▶ SYSCLK (168 MHz)
   HSE ─────────────────────────────┤            │
   PLLCLK ──────────────────────────┤            │
                                    └────────────┘
                                           │
                          ┌────────────────┼────────────────┐
                          ▼                ▼                ▼
                    ┌──────────┐    ┌──────────┐    ┌──────────┐
                    │ AHB /1   │    │ APB1 /4  │    │ APB2 /2  │
                    │ 168 MHz  │    │ 42 MHz   │    │ 84 MHz   │
                    └──────────┘    └──────────┘    └──────────┘
                          │                │                │
                    CPU, DMA        TIM2-7, UART      TIM1, SPI1
                    Flash, SRAM     I2C, SPI2/3       USART1, ADC
                    GPIO            CAN, DAC          TIM8-11
Activation obligatoire des horloges. Avant d'utiliser tout périphérique, il faut obligatoirement activer son horloge via le registre RCC. Sans cela, les registres du périphérique ne répondront pas.
clock_enable.cC / HAL
/* Activation des horloges périphériques en HAL */
__HAL_RCC_GPIOA_CLK_ENABLE();   // GPIO Port A
__HAL_RCC_GPIOB_CLK_ENABLE();   // GPIO Port B
__HAL_RCC_GPIOC_CLK_ENABLE();   // GPIO Port C
__HAL_RCC_USART2_CLK_ENABLE();  // USART2
__HAL_RCC_I2C1_CLK_ENABLE();    // I2C1
__HAL_RCC_SPI1_CLK_ENABLE();    // SPI1
__HAL_RCC_TIM2_CLK_ENABLE();    // Timer 2
__HAL_RCC_ADC1_CLK_ENABLE();    // ADC1
__HAL_RCC_DAC_CLK_ENABLE();     // DAC
__HAL_RCC_CAN1_CLK_ENABLE();    // CAN1
__HAL_RCC_DMA1_CLK_ENABLE();    // DMA1
3.5 Reset et modes de démarrage

Sources de reset :

  • Power-on Reset (POR) : à la mise sous tension
  • External Reset : pin NRST maintenu bas
  • Software Reset : via le registre AIRCR
  • Independent Watchdog (IWDG) : timer non rafraîchi
  • Window Watchdog (WWDG) : timer hors fenêtre
  • Low-Power Management : sortie de mode STANDBY

Modes de démarrage (Boot). Les pins BOOT0 et BOOT1 déterminent la source de démarrage :

BOOT1BOOT0Mode de démarrageDescription
X0Main FlashDémarre depuis la Flash utilisateur (normal)
01System MemoryDémarre le bootloader ST (pour programmation)
11Embedded SRAMDémarre depuis la RAM (pour debug)

4. STM32CubeIDE & CubeMX

Objectifs du chapitre

  • Installer et configurer STM32CubeIDE
  • Utiliser STM32CubeMX pour la configuration graphique
  • Comprendre la structure d'un projet HAL
  • Maîtriser le cycle de développement (compilation, debug)
4.1 Présentation des outils STM32

STMicroelectronics fournit un écosystème complet et gratuit pour le développement STM32 :

🔧

STM32CubeIDE

IDE complet basé sur Eclipse. Intègre éditeur, compilateur (GCC), débogueur, et CubeMX. C'est l'outil recommandé.

⚙️

STM32CubeMX

Outil de configuration graphique. Génère le code d'initialisation des périphériques à partir d'une interface visuelle.

📚

HAL Library

Hardware Abstraction Layer. Bibliothèque de fonctions pour accéder aux périphériques de manière portable.

📖

Documentation

Reference Manual, Datasheet, Application Notes disponibles sur st.com

Alternatives à STM32CubeIDE :

  • Keil MDK-ARM : IDE professionnel (payant, version gratuite limitée à 32 Ko)
  • IAR Embedded Workbench : IDE professionnel (payant)
  • PlatformIO + VS Code : extension populaire, gratuite
  • SW4STM32 : ancien IDE gratuit (remplacé par CubeIDE)
4.2 Configuration avec STM32CubeMX

STM32CubeMX permet de configurer visuellement tous les aspects du microcontrôleur :

Étapes de configuration :

  1. Sélection du MCU : choisir la référence exacte (ex : STM32F407VGT6)
  2. Configuration du Pinout : assigner les fonctions aux broches
  3. Configuration de l'horloge : Clock Configuration (Clock Tree)
  4. Configuration des périphériques : paramètres de chaque module
  5. Génération du code : projet complet avec initialisation

Onglets principaux de CubeMX :

OngletFonction
Pinout & ConfigurationVue du boîtier, affectation des pins, configuration des périphériques
Clock ConfigurationArbre d'horloge graphique, configuration PLL
Project ManagerNom du projet, IDE cible, options de génération
ToolsCalcul de consommation, vérification des conflits
4.3 Structure d'un projet HAL

Un projet généré par CubeMX a une structure standardisée :

arborescence projet CubeIDEarborescence
/* Arborescence typique d'un projet STM32CubeIDE */

MonProjet/
├── Core/
│   ├── Inc/                       // headers utilisateur
│   │   ├── main.h
│   │   ├── stm32f4xx_hal_conf.h  // configuration HAL
│   │   └── stm32f4xx_it.h        // prototypes handlers IT
│   │
│   └── Src/                       // sources utilisateur
│       ├── main.c                // programme principal
│       ├── stm32f4xx_it.c        // handlers d'interruption
│       ├── stm32f4xx_hal_msp.c   // init bas niveau (MSP)
│       ├── syscalls.c            // appels système
│       ├── sysmem.c              // gestion mémoire
│       └── system_stm32f4xx.c    // init système
│
├── Drivers/
│   ├── CMSIS/                    // définitions ARM standard
│   │   ├── Device/ST/STM32F4xx/
│   │   └── Include/
│   │
│   └── STM32F4xx_HAL_Driver/     // bibliothèque HAL
│       ├── Inc/                   // headers HAL
│       └── Src/                   // sources HAL
│
├── MonProjet.ioc                 // fichier de configuration CubeMX
├── STM32F407VGTX_FLASH.ld        // script de linkage
└── startup_stm32f407vgtx.s       // code de démarrage (assembleur)
4.4 Structure du fichier main.c
main.cC / HAL
/* main.c — structure typique */

#include "main.h"

/* USER CODE BEGIN PV — variables privées */
uint32_t counter = 0;
/* USER CODE END PV */

/* Prototypes des fonctions privées */
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_USART2_UART_Init(void);

int main(void)
{
    /* Reset de tous les périphériques, init Flash et SysTick */
    HAL_Init();

    /* Configuration de l'horloge système */
    SystemClock_Config();

    /* Initialisation des périphériques configurés */
    MX_GPIO_Init();
    MX_USART2_UART_Init();

    /* USER CODE BEGIN 2 — initialisation utilisateur */
    // votre code d'initialisation ici
    /* USER CODE END 2 */

    /* Boucle principale infinie */
    while (1)
    {
        /* USER CODE BEGIN 3 — code principal */
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
        HAL_Delay(500);  // délai 500 ms
        /* USER CODE END 3 */
    }
}

/**
 * @brief Configuration de l'horloge système
 */
void SystemClock_Config(void)
{
    /* Code généré par CubeMX — ne pas modifier */
    /* ... */
}
Règle cruciale : USER CODE. Écrivez uniquement entre les balises /* USER CODE BEGIN */ et /* USER CODE END */. Tout code en dehors sera écrasé lors de la régénération avec CubeMX.
4.5 Bibliothèque HAL

La HAL (Hardware Abstraction Layer) est la bibliothèque officielle de ST pour programmer les STM32. Elle offre une API portable entre les différentes familles.

Avantages de la HAL :

  • Abstraction : code indépendant des registres matériels
  • Portabilité : même API pour STM32F4, F7, L4, etc.
  • Documentation : bien documentée avec exemples
  • Support : maintenue et mise à jour par ST

Fonctions HAL courantes :

Délai bloquant en millisecondes
FonctionDescription
HAL_Init()Initialise HAL, Flash, SysTick
HAL_Delay(ms)
HAL_GetTick()Retourne le temps en ms depuis le démarrage
HAL_GPIO_Init()Configure un port GPIO
HAL_GPIO_WritePin()Écrit sur une broche
HAL_GPIO_ReadPin()Lit l'état d'une broche
HAL_GPIO_TogglePin()Inverse l'état d'une broche
HAL_UART_Transmit()Envoie des données par UART
HAL_UART_Receive()Reçoit des données par UART
HAL_ADC_Start()Démarre une conversion ADC
HAL_ADC_GetValue()Lit le résultat ADC
HAL_TIM_Base_Start()Démarre un timer
HAL_TIM_PWM_Start()Démarre une sortie PWM
4.6 Cycle de développement
Cycle de développement STM32
┌─────────────────────────────────────────────────────────────────────────┐
│                     CYCLE DE DÉVELOPPEMENT STM32                         │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│    ┌──────────────┐         ┌──────────────┐         ┌──────────────┐   │
│    │   1. SPEC    │────────▶│  2. CONFIG   │────────▶│   3. CODE    │   │
│    │   Cahier des │         │  STM32CubeMX │         │  Éditeur C   │   │
│    │   charges    │         │  Pinout+Clock│         │  main.c      │   │
│    └──────────────┘         └──────────────┘         └──────────────┘   │
│                                                              │           │
│                                                              ▼           │
│    ┌──────────────┐         ┌──────────────┐         ┌──────────────┐   │
│    │  6. DÉPLOY   │◀────────│   5. DEBUG   │◀────────│  4. BUILD    │   │
│    │  Production  │         │  ST-Link     │         │  Compilation │   │
│    │  sur cible   │         │  Breakpoints │         │  arm-gcc     │   │
│    └──────────────┘         └──────────────┘         └──────────────┘   │
│           │                        │                        │           │
│           │                        │                        │           │
│           └────────────────────────┼────────────────────────┘           │
│                                    │                                     │
│                              ┌─────▼─────┐                               │
│                              │  ITÉRER   │                               │
│                              │  Corriger │                               │
│                              │  Améliorer│                               │
│                              └───────────┘                               │
└─────────────────────────────────────────────────────────────────────────┘

Raccourcis clavier STM32CubeIDE :

RaccourciAction
Ctrl+BCompiler le projet (Build)
F11Déboguer (Debug)
Ctrl+F11Exécuter (Run)
F5Continuer (pendant debug)
F6Step Over (instruction suivante)
F7Step Into (entrer dans fonction)
Ctrl+Shift+BAjouter / retirer un breakpoint

5. GPIO & EXTI

Objectifs du chapitre

  • Comprendre l'organisation et la structure des GPIO
  • Maîtriser les différents modes de configuration
  • Programmer les GPIO avec la HAL et en accès direct aux registres
  • Configurer les interruptions externes (EXTI)
5.1 Organisation des GPIO

Les GPIO (General Purpose Input/Output) sont les broches d'entrée/sortie numériques du microcontrôleur. Sur le STM32F4, elles sont organisées en ports de 16 broches chacun.

Nomenclature :

gpio_naming.cC / HAL
/* Format : P + Lettre_Port + Numero_Pin */

PA0  = Port A, Broche 0     // pins 0 à 15
PB5  = Port B, Broche 5
PC13 = Port C, Broche 13    // souvent le bouton USER sur Nucleo
PD12 = Port D, Broche 12    // LED verte sur Discovery

/* STM32F407 : Ports A à I (9 ports × 16 pins = 144 pins max)
   Mais le nombre réel dépend du boîtier (64 à 176 pins) */

Caractéristiques électriques :

  • Tension : 0 V (LOW) à 3,3 V (HIGH)
  • 5 V tolérant : la plupart des pins acceptent 5 V en entrée
  • Courant de sortie : jusqu'à 25 mA par pin
  • Courant total : limité à 120 mA pour tout le boîtier
  • Impédance d'entrée : très haute (CMOS)
  • Pull-up / Pull-down internes : ~40 kΩ
5.2 Modes de configuration

Chaque broche GPIO peut être configurée dans l'un des 4 modes principaux :

Mode entrée (Input). La broche lit l'état logique externe.

gpio_input_modes.cC / HAL
/* La broche lit l'état logique externe */
                   VCC
                    │
              ┌─────┴─────┐
              │  Pull-up  │ (optionnel, ~40 kΩ interne)
              │ (interne) │
              └─────┬─────┘
                    │
    Signal ────────▶├────────▶ Registre IDR (lecture)
    externe         │
              ┌─────┴─────┐
              │ Pull-down │ (optionnel)
              └─────┬─────┘
                    │
                   GND

GPIO_MODE_INPUT  : entrée numérique
- GPIO_NOPULL    : haute impédance (flottant)
- GPIO_PULLUP    : résistance pull-up interne activée
- GPIO_PULLDOWN  : résistance pull-down interne activée

Mode sortie (Output). La broche impose un état logique.

gpio_output_modes.cC / HAL
GPIO_MODE_OUTPUT_PP : Push-Pull (le plus courant)
┌─────────────────────────────────────┐
│                VCC                   │
│                 │                    │
│            ┌────┴────┐               │
│            │ P-MOS   │◀── ODR=1 → ON │
│            └────┬────┬───────────► Sortie │
│            ┌────┴────┐               │
│            │ N-MOS   │◀── ODR=0 → ON │
│            └────┬────┬──────┘               │
│                 │                    │
│                GND                   │
└─────────────────────────────────────┘
→ peut fournir ET absorber du courant

GPIO_MODE_OUTPUT_OD : Open-Drain
┌─────────────────────────────────────┐
│           (pull-up externe)          │
│                 │                    │
│                 ├───────────► Sortie │
│            ┌────┴────┐               │
│            │ N-MOS   │◀── ODR=0 → ON │
│            └────┬────┬──────┘   (tire à GND)│
│                 │                    │
│                GND                   │
└─────────────────────────────────────┘
→ ne peut que tirer à la masse (nécessite pull-up externe)
→ utilisé pour I2C, bus partagés

Mode fonction alternée (Alternate Function). La broche est contrôlée par un périphérique interne.

gpio_af_modes.cC / HAL
/* La broche est contrôlée par un périphérique interne */

GPIO_MODE_AF_PP  : Alternate Function Push-Pull
GPIO_MODE_AF_OD  : Alternate Function Open-Drain

Exemples d'utilisation :
- USART TX/RX     → AF7 pour USART1/2/3
- SPI SCK/MOSI/MISO → AF5 pour SPI1/2
- I2C SDA/SCL     → AF4 (toujours en Open-Drain)
- Timer PWM       → AF1/AF2/AF3 selon le timer
- USB, CAN, etc.

Mode analogique. La broche est connectée à l'ADC ou DAC.

gpio_analog_mode.cC / HAL
GPIO_MODE_ANALOG : mode analogique
- désactive le buffer numérique
- réduit la consommation
- obligatoire pour ADC et DAC
5.3 Registres GPIO

Chaque port GPIO possède un ensemble de registres de configuration et de données :

RegistreNomTailleDescription
GPIOx_MODERMode32 bits2 bits/pin : Input(00), Output(01), AF(10), Analog(11)
GPIOx_OTYPEROutput Type16 bits1 bit/pin : Push-Pull(0), Open-Drain(1)
GPIOx_OSPEEDROutput Speed32 bits2 bits/pin : Low(00), Medium(01), High(10), VHigh(11)
GPIOx_PUPDRPull-up/Pull-down32 bits2 bits/pin : None(00), Pull-up(01), Pull-down(10)
GPIOx_IDRInput Data16 bitslecture seule : état des entrées
GPIOx_ODROutput Data16 bitslecture/écriture : état des sorties
GPIOx_BSRRBit Set/Reset32 bitsécriture atomique : bits [15:0]=set, [31:16]=reset
GPIOx_AFRL/HAlternate Function2 × 32 bits4 bits/pin : sélection AF0-AF15

Exemple de configuration directe par registres. Configuration de PA5 en sortie Push-Pull (LED) :

gpio_registers.cC / registres
/* Configuration de PA5 en sortie Push-Pull (LED) */

// 1. Activer l'horloge GPIOA
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;

// 2. Configurer PA5 en sortie (MODER5 = 01)
GPIOA->MODER &= ~(0x3 << (5 * 2));  // effacer bits 10-11
GPIOA->MODER |=  (0x1 << (5 * 2));  // mettre 01 (sortie)

// 3. Type Push-Pull (OTYPER5 = 0)
GPIOA->OTYPER &= ~(1 << 5);

// 4. Vitesse Low (OSPEEDR5 = 00)
GPIOA->OSPEEDR &= ~(0x3 << (5 * 2));

// 5. Pas de pull-up / pull-down (PUPDR5 = 00)
GPIOA->PUPDR &= ~(0x3 << (5 * 2));

/* Utilisation */
GPIOA->ODR |=  (1 << 5);    // LED ON
GPIOA->ODR &= ~(1 << 5);    // LED OFF
GPIOA->ODR ^=  (1 << 5);    // toggle

// Méthode atomique avec BSRR (recommandée)
GPIOA->BSRR = (1 << 5);          // LED ON  (bit 5 de BS)
GPIOA->BSRR = (1 << (5 + 16));   // LED OFF (bit 21 de BR)
5.4 Configuration avec HAL
gpio_hal.cC / HAL
/* Configuration d'une LED (PA5) et d'un bouton (PC13) avec HAL */

GPIO_InitTypeDef GPIO_InitStruct = {0};

/* Activer les horloges des ports */
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOC_CLK_ENABLE();

/* Configuration LED — PA5 en sortie Push-Pull */
GPIO_InitStruct.Pin   = GPIO_PIN_5;
GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
GPIO_InitStruct.Pull  = GPIO_NOPULL;
GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

/* Configuration bouton — PC13 en entrée avec pull-up */
GPIO_InitStruct.Pin   = GPIO_PIN_13;
GPIO_InitStruct.Mode  = GPIO_MODE_INPUT;
GPIO_InitStruct.Pull  = GPIO_PULLUP;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

/* Utilisation */

// Allumer la LED
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);

// Éteindre la LED
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_RESET);

// Inverser l'état
HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);

// Lire le bouton (actif bas)
if (HAL_GPIO_ReadPin(GPIOC, GPIO_PIN_13) == GPIO_PIN_RESET) {
    // bouton appuyé
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, GPIO_PIN_SET);
}
5.5 Interruptions externes (EXTI)

Les EXTI (External Interrupt) permettent de déclencher des interruptions sur changement d'état des GPIO, évitant le polling permanent.

Configuration d'une interruption sur bouton :

exti_button.cC / HAL
/* Configuration PC13 avec interruption sur front descendant */

GPIO_InitTypeDef GPIO_InitStruct = {0};

__HAL_RCC_GPIOC_CLK_ENABLE();

GPIO_InitStruct.Pin   = GPIO_PIN_13;
GPIO_InitStruct.Mode  = GPIO_MODE_IT_FALLING;  // interruption front descendant
GPIO_InitStruct.Pull  = GPIO_PULLUP;
HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

/* Configurer et activer l'interruption dans le NVIC */
HAL_NVIC_SetPriority(EXTI15_10_IRQn, 2, 0);   // priorité 2
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);

/* Modes d'interruption disponibles */
GPIO_MODE_IT_RISING          // front montant
GPIO_MODE_IT_FALLING         // front descendant
GPIO_MODE_IT_RISING_FALLING  // les deux fronts

Handler d'interruption. Dans stm32f4xx_it.c :

stm32f4xx_it.cC / IT
/* Handler d'interruption */
void EXTI15_10_IRQHandler(void)
{
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
}

/* Callback utilisateur dans main.c */
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    if (GPIO_Pin == GPIO_PIN_13)
    {
        // action lors de l'appui sur le bouton
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
    }
}
Anti-rebond (debouncing). Les boutons mécaniques génèrent des rebonds (transitions multiples). Utilisez un délai ou un timer pour filtrer les rebonds : static uint32_t last_press = 0;
if (HAL_GetTick() - last_press > 200) { /* action */ }
last_press = HAL_GetTick();

6. Timers & PWM

Objectifs du chapitre

  • Comprendre l'architecture des timers STM32
  • Configurer un timer en mode base de temps
  • Générer des signaux PWM
  • Utiliser les modes capture et comparaison
6.1 Types de timers

Le STM32F4 dispose de plusieurs types de timers avec des fonctionnalités différentes :

TypeTimersBitsCanauxFonctionnalités
AvancésTIM1, TIM8164 PWM complémentaire, dead-time, break, contrôle moteur
Généraux 32-bitTIM2, TIM5324 Compteur 32 bits, capture, PWM, encodeur
Généraux 16-bitTIM3, TIM4164 Capture, PWM, encodeur
GénérauxTIM9-TIM14161-2 PWM simple, capture
BasiquesTIM6, TIM7160 Base de temps uniquement, trigger DAC
6.2 Architecture d'un timer
Schéma interne d'un timer
┌─────────────────────────────────────────────────────────────────────────┐
│                         ARCHITECTURE TIMER                               │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│    Horloge APB    ┌──────────┐    ┌──────────┐                          │
│    (fAPB)    ────▶│   PSC    │───▶│   CNT    │───▶ Événements           │
│                   │ Prescaler│    │ Compteur │    (Update, CC)          │
│                   └──────────┘    └──────────┘                          │
│                        │              │  ▲                              │
│                        │              │  │                              │
│                        ▼              ▼  │                              │
│                   ┌────────────────────┐ │                              │
│                   │       ARR          │─┘                              │
│                   │ Auto-Reload (max)  │   Quand CNT = ARR → Reset      │
│                   └────────────────────┘                                │
│                                                                          │
│    Canaux de sortie :                                                    │
│    ┌────────────────────────────────────────────────────────────────┐   │
│    │  CCR1  │  CCR2  │  CCR3  │  CCR4  │  Capture/Compare Registers │   │
│    └────────────────────────────────────────────────────────────────┘   │
│        │        │        │        │                                      │
│        ▼        ▼        ▼        ▼                                      │
│    ┌──────┐ ┌──────┐ ┌──────┐ ┌──────┐                                  │
│    │ CH1  │ │ CH2  │ │ CH3  │ │ CH4  │  Sorties PWM / Captures          │
│    └──────┘ └──────┘ └──────┘ └──────┘                                  │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Registres principaux :

  • PSC (Prescaler) : divise l'horloge d'entrée (0 à 65 535)
  • CNT (Counter) : compteur actuel
  • ARR (Auto-Reload Register) : valeur maximale du compteur
  • CCRx (Capture/Compare Register) : valeur de comparaison pour chaque canal
6.3 Formules de calcul
timer_calc.cC / formules
/* Formules fondamentales des timers */

// Fréquence après prescaler
f_timer = f_APB / (PSC + 1)

// Période d'overflow (temps entre deux resets)
T_overflow = (ARR + 1) / f_timer
            = (ARR + 1) × (PSC + 1) / f_APB

// Fréquence d'overflow
f_overflow = f_APB / ((PSC + 1) × (ARR + 1))

/* Exemple : interruption toutes les 1 seconde */
// APB1 = 84 MHz pour TIM2-7 (avec prescaler ×2 si APB1 div > 1)
// On veut T = 1s, donc f = 1 Hz

// Méthode : choisir PSC pour avoir f_timer facile à diviser
PSC = 8399     // f_timer = 84 MHz / 8400 = 10 kHz
ARR = 9999     // f_overflow = 10 kHz / 10000 = 1 Hz

/* Exemple : PWM à 1 kHz avec résolution 1000 niveaux */
// On veut f_PWM = 1 kHz et 1000 niveaux de duty cycle
// f_PWM = f_APB / ((PSC+1) × (ARR+1))

ARR = 999       // 1000 niveaux (0 à 999)
PSC = 83        // f_timer = 84 MHz / 84 = 1 MHz
                 // f_PWM = 1 MHz / 1000 = 1 kHz ✓

// Duty cycle
Duty = CCR / (ARR + 1) × 100%
CCR = 500       // Duty = 500/1000 = 50 %
6.4 Mode base de temps avec interruption
tim2_base_it.cC / HAL
/* Configuration TIM2 pour interruption périodique de 1 seconde */

TIM_HandleTypeDef htim2;

void MX_TIM2_Init(void)
{
    __HAL_RCC_TIM2_CLK_ENABLE();

    htim2.Instance               = TIM2;
    htim2.Init.Prescaler         = 8399;           // 84 MHz / 8400 = 10 kHz
    htim2.Init.CounterMode       = TIM_COUNTERMODE_UP;
    htim2.Init.Period            = 9999;           // 10 kHz / 10000 = 1 Hz
    htim2.Init.ClockDivision     = TIM_CLOCKDIVISION_DIV1;
    htim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;

    HAL_TIM_Base_Init(&htim2);

    /* Activer l'interruption Update */
    HAL_NVIC_SetPriority(TIM2_IRQn, 1, 0);
    HAL_NVIC_EnableIRQ(TIM2_IRQn);
    HAL_TIM_Base_Start_IT(&htim2);
}

/* Handler d'interruption (stm32f4xx_it.c) */
void TIM2_IRQHandler(void)
{
    HAL_TIM_IRQHandler(&htim2);
}

/* Callback appelé toutes les secondes */
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
    if (htim->Instance == TIM2) {
        // Code exécuté toutes les 1 s
        HAL_GPIO_TogglePin(GPIOA, GPIO_PIN_5);
    }
}
6.5 PWM — Pulse Width Modulation

Le mode PWM permet de générer un signal de fréquence fixe dont le rapport cyclique (duty cycle) est variable. Très utilisé pour piloter des LEDs, des moteurs ou des servomoteurs.

tim3_pwm.cC / HAL PWM
/* PWM sur TIM3 Channel 1 (PA6) */

TIM_HandleTypeDef    htim3;
TIM_OC_InitTypeDef sConfigOC;

void MX_TIM3_PWM_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Activer les horloges
    __HAL_RCC_TIM3_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Configurer PA6 en Alternate Function (TIM3_CH1)
    GPIO_InitStruct.Pin       = GPIO_PIN_6;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_NOPULL;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF2_TIM3;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Configuration Timer — PWM 1 kHz
    htim3.Instance           = TIM3;
    htim3.Init.Prescaler     = 83;            // 84 MHz / 84 = 1 MHz
    htim3.Init.CounterMode   = TIM_COUNTERMODE_UP;
    htim3.Init.Period        = 999;            // 1 MHz / 1000 = 1 kHz
    htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    HAL_TIM_PWM_Init(&htim3);

    // Configuration du canal PWM
    sConfigOC.OCMode       = TIM_OCMODE_PWM1;
    sConfigOC.Pulse        = 500;            // duty cycle 50 %
    sConfigOC.OCPolarity   = TIM_OCPOLARITY_HIGH;
    sConfigOC.OCFastMode   = TIM_OCFAST_DISABLE;
    HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);

    // Démarrer le PWM
    HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
}

/* Modifier le duty cycle en temps réel */
void SetDutyCycle(uint16_t duty)  // duty : 0-1000
{
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, duty);
}

// Exemples d'utilisation
SetDutyCycle(0);      // 0 %
SetDutyCycle(250);    // 25 %
SetDutyCycle(500);    // 50 %
SetDutyCycle(750);    // 75 %
SetDutyCycle(1000);   // 100 %

7. ADC

Objectifs du chapitre

  • Comprendre le principe de conversion analogique-numérique
  • Configurer l'ADC du STM32F4
  • Réaliser des conversions simples et continues
  • Utiliser le DMA pour les acquisitions rapides
7.1 Principe de la conversion A/N

L'ADC (Analog to Digital Converter) convertit une tension analogique en une valeur numérique proportionnelle.

Principe de l'ADC
    Tension d'entrée              Valeur numérique

    VREF (3,3 V) ─────────────────── 4095 (0xFFF)
         │                            │
         │                            │
         │    ┌────────────────┐      │
    Vin ─┼───▶│      ADC       │──────┼──▶ Valeur
         │    │   12 bits      │      │    numérique
         │    └────────────────┘      │
         │                            │
    0 V ──┴───────────────────────────── 0 (0x000)


    Formule de conversion :

    ADC_Value = (Vin / VREF) × 4095

    Vin = (ADC_Value / 4095) × VREF

    Résolution = VREF / 4096 = 3,3 V / 4096 ≈ 0,8 mV
📏

12 bits

Résolution (0-4095)

⚡

2,4 MSPS

Vitesse max

📍

16 canaux

Par ADC (+ internes)

  • 3 ADC indépendants (ADC1, ADC2, ADC3)
  • Tension d'entrée : 0 V à VREF (généralement 3,3 V)
  • Modes : simple, continu, scan, discontinu
  • Déclenchement : logiciel ou hardware (Timer, EXTI)
  • Canaux internes : température, VREFINT, VBAT
7.2 Configuration et utilisation
adc1_basic.cC / HAL
/* Configuration ADC1 Channel 0 (PA0) — conversion simple */

ADC_HandleTypeDef       hadc1;
ADC_ChannelConfTypeDef sConfig;

void MX_ADC1_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Activer les horloges
    __HAL_RCC_ADC1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Configurer PA0 en mode analogique
    GPIO_InitStruct.Pin  = GPIO_PIN_0;
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Configuration ADC
    hadc1.Instance                   = ADC1;
    hadc1.Init.ClockPrescaler        = ADC_CLOCK_SYNC_PCLK_DIV4;
    hadc1.Init.Resolution            = ADC_RESOLUTION_12B;
    hadc1.Init.ScanConvMode          = DISABLE;          // un seul canal
    hadc1.Init.ContinuousConvMode    = DISABLE;          // conversion unique
    hadc1.Init.DiscontinuousConvMode = DISABLE;
    hadc1.Init.ExternalTrigConvEdge  = ADC_EXTERNALTRIGCONVEDGE_NONE;
    hadc1.Init.ExternalTrigConv      = ADC_SOFTWARE_START;
    hadc1.Init.DataAlign             = ADC_DATAALIGN_RIGHT;
    hadc1.Init.NbrOfConversion       = 1;
    hadc1.Init.DMAContinuousRequests = DISABLE;
    hadc1.Init.EOCSelection          = ADC_EOC_SINGLE_CONV;
    HAL_ADC_Init(&hadc1);

    // Configuration du canal
    sConfig.Channel      = ADC_CHANNEL_0;
    sConfig.Rank         = 1;
    sConfig.SamplingTime = ADC_SAMPLETIME_84CYCLES;
    HAL_ADC_ConfigChannel(&hadc1, &sConfig);
}

/* Fonction de lecture ADC */
uint16_t ReadADC(void)
{
    uint16_t adc_value;

    HAL_ADC_Start(&hadc1);                       // démarrer conversion
    HAL_ADC_PollForConversion(&hadc1, 100);      // attendre fin
    adc_value = HAL_ADC_GetValue(&hadc1);        // lire résultat
    HAL_ADC_Stop(&hadc1);                        // arrêter ADC

    return adc_value;
}

/* Conversion en tension */
float ADC_to_Voltage(uint16_t adc_value)
{
    return ((float)adc_value / 4095.0f) * 3.3f;
}

/* Utilisation */
uint16_t raw     = ReadADC();
float    voltage = ADC_to_Voltage(raw);  // en volts
7.3 Temps d'échantillonnage

Le temps d'échantillonnage détermine la durée pendant laquelle l'ADC capture le signal avant conversion. Un temps plus long est nécessaire pour les sources à haute impédance.

ConstanteCyclesTemps @21 MHzUsage
ADC_SAMPLETIME_3CYCLES30,14 µsSource basse impédance
ADC_SAMPLETIME_15CYCLES150,71 µsUsage général
ADC_SAMPLETIME_28CYCLES281,33 µsUsage général
ADC_SAMPLETIME_84CYCLES844,0 µsHaute impédance
ADC_SAMPLETIME_480CYCLES48022,9 µsTrès haute impédance
adc_calc.cC / formules
/* Temps total de conversion */
T_conv = T_sampling + 12 cycles (conversion successive approximation)

// Exemple avec 84 cycles de sampling à 21 MHz
T_conv = (84 + 12) / 21 MHz = 4,57 µs
f_max = 1 / T_conv ≈ 219 kSPS

8. DAC

Objectifs du chapitre

  • Comprendre le principe de conversion N/A
  • Configurer le DAC du STM32F4
  • Générer des tensions de sortie précises
  • Créer des formes d'onde (sinus, triangle)
8.1 Caractéristiques du DAC STM32F4

Le DAC (Digital to Analog Converter) génère une tension analogique proportionnelle à une valeur numérique.

📏

12 bits

Résolution (0-4095)

📍

2 canaux

DAC1 (PA4), DAC2 (PA5)

  • Tension de sortie : 0 V à VREF (3,3 V)
  • Impédance de sortie : ~15 kΩ (utiliser buffer opérationnel pour charge)
  • Temps de stabilisation : ~3 µs
  • Déclenchement : logiciel, Timer, EXTI
  • Générateurs intégrés : bruit, triangle
dac_formula.cC / formules
/* Formule de conversion */

V_out = (DAC_Value / 4095) × VREF

// Exemples avec VREF = 3,3 V
DAC_Value = 0     → V_out = 0 V
DAC_Value = 2048  → V_out = 1.65 V
DAC_Value = 4095  → V_out = 3.3 V

// Résolution
Résolution = 3,3 V / 4096 ≈ 0,8 mV
8.2 Configuration et utilisation
dac_output.cC / HAL
/* Configuration DAC Channel 1 (PA4) */

DAC_HandleTypeDef       hdac;
DAC_ChannelConfTypeDef sConfig;

void MX_DAC_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Activer les horloges
    __HAL_RCC_DAC_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Configurer PA4 en mode analogique
    GPIO_InitStruct.Pin  = GPIO_PIN_4;
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Configuration DAC
    hdac.Instance = DAC;
    HAL_DAC_Init(&hdac);

    // Configuration du canal
    sConfig.DAC_Trigger     = DAC_TRIGGER_NONE;        // pas de trigger
    sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE;
    HAL_DAC_ConfigChannel(&hdac, &sConfig, DAC_CHANNEL_1);

    // Démarrer le DAC
    HAL_DAC_Start(&hdac, DAC_CHANNEL_1);
}

/* Fonction pour définir la tension de sortie */
void DAC_SetVoltage(float voltage)
{
    uint16_t dac_value;

    // Limiter entre 0 et 3,3 V
    if (voltage < 0)     voltage = 0;
    if (voltage > 3.3f) voltage = 3.3f;

    // Convertir en valeur DAC
    dac_value = (uint16_t)((voltage / 3.3f) * 4095);

    HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1, DAC_ALIGN_12B_R, dac_value);
}

/* Exemples d'utilisation */
DAC_SetVoltage(0.0f);    // 0 V
DAC_SetVoltage(1.65f);   // 1,65 V (milieu)
DAC_SetVoltage(2.5f);    // 2,5 V
DAC_SetVoltage(3.3f);    // 3,3 V (max)

9. USART / UART

Objectifs du chapitre

  • Comprendre le principe de la transmission série asynchrone
  • Maîtriser le protocole RS232 et ses paramètres
  • Configurer l'USART du STM32F4
  • Implémenter la communication bidirectionnelle
9.1 Principe de la transmission série asynchrone

La transmission série asynchrone transmet les données bit par bit sur une seule ligne, sans signal d'horloge partagé. L'émetteur et le récepteur doivent être configurés avec les mêmes paramètres.

Trame UART
┌─────────────────────────────────────────────────────────────────────────┐
│                    CONNEXION UART SIMPLE                                 │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│    ┌──────────────┐                         ┌──────────────┐            │
│    │   DEVICE 1   │                         │   DEVICE 2   │            │
│    │   (STM32)    │         TX ────────────▶│              │            │
│    │              │◀──────────── RX         │   (PC/MCU)   │            │
│    │              │                         │              │            │
│    │         GND ─┼─────────────────────────┼─ GND         │            │
│    └──────────────┘                         └──────────────┘            │
│                                                                          │
│    Note : TX d'un appareil connecté au RX de l'autre (croisement)       │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────┐
│                      FORMAT D'UNE TRAME UART                             │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  Idle    Start                  Data Bits                    Parity Stop │
│  (HIGH)  Bit    D0   D1   D2   D3   D4   D5   D6   D7        (opt)  Bit │
│          │      │    │    │    │    │    │    │    │          │     │   │
│    ──────┐      │    │    │    │    │    │    │    │          │     ┌───│
│  HIGH    │      │    │    │    │    │    │    │    │          │     │   │
│          │      │    │    │    │    │    │    │    │          │     │   │
│  LOW     └──────┴────┴────┴────┴────┴────┴────┴────┴──────────┴─────┘   │
│                                                                          │
│  - Start Bit : toujours 0 (LOW) — signale le début                      │
│  - Data Bits : 8 bits (ou 7, 9) — LSB en premier                        │
│  - Parity    : optionnel — détection d'erreur simple                    │
│  - Stop Bit  : 1 ou 2 bits à HIGH — signale la fin                      │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘
9.2 Paramètres de communication

Baudrate (vitesse de transmission). Définit le nombre de bits transmis par seconde. Les deux appareils doivent utiliser le même baudrate.

BaudrateBits/sTemps par bitUsage typique
96009600 bps104 µsApplications lentes, GPS
1920019200 bps52 µsUsage général
3840038400 bps26 µsUsage général
5760057600 bps17 µsModems
115200115200 bps8,7 µsDebug, standard
230400230400 bps4,3 µsHaute vitesse
921600921600 bps1,1 µsTrès haute vitesse

Format de données courant :

uart_format.cC / notes
/* Configuration standard "8N1" */
- 8 bits de données
- No parity (pas de parité)
- 1 stop bit

/* Autres configurations possibles */
7E1 : 7 bits, parité paire, 1 stop
8E1 : 8 bits, parité paire, 1 stop
8O1 : 8 bits, parité impaire, 1 stop
8N2 : 8 bits, pas de parité, 2 stop bits

Parité :

  • None : pas de bit de parité
  • Even (paire) : le bit de parité rend le nombre total de 1 pair
  • Odd (impaire) : le bit de parité rend le nombre total de 1 impair
9.3 Norme RS232

La norme RS232 définit l'interface électrique pour la communication série. Elle utilise des niveaux de tension différents du TTL/CMOS.

CaractéristiqueTTL (STM32)RS232
Niveau logique HIGH3,3 V-3 V à -15 V
Niveau logique LOW0 V+3 V à +15 V
Distance max~1 m15 m
Débit maxPlusieurs Mbps~115 kbps
Adaptateur nécessaire. Pour connecter un STM32 (niveaux 3,3 V) à un port RS232 (niveaux ±12 V), il faut un convertisseur de niveau comme le MAX232 ou MAX3232. Ne jamais connecter directement sous peine de détruire le microcontrôleur.

Connecteur DB9 RS232 — brochage côté câble :

db9_pinout.txtmatériel
/* Brochage connecteur DB9 (vue côté câble) */

    ┌───────────────────────┐
    │  1   2   3   4   5    │
    │   ○   ○   ○   ○   ○   │
    │     ○   ○   ○   ○     │
    │     6   7   8   9     │
    └───────────────────────┘

Pin 2 : RXD  (Receive Data)
Pin 3 : TXD  (Transmit Data)
Pin 5 : GND  (Ground)
Pin 7 : RTS  (Request To Send) — contrôle de flux
Pin 8 : CTS  (Clear To Send)   — contrôle de flux
9.4 USART du STM32F4

Le STM32F4 possède plusieurs USART/UART avec des fonctionnalités avancées :

  • USART1, USART2, USART3 : complets avec support synchrone
  • UART4, UART5 : asynchrone uniquement
  • USART6 : complet

Fonctionnalités :

  • Full-duplex (émission et réception simultanées)
  • Baudrate programmable jusqu'à plusieurs Mbps
  • Parité programmable (paire, impaire, aucune)
  • 1 ou 2 stop bits
  • Contrôle de flux matériel (RTS/CTS)
  • Mode DMA pour transferts sans CPU
  • Interruptions sur TX/RX/erreurs

Pins USART (exemples STM32F4) :

USARTTXRXBusAF
USART1PA9PA10APB2AF7
USART2PA2PA3APB1AF7
USART3PB10PB11APB1AF7
USART6PC6PC7APB2AF8
9.5 Configuration et programmation USART
usart2_basic.cC / HAL
/* Configuration USART2 à 115200 bauds, 8N1 */

UART_HandleTypeDef huart2;

void MX_USART2_UART_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Activer les horloges
    __HAL_RCC_USART2_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Configurer PA2 (TX) et PA3 (RX) en Alternate Function
    GPIO_InitStruct.Pin       = GPIO_PIN_2 | GPIO_PIN_3;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_PULLUP;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF7_USART2;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Configuration UART
    huart2.Instance        = USART2;
    huart2.Init.BaudRate   = 115200;
    huart2.Init.WordLength = UART_WORDLENGTH_8B;
    huart2.Init.StopBits   = UART_STOPBITS_1;
    huart2.Init.Parity     = UART_PARITY_NONE;
    huart2.Init.Mode       = UART_MODE_TX_RX;
    huart2.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
    huart2.Init.OverSampling = UART_OVERSAMPLING_16;
    HAL_UART_Init(&huart2);
}

/* Transmission bloquante */
char message[] = "Hello STM32!\r\n";
HAL_UART_Transmit(&huart2, (uint8_t*)message, strlen(message), 1000);

/* Réception bloquante */
uint8_t rx_buffer[100];
HAL_UART_Receive(&huart2, rx_buffer, 10, 5000);  // 10 octets, timeout 5 s

/* Transmission d'un seul caractère */
uint8_t ch = 'A';
HAL_UART_Transmit(&huart2, &ch, 1, 100);
9.6 Réception par interruption

La réception par interruption est recommandée pour ne pas bloquer le programme principal.

usart2_rx_it.cC / HAL
/* Configuration réception par interruption */

uint8_t  rx_byte;
uint8_t  rx_buffer[256];
uint16_t rx_index = 0;

void StartUARTReception(void)
{
    // Configurer l'interruption NVIC
    HAL_NVIC_SetPriority(USART2_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(USART2_IRQn);

    // Démarrer la réception d'un octet
    HAL_UART_Receive_IT(&huart2, &rx_byte, 1);
}

/* Handler d'interruption (stm32f4xx_it.c) */
void USART2_IRQHandler(void)
{
    HAL_UART_IRQHandler(&huart2);
}

/* Callback de réception (main.c) */
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART2)
    {
        // Stocker l'octet reçu
        rx_buffer[rx_index++] = rx_byte;

        // Vérifier fin de ligne ou buffer plein
        if (rx_byte == '\n' || rx_index >= 255)
        {
            rx_buffer[rx_index] = '\0';   // terminer la chaîne
            // traiter la commande reçue...
            rx_index = 0;
        }

        // Relancer la réception
        HAL_UART_Receive_IT(&huart2, &rx_byte, 1);
    }
}
9.7 Fonction printf via UART

Il est pratique de rediriger printf() vers l'UART pour le debug :

syscalls.cC / syscall
/* Redirection de printf vers UART2 */
/* Ajouter dans main.c ou syscalls.c */

#include <stdio.h>

// Nécessaire pour la redirection
int __io_putchar(int ch)
{
    HAL_UART_Transmit(&huart2, (uint8_t*)&ch, 1, 100);
    return ch;
}

int _write(int file, char *ptr, int len)
{
    HAL_UART_Transmit(&huart2, (uint8_t*)ptr, len, 1000);
    return len;
}

/* Utilisation */
int   valeur  = 42;
float tension = 3.14;

printf("Valeur: %d\r\n", valeur);
printf("Tension: %.2f V\r\n", tension);
printf("ADC: %04X\r\n", adc_value);  // hexadécimal
\r\n pour le retour à la ligne. Utilisez \r\n (Carriage Return + Line Feed) pour assurer la compatibilité avec tous les terminaux série (Windows, Linux, Mac).

10. I2C

Objectifs du chapitre

  • Comprendre le protocole I2C et son fonctionnement
  • Maîtriser l'adressage et le format des trames
  • Configurer l'I2C du STM32F4
  • Communiquer avec des périphériques I2C
10.1 Présentation du bus I2C

L'I2C (Inter-Integrated Circuit), inventé par Philips, est un bus série synchrone bidirectionnel utilisant seulement 2 fils. Il permet de connecter plusieurs périphériques sur le même bus.

🔗

2 fils

SDA (données) + SCL (horloge)

📍

127 adresses

7 bits (ou 1024 en 10 bits)

Caractéristiques principales :

  • Synchrone : horloge partagée (SCL) générée par le maître
  • Multi-maîtres : plusieurs maîtres possibles sur le bus
  • Multi-esclaves : jusqu'à 127 périphériques (adressage 7 bits)
  • Bidirectionnel : même ligne pour lecture et écriture
  • Open-drain : nécessite des résistances pull-up
Topologie du bus I2C
┌─────────────────────────────────────────────────────────────────────────┐
│                         TOPOLOGIE BUS I2C                                │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│                         VCC (3,3 V)                                       │
│                           │  │                                           │
│                          ┌┴┐┌┴┐                                          │
│                    4,7 kΩ │ ││ │ 4,7 kΩ   (résistances pull-up)         │
│                          └┬┘└┬┘                                          │
│            ┌──────────────┼──┼──────────────┬────────────────┐          │
│   SDA ─────┤              │  │              │                │          │
│            │              │  │              │                │          │
│   SCL ─────┼──────────────┼──┤              │                │          │
│            │              │  │              │                │          │
│       ┌────┴────┐    ┌────┴──┴───┐    ┌────┴────┐    ┌──────┴─────┐    │
│       │  MAÎTRE │    │  ESCLAVE  │    │ ESCLAVE │    │   ESCLAVE  │    │
│       │  STM32  │    │  0x3C     │    │  0x50   │    │    0x68    │    │
│       │         │    │  (OLED)   │    │ (EEPROM)│    │   (MPU6050)│    │
│       └─────────┘    └───────────┘    └─────────┘    └────────────┘    │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘
10.2 Vitesses de communication
ModeVitesse SCLUsage
Standard Mode100 kHzCapteurs, EEPROM, compatible tous
Fast Mode400 kHzUsage courant, bon compromis
Fast Mode Plus1 MHzApplications rapides
High Speed Mode3,4 MHzHaute performance
Résistances pull-up. Les résistances pull-up sont obligatoires car les lignes sont en Open-Drain. Valeurs typiques : 4,7 kΩ pour 100-400 kHz, 2,2 kΩ pour les vitesses supérieures. Certaines cartes de développement les incluent déjà.
10.3 Protocole et format des trames
Trame I2C — écriture
┌─────────────────────────────────────────────────────────────────────────┐
│                      TRAME I2C — ÉCRITURE                                │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  │START│ ADRESSE 7 bits │R/W│ACK│   DATA    │ACK│   DATA    │ACK│STOP│  │
│  │  S  │ A6 A5 A4 A3 A2 A1 A0│ 0 │ A │ D7...D0 │ A │ D7...D0 │ A │ P │  │
│                                                                          │
│  START : SDA passe à LOW pendant que SCL est HIGH                       │
│  STOP  : SDA passe à HIGH pendant que SCL est HIGH                      │
│  R/W   : 0 = écriture (Master → Slave), 1 = lecture (Slave → Master)    │
│  ACK   : 0 = acknowledged (OK), 1 = NACK (erreur ou fin)                │
│                                                                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  Exemple : écrire 0x55 à l'adresse 0x3C                                  │
│                                                                          │
│  START │ 0 0 1 1 1 1 0 │ 0 │ACK│ 0 1 0 1 0 1 0 1 │ACK│ STOP             │
│        │  0x3C (7 bits) │ W │   │     0x55        │   │                  │
│                                                                          │
│  Note : l'adresse envoyée est (0x3C << 1) | 0 = 0x78                     │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Séquence typique d'écriture :

  1. Maître génère condition START
  2. Maître envoie adresse esclave + bit R/W = 0 (écriture)
  3. Esclave répond ACK
  4. Maître envoie octet de données
  5. Esclave répond ACK (pour chaque octet)
  6. Maître génère STOP
10.4 Adressage I2C

L'adresse I2C est sur 7 bits (étendable à 10 bits). Les adresses courantes sont souvent configurables par des broches sur le composant (A0, A1, A2) pour permettre plusieurs composants identiques sur le même bus.

Décalage d'adresse. En I2C, l'adresse est sur 7 bits mais la trame ajoute un bit R/W, ce qui donne 8 bits à envoyer. La HAL STM32 attend l'adresse déjà décalée à gauche, soit adresse_7bits << 1. Ne pas oublier ce décalage !
10.5 Configuration et utilisation en HAL
i2c1_main.cC / HAL
/* Configuration I2C1 sur PB8 (SCL) et PB9 (SDA) — 100 kHz */

I2C_HandleTypeDef hi2c1;

void MX_I2C1_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Activer les horloges
    __HAL_RCC_I2C1_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();

    // Configurer PB8 (SCL) et PB9 (SDA) en AF Open-Drain
    GPIO_InitStruct.Pin       = GPIO_PIN_8 | GPIO_PIN_9;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_OD;
    GPIO_InitStruct.Pull      = GPIO_NOPULL;        // pull-up externe obligatoire
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF4_I2C1;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    // Configuration I2C
    hi2c1.Instance             = I2C1;
    hi2c1.Init.ClockSpeed      = 100000;             // 100 kHz
    hi2c1.Init.DutyCycle       = I2C_DUTYCYCLE_2;
    hi2c1.Init.OwnAddress1     = 0;                   // adresse du STM32 (esclave)
    hi2c1.Init.AddressingMode  = I2C_ADDRESSINGMODE_7BIT;
    hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
    hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
    hi2c1.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE;
    HAL_I2C_Init(&hi2c1);
}
i2c1_io.cC / HAL
/* Écrire des données vers un esclave */
uint8_t tx_data[] = {0x00, 0xAE};  // [registre, valeur]
HAL_I2C_Master_Transmit(&hi2c1,
                         DEVICE_ADDR << 1,   // décalage à gauche !
                         tx_data,
                         2,                   // 2 octets
                         100);                 // timeout 100 ms

/* Lire des données depuis un esclave */
uint8_t rx_data[6];
HAL_I2C_Master_Receive(&hi2c1,
                        DEVICE_ADDR << 1 | 0x01,  // bit R/W = 1
                        rx_data,
                        6,                   // 6 octets
                        100);

/* Écrire dans un registre spécifique */
uint8_t reg_addr = 0x20;
uint8_t value    = 0x77;
HAL_I2C_Mem_Write(&hi2c1,
                   DEVICE_ADDR << 1,
                   reg_addr,                  // adresse du registre
                   I2C_MEMADD_SIZE_8BIT,  // taille adresse : 8 bits
                   &value,
                   1,                     // 1 octet
                   100);

/* Lire un registre spécifique */
uint8_t temp_data[2];
HAL_I2C_Mem_Read(&hi2c1,
                  DEVICE_ADDR << 1,
                  0x00,                  // registre à lire
                  I2C_MEMADD_SIZE_8BIT,
                  temp_data,
                  2,                     // 2 octets
                  100);

/* Vérifier si un périphérique est présent */
if (HAL_I2C_IsDeviceReady(&hi2c1, DEVICE_ADDR << 1, 3, 100) == HAL_OK)
{
    // périphérique détecté à l'adresse DEVICE_ADDR
}
Décalage de l'adresse. La HAL STM32 attend l'adresse sur 8 bits (adresse 7 bits décalée à gauche + bit R/W). Multipliez toujours l'adresse 7 bits par 2 ou utilisez << 1.
10.6 Scanner I2C

Utile pour trouver les adresses des périphériques connectés :

i2c_scanner.cC / outils
/* Fonction pour scanner le bus I2C */
void I2C_Scanner(void)
{
    uint8_t devices_found = 0;

    printf("Scanning I2C bus...\r\n");

    for (uint8_t addr = 0x08; addr < 0x78; addr++)
    {
        if (HAL_I2C_IsDeviceReady(&hi2c1, addr << 1, 1, 10) == HAL_OK)
        {
            printf("Device found at 0x%02X\r\n", addr);
            devices_found++;
        }
    }

    printf("Scan complete. %d device(s) found.\r\n", devices_found);
}

Adresses I2C courantes :

AdressePériphérique
0x3C / 0x3DÉcran OLED SSD1306
0x50 - 0x57EEPROM 24Cxx
0x68 / 0x69MPU6050, DS1307 RTC
0x76 / 0x77BME280, BMP280
0x27 / 0x3FLCD I2C PCF8574
0x48 - 0x4BADS1115 ADC

11. SPI

Objectifs du chapitre

  • Comprendre le fonctionnement du bus SPI
  • Maîtriser les modes de polarité et phase (CPOL/CPHA)
  • Configurer le SPI du STM32F4
  • Communiquer avec des périphériques SPI
11.1 Présentation du bus SPI

Le SPI (Serial Peripheral Interface) est un bus série synchrone full-duplex développé par Motorola. C'est le protocole le plus rapide des bus série couramment utilisés.

🔗

4 fils

MOSI, MISO, SCK, CS

⚡

Très rapide

Jusqu'à 50+ MHz

↔️

Full-duplex

TX et RX simultanés

Signaux SPI :

SignalNom completDirection (Maître)Description
MOSIMaster Out Slave InSortie →Données du maître vers l'esclave
MISOMaster In Slave Out← EntréeDonnées de l'esclave vers le maître
SCK/SCLKSerial ClockSortie →Horloge générée par le maître
CS/SS/NSSChip Select / Slave SelectSortie →Sélection de l'esclave (actif bas)
Topologie SPI multi-esclaves
┌─────────────────────────────────────────────────────────────────────────┐
│                         TOPOLOGIE BUS SPI                                │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│                 ┌──────────────┐                                         │
│                 │    MAÎTRE    │                                         │
│                 │    (STM32)   │                                         │
│                 └──────┬───────┘                                         │
│                        │                                                 │
│        ┌───────────────┼───────────────┬───────────────┐                │
│        │               │               │               │                │
│      MOSI            MISO            SCK        CS0  CS1  CS2           │
│        │               │               │         │    │    │            │
│        │    ┌──────────┼───────────────┼─────────┤    │    │            │
│        ▼    │          │               │         │    │    │            │
│      ──┬────┼──────────┼───────────────┼─────────┼────┼────┼──          │
│        │    │          │               │         │    │    │            │
│   ┌────┴────┴───┐ ┌────┴────┴───┐ ┌────┴────┴───┐                       │
│   │  ESCLAVE 1  │ │  ESCLAVE 2  │ │  ESCLAVE 3  │                       │
│   │  (Flash)    │ │  (ADC)      │ │  (LCD)      │                       │
│   └─────────────┘ └─────────────┘ └─────────────┘                       │
│                                                                          │
│   Note : un seul CS actif (LOW) à la fois pour sélectionner l'esclave    │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘
11.2 Modes SPI (CPOL/CPHA)

Le SPI définit 4 modes de fonctionnement basés sur la polarité de l'horloge (CPOL) et la phase d'échantillonnage (CPHA) :

ModeCPOLCPHAHorloge au reposÉchantillonnage
Mode 000LOWFront montant
Mode 101LOWFront descendant
Mode 210HIGHFront descendant
Mode 311HIGHFront montant
Chronogrammes SPI
MODE 0 (CPOL=0, CPHA=0) — le plus courant
─────────────────────────────────────────
SCK     ____┌──┐__┌──┐__┌──┐__┌──┐__┌──┐__┌──┐__┌──┐__┌──┐____
            │  │  │  │  │  │  │  │  │  │  │  │  │  │  │  │
MOSI/   ────X──┴──X──┴──X──┴──X──┴──X──┴──X──┴──X──┴──X──┴────
MISO        D7    D6    D5    D4    D3    D2    D1    D0
            ▲     ▲     ▲     ▲     ▲     ▲     ▲     ▲
            │     │     │     │     │     │     │     │
        Échantillonnage sur front MONTANT

MODE 3 (CPOL=1, CPHA=1)
─────────────────────────────────────────
SCK     ────┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌──┐  ┌────
            └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  └──┘  └──┘
MOSI/   ────X──┴──X──┴──X──┴──X──┴──X──┴──X──┴──X──┴──X──┴────
MISO        D7    D6    D5    D4    D3    D2    D1    D0
               ▲     ▲     ▲     ▲     ▲     ▲     ▲     ▲
               │     │     │     │     │     │     │     │
           Échantillonnage sur front MONTANT
Mode le plus courant. Le Mode 0 (CPOL=0, CPHA=0) est le plus utilisé. Consultez toujours la datasheet du périphérique pour connaître le mode requis.
11.3 Configuration SPI STM32F4
spi1_init.cC / HAL
/* Configuration SPI1 — Mode Master */
/* PA5=SCK, PA6=MISO, PA7=MOSI, PA4=CS (GPIO manuel) */

SPI_HandleTypeDef hspi1;

void MX_SPI1_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Activer les horloges
    __HAL_RCC_SPI1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Configurer PA5 (SCK), PA6 (MISO), PA7 (MOSI) en AF
    GPIO_InitStruct.Pin       = GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_NOPULL;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF5_SPI1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Configurer PA4 (CS) en sortie GPIO
    GPIO_InitStruct.Pin   = GPIO_PIN_4;
    GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;
    GPIO_InitStruct.Pull  = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // CS désactivé au départ (HIGH)
    HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET);

    // Configuration SPI
    hspi1.Instance               = SPI1;
    hspi1.Init.Mode              = SPI_MODE_MASTER;
    hspi1.Init.Direction         = SPI_DIRECTION_2LINES;       // full duplex
    hspi1.Init.DataSize          = SPI_DATASIZE_8BIT;
    hspi1.Init.CLKPolarity       = SPI_POLARITY_LOW;           // CPOL = 0
    hspi1.Init.CLKPhase          = SPI_PHASE_1EDGE;            // CPHA = 0
    hspi1.Init.NSS               = SPI_NSS_SOFT;                // CS manuel
    hspi1.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16;     // ~5 MHz
    hspi1.Init.FirstBit          = SPI_FIRSTBIT_MSB;
    hspi1.Init.TIMode            = SPI_TIMODE_DISABLE;
    hspi1.Init.CRCCalculation    = SPI_CRCCALCULATION_DISABLE;
    HAL_SPI_Init(&hspi1);
}

Calcul du baudrate SPI — SPI1 est sur APB2 (84 MHz max) :

spi_baud.cC / formules
/* SPI1 est sur APB2 (84 MHz max) */
f_SPI = f_APB2 / Prescaler

Prescaler = 2, 4, 8, 16, 32, 64, 128, 256

// Exemples avec APB2 = 84 MHz
SPI_BAUDRATEPRESCALER_2    → 42 MHz
SPI_BAUDRATEPRESCALER_4    → 21 MHz
SPI_BAUDRATEPRESCALER_8    → 10.5 MHz
SPI_BAUDRATEPRESCALER_16   → 5.25 MHz
SPI_BAUDRATEPRESCALER_32   → 2.625 MHz
11.4 Communication SPI avec HAL
spi1_io.cC / HAL
/* Macros pour le Chip Select */
#define CS_LOW()   HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_RESET)
#define CS_HIGH()  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4, GPIO_PIN_SET)

/* Transmission seule */
uint8_t tx_data[] = {0x9F};  // commande
CS_LOW();
HAL_SPI_Transmit(&hspi1, tx_data, 1, 100);
CS_HIGH();

/* Réception seule */
uint8_t rx_data[4];
CS_LOW();
HAL_SPI_Receive(&hspi1, rx_data, 4, 100);
CS_HIGH();

/* Transmission et réception simultanées (Full Duplex) */
uint8_t tx_buf[4] = {0x9F, 0x00, 0x00, 0x00};
uint8_t rx_buf[4];
CS_LOW();
HAL_SPI_TransmitReceive(&hspi1, tx_buf, rx_buf, 4, 100);
CS_HIGH();

/* Exemple : lire l'ID d'une mémoire Flash SPI */
uint8_t Flash_ReadID(void)
{
    uint8_t cmd = 0x9F;          // commande JEDEC ID
    uint8_t id[3];

    CS_LOW();
    HAL_SPI_Transmit(&hspi1, &cmd, 1, 100);
    HAL_SPI_Receive(&hspi1, id, 3, 100);
    CS_HIGH();

    // id[0] = Manufacturer, id[1] = Type, id[2] = Capacity
    return id[0];
}
11.5 Comparaison SPI vs I2C
CaractéristiqueSPII2C
Nombre de fils4 (MOSI, MISO, SCK, CS)2 (SDA, SCL)
Vitesse max~50 MHz et plus3,4 MHz (High Speed)
DuplexFull duplexHalf duplex
AdressagePar ligne CS (1 par esclave)7/10 bits (127/1024 adresses)
Multi-maîtresComplexe à implémenterNatif avec arbitrage
ComplexitéSimple (pas de protocole)Plus complexe (ACK, adresses)
ConsommationPlus élevéePlus faible
DistanceCourte (~10 cm)Moyenne (~1 m)
Usage typiqueFlash, SD Card, LCD, ADC rapidesCapteurs, EEPROM, OLED

12. Bus CAN

Objectifs du chapitre

  • Comprendre l'architecture et le principe du bus CAN
  • Identifier la connectique et les niveaux électriques
  • Maîtriser la structure des trames de données et de contrôle
  • Connaître l'identifiant, l'arbitrage et le protocole d'échange
12.1 Introduction au bus CAN

Le CAN (Controller Area Network) est un protocole de communication série développé par Bosch dans les années 1980 pour l'industrie automobile. Il est devenu un standard ISO (ISO 11898) utilisé dans de nombreux domaines.

🔗

2 fils

CAN_H et CAN_L (différentiel)

⚡

1 Mbps

Vitesse max (High Speed)

📍

Multi-maîtres

Tous les nœuds peuvent émettre

  • Robuste : transmission différentielle, immunité au bruit
  • Fiable : détection d'erreurs intégrée (CRC, ACK, bit stuffing)
  • Déterministe : arbitrage non destructif basé sur la priorité
  • Broadcast : tous les nœuds reçoivent tous les messages
  • Distance : jusqu'à 1 km à 50 kbps, 40 m à 1 Mbps

Applications du CAN :

  • Automobile : moteur, ABS, airbag, tableau de bord, OBD-II
  • Industriel : CANopen, DeviceNet (automates, capteurs)
  • Médical : équipements hospitaliers
  • Aéronautique : avionique
  • Marine : NMEA 2000 (navigation)
12.2 Architecture et connectique
Topologie du bus CAN
┌─────────────────────────────────────────────────────────────────────────┐
│                         TOPOLOGIE BUS CAN                                │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   Terminaison                                            Terminaison     │
│      120 Ω                                                  120 Ω       │
│      ┌───┐                                                  ┌───┐       │
│   ───┤   ├──┬───────┬───────┬───────┬───────┬───────┬──────┤   ├───    │
│      └───┘  │       │       │       │       │       │      └───┘       │
│   CAN_H ────┼───────┼───────┼───────┼───────┼───────┼─────────────     │
│             │       │       │       │       │       │                   │
│   CAN_L ────┼───────┼───────┼───────┼───────┼───────┼─────────────     │
│             │       │       │       │       │       │                   │
│          ┌──┴──┐ ┌──┴──┐ ┌──┴──┐ ┌──┴──┐ ┌──┴──┐ ┌──┴──┐              │
│          │Node1│ │Node2│ │Node3│ │Node4│ │Node5│ │Node6│              │
│          │ ECU │ │Capt.│ │Motor│ │Dash │ │ ABS │ │Airbag│             │
│          └─────┘ └─────┘ └─────┘ └─────┘ └─────┘ └─────┘              │
│                                                                          │
│   Note : résistances de terminaison 120 Ω aux deux extrémités            │
│         câble torsadé, longueur totale dépend du débit                   │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Niveaux électriques (CAN High Speed - ISO 11898-2) :

ÉtatCAN_HCAN_LDifférence (CAN_H - CAN_L)
Récessif (1)2,5 V2,5 V0 V
Dominant (0)3,5 V1,5 V2 V
Niveaux électriques CAN
      Tension
        │
    3,5V├──────────────────────┐
        │      CAN_H           │       CAN_H
    2,5V├──────┐       ┌───────┴───────┐       ┌───────
        │      │       │               │       │
    1,5V├──────┴───────┘               └───────┴───────
        │      CAN_L           CAN_L
        │
        └──────────────────────────────────────────────▶ Temps
              │                │               │
            Dominant         Récessif       Dominant
              (0)              (1)            (0)
Transceiver CAN obligatoire. Le STM32 possède un contrôleur CAN mais pas de transceiver. Il faut ajouter un circuit externe (MCP2551, SN65HVD230, TJA1050) pour convertir les niveaux logiques en niveaux différentiels CAN.
12.3 Structure des trames CAN

Le protocole CAN définit plusieurs types de trames. La plus importante est la trame de données :

Trame de données (Data Frame)

Trame de données CAN 2.0A
┌─────────────────────────────────────────────────────────────────────────┐
│                    TRAME DE DONNÉES CAN 2.0A (Standard)                  │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  │SOF│  IDENTIFIANT  │RTR│IDE│r0│  DLC  │   DATA (0-8 octets)  │  CRC  │
│  │ 1 │    11 bits    │ 1 │ 1 │1 │ 4 bits│     0-64 bits        │15+1+1 │
│                                                                          │
│  │ACK│ EOF │ IFS │                                                       │
│  │ 2 │  7  │  3  │                                                       │
│                                                                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  SOF : Start Of Frame (bit dominant, synchronisation)                   │
│  ID  : Identifiant du message (11 bits = 0-2047, définit la priorité)   │
│  RTR : Remote Transmission Request (0=Data, 1=Remote)                   │
│  IDE : Identifier Extension (0=Standard 11 bits, 1=Extended 29 bits)    │
│  r0  : Réservé (dominant)                                               │
│  DLC : Data Length Code (0-8, nombre d'octets de données)               │
│  DATA: Données utiles (0 à 8 octets)                                    │
│  CRC : Cyclic Redundancy Check (15 bits + délimiteur)                   │
│  ACK : Acknowledgement (2 bits, confirmé par les récepteurs)            │
│  EOF : End Of Frame (7 bits récessifs)                                  │
│  IFS : Inter-Frame Space (3 bits, espacement entre trames)              │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Trame étendue CAN 2.0B. La version étendue utilise un identifiant de 29 bits au lieu de 11 bits, permettant plus de messages uniques (2²⁹ = 536 millions).

Autres types de trames :

TypeDescription
Data FrameTrame de données (0-8 octets)
Remote FrameDemande de données (pas de champ DATA)
Error FrameSignale une erreur détectée
Overload FrameDemande de délai entre trames
12.4 Identifiant et arbitrage

L'identifiant joue deux rôles fondamentaux :

  • Identification du message : il identifie le type de données (ex : vitesse moteur, température…)
  • Priorité : plus l'ID est bas, plus la priorité est haute

Mécanisme d'arbitrage non destructif. Quand plusieurs nœuds émettent simultanément, l'arbitrage se fait bit à bit :

Arbitrage CAN bit à bit
                    Arbitrage bit à bit

Bus CAN     ────────────────────────────────────────────────

Nœud A      ID = 0x100 = 001 0000 0000
(ID:0x100)  Bit:  0   0   1   ←── perd l'arbitrage (lit 0, a envoyé 1)
                  ↓   ↓   ↓
            ─────┬───┬───┬───
                 │ 0 │ 0 │ 1 │  ← continue à lire, arrête d'émettre
                 └───┴───┴───┘

Nœud B      ID = 0x080 = 000 1000 0000
(ID:0x080)  Bit:  0   0   0   ←── gagne (ID plus bas = prioritaire)
                  ↓   ↓   ↓
            ─────┬───┬───┬───
                 │ 0 │ 0 │ 0 │  ← continue à émettre
                 └───┴───┴───┘

Bus réel :  ─────┬───┬───┬───
                 │ 0 │ 0 │ 0 │  (dominant gagne sur récessif)
                 └───┴───┴───┘

→ Le bit DOMINANT (0) l'emporte toujours sur le bit RÉCESSIF (1)
→ L'ID le plus bas est donc le plus prioritaire
Arbitrage non destructif. L'arbitrage CAN est dit « non destructif » car le message du nœud gagnant n'est pas altéré. Les nœuds perdants se retirent et retentent automatiquement leur émission.
12.5 Protocole d'échange et filtrage

Communication broadcast. En CAN, tous les nœuds reçoivent tous les messages. Chaque nœud décide localement quels messages il accepte grâce aux filtres d'acceptance.

Filtrage des messages CAN
┌─────────────────────────────────────────────────────────────────────────┐
│                      FILTRAGE DES MESSAGES CAN                           │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│   Émetteur envoie :  ID = 0x123, Data = "Temperature = 25°C"           │
│                                                                          │
│   ───────────────────────────────────────────────────────────────       │
│                  │           │           │           │                   │
│               ┌──┴──┐     ┌──┴──┐     ┌──┴──┐     ┌──┴──┐              │
│               │Node1│     │Node2│     │Node3│     │Node4│              │
│               │Filtre│    │Filtre│    │Filtre│    │Filtre│             │
│               │0x1xx│     │0x200│     │0x123│     │0x4xx│             │
│               └──┬──┘     └──┬──┘     └──┬──┘     └──┬──┘              │
│                  │           │           │           │                   │
│                  ✓           ✗           ✓           ✗                   │
│               Accepte     Rejette    Accepte     Rejette                │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Détection d'erreurs. Le CAN intègre 5 mécanismes de détection d'erreurs :

  • Bit Error : différence entre bit émis et bit lu
  • Stuff Error : plus de 5 bits consécutifs identiques
  • CRC Error : erreur de checksum
  • Form Error : violation du format de trame
  • ACK Error : pas d'acquittement reçu
12.6 Configuration CAN STM32F4
can1_init.cC / HAL
/* Configuration CAN1 sur PA11 (RX) et PA12 (TX) */
/* Nécessite un transceiver externe (MCP2551, TJA1050...) */

CAN_HandleTypeDef  hcan1;
CAN_FilterTypeDef canFilter;

void MX_CAN1_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // Activer les horloges
    __HAL_RCC_CAN1_CLK_ENABLE();
    __HAL_RCC_GPIOA_CLK_ENABLE();

    // Configurer PA11 (RX) et PA12 (TX)
    GPIO_InitStruct.Pin       = GPIO_PIN_11 | GPIO_PIN_12;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_NOPULL;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Alternate = GPIO_AF9_CAN1;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Configuration CAN — 500 kbps (APB1 = 42 MHz)
    // Baudrate = APB1 / (Prescaler × (1 + BS1 + BS2))
    // 500 k = 42 M / (6 × (1 + 7 + 6)) = 42 M / 84 = 500 kbps
    hcan1.Instance             = CAN1;
    hcan1.Init.Prescaler      = 6;
    hcan1.Init.Mode           = CAN_MODE_NORMAL;
    hcan1.Init.SyncJumpWidth  = CAN_SJW_1TQ;
    hcan1.Init.TimeSeg1       = CAN_BS1_7TQ;
    hcan1.Init.TimeSeg2       = CAN_BS2_6TQ;
    hcan1.Init.TimeTriggeredMode   = DISABLE;
    hcan1.Init.AutoBusOff          = ENABLE;
    hcan1.Init.AutoWakeUp          = DISABLE;
    hcan1.Init.AutoRetransmission  = ENABLE;
    hcan1.Init.ReceiveFifoLocked   = DISABLE;
    hcan1.Init.TransmitFifoPriority = DISABLE;
    HAL_CAN_Init(&hcan1);

    // Configuration du filtre (accepter tous les messages)
    canFilter.FilterBank           = 0;
    canFilter.FilterMode           = CAN_FILTERMODE_IDMASK;
    canFilter.FilterScale          = CAN_FILTERSCALE_32BIT;
    canFilter.FilterIdHigh         = 0x0000;
    canFilter.FilterIdLow          = 0x0000;
    canFilter.FilterMaskIdHigh     = 0x0000;
    canFilter.FilterMaskIdLow      = 0x0000;
    canFilter.FilterFIFOAssignment = CAN_RX_FIFO0;
    canFilter.FilterActivation     = ENABLE;
    HAL_CAN_ConfigFilter(&hcan1, &canFilter);

    // Démarrer le CAN
    HAL_CAN_Start(&hcan1);
}
12.7 Émission et réception CAN
can1_txrx.cC / HAL
/* Envoi d'un message CAN */
CAN_TxHeaderTypeDef TxHeader;
uint8_t            TxData[8];
uint32_t           TxMailbox;

void CAN_SendMessage(uint16_t id, uint8_t *data, uint8_t len)
{
    TxHeader.StdId              = id;     // identifiant standard 11 bits
    TxHeader.ExtId              = 0;    // non utilisé en mode standard
    TxHeader.IDE                = CAN_ID_STD;        // format standard
    TxHeader.RTR                = CAN_RTR_DATA;      // trame de données
    TxHeader.DLC                = len;    // nombre d'octets (0-8)
    TxHeader.TransmitGlobalTime = DISABLE;

    for (int i = 0; i < len; i++) {
        TxData[i] = data[i];
    }

    HAL_CAN_AddTxMessage(&hcan1, &TxHeader, TxData, &TxMailbox);
}

/* Réception d'un message CAN */
CAN_RxHeaderTypeDef RxHeader;
uint8_t            RxData[8];

void CAN_ReceiveMessage(void)
{
    if (HAL_CAN_GetRxFifoFillLevel(&hcan1, CAN_RX_FIFO0) > 0)
    {
        HAL_CAN_GetRxMessage(&hcan1, CAN_RX_FIFO0, &RxHeader, RxData);

        printf("CAN Rx: ID=0x%03lX, DLC=%d, Data=",
               RxHeader.StdId, RxHeader.DLC);
        for (int i = 0; i < RxHeader.DLC; i++) {
            printf("%02X ", RxData[i]);
        }
        printf("\r\n");
    }
}

/* Exemple d'utilisation */
uint8_t speed_data[2] = {0x00, 0x50};  // vitesse = 80 km/h
CAN_SendMessage(0x123, speed_data, 2);
12.8 Résumé comparatif des protocoles
CaractéristiqueUARTI2CSPICAN
Fils2 (TX, RX)2 (SDA, SCL)4 (MOSI, MISO, SCK, CS)2 (CAN_H, CAN_L)
SynchroneNonOuiOuiOui
DuplexFullHalfFullHalf
Vitesse max~1 Mbps3,4 MHz50+ MHz1 Mbps
Distance~15 m (RS232)~1 m~10 cm1 km
TopologiePoint à pointBus (127 max)Point à multipointBus multi-maîtres
Détection erreurParitéACKNonCRC, ACK, 5 types
UsageDebug, GPSCapteurs, EEPROMFlash, LCD rapideAutomobile, industrie
Cours STM32F4 — BTS 2EII — Systèmes Embarqués · Module S03 · 12 chapitres · 48 h cours + 24 h TP