Tuesday, October 13, 2026

Introduction STM32F4xx

Introduction au STM32

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.

CPU Unité de contrôle ALU Registres : R0–R12, SP, LR, PC, xPSR PC = adresse de la prochaine instruction Mémoire Périphériques Bus : adresses · données · contrôle
Le CPU échange avec la mémoire et les périphériques par trois bus : adresse (où), données (quoi), contrôle (lire/écrire).

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.

Fetch · instr. n
Decode · instr. n
Execute · instr. n
Fetch · n+1
Decode · n+1
Execute · n+1

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)
ContientCPU (souvent + cache, MMU)CPU + Flash + SRAM + périphériques
MémoireRAM DDR et stockage externesInterne, de quelques Ko à quelques Mo
SystèmeLinux, Android, WindowsBare metal ou petit RTOS (FreeRTOS)
Fréquence500 MHz à plusieurs GHz1 à environ 800 MHz
Temps réelDifficile à garantirDéterministe, à la microseconde
ConsommationWattsµW à mW
ExemplesCortex-A72, Intel Core, Raspberry PiSTM32F411, 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.

ArchitectureTypeUtilisation
x86-64 (Intel, AMD)CISCPC, serveurs
ARMRISC, sous licenceSmartphones, Apple Silicon, presque tous les MCU 32 bits
RISC-VRISC, ouvertESP32-C3, recherche, puces sur mesure
AVRRISC 8 bitsArduino Uno
PIC, 80518/16/32 bitsIndustriel, systèmes anciens
Xtensa, MIPS32 bitsESP32 ; 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œurArchitectureDMIPS/MHzPoints fortsSéries STM32
M0 / M0+ARMv6-M0,87 / 0,93Le plus petit et le moins cherF0, L0, G0, C0
M3ARMv7-M1,25Thumb-2, division matérielleF1 (Blue Pill), F2, L1
M4ARMv7E-M1,25DSP + FPU optionnelleF3, F4, L4, G4
M7ARMv7E-Mjusqu'à 2,14Superscalaire, caches, FPU double précisionF7, H7
M33ARMv8-M1,5TrustZone (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œurCortex-M3Cortex-M4FCortex-M7
Fréquence max72 MHz100 MHz480 MHz
FPU / DSPNonSimple + DSPDouble + DSP
Flash / RAM64–128 Ko / 20 Ko512 Ko / 128 Kojusqu'à 2 Mo / 1 Mo
Config GPIOCRL/CRHMODER, OTYPER, PUPDRComme F4
CarteBlue PillBlack PillNucleo-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

Cortex-M4F32 bits, ARMv7E-M
100 MHzmaximum du F411
512 KoFlash (F411CE)
128 KoSRAM
1,7 – 3,6 Valimentation

Lire la référence : STM32 F 411 C E U 6

FSérie : usage général (L basse conso, H haute performance, W sans fil)
411Ligne : M4F, 100 MHz, USB OTG FS, 128 Ko de RAM
CBroches : C=48, R=64, V=100, Z=144, I=176
EFlash : 8=64 Ko, B=128, C=256, D=384, E=512, G=1 Mo, I=2 Mo
UBoîtier : T=LQFP, U=UFQFPN, H=BGA
6Température : 6 = −40 à +85 °C, 7 = jusqu'à +105 °C

Les lignes F4

LigneMHzFlashRAMParticularité
F40184512 Ko96 KoEntrée de gamme
F410100128 Ko32 KoMoins cher, avec DAC
F411100512 Ko128 KoBlack Pill, basse consommation
F412 / F4131001–1,5 Mo256–320 KoCAN, plus d'UART
F405 / F4071681 Mo192 Ko2 CAN ; F407 + Ethernet, caméra
F446180512 Ko128 KoSAI, SPDIF, Nucleo-F446RE
F427 – F479180jusqu'à 2 Mo256–384 KoSDRAM, 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.

0xE000 00000x5000 00000x4002 00000x4001 00000x4000 00000x2000 00000x1FFF 00000x0800 0000 Cœur Cortex-M4 : SysTick, NVIC, SCB, débogage AHB2 : USB OTG FS AHB1 : GPIOA 0x4002 0000 · GPIOB …0400 · GPIOC …0800 · RCC 0x4002 3800 · DMA APB2 : TIM1, USART1/6, SPI1/4/5, ADC1 APB1 : TIM2–5, USART2, SPI2/3, I2C1–3, RTC SRAM 128 Ko : variables, tas, pile (la pile descend depuis le haut) Mémoire système : bootloader ST en ROM (DFU, UART, I2C, SPI) Flash 512 Ko : votre programme (secteurs 4×16, 1×64, 3×128 Ko)
Simplifié. Source : manuel de référence RM0383. L'alias de démarrage en 0x0000 0000 pointe vers la Flash, la mémoire système ou la SRAM selon la broche BOOT0.

Bus et horloges

Cortex-M4FI-bus · D-bus · S-bus DMA1 / DMA2copie sans le CPU Matrice de bus Flash (via accélérateur ART) SRAM AHB1 ≤ 100 MHz : GPIO, DMA, RCC APB2 ≤ 100 MHz : TIM1, USART1, SPI1, ADC APB1 ≤ 50 MHz : TIM2–5, I2C, SPI2/3
La matrice permet au CPU et au DMA d'accéder à des mémoires différentes en même temps.
SourceFréquenceRemarques
HSI16 MHz (RC interne)Par défaut après reset, précision de quelques %
HSE4–26 MHz (quartz)25 MHz sur Black Pill ; nécessaire pour l'USB
PLLjusqu'à 100 MHzf = fin / M × N / P. Ex. : 25 / 25 × 200 / 2 = 100 MHz
LSE / LSI32,768 kHz / ~32 kHzQuartz 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).

