Exercice STM Nucleo FCU

Vous trouverez sur cette page toutes les informations, exercices, et fichiers nécessaires à la prise en main et à la réalisation d'un prototype de FCU (Flight Control Unit) dans le cadre de travaux dirigés (TD) à faire en classe.

Fonctions de base Nucleo

Void HAL_GPI0_Init() : Cette fonction est utilisée pour initialiser les broches d’entrée ou de sortie pour les LEDs ou les boutons disponibles sur la carte Nucleo.

Void HAL_UART_Init() : Cette fonction est utilisée pour initialiser le module UART (communication série), qui sert à communiquer avec l’ordinateur.

Void HAL_TIM_Base_Start() : Cette fonction est utilisée pour démarrer un timer, utile par exemple pour mettre à jour périodiquement un affichage ou une mesure d’un capteur.

Void HAL_GPI0_ReadPin/WritePin() : Cette fonction permet de lire ou d’écrire l’état d’un port de la carte Nucleo.

Installation des bibliothèques STM Nucleo dans le logiciel Arduino

Carte Nucleo utilisée

La carte X-Nucleo IKS01A2 fonctionne de la même manière qu’une carte Arduino, d’ailleurs on utilise le même logiciel (Arduino) pour la faire foctionner et reccueillir des informations.

Afin de pouvoir commander cette carte par l’intermédiaire du logiciel Arduino, il est nécessaire d’installer une bibliothèque accessible via ce lien : https://www.arduinolibraries.info/libraries/stm32duino-x-nucleo-iks01-a2

Prendre la dernière version disponible. Un fichier .zip sera alors téléchargé sur votre ordinateur.

Sur Arduino, aller dans Croquis -> Inclure une bibliothèque -> Ajouter la bibliothèque .ZIP.

Sélectionner le fichier téléchargé précédemment (ne pas le décompresser).

Pour inclure cette bibliothèque dans le code, aller dans Croquis -> Inclure une bibliothèque ->STM32duino-X-NUCLEO-IKS01A2, la ligne de code #include <X-NUCLEO-IKS01A2.h> doit apparaître.

Il faut maintenant installer le protocole de communication utilisé pour la carte Nucleo. Pour cela, aller dans Fichier -> Préférences, puis rentrer ce lien dans URL de gestionnaire de cartes supplémentaires : https://github.com/stm32duino/BoardManagerFiles/raw/main/package_stmicroelectronics_index.json

Cliquer ensuite sur OK.

Le protocole est maintenant téléchargé, pour l’installer, aller dans Outils -> Type de carte -> Gestionnaire de carte.

Dans la barre de recherche, taper « stm », vous devriez avoir l’écran suivant :

Sélectionner la dernière version disponible (ici 2.4.0) puis Installer. Le processus prend quelques minutes. Si tout s’est bien déroulé, la mention INSTALLED doit apparaître.

Exercice 1 : Faire clignoter une LED

Etape 1 : branchements

Branchez une LED sur une broche GPIO (par exemple, la broche PA5) de la carte Nucleo en utilisant une résistance de limitation de courant (par exemple, une résistance de 220 ohms) en série avec la LED. La borne positive de la LED doit être connectée à la broche GPIO et la borne négative doit être connectée à la résistance, puis à la masse (GND) de la carte.

Etape 2 : initialisation

Il est important de commencer par disposer d’un IDE (Integrated Developement Environnement) adapté au micro-controleur STM32. Créer un nouveau projet pour la carte Nucléo en sélectionnant le type de microcontrôleur utilisé sur votre carte Nucleo (ici STM32).

Ajoutez un fichier source "main.c" à votre projet. Ajoutez le fichier d'en-tête pour le microcontrôleur utilisé dans la carte Nucleo (par exemple, stm32fxxx.h). Ce sont les headers de la bibliothèque HAL.

Initialisez la broche GPIO pour la sortie en écrivant un 1 dans le registre de configuration approprié (par exemple, GPIOA->MODER |= GPIO_MODER_MODE5_0).

