Robot à commande gestuelle : Construisez votre propre bot à détection de mouvement

Composants et fournitures

Arduino UNO	×	1
Arduino Nano R3	×	1
Émetteur/récepteur RF 433 MHz	×	1
Encodeur/Décodeur HT12	×	1
Accéléromètre analogique Adafruit ADXL335	×	1
Shield moteur pour Uno	×	1
Moteur DC (générique)	×	1

Outils nécessaires

• Fer à souder (générique)

À propos du projet

Le robot à commande gestuelle est l'un des projets les plus courants réalisés par les amateurs et étudiants pour comprendre et implémenter les connaissances sur microcontrôleurs dans un projet physique et pratique. Le concept est simple : l'orientation de la paume contrôle le mouvement du robot. Voyons comment cela fonctionne en détail.

1. ADXL335 (Accéléromètre)

L'accéléromètre détecte l'orientation du poignet. Il mesure l'accélération, y compris la gravité 'g'. On peut donc utiliser l'accéléromètre pour détecter l'orientation en mesurant la composante de 'g' sur un axe particulier de l'ADXL335. Du fait de l'inclinaison de la main, l'angle des axes X et/ou Y avec la verticale change, et une composante de l'accélération 'g' agit sur eux, ce qui peut être mesuré et indique l'orientation.

L'ADXL335 mesure jusqu'à 3g et s'interface avec l'Arduino en connectant ses axes aux broches analogiques. Il sort des tensions proportionnelles à l'accélération. Dans ce projet, l'accéléromètre est connecté à l'Arduino Nano et fixé à la paume. La sortie 0-Vcc (généralement 3,3V) est lue par les broches analogiques de l'Arduino, donnant une valeur 0-1024 (ADC 10 bits). Chaque orientation donne une valeur analogique différente pour chaque axe, qui est ensuite mappée aux mouvements du robot.

Schéma de câblage de l'accéléromètre

Voir schéma joint.

Code de test ADXL335

void setup() {
  pinMode(A0, INPUT); // X
  pinMode(A1, INPUT); // Y
  pinMode(A2, INPUT); // Z
  Serial.begin(9600);
}
void loop() {
  Serial.print(" X= "); Serial.println(analogRead(A0));
  Serial.print(" Y= "); Serial.println(analogRead(A1));
  Serial.print(" Z= "); Serial.println(analogRead(A2));
  delay(1000);
}

Exécutez ce programme pour voir les valeurs pour inclinaison avant/arrière, gauche/droite de votre paume, qui serviront au contrôle final.

2. Émetteur et récepteur RF 433 MHz

Le module RF transmet les données de commande de l'Arduino Nano (poignet) vers l'Arduino Uno (moteurs). Il utilise des ondes radio à 433 MHz avec modulation d'amplitude. En termes simples : il transmet les commandes (avancer, reculer, droite, gauche) et en l'absence de données, le robot reste immobile. Portée ~10 mètres.

Circuit émetteur

Composé de l'émetteur RF et de l'encodeur HT12E. L'encodeur a 4 broches de données pour représenter les 4 mouvements : un HIGH sur chacune = un mouvement, LOW sur toutes = arrêt. Les broches d'adresse (A0-A7) sont mises à la masse. Les broches de données connectées aux broches numériques 6-9 de l'Arduino Nano :

• Broche 9 → Avant
• Broche 10 → Arrière
• Broche 11 → Gauche
• Broche 12 → Droite

Circuit récepteur

Similaire à l'émetteur, mais les broches de données sont lues en entrée par l'Arduino Uno pour commander les moteurs. Pour simplifier, on peut connecter une LED en série sur la broche 17 avec une résistance 1kΩ pour indiquer la bonne liaison.

3. Shield Moteur

Le shield moteur est facile à gérer grâce à la bibliothèque Adafruit AFMotor (GitHub). Télécharger et copier dans le dossier libraries d'Arduino.

Exemple bibliothèque AFMotor

#include 
AF_DCMotor motor(4);
void setup() {
  Serial.begin(9600);
  Serial.println("Test moteur !");
  motor.setSpeed(200);
  motor.run(RELEASE);
}
void loop() {
  // ... contrôle vitesse avant/arrière ...
}

4. Assemblage final

Comme le shield moteur utilise presque toutes les broches numériques, on utilise les broches analogiques de l'Arduino Uno pour lire les données du récepteur. Le shield gère les connexions aux moteurs. Connecter une batterie 9V à l'entrée d'alimentation du shield (préférablement 2-3 batteries 9V en parallèle pour assez de puissance pour 4 moteurs). Les 4 moteurs sont groupés par 2 (moteurs du même côté en parallèle), nécessitant seulement les points moteur 3 et 4.

Codes finaux

Pour Arduino Nano (émetteur) :

int x_axis = 0, y_axis = 0;
int forward = 9, backward = 10, right = 11, left = 12;

void setup() {
  pinMode(A0, INPUT);
  pinMode(A3, OUTPUT);
  pinMode(forward, OUTPUT);
  pinMode(backward, OUTPUT);
  pinMode(right, OUTPUT);
  pinMode(left, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  x_axis = analogRead(A0);
  y_axis = analogRead(A3);
  Serial.print(" X = "); Serial.println(x_axis);
  Serial.print(" Y = "); Serial.println(y_axis);
  
  if (y_axis >= 390) { Serial.println("Forward"); digitalWrite(forward, HIGH); }
  else if (y_axis <= 310) { Serial.println("BACK"); digitalWrite(backward, HIGH); }
  else if (x_axis >= 380) { Serial.println("RIGHT"); digitalWrite(right, HIGH); }
  else if (x_axis <= 320) { Serial.println("LEFT"); digitalWrite(left, HIGH); }
  else { Serial.println(" "); }
  
  delay(200);
  
  if (x_axis > 320 && x_axis < 380 && y_axis > 310 && y_axis < 390) {
    digitalWrite(forward, LOW);
    digitalWrite(backward, LOW);
    digitalWrite(right, LOW);
    digitalWrite(left, LOW);
  }
}

Pour Arduino Uno (récepteur + moteurs) :

#include 
AF_DCMotor motor_right(3);
AF_DCMotor motor_left(4);
int forward=0, backward=0, right=0, left=0;

void setup() {
  pinMode(A2, INPUT); pinMode(A3, INPUT);
  pinMode(A4, INPUT); pinMode(A5, INPUT);
  Serial.begin(9600);
  motor_right.setSpeed(255);
  motor_left.setSpeed(255);
  motor_right.run(RELEASE);
  motor_left.run(RELEASE);
}

void loop() {
  forward = digitalRead(A0);
  backward = digitalRead(A1);
  right = digitalRead(A2);
  left = digitalRead(A3);
  
  if (forward == HIGH) { motor_right.run(FORWARD); motor_left.run(FORWARD); Serial.println("Forward"); }
  if (backward == HIGH) { motor_right.run(BACKWARD); motor_left.run(BACKWARD); Serial.println("Reverse"); }
  if (right == HIGH) { motor_right.run(FORWARD); motor_left.run(RELEASE); Serial.println("RIGHT"); }
  if (left == HIGH) { motor_right.run(RELEASE); motor_left.run(FORWARD); Serial.println("LEFT"); }
  if (left==LOW && right==LOW && forward==LOW && backward==LOW) {
    motor_right.run(RELEASE); motor_left.run(RELEASE);
  }
  delay(100);
}