Association hc-05 et ESC
Article mis en ligne le 15 mars 2022
dernière modification le 16 mars 2022

par Rémi

A présent que je sais gérer le module Bluetooth HC-05 et l’ESC avec l’Arduino, il faut mettre tout ça ensemble.

Les broches ne changent pas.
Seul le code change :

/* ------------------------------------------------------------------------
/ Communication radio (Bluetooth) entre le smartphone et un aéroglisseur
/ via un Arduino nano. Descriptif: https://www.suinot.org
/
/ Auteur: R. Suinot <remi --at-- suinot.org>
/ Première version: 14 janvier 2022
/ Rev: 15 mars 2022
/ Rev: 16 mars 2022
/ Paramètres à envoyer en bluetooth (peut être fait en console pour test)
/     + : augmente la vitesse du moteur ( dans le code, par pas de 10)
/     - : diminue la vitesse du moteur (dans le code, par pas de 10)
/     d : dérive vers la droite 
/     g : dérive vers la gauche
/     m : dérive au milieu (retour rapide ) 
/     s : Arrêt moteur
/--------------------------------------------------------------------------*/

#include <Servo.h> // bibliothèque de gestion des servo commandes
#include <SoftwareSerial.h>

// #define DEBUG 1 // à commenter quand on sera en mode autonome

#define rxPin 10  // hc05
#define txPin 11  // hc05
#define baudrate 115200
#define pwm_derive 4 // servomoteur
#define pwm_esc 3 // ESC brushless

int Moteur;
Servo ESC; // Création de l'objet permettant le contrôle de l'ESC

int Derive;
Servo DERIVE; // Création de l'objet permettant le contrôle de la dérive

SoftwareSerial hc05(rxPin ,txPin);

void setup() {

 initialisation();  // Partie initialisation de l'ESC

 pinMode(rxPin,INPUT);
 pinMode(txPin,OUTPUT);
 
 #ifdef DEBUG
   Serial.begin(baudrate);
 #endif
 hc05.begin(baudrate);
}

void loop() {
 String message;
 // Boucle de lecture sur le hc-05
 while (hc05.available()){
   message = hc05.readString();
   // Écriture du message dans le serial usb
   Serial.println(message);
   // retour vers la console du hc05
   #ifdef DEBUG
     hc05.println("depuis bluetooth " + message);
   #endif
 }
 #ifdef DEBUG
 // Boucle de lecture sur le serial usb
 while (Serial.available()){
   // Lecture du message envoyé par le serial usb
   message = Serial.readString();
   // Écriture du message vers le hc-05
   hc05.println(message);
   // Retour vers la console arduino
   Serial.println("depuis arduino: " + message);
 }
 #endif

 // Lecture du message et interprétation
 if(message == "+\r\n"){
   // moteur plus vite  
   if ( Moteur < 180 ) {
     Moteur += 10;      
     moteur(message);
   }                    
 } else if(message == "-\r\n"){
   // moteur moins vite        
   if ( Moteur > 0 ) {        
     Moteur -= 10;
     moteur(message);
   }                          
 } else if(message == "d\r\n"){
   // dérive vers la droite
   if ( Derive < 180 ) {
     Derive += 10;
     derive(message);
   }
 } else if(message == "g\r\n"){
   // dérive vers la gauche  
   if ( Derive > 0 ) {
     Derive -= 10;
     derive(message);
   }
 } else if(message == "m\r\n"){
   // dérive revient au point milieu  
     Derive = 90;
     derive(message);
 } else if(message == "s\r\n"){
   // moteur stop              
   Moteur = 0;                
   moteur(message);                  
 } else if ( message != "" ) {
   hc05.println("erreur de message: " + message);
 }
}

void initialisation() {
 delay(500);
 DERIVE.attach(pwm_derive);
 ESC.attach(pwm_esc, 1000, 2000); // On attache l'ESC au port numérique 9 (port PWM obligatoire)
 delay(1000);
 ESC.write(180);
 delay(1000);
 ESC.write(0);
 delay(1000);
 // Fin d'initialisation
 Moteur=0; // moteur à l'arret
 Derive=90; // derive à mis parcourt
}


void moteur (String msg) {
 // envoi une valeur dans l'ESC    
 ESC.write(Moteur);
 hc05.println(" - " + msg + " Moteur: " + Moteur);
}

void derive(String msg) {
 // envoi une valeur dans la derive
 DERIVE.write(Derive);
 hc05.println(" - " + msg + " derive: " + Derive);
}

En début de code, il y a la ligne "define DEBUG" à laisser pour pouvoir utiliser la console Arduino. Ici, je l’ai commenté, car j’ai déjà fait mes tests. Je suis donc en mode entièrement autonome, c’est à dire que l’alimentation de l’Arduino se fait par l’ESC uniquement.

Les commandes à envoyer (c’est écrit en tête de code) pour agir sur le moteur et la dérive (nous en parlerons plus tard) :

  • + pour accélérer le moteur
  • - pour décélérer
  • d pour aller à droite
  • g pour aller à gauche
  • m pour que le servomoteur revienne à sa position milieu
  • s pour stopper le moteur

Attention : Chaque commande doit être envoyée l’une après l’autre , pas de traitement de commandes ’++++ddd’
en un seul envoi.

Après test, voila comment cela fonctionne :
1) branchement du moteur sur l’Arduino, de l’ESC, du servomoteur (je n’en ai pas encore parlé, mais on le devine dans le code, cela viendra).
2) branchement de l’alimentation de l’ESC : il va alimenter l’ESC, et l’Arduino, le moteur, le servomoteur.
3) l’Arduino démarre, alimente de module Bluetooth, et initialise l’ESC
4) pendant ce temps, connexion du smartphone et du module hc-05
5) à partir de là, la première commande envoyer avec le smartphone : ’+’ mets le moteur en marche (vitesse faible).

C’est tout. ici, j’ai testé avec un terminal Bluetooth comme depuis le début.
L’application d’utilisation sous android viendra plus tard (en cours d’écriture).

A suivre donc...