Robot de contrôle des gestes

Outils et machines nécessaires

Fer à souder (générique)

À propos de ce projet

Le robot à commande gestuelle est l'un des types de projets les plus courants réalisés par les amateurs et les étudiants pour comprendre et mettre en œuvre les connaissances des microcontrôleurs dans un projet physique et pratique. Le concept est simple :l'orientation de la paume contrôle le mouvement de la voiture robotisée. Comment fait-il cela, demandez-vous? Décomposons-le.

Pour bien comprendre, nous allons procéder en comprenant le rôle et la fonction de chaque composant, puis en les combinant pour obtenir les performances souhaitées.

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

La fonction de l'accéléromètre est simple :capter l'orientation du poignet. L'accéléromètre mesure l'accélération, y compris l'accélération due à la gravité « g ». Ainsi, nous pouvons utiliser l'accéléromètre pour détecter l'orientation du poignet en mesurant la composante de « g » dans n'importe quel axe particulier de l'ADXL335, comme le montre la figure ci-dessous :

En raison de l'inclinaison de la main, l'angle de l'axe X et/ou Y avec les changements verticaux et donc une composante de l'accélération 'g' agit également sur eux qui peut être mesuré et indique ainsi l'orientation de la main.

L'ADXL335 peut mesurer jusqu'à 3g d'accélération et est interfacé avec Arduino en connectant ses broches d'axe aux broches analogiques d'Arduino. L'accéléromètre délivre des valeurs de tension proportionnelles à l'accélération.

Dans ce projet, l'accéléromètre est connecté à Arduino Nano et est attaché à la paume. L'ADXL335 produit une tension dans une plage de 0 à Vcc (tension appliquée généralement de 3,3 V) et est lu par les broches analogiques d'Arduino. Ainsi pour l'utilisateur, on obtient une valeur comprise entre 0 et 1024 (ADC 10 bits). L'orientation différente donne une valeur analogique différente pour chaque axe qui est ensuite mappée sur différents mouvements de robot.

Le schéma de circuit de l'accéléromètre est :

Un code de test pour comprendre le fonctionnement de l'ADXL335 est le suivant :

void setup(){ pinMode(A0,INPUT); // L'axe x est connecté à A0 pinMode (A1, INPUT); // l'axe y est connecté à A1 pinMode (A2, INPUT); //l'axe z est connecté à A2Serial.begin(9600); //Pour imprimer les données sur Serial Monitor}void loop(){ Serial.print(" X="); Serial.println(analogRead(A0)); Serial.print(" Y="); Serial.println(analogRead(A1)); Serial.print(" Z="); Serial.println(analogRead(A2)); retard(1000);} 

Vous pouvez exécuter ce programme pour voir quelles valeurs vous obtenez pour l'inclinaison en avant, en arrière, à gauche et à droite de votre paume et de votre poignet qui seront finalement utilisées pour contrôler le robot.

2. Émetteur et récepteur RF-433

La fonction du module RF est simple :transmettre les données de commande du poignet Arduino Nano au moteur contrôlant l'Arduino Uno. Le module RF utilise des ondes radio à la fréquence 433hz et donc le nom RF-433. Ils utilisent la modulation d'amplitude pour envoyer des données, mais sans entrer dans beaucoup de détails techniques et en gardant les choses simples, ils seront utilisés pour transmettre des commandes au robot, c'est-à-dire :avancer, reculer, droite ou gauche. Et en cas d'absence de données, restez immobile. Ils fonctionnent bien jusqu'à une portée de 10 mètres.

Maintenant, pour comprendre comment implémenter le module RF dans notre projet, travaillons séquentiellement sur les circuits émetteur et récepteur.

Circuit émetteur

Le circuit émetteur se compose de deux parties :l'émetteur RF et l'encodeur HT12E. L'émetteur se compose d'une broche de données, d'une antenne, d'une masse et d'une alimentation. C'est le travail de l'encodeur HT12E de fournir des données à l'émetteur. L'encodeur se compose de 4 broches de données dont les données peuvent être envoyées. Nous utiliserons ces 4 broches de données pour représenter les quatre mouvements, un HAUT sur ces broches individuellement représentera l'un des quatre mouvements et un BAS sur tous représente l'arrêt.

Le schéma de circuit est comme indiqué :

Les broches de gauche (A0-A7) sont les broches d'adresse et définissent la paire qui échangera des données (l'émetteur et le récepteur ayant les mêmes adresses ne partageront que les données). Nous allons définir A0-A7 comme LOW (Grounded).

Les broches d'entrée de données sont connectées aux broches numériques Arduino (dans ce projet 6 à 9) et elles généreront les données de commande sous la forme :

Commande de broche numérique (lorsque HAUT)

9 Avant

10 Inverser

11 Gauche

12 Droit

Nous allons digitalWrite les broches numériques comme HIGH en fonction de l'entrée de ADXL335 pour effectuer le mouvement requis.