Etape 3 : code

Bouclez indéfiniment et allumez la LED en écrivant un 1 dans le registre de sortie (par exemple, GPIOA->BSRR = GPIO_BSRR_BS5) pendant une courte période, puis éteignez la LED en écrivant un 1 dans le registre de sortie (par exemple, GPIOA->BSRR = GPIO_BSRR_BR5) pendant une autre courte période. Répétez cette séquence pour faire clignoter la LED.

Voici un exemple de code en langage C qui utilise la carte Nucleo STM32F401RE pour faire clignoter une LED connectée à la broche PA5.

Remarque : Les codes utilisent ici la broche PA5 pour la sortie de la LED, il faut bien sûr s'adapter à la broche sur laquelle on est branché. Ce code utilise la fonction "for" pour attendre pendant une courte période après chaque changement d'état de la LED. Le nombre de boucles peut être ajusté pour changer la vitesse de clignotement de la LED.

Aide : Voici un schéma de branchement de branchement typique pour une LED sur une carte Nucléo.

Dans ce schéma, R1 est la résistance de limitation de courant et GPIO est la broche GPIO de la carte Nucleo à laquelle la LED est connectée. La borne positive de la LED est connectée à la broche GPIO et la borne négative est connectée à la résistance, puis à la masse (GND) de la carte.

Notez que la valeur de la résistance R1 dépend de la tension d'alimentation de votre carte Nucleo et de la caractéristique de la LED que vous utilisez. Une valeur typique pour la résistance est de 220 ohms.

Exercice 2 : Récupérer la position d'un joystick non-analogique

Etape 1 : branchements

Branchez le joystick sur la carte Nucleo en utilisant des câbles de raccordement. Le joystick a généralement deux axes de mouvement (X et Y) et un bouton de pression. Chaque axe est relié à deux broches (par exemple, la broche A0 et la broche A1), tandis que le bouton est relié à une autre broche (par exemple, la broche D2). Assurez-vous de connecter les broches correctes du joystick aux broches correspondantes de la carte Nucleo.

Etape 2 : initialisation

Ouvrez votre IDE et créez un nouveau projet ; ajoutez ensuite un fichier source "main.c". Incluez ensuite le header pour utiliser les fonctions HAL comme dans l'exercice précédent. Dans la fonction "main.c", initialisez les broches GPIO lecture en écrivant un 0 dans le registre de configuration approprié (par exemple, GPIOA->MODER &= ~(GPIO_MODER_MODE0_Msk | GPIO_MODER_MODE1_Msk)).

Etape 3 : code

Bouclez indéfiniment et lisez les broches GPIO correspondantes pour récupérer la position du joystick. Pour cela, vous pouvez utiliser la fonction "GPIO_ReadPin" pour lire la valeur de la broche GPIO. Ensuite, vous pouvez utiliser des conditions pour déterminer la position du joystick (par exemple, si la valeur de la broche X est faible et la valeur de la broche Y est élevée, le joystick est en haut à droite).

Voici un exemple de code en langage C qui utilise la carte Nucleo STM32F401RE pour récupérer la position (non-analogique) d'un joystick connecté aux broches PA0, PA1 et PB2.

Remarque : Cet exemple utilise les broches PC0 et PC1 pour les entrées du joystick, il faut bien sûr s'adapter aux broches sur lesquelles on est branché.

Aide : Voici un schéma de branchement typique pour récupérer la position (non-analogique) d'un joystick sur une carte Nucleo.

Remarque : Dans ce schéma, R1, R2 et R3 sont des résistances de pull-down, qui permettent de fixer un état de référence à chaque broche du joystick. Les broches du joystick sont reliées à la carte Nucleo en utilisant des câbles de raccordement. Les broches X-Axis et Y-Axis sont reliées à deux broches GPIO de la carte Nucleo (par exemple, les broches PA0 et PA1), tandis que la broche Button est reliée à une autre broche GPIO de la carte (par exemple, la broche PB2). Les résistances R1, R2 et R3 sont connectées entre chaque broche du joystick et la masse (GND) de la carte Nucleo.

