Voir la source de Guide STM32CubeIDE

[[Fichier:Logo STM32Cube.jpg|frame|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==

* Accéder à https://www.st.com/en/development-tools/stm32cubeide.html.
* Télécharger la dernière version du logiciel pour votre plateforme (cela passe par la création d'un compte myST).
* 
* Programmer.
	
==<span id="creer projet"></span>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 [[#astuces|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''

=<span id="astuces"></span>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 <syntaxhighlight lang="C" inline>/* USER CODE BEGIN X */</syntaxhighlight> et <syntaxhighlight lang="C" inline>/* USER CODE END X */</syntaxhighlight>. 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.<br>
[[Fichier:Capture2.png|cadre|centré]]
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.<br>
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.<br>
Le premier argument correspond à la famille du GPIO qui correspond à une lettre par exemple GPIOA, GPIOB et etc.<br>
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.<br>
Leur premier argument est la famille du GPIO.<br>
Le second argument correspond à son numéro.<br>
Ainsi pour réussir notre application, nous allons réaliser le code suivant:
[[Fichier:Code pour commander la LED avec le Boutton PC13.png|cadre|centré]]
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 <syntaxhighlight lang="cpp" inline>/* USER CODE BEGIN 0 */</syntaxhighlight> et <syntaxhighlight lang="cpp" inline>/* USER CODE END 0 */</syntaxhighlight> la fonction suivante:

<syntaxhighlight lang="cpp">
int __io_putchar(int ch)
{
	uint8_t c = ch & 0x00FF;
	HAL_UART_Transmit(&huart2, &c, 1, 10);
	return ch;
}
</syntaxhighlight>

3. Ajouter entre les balises <syntaxhighlight lang="cpp" inline>/* USER CODE BEGIN Includes */</syntaxhighlight> et <syntaxhighlight lang="cpp" inline>/* USER CODE END Includes */</syntaxhighlight> l'include suivant:
<syntaxhighlight lang="cpp">
#include <stdio.h>
</syntaxhighlight>

Lors de l'utilisation du ''printf'', ayez le réflexe d'ajouter systématiquement <syntaxhighlight lang="cpp" inline>\n</syntaxhighlight> à 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 [[#ajout_uart|ce guide]]).

==<span id="ajout_uart"></span>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.
[[Fichier:Connexion de l'UART.png|cadre|centré|Connexion de l'UART]]
Les message transmis par l’UART sont communément de la forme suivante :<br>
→ Si à l’arrêt START = 1 alors UART = VDD (niveau logique haut)<br>
→ 7 bit après START communication d’un caractère<br>
→ Stop bit toujours = 1 <br>
→ 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.<br>
[[Fichier:Fonctionnement UART.png|cadre|centré|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.<br>
Pour connecter deux UARTs entre eux où un ordinateur à un UART, il y a plusieurs critères à vérifier.<br>
À courte distance de connexion :<br>
On connecte directement TXD1→RXD2 et RXD1→TXD2 + Masse. On s’assure que les niveaux logiques correspondent aux niveaux logiques des deux éléments.<br>
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===
====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).

#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.[[Fichier:Configuration Cube Mx.png|cadre|centré|Configuration UART sur Mx 1]]

#Ensuite cliquer sur UART2, pour le configurer.[[Fichier:Configuration UART sur Mx.png|cadre|centré|Configuration UART sur Mx 2]]Sur l'image ci-dessus, nous pouvons lire les informations suivante:<br>
-> 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.<br>
-> word length correspond au nombre de bits d'information envoyés par l'UART.<br>
-> 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é.<br> 
-> bit de stop correspond au nombre de bits utilisés pour déclarer la fin d'un caractère/word. Il est ici à 1.<br>
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  [[#creer projet|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.
# 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). [[Fichier:PWM1.png|sans_cadre|centré|500px]]
# 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''.[[Fichier:PWM2.png|sans_cadre|centré|500px]]
# 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. [[Fichier:PWM3.png|sans_cadre|centré|900px]]
# D'après la [https://www.st.com/resource/en/datasheet/stm32f446re.pdf documentation] du microcontrôleur (p.16) nous voyons que le timer 2 est connecté au bus APB1. [[Fichier:PWM4.png|sans_cadre|centré|400px]] et d'après la vue précédente, les timers de APB1 tournent à 90 MHz (x2 de APB1 peripheral clocks). [[Fichier:PWM5.png|sans_cadre|centré|300px]]
# 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: [[Fichier:PWM6.png|sans_cadre|centré|400px]]

===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 */ ).   
<syntaxhighlight lang="cpp">
HAL_TIM_PWM_Start(&htim2, TIM_CHANNEL_1);
htim2.Instance->CCR1 = 10000-1; // 10000/20000 = 0.5 (duty cycle)
</syntaxhighlight>

# Vous pouvez également utiliser la fonction <syntaxhighlight lang="cpp">HAL_TIM_PWM_Stop</syntaxhighlight> pour arrêter le signal.
# 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.
# 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 [https://gitlab.com/polybot-grenoble/tutorials/tutorials-cubeide-pwm-and-servos 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:

<syntaxhighlight lang="cpp">
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);
}
</syntaxhighlight>

<syntaxhighlight lang="cpp">
void wait_custom(int nb_ms)
{
    wait_ms(nb_ms);
}
</syntaxhighlight>

Seront traduit ainsi avec l'HAL fourni par STMicroelectronics:

<syntaxhighlight lang="cpp">
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);
}
</syntaxhighlight>

<syntaxhighlight lang="cpp">
void wait_custom(int nb_ms)
{
    HAL_Delay(nb_ms);
}
</syntaxhighlight>

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''.