Circuit récepteur

Le circuit récepteur est complètement similaire au circuit émetteur comme indiqué, mais au lieu de broches de données allant en sortie d'Arduino, dans ce cas, elles seront lues comme des entrées pour prendre la commande pour Arduino Uno et faire fonctionner les moteurs selon les besoins :

Pour simplifier, vous pouvez connecter la LED en série à la broche 17 avec une résistance de 1K au lieu du circuit complexe comme indiqué pour indiquer une connexion correcte avec l'émetteur.

3. BOUCLIER MOTEUR

Le bouclier moteur est la partie la plus facile à manipuler en raison de la disponibilité de la bibliothèque Adafruit AFMotor, lien :- https://github.com/adafruit/Adafruit-Motor-Shield-library

Téléchargez et copiez la bibliothèque dans le dossier des bibliothèques Arduino pour pouvoir l'inclure dans l'esquisse du programme.

Un exemple de bibliothèque AFMotor est donné :

#include AF_DCMotor motor(4) ;//Fixer les fils du moteur au point Motor 4 sur shieldvoid setup() { Serial.begin(9600); // configuration de la bibliothèque série à 9600 bps Serial.println("Motor test!"); // allume le moteur motor.setSpeed(200); motor.run(RELEASE);}void loop() { uint8_t i; Serial.print("tick"); motor.run(AVANT); pour (i=0; i<255; i++) { motor.setSpeed(i); delay(10);} pour (i=255; i!=0; i--) { motor.setSpeed(i); delay(10);} Serial.print("tock"); motor.run(BACKWARD); pour (i=0; i<255; i++) { motor.setSpeed(i); delay(10);} pour (i=255; i!=0; i--) { motor.setSpeed(i); delay(10);} Serial.print("tech"); motor.run(RELEASE); retard(1000); 

4. Tout combiner

La dernière et la dernière partie comprend la combinaison de toutes les parties ci-dessus pour former le robot complet qui suit les commandes de la main !

Étant donné que le blindage du moteur utilise presque toutes les broches numériques, nous utiliserons les broches analogiques d'Arduino Uno pour lire les données du récepteur. Le schéma de circuit final est comme indiqué :

Le blindage du moteur gère les connexions aux moteurs. Connectez une pile 9V à l'entrée d'alimentation du blindage.

REMARQUE :Je préfère personnellement connecter 2 ou même 3,9 V batteries en parallèle à l'entrée d'alimentation du blindage pour fournir suffisamment de puissance pour faire fonctionner les quatre moteurs. J'ai connecté les quatre moteurs dans un groupe de 2 (les moteurs du même côté sont connectés en parallèle et ne nécessitent donc que les points moteur 3 et 4 pour fonctionner).

Le code final

Pour Arduino Nano :

int x_axis =0;int y_axis =0;int avant =9;int arrière =10;int droite =11;int gauche =12;void setup(){ pinMode(A0, INPUT); //Mode broche de l'axe X (A3, SORTIE); // PinMode de l'axe Y (avant, SORTIE); //HIGH pour avancer pinMode(backward, OUTPUT); //HIGH pour reculer pinMode(right, OUTPUT); //HIGH pour déplacer Right pinMode(left, OUTPUT); //HIGH pour se déplacer vers la gauche 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(en avant, HAUT); } else { if (y_axis <=310) { Serial.println("BACK"); digitalWrite (en arrière, HAUT); } else { if (x_axis>=380) { Serial.println("RIGHT"); digitalWrite (droit, HAUT); } else { if (x_axis <=320) { Serial.println("LEFT"); digitalWrite(gauche, HAUT); } Serial.println(" "); } } } délai (200); if (x_axis> 320 &&x_axis <380 &&y_axis> 310 &&y_axis <390) { digitalWrite(forward, LOW); digitalWrite (en arrière, LOW); digitalWrite (à droite, FAIBLE); digitalWrite(gauche, BAS); }} 

Pour Arduino Uno :

#includeAF_DCMotor motor_right(3);AF_DCMotor motor_left(4);int forward=0;int back=0;int right=0;int left=0;void setup() { pinMode (A2, INPUT); pinMode(A3,ENTRÉE); pinMode(A4,ENTRÉE); pinMode(A5,ENTRÉE); Serial.begin(9600); motor_right.setSpeed(255); motor_left.setSpeed(255); motor_right.run(RELEASE); motor_left.run(RELEASE);}void loop() { forward=digitalRead(A0) ; vers l'arrière=digitalRead(A1) ; right=digitalRead(A2) ; gauche=numériqueLecture(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("GAUCHE"); } if(left==LOW&&right==LOW&&forward==LOW&&backward==LOW) { motor_right.run(RELEASE); motor_left.run(RELEASE); } délai(100);} 

Les photos et vidéos sont ici :