• 15 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

course.header.alt.is_video

course.header.alt.is_certifying

J'ai tout compris !

Mis à jour le 08/11/2019

Utilisez l'application Android “Bluetooth Electronics”

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Dans ce chapitre, vous allez utiliser l’application Android de type Terminal et vous apprendrez à la configurer pour aboutir à une solution de pilotage sans fil du robot en mode pilotage “bas niveau”, c'est-à-dire piloté par un opérateur humain qui adresse des ordres élémentaires. Dans ce mode de pilotage, le robot n'est pas autonome et ne peut réagir à lui seul à des situations complexes. Il s'agit d'implémenter dans l'application "Bluetooth Electronics" des objets graphiques qui permettent de mettre en œuvre les actionneurs et capteurs du robot mobile pour interagir. Le robot sera donc piloté à distance par l'intermédiaire de la tablette.

Construction de "panels" de l’application ‘Bluetooth Electronics’

La vidéo qui suit montre la construction d'un panel élémentaire qui implémente quatre boutons plus un bouton Stop, qui permettent de piloter le robot moyennant 4 mouvements élémentaires : avance, recul, virer à gauche, virer à droite. Pour stopper un des 4 mouvements élémentaires, il est nécessaire d'actionner le bouton Stop.

Côté Arduino, il est nécessaire d'écrire le code qui correspond à la réception des caractères ASCII envoyés depuis la tablette. Ainsi, pour le caractère ASCII "U" qui correspond à l'avance tout droit du robot, il faut piloter les deux moteurs à vitesse maximale donc identique. Pour virer à gauche, il faut stopper le servo droit et piloter à vitesse maximale le servo gauche, et ainsi de suite.

Exploitez le capteur de distance

Dans ce paragraphe, nous allons exploiter la tourelle radar qui permet de détecter les obstacles et de mesurer leur distance au robot.

Avant de montrer la construction du panel, voyons le résultat que nous souhaitons obtenir. En actionnant un bouton du panel, on oriente la tourelle à gauche et on mesure la distance d'un obstacle éventuel au robot. En l'absence d'obstacle, la jauge correspondante retourne la distance maximale que le capteur est capable de mesurer. En actionnant un deuxième bouton, on oriente la tourelle droit devant et on place sur la jauge correspondante la distance de l'éventuel obstacle et de même pour un troisième bouton qui place la tourelle à droite.

La vidéo qui suit montre la construction du panel correspondant.

Notez bien que ces commandes vont enrichir les commandes implémentées à l'étape précédente.

Implémentez le code Arduino correspondant

Il faut placer dans le même sketch les quatre codes suivants :

/* sous programme de gestion de la liaion Bluetooth
*
*/
// programme écho renvoie sur le liaion Bluetooth les signaux de la console et inversement
void echo(){
char recvChar;
//On lit caractere par caractere sur le BTSerie et on affiche sur le Terminal Serie
if (BTSerie.available()) {
recvChar = BTSerie.read();
Serial.write(recvChar);
}
//On lit caractere par caractere sur le terminal Serie et on affiche sur le BTSerie
if (Serial.available()) {
recvChar = Serial.read();
BTSerie.write(recvChar);
}
}
//Décode les touches envoyées par la tablette
char decodeCommande(){
char recvChar=0;
//On lit caractere par caractere sur le BTSerie et on affiche sur le Terminal Serie
if (BTSerie.available()) {
recvChar = BTSerie.read();
}
return recvChar;
}
//affiche la distance sur les gauges
void afficheDistance(int pos,int distance){
BTSerie.print('*');
BTSerie.write(pos);
BTSerie.print(distance);
BTSerie.print('*');
}

Ce premier code, ci-dessus, permet d'exploiter les caractères réceptionnés pour afficher sur la liaison série en mode Terminal et par ailleurs, affiche toujours sur la liaison série les distances mesurées par le capteur.

//////////////////////////////////
//déclaration des sous routine de la tourelle
/////////////////////////////////
int mesureDistance(int pos){
int mesure = 0;
servoT.write(pos); // positione le servo
delay(800); // delay de réaction
// réalise une moyenne de 4 mesures
for (int i=0;i<4;i++){
mesure=mesure + analogRead(telemetre);
delay(10); // temposiration pour filtrer les parasites
}
mesure = mesure>>2; // divise la distance par 4 pour faire la moyenne
return mesure;
}
/* ce programme récupère la valeur du CAN et la traduit en distance
* grace à la caractéristique de la courbe de la documentation technique
* Attention la distance n'est pas précise car la surface de reflexion
* à une grande influence.
*/
int conversion(int can){
int table[] ={620,530,456,393,350,307,276,250,230,214,200,185,173,162,152,140,130,120,115,110,106,100,97,94,91,89};
int i = 0;
while ((can<table[i]) and (i<28)){
i++;
}
if (i>28) {
return 20;
} else {
return (i+2);
}
}

Le deuxième code, ci-dessus, positionne la tourelle du capteur de distance, réalise la lecture du port analogique et convertit la valeur moyennée sur 4 mesures en une distance en centimètres, par exploitation de la courbe caractéristique tension en fonction de la distance fournie par la documentation technique du capteur.

