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.
Sommaire
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
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
Un système embarqué typique est composé de plusieurs éléments interconnectés :
┌─────────────────────────────────────────────────────────────────────┐ │ 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 │ │ │ └──────────────────────────────────────────────────────────────┘ │ └─────────────────────────────────────────────────────────────────────┘
Il est essentiel de distinguer ces deux composants fondamentaux :
| Critère | Microprocesseur (µP) | Microcontrôleur (µC) |
|---|---|---|
| Définition | Unité centrale de traitement seule | Système complet sur une puce (SoC) |
| Composants intégrés | CPU uniquement | CPU + RAM + Flash + Périphériques |
| Mémoire | Externe (sur carte mère) | Interne (intégrée) |
| Périphériques | Externes (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 €) |
| Applications | PC, serveurs, calcul intensif | Embarqué, IoT, contrôle |
| Exemples | Intel Core, AMD Ryzen, ARM Cortex-A | STM32, PIC, AVR, ESP32 |
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 :
| Famille | Fabricant | Architecture | Points forts |
|---|---|---|---|
| STM32 | STMicroelectronics | ARM Cortex-M | Large gamme, outils gratuits, écosystème riche |
| PIC | Microchip | Propriétaire | Simplicité, faible coût, XC compilers |
| AVR | Microchip (ex-Atmel) | RISC 8 bits | Arduino, simple, bien documenté |
| ESP32 | Espressif | Xtensa / RISC-V | WiFi/Bluetooth intégré, IoT |
| LPC | NXP | ARM Cortex-M | Performance, USB, Ethernet |
| MSP430 | Texas Instruments | RISC 16 bits | Ultra basse consommation |
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 :
| Gamme | Cœur | Fréquence | Positionnement |
|---|---|---|---|
| STM32F0 | Cortex-M0 | 48 MHz | Entrée de gamme, remplacement 8 bits |
| STM32F1 | Cortex-M3 | 72 MHz | Usage général, mainstream |
| STM32F3 | Cortex-M4 | 72 MHz | Mixed-signal, ADC haute résolution |
| STM32F4 | Cortex-M4F | 180 MHz | Haute performance, DSP, FPU |
| STM32F7 | Cortex-M7 | 216 MHz | Très haute performance |
| STM32H7 | Cortex-M7 | 480 MHz | Performance maximale |
| STM32L0/L4/L5 | Cortex-M0+/M4/M33 | 32-110 MHz | Ultra basse consommation |
| STM32G0/G4 | Cortex-M0+/M4 | 64-170 MHz | Nouvelle génération mainstream |
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
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 :
| Famille | Cœurs | Applications |
|---|---|---|
| Cortex-A | A5, A7, A9, A53, A72, A76… | Smartphones, tablettes, serveurs |
| Cortex-R | R4, R5, R7, R8… | Temps réel critique (automobile, disques durs) |
| Cortex-M | M0, M0+, M3, M4, M7, M23, M33… | Microcontrôleurs, embarqué, IoT |
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éristique | Cortex-M3 | Cortex-M4 |
|---|---|---|
| Architecture | ARMv7-M | ARMv7E-M |
| Pipeline | 3 étages | 3 étages |
| Jeu d'instructions | Thumb / Thumb-2 | Thumb / Thumb-2 + DSP |
| FPU | Non | Optionnelle (simple précision) |
| Instructions DSP | Non | Oui (SIMD, MAC) |
| Performance | 1,25 DMIPS/MHz | 1,25 DMIPS/MHz (+ DSP/FPU) |
| Interruptions | Jusqu'à 240 | Jusqu'à 240 |
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.Le Cortex-M4 utilise un pipeline à 3 étages qui permet d'exécuter plusieurs instructions en parallèle :
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.
Le Cortex-M4 dispose de 16 registres de 32 bits accessibles directement par le programmeur :
┌─────────────────────────────────────────────────────────────┐ │ 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
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)
RESET
│
▼
┌─────────────────────┐
│ THREAD MODE │
│ (Privileged) │◀─────────────────┐
│ │ │
│ Programme principal│ │
└─────────┬───────────┘ │
│ │
│ Interruption │ Retour
│ │
▼ │
┌─────────────────────┐ │
│ HANDLER MODE │ │
│ (Privileged) │──────────────────┘
│ │
│ Routine interruption│
└─────────────────────┘
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 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
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 :
| Offset | Vecteur | Description |
|---|---|---|
| 0x0000 | Initial SP | Valeur initiale du Stack Pointer |
| 0x0004 | Reset | Adresse du handler Reset |
| 0x0008 | NMI | Non-Maskable Interrupt |
| 0x000C | HardFault | Erreur matérielle grave |
| 0x0010 | MemManage | Erreur de protection mémoire |
| 0x0014 | BusFault | Erreur de bus |
| 0x0018 | UsageFault | Instruction invalide |
| 0x002C | SVCall | Appel système (SVC) |
| 0x0038 | PendSV | Pending Service Call |
| 0x003C | SysTick | Timer 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
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)
┌────────────────────────────────────────────────────────────────────────────┐ │ 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 │ │ │ │ └─────┘ │ │ └────────────────────────────────────────────────────────────────────────────┘
L'espace d'adressage du Cortex-M4 est de 4 Go (32 bits), divisé en régions prédéfinies :
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 │ └──────────────┴─────────────┴────────────────────────────────────────┘
0x08000000: début de la Flash (programme)0x20000000: début de la SRAM (données)0x40000000: début des périphériques0xE0000000: registres système Cortex-M
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 :
| Source | Nom | Fréquence | Caractéristiques |
|---|---|---|---|
| HSI | High Speed Internal | 16 MHz | RC interne, moins précis, démarrage rapide |
| HSE | High Speed External | 4-26 MHz | Quartz externe, très précis, utilisé pour PLL |
| LSI | Low Speed Internal | 32 kHz | RC interne, pour watchdog et RTC |
| LSE | Low Speed External | 32,768 kHz | Quartz externe, RTC précis |
| PLL | Phase Locked Loop | Jusqu'à 180 MHz | Multiplie 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 :
/* 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é :
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 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
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 :
| BOOT1 | BOOT0 | Mode de démarrage | Description |
|---|---|---|---|
| X | 0 | Main Flash | Démarre depuis la Flash utilisateur (normal) |
| 0 | 1 | System Memory | Démarre le bootloader ST (pour programmation) |
| 1 | 1 | Embedded SRAM | Dé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)
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)
STM32CubeMX permet de configurer visuellement tous les aspects du microcontrôleur :
Étapes de configuration :
- Sélection du MCU : choisir la référence exacte (ex : STM32F407VGT6)
- Configuration du Pinout : assigner les fonctions aux broches
- Configuration de l'horloge : Clock Configuration (Clock Tree)
- Configuration des périphériques : paramètres de chaque module
- Génération du code : projet complet avec initialisation
Onglets principaux de CubeMX :
| Onglet | Fonction |
|---|---|
| Pinout & Configuration | Vue du boîtier, affectation des pins, configuration des périphériques |
| Clock Configuration | Arbre d'horloge graphique, configuration PLL |
| Project Manager | Nom du projet, IDE cible, options de génération |
| Tools | Calcul de consommation, vérification des conflits |
Un projet généré par CubeMX a une structure standardisée :
/* 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)
main.c/* 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 */ /* ... */ }
/* USER CODE BEGIN */ et /* USER CODE END */. Tout code en dehors sera écrasé lors de la régénération avec CubeMX.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 :
| Fonction | Description |
|---|---|
| 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 |
┌─────────────────────────────────────────────────────────────────────────┐ │ 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 :
| Raccourci | Action |
|---|---|
Ctrl+B | Compiler le projet (Build) |
F11 | Déboguer (Debug) |
Ctrl+F11 | Exécuter (Run) |
F5 | Continuer (pendant debug) |
F6 | Step Over (instruction suivante) |
F7 | Step Into (entrer dans fonction) |
Ctrl+Shift+B | Ajouter / 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)
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 :
/* 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Ω
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.
/* 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_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.
/* 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_MODE_ANALOG : mode analogique
- désactive le buffer numérique
- réduit la consommation
- obligatoire pour ADC et DAC
Chaque port GPIO possède un ensemble de registres de configuration et de données :
| Registre | Nom | Taille | Description |
|---|---|---|---|
| GPIOx_MODER | Mode | 32 bits | 2 bits/pin : Input(00), Output(01), AF(10), Analog(11) |
| GPIOx_OTYPER | Output Type | 16 bits | 1 bit/pin : Push-Pull(0), Open-Drain(1) |
| GPIOx_OSPEEDR | Output Speed | 32 bits | 2 bits/pin : Low(00), Medium(01), High(10), VHigh(11) |
| GPIOx_PUPDR | Pull-up/Pull-down | 32 bits | 2 bits/pin : None(00), Pull-up(01), Pull-down(10) |
| GPIOx_IDR | Input Data | 16 bits | lecture seule : état des entrées |
| GPIOx_ODR | Output Data | 16 bits | lecture/écriture : état des sorties |
| GPIOx_BSRR | Bit Set/Reset | 32 bits | écriture atomique : bits [15:0]=set, [31:16]=reset |
| GPIOx_AFRL/H | Alternate Function | 2 × 32 bits | 4 bits/pin : sélection AF0-AF15 |
Exemple de configuration directe par registres. Configuration de PA5 en sortie Push-Pull (LED) :
/* 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)
/* 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); }
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 :
/* 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 :
/* 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); } }
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
Le STM32F4 dispose de plusieurs types de timers avec des fonctionnalités différentes :
| Type | Timers | Bits | Canaux | Fonctionnalités |
|---|---|---|---|---|
| Avancés | TIM1, TIM8 | 16 | 4 | PWM complémentaire, dead-time, break, contrôle moteur |
| Généraux 32-bit | TIM2, TIM5 | 32 | 4 | Compteur 32 bits, capture, PWM, encodeur |
| Généraux 16-bit | TIM3, TIM4 | 16 | 4 | Capture, PWM, encodeur |
| Généraux | TIM9-TIM14 | 16 | 1-2 | PWM simple, capture |
| Basiques | TIM6, TIM7 | 16 | 0 | Base de temps uniquement, trigger DAC |
┌─────────────────────────────────────────────────────────────────────────┐ │ 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
/* 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 %
/* 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); } }
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.
/* 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
L'ADC (Analog to Digital Converter) convertit une tension analogique en une valeur numérique proportionnelle.
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
/* 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
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.
| Constante | Cycles | Temps @21 MHz | Usage |
|---|---|---|---|
ADC_SAMPLETIME_3CYCLES | 3 | 0,14 µs | Source basse impédance |
ADC_SAMPLETIME_15CYCLES | 15 | 0,71 µs | Usage général |
ADC_SAMPLETIME_28CYCLES | 28 | 1,33 µs | Usage général |
ADC_SAMPLETIME_84CYCLES | 84 | 4,0 µs | Haute impédance |
ADC_SAMPLETIME_480CYCLES | 480 | 22,9 µs | Très haute impédance |
/* 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)
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
/* 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
/* 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
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.
┌─────────────────────────────────────────────────────────────────────────┐ │ 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 │ │ │ └─────────────────────────────────────────────────────────────────────────┘
Baudrate (vitesse de transmission). Définit le nombre de bits transmis par seconde. Les deux appareils doivent utiliser le même baudrate.
| Baudrate | Bits/s | Temps par bit | Usage typique |
|---|---|---|---|
| 9600 | 9600 bps | 104 µs | Applications lentes, GPS |
| 19200 | 19200 bps | 52 µs | Usage général |
| 38400 | 38400 bps | 26 µs | Usage général |
| 57600 | 57600 bps | 17 µs | Modems |
| 115200 | 115200 bps | 8,7 µs | Debug, standard |
| 230400 | 230400 bps | 4,3 µs | Haute vitesse |
| 921600 | 921600 bps | 1,1 µs | Très haute vitesse |
Format de données courant :
/* 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
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éristique | TTL (STM32) | RS232 |
|---|---|---|
| Niveau logique HIGH | 3,3 V | -3 V à -15 V |
| Niveau logique LOW | 0 V | +3 V à +15 V |
| Distance max | ~1 m | 15 m |
| Débit max | Plusieurs Mbps | ~115 kbps |
Connecteur DB9 RS232 — brochage côté câble :
/* 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
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) :
| USART | TX | RX | Bus | AF |
|---|---|---|---|---|
| USART1 | PA9 | PA10 | APB2 | AF7 |
| USART2 | PA2 | PA3 | APB1 | AF7 |
| USART3 | PB10 | PB11 | APB1 | AF7 |
| USART6 | PC6 | PC7 | APB2 | AF8 |
/* 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);
La réception par interruption est recommandée pour ne pas bloquer le programme principal.
/* 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); } }
printf via UARTIl est pratique de rediriger printf() vers l'UART pour le debug :
/* 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
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 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)│ │ │ └─────────┘ └───────────┘ └─────────┘ └────────────┘ │ │ │ └─────────────────────────────────────────────────────────────────────────┘
| Mode | Vitesse SCL | Usage |
|---|---|---|
| Standard Mode | 100 kHz | Capteurs, EEPROM, compatible tous |
| Fast Mode | 400 kHz | Usage courant, bon compromis |
| Fast Mode Plus | 1 MHz | Applications rapides |
| High Speed Mode | 3,4 MHz | Haute performance |
┌─────────────────────────────────────────────────────────────────────────┐ │ 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 :
- Maître génère condition START
- Maître envoie adresse esclave + bit R/W = 0 (écriture)
- Esclave répond ACK
- Maître envoie octet de données
- Esclave répond ACK (pour chaque octet)
- Maître génère STOP
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.
adresse_7bits << 1. Ne pas oublier ce décalage !/* 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); }
/* É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 }
<< 1.Utile pour trouver les adresses des périphériques connectés :
/* 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 :
| Adresse | Périphérique |
|---|---|
| 0x3C / 0x3D | Écran OLED SSD1306 |
| 0x50 - 0x57 | EEPROM 24Cxx |
| 0x68 / 0x69 | MPU6050, DS1307 RTC |
| 0x76 / 0x77 | BME280, BMP280 |
| 0x27 / 0x3F | LCD I2C PCF8574 |
| 0x48 - 0x4B | ADS1115 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
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 :
| Signal | Nom complet | Direction (Maître) | Description |
|---|---|---|---|
| MOSI | Master Out Slave In | Sortie → | Données du maître vers l'esclave |
| MISO | Master In Slave Out | ← Entrée | Données de l'esclave vers le maître |
| SCK/SCLK | Serial Clock | Sortie → | Horloge générée par le maître |
| CS/SS/NSS | Chip Select / Slave Select | Sortie → | Sélection de l'esclave (actif bas) |
┌─────────────────────────────────────────────────────────────────────────┐ │ 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 │ │ │ └─────────────────────────────────────────────────────────────────────────┘
Le SPI définit 4 modes de fonctionnement basés sur la polarité de l'horloge (CPOL) et la phase d'échantillonnage (CPHA) :
| Mode | CPOL | CPHA | Horloge au repos | Échantillonnage |
|---|---|---|---|---|
| Mode 0 | 0 | 0 | LOW | Front montant |
| Mode 1 | 0 | 1 | LOW | Front descendant |
| Mode 2 | 1 | 0 | HIGH | Front descendant |
| Mode 3 | 1 | 1 | HIGH | Front montant |
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
/* 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) :
/* 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
/* 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]; }
| Caractéristique | SPI | I2C |
|---|---|---|
| Nombre de fils | 4 (MOSI, MISO, SCK, CS) | 2 (SDA, SCL) |
| Vitesse max | ~50 MHz et plus | 3,4 MHz (High Speed) |
| Duplex | Full duplex | Half duplex |
| Adressage | Par ligne CS (1 par esclave) | 7/10 bits (127/1024 adresses) |
| Multi-maîtres | Complexe à implémenter | Natif avec arbitrage |
| Complexité | Simple (pas de protocole) | Plus complexe (ACK, adresses) |
| Consommation | Plus élevée | Plus faible |
| Distance | Courte (~10 cm) | Moyenne (~1 m) |
| Usage typique | Flash, SD Card, LCD, ADC rapides | Capteurs, 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
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)
┌─────────────────────────────────────────────────────────────────────────┐ │ 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) :
| État | CAN_H | CAN_L | Différence (CAN_H - CAN_L) |
|---|---|---|---|
| Récessif (1) | 2,5 V | 2,5 V | 0 V |
| Dominant (0) | 3,5 V | 1,5 V | 2 V |
Tension
│
3,5V├──────────────────────┐
│ CAN_H │ CAN_H
2,5V├──────┐ ┌───────┴───────┐ ┌───────
│ │ │ │ │
1,5V├──────┴───────┘ └───────┴───────
│ CAN_L CAN_L
│
└──────────────────────────────────────────────▶ Temps
│ │ │
Dominant Récessif Dominant
(0) (1) (0)
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 (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 :
| Type | Description |
|---|---|
| Data Frame | Trame de données (0-8 octets) |
| Remote Frame | Demande de données (pas de champ DATA) |
| Error Frame | Signale une erreur détectée |
| Overload Frame | Demande de délai entre trames |
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 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
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 │ ├─────────────────────────────────────────────────────────────────────────┤ │ │ │ É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
/* 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); }
/* 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);
| Caractéristique | UART | I2C | SPI | CAN |
|---|---|---|---|---|
| Fils | 2 (TX, RX) | 2 (SDA, SCL) | 4 (MOSI, MISO, SCK, CS) | 2 (CAN_H, CAN_L) |
| Synchrone | Non | Oui | Oui | Oui |
| Duplex | Full | Half | Full | Half |
| Vitesse max | ~1 Mbps | 3,4 MHz | 50+ MHz | 1 Mbps |
| Distance | ~15 m (RS232) | ~1 m | ~10 cm | 1 km |
| Topologie | Point à point | Bus (127 max) | Point à multipoint | Bus multi-maîtres |
| Détection erreur | Parité | ACK | Non | CRC, ACK, 5 types |
| Usage | Debug, GPS | Capteurs, EEPROM | Flash, LCD rapide | Automobile, industrie |