Voiture robotisée et contrôlée via bluetooth avec Arduino.

Dans ce post nous allons construire un robot mobile contrôlé via bluetooth à travers d’une application Android pour notre portable.

Le montage et la mise en fonctionnement de ce petit projet est simple car il est le résultat de la combinaison de deux tutoriels que nous avons déjà pratiqué: Fonctionnement du module contrôleur de moteurs L298N. et Tutoriel basique d’usage du module bluetooth HC-06 avec Arduino. On vous conseille de revoir ces deux articles afin de connaître préalablement le fonctionnement du contrôleur de moteurs L298N et comment configurer et connecter le module bluetooth HC-06.

Il est nécessaire:

• Plaque Arduino ou équivalent.
• Châssis de voiture.
• 2 pneus de voiture.
• 1 roue universelle.
• 2 moteurs réducteurs TT de double axe.
• Module contrôleur de moteurs L298N.
• Module bluetooth HC-06.
• Interrupteur ON/OFF à 2 pins.
• Boîtier de batteries 4 piles AA.
• Batterie de 9 V pour le module L298N et les moteurs.
• Fils.
• Vis et écrous.

Schéma.

Assemblage.

1. On connecte les cables aux moteurs et on les fixe au châssis.

Pour connecter les cables rouges et noirs on peut faire deux choix: les souder aux bornes métalliques des moteurs ou bien, utiliser du ruban isolant et adhésif, faisant attention de bien relier les contacts et les bornes.

Pour fixer les moteurs au châssis on utilisera les pièces rectangulaires (fournies avec le châssis) et les vis.

2. On installe la roue universelle et le boîtier des batteries.

Cette roue n’a pas de traction et tourne librement.

Le porte-piles sera chargé de contenir les 4 piles AA qui vont alimenter la plaque Arduino.

3. On fixe l’interrupteur.

On utilisera cet interrupteur pour notre module contrôleur de moteurs L298N. On l’insère dans le creux entre les deux moteurs au centre du châssis.

4. On fixe la plaque Arduino à l’avant du châssis.

5. On installe le module L298N à l’arrière du châssis.

Une fois installé on relie les cables des moteurs avec leurs pins correspondant du module.

6. On installe la pile de 9 V qui va alimenter le module contrôleur.

Le cable rouge se relie avec l’entrée d’énergie du module et le cable noir (masse) au GND du module et au GND de la plaque Arduino.

7. On connecte la plaque Arduino avec le module L298N.

On relie les pins de cette façon:

• ENA -> pin 10 (cable vert). Rappelez-vous que les pins ENA et ENB sont ceux qui gèrent la vitesse de rotation.
• ENB -> pin 5 (vert)
• IN1 -> pin 9 (orange)
• IN2 -> pin 8 (bleu)
• IN3 -> pin 7 (bleu)
• IN4 -> pin 6 (orange)

8. On essaie les moteurs.

Arrivés à ce stade on peut vraiment essayer les moteurs et tester si la rotation des roues est la correcte.

Le code pour tester la rotation des moteurs n’utilise pas de bibliothèque. Néanmoins, si vous la préférez, vous pouvez le faire suivant le tutoriel : fonctionnement du module contrôleur de moteurs L298N.

// Moteur 1
int ENA = 10;
int IN1 = 9;
int IN2 = 8;

// Moteur 2
int ENB = 5;
int IN3 = 7;
int IN4 = 6;

void setup() {
 pinMode (ENA, OUTPUT);
 pinMode (ENB, OUTPUT);
 pinMode (IN1, OUTPUT);
 pinMode (IN2, OUTPUT);
 pinMode (IN3, OUTPUT);
 pinMode (IN4, OUTPUT);  
}

void loop() {
  Avancer();
  delay(5000);
  Reculer();
  delay(5000);
  Droite();
  delay(5000);
  Gauche();
  delay(5000);
  Pause();
  delay(5000);
}

void Avancer (){
 //Direction moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 100); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 100); //Vitesse moteur B
}

void Droite (){
 //Direction moteur A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 255); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 255); //Vitesse moteur A
}

void Gauche (){
 //Direction moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 255); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 255); //Vitesse moteur A
}

void Reculer (){
 //Direction moteur A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 255); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 255); //Vitesse moteur B
}

void Pause (){
 //Direction moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 0); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 0); //Vitesse moteur A
}

