STM32 premier pas et prise en main logiciel

STM32 — Premiers pas et prise en main logicielle

Cette page présente les bases logicielles STM32 utilisées pour la maquette Mini-Bee. Elle permet de démarrer rapidement avec la carte STM32 Nucleo F446RE, Arduino IDE, le bus CAN, les BluePills et les modules de puissance L298N.

Objectif

L’objectif est de donner une base claire pour reprendre la partie logicielle STM32 du Flight Control Unit Mini-Bee.

À la fin de cette prise en main, un contributeur doit savoir :

• installer l’environnement STM32 dans Arduino IDE ;
• téléverser un premier programme ;
• tester une sortie numérique ;
• lire un joystick ou un potentiomètre ;
• piloter un moteur DC ;
• comprendre le rôle du bus CAN dans l’architecture Mini-Bee.

Contexte Mini-Bee

Dans le projet Mini-Bee, la STM32 Nucleo joue le rôle de contrôleur principal du Flight Control Unit.

Elle reçoit les consignes pilote, lit les données capteurs et transmet les ordres aux modules moteurs.

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_09_20260511_FCU_MINIBEE_image36.png Télécharger le visuel Mini-Bee / contexte FCU]

L’architecture étudiée vise à rendre le Mini-Bee contrôlable sur trois axes :

• Roll : roulis ;
• Pitch : tangage ;
• Yaw : lacet.

Matériel utilisé

Élément	Rôle
STM32 Nucleo F446RE	Carte maître du système
BluePill STM32F103	Carte esclave locale pour le pilotage moteur
SN65HVD230	Transceiver de communication CAN
L298N	Pont en H pour piloter les moteurs DC
Joystick / potentiomètre	Entrée de commande
Moteurs DC	Actionneurs de test de la maquette

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_11_20260511_FCU_MINIBEE_image50.png Télécharger la carte STM32 Nucleo F446RE]

Installation logicielle

La carte STM32 peut être programmée avec Arduino IDE.

Étapes principales :

1. Installer Arduino IDE.
2. Ajouter le gestionnaire de cartes STM32duino.
3. Installer le support STM32 depuis le gestionnaire de cartes.
4. Importer la bibliothèque STM32duino X-NUCLEO-IKS01A2 au format ZIP.
5. Sélectionner la carte Nucleo-64.
6. Sélectionner le modèle Nucleo F446RE.
7. Choisir le port série de la carte.

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_01_Maquette_et_code_fin_image1.png Télécharger l’image installation bibliothèque STM32duino]

Point de vigilance : importer la bibliothèque directement en fichier ZIP, sans la décompresser.

Premier test : clignotement LED

Le premier exercice consiste à faire clignoter une LED sur la broche D13 / PA5.

Il valide :

• le câblage ;
• la reconnaissance de la carte ;
• le téléversement du programme ;
• la commande d’une sortie numérique.

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_02_Maquette_et_code_fin_image3.png Télécharger le montage LED STM32]

<syntaxhighlight lang="cpp">

1. define LED_PIN PA5
2. define BLINK_DELAY 500

void setup() {

 Serial.begin(115200);
 pinMode(LED_PIN, OUTPUT);

}

void loop() {

 digitalWrite(LED_PIN, HIGH);
 delay(BLINK_DELAY);

 digitalWrite(LED_PIN, LOW);
 delay(BLINK_DELAY);

} </syntaxhighlight>

Lecture d’un joystick

Le joystick permet de transformer une action pilote en signal électrique.

Deux cas sont possibles :

• joystick numérique : lecture ON / OFF ;
• joystick analogique : lecture proportionnelle sur les axes X et Y.

Le joystick analogique est le plus intéressant pour le Mini-Bee, car il permet de générer une consigne progressive.

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_03_Maquette_et_code_fin_image6.png Télécharger le montage joystick]

<syntaxhighlight lang="cpp">

1. define JOYSTICK_X_PIN PA0
2. define JOYSTICK_Y_PIN PA1

void setup() {

 Serial.begin(115200);
 pinMode(JOYSTICK_X_PIN, INPUT);
 pinMode(JOYSTICK_Y_PIN, INPUT);

}

