Guide STM32CubeIDE

De Polybot Grenoble
Aller à : navigation, rechercher
Suite STM32Cube

Présentation

STM32CubeIDE est l'interface de programmation (IDE) que nous utilisons pour programmer les microcontrôleurs de nos robots.

Qu'est ce qu'un microcontrôleur

Les microcontrôleurs (microC, uc et MCU), sont des ordinateurs minimalistes. Vous en connaissez sûrement déjà commes les cartes Arduino. Les MCU sont peu rapides et puissants mais ils possèdent un coût peu élevé, consomment peu et surtout ont un niveau d’intégration beaucoup plus important qu’un ordinateur !

Un haut niveau d’intégration signifie qu’ils possèdent de nombreux canaux de transmission appelés BUS (UART, I2C ou SPI). Ces BUS permettent de commander des actionneurs, communiquer avec des capteurs voire échanger avec d'autres microcontrôleurs ou une Raspberry par exemple.

Ainsi les MCU sont fréquemment utilisés pour les robots :) , mais aussi dans tous les systèmes embarqués. Par exemple dans l’automobile, l'aviation, les télécommandes, les jouets, la téléphonie mobile, etc. Nous allons maintenant étudier comment ils se programment.

Pourquoi utilisé CubeIDE

Les MCU étant des ordinateurs minimalistes, ils ne possèdent pas de système d’exploitation (linux etc…). Il n’y en a aussi pas l'intérêt. De ce fait, les programmes au sein de MCU sont souvent codés, compilés puis téléversés par un ordinateur extérieur. Plusieurs solutions existent comme les systèmes arduino, le compilateur en ligne MBED ou bien Atollic. MBED et Arduino ont l'avantage de permettre une prise en main rapide. Cependant pour les prendre en main vous trouverez de nombreux tutos sur internet. Et ils ne sont pas utilisés à Polybot ! À Polybot, nous utilisons CubeIDE pour avoir une architecture logicielle commune. De plus CubeIDE permet d'utiliser des OS temps réel qui nous permette d’avoir un contrôle précis de ce que nous faisons. Enfin CubeIDE est une solution professionnelle utilisée en entreprise, ainsi prendre en main cette outil est un véritable atout pour votre CV.

Utilisation de STM32CubeIDE

Installation