Vous pouvez observer que chaque fonction est séparée, il faudra les tester une par une pour voir si elles correspondent avec le mouvement que vous désirez, dans le cas contraire il faudra réviser les cables des connexions ou modifier la section du code où se trouve le problème. IN1 et IN2 sont les pins responsables de la rotation du moteur. Si IN1 est configuré HIGH et IN2 est configuré LOW, pour changer le sens de rotation on doit inverser la configuration (IN1 -> LOW / IN2 -> HIGH).

9. On connecte le module bluetooth.

On établit les connexions entre la plaque et le module:

• VCC -> se connecte au pin 5 V d’Arduino.
• GND -> se connecte au pin GND de la plaque.
• TXD -> au pin 4 de la plaque.
• RXD -> au pin 2 .

Avant de tester le module on doit configurer l’application. Cette application nous l’avons déjà utilisée dans le tutoriel: tutoriel basique d’usage du module bluetooth HC-06 avec Arduino. On peut la télécharger de Google Play (Arduino bluetooth controller).

Pour installer l’application on doit d’abord relier le portable au module. Si on ouvre l’application, on vera:

Sur l’écran apparaîtra le nom du dispositif, par défaut HC-06 si vous utiliser celui-ci. Dans ce cas concret, on lit mibluetooth puisque nous avons changé la configuration. Le mot de passe par défaut est 1234. Un fois connecté on choisit: controller mode.

Pour contrôler notre voiture on utilisera les flèches du côté gauche; on les configurera cliquant sur l’icone de la roue dans la zone supérieur droite, sur la nouvelle fenêtre on pourra gérer chaque flèche choisissant les lettres qui correspondent à l’image de la droite. Nous avons choisi: G -> gauche, A -> avancer, D -> droite, R -> reculer et P -> pause. (I -> initialisation).

On ajoute le code nécessaire pour le contrôle du module bluetooth avec la bibliothèque SoftwareSerial, laissant libres les pins 0 et 1 de la plaque Arduino:

#include <SoftwareSerial.h>
SoftwareSerial BT(4,2);

Dans la fonction setup() on démarre la communication série avec le port BT:

Serial.begin(9600);
BT.begin(9600);

Et on modifie la fonction loop() pour contrôler notre voiture. Arduino doit réaliser les mouvements que nous l’indiquons en pressant les commandes configurées dans l’application du portable.

void loop() {
  if (BT.available()){
    char donnee=BT.read();

    switch(donnee){
      case 'a':
        Avancer();
        break;
      case 'r':
        Reculer();
        break;
      case 'd':
        Droite();
        break;
      case 'g':
        Gauche();
        break;
      case 'p':
        Pause();
        break;
    }    
  }
}

Le code complet:

#include <SoftwareSerial.h>
SoftwareSerial BT(4,2);

// Moteur 1
int ENA = 10;
int IN1 = 9;
int IN2 = 8;

// Moteur 2
int ENB = 5;
int IN3 = 7;
int IN4 = 6;

void setup() {
 Serial.begin(9600);
 BT.begin(9600);

 pinMode (ENA, OUTPUT);
 pinMode (ENB, OUTPUT);
 pinMode (IN1, OUTPUT);
 pinMode (IN2, OUTPUT);
 pinMode (IN3, OUTPUT);
 pinMode (IN4, OUTPUT);  
}

void loop() {
  if (BT.available()){
    char donnee=BT.read();

    switch(donnee){
      case 'a':
        Avancer();
        break;
      case 'r':
        Reculer();
        break;
      case 'd':
        Droite();
        break;
      case 'g':
        Gauche();
        break;
      case 'p':
        Pause();
        break;
    }
  }  
}

void Avancer (){
 //Direction moteur A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 255); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 255); //Vitesse moteur B
}

void Droite (){
  //Direction moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 100); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 100); //Vitesse moteur B
}

void Gauche (){
 //Direction moteur A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 100); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 100); //Vitesse moteur A
}

void Reculer (){
 //Direction moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 255); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 255); //Vitesse moteur B
}

void Pause (){
 //Direction moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 0); //Vitesse moteur A
 //Direction moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 0); //Vitesse moteur A
}

« Précédent

Débuter avec mBlock et le robot mBot, programmation par blocs.

Suivant »

Piloter un robot Arduino esquivant les obstacles grâce au capteur à ultrasons.

Articles similaires

Comment relier l’écran LCD à l’ Arduino Uno.

Claviers matriciels

Lecture d’un potentiomètre. Entrées analogiques d’Arduino.