void loop() {

 int x = analogRead(JOYSTICK_X_PIN);
 int y = analogRead(JOYSTICK_Y_PIN);

 Serial.print("X: ");
 Serial.print(x);
 Serial.print(" | Y: ");
 Serial.println(y);

 delay(200);

} </syntaxhighlight>

Pilotage moteur avec L298N

La STM32 ne doit pas alimenter directement un moteur.

Le module L298N sert d’étage de puissance. Il reçoit des signaux logiques et alimente le moteur avec une source adaptée.

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_14_20260511_FCU_MINIBEE_image61.png Télécharger le module L298N]

Principe de commande :

IN1	IN2	Effet
HIGH	LOW	Rotation sens A
LOW	HIGH	Rotation sens B
LOW	LOW	Arrêt

Exemple de test simple :

<syntaxhighlight lang="cpp"> const int motorPin1 = 5; const int motorPin2 = 6; const int motorPin3 = 10; const int motorPin4 = 9;

void setup() {

 pinMode(motorPin1, OUTPUT);
 pinMode(motorPin2, OUTPUT);
 pinMode(motorPin3, OUTPUT);
 pinMode(motorPin4, OUTPUT);

}

void loop() {

 digitalWrite(motorPin1, HIGH);
 digitalWrite(motorPin2, LOW);
 digitalWrite(motorPin3, LOW);
 digitalWrite(motorPin4, LOW);
 delay(2000);

 digitalWrite(motorPin1, LOW);
 digitalWrite(motorPin2, HIGH);
 delay(2000);

 digitalWrite(motorPin1, LOW);
 digitalWrite(motorPin2, LOW);
 digitalWrite(motorPin3, HIGH);
 digitalWrite(motorPin4, LOW);
 delay(2000);

 digitalWrite(motorPin3, LOW);
 digitalWrite(motorPin4, HIGH);
 delay(2000);

 digitalWrite(motorPin1, LOW);
 digitalWrite(motorPin2, LOW);
 digitalWrite(motorPin3, LOW);
 digitalWrite(motorPin4, LOW);

} </syntaxhighlight>

Bus CAN

Le bus CAN permet de connecter la STM32 Nucleo aux modules moteurs sans multiplier les câbles.

Il est adapté au Mini-Bee car il offre :

• une communication robuste ;
• une transmission différentielle sur CAN_H et CAN_L ;
• une meilleure résistance aux parasites ;
• une architecture multipoint ;
• une extension plus simple vers plusieurs moteurs.

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_13_20260511_FCU_MINIBEE_image60.png Télécharger le transceiver CAN SN65HVD230]

Architecture de commande

L’architecture Mini-Bee sépare la commande et la puissance.

La STM32 décide. La BluePill exécute localement. Le L298N fournit la puissance aux moteurs.

Joystick / capteurs
        ↓
STM32 Nucleo F446RE
        ↓ Bus CAN
SN65HVD230
        ↓
BluePill STM32F103
        ↓ PWM + direction
L298N
        ↓
Moteurs DC

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_08_Maquette_et_code_fin_image14.png Télécharger le schéma de principe STM32 / CAN / BluePill / L298N]

Montage maquette

Le montage final reprend cette logique sur plusieurs branches moteurs.

Chaque branche comprend :

• un module CAN ;
• une BluePill ;
• un L298N ;
• un ou deux moteurs DC.

Image à ajouter : [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_07_Maquette_et_code_fin_image12.jpeg Télécharger le montage maquette complet]

Exemple de branchement d’une branche moteur

Liaison	Connexion
CAN principal vers CAN branche	CANH vers CANH, CANL vers CANL
CAN vers BluePill	CANTX vers A7, CANRX vers B1
BluePill vers L298N	B8 vers ENA, B7 vers IN1, B6 vers IN2, B5 vers IN3, B4 vers IN4, B3 vers ENB
L298N vers moteurs	OUT1 / OUT2 vers moteur 1, OUT3 / OUT4 vers moteur 2

Exemple de code maître STM32

Ce code illustre le principe d’envoi d’une consigne de vitesse vers plusieurs BluePills via le bus CAN.