Créer un nouveau projet

  • Accéder à File>New>STM32 Project.
  • Choisissez votre cible (généralement dans l'onglet Board Selector) puis Next.
  • Saisissez un nom de projet et le langage cible. Afin d'avoir une compatibilité maximale, choisissez C++ ainsi vous pourrez utiliser des bibliothèques C++ même si le reste de vos sources sont en C. Laissez Binary Type et Project Type par défaut.
  • Répondez Oui à la question Voulez-vous initialiser tous les périphériques avec leurs paramètres par défaut?.
  • Vous êtes maintenant sur la perspective STM32CubeMX. Ici, il va être possible d'ajouter des fonctionnalités supplémentaire (en suivant ces astuces).
  • Lorsque vous avez terminé, sauvegarder le fichier .ioc, cela générera les sources nécessaires.
  • Vous êtes prêt à programmer.

Importer un projet existant

Pour importer un projet existant (après avoir cloner un dépot Git par exemple), il est facile de l'importer sous STM32CubeIDE.

Pour cela, accédez à File>Open project from File System.

Rechercher le projet sur votre ordinateur et cliquez sur Terminer

Astuces & conseils

Balises STM32CubeMX

Lors de la génération (ou regénération) du fichier main.c, STM32CubeMX ajoute des balises de la forme /* USER CODE BEGIN X */ et /* USER CODE END X */. Lorsque vous ajoutez du code dans ce fichier, veillez à le faire entre ces balises, sinon votre code sera supprimé si vous regénérez ultérieurement votre projet avec STM32CubeMX.

Si vous devez ajouter du code à un endroit ou aucune balise n'est disponible, c'est sûrement que vous ne vous y prenez pas de la bonne manière...

Projet C et C++

Explication

Lors de la création d'un projet, nous avons la possibilité de sélectionner le langage cible en tant que C++. Malheureusement, STM32CubeMX ne supporte actuellement pas ce langage. Les fichiers générés par ce dernier seront en C et en particulier le fichier main.c.

Lorsque l'on veut utiliser, ou produire du code C++, il est nécessaire que le fichier main soit en C++. La solution est alors de renommer le fichier main.c en main.cpp. Si le langage cible du projet a bien été réglé sur C++, alors le projet compilera avec succès.

Le problème se produit quand on veut regénerer le projet avec STM32CubeMX. Il va recréer un nouveau fichier main.c à coté de notre fichier main.cpp. Le nouveau code généré sera donc dans le fichier main.c et non main.cpp.

Résolution du problème

  • Fusionner les deux fichiers de manière manuelle dans main.cpp: garder la génération de STM32CubeMX présente dans le fichier main.c et garder le code présent entre toutes les balises du fichier main.cpp.
  • Exclure le fichier main.c du build: clic droit sur main.c > Ressource Configurations > Exclude from build. Ceci indiquera au compilateur de ne pas compiler ce fichier. Il compilera néanmoins main.cpp et ne trouvera pas de conflit.

Notes

Il est possible que ce problème ne soit plus suite à des futures mises à jour de STM32CubeMX. Lors de la rédaction de ce guide, les projets C++ ne sont pas supportés pleinement.

Hello W... LED ! (Commencer ici!) Utilisation des GPIOs

Introduction

Dans cette partie, nous allons apprendre diverse manière d'allumer une LED à partir des GPIOs de notre carte.

Présentation des GPIOs

GPIO signifie General Purpose Input Output, il s'agit donc des entrées et des sorties des pins de votre carte. En output, il peut vous permettre d'alimenter une pin d'un de vos composants ou bien une LED. En input, il peut permettre de détecté l'état d'un composant extérieur par exemple celui d'un bouton poussoir.

Entrée en matière commander une LED

Dans cette exercice, nous allons alimenté la LED PA5 et commandé la LED avec le bouton poussoir PC13. Ces deux composants sont intégré à la STM32F446.

Configuration sur CubeMx

Ouvrez le projet, comme il est montré à la section 2.2.

Capture2.png

Si vous utilisez une STM32 et avez généré la configuration générale qui vous est proposé en initialisation du projet, vous obtenez la vue ci-dessus. Sinon, soit vous avez oubliez de générer la configuration standard, soit vous avez sélectionné le MCU à la place de la board.

Sur cette image, vous observez les ports PC13 et PB5 en vert. On en déduit que les ports respectifs au bouton poussoir et à la LED sont ENABLE.
Si vous réalisez un clic droit sur PB5, vous remarquerez que le port de PB5 est en OUTPUT. Si vous réalisez un clic droit sur PC13 vous remarquer que le port n'est pas en INPUT mais EXTI. Nous aborderons la signification de cette configuration plus tard. Pour ce tutoriel cliquez sur PC13 et sélectionnez INPUT. Générez votre code en appuyant sur CTRL+S.

Maintenant que la configuration sur Mx a été réalisé, nous allons aborder le code.

Alimenté une LED

Pour alimenter une LED, nous allons utilisé la fonction HAL_GPIO_WritePin(GPIOx, GPIO_Pin, PinState). Cette fonction permet de commander l'état d'un port GPIO en OUTPUT.
Le premier argument correspond à la famille du GPIO qui correspond à une lettre par exemple GPIOA, GPIOB et etc.
Le second argument correspond au numéro du GPIO. Le troisième correspond à l'état haut ou bas du GPIO. Vous pouvez entré 1 ou 0 ou bien les constantes SET ou RESET pour plus lisibilité.

Pour notre application, nous allons écrire HAL_GPIO_WritePin(GPIOA, GPIO_PIN_5, SET) entre les balises /* USER CODE BEGIN 2 */ et /* USER CODE END 2 */.

Vous pouvez maintenant compilez et voir votre LED s'allumer. Féliciation !

Commander une LED avec un bouton poussoir

Pour commander votre LED avec le bouton poussoir, revérifiez une seconde fois que votre port PC13 est en INPUT.

Notre objectif est que lorsque l'on appuie sur le bouton la LED s'allume puis que si on rappuie dessus elle s'éteigne.

Pour ce faire, nous allons utiliser les fonctions HAL_GPIO_ReadPin et HAL_GPIO_TogglePin. La première est utilisé sur un port en INPUT, elle permet de lire l'état d'entrée. La seconde est utilisé en output, elle inverse l'état de sortit si état haut alors état bas et inversement.
Leur premier argument est la famille du GPIO.
Le second argument correspond à son numéro.
Ainsi pour réussir notre application, nous allons réaliser le code suivant:

Code pour commander la LED avec le Boutton PC13.png

Vous connaissez maintenant les fondamentaux sur les GPIOs. Nous allons maintenant vous proposer diverse petit projet à réaliser par vous même pour consolider vos bases.

POUR ALLER PLUS LOIN

PROJET 1 : Faire clignoter une LED avec HAL_DELAY

Faite clignotez une LED avec la fonction HAL_Delay(tmps) tmps en secondes.

PROJET 2 : Clignoter une LED + boutons poussoir

Lorsque l'on appuie une fois sur le bouton la LED clignote et lorsque l'on appuie une seconde fois elle s'éteint.

PROJET 3 : Commander une LED externe à la carte

Pour ce projet, réutilisez l'un des codes vue auparavant. Configurez un nouveau port de sortie output sur CubeMx. Branchez une résistance en série à une LED sur le nouvelle OUTPUT puis exécuter votre code. ATTENTION, utilisez bien une RÉSISTANCE sinon la LED EXPLOSERA !

PROJET 4 : Commander une LED avec un capteur de fin de course

UART: utilisation du printf

Afin de rediriger le printf sur une liaison série (et afficher des messages dans une console par exemple) il est nécessaire de réaliser quelques modifications:

1. Aller dans le fichier Core/Src/main.c/cpp.

2. Ajouter entre les balises /* USER CODE BEGIN 0 */ et /* USER CODE END 0 */ la fonction suivante:

int __io_putchar(int ch)
{
	uint8_t c = ch & 0x00FF;
	HAL_UART_Transmit(&huart2, &c, 1, 10);
	return ch;
}

3. Ajouter entre les balises /* USER CODE BEGIN Includes */ et /* USER CODE END Includes */ l'include suivant:

#include <stdio.h>

Lors de l'utilisation du printf, ayez le réflexe d'ajouter systématiquement \n à la fin de chaque trame afin de vider le buffer et bien réaliser la communication.

Dans ce guide, j'utilise le handler sur UART nommé huart2, pour une carte Nucleo F446RE, c'est la liaison utilisée par le ST-Link. Si vous voulez utiliser une autre liaison, pensez à le remplacer. Pour ajouter une nouvelle liaison série, vous pouvez suivre ce guide).