Notez que la valeur de chaque résistance dépend de la caractéristique du joystick et de la carte Nucleo que vous utilisez. Une valeur typique pour chaque résistance est de 10k ohms.

Exercice 3 : Commander un moteur

Branchez votre joystick en utilisant les broches analogiques de la carte, puis créez un nouveau projet sur votre IDE.

Ajoutez ensuite le code suivant pour initialiser les broches analogiques d'entrée branchées au joystick.

Créez une fonction pour lire les valeurs analogiques du joystick avec le code suivant.

Utilisez les valeurs des coordonnées pour contrôler les moteurs avec le code suivant.

Dans le programme principal (boucle "loop"), appelez les fonctions créées précédemment.

Une fois compilé et téléversé sur la carte, les mouvements du joystick contrôleront les moteurs dans les directions souhaitées avec une précision due au fonctionnement analogique (un mouvement plus appuyé entrainera plus de mouvement du moteur associé).

Ces exercices simples correspondent aux fonctions qui pourraient être utiles pour une utilisation basique de la carte Nucleo.

Exercice 4 : Récupérer la position d'un potentiomètre

En guise de dernier exercice, nous avons pensé à une application également très concrète pour le Mini-Bee : il s'agit de la gestion par la carte Nucleo d'un potentiomètre. En effet, un drone doit pouvoir monter ou descendre verticalement, impliquant une montée ou une baisse de régime simultanée de l'ensemble des rotors. Ainsi, un potentiomètre analogique permettrait de contrôler finement l'appareil sur l'axe vertical.

Pour faire fonctionner un potentiomètre avec une carte Nucleo, voici les étapes à suivre :

Pour commencer, il faut brancher le potentiomètre sur un port GPIO de la carte (qu'il ne faut bien entendu pas oublier d'initialiser). Ensuite, on branche plusieurs LEDs à d’autres broches GPIO, sans oublier de brancher également en série des résistances de protection. Ces LEDs serviront donc à donner un indice visuel sur le niveau d'enfoncement du potentiomètre : plus le potentiomètre émet un signal analogique élevé, plus il y a de LEDs allumées.

Voici donc un exemple de code qui permettrait de récupérer la position analogique d'un potentiomètre et de l'afficher à l'aide de 3 LEDs.

#include"mbed.h"
	 
AnalogIn enfoncement_potentiometre(A0);
	 
DigitalOut led_1(D2);
DigitalOut led_2(D3);
DigitalOut led_3(D4);
	
int main() {
 while(1) {      
  uint16_t valeur = enfoncement_potentiometre.read_u16(); 
  if (valeur < 50) {
   led_1 = 0;  
   led_2 = 0;  
   led_3 = 0;  
  }
  else if ((valeur >= 50) && (valeur < 2000)) { 
   led_1 = 1;  
   led_2 = 0;  
   led_3 = 0;  
  }
  else if ((valeur >= 2000) && (valeur < 4000)) {
   led_1 = 1; 
   led_2 = 1; 
   led_3 = 0;  
  }
  else if (valeur >= 4000) {
   led_1 = 1;  
   led_2 = 1;  
   led_3 = 1;  
  }   
 }
}

Exercise 2: Retrieve the Position of a Non-Analog Joystick

Step 1: Wiring

Plug the joystick into the Nucleo board using jumper cables. The joystick usually has two axes of movement (X and Y) and a pressure button. Each axis is connected to two pins (for example, pin A0 and pin A1), while the button is connected to another pin (for example, pin D2). Make sure to connect the joystick's correct pins to the corresponding pins on the Nucleo board.

Step 2: Initialization

