TP1 Initiation à la carteSTM32F407

Plan
1- Installation de l’environnement
2- Présentation de la carte STM32F407
3- Manipulation des GPIOs
I- Installation de l’environnement
Dans ce TP, nous envisageons configurer la carte STM32f407VGTi-discovery-kit afin
d’explorer toute l’architecture du SoC integré. Pour cela, nous avons besoin d’un
environnement de développement complet
1- STM32CubeMX et STM32CubeF4
Cet outil permet configurer les composants de la carte ainsi que les différents paramètres (les
pins d’E/S, l’horloge….). Après la configuration, cet outil permet de générer un code
C incluant un certain nombre de fonctions de la bibliothèque HAL. Pour cette raison
l’installation de l’environnement contenant les fonctions de cette bibliothèque est
indispensable. Il s’agit de l’environnement STM32CubeF4.
Pour installer le STM32CubeMX et le STM32CubeF4, visiter la page :
https://www.st.com/content/st_com/en.html (Pour le STM32CubeMX, installer une version
supérieure à 4.15 )
Après avoir installé STM32CubeMX, ouvrir cet outil puis taper l’onglet « help » puis «
manage embedded software packages » (ou dans quelques version antérieure « install
packages ») .Appuyer sur « from local » situé en bas. Puis sélectionner le chemin dans lequel
vous avez placé le fichier de STMCubeF4_Vxxx.zip. Ceci permettra de charger le contenu de
la bibliothèque HAL dans un répertoire « repository ». Noter le chemin de ce répertoire, vous
allez en servir plus tard.
2-

Keil uvision 5
Cet outil permet d’éditer le code qui va tourner sur la carte STM32. Après avoir configuré la
carte dans l’environnement graphique STM32CubeMX, il est possible d’ouvrir le code généré
par STM32CubeMX et d’y ajouter le code qui décrit le fonctionnement qui va être effectué
sur la carte Discovery f4. Par exemple dans STM32CubeMX, il est possible de définir si un
port servira d’Input ou Output, dans l’environnement Keil, il est possible de décrire les
fonctions relatives à l’utilisation de ce port (lecture, écriture, condition…).
L’installation de Keil uvis ion5 est effectuée à
travershttps://www.st.com/content/st_com/en.html
Une fois installé et lancé, ouvrir le « pack installer » et sélectionner le pack de la carte
stm32f407VGTx pour l’installer comme le montre la figure suivante. Ceci permettra à l’outil
Keil de reconnaitre les composants de cette carte.

Pour vérifier si ce pack a été bien installé ou pas. Créer un nouveau projet dans Keil. Vérifier
la présence du menu « STmicroelectronics » tout comme le menu « ARM »

3- ST_link
Cet environnement peut être téléchargé à partir du site
dehttps://www.st.com/content/st_com/en.html.
Il permettra de configurer la carte STM32 et de lancer la session de débogage.
II- Présentation de la carte STM32F407
L’objectif de ce TP est de se familiariser avec la carte STM32f407 (Fig. 1) et ces
périphériques. La famille des microprocesseurs STM32f4 de ST Microelectronics fournit une
vaste gamme de périphériques autour d’un cœur ARMRCortexR-M4 32-bit. Dans ce TP, on
considère la carteSTM32f407VG illustrée par la figure 1. Les caractéristiques et les
fonctionnalités de cette carte sont accessibles depuis ses 100 ports broches (Pins) ainsi que
d’autres périphériques de liaisons, allant des simples GPIOs et des interfaces de
communication série synchrone (SPI) ou asynchrone (RS232) jusqu’aux interfaces plus
complexes comme l’USB, l'Ethernet et le HDMI, etc.
Nous allons nous intéresser précisément, à ses entrées/sorties générales (LED, Bouton
poussoir…) et quelques fonctionnalités possibles notamment les fonctions d’interruption.
Pour y faire, nous allons exploiter certaines sections de la datasheet de la plateforme présentée
(Fig. 1) afin d’acquérir le nécessaire pour mener à bien cette manipulation.

Figure 1. Aperçu général de la carte STM32