BrochenBits MODERDécalage 2n
PA001:00
PA5511:1010
PB7715:1414
PC131327:2626

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érateurNomExemple (4 bits)Résultat
&ET1100 & 10101000
|OU1100 | 10101110
^OU exclusif1100 ^ 10100110
~NON~11000011
<< / >>Décalages0011 << 21100
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.

RegistreDécalageTailleRôleAccès
MODER0x002 bits/brocheEntrée, sortie, AF, analogiqueR/W
OTYPER0x041 bit/brochePush-pull ou drain ouvertR/W
OSPEEDR0x082 bits/brocheVitesse de commutationR/W
PUPDR0x0C2 bits/brochePull-up / pull-down interneR/W
IDR0x101 bit/brocheNiveau lu sur la brochelecture seule
ODR0x141 bit/brocheNiveau écrit en sortieR/W
BSRR0x18set + resetMise à 1 / 0 atomiqueécriture seule
LCKR0x1C17 bitsVerrouillage de la configR/W
AFRL / AFRH0x20 / 0x244 bits/brocheFonction alternative, broches 0–7 / 8–15R/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 propager

OSPEEDR : 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 |=.

Bits 31:16 : BRy (reset, mise à 0)Bits 15:0 : BSy (set, mise à 1) bit 29 = 1 → PC13 passe à 0 (LED allumée)bit 13 = 1 → PC13 passe à 1 (LED éteinte) Reset de la broche n = bit (n + 16)Set de la broche n = bit n
Les deux moitiés de BSRR : écrire un 1 agit, écrire un 0 ne change rien. Aucun besoin de lire le registre avant.

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.

AF0AF1AF2AF3AF4AF5AF6AF7AF8AF9AF10AF12
Système, SWDTIM1-2TIM3-5TIM9-11I2C1-3SPI1-5SPI3USART1-2USART6I2C2-3USBSDIO
// 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.

RegistreGPIOAGPIOBAutres ports
MODER0xA80000000x000002800
OSPEEDR0x0C0000000x000000C00
PUPDR0x640000000x000001000

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é

  1. Activer l'horloge du port (RCC_AHB1ENR).
  2. Préparer le niveau initial (ODR ou BSRR).
  3. Régler OTYPER, OSPEEDR, PUPDR.
  4. Choisir la fonction dans AFRL/AFRH si besoin.
  5. Écrire MODER en 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
    }
}
RegistreActionExemple pour PC13
ODRMettre à 1GPIOC->ODR |= (1UL << 13);
ODRMettre à 0GPIOC->ODR &= ~(1UL << 13);
ODRInverserGPIOC->ODR ^= (1UL << 13);
BSRRMettre à 1 (atomique)GPIOC->BSRR = (1UL << 13);
BSRRMettre à 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 suffit
4. 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-down
12. 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 dernier

Un 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 = 1
16. 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.
BTS EII, systèmes embarqués, Black Pill (STM32F411). Valeurs issues de la datasheet et du RM0383 ; vérifier les valeurs critiques avant de concevoir une carte.

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.

Question 0/40Score : 0/40