Imprimer

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 :

 

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 

 

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 :

 

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);
 }
}