Open your IDE and create a new project; then add a "main.c" source file. Next, include the header to use the HAL functions as in the previous exercise. In the "main.c" function, initialize the GPIO reading pins by writing a 0 in the appropriate configuration register (for example, GPIOA->MODER &= ~(GPIO_MODER_MODE0_Msk | GPIO_MODER_MODE1_Msk)).

Step 3: Code

Loop indefinitely and read the corresponding GPIO pins to get the joystick's position. For this, you can use the "GPIO_ReadPin" function to read the GPIO pin value. Then, you can use conditions to determine the joystick's position (for example, if the X pin's value is low and the Y pin's value is high, the joystick is in the top right corner).

Here's a C language code example that uses the Nucleo STM32F401RE board to retrieve a non-analog joystick position connected to pins PA0, PA1, and PB2.

File:Exercise2 1.png

400px

File:Exercise2 2.png

400px

Note: This example uses PC0 and PC1 pins for joystick inputs; you'll, of course, have to adapt to the pins you're using.

Hint: Here is a typical wiring diagram to retrieve the non-analog position of a joystick on a Nucleo board.

File:Exercise2 3.png

400px

Note: In this diagram, R1, R2, and R3 are pull-down resistors, which set a reference state for each joystick pin. The joystick pins are connected to the Nucleo board using jumper cables. The X-Axis and Y-Axis pins are connected to two GPIO pins on the Nucleo board (for example, pins PA0 and PA1), while the Button pin is connected to another GPIO pin on the board (for example, pin PB2). The resistors R1, R2, and R3 are connected between each joystick pin and the board's ground (GND).

Note that the value of each resistor depends on the joystick and the Nucleo board you're using. A typical value for each resistor is 10k ohms.

Exercise 3: Control a Motor

Plug your joystick using the board's analog pins, then create a new project in your IDE.

Next, add the following code to initialize the input analog pins connected to the joystick.

File:Exercise3 1.png

400px

Create a function to read the joystick's analog values with the following code.

File:Exercise3 2.png

400px

Use the coordinate values to control the motors with the following code.

File:Exercise3 3.png

400px

In the main program (loop), call the functions created earlier.

File:Exercise3 4.png

400px

Once compiled and uploaded to the board, the joystick movements will control the motors in the desired directions with precision due to analog operation (more forceful movement will cause more motor movement).

These simple exercises correspond to the functions that could be useful for basic use of the Nucleo board.

Exercise 4: Retrieve the Position of a Potentiometer

For the final exercise, we thought of a very practical application for the Mini-Bee: it is about the Nucleo board's management of a potentiometer. Indeed, a drone must be able to ascend or descend vertically, implying a simultaneous increase or decrease in all rotors' speed. Thus, an analog potentiometer would allow for fine control of the device on the vertical axis.

To operate a potentiometer with a Nucleo board, here are the steps to follow:

First, you need to plug the potentiometer into a GPIO port on the board (which you should not forget to initialize, of course). Next, connect several LEDs to other GPIO pins, without forgetting to also plug in series protection resistors. These LEDs will serve to give a visual indication of the potentiometer's level of depression: the higher the analog signal emitted by the potentiometer, the more LEDs will light up.

Here is an example code that would allow you to retrieve the analog position of a potentiometer and display it using 3 LEDs.

1. include"mbed.h"

AnalogIn enfoncement_potentiometre(A0);

DigitalOut led_1(D2); DigitalOut led_2(D3); DigitalOut led_3(D4);

int main() { while(1) { uint16_t valeur = enfoncement_potentiometre.read_u16(); if (valeur < 50) { led_1 = 0; led_2 = 0; led_3 = 0; } else if ((valeur >= 50) && (valeur < 2000)) { led_1 = 1; led_2 = 0; led_3 = 0; } else if ((valeur >= 2000) && (valeur < 4000)) { led_1 = 1; led_2 = 1; led_3 = 0; } else if (valeur >= 4000) { led_1 = 1; led_2 = 1; led_3 = 1; } } }