Einfacher und intelligenter Roboterarm mit Arduino !!! - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

In diesem anweisbaren werde ich einen einfachen Roboterarm machen. Das wird über einen Masterarm gesteuert. Der Arm wird sich an Bewegungen erinnern und nacheinander spielen. Das Konzept ist nicht neu Ich habe die Idee von "Mini-Roboterarm - von Stoerpeak" Ich wollte das schon lange machen, aber damals war ich totaler Neuling und hatte keine Ahnung von Programmierung. Jetzt endlich baue ich eins, halte es einfach, billig und teile es mit euch allen.

Also lasst uns anfangen….

Schritt 1: Dinge, die Sie brauchen:-

Hier ist eine Liste der Dinge, die Sie benötigen: -

1. Servomotoren x 5 Link für USA:- https://amzn.to/2OxbSH7Link für Europa:-

2. Potentiometer x 5 (ich habe 100k verwendet.)Link für USA:- https://amzn.to/2ROjhDMLink für Europa:-

3. Arduino-UNO. (Sie können auch Arduino Nano verwenden)Link für USA:- https://amzn.to/2DBbENWLink für Europa:-

4. Steckbrett. (Ich schlage dieses Kit vor)Link für USA:- https://amzn.to/2Dy86w4Link für Europa:-

5. Batterie. (optional, ich verwende einen 5V-Adapter)

6. Karton/Holz/Sonnenbrett/Acryl, was immer verfügbar oder leicht zu finden ist.

Und Sie müssen auch die Arduino IDE installiert haben.

Schritt 2: Herstellung des Arms:-

Hier habe ich Popsicle-Sticks verwendet, um den Arm zu machen. Sie können jedes Material verwenden, das Ihnen zur Verfügung steht. Und Sie können verschiedene mechanische Designs ausprobieren, um einen noch besseren Arm herzustellen. Mein Design ist nicht sehr stabil.

Ich habe nur doppelseitiges Klebeband verwendet, um die Servos auf den Popsicle-Stick zu kleben und sie mit Schrauben zu befestigen.

Für den Master-Arm klebte ich Potentiometer an Popsicle-Sticks und machte Arm.

Wenn Sie sich auf die Bilder beziehen, erhalten Sie eine bessere Idee.

Ich habe alles auf einem A4-Leinwandbrett als Basis montiert.

Schritt 3: Verbindungen herstellen:-

In diesem Schritt werden wir alle notwendigen Verbindungen herstellen. Siehe die Bilder oben.

• Schließen Sie zuerst alle Servos parallel an die Stromversorgung an (Das rote Kabel an +ve und das schwarze oder braune Kabel an Gnd)
• Als nächstes verbinden Sie die Signaldrähte, dh das gelbe oder orangefarbene Kabel mit dem PWM-Pin von Arduino.
• Verbinden Sie nun die Potentiometer parallel mit +5V und Gnd von Arduino.
• Verbinden Sie das mittlere Terminal mit dem analogen Pin von ardunio.

Hier werden die Digital Pins 3, 5, 6, 9 & 10 zur Ansteuerung der Servos verwendet

Die analogen Pins A0 bis A4 werden für die Eingabe von Potentiometern verwendet.

Das an Pin 3 angeschlossene Servo wird durch ein an A0. angeschlossenes Potentiometer gesteuert

Der an Pin 5 angeschlossene Servo wird von Pot auf A1 gesteuert und so weiter….

Hinweis: - Auch wenn Servos nicht von Arduino angetrieben werden, stellen Sie sicher, dass Sie die Masse der Servos mit Arduino verbinden, sonst funktioniert der Arm nicht.

Schritt 4: Codierung:-

Die Logik dieses Codes ist ziemlich einfach. Die Werte der Potentiometer werden in einem Array gespeichert, die Datensätze werden dann mit einer for-Schleife durchlaufen und die Servos führen die Schritte gemäß den Werten aus. Sie können sich dieses Tutorial ansehen, das ich als Referenz "Arduino Potentiometer Servo Control & Memory" verwendet habe.

Code:- (Herunterladbare Datei unten angehängt.)

