Salut les Makers / Makeuses ! Aujourd’hui, on va mettre en pratique ce qu’on a vu dans la série « Apprendre Arduino » et introduire la bibliothèque Virtuino pour contrôler un rover Arduino avec son smartphone grâce au Bluetooth.

Abonnez-vous à ma chaîne YouTube !

C’est à l’occasion du concours pour devenir ambassadeur Conrad avec Make It With Conrad, que j’ai eu la chance de développer ce projet ! Vous trouverez l’ensemble du tutoriel pour la réalisation de ce projet sur le post que j’ai réalisé ici. N’hésitez pas à m’aider en votant pour ce projet ! Retrouvez chaque étape de la construction du rover Arduino piloté par bluetooth jusqu’à la réalisation du châssis en 3D !

Retrouvez d’ailleurs les fichiers .STL pour le châssis imprimé en 3D pour un rover Joy-It pour Arduino / Raspberry Pi.

Je vais quand même en profiter pour faire un point sur les difficultés rencontrées lors de la réalisation de ce tutoriel.

Le tutoriel complet : Rover Arduino

1. Montage du châssis

– Souder les fils du kit Joy-It sur les cosses à souder des moteurs. Veillez à respecter toujours le même sens avec le code couleur (toujours rouge et noir du même côté du moteur)
– Monter les moteurs sur la première plaque du kit Joy-It conformément à la notice du kit.
– Monter la seconde plaque du kit Joy-It.
– Repérer des fixations disponibles pour pouvoir placer votre Arduino UNO sur cette seconde plaque.

2. Configuration des shields moteurs

Les Shields Moteurs Velleman sont composés de cavaliers permettant de définir quels pins de l’Arduino commutera le sens de rotation du moteur ainsi que la consigne de vitesse PWM. Pour se faire, sélectionnez des pins différents sur chaque Shield. Pour ma part j’ai utilisé les pins suivants :

– Sur le 1er Shield :
– Direction Arrière Gauche : 12
– Direction Arrière Droite : 4
– PWM Arrière Gauche : 10
– PWM Arrière Droite : 5

– Sur le 2nd Shield :
– Direction Avant Gauche : 8
– Direction Avant Droite 2
– PWM Avant Gauche : 9
– PWM Avant Droite : 3

Veillez également à placer le cavalier de la source de tension (POWER ou PWR) sur EXT et non sur INT.

Une fois les cavaliers placés, vous pouvez empiler les Shields Moteur sur la carte Arduino UNO.

3. Raccordement de l’électronique de commande

Pour l’électronique de commande, j’ai utilisé deux plaques d’essais pour souder les connecteurs 5 pins femelles 2,54mm. Je les ai découpées à la forme de la structure Joy-It (voir vidéo). Cependant, il n’est pas nécessaire d’aller jusqu’à ce niveau de détail, Deux simples cartes rectangulaires font l’affaire.

Le saviez-vous ?
Les entrées analogiques A0 à A5 peuvent s’utiliser comme des entrées digitales. Dans ce dernier cas, A0 à A5 devient des INPUTS de 14 à 19.

Pour le câblage des différents capteurs à l’Arduino, j’ai suivi le schéma suivant (cliquez pour afficher en grand) :

4. Raccordement de l’électronique de puissance

Reliez ensuite les fils des différents moteurs aux Shields. Peu importe la polarité, il faudra juste vérifier que celle-ci soit la même pour les 4 moteurs. Pour la répartition, se référer à la répartition effectuée à l’étape 3.

Reliez une pile 9V sur les connecteurs PWR des 2 Shields Moteurs.

5. Finition du câblage

Sécurisez ensuite l’ensemble de votre câblage avec des attaches-câbles afin que vos fils ne se baladent pas partout.

6. Programmation – Côté Rover Arduino

Vient ensuite l’étape de la programmation. Pour ce faire, téléchargez la librairie Virtuino ici : http://users.art.sch.gr/iliaslamprou/virtuino/virtuino.zip

Pour plus d’infos sur l’ajout de cette librairie et l’application Virtuino, se référer au tutoriel de démarrage Virtuino disponible ici : http://users.sch.gr//iliaslamprou/virtuino/virtuino_bluetooth_tutorial_1.html