Ce TP vise la manipulation des étapes suivantes :
• Compiler et exécuter un programme a partir des Environnements de Développement Intégré
(IDE) STM32CubeMX et MDK (ARM V5).
• Contrôler les entrées/sorties digitales du microcontrôleur.
III- MANIPULATION
1. Programmation de STM32F407 dans un kit d’évaluation STM32F4-Discovery pour
clignoter les LED du kit.
2. Faire clignoter des LEDs est un programme basique très élémentaire et assez simple qui
vise à la fois de découvrir l’univers de la carte STM32 et de s’assurer du bon fonctionnement
et de la bonne synchronisation entre le Software et le Hardware. Les deux environnements de
développement intégré qu’on va l’utiliser sont le STM32CubeMX et le MDK (ARM V5).
A- STM32CubeMX
Avec la carte STM32, STMicroelectronics fournit un outil logiciel complet, réduisant
considérablement les efforts de développement, le temps et les couts. Le STM32CubeMX est
un outil graphique qui permet une configuration très simple des microcontrôleurs et la
génération du code C d'initialisation correspondante.
• Pour commencer, ouvrir le logiciel STM32CubeMX et créer un nouveau projet comme il est
illustré sur la figure suivante.

• Sélectionner la plateforme d’évaluation (Board) STM32F4 -Discovery, et la référence du

processeur STM32F407 VGTx comme le montre la figure suivante
• Une fois vous avez bien sélectionné la plateforme, cliquez sur l’onglet start Project.
• Vous pouvez réinitialiser la configuration des pines du microcontrôleur en cliquant sur
l’onglet Pinout → Clear Pinouts :

• L’étape suivante consiste à configurer les pins d’entrées/sorties de la plateforme. On va

utiliser le bouton poussoir de l’utilisateur comme entrée et les 4 LED (LED 3, LED 4, LED 5
et LED 6) comme sorties. En pratique, le bouton poussoir est lié au Pin PA0 et les LED 3, 4,
5 et 6 sont liées respectivement aux Pin PD12, PD13, PD14 et PD15(vérifier la figure 1).
Vous pouvez vérifier les connexions des pines sur la figure suivante, extraite à partir du
datasheet de la plateforme.
• Dans la branche des pins, faire les configurations graphiques suivantes pour PA0, PD12,
PD13, PD14, PD15.

Avec la configuration des entrées/ sorties, nous aurons besoin de sélectionner un type
d’horloge pour notre microcontrôleur, sous l’onglet RCC, sélectionner le type
Crystal/Ceramic Resonator.

A ce stade, nous avons configuré graphiquement tous les pins nécessaires de la

plateformeSTM32. La dernière étape, avant de migrer vers a l’environnement de
programmation Keil MDK μ5,consiste à paramétrer les options d’intégration du projet à
savoir : le nom du projet, l’emplacement, l’outil IDE (Toolcchain/IDE) et la version de la
bibliothèque utilisée (Firmware Package). La figure suivante présente les paramètres à
introduire dans l’onglet« Project Settings ».
Dans la figure précédente, noter que :
• Le toolchain/IDE est MDK-ARM qui est intégré dans l’environnement Keil. (utiliserla
version 5)
• Dans le MCU Reference: vérifier qu’il s’agit bien de la carte STM32F407VGTx
• Pour le firmware package location sélectionner l’emplacement du répertoire« repository»
dans lequel se trouve l’environnement STM32CubeF4.
Il ne reste maintenant que la génération du Code C équivalent à la configuration réalisée
onglet Project puis Generate Code.

