Gestensteuerungsroboter

Notwendige Werkzeuge und Maschinen

Lötkolben (generisch)

Über dieses Projekt

Der Gestensteuerungsroboter ist eine der häufigsten Arten von Projekten, die von Bastlern und Studenten durchgeführt werden, um Mikrocontroller-Wissen in einem physischen und praktischen Projekt zu verstehen und zu implementieren. Das Konzept dahinter ist einfach:Die Ausrichtung der Handfläche steuert die Bewegung des Roboterautos. Wie geht das, fragen Sie? Lass es uns aufschlüsseln.

Um ein gutes Verständnis zu erhalten, werden wir die Rolle und Funktion jeder Komponente verstehen und sie dann kombinieren, um die gewünschte Leistung zu erzielen.

1. ADXL335 (Beschleunigungsmesser)

Die Funktion des Beschleunigungsmessers ist einfach:Erfassen der Ausrichtung des Handgelenks. Der Beschleunigungsmesser misst die Beschleunigung einschließlich der Erdbeschleunigung 'g'. Daher können wir den Beschleunigungsmesser verwenden, um die Ausrichtung des Handgelenks zu erfassen, indem wir die Komponente von 'g' in einer bestimmten Achse des ADXL335 messen, wie in der folgenden Abbildung gezeigt:

Aufgrund der Neigung der Hand wirkt auf sie auch der Winkel der X- und/oder Y-Achse mit vertikalen Änderungen und damit eine Komponente der 'g'-Beschleunigung, die gemessen werden kann und somit die Ausrichtung der Hand anzeigt.

Der ADXL335 kann bis zu 3 g Beschleunigung messen und ist mit Arduino verbunden, indem seine Achsenpins mit analogen Pins von Arduino verbunden werden. Der Beschleunigungsmesser gibt Spannungswerte proportional zur Beschleunigung aus.

In diesem Projekt ist der Beschleunigungsmesser mit Arduino Nano verbunden und an der Handfläche befestigt. Der ADXL335 gibt eine Spannung im Bereich von 0 bis Vcc (angelegte Spannung normalerweise 3,3 V) aus und wird von den analogen Pins von Arduino gelesen. Somit erhalten wir für den Benutzer einen Wert im Bereich von 0 bis 1024 (10-Bit-ADC). Die unterschiedliche Orientierung ergibt für jede Achse einen anderen Analogwert, der dann auf unterschiedliche Roboterbewegungen abgebildet wird.

Der Schaltplan für den Beschleunigungsmesser ist:

Ein Testcode, um die Funktionsweise von ADXL335 zu verstehen, lautet wie folgt:

