Handgestengesteuerter Roboterarm mit Arduino Nano

Schaltungsverbindung zwischen MPU6050 und Arduino Nano:

Schaltungsverbindung zwischen Servomotoren und Arduino Nano:

Ein Flex-Sensor enthält zwei Stifte. Es enthält keine polarisierten Anschlüsse. Der Pin 1 P1 ist also mit einem Pull-Up-Widerstand von 10k mit dem analogen Pin A0 des Arduino Nano verbunden, und der Pin 2 P2 ist mit Arduino geerdet.

Montage des MPU6050 & Flex-Sensors an Handschuhen

Wir haben die MPU6050 und den Flex-Sensor an einem Handschuh befestigt. Hier wird eine Kabelverbindung verwendet, um Handschuh und Roboterarm zu verbinden. Sie kann jedoch über eine HF-Verbindung oder eine Bluetooth-Verbindung drahtlos hergestellt werden.

Nach jeder Verbindung sieht das endgültige Setup für den gestengesteuerten Roboterarm wie folgt aus:

Programmierung von Arduino Nano für Robotic Arm

Wie üblich finden Sie am Ende dieses Tutorials vollständigen Code zusammen mit einem Arbeitsvideo. Hier werden einige wichtige Codezeilen erläutert.

1. Fügen Sie zunächst die erforderlichen Bibliotheksdateien hinzu. Die Wire.h- Bibliothek wird für die I2C-Kommunikation zwischen Arduino Nano & MPU6050 und servo.h zur Steuerung des Servomotors verwendet.

#einschließen #einschließen

2. Als nächstes werden die Objekte für das Klassenservo deklariert. Da wir vier Servomotoren verwenden, werden vier Objekte wie servo_1, servo_2, servo_3, servo_4 erstellt.

Servo servo_1; Servo servo_2; Servo servo_3; Servo servo_4;

3. Als nächstes wird die I2C-Adresse der MPU6050 und die zu verwendenden Variablen deklariert.

const int MPU_addr = 0x68; // MPU6050 I2C-Adresse int16_t axis_X, axis_Y, axis_Z; int minVal = 265; int maxVal = 402; Doppel-X; doppeltes y; Doppel z;

4. Als nächstes wird im Void-Setup eine Baudrate von 9600 für die serielle Kommunikation festgelegt.

Serial.begin (9600);

Die I2C-Kommunikation zwischen dem Arduino Nano und der MPU6050 wird hergestellt:

Wire.begin (); // I2C Communication Wire.beginTransmission (MPU_addr) initialisieren; // Starten Sie die Kommunikation mit MPU6050 Wire.write (0x6B); // Schreibt in Register 6B Wire.write (0); // Schreibt 0 in das 6B-Register, um Wire.endTransmission (true) zurückzusetzen; // Beendet die I2C-Übertragung

Außerdem sind vier PWM-Pins für Servomotorverbindungen definiert.

servo_1.attach (2); // Forward / Reverse_Motor servo_2.attach (3); // Up / Down_Motor servo_3.attach (4); // Gripper_Motor servo_4.attach (5); // Links / Rechts_Motor

5. Stellen Sie als Nächstes in der Void-Loop- Funktion erneut eine I2C-Verbindung zwischen der MPU6050 und Arduino Nano her und beginnen Sie dann, die X-, Y- und Z-Achsen-Daten aus dem Register der MPU6050 zu lesen und in entsprechenden Variablen zu speichern.

Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Beginne mit dem Regsiter 0x3B Wire.endTransmission (false); Wire.requestFrom (MPU_addr, 14, true); // 14 Register lesen axis_X = Wire.read () << 8-Wire.read (); axis_Y = Wire.read () << 8-Wire.read (); axis_Z = Wire.read () << 8-Wire.read ();

Ordnen Sie anschließend den Min- und Max-Wert der Achsdaten vom MPU6050-Sensor im Bereich von -90 bis 90 zu.

int xAng = map (axis_X, minVal, maxVal, -90,90); int yAng = map (axis_Y, minVal, maxVal, -90,90); int zAng = map (axis_Z, minVal, maxVal, -90,90);

Verwenden Sie dann die folgende Formel, um die x-, y- und z-Werte in Form von 0 bis 360 zu berechnen.

x = RAD_TO_DEG * (atan2 (-yAng, -zAng) + PI); y = RAD_TO_DEG * (atan2 (-xAng, -zAng) + PI); z = RAD_TO_DEG * (atan2 (-yAng, -xAng) + PI);

Lesen Sie dann die Analogausgangsdaten des Flexsensors am A0-Pin des Arduino Nano ab und stellen Sie den Servowinkel des Greifers gemäß dem digitalen Wert des Flexsensors ein. Wenn also die Daten des Flex-Sensors größer als 750 sind, beträgt der Servomotorwinkel des Greifers 0 Grad und wenn er kleiner als 750 ist, beträgt er 180 Grad.

int Greifer; int flex_sensorip = analogRead (A0); if (flex_sensorip> 750) { gripper = 0; } else { gripper = 180; } servo_3.write (Greifer);

Dann wird die Bewegung der MPU6050 auf der X-Achse von 0 bis 60 in 0 bis 90 Grad für die Vorwärts- / Rückwärtsbewegung des Servomotors des Roboterarms abgebildet.

if (x> = 0 && x <= 60) { int mov1 = map (x, 0,60,0,90); Serial.print ("Bewegung in F / R ="); Serial.print (mov1); Serial.println ((char) 176); servo_1.write (mov1); }}

Die Bewegung der MPU6050 auf der X-Achse von 250 bis 360 wird für den UP / DOWN-Bewegungsroboterarm des Servomotors in 0 bis 90 Grad abgebildet.

sonst wenn (x> = 300 && x <= 360) { int mov2 = map (x, 360, 250, 0, 90); Serial.print ("Bewegung in Auf / Ab ="); Serial.print (mov2); Serial.println ((char) 176); servo_2.write (mov2); }}

Die Bewegung der MPU6050 auf der Y-Achse von 0 bis 60 wird in 90 bis 180 Grad für die linke Bewegung des Servomotors des Roboterarms abgebildet.

if (y> = 0 && y <= 60) { int mov3 = map (y, 0,60,90,180); Serial.print ("Bewegung links ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }}

Die Bewegung der MPU6050 in der Y-Achse von 300 auf 360 wird in 0 bis 90 Grad für die rechte Bewegung des Servomotors des Roboterarms abgebildet.

sonst wenn (y> = 300 && y <= 360) { int mov3 = map (y, 360.300,90,0); Serial.print ("Bewegung nach rechts ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }}

Arbeiten des gestengesteuerten Roboterarms mit Arduino

Laden Sie zum Schluss den Code auf Arduino Nano hoch und tragen Sie den mit dem MPU6050 & Flex Sensor montierten Handschuh.

1. Bewegen Sie nun die Hand nach unten, um den Roboterarm nach vorne zu bewegen, und nach oben, um den Roboterarm nach oben zu bewegen.

2. Kippen Sie dann die Hand nach links oder rechts, um den Roboterarm nach links oder rechts zu drehen.

3. Biegen Sie das mit dem Finger des Handschuhs befestigte Flexkabel, um den Greifer zu öffnen, und lassen Sie ihn dann los, um ihn zu schließen.

Die vollständige Arbeitsweise wird im folgenden Video demonstriert.