Ajout d'une liaison UART

L'UART fait partie des bus de communication. Un bus de données, vous permet de faire communiquer votre MCU avec votre PC, un autre MCU ou un composant électronique. L'UART est l'un des bus de données les plus anciens, il reste néanmoins toujours utilisé pour sa simplicité. Il s'agit donc du bus de donnée type qu'il faut savoir maîtriser.

Présentation de l'UART

L’Universal Asynchronous Receiver Transmitter comme son nom l’indique est un système de communication série asynchrone. Elle communique exclusivement des bits ou des caractères ASCII. La communication série indique qu’il transmet des bit de données à partir d’un unique fils en opposition des communication parallèle (SPI/I2C).

Fonctionnement de l'UART

Une communication UART s’effectue par deux câbles de données TXD et RXD (transmetter and receiver). Soient les composants 1 et 2, on a TXD1 qui transmet à RXD2 et TXD2 qui transmet RXD1. Il ne faut pas oublier d'ajouter une connexion à la masse pour qu'il est une masse commune au deux composants. L'encodage de l'UART correspondent a un signal qui fait varier sa tension en état haut/bas pour représenter des bits.

Connexion de l'UART

Les message transmis par l’UART sont communément de la forme suivante :
→ Si à l’arrêt START = 1 alors UART = VDD (niveau logique haut)
→ 7 bit après START communication d’un caractère
→ Stop bit toujours = 1
→ Bit de parité doit toujours permettre d’avoir un nombre pair ou impaire de bits pour vérifier la transmission. Son utilisation n'est pas courante actuellement.