Une fois la librairie installée, on va pouvoir commencer à coder. Je vous laisse le code complet et commenté ici :

#include <VirtuinoBluetooth.h>
#include <VirtuinoEsp8266_WebServer.h>
#include <VirtuinoEthernet_WebServer.h>

#include <SoftwareSerial.h>

SoftwareSerial bluetoothSerial =  SoftwareSerial(0,1);
VirtuinoBluetooth virtuino(bluetoothSerial); 

// VirtuinoBluetooth virtuino(Serial1); 

int buzzerPin = 13;

int dirArG = 12;
int dirArD = 4;
int dirAvG = 8;
int dirAvD = 2;

int PWMArG = 10;
int PWMArD = 5;
int PWMAvG = 9;
int PWMAvD = 3;

int trigAv = 7;
int trigAr = 6;

int echoAvG = 14;
int echoAvD = 15;
int echoArD = 16;
int echoArC = 17;
int echoArG = 18;

int vitesseGauche = 0;
int vitesseDroite = 0;

int capteur = 0;

void setup() {
  // put your setup code here, to run once:

  //virtuino.DEBUG=true;               // set this value TRUE to enable the serial monitor status
  //Serial.begin(9600);                // Set serial monitor baud rate
  bluetoothSerial.begin(9600);
   
  virtuino.vPinMode(buzzerPin,OUTPUT);

  //Gauche
  pinMode(PWMArG, OUTPUT);
  pinMode(PWMAvG, OUTPUT);
  pinMode(dirArG, OUTPUT);
  pinMode(dirAvG, OUTPUT);
 

  //Droite
  pinMode(PWMArD, OUTPUT);
  pinMode(PWMAvD, OUTPUT);
  pinMode(dirArD, OUTPUT);
  pinMode(dirAvD, OUTPUT);

  //Trigger des émetteurs Ultrasons
   pinMode(trigAv, OUTPUT);
   pinMode(trigAr, OUTPUT);

  //Récepteurs Ultrasons
   pinMode(echoAvG, INPUT);
   pinMode(echoAvD, INPUT);
   pinMode(echoArD, INPUT);
   pinMode(echoArC, INPUT);
   pinMode(echoArG, INPUT);
  
}

void loop() {
  // put your main code here, to run repeatedly:

  virtuino.run(); 

  // Arrêt des moteurs sur VD0
  if(virtuino.vDigitalMemoryRead(0) == 1){
    RAZMot();
  }



  vitesseGauche = (int)virtuino.vMemoryRead(0);
  vitesseDroite = (int)virtuino.vMemoryRead(1);

  // Contrôle Gauche entre -250 et 250

  if(vitesseGauche >= 0){
    digitalWrite(dirArG, 1);
    digitalWrite(dirAvG, 1);
    analogWrite(PWMArG, vitesseGauche);
    analogWrite(PWMAvG, vitesseGauche);
  }
  if(vitesseGauche < 0){
    digitalWrite(dirArG, 0);
    digitalWrite(dirAvG, 0);
    analogWrite(PWMArG, -vitesseGauche);
    analogWrite(PWMAvG, -vitesseGauche);
  }

  // Contrôle Droite entre -250 et 250

  if(vitesseDroite >= 0){
    digitalWrite(dirArD, 1);
    digitalWrite(dirAvD, 1);
    analogWrite(PWMArD, vitesseDroite);
    analogWrite(PWMAvD, vitesseDroite);
  }
  if(vitesseDroite < 0){
    digitalWrite(dirArD, 0);
    digitalWrite(dirAvD, 0);
    analogWrite(PWMArD, -vitesseDroite);
    analogWrite(PWMAvD, -vitesseDroite);
  }

//Une mesure est réalisée toutes les 100 boucles (100 cycles), à chaque fois sur un capteur différent pour éviter la latence de la commande.

  capteur++;

switch (capteur) { 
   case 100:{
     Distance(trigAr,echoArD,4);
     break;
  }
   case 200:{
     Distance(trigAv,echoAvG,2);
     break;
  }
   case 300:{
     Distance(trigAr,echoArC,5);
     break;
  }
   case 400:{
     Distance(trigAv,echoAvD,3);
     break;
  }
   case 500:{
     Distance(trigAr,echoArG,6);
     break;
  }
}

if(capteur == 500){
  capteur = 0;
}

}

  // Permet de faire un bip tout les 2,5 cycle (sur VD1) et de constater la longueur des cycles, et donc la latence.
  if(virtuino.vDigitalMemoryRead(1) == 1){
    if(capteur == 400){
    digitalWrite(buzzerPin,1);
    }
    if(capteur == 200){
    digitalWrite(buzzerPin,0);
    }
  }