Apres la réussite de la génération du code par STM32CubeMX, appuyer sur « Open Project
»ceci permet d’ouvrir le code généré dans l’environnement keil uvision 5.
B- Keil MDK uvision
Keil MDK est un environnement complet de développement de logiciels pour une large
gamme de microcontrôleurs a bras Cortex-M. MDK comprend le μVision IDE et le
débogueur, le compilateur Arm C / C ++ et les composants essentiels du middleware. Il
contient également de nombreux exemples pratiques prêts à exécuter pour les cartes utilisant
des processeurs ST. Le code généré par STM32CubeMX est ouvert dans Keil. Sous le fichier
Application/Userouvrir le sous-fichier Main.c. Le code (Main.c) contient les fonctions
suivantes:
-l’entête du fichier (nom du programme, la bibliothèque utilisée), exemple :
/* Includes ------------------------------------------------------------------*/
#include « main.h »
#include « stm32f4xx_hal.h »
- les fonctions de configuration équivalentes à la configuration graphique réalisée sur
STM32CubeMX, exemple

/* Private function prototypes -----------------------------------------------*/

void SystemClock_Config(void); /* pour la configuration du Clock
static void MX_GPIO_Init(void); /* pour la configuration des E/S GPIO
- la fonction main principale
int main(void)
{
….
….
}
- Des zones délimitées par les commentaires « /* USER CODE BEGIN …*/ » et « /*
USERCODE END…*/ » allouées à l’utilisateur pour ajouter des codes personnalises.
/* USER CODE BEGIN 1 */
….
….
/* USER CODE END 1 */
Remarque
Il est très important d’ajouter votre code dans les zones délimitées par les commentaires
« /*USER CODE BEGIN …*/ » et « /* USER CODE END…*/ » car si vous retournez dans
cube pour modifier la configuration du microcontrôleur, la régénération automatique du
code écraserale code qui n’a pas été écrit dans ces zones.
• Pour faire clignoter des LEDs 12, 13, 14 et 15 de la plateforme, ajouter les deux instructions
suivantes dans la boucle while du programme principale main(void).
Attention !!!! Le code ajouté doit être introduit dans la zone allouée à l’utilisateur comme le
montre la figure suivante.
HAL_GPIO_TogglePin (GPIOD, GPIO_PIN_12| GPIO_PIN_13|
GPIO_PIN_14|GPIO_PIN_15);
HAL_Delay (2000) ;
• La fonction TogglePin de la bibliothèque HAL permet le clignotement de LED(inverser
l’état de la LED à chaque itération).
• L’instruction GPIOD permet la sélection du bloc D de la plateforme STM32. En effet, la
carte a 4 blocs GPIO relativement à (gauche, droite, haut et bas)
• La fonction « HAL_Delay(2000) » permet de faire une temporisation de sec (2000 ms).
Compiler le code et vérifier s’il y a des erreur s comme le montre la figure suivante.

C- Implémentation sur la carte

1- Brancher la carte à travers le port mini-USB
2- Vérifier que les connecteurs CN3 sont court-circuités comme le montre la figure
suivante

3- Vérifier la connexion de la carte

4- Programmer la carte et tester le fonctionnement

5- Lancer une session de débogage et exécuter le code sur la carte en appuyant sur « run»
comme le montre la figure suivante
 Noter que la zone A représente la traduction en assembleur du code C situé dans la zone B.
Finalement la zone C représente l’état des registres internes du processeur CortexM4 situé
dans la carte
6- Fermer la session de débogage et modifier le code C de telle sorte que la LED bleue
du kit s’allume lorsqu’on appuie sur le bouton User. La lumière s’éteint lorsqu’on
relâche le bouton.
Annexe
Fonction Exemple Description
HAL_GPIO_ReadPin Lit l’état du pin PA0
void HAL_GPIO_ReadPin (GPIOA,GPIO_PIN_0)
(GPIO_TypeDef *GPIOx,
uint16_tGPIO_Pin)
HAL_GPIO_WritePin Cette fonction éteint
void HAL_GPIO_WritePin (GPIOD, la led 3 (la variable
(GPIO_TypeDef *GPIOx, uint16_t GPIO_PIN_12, GPIO_PIN_SET
GPIO_Pin, GPIO_PinState PinState) GPIO_PIN_RESET) permet de l’allumer)

HAL_GPIO_TogglePin Permet d’inverser

void HAL_GPIO_TogglePin (GPIOD, GPIO_PIN_12) l’état de la led 3
(GPIO_TypeDef *GPIOx, uint16_t
GPIO_Pin)