Fonctionnement UART

Les messages envoyés peuvent être convertis en signal RS232 (existe aussi RS422 RS485). Il s’agit d’une polarité inversée au lieu de soit 0V ou VDD1 on va avoir soit supérieur à +VDD2 ou inférieur à -VDD2 (Souvent avec VDD2>VDD1). Cela permet de sortir d’un contexte de petit signal qui peut-être imprécis. La liaison UART peut donc se réaliser sur de plus longue distance.
Pour connecter deux UARTs entre eux où un ordinateur à un UART, il y a plusieurs critères à vérifier.
À courte distance de connexion :
On connecte directement TXD1→RXD2 et RXD1→TXD2 + Masse. On s’assure que les niveaux logiques correspondent aux niveaux logiques des deux éléments.
Ensuite on peut télécharger un logiciel de Terminal UART (ex GTKERM (Linux) ou Putty (Windows)), ou alors on peut développer sa propre interface. (Voir libraire Serial sur Python).
Pour plus d'information : https://www.youtube.com/watch?v=kVd8Zj413l8

Mise en place de l'UART sur STM32CubeIDE

Utilisation et Installation PUTTY et GTKTERM

À POLYBOT, nous pouvons vous aider sur deux outils de lecture et rans

Configuration sur MX

Pour débuter, créer un nouveau projet comme décrit dans la section 2.2. (Cible STM32 NUCLEO-F446RE pour ce tuto).

  1. Pour plus de facilité, nous allons utiliser l'UART 2 car il s'agit de l'UART qui est aussi utilisé par le périphérique USB de votre carte.

Pour ce faire, vérifier bien que votre UART2 est enable. Pour cela cliquer sur Pinout and Configuration, puis sur l'onglet Connectivity du menu déroulant de gauche. Si l'UART 2 n'est pas enable alors vous avez soit choisit la mauvaise carte, soit choisi le processeur de la STM au lieu de sa board. Il faut relire la section 2.2 de ce tuto.

Configuration UART sur Mx 1
  1. Ensuite cliquer sur UART2, pour le configurer.
    Configuration UART sur Mx 2
    Sur l'image ci-dessus, nous pouvons lire les informations suivante:

-> baud rate correspond nombre de bits envoyer par seconde. Il s'agit de la vitesse de notre communication. Cette vitesse doit être la même sur les deux composants émetteur-récepteur de l'UART.
-> word length correspond au nombre de bits d'information envoyés par l'UART.
-> parity correspond au nombre de bit de parité, expliqué plus en haut. Il y est écrit none, cela signifie qu'il n'y a pas de bits de parité.
-> bit de stop correspond au nombre de bits utilisés pour déclarer la fin d'un caractère/word. Il est ici à 1.
Pour l'instant, nous n'allons pas toucher ou modifier ces paramètres.

==

Interruptions

Interruption sur GPIO

À faire.

Interruption sur UART

À faire.

PWM et servos

Prérequis

  • Carte STM32 NUCLEO-F446RE
  • STM32 CubeIDE
  • Servomoteur (facultatif)

Fonctionnement d'un servomoteur

Un servomoteur est commandé par un signal PWM (Pulse Modulation Width) de période de 20ms. En fonction de la durée de l'état haut du PWM, le servomoteur va adopter un angle tel que 0°, 90° ou 180°.

Pour commander un servomoteur, nous allons configurer un PWM de fréquence 50Hz (T=20ms), modifier son rapport cycle (CCR1) afin que l'état haut du PWM corresponde à l'angle désiré.

Création de projet

Créer un nouveau projet comme décrit dans la section 2.2. (Cible STM32 NUCLEO-F446RE pour ce tuto)

Configuration via CubeMX

