DIY Arduino Roboterarm – gesteuert durch Handgesten

Notwendige Werkzeuge und Maschinen

3D-Drucker (generisch)

Über dieses Projekt

Einführung des DIY-Roboterarms, der durch menschliche Gesten gesteuert wird.

Blockbuster-Filme wie Pacific Rim, Avatar und andere Science-Fiction-Filme haben auf die Möglichkeit hingewiesen, mit Robotern zu arbeiten – wo Ihre Bewegungen mit Roboterunterstützung verbessert werden können.

Was wäre, wenn wir den gleichen Industrieroboter bauen könnten, aber in kleinerem Maßstab?

Dieses Projekt ist ein Versuch, dies zu erreichen.

Dies ist ein Arduino-Roboterarm, der durch Handgesten programmiert oder sogar gesteuert werden kann.

Um der Anzugkonvention von Iron Man treu zu bleiben, würde jede Iteration als Mark bekannt sein. Dieser Prototyp würde als MARK 1 bekannt sein. Wir können erwarten, dass weitere Iterationen den ursprünglichen Roboterarm verbessern.

Sehen Sie sich hier das vollständige Tutorial für den DIY-Roboterarm (gesteuert durch Handgesten) an

Übersicht

In diesem Tutorial bauen wir einen sechsachsigen Roboter, der mit Handgesten mit einem Roboterhandschuh gesteuert wird. Und durch Nachahmen natürlicher menschlicher Gesten wie einem Kneifen oder einer Handgelenksdrehung nach links können Sie den Roboterarm öffnen/schließen oder nach links bzw. rechts drehen. Tatsächlich wird ein Roboterarm manuell gesteuert.

Weitere Details zum Originalartikel finden

MARK 1-Funktionen:

• 6-Achsen-Rotation
• Tragbar
• Steuern Sie den Roboter mit menschlichen Gesten
• Kann für grundlegende Funktionen vorprogrammiert werden
• Kann drahtlos aus der Entfernung gesteuert werden
• Kann ein Lastgewicht von 600 g halten (max. Last 1 kg)

Teileliste

Der Roboterarm ist vollständig anpassbar. Sie können entweder Ihre eigenen kaufen oder Ihre eigenen in 3D drucken. Wenn Sie sich für den 3D-Druck entscheiden, machen Sie sich keine Sorgen. Es gibt eine Liste verschiedener Roboter, die Servomotoren verwenden, daher gilt die Theorie dessen, was wir bauen, immer noch.

Für dieses Projekt würde dieser Prototyp (Mark 1) in 3D gedruckt, da er mir mehr Platz gibt, um benutzerdefinierte Teile zu erstellen.

Roboterarm: Thingiverse 3D-gedruckter Roboterarm (Credits:Wonder Tiger):

• Teil 1:Greiferteile
• Teil 2:Basis und Plattenspieler
• Teil 3:Kernarm des Roboters

Weitere Informationen zu diesem Build finden Sie zusammen mit den Schraubentypen aus den obigen Teilen. Die Druckzeit kann bis zu 40 Stunden betragen. Dies senkt jedoch die Kosten für den Kauf eines Roboterarms.

Roboterhandschuh : Die Robotic Glove.STL-Dateien (Credits:Roman 13)

Der Roboterhandschuh war eine ästhetische Ergänzung des Projekts, aber Sie können auch einen Bauhandschuh verwenden, um den Roboterarm zu implementieren.

Hinweis: für größere Hände drucken Sie mit einer Skalierung von 105%

Wie es funktioniert

Insgesamt senden wir ein Signal (über Bluetooth) vom Roboterhandschuh an den Servomotor. Wenn ein Wert empfangen wurde, sendet der Servotreiber ein Signal an einen bestimmten Servomotor, der den Roboterarm bewegt.