Zuerst werden wir alle notwendigen Variablen global deklarieren, damit wir sie im gesamten Programm verwenden können. Dafür bedarf es keiner besonderen Erklärung

#enthalten

// Servoobjekte Servo Servo_0; Servo-Servo_1; Servo-Servo_2; Servo-Servo_3; Servo-Servo_4; // Potentiometerobjekte int Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; //Variable zum Speichern der Servoposition int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; //Variable zum Speichern der vorherigen Positionswerte int Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int Prev_3_Pos; int Prev_4_Pos; //Variable zum Speichern der aktuellen Positionswerte int Current_0_Pos; int Aktuell_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Position; // Speichert den Winkel int Servo_Number; // Speichert keine Servo int Storage [600]; //Array zum Speichern von Daten (Erhöhung der Array-Größe verbraucht mehr Speicher) Int Index = 0; // Array-Index beginnt ab Position 0 char data = 0; // Variable zum Speichern von Daten von der seriellen Eingabe.

Jetzt schreiben wir eine Setup-Funktion, in der wir Pins und deren Funktionen setzen. Dies ist die Hauptfunktion, die zuerst ausgeführt wird

Void-Setup ()

{ Serial.begin (9600); // Für die serielle Kommunikation zwischen Arduino und IDE. // Servoobjekte werden an PWM-Pins angeschlossen. Servo_0.attach(3); Servo_1.attach(5); Servo_2.attach(6); Servo_3.attach(9); Servo_4.attach(10); //Servos werden bei der Initialisierung auf 100 Position gesetzt. Servo_0.write (100); Servo_1.write (100); Servo_2.write (100); Servo_3.write (100); Servo_4.write (100); Serial.println ("Drücken Sie 'R' zum Aufnehmen und 'P' zum Abspielen"); }

Jetzt müssen wir die Werte von Potentiometern mit den analogen Eingangspins auslesen und sie auf die Steuerung von Servos abbilden. Dazu definieren wir eine Funktion und nennen sie Map_Pot();, Sie können es beliebig benennen, es ist eine benutzerdefinierte Funktion

void Map_Pot()

{/* Die Servos drehen sich um 180 Grad, aber es ist keine gute Idee, sie bis zur Grenze zu verwenden, da dies die Servos ständig brummen lässt, was ärgerlich ist, also begrenzen wir die Servobewegung zwischen: 1-179 */ Pot_0 = analogRead (A0); // Eingabe von Pot lesen und in Variable Pot_0 speichern. Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179); // Servos gemäß dem Wert zwischen 0 bis 1023 zuordnen Servo_0.write (Servo_0_Pos); // Bewegen Sie das Servo in diese Position. Pot_1 = analogRead(A1); Servo_1_Pos = map(Pot_1, 0, 1023, 1, 179); Servo_1.write (Servo_1_Pos); Pot_2 = analogRead(A2); Servo_2_Pos = map(Pot_2, 0, 1023, 1, 179); Servo_2.write (Servo_2_Pos); Pot_3 = analogRead(A3); Servo_3_Pos = map(Pot_3, 0, 1023, 1, 179); Servo_3.write (Servo_3_Pos); Pot_4 = analogRead(A4); Servo_4_Pos = map(Pot_4, 0, 1023, 1, 179); Servo_4.write (Servo_4_Pos); }

Jetzt schreiben wir eine Schleifenfunktion:

Leere Schleife ()

{ Map_Pot(); // Funktionsaufruf zum Lesen von Pot-Werten while (Serial.available () > 0) { data = Serial.read (); if (data == 'R') Serial.println("Aufzeichnungsbewegungen…"); if (data == 'P') Serial.println("Aufgezeichnete Züge abspielen…"); } if (data == 'R') //Wenn 'R' eingegeben wird, starten Sie die Aufnahme. { //Speichere die Werte in einer Variablen Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos; Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Servo_3_Pos; Prev_4_Pos = Servo_4_Pos; Map_Pot(); // Map-Funktion zum Vergleich aufgerufen if (abs(Prev_0_Pos == Servo_0_Pos)) // Absolutwert wird durch Vergleichen erhalten { Servo_0.write (Servo_0_Pos); // Wenn die Werte übereinstimmen, wird das Servo neu positioniert if (Current_0_Pos != Servo_0_Pos) // Wenn die Werte nicht übereinstimmen { Storage[Index] = Servo_0_Pos + 0; // Wert wird zum Array hinzugefügt Index++; // Indexwert um 1 erhöht } Current_0_Pos = Servo_0_Pos; } /* Analog erfolgt der Wertevergleich für alle Servos, jeweils +100 wird für die Eingabe als Differenzwert addiert. */ if (abs (Prev_1_Pos == Servo_1_Pos)) { Servo_1.write (Servo_1_Pos); if (Current_1_Pos != Servo_1_Pos) { Storage[Index] = Servo_1_Pos + 100; Index++; } Strom_1_Pos = Servo_1_Pos; } if (abs (Prev_2_Pos == Servo_2_Pos)) { Servo_2.write (Servo_2_Pos); if (Current_2_Pos != Servo_2_Pos) { Storage[Index] = Servo_2_Pos + 200; Index++; } Strom_2_Pos = Servo_2_Pos; } if (abs (Prev_3_Pos == Servo_3_Pos)) { Servo_3.write (Servo_3_Pos); if (Current_3_Pos != Servo_3_Pos) { Storage[Index] = Servo_3_Pos + 300; Index++; } Current_3_Pos = Servo_3_Pos; } if (abs (Prev_4_Pos == Servo_4_Pos)) { Servo_4.write (Servo_4_Pos); if (Current_4_Pos != Servo_4_Pos) { Storage[Index] = Servo_4_Pos + 400; Index++; } Current_4_Pos = Servo_4_Pos; } /* Werte werden auf seriellem Monitor gedruckt, '\t' dient zur Anzeige von Werten im Tabellenformat */ Serial.print(Servo_0_Pos); Serial.print (" / t "); Serial.print (Servo_1_Pos); Serial.print (" / t "); Serial.print (Servo_2_Pos); Serial.print (" / t "); Serial.print (Servo_3_Pos); Serial.print (" / t "); Serial.println (Servo_4_Pos); Serial.print ("Index = "); Serial.println (Index); Verzögerung (50); } if (data == 'P') // WENN 'P' eingegeben wird, Starten Sie die Wiedergabe aufgezeichneter Züge. { for (int i = 0; i < Index; i++) // Durchlaufe das Array mit der for-Schleife { Servo_Number = Storage / 100; // Findet die Anzahl der Servos Servo_Position = Storage % 100; // Findet die Position des Servoschalters (Servo_Number) {Fall 0: Servo_0.write (Servo_Position); brechen; Fall 1: Servo_1.write (Servo_Position); brechen; Fall 2: Servo_2.write (Servo_Position); brechen; Fall 3: Servo_3.write (Servo_Position); brechen; Fall 4: Servo_4.write (Servo_Position); brechen; } Verzögerung (50); } } }

Sobald der Code fertig ist, laden Sie ihn nun auf das Arduino-Board hoch

Der Smart Arm ist einsatzbereit. Die Funktion ist noch nicht so flüssig wie die von Stoerpeak.

Wenn Sie den Code verbessern können oder Vorschläge für mich haben, lassen Sie es mich bitte im Kommentarbereich wissen.

Nachdem dies gesagt wurde, gehen wir zum Testen über….

Schritt 5: Testen:-

Nachdem Sie den Code erfolgreich auf das Board hochgeladen haben, öffnen Sie 'Serial Monitor', den Sie in der Option Tools finden. Wenn der serielle Monitor startet, wird das Arduino zurückgesetzt. Jetzt können Sie den Roboterarm mit dem Masterarm steuern. Aber es wird nichts aufgezeichnet.

Um die Aufnahme zu starten, geben Sie 'R' in den Monitor ein, jetzt können Sie die Bewegungen ausführen, die Sie aufnehmen möchten.

Nachdem die Züge fertig sind, müssen Sie 'P' eingeben, um die aufgezeichneten Züge abzuspielen. Die Servos führen die Bewegungen weiter aus, solange das Board nicht zurückgesetzt wird.