void RAZMot(){  // Fonction permettant de réinitialiser les moteurs à 0 pour s'arrêter proprement
  virtuino.vMemoryWrite(0,0);
  virtuino.vMemoryWrite(1,0);
}

// Fonction qui calcule la distance selon le pin de trigger et d'echo. Le MemoryWrite designe la valeur mémoire où écrire dans Virtuino.
void Distance(int trigPin, int echoPin, int MemoryWrite) {

  long duration, distance;
  
 // Envoie de l'onde
 digitalWrite(trigPin, LOW);
 delayMicroseconds(2);
 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10);
 digitalWrite(trigPin, LOW);
 // Réception de l'écho
 duration = pulseIn(echoPin, HIGH);

 // Calcul de la distance
 distance = (duration/2) / 29.1;
 
 if (distance >= 20 || distance <= 0){
 virtuino.vMemoryWrite(MemoryWrite,20);
 }
 else {
 virtuino.vMemoryWrite(MemoryWrite,distance);
 }
 
 delay(10);
}

7. Programmation – Côté Smartphone avec Virtuino

Tout d’abord, téléchargez Virtuino sur le Google Play Store : https://tinyurl.com/virtuino
Comme précédemment, référez-vous à ce tutoriel pour la configuration et la connexion Bluetooth : http://users.sch.gr//iliaslamprou/virtuino/virtuino_bluetooth_tutorial_1.html

Ensuite, une fois le logiciel lancé, vous pouvez personnaliser l’interface. Il faut savoir que Virtuino peut travailler directement avec les valeurs d’INPUT/OUTPUT d’Arduino mais possède également un système dit de « mémoire virtuelle » qui permet de faire des liens avec des variables dans le programme Arduino.

Les mémoires programmées (dans le programme de l’étape précédente) sont :
– DV0 : Arrêt complet des moteurs du rover Arduino.
– DV1 : Permet de faire un bip tous les 2,5 cycles environs. Cela permet d’estimer les temps de latence.
– V0 : Vitesse des moteurs à gauche pouvant varier de -255 (marche arrière) à 255 (marche avant).
– V1 : Vitesse des moteurs à droite pouvant varier de -255 (marche arrière) à 255 (marche avant).
– V2 : Distance mesurée par le capteur ultrasons Avant Gauche en cm.
– V3 : Distance mesurée par le capteur ultrasons Avant Droit en cm.
– V4 : Distance mesurée par le capteur ultrasons Arrière Droit en cm.
– V5 : Distance mesurée par le capteur ultrasons Arrière Centre en cm.
– V6 : Distance mesurée par le capteur ultrasons Arrière Gauche en cm.

Vous pouvez également récupérer mon fichier de la configuration disponible ici.
Pour le récupérer, dézippez le fichier .vrt sur votre smartphone et ouvrez-le avec Virtuino.

8. Etape Facultative : Impression 3D de la coque haute du châssis

Afin de protéger au mieux le montage du rover Arduino, vous pouvez télécharger le modèle que j’ai imprimé dans la vidéo ici :
https://www.thingiverse.com/thing:2922890

Pour l’impression de cette pièce, les supports sont nécessaires. Le remplissage est à 20%.
Et en prime j’ai ajouté un support pour une CAM sportive.

Difficultés rencontrées et questionnements

Limitations du courant sur Arduino et Shields moteurs :