Wenn wir nun mehrere Servos und mehr Sensoren hinzufügen, können wir jeden Motor steuern. `

Wenn wir uns einen Roboterarm als eine Reihe von Servomotoren vorstellen, die sich gegenseitig koordinieren, um eine Funktion auszuführen, können wir einen Roboterarm erstellen, der von einem Roboterhandschuh gesteuert wird.

Das Arduino des Roboterhandschuhs verwendet Sensoren, um mit dem Roboterarm Arduino zu kommunizieren und sendet Daten, um einen Servo in den gewünschten Winkel zu bewegen.

Sie fragen sich vielleicht, welche Sensoren der Roboterhandschuh verwendet?

Für MARK 1 würden wir Flex-Sensoren und einen Beschleunigungsmesser (MPU6050) verwenden

• Flexsensoren – Je nach Biegungsgrad dieses Kunststoffteils ändert sich der Widerstand und beeinflusst den Strom. Diese Messung wird dann verwendet, um Änderungen der Handbewegungen zu erkennen.
• Beschleunigungsmesser – Für natürlichere Gesten kann ein Beschleunigungsmesser eine Änderung der Arm- und Handgelenksrotation erkennen.

Wir verwenden diese Sensoren, um eine Änderung einer Geste zu erkennen. Wir können dann einen bestimmten Wert, der einer Geste zugeordnet ist, an den Roboterarm senden, um einen Servomotor über Bluetooth zu steuern. Und mit genug Gesten erwacht der Roboterarm zum Leben!

Roboterarm-Mapping

Das Folgende stellt eine Zuordnungstabelle der Werte dar, die vom Handschuh an den Roboterarm gesendet werden. Dies ist im Originalartikel zu finden. Jeder hat einen Schlüssel, um seine Funktion zu charakterisieren. (P – Pinkie, L – Rechts usw.)

Hinweis: Großbuchstabe „F“ (Finger) repräsentiert die entgegengesetzte Drehrichtung des Servomotors

Montage von Teilen

Roboterarm – Montage

Der Kauf eines Roboterarms kann ziemlich teuer sein. Um diesen Roboterarm innerhalb des Budgets zu halten, war der 3D-Druck eines Roboterarms die beste Option.

Dies hilft auf lange Sicht, da es viele Beispiele für einen 3D-gedruckten Roboterarm gibt, der individuell angepasst werden kann, z. B. Hinzufügen einer LED, Erstellen eines Kameraständers Klemme:

Wie bereits erwähnt, wurde der Roboterarm dem Roboterarm von Thingyverse nachempfunden. Ich habe dieses Beispiel gewählt, da es ein ausgezeichnetes Design mit sechs Achsen war, gut dokumentiert und stark/robust war. Sie können über die Teileliste auf den Roboterarm von Wonder Tiger zugreifen.

Sie können auch meine Remixe für einen Roboterarm-Kamerastand finden. Wir werden dies in einer zukünftigen Version ausführlicher behandeln. Die Teile können jedoch mindestens 40 Stunden dauern, um alle Teile zu drucken.

Sie können auch viele andere 3D-gedruckte Roboterarm-Alternativen finden.

Vorstellung des Servomotors und des Treibers

Da der Roboterarm idealerweise eine Reihe von Motoren ist, die sich koordinieren, können wir theoretisch mehrere Motoren anbringen, die alle vom Arduino angetrieben werden können. In diesem Projekt verwenden wir den PCA9685-Servotreiber, um den MG966R-Servo mit Strom zu versorgen.

Hinweis: Verwenden Sie eine externe Stromversorgung, wenn Sie jeden Motor mit Strom versorgen. Der Arduino kann nicht genug Leistung liefern, um alle Motoren zu steuern. In diesem Projekt wurde eine 5V, eine 2200 mAh RC Batterie verwendet.

Die Verdrahtung des Arduino-Diagramms sollte wie folgt aussehen:

NEMA-17 für Basisrotation

Da der Robotic langsam an Gewicht zunahm und der Servomotor MG966R nicht stark genug war, um den Robotic Arm an der Basis zu drehen. Um den Roboterarm zu drehen, müsste ein robusterer Motor als ein Servomotor verwendet werden

Aufgrund seiner Präzision und seines hohen Drehmoments kann ein Schrittmotor (NEMA-17) verwendet werden, der dem Roboterarm hilft, sich nahtlos zur Gestensteuerung zu drehen.

Die NEMA-17 und der A4988-Treiber werden verwendet, um die Richtung des Motors zu steuern, wie Sie dem Diagramm unten entnehmen können:

Und schließlich zeigt das folgende Diagramm den endgültigen Schaltplan des kompletten Roboterarms.

Montage der Schaltung

Der folgende Schaltplan zeigt die Endmontage aller elektronischen Teile zu einem Roboterarm, einschließlich des Bluetooth-Moduls. Wir werden den Paring-Prozess unten behandeln.

Menschlicher Flex-Sensor

Um der Ästhetik des Roboterarms treu zu bleiben, können Sie einen 3D-gedruckten Exoskelett-Handschuh drucken, um ihn als Roboterhandschuh zu verwenden.

Sie können jedoch einen standardmäßigen Bauhandschuh . verwenden für das Prototyping des Roboterhandschuhs. Dieses „Roboterhandschuh-Exoskelett“-Design passte einfach gut zum Design des Roboterarms.

Der Roboterhandschuh besteht aus folgenden Komponenten:

• Flexsensor –  Basierend auf der Beugung des Fingers ändert sich der Strom, mit dem wir ein Signal an den Motor senden könnten
• Beschleunigungsmesser (MPU6050 ) – Wir können den Motor steuern, indem wir menschliche Gesten von der X-, Y-, Z-Ebene abbilden
• LED – Die LED leuchtet, wenn eine menschliche Gestensteuerung an den Arduino gesendet wurde
• Bluetooth (HC-05)-Modul – Senden von Daten an den Empfänger des Roboterarms HC-05
• Arduino Nano – Der Mikrocontroller würde als das Gehirn des Roboterhandschuhs fungieren

Das folgende Diagramm eignet sich hervorragend zum Testen des Flexsensors und des Beschleunigungsmessers.

Wichtig: Der Roboterarm ist nur so genau wie die Roboterhandschuh-Steuerung. Es lohnt sich also, dies richtig zu machen.

Bluetooth konfigurieren (Master und Empfänger)

Der Arduino-Roboterarm kommuniziert über Bluetooth mit den HC-05-Modulen. Heben Sie unten die kritischen Informationen hervor.

Modul

Konfiguration

Roboterhandschuh HC-05   Master Roboterarm HC-05  Slave

Hinweis:

Baudrate ist auf 4800 eingestellt

Arduino-Programmierung

Sie können den folgenden Code unten herunterladen:

Hinweis: Alle anderen Testcodes und die neueste Version finden Sie auf dem Arduino Robotic Arm Git Repo

Programmierung des Roboterarms

Der Roboterarm-Code verwendet die HCPCA9685-Bibliothek (für den Servotreiber). Auf diese Weise können wir mehrere Servomotoren mit Strom versorgen, die alle von einem Arduino gesteuert werden. Im Code können wir damit beginnen, diese Bibliothek hinzuzufügen und die Servovariablen zu deklarieren.

Die folgenden Variablen werden verwendet, um das vorherige/Inkrement zu finden und die aktuelle Position des Servos zu erhalten.

* Die HCPCA9685-Bibliothek einschließen */
#include "HCPCA9685.h"
/* I2C-Slave-Adresse für das Gerät/Modul. Für das HCMODU0097 ist die Standard-I2C-Adresse
0x40 */
#define I2CAdd 0x40
/* Erstellen Sie eine Instanz der Bibliothek */
HCPCA9685 HCPCA9685(I2CAdd);
//anfängliche Parkposition des Motors
const int servo_joint_L_parking_pos =60;
//Grad der Roboter-Servoempfindlichkeit - Intervalle
int servo_joint_L_pos_increment =20;
//Behalten Sie den Überblick über der aktuelle Wert der Motorpositionen
int servo_joint_L_parking_pos_i =servo_joint_L_parking_pos;
//Minimaler und maximaler Winkel des Servomotors
int servo_joint_L_min_pos =10;
int servo_joint_L_max_pos =180; 

Initialisieren Sie den seriellen Port mit der Baudrate 4800, um die Bluetooth-Kommunikation zu starten

Serial.begin(4800); // Standard-Kommunikationsrate des Bluetooth-Moduls initialisieren 

Im Abschnitt loop() überprüfen wir ständig, ob Daten vom Roboterhandschuh stammen. Wenn wahr, speichern wir die eingehenden Daten in der Variable „state“. Und abhängig von dem angegebenen Zeichen verwenden wir dies, um den/die Motor(e) zu bewegen.

Der folgende Abschnitt beschreibt den Code:

Der Roboterarm-Code kann als eine Reihe von Servomotoren angesehen werden, die zusammenarbeiten, um menschliche Bewegungen zu simulieren. Der Code ist der gleiche, wobei Servos von einem Servotreiber basierend auf Bluetooth-Werten angetrieben werden.

//Definieren des Servotreibers. 0x40-Adresse ist die Standard-I2C-Adresse.
#define I2CAdd 0x40
int response_time =5; //Empfangen von Werten aus dem Robotic Glove-Intervall
// Prüft, ob Daten von der seriellen Schnittstelle kommen

if (Serial.available()> 0) {
state =Serial .lesen(); // Liest die Daten vom seriellen Port
Serial.print(state); // Gibt den gesendeten Wert aus
//Motorfunktionscodeblock
} 

Basierend auf dem aktuellen "Zustandswert" würde der Servotreiber ein Signal an den entsprechenden Motor senden.

Zum Beispiel, wenn wir unsere Finger beugen. Der Wert „f“ würde vom Roboterhandschuh (über Bluetooth) gesendet, wobei der Roboterarm diese Daten ausliest und eine Funktion zum Drehen des jeweiligen Servomotors auslöst. Dieser Vorgang wird in einer Endlosschleife wiederholt.

if (Serial.available()> 0) { // Prüft, ob Daten vom seriellen Port kommen
state =Serial.read(); // Liest die Daten vom seriellen Port
Serial.print(state); // Gibt den gesendeten Wert aus
//Zur Benennung der Motoren siehe Artikel / Tutorial
//Move (Base Rotation) Stepper Motor Left
if (state ==' S') {
baseRotateLeft();
delay(response_time);
}
} 

Hinweis: Der Code implementiert einen harten Stopp, um zu verhindern, dass der Motor seinen maximalen Winkel überschreitet, wodurch die Motorzahnräder abgestreift werden können.

HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Servomotor auf Kanal 0 in den gewünschten Winkel fahren.
//Klauenmotor nach unten bewegen
if (state =='f') {
if (servo_joint_3_parking_pos_i HCPCA9685.Servo(4, servo_joint_3_parking_pos_i);
delay(response_time);
Serial.println(servo_joint_3_parking_pos_i);
servo_joint_3_parking_pos_i =
servo_joint_3_cre>servo_joint_3_parking_pos_i =
servo_joint_3_ment /servo_joint_3_ment}>}
void baseRotateLeft() {
digitalWrite(stepPin, LOW); //Spin in eine Richtung basierend auf HIGH, LOW
delayMicroseconds(stepDelay); //Ändere die Geschwindigkeit des Schrittmotors
} 

Wenn der Wert des Servomotors kleiner als die maximale Umdrehung ist, drehen Sie weiter. Wenn die maximale Drehung von 180 Grad erreicht ist, stoppen Sie.

servo_joint_3_parking_pos_i  

Wobei servo_joint_3_max_pos die maximale Position des Motors ist.

Hinweis: Der Code implementiert einen harten Stopp, um zu verhindern, dass der Motor seinen maximalen Winkel überschreitet, was die Motorzahnräder beschädigen kann.

Programmierung des Flex-Sensors

Den Roboterarm-Code finden Sie auf GitHub. Wenn Sie an dem Projekt arbeiten, tragen Sie Ihre eigene Version zu Git Repo bei. Dies würde helfen, einen Index der verschiedenen Versionen und Funktionen des Roboterarms zu erstellen.

Der Code wurde bereits dokumentiert (auch auf Git verfügbar). Wir werden jedoch die wichtigsten Punkte behandeln:

Wir definieren die fünf Sensoren:

//LED ON PIN 3
int pinkie_Data =A1;
int finger_Data =A2;
int thumb_Data =A3;
//const int MPU_addr =0x68;
const int MPU2 =0x69, MPU1 =0x68; 

Hinweis: 0x68 und 0x69 repräsentieren die I2C-Adresse der 2 MPU6050-Beschleunigungsmesser

//Wie oft Werte an den Roboterarm gesendet werden
int response_time =1000; 

Der folgende Code skizziert das Arduino, das die Werte der Sensoren liest:

// die Werte von Flex-Sensoren zu Arduino lesen
pinkie =analogRead(pinkie_Data);
finger =analogRead(finger_Data);
thumb =analogRead(thumb_Data); 

Lesen Sie die aktuelle Position des Beschleunigungsmessers:

GetMpuValue1(MPU1);
GetMpuValue2(MPU2); 

Kalibrieren der Werte:

Der folgende Code kalibriert, um die obere und untere Grenze des Flex-Sensors zu finden. Um den Flex-Handschuh neu zu kalibrieren, drücken Sie die Reset-Taste auf dem Arduino.

if (bool_caliberate ==false ) {
delay(1000);
thumb_high =(thumb * 1,15);
thumb_low =(thumb * 0,9);
finger_high =(finger * 1.03);
finger_low =(finger * 0.8);
pinkie_high =(pinkie * 1.06);
pinkie_low =(pinkie * 0.8);
bool_caliberate =wahr;
} 

Wir prüfen ständig, ob der aktuelle Wert basierend auf der Kalibrierung die definierte Ober- oder Untergrenze des Flex überschritten hat. Wenn der Flexsensor diesen Wert überschreitet oder unterschreitet, werden Daten an den Roboterarm gesendet, um einen bestimmten Servomotor in eine bestimmte Richtung zu bewegen.

// finger 1 - Claw Bend/Open
if (finger>=finger_high) {
Serial.print("F");
delay(response_time);
}
if (finger <=finger_low) {
Serial.print("f");
delay(response_time);
} 

Programmierung des Roboterarms

Ergebnisse – Auszahlung

Der Roboterarm ist genau genug, um Objekte zu bewegen. Es erfordert jedoch einige Arbeit, komplexe Objekte zu bewegen oder sogar mit den über Millionen Jahren zu konkurrieren, die Menschen in Bezug auf Geschicklichkeit haben … Obwohl er mehr Zeit mit der Arbeit am Code verbringt, kann die Präzision des Roboters so sein, wie es für MARK 1i . vorgesehen ist . Obwohl der Arm verbessert werden kann, kann er erheblich verbessert werden.

Wenn Sie den Code verbessern möchten, tragen Sie dazu bei Arduino Robot Arm Git Repo und baue deinen Arm. Lasst uns dies für andere öffnen, auf dem sie aufbauen können!

Zuletzt sind wir auch in der Lage, den Roboter durch Handgesten zu steuern und den Roboter so zu programmieren, dass er grundlegende Aufgaben automatisiert.

Nächste Schritte

Und das ist alles für MARK 1-Leute! Wenn Sie dieses Projekt mögen, sollten Sie meine Patreon-Seite unterstützen.