Avant de sauvegarder le fichier .ioc (fichier de config STM32CubeMX) et générer le code du projet, nous devons faire quelques configurations supplémentaires.

  1. Nous choisissons le pin PA5 pour générer le PWM (pin connecté à la LED intégrée LD2). Le signal est généré par un timer et donc nous devons “connecter” le pin à ce périphérique. Pour ce faire, veuillez cliquer sur la pâte PA5 (dans la vue Pinout view). D'après le menu qui apparaît, ce pin peut être connecté au canal 1 du timer 2 (TIM2_CH1) et au canal 1 du timer 8 (TIM8_CH1N). Nous choisissons TIM2_CH1 (cliquer pour activer).
    PWM1.png
  2. Ensuite, accéder à la catégorie Timers (menu à gauche) et sélectionner le TIM2. Activer le canal 1 en mode PWM Generation et choisir Internal Clock comme Clock Source.
    PWM2.png
  3. Maintenant, nous devons configurer les horloges du microcontrôleur. Accéder à l'onglet Clock Configuration. Puis enter 180 MHz comme fréquence de processeur (maximale pour ce microcontrôleur) et appuyer sur entrée. CubeMX règle automatiquement la fréquence des périphériques.
    PWM3.png
  4. D'après la documentation du microcontrôleur (p.16) nous voyons que le timer 2 est connecté au bus APB1.
    PWM4.png
    et d'après la vue précédente, les timers de APB1 tournent à 90 MHz (x2 de APB1 peripheral clocks).
    PWM5.png
  5. Revenant sur la configuration du TIM2, nous devons configurer le registres Prescaler et Counter Period pour régler la fréquence du signal généré d'après la formule suivante : f_PWM = f_APBx_timer/((PSC+1)*(CounterPeriod+1)). Pour arriver à une fréquence de 50 Hz, nécessaire pour piloter un servomoteur analogique, nous pouvons entrer les valeurs suivantes:
    PWM6.png

Programmation

Accéder au fichier main.c (Core/Src/main.c). Ajouter les lignes suivantes pour démarrer la génération du PWM et contrôler son rapport cyclique (entre les balises /* USER CODE 2 */ ).

HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
htim2.Instance->CCR1 = 10000-1; // 10000/20000 = 0.5 (duty cycle)
  1. Vous pouvez également utiliser la fonction
    HAL_TIM_PWM_Stop
    pour arrêter le signal.
  2. Le rapport cyclique est égal au rapport CCRx/CounterPeriod. CounterPeriod nous avons fixé, mais nous pouvons changer le registre CCR1. CCR1=10000 règle le rapport à 0.5 ou 50% dans ce cas.
  3. Vous pouvez utiliser la ligne suivante pour piloter un servo de 270°. CCR1 = 200*(2.5+deg/27)

Code complet

Vous trouverez le code complet de l'exemple ici

Porter une bibliothèque

Cette partie donne des conseils concernant l'utilisation de bibliothèques initialement conçues pour Arduino, Mbed etc.

Beaucoup de bibliothèque sont disponibles. Afin de pouvoir les utiliser dans vos projets, il est nécessaire de les porter. En effet, chaque outil a sa propre HAL (Hardware Abstraction Layer) et il est donc nécessaire de modifier cette partie du code pour que la bibliothèque soit fonctionnelle. En général, les bibliothèques que vous aurez besoin d’utiliser seront des bibliothèques interfaçant des composants, capteurs, actionneurs et donc les parties du code que vous aurez à modifier concernent les liaisons série, UART, I2C etc.

Par exemple les code Mbed suivants:

void VL53L0X::writeReg(uint8_t reg, uint8_t value)
{
    char data_write[2];
    data_write[0]=reg;
    data_write[1]=value;

    handler_i2c.write(address,data_write,2);
}
void wait_custom(int nb_ms)
{
    wait_ms(nb_ms);
}

Seront traduit ainsi avec l'HAL fourni par STMicroelectronics:

void VL53L0X::writeReg(uint8_t reg, uint8_t value)
{
    uint8_t data_write[2];
    data_write[0]=reg;
    data_write[1]=value;

    HAL_I2C_Master_Transmit(&handler_i2c, address, data_write, 2, 10);
}
void wait_custom(int nb_ms)
{
    HAL_Delay(nb_ms);
}

Afin de réaliser un portage avec succès, il est nécessaire de lire les documentations des HAL sources et destinations, afin de comprendre leurs différences et points communs. Dans notre exemple, il a été nécessaire de changer le type de données envoyé sur la liaison I2C, la fonction du HAL Mbed acceptait des données de type char tandis que le HAL fourni par ST accepte des données de type uint8_t.