La première difficulté dans ce projet concerne les limitations en courant sur les broches de l’Arduino. En effet, l’Arduino peut fournir au maximum 50 mA par broche et le régulateur 5V qui se trouve sur la carte ne supporte pas plus de 450 mA en consommation globale. Sachant que la carte Arduino peut consommer jusqu’à 80 mA, cela nous laisse un peu près 370 mA pour l’alimentation des divers capteurs et Shield Arduino à ajouter. Les émetteurs/récepteurs ultrasons consomment entre 10 et 40 mA chacun. J’estime qu’ils consomment 10 mA au repos et 40 mA lors de la mesure. Dans le programme, je ne réaliserai qu’une mesure à la fois, ce qui nous donne 4*10 + 1*40 = 80 mA pour les capteurs à ultrasons que j’arrondis à 100 mA (je ne pense pas que le courant soit toujours de 10 mA au repos, il s’agit juste d’une valeur basse de consommations). Il reste donc 270 mA.

Ensuite vient le buzzer, qui lui, consomme environ 10 mA lorsqu’il est actif. On tombe à 260 mA. Puis le module Bluetooth qui lui, consomme environ 30 mA en fonctionnement, on tombe à 230 mA.

Il faut donc veiller qu’au niveau de la consommation, on ne tombe pas à 0 mA, sinon l’Arduino redémarrera dès que le pic de consommation sera atteint. Et on ne veut surtout pas que le rover Arduino s’arrête en plein milieu d’une course !

Reste ensuite la grande interrogation sur les Shields moteurs. Je ne vois aucune information concernant la consommation de ces Shields. On doit commuter 4 directions pour les 4 moteurs et envoyer 4 signaux PWM. Ces signaux consomment peu en théorie, environ 10 mA chacun. 230 – 8×10 = 150 mA restants. Après, les deux Shields doivent alimenter leurs composants, soit deux doubles pont-H, deux fois deux Leds et une multitude de composants passifs ou inductifs. En raccordant le tout et après plusieurs essais, au niveau de la consommation de la carte et de l’alimentation de l’ensemble des capteurs et Shields, ça passe. Cependant, lorsque je fais tourner plus d’un moteur en même temps, l’ensemble du système se coupe et redémarre.

Pour les 2 Shields, j’ai le choix d’alimenter les moteurs via la carte Arduino, ce qui a pour effet de prendre directement la tension en entrée de l’Arduino. Cependant lorsque plus d’un moteur tournait, l’ensemble du système se coupait. D’où la solution de passer par une alimentation séparée pour les moteurs, ce qui explique le choix de 2 piles 9 V.

Un point crucial sur l’autonomie du Rover Arduino :

Je n’ai pas encore assez de recul sur l’autonomie de la partie « Arduino et capteurs », car après plusieurs essais sur ce rover Arduino, je n’ai pas encore réussi à vider la pile 9V pour la partie commande. Par contre côté pile moteur, après environ 1h d’essais j’ai commencé à sentir la pile un peu faiblarde. Je n’ai pas eu la chance sur ce projet d’ajouter des batteries externes de modélisme (trop onéreux par rapport au coût global du projet). De ce côté-là mon PiRobot avait bien plus d’énergie à revendre ! (en même temps avec une batterie de modélisme de 22000 mAh et une powerbank de 5000mAh pour la partie commande, un peu normal que ça me tienne la journée !).

Différences Raspberry Pi / Arduino et Bluetooth / Wifi :

Ce n’est qu’un ressenti par rapport au pilotage du rover Arduino et du PiRobot : la communication Wifi avec le PiRobot était bien mieux optimisée que la communication Bluetooth avec l’Arduino sur le RoverDuino. Pourtant les fréquences Bluetooth et Wifi sont très proches les unes des autres. Donc je pense que la vitesse d’exécution du programme joue un rôle crucial dans le pilotage du Robot. Sur le PiRobot, avec le serveur de pilotage codé en C++, le programme avait une bien plus grande vitesse d’exécution. Je pense que la latence est peut-être due à la librairie Virtuino qui attend systématiquement une réponse à chacune des requêtes effectuées, ce qui n’était pas mon cas avec le PiRobot, car je communiquais via le protocole UDP.

Conclusion

J’ai été heureux de participer à ce concours avec Conrad. Je me rends compte que mon premier Rover qui a demandé bien plus de temps et de développement est finalement plus abouti. L’avantage ici, c’est que j’avais déjà de bonnes notions en ce qui concerne la création de rover. J’ai donc pu développer ce projet rapidement, sans avoir de trop de contraintes.

Ben.