Einfacher und intelligenter Roboterarm mit Arduino

Über dieses Projekt

In diesem Tutorial werde ich einen einfachen Roboterarm herstellen, der mit einem Masterarm gesteuert wird. 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 baue ich endlich einen, halte ihn einfach, billig und teile ihn mit euch allen.

Fangen wir also an....

Schritt 1:Dinge, die Sie brauchen

Hier ist eine Liste der Dinge, die Sie brauchen:-

1. Servomotoren x 5 (Amazon Link)

2. Potentiometer x 5 (Amazon Link)

3. Arduino-UNO. (Amazon-Link)

4. Batterie. (Ich verwende einen 5V-Adapter)

5. Steckbrett. (Amazon-Link)

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 einfach doppelseitiges Klebeband verwendet, um die Servos auf den Popsicle-Stick zu kleben und sie mit Schrauben zu befestigen.

Für den Master-Arm habe ich Potentiometer auf Popsicle-Sticks geklebt und Arm gemacht.

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

Ich habe alles auf ein A4-Leinwandbrett als Unterlage montiert.

Schritt 3:Herstellen von Verbindungen

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)
• Verbinden Sie als nächstes die Signaldrähte, dh das gelbe oder orangefarbene Kabel mit dem PWM-Pin von Arduino.
• Schließen Sie nun die Potentiometer parallel an +5V und Gnd von Arduino an.
• Verbinden Sie das mittlere Terminal mit dem analogen Pin von ardunio.

Hier werden die digitalen Pins 3, 5, 6, 9 &10 zur Steuerung 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.

#include 
//Servo Objects
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.
 //Servo-Objekte 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 Analog Input Pins auslesen und sie auf Servos steuern. Dazu werden wir eine Funktion definieren und sie Map_Pot();, . nennen 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, es an Grenzen zu verwenden
, da es die Servos summen ständig
 was nervig ist, daher beschränken wir die Servobewegung
 zwischen:1-179 */
 Pot_0 =analogRead(A0); // Eingabe vom Pot lesen und in der Variablen 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:

void loop() 
{
 Map_Pot(); //Funktionsaufruf zum Lesen von Pot-Werten
 
 while (Serial.available()> 0) 
 {
 data =Serial.read();
 if (data =='R')
 Serial.println("Recording Moves...");
 if (data =='P')
 Serial.println("Playing Recording Moves.. .");
 }
 if (data =='R') //Wenn 'R' eingegeben wird, Aufnahme starten.
 {
 //Werte in a . speichern variabel
 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 (); // Map-Funktion zum Vergleich aufgerufen 
 
 if (abs(Prev_0_Pos ==Servo_0_Pos)) // Absolutwert wird durch Vergleich erhalten 
 {
 Servo_0.write(Servo_0_Pos); // Wenn Werte übereinstimmen, wird Servo neu positioniert 
 if (Current_0_Pos !=Servo_0_Pos) // Wenn 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 bei 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)
 {
 Speicher[Index] =Servo_1_Pos + 100; 
 Index++;
 }
 Aktuell_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)
 {
 Speicher[Index] =Servo_2_Pos + 200; 
 Index++;
 }
 Current_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)
 {
 Speicher[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)
 {
 Speicher[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') //IF 'P' wird eingegeben , Starte die Wiedergabe aufgezeichneter Züge.
 {
 for (int i =0; i  {
 Servo_Number =Storage[i] / 100; // Findet die Anzahl der Servos
 Servo_Position =Storage[i] % 100; // Findet die Position des Servos
 switch(Servo_Number) 
 { 
 case 0:
 Servo_0.write(Servo_Position);
 break;
 case 1:
 Servo_1.write(Servo_Position);
 Pause;
 Fall 2:
 Servo_2.write(Servo_Position);
 Pause; 
 Fall 3:
 Servo_3.write(Servo_Position);
 Pause;
 Fall 4:
 Servo_4.write(Servo_Position);
 Pause;
 }
 Verzögerung(50);
 }
 }
} 

• Sobald der Code fertig ist, laden Sie ihn jetzt auf das Arduino-Board hoch.

Der Smart Arm ist einsatzbereit. Die Funktion ist noch nicht so reibungslos 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.

Ich hoffe, dir gefällt das Projekt.

Danke...

Code

• Record-Play.ino
• Code-Snippet Nr. 1
• Code-Snippet 2
• Code-Snippet #3
• Code-Snippet Nr. 4

Record-Play.inoArduino

Code-Snippet Nr. 1Nur-Text

#include //Servo ObjectsServo Servo_0;Servo Servo_1;Servo Servo_2;Servo Servo_3;Servo Servo_4;//Potentiometer Objectsint Pot_0;int Pot_1;int Pot_2; int Pot_3;int Pot_4;//Variable zum Speichern der Servopositionint Servo_0_Pos;int Servo_1_Pos;int Servo_2_Pos;int Servo_3_Pos;int Servo_4_Pos;//Variable zum Speichern der vorherigen Positionswerteint Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos;int Prev_3_Pos; int Prev_4_Pos; // Variable zum Speichern der aktuellen Positionswerteint 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 Servoint Storage [600]; //Array zum Speichern von Daten (Erhöhung der Array-Größe verbraucht mehr Speicher)int Index =0; // Array-Index beginnt bei 0. positionchar data =0; //Variable zum Speichern von Daten vom seriellen Eingang.

Code-Snippet #2Klartext

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"); }

Code-Snippet #3Kurztext

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 Bewegung zwischen:1-179 * / Pot_0 =analogRead (A0); // Eingabe von Pot lesen und in der Variablen 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);}

Code-Snippet #4Nur-Text

void loop() { 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 Moves 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 Werte übereinstimmen, wird Servo neu positioniert if (Current_0_Pos !=Servo_0_Pos) // Wenn 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 zur 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++; } Current_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, Beginnen Sie mit der Wiedergabe aufgezeichneter Züge. { for (int i =0; i  

Schaltpläne