/* ce programme présente les bases de notre robot
les servo moteurs et leur branchement sur la carte
il permet de controler une position du servo moteur
Nous introduisons des mouvements de base
avancer, reculer, tourner à droite et tourner à gauche
une tourelle à l'avant permet de déplacer le télémetre
*/
// bibliothèque de fonctions pour la gestion des servomoteurs
#include <Servo.h>
// bibliotheque de la liaison série software
#include <SoftwareSerial.h>
#define RxD 4 // Pin 4 pour la reception dans l'arduino
#define TxD 5 //Pin 5 pour l'émission de l'arduino
SoftwareSerial BTSerie(RxD,TxD); // affectation des broches de communication de la liaison bluetooth
Servo roueG, roueD; // définit le nom des deux servos
Servo servoT; // nom de la tourelle
int commande = 0;
int distance = 0;
int posG, posD; // position des servos
const int pinG = 6; // broche de la roue gauche
const int pinD = 7; // broche de la roue droite
const int vmax = 5; // vitesse maximale des servos
const int repos = 90; // position de repos des servos
const int pinT = 8; // broche de la tourelle
const int droit = 00; // position de la tourelle
const int gauche = 170;
const int face = 90;
const int telemetre = 0; // broche analogique du capteur de distance
// sous programme d'initialisation et il n'est exécuté qu'une fois
void setup() {
roueG.attach(pinG); // déclaration des broches des roues
roueD.attach(pinD);
servoT.attach(pinT); // déclaration de la broche de la tourelle
Serial.begin(9600); // initialise la liaison série à 9600 bauds;
while (!Serial); // attends l'ouverture du la fenetre terminal
pinMode(RxD, INPUT); // place la broche RX en entrée
pinMode(TxD, OUTPUT); // place la broche TX en sortie
BTSerie.begin(9600); // déclare la vitesse de communication
arreter(); // place le robot à l'arret
}
// boucle infinie
void loop(){
commande=decodeCommande();
if (commande=='U') avancer();
if (commande=='X') arreter();
if (commande=='D') reculer();
if (commande=='R') tournerD();
if (commande=='L') tournerG();
if (commande=='A') {
distance = mesureDistance(gauche);
distance = conversion (distance);
afficheDistance('A',distance);
}
if (commande=='B') {
distance = mesureDistance(face);
distance = conversion (distance);
afficheDistance('B',distance);
}
if (commande=='C') {
distance = mesureDistance(droit);
distance = conversion (distance);
afficheDistance('C',distance);
}
}

Enfin, le troisième code, ci-dessus, incorpore la boucle loop. Il exploite la commande réceptionnée, envoyée par la tablette. En fonction du caractère réceptionné, le code appelle une fonction de déplacement de base ou bien active la mesure de distance à gauche, sur réception du caractère "A", plein centre sur réception du caractère "B" et enfin, à droite, sur réception du caractère "C".

Pour que le code fonctionne, il faut bien sûr que figurent dans le sketch les fonctions de déplacements de base rappelées ci-dessous :

//////////////////////////////////
//déclaration des sous routine de mouvement
/////////////////////////////////
void mouvement(int posD, int posG){
roueG.write(posG); // indique au servo de rejoindre sa position
roueD.write(posD);
}
void arreter(){
mouvement(repos,repos);
}
void accelerer(){
for (int i=0; i<vmax; i++){ // augmentation prograssive de la vitesse
posG = repos + i;
posD = repos - i;
mouvement(posD,posG);
delay(20); // vitesse de la rampe d'accélération
}
}
void freiner(){
for (int i=vmax; i>0; i--){ // reduction prograssive de la vitesse
posG = repos + i;
posD = repos - i;
mouvement(posD,posG);
delay(20); // vitesse de la rampe de freinage
}
}
void avancer(){
posG = repos + vmax;
posD = repos - vmax;
mouvement(posD,posG);
}
void reculer(){
posG = repos - vmax;
posD = repos + vmax;
mouvement(posD,posG);
}
void tournerD(){
posG = repos + vmax;
posD = repos;
mouvement(posD,posG);
}
void tournerG(){
posG = repos;
posD = repos - vmax;
mouvement(posD,posG);
}

En résumé

Nous disposons à présent des principales fonctionnalités pour piloter les mouvements du robot à distance et pour mesurer son environnement. À vous maintenant de jouer. Pratiquez, modifiez, testez jusqu'à ce que vous vous sentiez vraiment en maîtrise des éléments que nous avons vus jusqu'ici. Il nous restera à envisager le mode autonome du robot, c'est-à-dire le mode dans lequel il est capable de prendre en compte son environnement pour se déplacer sans commande extérieure.

Ce cours touche à sa fin ! Vous avez à présent toutes les clés pour :

  • décrire le fonctionnement des composants d’un robot mobile ;

  • reconnaître un environnement Arduino ;

  • énoncer le principe général de fonctionnement d’un servomoteur ;

  • programmer une interface de commande par Bluetooth dans un environnement Arduino.

N'oubliez pas de valider ces compétences en réalisant les exercices de fin de partie.

Nous vous proposons dans la partie suivante de réaliser un défi : permettre à votre robot de trouver son chemin dans un labyrinthe !

Exemple de certificat de réussite
Exemple de certificat de réussite