void setup () { pinMode (A0, INPUT); // x-Achse ist mit A0 verbunden pinMode (A1, INPUT); // y-Achse ist mit A1 PinMode (A2, INPUT) verbunden; // Z-Achse ist mit A2Serial.begin (9600) verbunden; // Um ​​Daten auf Serial Monitor zu drucken}void loop () { Serial.print ( " X ="); Serial.println (analogRead (A0)); Serial.print ( " Y ="); Serial.println (analogRead (A1)); Serial.print("Z="); Serial.println (analogRead (A2)); Verzögerung(1000);} 

Sie können dieses Programm ausführen, um zu sehen, welche Werte Sie für die Vorwärts-, Rückwärts-, Links- und Rechtsneigung Ihrer Handfläche und Ihres Handgelenks erhalten, die schließlich zur Steuerung des Roboters verwendet werden.

2. RF-433 Sender und Empfänger

Die Funktion des RF-Moduls ist einfach:Befehlsdaten vom Handgelenk Arduino Nano an den Motor zu übertragen, der Arduino Uno steuert. Das HF-Modul verwendet Funkwellen mit einer Frequenz von 433 Hz und trägt daher den Namen RF-433. Sie verwenden die Amplitudenmodulation, um Daten zu senden, gehen jedoch nicht auf viele technische Details ein und halten die Dinge einfach. Sie werden verwendet, um Befehle an den Roboter zu übertragen, dh:vorwärts, rückwärts, rechts oder links bewegen. Und wenn keine Daten vorliegen, bleiben Sie stehen. Sie funktionieren gut bis zu einer Reichweite von 10 Metern.

Um nun zu verstehen, wie das HF-Modul in unserem Projekt implementiert wird, arbeiten wir nacheinander an den Sender- und Empfängerschaltkreisen.

Senderschaltung

Die Senderschaltung besteht aus zwei Teilen:dem Sender RF und dem Encoder HT12E. Der Sender besteht aus einem Daten-Pin, einer Antenne, einer Masse und einer Stromversorgung. Es ist die Aufgabe des HT12E-Encoders, dem Sender Daten bereitzustellen. Der Encoder besteht aus 4 Datenpins, deren Daten gesendet werden können. Wir werden diese 4 Datenpins verwenden, um die vier Bewegungen darzustellen, ein HIGH an diesen Pins einzeln repräsentiert eine der vier Bewegungen und ein LOW an allen steht für Stillstand.

Der Schaltplan ist wie abgebildet:

Die linken Pins (A0-A7) sind die Adresspins und definieren das Paar, das Daten austauscht (Sender und Empfänger mit gleichen Adressen teilen nur Daten). Wir werden A0-A7 auf LOW (geerdet) setzen.

Die Data In-Pins sind mit Arduino-Digitalpins verbunden (in diesem Projekt 6 bis 9) und sie geben die Befehlsdaten aus als:

Digitaler Pin-Befehl (wenn HIGH)

9 Weiterleiten

10 Rückwärts

11 Links

12 Rechts

Wir werden die digitalen Pins basierend auf dem Eingang von ADXL335 als HIGH digitalWrite, um die erforderliche Bewegung auszuführen.

Empfängerschaltung

Die Empfängerschaltung ist wie gezeigt der Senderschaltung völlig ähnlich, aber anstatt Datenpins als Ausgang von Arduino zu verwenden, werden sie in diesem Fall als Eingänge gelesen, um den Befehl für Arduino Uno aufzunehmen und die Motoren nach Bedarf zu betreiben:

Zur Vereinfachung können Sie die LED in Reihe an Pin 17 mit einem 1K-Widerstand anstelle der komplexen Schaltung schalten, wie gezeigt, um die ordnungsgemäße Verbindung mit dem Sender anzuzeigen.

3. MOTORSCHILD

Das Motorschild ist aufgrund der Verfügbarkeit der Adafruit-Bibliothek AFMotor am einfachsten zu handhaben, Link:- https://github.com/adafruit/Adafruit-Motor-Shield-library

Laden Sie die Bibliothek herunter und kopieren Sie sie in den Arduino-Bibliotheksordner, um sie in die Programmskizze aufzunehmen.

Ein Beispiel für die AFMotor-Bibliothek ist wie folgt:

#include AF_DCMotor motor (4); // Motorkabel an Punkt Motor 4 auf Shieldvoid setup () anschließen { Serial.begin (9600); // serielle Bibliothek mit 9600 bps einrichten Serial.println ("Motortest!"); // Motor einschalten motor.setSpeed ​​(200); motor.run(RELEASE);}void loop() { uint8_t i; Serial.print ("Häkchen"); motor.run(FOWARD); für (i=0; i<255; i++) { motor.setSpeed ​​(i); Verzögerung (10);} für (i =255; i! =0; i--) { motor.setSpeed ​​(i); Verzögerung (10);} Serial.print ("tock"); motor.run (RÜCKWÄRTS); für (i=0; i<255; i++) { motor.setSpeed ​​(i); Verzögerung (10);} für (i =255; i! =0; i--) { motor.setSpeed ​​(i); Verzögerung (10);} Serial.print ("tech"); motor.run(RELEASE); Verzögerung(1000); 

4. Alles kombinieren

Der letzte und letzte Teil beinhaltet das Kombinieren aller oben genannten Teile, um den kompletten Roboter zu bilden, der den Befehlen der Hand folgt!

Da das Motorschild fast alle digitalen Pins verwendet, verwenden wir die analogen Pins von Arduino Uno, um die Empfängerdaten zu lesen. Der endgültige Schaltplan ist wie folgt:

Der Motorschirm übernimmt die Verbindungen zu den Motoren. Schließen Sie eine 9-V-Batterie an den Stromeingang der Abschirmung an.

HINWEIS:Ich persönlich bevorzuge es, 2 oder sogar 3,9-V-Batterien parallel an den Schildstromeingang anzuschließen, um genügend Leistung für den Betrieb aller vier Motoren bereitzustellen. Ich habe die vier Motoren in einer 2er Gruppe geschaltet (gleichseitige Motoren sind parallel miteinander verbunden und benötigen daher nur die Motorpunkte 3 und 4 zum Laufen).

Der endgültige Code

Für Arduino Nano:

int x_axis =0;int y_axis =0;int vorwärts =9;int rückwärts =10;int rechts =11;int links =12;void setup(){ pinMode(A0, INPUT); // X-Achsen-PinMode (A3, AUSGANG); // Y-Achse PinMode (vorwärts, AUSGANG); // HOCH, um vorwärts zu bewegen PinMode (rückwärts, AUSGANG); // HOCH, um rückwärts zu bewegen pinMode (rechts, AUSGANG); // HOCH, um den rechten PinMode (links, OUTPUT) zu bewegen; // HOCH, um nach links zu bewegen Serial.begin (9600);} ungültige Schleife () { x_axis =analogRead (A0); y_Achse =analogRead(A3); Serial.print(" X ="); Serial.println (x_axis); Serial.print(" Y ="); Serial.println (y_axis); if (y_axis>=390) {Serial.println ("Forward"); digitalWrite (vorwärts, HIGH); aufrechtzuerhalten. Sonst { if (y_axis <=310) { Serial.println ("BACK"); digitalWrite (rückwärts, HIGH); aufrechtzuerhalten. Sonst { if (x_axis>=380) { Serial.println ("RECHTS"); digitalWrite (rechts, HIGH); aufrechtzuerhalten. Sonst { if (x_axis <=320) { Serial.println ( "LINKS"); digitalWrite (links, HIGH); } Serial.println(" "); } } } Verzögerung (200); if (x_axis> 320 &&x_axis <380 &&y_axis> 310 &&y_axis <390) { digitalWrite (vorwärts, LOW); digitalWrite (rückwärts, LOW); digitalWrite (rechts, NIEDRIG); digitalWrite (links, LOW); }} 

Für 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, EINGANG); PinMode (A3, EINGANG); PinMode (A4, EINGANG); PinMode (A5, EINGANG); Serial.begin (9600); motor_right.setSpeed(255); motor_left.setSpeed(255); motor_right.run(RELEASE); motor_left.run(RELEASE);}void loop() { forward=digitalRead(A0); rückwärts =digitalRead (A1); rechts =digitalRead (A2); links =digitalRead (A3); if (vorwärts ==HOCH) { motor_right.run (FORWARD); motor_left.run(FORWARD); Serial.println ("Vorwärts"); aufrechtzuerhalten. Wenn (rückwärts ==HOCH) { motor_right.run (RÜCKWÄRTS); motor_left.run (RÜCKWÄRTS); Serial.println ( "Rückwärts"); } if(right==HIGH) { motor_right.run(FORWARD); motor_left.run(RELEASE); Serial.println ("RECHTS"); } if(left==HIGH) { motor_right.run(RELEASE); motor_left.run(FORWARD); Serial.println ("LINKS"); } if (links ==NIEDRIG &&rechts ==NIEDRIG &vorwärts ==NIEDRIG &&rückwärts ==NIEDRIG) { motor_right.run (RELEASE); motor_left.run(RELEASE); } Verzögerung (100);} 

Die Fotos und Videos sind hier: