Introduction au STM32
Du microprocesseur aux registres du STM32F4 : ce qu'est un processeur, pourquoi ARM domine l'embarqué, et comment configurer une broche GPIO bit par bit sur la Black Pill (STM32F411).
1. Qu'est-ce qu'un microprocesseur ?
Un microprocesseur est une unité centrale (CPU) complète sur une seule puce de silicium. Il lit des instructions en mémoire, les décode et les exécute, des milliards de fois par seconde. Le premier, l'Intel 4004 (1971), était un 4 bits de 2 300 transistors cadencé à 740 kHz.
Le cycle d'instruction (animé)
Le CPU répète sans fin : chercher l'instruction à l'adresse PC (fetch), la décoder, l'exécuter. Le Cortex-M4 recouvre ces étapes dans un pipeline à 3 étages : pendant qu'une instruction s'exécute, la suivante est décodée et la troisième cherchée. Résultat : près d'une instruction par cycle d'horloge.
Von Neumann
Un seul bus pour le code et les données : simple, mais on ne peut pas chercher une instruction et lire une donnée en même temps.
Harvard
Bus séparés code / données : les deux accès se font dans le même cycle. Le Cortex-M4 est Harvard en interne, avec un espace d'adressage unique.
Microprocesseur ou microcontrôleur ?
Un microcontrôleur (MCU) réunit CPU, mémoire et périphériques (GPIO, timers, UART, ADC…) sur une seule puce : petit, peu cher, économe. Le STM32 est un MCU.
| Microprocesseur (MPU) | Microcontrôleur (MCU) | |
|---|---|---|
| Contient | CPU (souvent + cache, MMU) | CPU + Flash + SRAM + périphériques |
| Mémoire | RAM DDR et stockage externes | Interne, de quelques Ko à quelques Mo |
| Système | Linux, Android, Windows | Bare metal ou petit RTOS (FreeRTOS) |
| Fréquence | 500 MHz à plusieurs GHz | 1 à environ 800 MHz |
| Temps réel | Difficile à garantir | Déterministe, à la microseconde |
| Consommation | Watts | µW à mW |
| Exemples | Cortex-A72, Intel Core, Raspberry Pi | STM32F411, ATmega328, ESP32 |
À connaître aussi : le DSP (traitement du signal ; le M4 ajoute des instructions DSP), le SoC (MPU + nombreux blocs) et le FPGA (matériel reconfigurable, pas un processeur).
Exercices du chapitre 1
1.1 Classer : lave-linge, PC portable, drone (contrôleur de vol), Raspberry Pi 4. MPU ou MCU ?
Lave-linge : MCU. PC portable : MPU. Drone : MCU (boucle de contrôle temps réel). Raspberry Pi 4 : MPU (Cortex-A72 + RAM externe + Linux).
1.2 Pipeline à 3 étages : combien de cycles pour 100 instructions, avec et sans pipeline ?
Sans pipeline : 100 × 3 = 300 cycles. Avec pipeline : 3 cycles pour remplir, puis 1 instruction par cycle : 3 + 99 = 102 cycles. Gain proche de ×3.
1.3 Pourquoi l'architecture Harvard est-elle plus rapide que Von Neumann ?
Elle a un bus pour le code et un pour les données : le CPU peut chercher l'instruction suivante et lire/écrire une donnée dans le même cycle. Avec un bus unique, ces deux accès doivent se succéder.
1.4 À quoi sert chaque bus (adresse, données, contrôle) ? Que se passe-t-il si le bus d'adresse fait 32 bits ?
Adresse : désigne la case visée. Données : transporte la valeur. Contrôle : lecture/écriture, horloge. 32 bits d'adresse = 232 cases = 4 Go d'espace adressable, ce qui correspond à l'espace du STM32.
2. Les familles de processeurs
On classe les processeurs par jeu d'instructions (ISA). Un programme compilé pour une ISA ne tourne pas sur une autre.
| Architecture | Type | Utilisation |
|---|---|---|
| x86-64 (Intel, AMD) | CISC | PC, serveurs |
| ARM | RISC, sous licence | Smartphones, Apple Silicon, presque tous les MCU 32 bits |
| RISC-V | RISC, ouvert | ESP32-C3, recherche, puces sur mesure |
| AVR | RISC 8 bits | Arduino Uno |
| PIC, 8051 | 8/16/32 bits | Industriel, systèmes anciens |
| Xtensa, MIPS | 32 bits | ESP32 ; routeurs |
CISC : beaucoup d'instructions complexes de longueur variable. RISC : peu d'instructions simples, rapides, qui coûtent peu de silicium et d'énergie. L'embarqué privilégie l'efficacité, d'où la domination du RISC.
Les trois profils Cortex
Cortex-A (Application)
Très rapide, MMU et caches, exécute Linux/Android : smartphones, Raspberry Pi.
Cortex-R (Real-time)
Déterministe et tolérant aux pannes : freinage automobile, disques durs.
Cortex-M (Microcontrôleur)
Petit, économe, piloté par interruptions. C'est le monde STM32.
Cœurs Cortex-M et séries STM32
| Cœur | Architecture | DMIPS/MHz | Points forts | Séries STM32 |
|---|---|---|---|---|
| M0 / M0+ | ARMv6-M | 0,87 / 0,93 | Le plus petit et le moins cher | F0, L0, G0, C0 |
| M3 | ARMv7-M | 1,25 | Thumb-2, division matérielle | F1 (Blue Pill), F2, L1 |
| M4 | ARMv7E-M | 1,25 | DSP + FPU optionnelle | F3, F4, L4, G4 |
| M7 | ARMv7E-M | jusqu'à 2,14 | Superscalaire, caches, FPU double précision | F7, H7 |
| M33 | ARMv8-M | 1,5 | TrustZone (sécurité) | L5, U5, H5, WBA |
En classe : les registres changent selon la famille. Le STM32F103 (Blue Pill) configure les broches avec CRL/CRH ; le STM32F4 (Black Pill) utilise MODER, OTYPER, PUPDR… Toujours adapter le code à la famille.
Exercices du chapitre 2
2.1 Quel profil Cortex choisir : contrôleur de freinage ABS, smartphone, thermostat sur pile ?
ABS : Cortex-R (déterministe, tolérant aux pannes). Smartphone : Cortex-A (Linux/Android, MMU). Thermostat sur pile : Cortex-M (basse consommation).
2.2 Pourquoi un code écrit pour le STM32F103 avec CRL/CRH ne fonctionne-t-il pas sur un F411 ?
Le périphérique GPIO est différent : le F411 n'a pas de CRL/CRH mais MODER, OTYPER, OSPEEDR, PUPDR, AFRL/AFRH. Les décalages et les adresses de registres ne correspondent pas.
2.3 Un projet demande une FPU simple précision, du DSP et un faible coût. Quel cœur et quelle série ?
Cortex-M4F : séries STM32F4 (ou G4, L4 si basse consommation). Le M3 n'a ni FPU ni DSP ; le M7 est plus cher et plus puissant que nécessaire.
2.4 CISC ou RISC : citez deux avantages du RISC pour un système sur pile.
Instructions simples et de longueur régulière : moins de transistors, donc moins de consommation ; exécution rapide, d'où un CPU qui se rendort plus vite.
3. Pourquoi ARM ?
ARM (Acorn RISC Machine, 1985) vend des conceptions, pas des puces : plus de 200 milliards de puces à base ARM ont été produites.
Licences
ST, NXP, Apple… ajoutent leurs périphériques au cœur ARM. Une architecture, plusieurs fournisseurs : pas de dépendance.
Efficacité énergétique
RISC simple, peu de transistors : un Cortex-M tient des années sur une pile bouton.
Densité de code
Thumb-2 mêle instructions 16 et 32 bits : programmes compacts, donc moins de Flash et moins de coût.
Écosystème
GCC, Keil, IAR, STM32CubeIDE, PlatformIO, Zephyr, FreeRTOS, Arduino.
CMSIS
Standard ARM : mêmes noms (NVIC, SysTick) sur tous les Cortex-M, de tous les fabricants.
Évolutif
Du M0+ au M7 avec le même modèle de programmation : on monte en gamme sans tout réapprendre.
Atouts Cortex-M : contrôleur d'interruptions NVIC à priorités programmables, timer SysTick 24 bits, latence d'interruption de 12 cycles sur M4, MPU optionnel, débogage SWD/JTAG.
Exercices du chapitre 3
3.1 Latence d'interruption : 12 cycles à 100 MHz, combien de nanosecondes ?
Une période dure 1 / 100 MHz = 10 ns. 12 cycles × 10 ns = 120 ns.
3.2 Expliquez en 3 phrases pourquoi le modèle de licence d'ARM profite aux fabricants et aux développeurs.
Les fabricants achètent un cœur éprouvé et se concentrent sur leurs périphériques. Les développeurs gardent les mêmes outils et la même architecture d'un fabricant à l'autre. Cela évite de dépendre d'un seul fournisseur.
3.3 Quel est l'intérêt de CMSIS ?
Les fonctions et noms du cœur (NVIC, SysTick, accès aux registres) sont identiques sur tous les Cortex-M : le code qui s'appuie dessus se porte d'une puce à l'autre.
4. Pourquoi le STM32F4xx ?
Performance
Cortex-M4 de 84 à 180 MHz : audio, commande moteur, graphisme, fusion de capteurs.
FPU et DSP
Virgule flottante simple précision matérielle (1 cycle au lieu de centaines) ; MAC en 1 cycle et SIMD pour filtres et FFT.
Périphériques riches
UART, SPI, I²C, timers, ADC 12 bits, DMA, USB, SDIO, I²S.
Compatibilité
Le code passe d'une ligne F4 à l'autre, puis vers F7/H7, avec peu de changements.
Coût et docs
La Black Pill coûte quelques euros. Manuel de référence RM0383, datasheet DS10314.
Outils gratuits
STM32CubeIDE, CubeMX, CubeProgrammer, bibliothèques HAL et LL.
| STM32F103 (F1) | STM32F411 (F4) | STM32H743 (H7) | |
|---|---|---|---|
| Cœur | Cortex-M3 | Cortex-M4F | Cortex-M7 |
| Fréquence max | 72 MHz | 100 MHz | 480 MHz |
| FPU / DSP | Non | Simple + DSP | Double + DSP |
| Flash / RAM | 64–128 Ko / 20 Ko | 512 Ko / 128 Ko | jusqu'à 2 Mo / 1 Mo |
| Config GPIO | CRL/CRH | MODER, OTYPER, PUPDR | Comme F4 |
| Carte | Blue Pill | Black Pill | Nucleo-H743 |
Exercices du chapitre 4
4.1 Comparer F103 et F411 : rapport des fréquences, de la Flash, durée d'un cycle.
Fréquence : 100 / 72 ≈ 1,39. Flash : 512 Ko / 128 Ko = 4 (pour le plus grand F103). Cycle : 10 ns à 100 MHz, environ 13,9 ns à 72 MHz.
4.2 Un projet exige un bus CAN. Le F411 convient-il ? Que choisir ?
Non : le F411 n'a pas de CAN. Prendre un F405/F407 (2 CAN), un F446 ou un F412/F413.
4.3 Pourquoi le F4 est-il plus rapide que le F1 sur un filtre FIR ?
Il a un MAC (multiplication-accumulation) en 1 cycle, du SIMD et une FPU matérielle : un tour de filtre prend un cycle par coefficient au lieu de plusieurs dizaines en logiciel.
5. Le STM32F4 en détail
Lire la référence : STM32 F 411 C E U 6
F | Série : usage général (L basse conso, H haute performance, W sans fil) |
411 | Ligne : M4F, 100 MHz, USB OTG FS, 128 Ko de RAM |
C | Broches : C=48, R=64, V=100, Z=144, I=176 |
E | Flash : 8=64 Ko, B=128, C=256, D=384, E=512, G=1 Mo, I=2 Mo |
U | Boîtier : T=LQFP, U=UFQFPN, H=BGA |
6 | Température : 6 = −40 à +85 °C, 7 = jusqu'à +105 °C |
Les lignes F4
| Ligne | MHz | Flash | RAM | Particularité |
|---|---|---|---|---|
| F401 | 84 | 512 Ko | 96 Ko | Entrée de gamme |
| F410 | 100 | 128 Ko | 32 Ko | Moins cher, avec DAC |
| F411 | 100 | 512 Ko | 128 Ko | Black Pill, basse consommation |
| F412 / F413 | 100 | 1–1,5 Mo | 256–320 Ko | CAN, plus d'UART |
| F405 / F407 | 168 | 1 Mo | 192 Ko | 2 CAN ; F407 + Ethernet, caméra |
| F446 | 180 | 512 Ko | 128 Ko | SAI, SPDIF, Nucleo-F446RE |
| F427 – F479 | 180 | jusqu'à 2 Mo | 256–384 Ko | SDRAM, LCD-TFT, MIPI-DSI |
Le cœur Cortex-M4F
Architecture
32 bits, Harvard interne, pipeline 3 étages, Thumb-2. Registres R0–R12, SP (R13), LR (R14), PC (R15), xPSR.
FPU
IEEE 754 simple précision (float). Compiler avec -mfpu=fpv4-sp-d16 -mfloat-abi=hard. Un double reste émulé en logiciel : à éviter.
NVIC et SysTick
Environ 80 interruptions sur F4, 16 niveaux de priorité. SysTick sert de base de temps à HAL_Delay et aux RTOS.
Débogage
SWD sur PA13 (SWDIO) et PA14 (SWCLK), JTAG, points d'arrêt, trace ITM via une sonde ST-Link.
L'ART Accelerator (cache + prélecture devant la Flash) permet d'exécuter le code depuis la Flash presque sans état d'attente, malgré sa lenteur.
Carte mémoire
Mémoire et registres de périphériques partagent un seul espace de 4 Go (entrées/sorties mappées en mémoire). Écrire à une adresse, c'est piloter le matériel : tout le chapitre GPIO repose là-dessus.
Bus et horloges
| Source | Fréquence | Remarques |
|---|---|---|
HSI | 16 MHz (RC interne) | Par défaut après reset, précision de quelques % |
HSE | 4–26 MHz (quartz) | 25 MHz sur Black Pill ; nécessaire pour l'USB |
PLL | jusqu'à 100 MHz | f = fin / M × N / P. Ex. : 25 / 25 × 200 / 2 = 100 MHz |
LSE / LSI | 32,768 kHz / ~32 kHz | Quartz de l'horloge RTC / chien de garde |
États d'attente Flash (2,7–3,6 V) : 0 jusqu'à 30 MHz, 1 jusqu'à 64, 2 jusqu'à 90, 3 jusqu'à 100. Régler FLASH_ACR.LATENCY avant d'augmenter l'horloge, sinon plantage.
Les horloges des périphériques sont coupées après le reset pour économiser l'énergie. Il faut activer le port GPIO dans RCC_AHB1ENR avant de l'utiliser : c'est l'oubli le plus fréquent des débutants.
Modes d'énergie
- Run : fonctionnement normal
- Sleep : CPU arrêté, périphériques actifs, toute interruption réveille (
WFI) - Stop : horloges coupées, SRAM conservée, réveil par EXTI/RTC
- Standby : SRAM perdue, réveil par WKUP/RTC/reset
Périphériques du F411
- GPIO : jusqu'à 81 E/S (36 en 48 broches)
- Timers : TIM1, TIM2–5, TIM9–11
- ADC 12 bits, 16 voies, 2,4 MSPS
- 3 USART, 5 SPI/I²S, 3 I²C
- DMA 2×8 flux, USB OTG FS, SDIO, RTC, CRC
Le F411 n'a ni DAC, ni CAN, ni Ethernet : choisir un F405/F407 ou F446 si besoin. Le nombre de périphériques dépend du boîtier : vérifier dans la datasheet DS10314.
La carte Black Pill (WeAct STM32F411CEU6)
Sur la carte
- Quartz HSE 25 MHz, LSE 32,768 kHz
- USB-C, régulateur 3,3 V
- LED utilisateur sur PC13 (active à l'état bas)
- Bouton utilisateur sur PA0 (vers la masse)
- Boutons NRST et BOOT0, connecteur SWD
Programmation
- ST-Link sur SWD : programmer et déboguer
- USB DFU : maintenir BOOT0, appuyer sur NRST
- STM32CubeIDE, PlatformIO, CubeProgrammer
Broches à éviter
- PA13 / PA14 : SWD (on perdrait le débogage)
- PA11 / PA12 : USB D− / D+
- PH0 / PH1 : quartz
- PC13–15 : faible courant de sortie
Exercices du chapitre 5
5.1 Décoder STM32F407VGT6.
Série F, ligne 407 (M4F, 168 MHz, Ethernet), V = 100 broches, G = 1 Mo de Flash, T = boîtier LQFP, 6 = −40 à +85 °C.
5.2 PLL : HSE = 25 MHz, M = 25, N = 192, P = 2. Fréquence du cœur ? Combien d'états d'attente Flash ?
25 / 25 = 1 MHz ; × 192 = 192 MHz (VCO) ; / 2 = 96 MHz, valide (≤ 100 MHz). Entre 90 et 100 MHz : 3 états d'attente. Avec Q = 4, la sortie USB vaut 192 / 4 = 48 MHz.
5.3 Calculer les adresses de GPIOC_ODR, GPIOA_IDR et RCC_AHB1ENR.
GPIOC_ODR = 0x40020800 + 0x14 = 0x40020814. GPIOA_IDR = 0x40020000 + 0x10 = 0x40020010. RCC_AHB1ENR = 0x40023800 + 0x30 = 0x40023830.
5.4 Plage d'adresses de la SRAM (128 Ko) et valeur initiale du pointeur de pile.
128 Ko = 0x20000 octets : de 0x20000000 à 0x2001FFFF. La pile descend : SP initial = 0x20020000.
5.5 Quel mode d'énergie choisir : (a) attendre un bouton avec reprise immédiate, (b) capteur relevé une fois par heure sur batterie ?
(a) Sleep ou Stop (réveil par EXTI, SRAM conservée). (b) Stop avec réveil RTC, ou Standby si l'état n'a pas besoin d'être conservé (la SRAM est perdue).
6. GPIO et registres
Un GPIO est une broche utilisable en entrée ou sortie numérique. Chaque port STM32F4 (GPIOA, GPIOB, GPIOC…) a 16 broches et 10 registres de 32 bits. Configurer une broche, c'est écrire des bits dans ces registres, situés à des adresses fixées par la puce.
6.1 Le registre MODER
MODER contient 2 bits par broche : 00 entrée, 01 sortie, 10 fonction alternative (UART, SPI, PWM…), 11 analogique. Pour la broche n : bits 2n+1 et 2n, masque 3UL << (2*n).
| Broche | n | Bits MODER | Décalage 2n |
|---|---|---|---|
| PA0 | 0 | 1:0 | 0 |
| PA5 | 5 | 11:10 | 10 |
| PB7 | 7 | 15:14 | 14 |
| PC13 | 13 | 27:26 | 26 |
Erreur n°1 des étudiants : le numéro de broche (13) n'est pas la position du bit (26).
Simulateur : effacer puis écrire
Choisissez une broche et un mode, puis lancez. Les bits encadrés sont ceux de la broche ; en jaune, les bits à 1. Le registre part de 0xFFFFFFFF (tout analogique) pour montrer le piège du « set seul ».
Appuyez sur Lancer.
Les opérateurs bit à bit
| Opérateur | Nom | Exemple (4 bits) | Résultat |
|---|---|---|---|
& | ET | 1100 & 1010 | 1000 |
| | OU | 1100 | 1010 | 1110 |
^ | OU exclusif | 1100 ^ 1010 | 0110 |
~ | NON | ~1100 | 0011 |
<< / >> | Décalages | 0011 << 2 | 1100 |
REG &= ~(masque); // ET avec le complément : met les bits du masque à 0
REG |= (masque); // OU : met les bits du masque à 1
REG ^= (masque); // XOR : inverse les bits du masque
Le suffixe UL force une constante 32 bits non signée. Sans lui, 1 << 31 est un comportement indéfini sur un int signé.
Pas à pas : PC13 en sortie, avec MODER = 0xFFFFFFFF
3UL = 0x00000003
3UL << 26 = 0x0C000000 // 11 placé sur les bits 27:26
~(3UL << 26) = 0xF3FFFFFF // masque : 0 seulement sur les bits à effacer
MODER & masque = 0xF3FFFFFF // bits 27:26 = 00 ; les autres sont inchangés (ET avec 1)
1UL << 26 = 0x04000000 // la valeur « sortie » (01) à la bonne position
MODER | valeur = 0xF7FFFFFF // bits 27:26 = 01 ; les autres sont inchangés (OU avec 0)
Le piège du « set seul » : si PC13 est analogique (11), |= (1UL << 26) laisse 11 car 11 | 01 = 11. Toujours effacer, puis écrire : c'est le schéma lecture-modification-écriture.
// 1re ligne : efface les 2 bits de la broche ; 2e ligne : écrit le mode (0 à 3).
// do/while(0) : la macro s'utilise comme une instruction.
// (un commentaire ne doit jamais suivre le \ de fin de ligne)
#define GPIO_SET_MODE(GPIOx, pin, mode) \
do { \
(GPIOx)->MODER &= ~(3UL << ((pin) * 2)); \
(GPIOx)->MODER |= ((mode) << ((pin) * 2)); \
} while (0)
GPIO_SET_MODE(GPIOC, 13, 1UL); // PC13 en sortie
GPIOC->MODER &= ~GPIO_MODER_MODER13; // version CMSIS : efface les bits 27:26
GPIOC->MODER |= GPIO_MODER_MODER13_0; // met le bit 26 à 1, soit 01
6.2 Les 10 registres GPIO du STM32F411
Chaque registre se trouve à l'adresse base du port + décalage.
| Registre | Décalage | Taille | Rôle | Accès |
|---|---|---|---|---|
MODER | 0x00 | 2 bits/broche | Entrée, sortie, AF, analogique | R/W |
OTYPER | 0x04 | 1 bit/broche | Push-pull ou drain ouvert | R/W |
OSPEEDR | 0x08 | 2 bits/broche | Vitesse de commutation | R/W |
PUPDR | 0x0C | 2 bits/broche | Pull-up / pull-down interne | R/W |
IDR | 0x10 | 1 bit/broche | Niveau lu sur la broche | lecture seule |
ODR | 0x14 | 1 bit/broche | Niveau écrit en sortie | R/W |
BSRR | 0x18 | set + reset | Mise à 1 / 0 atomique | écriture seule |
LCKR | 0x1C | 17 bits | Verrouillage de la config | R/W |
AFRL / AFRH | 0x20 / 0x24 | 4 bits/broche | Fonction alternative, broches 0–7 / 8–15 | R/W |
Adresses de base : GPIOA 0x40020000, GPIOB 0x40020400, GPIOC 0x40020800, GPIOH 0x40021C00, RCC 0x40023800.
#define GPIOC_BASE 0x40020800UL // adresse du port C
#define GPIOC_MODER (*(volatile uint32_t *)(GPIOC_BASE + 0x00)) // convertit l'adresse en pointeur, puis déréférence
#define GPIOC_ODR (*(volatile uint32_t *)(GPIOC_BASE + 0x14)) // volatile : le compilateur ne doit rien optimiser
#define GPIOC_BSRR (*(volatile uint32_t *)(GPIOC_BASE + 0x18)) // GPIOC_BSRR s'utilise ensuite comme une variable
RCC_AHB1ENR (RCC + 0x30)
Active l'horloge des ports : GPIOAEN bit 0, GPIOBEN 1, GPIOCEN 2, GPIODEN 3, GPIOEEN 4, GPIOHEN 7 ; CRCEN 12, DMA1EN 21, DMA2EN 22. Sans horloge, les écritures sont ignorées.
RCC_AHB1ENR |= (1UL << 2); // active GPIOC
(void)RCC_AHB1ENR; // relecture : laisse l'horloge se propagerOSPEEDR : vitesse
00 faible ≈ 2 MHz (LED) · 01 moyenne ≈ 25 MHz · 10 rapide ≈ 50 MHz (SPI) · 11 très rapide ≈ 100 MHz. Plus c'est rapide, plus la consommation et les perturbations EMI augmentent. Ne concerne que les sorties.
PUPDR : résistances
00 aucune (broche flottante) · 01 pull-up ≈ 40 kΩ vers VDD · 10 pull-down vers GND · 11 réservé. Un bouton relié à la masse demande un pull-up : repos = 1, appui = 0.
OTYPER : type de sortie
0 push-pull : la broche impose 0 et 1 (défaut). 1 drain ouvert : elle n'impose que 0, le 1 est haute impédance et exige un pull-up. Obligatoire pour l'I²C.
IDR et ODR
IDR (lecture seule) reflète le niveau réel de la broche, même en sortie. ODR contient le niveau à émettre et le garde même avant le passage en sortie. Les opérations |=, &=, ^= sur ODR ne sont pas atomiques.
BSRR : set/reset atomique
Bits 15:0 mettent à 1, bits 31:16 mettent à 0. Set = bit n, reset = bit n+16. Un 0 n'a aucun effet ; si BSn et BRn valent 1, BSn gagne. On écrit avec =, jamais |=.
AFRL et AFRH : fonction alternative
4 bits par broche, utilisés seulement si MODER = 10. Broche 9 = AFRH bits 7:4 ; broche 5 = AFRL bits 23:20. La fonction exacte de chaque broche est dans la table « Alternate function mapping » de la datasheet.
| AF0 | AF1 | AF2 | AF3 | AF4 | AF5 | AF6 | AF7 | AF8 | AF9 | AF10 | AF12 |
|---|---|---|---|---|---|---|---|---|---|---|---|
| Système, SWD | TIM1-2 | TIM3-5 | TIM9-11 | I2C1-3 | SPI1-5 | SPI3 | USART1-2 | USART6 | I2C2-3 | USB | SDIO |
// PA9 en USART1_TX (AF7)
GPIOA_MODER &= ~(3UL << 18); // efface les bits 19:18 (broche 9 × 2 = 18)
GPIOA_MODER |= (2UL << 18); // mode 10 : fonction alternative
GPIOA_AFRH &= ~(0xFUL << 4); // efface AFRH9 (bits 7:4) : 4 bits à effacer
GPIOA_AFRH |= (7UL << 4); // AF7 = USART1
LCKR et valeurs de reset
LCKR gèle la configuration des broches choisies jusqu'au prochain reset. Séquence : écrire LCKK=1, puis 0, puis 1 (avec les mêmes bits LCK15:0), puis lire deux fois LCKR ; LCKK=1 confirme le verrouillage.
| Registre | GPIOA | GPIOB | Autres ports |
|---|---|---|---|
| MODER | 0xA8000000 | 0x00000280 | 0 |
| OSPEEDR | 0x0C000000 | 0x000000C0 | 0 |
| PUPDR | 0x64000000 | 0x00000100 | 0 |
PA13, PA14 et PA15 démarrent en fonction alternative (SWD). Ne les reconfigurez pas sous peine de perdre la liaison ST-Link.
Ordre de configuration recommandé
- Activer l'horloge du port (
RCC_AHB1ENR). - Préparer le niveau initial (
ODRouBSRR). - Régler
OTYPER,OSPEEDR,PUPDR. - Choisir la fonction dans
AFRL/AFRHsi besoin. - Écrire
MODERen dernier : la broche ne devient active qu'avec une configuration complète.
6.3 Exemples complets commentés
LED sur PC13 et bouton sur PA0
/* 1. Horloges des ports A et C */
RCC_AHB1ENR |= (1UL << 0) | (1UL << 2); // GPIOAEN et GPIOCEN
(void)RCC_AHB1ENR; // relecture pour la propagation
/* 2. PC13 : sortie push-pull, vitesse faible, sans pull */
GPIOC_BSRR = (1UL << 13); // niveau haut d'abord : LED éteinte (active à l'état bas)
GPIOC_OTYPER &= ~(1UL << 13); // 0 = push-pull
GPIOC_OSPEEDR &= ~(3UL << 26); // 00 = vitesse faible
GPIOC_PUPDR &= ~(3UL << 26); // 00 = pas de résistance
GPIOC_MODER &= ~(3UL << 26); // efface...
GPIOC_MODER |= (1UL << 26); // ...puis 01 = sortie, écrit en dernier
/* 3. PA0 : entrée avec pull-up (bouton relié à la masse) */
GPIOA_PUPDR &= ~(3UL << 0);
GPIOA_PUPDR |= (1UL << 0); // 01 = pull-up : repos = 1
GPIOA_MODER &= ~(3UL << 0); // 00 = entrée
/* 4. LED allumée tant que le bouton est appuyé */
while (1) {
if ((GPIOA_IDR & (1UL << 0)) == 0) // bit 0 de IDR = 0 : bouton appuyé
GPIOC_BSRR = (1UL << (13 + 16)); // PC13 = 0 : LED allumée
else
GPIOC_BSRR = (1UL << 13); // PC13 = 1 : LED éteinte
}
Faire clignoter la LED PC13
La LED est active à l'état bas : elle s'allume quand la broche vaut 0. Voici le résultat attendu, au rythme du programme ci-dessous :
#include <stdint.h>
#define RCC_AHB1ENR (*(volatile uint32_t *)(0x40023800UL + 0x30)) // registre d'horloge
#define GPIOC_MODER (*(volatile uint32_t *)(0x40020800UL + 0x00)) // mode des broches du port C
#define GPIOC_BSRR (*(volatile uint32_t *)(0x40020800UL + 0x18)) // set/reset atomique
static void delay(volatile uint32_t n) { while (n--) { } } // attente active : volatile empêche sa suppression
int main(void)
{
RCC_AHB1ENR |= (1UL << 2); // 1. horloge du port C
GPIOC_MODER &= ~(3UL << 26); // 2. PC13 : efface puis...
GPIOC_MODER |= (1UL << 26); // ...sortie
while (1) // 3. boucle infinie
{
GPIOC_BSRR = 1UL << (13 + 16); delay(500000); // PC13 = 0 : LED allumée
GPIOC_BSRR = 1UL << 13; delay(500000); // PC13 = 1 : LED éteinte
}
}
| Registre | Action | Exemple pour PC13 |
|---|---|---|
| ODR | Mettre à 1 | GPIOC->ODR |= (1UL << 13); |
| ODR | Mettre à 0 | GPIOC->ODR &= ~(1UL << 13); |
| ODR | Inverser | GPIOC->ODR ^= (1UL << 13); |
| BSRR | Mettre à 1 (atomique) | GPIOC->BSRR = (1UL << 13); |
| BSRR | Mettre à 0 (atomique) | GPIOC->BSRR = (1UL << (13 + 16)); |
Préférez BSRR : pas de lecture-modification-écriture, donc aucun risque si une interruption modifie le même port.
6.4 Exercices
Essayez d'abord sur papier, puis ouvrez la correction.
1. Masques. Donnez en hexadécimal : a) 3UL<<4, b) 1UL<<26, c) ~(3UL<<4), d) masque d'effacement et valeur « sortie » pour PA5
a) 0x00000030 b) 0x04000000 c) 0xFFFFFFCF d) PA5 : décalage 10, masque ~(3UL<<10) = 0xFFFFF3FF, valeur 1UL<<10 = 0x00000400.
2. Bits de MODER pour PA0, PA5, PB7, PC8, PD12, PA15
1:0 · 11:10 · 15:14 · 17:16 · 25:24 · 31:30. Formule : bits 2n+1 et 2n.
3. Écrire effacement + écriture : PA5 sortie, PB7 sortie, PA0 entrée, PC8 AF, PD12 analogique
GPIOA_MODER &= ~(3UL << 10); GPIOA_MODER |= (1UL << 10); // PA5 sortie
GPIOB_MODER &= ~(3UL << 14); GPIOB_MODER |= (1UL << 14); // PB7 sortie
GPIOA_MODER &= ~(3UL << 0); // PA0 entrée : l'effacement suffit (00)
GPIOC_MODER &= ~(3UL << 16); GPIOC_MODER |= (2UL << 16); // PC8 AF (10)
GPIOD_MODER |= (3UL << 24); // PD12 analogique (11) : OU suffit4. Valeur finale de MODER : a) 0xA8000000 + PA5 sortie ; b) 0xFFFFFFFF + PB3 sortie ; c) 0x0C000000 avec seulement |= (1UL<<26)
a) Bits 11:10 valent 00 : après écriture 0xA8000400. b) PB3 = bits 7:6. Effacement : 0xFFFFFF3F, écriture (0x40) : 0xFFFFFF7F. c) Bits 27:26 valaient 11 ; 11 | 01 = 11, donc MODER reste 0x0C000000 : PC13 est toujours analogique.
5. Trouver l'erreur (PC13 doit devenir une sortie) : a) |= (1UL<<13) b) &= (3UL<<26) c) = (1UL<<26) d) &= ~(1UL<<26)
a) 13 est le numéro de broche, pas la position : on touche la broche 6 (il faut 26). b) Le ~ est oublié : tous les autres bits sont mis à 0. c) = écrase tout le registre. d) Le masque n'efface que le bit 26, pas le 27 : de 10, on obtient 11 (analogique) au lieu de 01. Il faut 3UL.
6. PC13 et PC14 en sortie en un effacement et une écriture
PC13 : bits 27:26 ; PC14 : bits 29:28. Masque : (3UL<<26)|(3UL<<28) = 0x3C000000. Valeur : (1UL<<26)|(1UL<<28) = 0x14000000.
GPIOC_MODER &= ~0x3C000000UL;
GPIOC_MODER |= 0x14000000UL;7. Écrire une expression qui retourne le mode (0 à 3) de la broche n, puis une fonction sûre gpio_set_mode
mode = (GPIOC_MODER >> (2*n)) & 3UL; // décale vers la droite, puis garde 2 bits
void gpio_set_mode(volatile uint32_t *moder, uint8_t pin, uint8_t mode)
{
if (pin > 15 || mode > 3) return; // arguments invalides : on ignore
*moder &= ~(3UL << (pin * 2)); // efface
*moder |= ((uint32_t)mode << (pin * 2)); // écrit
}Test : n = 13 et MODER = 0x04000000 : >> 26 donne 1, donc sortie.
8. Décoder la valeur de reset 0xA8000000 de GPIOA
0xA8000000 = 1010 1000 0000… : bits 31:30 = 10 (PA15), 29:28 = 10 (PA14), 27:26 = 10 (PA13). Ces trois broches sont en fonction alternative : c'est le SWD/JTAG actif au reset.
9. Sur la carte : a) clignoter PC13 à 2 Hz ; b) bouton PA0 avec pull-up ; c) alterner PC13 et PA5 avec BSRR seul ; d) SOS en morse
a) Inverser PC13 toutes les 250 ms. b) Voir l'exemple complet ci-dessus. c) GPIOC_BSRR = 1UL<<13; GPIOA_BSRR = 1UL<<(5+16); puis l'inverse après le délai ; attention, PC13 est actif à l'état bas. d) Trois impulsions courtes, trois longues, trois courtes, avec une fonction pulse(duree) appelée neuf fois et une pause plus longue entre les lettres.
10. Valeur à écrire dans BSRR pour mettre PA5 à 1 et PA6 à 0 en même temps.
Set PA5 : bit 5 = 0x20. Reset PA6 : bit 6 + 16 = 22, soit 0x400000. Total : GPIOA_BSRR = 0x00400020; (écrit avec =).
11. PA0 en pull-up et PB4 en pull-down : écrire le code PUPDR.
GPIOA_PUPDR &= ~(3UL << 0); GPIOA_PUPDR |= (1UL << 0); // PA0 : 01 = pull-up
GPIOB_PUPDR &= ~(3UL << 8); GPIOB_PUPDR |= (2UL << 8); // PB4 : décalage 2×4 = 8, 10 = pull-down12. Configurer PB6 et PB7 pour l'I²C1 (AF4, drain ouvert, pull-up interne).
GPIOB_OTYPER |= (1UL << 6) | (1UL << 7); // drain ouvert
GPIOB_PUPDR &= ~((3UL << 12) | (3UL << 14)); // efface
GPIOB_PUPDR |= (1UL << 12) | (1UL << 14); // pull-up (01)
GPIOB_AFRL &= ~0xFF000000UL; // efface AFRL6 (27:24) et AFRL7 (31:28)
GPIOB_AFRL |= (4UL << 24) | (4UL << 28); // AF4 = I2C1, soit 0x44000000
GPIOB_MODER &= ~0x0000F000UL; // efface les bits 15:12
GPIOB_MODER |= 0x0000A000UL; // 10 = AF, écrit en dernierUn pull-up externe de 4,7 kΩ est préférable pour l'I²C rapide.
13. Deux boutons sur PA0 et PA1 (pull-up). Écrire la condition « les deux sont appuyés ».
Au repos 1, appui = 0 : if ((GPIOA_IDR & 0x3UL) == 0). Pour « seulement PA0 appuyé » : (GPIOA_IDR & 0x3UL) == 0x2UL.
14. Un programme principal fait GPIOA_ODR ^= 1 et une interruption fait GPIOA_ODR |= 2. Quel est le risque ? Comment le corriger ?
Chaque opération lit, modifie, puis écrit. Si l'interruption survient entre la lecture et l'écriture du programme principal, sa modification est écrasée. Correction : BSRR pour les mises à 1/0, qui sont atomiques. Pour un basculement, lire ODR puis écrire dans BSRR, avec section critique si nécessaire.
15. Écrire la séquence de verrouillage de PA5 avec LCKR.
uint32_t v = (1UL << 16) | (1UL << 5); // LCKK = 1 et LCK5 = 1 : 0x00010020
GPIOA_LCKR = v; // LCKK = 1
GPIOA_LCKR = (1UL << 5); // LCKK = 0
GPIOA_LCKR = v; // LCKK = 1
(void)GPIOA_LCKR; // 1re lecture : renvoie 0
if (GPIOA_LCKR & (1UL << 16)) { /* verrouillé */ } // 2e lecture : LCKK = 116. Décoder le MODER de GPIOB au reset : 0x00000280.
0x280 = 10 1000 0000. Les bits 9:8 valent 10 (PB4) et les bits 7:6 valent 10 (PB3) : PB3 et PB4 sont en fonction alternative (JTDO/TRACESWO et NJTRST).
17. Projet : le bouton PA0 inverse l'état de la LED PC13 à chaque appui (anti-rebond simple).
Pistes : lire IDR en boucle ; détecter le front descendant (ancien état = 1, nouveau = 0) ; attendre 20 ms pour le rebond ; inverser avec GPIOC_ODR ^= (1UL << 13) ou, mieux, tester ODR puis écrire BSRR. Étendre : compter les appuis et clignoter n fois.
18. Projet : feu tricolore sur PA5 (rouge), PA6 (orange), PA7 (vert).
Configurer les trois broches en sortie avec une seule effacement/écriture sur les bits 15:10 (masque 0xFC00, valeur 0x5400). Séquence avec BSRR : vert 5 s, orange 1 s, rouge 5 s. Un seul écrit BSRR par étape éteint l'ancienne couleur et allume la nouvelle, par exemple GPIOA_BSRR = (1UL<<7) | (1UL<<(5+16));.
7. À retenir
Vue d'ensemble
- Un MCU = CPU + mémoire + périphériques sur une puce.
- ARM licencie des cœurs ; ST construit le STM32 autour du Cortex-M.
- Le F4 est un Cortex-M4F avec FPU et DSP.
- Black Pill F411 : 100 MHz, 512 Ko de Flash, 128 Ko de RAM.
Règles des registres
- 1 broche = 2 bits dans MODER ; position = 2 × numéro.
- Activer l'horloge, effacer avec
&= ~(3UL << 2n), puis écrire. - 00 entrée, 01 sortie, 10 AF, 11 analogique.
- Piloter les sorties avec BSRR.
- Jamais
=sur un registre partagé, sauf BSRR.
8. QCM d'auto-évaluation : 40 questions
Cliquez sur une réponse : la correction s'affiche tout de suite. Le score se met à jour en direct.