Programming GPIOs on STM32F4Discovery Platform

Ce laboratoire pratique permet d'apprendre la programmation bas niveau des GPIOs (General Purpose Input/Output) sur la plateforme STM32F4Discovery. Il enseigne comment manipuler directement les registres du microcontrôleur en langage C pour contrôler les entrées/sorties numériques, notamment pour faire clignoter une LED connectée à une broche spécifique. Pour réaliser ce TP, il est nécessaire de disposer d'une carte STM32F4Discovery, d'un environnement de développement compatible (comme Keil µVision), et de connaissances de base en langage C et en architecture microcontrôleur.

Objectifs

• Utiliser le langage C embarqué pour définir et manipuler les registres GPIO.
• Adresser et programmer les registres STM32 via leur adresse mémoire (Memory Map).
• Configurer les GPIOs en entrée, sortie, ou fonction alternative.
• Contrôler une LED via la broche PD12 du port GPIOD.
• Comprendre le rôle du contrôleur d'horloge RCC pour activer les périphériques.

Prérequis et configuration

• Carte STM32F4Discovery.
• Environnement de développement compatible, par exemple Keil µVision (http://www.keil.com/uvision/).
• Connaissances de base en langage C et en architecture Cortex-M4.
• Compréhension des concepts de registres mémoire et d'adressage direct.
• Documentation STM32F40x (datasheet et Reference Manual) pour les adresses des registres.

Architecture et registres STM32 liés aux GPIO

Le STM32F4 est basé sur un CPU Cortex-M4 avec une architecture Harvard, séparant bus instructions et bus données. Les périphériques sont connectés aux bus APB1, APB2, et AHB1. Les GPIOs sont montés sur le bus AHB1 et doivent être activés via le contrôleur RCC avant utilisation.

Les registres principaux pour manipuler un port GPIO (x = A..I) sont :

• GPIOx_MODER : sélection du mode (entrée, sortie, fonction alternative, analogique).
• GPIOx_OTYPER : type de sortie (push-pull ou open-drain).
• GPIOx_OSPEEDR : vitesse de sortie (jusqu'à 50 MHz).
• GPIOx_PUPDR : configuration pull-up/pull-down.
• GPIOx_IDR : lecture des données en entrée.
• GPIOx_ODR : écriture des données en sortie.

Les adresses des registres sont calculées en ajoutant l'adresse de base du port GPIO à l'offset du registre. Par exemple :

GPIOC_ODR = GPIOC_BASE + OFFSET_ODR
= 0x40020800 + 0x14
= 0x40020814

Le contrôleur RCC permet d'activer l'horloge des périphériques via le registre RCC_AHB1ENR (offset 0x30) et de réinitialiser un périphérique via RCC_AHB1RSTR (offset 0x10).

Étape 1 : Définition des registres à utiliser

Pour contrôler la LED connectée à la broche PD12 du port GPIOD, il faut utiliser les registres suivants :

• RCC_AHB1ENR (0x40023830) : activation de l'horloge pour GPIOD.
• RCC_AHB1RSTR (0x40023810) : réinitialisation du port GPIOD.
• GPIOD_MODER (0x40020C00) : configuration du mode de la broche PD12.
• GPIOD_OTYPER (0x40020C04) : type de sortie.
• GPIOD_OSPEEDR (0x40020C08) : vitesse de sortie.
• GPIOD_PUPDR (0x40020C0C) : pull-up/pull-down.
• GPIOD_ODR (0x40020C14) : sortie des données (commande de la LED).

Ces adresses sont définies dans le code C par des pointeurs volatiles :

volatile unsigned int* MODREG = (unsigned int *) 0x40020C00;
volatile unsigned int* DOTYPE = (unsigned int *) 0x40020C04;
volatile unsigned int* DSPEED = (unsigned int *) 0x40020C08;
volatile unsigned int* PUPPDR = (unsigned int *) 0x40020C0C;
volatile unsigned int* DODR   = (unsigned int *) 0x40020C14;

volatile unsigned int* AHB1_ENR = (unsigned int *) 0x40023830;
volatile unsigned int* AHB1_RSTR = (unsigned int *) 0x40023810;

Le mot-clé volatile est utilisé pour empêcher l'optimisation du compilateur sur ces variables liées aux registres matériels.

Étape 2 : Activation et réinitialisation du port GPIOD

Avant de configurer et utiliser GPIOD, il faut :

• Réinitialiser le port GPIOD en mettant le bit 3 du registre RCC_AHB1RSTR à 1, puis à 0.
• Activer l'horloge du port GPIOD en mettant le bit 3 du registre RCC_AHB1ENR à 1.

En C :

*AHB1_RSTR |= 1 << 3;   // Reset GPIOD
*AHB1_RSTR &= ~(1 << 3);  // Sortie du reset

*AHB1_ENR |= 1 << 3;      // Activation horloge GPIOD

Cette étape est essentielle pour que le microcontrôleur puisse accéder et contrôler le port GPIOD.

Étape 3 : Configuration de la broche PD12 en sortie

La broche PD12 doit être configurée en sortie générale push-pull à 50 MHz. Pour cela :

• Configurer les bits 25-24 du registre MODER à 01 (mode sortie pour PD12).
• Mettre le bit 12 du registre OTYPER à 0 (push-pull).
• Configurer la vitesse à 50 MHz en mettant bits 25-24 du registre OSPEEDR à 01.
• Configurer le registre PUPDR bits 25-24 à 00 (aucun pull-up/pull-down).

En C :

*MODREG &= 0xFCFFFFFF;  // Effacer bits 25-24
*MODREG |= 0x01000000;  // Mettre bits 25-24 à 01 (mode sortie)

*DOTYPE &= ~(1 << 12);  // Push-pull (bit 12 = 0)

*DSPEED &= 0xFCFFFFFF;  // Effacer bits 25-24
*DSPEED |= 0x01000000;  // Vitesse 50 MHz (bits 25-24 = 01)

*PUPPDR &= 0xFCFFFFFF;  // Pas de pull-up/pull-down (bits 25-24 = 00)

Cette configuration prépare la broche PD12 pour piloter une LED.

Étape 4 : Faire clignoter la LED PD12

Pour faire clignoter la LED, il faut alterner l'état du bit 12 du registre ODR :

• Mettre le bit 12 à 1 pour allumer la LED.
• Insérer un délai (tempo) pour que l'allumage soit visible.
• Mettre le bit 12 à 0 pour éteindre la LED.
• Insérer un délai identique.
• Répéter indéfiniment.

La fonction de délai est une simple boucle vide :

void tempo(volatile unsigned int CNT){
  for(; CNT > 0; CNT--);
}

Le code principal :

while(1){
  *DODR |= 1 << 12;    // Allumer LED PD12
  tempo(0xffffff);     // Délai
  *DODR &= ~(1 << 12); // Éteindre LED PD12
  tempo(0xffffff);     // Délai
}

Ce programme fait clignoter la LED connectée à PD12 avec un temps d'allumage et d'extinction visible.

Code complet de l'application

volatile unsigned int* MODREG = (unsigned int *) 0x40020C00;
volatile unsigned int* DOTYPE = (unsigned int *) 0x40020C04;
volatile unsigned int* DSPEED = (unsigned int *) 0x40020C08;
volatile unsigned int* PUPPDR = (unsigned int *) 0x40020C0C;
volatile unsigned int* DODR   = (unsigned int *) 0x40020C14;

volatile unsigned int* AHB1_ENR = (unsigned int *) 0x40023830;
volatile unsigned int* AHB1_RSTR = (unsigned int *) 0x40023810;

void tempo(volatile unsigned int CNT){
  for(; CNT > 0; CNT--);
}

int main(){
  // Réinitialiser GPIOD
  *AHB1_RSTR |= 1 << 3;
  *AHB1_RSTR &= ~(1 << 3);

  // Activer horloge GPIOD
  *AHB1_ENR |= 1 << 3;

  // Configurer PD12 en sortie push-pull 50 MHz
  *MODREG &= 0xFCFFFFFF;
  *MODREG |= 0x01000000;

  *DOTYPE &= ~(1 << 12);

  *DSPEED &= 0xFCFFFFFF;
  *DSPEED |= 0x01000000;

  *PUPPDR &= 0xFCFFFFFF;

  while(1){
    *DODR |= 1 << 12;    // Allumer LED
    tempo(0xffffff);
    *DODR &= ~(1 << 12); // Éteindre LED
    tempo(0xffffff);
  }
}

Résultats attendus

Après compilation et programmation de la carte STM32F4Discovery, la LED connectée à la broche PD12 (LED4 sur la carte) doit clignoter régulièrement. Le clignotement doit être visible à l'œil nu avec un temps d'allumage et d'extinction d'environ quelques centaines de millisecondes, selon la valeur du délai dans la fonction tempo.

Pièges courants

• Oubli d'activer l'horloge du port GPIOD : sans cette activation via RCC_AHB1ENR, la configuration et la commande du port ne fonctionnent pas.
• Mauvaise adresse des registres : vérifier que les adresses des registres correspondent bien au port et registre ciblés.
• Configuration incorrecte du mode de la broche : le mode doit être sortie générale (bits MODER à 01) pour piloter une LED.
• Optimisation du compilateur : ne pas oublier le mot-clé volatile pour les pointeurs vers registres, sinon les accès peuvent être optimisés et ne pas produire l'effet attendu.
• Délais trop courts ou trop longs : ajuster la valeur passée à la fonction tempo pour obtenir un clignotement visible et stable.
• Confusion entre bits et positions : bien utiliser le bit 12 pour la broche PD12 dans les registres ODR, OTYPER, etc.