Dans cet article, il s'agit de réaliser une voiture télécommandée avec une carte Arduino, la télécommande étant une tablette Android en communication via bluetooth avec la carte Arduino.
Dans un précédent article nous avons vu comment utiliser une carte de puissance afin de piloter deux moteurs (lire l'article). Nous avions alors la base pour réaliser une voiture électrique, celle-ci se déplaçant à droite ou à gauche en jouant sur la puissance délivrée au moteur droit ou moteur gauche.
A présent, pour la télécommander, nous allons doter cette voiture d'un capteur bluetooth, la télécommande sera une tablette Android en communication avec le capteur bluetooth. La tablette enverra des chaines de caractère ( à droite, plus vite, en arrière, ...) qui seront reçues par la carte Arduino, celle-ci réalisant le traitement adéquat.
Le capteur Bluetooth pour Arduino
Notre capteur bluetooth se compose de 4 broches :
- broche power que la carte Arduino alimentera en 5 V
- broche de masse que l'on reliera à la masse de la carte Arduino
- broche RX : celle-ci reçoit des données
- broche TX : celle-ci envoie des données
Pour programmer le capteur Arduino, nous utiliserons la bibliothèque SoftwareSerial.h
Ainsi, nous instantions le connecteur bluetooth le code suivant
SoftwareSerial bluetoothSerial(11, 10);
ceci signifie que
- la broche 11 de l'arduino sera la broche en réception RX
- la broche 10 de l'arduino sera la broche en émission TX
Comme la broche 11 correspond à la RX sur l'arduino, il faut relier cette broche à la broche TX du capteur bluetooth.
Comme la broche 10 correspond à la TX sur l'arduino, il faut relier cette broche à la broche RX du capteur bluetooth.
Ces branchements réalisés, les lignes suivantes permettent de lire les données reçues par le capteur bluetooth :
if (bluetoothSerial.available()) {
character = bluetoothSerial.read(); // on lit caractère par caractère les données arrivant sur le capteur
}
Il reste à présent à réaliser l'outil Android permettant d'envoyer des ordres au capteur bluetooth. Nous ne développerons pas un outil mais utiliserons l'application Android "BlueTooth Serial controler 16".
Cette application propose une damier de 4*4 touches programmables. On va donc programmer ces touches pour envoyer la chaine de caractères voulue :
- touche "en avant" : enverra la chaine de caractères cmd_tout_droit
- touche "en arrière" : enverra la chaine de caractères cmd_en_arriere
- touche "à droite" : enverra la chaine de caractères cmd_a_droite
- touche "à gauche" : enverra la chaine de caractères cmd_a_gauche
- touche "plus vite" : enverra la chaine de caractères cmd_plus_vite
- touche "moins vite" : enverra la chaine de caractères cmd_moins_vite
- touche "stop" : enverra la chaine de caractères cmd_stop
Le code de l'application pour la carte Arduino
Au final, le code est le suivant, les commentaires dans le code devrait suffire pour la compréhension.
#include <SoftwareSerial.h>
SoftwareSerial bluetoothSerial(11, 10); // (RX, TX)
// broche RX du composant bluetooth sera transmis à Digital 10 , broche TX du composant bluetooth relie à Digital 11
String cmd = ""; // la chaine de commande que la telecommande envoie
char character;
int sens = 1; // sens 1 marche avant, sens 2 marche arriere
int pwm = 30; // la pwm de depart
int stdby = 0 ; // l etat de la broche stdby
/* definition des commandes que la telecommande envoie */
#define CMD_LEFT "cmd_aga" // commande a gauche
#define CMD_RIGHT "cmd_adr" // commande a droite
#define CMD_STRAIGHT "cmd_sta" // commande start, la voiture avance tout droit
#define CMD_STOP "cmd_sto" // commande stop
#define CMD_BACK "cmd_arr" // commande marche arriere
#define CMD_PLUS "cmd_+++" // commande plus vite
#define CMD_MOINS "cmd_---" // commande moins vite
/* cablage des broches de la carte de puissance TB6612FNG vers la carte arduino */
#define PWMA 3
#define AIN1 2
#define AIN2 4
#define PWMB 5
#define BIN1 2
#define BIN2 4
#define STBY 6
void setup()
{
/* definition des broches de la carte de puissance en tant que sortie */
pinMode(PWMA,OUTPUT);
pinMode(AIN1,OUTPUT);
pinMode(AIN2,OUTPUT);
pinMode(PWMB,OUTPUT);
pinMode(BIN1,OUTPUT);
pinMode(BIN2,OUTPUT);
pinMode(STBY,OUTPUT);
// Ouvre la voie série avec l'ordinateur
Serial.begin(9600);
// Ouvre la voie série avec le module BlueTooth
bluetoothSerial.begin(9600);
}
void loop()
{
if (bluetoothSerial.available()) {
character = bluetoothSerial.read();
cmd.concat(character);
//Serial.write(character);
if (cmd == CMD_LEFT)
{
Serial.write(CMD_LEFT);
cmd="";
if ( stdby == 0 ) startUp();
rotateLeft(pwm); // tourne a gauche pendant 500 ms a la pwm de 30
if ( sens == 1 ) {
// en marche avant precedemment
goForward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens avant
} else {
// en marche arriere precedemment
goBackward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens arriere
}
} else if ( cmd == CMD_RIGHT ) {
Serial.write(CMD_RIGHT);
cmd="";
if ( stdby == 0 ) startUp();
rotateRight(pwm); // tourne a droite pendant 500 ms a la pwm de 30
if ( sens == 1 ) {
// en marche avant precedemment
goForward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens avant
} else {
// en marche arriere precedemment
goBackward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens arriere
}
} else if ( cmd == CMD_STRAIGHT ) {
Serial.write(CMD_STRAIGHT);
cmd="";
startUp();
goForward(pwm); // avance a la pwm de 30
} else if ( cmd == CMD_BACK ) {
Serial.write(CMD_BACK);
cmd="";
shutDown();
startUp();
goBackward(pwm); // recule a la pwm de 30
} else if ( cmd == CMD_PLUS ) {
Serial.write(CMD_PLUS);
cmd="";
pwm=pwm+15;
if ( sens == 1 ) {
// en marche avant precedemment
goForward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens avant
} else {
// en marche arriere precedemment
goBackward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens arriere
}
} else if ( cmd == CMD_MOINS ) {
Serial.write(CMD_MOINS);
cmd="";
pwm=pwm-15;
if ( sens == 1 ) {
// en marche avant precedemment
goForward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens avant
} else {
// en marche arriere precedemment
goBackward(pwm); // apres avoir tourne, on avance a nouveau tout droit en sens arriere
}
}
else if ( cmd == CMD_STOP ) {
Serial.write(CMD_STOP);
cmd="";
shutDown();
pwm=30;// pour redemarrer ensuite a vitesse raisonnable
}
}
}
void startUp ()
{
Serial.println("in startUp");
stdby=1;
digitalWrite(STBY,HIGH);
}
void shutDown ()
{
Serial.println("in shutDown");
stdby=0;
digitalWrite(STBY,LOW);
}
void goForward (int pwm)
{
Serial.println("in goForward");
sens=1;
digitalWrite (AIN1,HIGH);
digitalWrite (AIN2,LOW);
analogWrite(PWMA,pwm);
analogWrite(PWMB,pwm);
}
void goBackward (int pwm)
{
Serial.println("in goBackward");
sens=2;
digitalWrite (AIN1,LOW);
digitalWrite (AIN2,HIGH);
analogWrite(PWMA,pwm);
analogWrite(PWMB,pwm);
}
void rotateRight (int pwm)
{
Serial.println("in rotateRight");
analogWrite(PWMA,2*pwm);
analogWrite(PWMB,pwm);
// plus on va vite, moins le delay devra etre important sinon on tournera beaucoup trop
if ( pwm == 15 ) {
delay(1000);
} else if ( pwm == 30 ) {
delay(500);
} else if ( pwm >= 45 ) {
delay(250);
}
}
void rotateLeft (int pwm)
{
Serial.println("in rotateLeft");
analogWrite(PWMA,pwm);
analogWrite(PWMB,2*pwm);
// plus on va vite, moins le delay devra etre important sinon on tournera beaucoup trop
if ( pwm == 15 ) {
delay(1000);
} else if ( pwm == 30 ) {
delay(500);
} else if ( pwm >= 45 ) {
delay(250);
}
}