<syntaxhighlight lang="cpp">

1. define HAL_CAN_MODULE_ENABLED
2. include <STM32_CAN.h>

STM32_CAN Can1(CAN1, ALT);

void setup() {

 Serial.begin(115200);
 Can1.begin();
 Can1.setBaudRate(500000);
 Serial.println("Mini-Bee master ready");

}

void loop() {

 static uint8_t speed = 0;
 static bool increasing = true;

 for (int id = 0x101; id <= 0x104; id++) {
   CAN_message_t msg;
   msg.id = id;
   msg.len = 2;
   msg.buf[0] = speed;
   msg.buf[1] = speed;
   Can1.write(msg);
 }

 if (increasing) {
   speed += 5;
 } else {
   speed -= 5;
 }

 if (speed >= 250 || speed <= 0) {
   increasing = !increasing;
 }

 delay(50);

} </syntaxhighlight>

Exemple de code BluePill esclave

Chaque BluePill possède un identifiant unique. Elle ne traite que les messages CAN qui lui sont destinés.

<syntaxhighlight lang="cpp">

1. include <STM32_CAN.h>

1. define NODE_ID 0x101

1. define ENA_PIN PB8
2. define IN1_PIN PB7
3. define IN2_PIN PB6
4. define IN3_PIN PB5
5. define IN4_PIN PB4
6. define ENB_PIN PB3

STM32_CAN Can1(CAN1, DEF);

void setup() {

 pinMode(ENA_PIN, OUTPUT);
 pinMode(IN1_PIN, OUTPUT);
 pinMode(IN2_PIN, OUTPUT);
 pinMode(ENB_PIN, OUTPUT);
 pinMode(IN3_PIN, OUTPUT);
 pinMode(IN4_PIN, OUTPUT);

 Can1.begin();
 Can1.setBaudRate(500000);
 Can1.setFilter(0, NODE_ID, 0x7FF);

}

void driveMotors(uint8_t spd1, uint8_t spd2) {

 analogWrite(ENA_PIN, spd1);
 digitalWrite(IN1_PIN, HIGH);
 digitalWrite(IN2_PIN, LOW);

 analogWrite(ENB_PIN, spd2);
 digitalWrite(IN3_PIN, HIGH);
 digitalWrite(IN4_PIN, LOW);

}

void loop() {

 CAN_message_t msg_rx;

 if (Can1.read(msg_rx)) {
   if (msg_rx.id == NODE_ID) {
     driveMotors(msg_rx.buf[0], msg_rx.buf[1]);
   }
 }

} </syntaxhighlight>

Bonnes pratiques

Avant chaque test :

• vérifier les masses communes ;
• tester sans hélice ;
• limiter la vitesse moteur ;
• numéroter les BluePills ;
• noter les identifiants CAN ;
• conserver une version stable du code ;
• documenter chaque modification.

Sécurité : ne jamais faire un premier test moteur avec hélices montées.

Images complémentaires

Ces images peuvent être ajoutées si la page doit être enrichie.

• [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_04_Maquette_et_code_fin_image8.png Télécharger le montage moteur / pont en H]
• [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_05_Maquette_et_code_fin_image9.jpeg Télécharger le module de test moteur]
• [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_06_Maquette_et_code_fin_image10.png Télécharger le module CAN / câblage]
• [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_10_20260511_FCU_MINIBEE_image41.png Télécharger l’architecture / projet FCU]
• [sandbox:/mnt/data/stm32_wiki_photos_selected/STM32_wiki_12_20260511_FCU_MINIBEE_image57.png Télécharger le schéma architecture commande / puissance]

Conclusion

La prise en main STM32 constitue la première étape du Flight Control Unit Mini-Bee.

Les exercices simples — LED, joystick, potentiomètre, moteur et CAN — permettent de construire progressivement une architecture distribuée.

Cette base prépare les prochaines étapes :

• synchronisation des moteurs ;
• intégration des capteurs ;
• stabilisation roll / pitch / yaw ;
• ajout du correcteur PID ;
• validation des cas de vol sur la maquette.