Wie man mit wenig Geld einen Roboterarm baut

Sicherlich haben viele von Ihnen in Science-Fiction-Filmen gesehen, wie der Wissenschaftler oder Geek einen Roboterarm hat, der alles kontrolliert und Objekte aufheben oder Funktionen ausführen kann, als wäre er ein Mensch. Etwas, das dank zunehmend möglich ist Hardware Libre und das Arduino-Projekt. Aber was ist ein Roboterarm? Welche Funktionen hat dieses Gadget? Wie ist ein Roboterarm aufgebaut? Im Folgenden werden wir alle diese Fragen beantworten.

Was ist ein Roboterarm?

Ein Roboterarm ist ein mechanischer Arm mit einer elektronischen Basis, mit der er vollständig programmierbar ist. Darüber hinaus kann dieser Armtyp ein einzelnes Element sein, er kann jedoch auch Teil eines Roboters oder eines anderen Robotersystems sein. Die Qualität eines Roboterarms im Vergleich zu anderen Arten von mechanischen Elementen ist die folgende Ein Roboterarm ist vollständig programmierbar, der Rest des Geräts jedoch nicht. Diese Funktion ermöglicht es uns, einen einzigen Roboterarm für verschiedene Operationen zu haben und verschiedene und unterschiedliche Aktivitäten auszuführen, Aktivitäten, die dank elektronischer Karten wie Arduino-Karten ausgeführt werden können.

Funktionen eines Roboterarms

Möglicherweise ist die grundlegendste Funktion eines Roboterarms die Hilfsarmfunktion. Bei einigen Operationen benötigen wir einen dritten Arm, der ein Element unterstützt, damit eine Person etwas bauen oder erschaffen kann. Für diese Funktion ist keine spezielle Programmierung erforderlich und wir müssen nur das Gerät selbst ausschalten.

Roboterarme können aus verschiedenen Materialien hergestellt werden, wodurch sie als Ersatz für gefährliche Operationen verwendet werden können. wie die Manipulation umweltschädlicher chemischer Elemente. Ein Roboterarm kann uns auch bei schweren Aufgaben helfen oder solchen, die einen angemessenen Druck erfordern, solange er aus einem starken und widerstandsfähigen Material besteht.

Für den Bau benötigte Materialien

Als nächstes werden wir Ihnen beibringen, wie Sie einen Roboterarm schnell, einfach und wirtschaftlich für alle bauen können. Dieser Roboterarm ist jedoch nicht so leistungsstark oder nützlich wie die Arme, die wir in den Filmen sehen, sondern dient dazu, mehr über seine Funktionsweise und Konstruktion zu erfahren. So dass, Die Materialien, die wir benötigen, um dieses Gerät zu bauen, sind:

1. Ein Teller  Arduino UNO REV3 oder höher.
2. Zwei Entwicklungsboards.
3. Zweiachsenservos parallel
4. Zwei Mikroservos
5. Zwei analoge Steuerungen parallel
6. Überbrückungskabel für Entwicklungsplatinen.
7. Band
8. Karton oder Schaumstoff für den Ständer.
9. Ein Cutter und eine Schere.
10. Viel Geduld.

Versammlung

Die Montage dieses Roboterarms ist recht einfach. Zuerst müssen wir zwei Rechtecke mit dem Schaumstoff ausschneiden; Jedes dieser Rechtecke ist Teil des Roboterarms. Wie Sie in den Bildern sehen können, müssen diese Rechtecke die gewünschte Größe haben, obwohl dies empfohlen wird Die Größe eines von ihnen beträgt 16,50 x 3,80 cm. und das zweite Rechteck hat die folgende Größe 11,40 x 3,80 cm.

Sobald wir die Rechtecke haben, werden wir an einem Ende jedes Rechtecks ​​oder Streifens jeden Servomotor abkleben. Danach Wir werden ein "U" aus Schaumstoff schneiden. Dies wird als Halte- oder Endteil des Arms dienen, der für einen Menschen die Hand wäre. Wir werden dieses Stück mit dem Servomotor verbinden, der sich im kleinsten Rechteck befindet.

Jetzt müssen wir den unteren Teil oder die Basis machen. Dazu führen wir das gleiche Verfahren durch: Wir schneiden ein Schaumquadrat aus und platzieren die zweiachsigen Servomotoren parallel wie in der folgenden Abbildung:

Jetzt müssen wir alle Motoren an die Arduino-Platine anschließen. Aber zuerst müssen wir die Verbindungen mit der Entwicklungsplatine und diese mit der Arduino-Platine verbinden. Wir verbinden das schwarze Kabel mit dem GND-Pin, das rote Kabel mit dem 5-V-Pin und die gelben Kabel mit -11, -10, 4 und -3. Wir werden auch die Joysticks oder Bedienelemente des Roboterarms mit dem Arduino-Board verbinden, in diesem Fall wie auf dem Bild angegeben:

Sobald wir alles angeschlossen und zusammengebaut haben, müssen wir das Programm an die Arduino-Karte übergeben, für die wir die Arduino-Karte an den Computer oder Laptop anschließen müssen. Sobald wir das Programm an das Arduino-Board übergeben haben, müssen wir dies sicherstellen Verbinden Sie die Kabel mit der Arduino-Platine, obwohl wir immer mit der Entwicklungsplatine fortfahren und alles zerlegen könnenLetzteres, wenn wir nur wollen, dass es lernt.

Für den Betrieb erforderliche Software

Obwohl es so aussieht, als hätten wir den Bau eines Roboterarms abgeschlossen, ist die Wahrheit, dass noch viel vor uns liegt und das Wichtigste ist. Erstellen oder Entwickeln eines Programms, das unserem Roboterarm Leben einhaucht, da die Servomotoren ohne dieses Programm nicht aufhören würden, einfache Uhrwerke zu sein, die sich ohne Bedeutung drehen.

Dies wird gelöst, indem das Arduino-Board an unseren Computer angeschlossen wird und wir das Programm öffnen Arduino IDEWir verbinden den Computer mit der Karte und schreiben den folgenden Code in eine leere Datei:

#include <Servo.h>

const int servo1 = 3;       // first servo

const int servo2 = 10;      // second servo

const int servo3 = 5;       // third servo

const int servo4 = 11;      // fourth servo

const int servo5 = 9;       // fifth servo

const int joyH = 2;        // L/R Parallax Thumbstick

const int joyV = 3;        // U/D Parallax Thumbstick

const int joyX = 4;        // L/R Parallax Thumbstick

const int joyP = 5;        // U/D Parallax Thumbstick

const int potpin = 0;      // O/C potentiometer

int servoVal;           // variable to read the value from the analog pin

Servo myservo1;  // create servo object to control a servo

Servo myservo2;  // create servo object to control a servo

Servo myservo3;  // create servo object to control a servo

Servo myservo4;  // create servo object to control a servo

Servo myservo5;  // create servo object to control a servo

void setup() {

// Servo

myservo1.attach(servo1);  // attaches the servo

myservo2.attach(servo2);  // attaches the servo

myservo3.attach(servo3);  // attaches the servo

myservo4.attach(servo4);  // attaches the servo

myservo5.attach(servo5);  // attaches the servo

// Inizialize Serial

Serial.begin(9600);

}

void loop(){

servoVal = analogRead(potpin);

servoVal = map(servoVal, 0, 1023, 0, 179);

myservo5.write(servoVal);

delay(15);

// Display Joystick values using the serial monitor

outputJoystick();

// Read the horizontal joystick value  (value between 0 and 1023)

servoVal = analogRead(joyH);

servoVal = map(servoVal, 0, 1023, 0, 180);     // scale it to use it with the servo (result  between 0 and 180)

myservo2.write(servoVal);                         // sets the servo position according to the scaled value

// Read the horizontal joystick value  (value between 0 and 1023)

servoVal = analogRead(joyV);

servoVal = map(servoVal, 0, 1023, 70, 180);     // scale it to use it with the servo (result between 70 and 180)

myservo1.write(servoVal);                           // sets the servo position according to the scaled value

delay(15);                                       // waits for the servo to get there

// Read the horizontal joystick value  (value between 0 and 1023)

servoVal = analogRead(joyP);

servoVal = map(servoVal, 0, 1023, 70, 180);     // scale it to use it with the servo (result between 70 and 180)

myservo4.write(servoVal);                           // sets the servo position according to the scaled value

delay(15);                                       // waits for the servo to get there

// Read the horizontal joystick value  (value between 0 and 1023)

servoVal = analogRead(joyX);

servoVal = map(servoVal, 0, 1023, 70, 180);     // scale it to use it with the servo (result between 70 and 180)

myservo3.write(servoVal);                           // sets the servo position according to the scaled value

delay(15);                                       // waits for the servo to get there

/**

* Display joystick values

*/

void outputJoystick(){

Serial.print(analogRead(joyH));

Serial.print ("---");

Serial.print(analogRead(joyV));

Serial.println ("----------------");

Serial.print(analogRead(joyP));

Serial.println ("----------------");

Serial.print(analogRead(joyX));

Serial.println ("----------------");

}

Wir speichern es und senden es anschließend auf den Teller Arduino UNO. Bevor wir mit dem Code fertig sind, werden wir die entsprechenden Tests durchführen, um zu überprüfen, ob die Joysticks funktionieren und dass der Code keine Fehler enthält.

Ich habe es schon montiert, was nun?

Sicherlich haben viele von Ihnen diese Art von Roboterarm nicht erwartet, aber er ist ideal, da er die Grundlagen dessen, was er kostet und die Art und Weise lehrt, wie man einen Roboter baut. Von hier aus gehört alles zu unserer Vorstellungskraft. Das heißt, wir können die Materialien, die Servomotoren ändern und sogar den Programmcode vervollständigen. Das versteht sich natürlich auch von selbst Wir können das Arduino-Board-Modell gegen ein leistungsfähigeres und vollständigeres austauschen, mit dem wir eine Fernbedienung anschließen können oder mit dem Smartphone arbeiten. Kurz gesagt, eine breite Palette von Möglichkeiten, die die Hardware Libre und Roboterarme.

Mehr Informationen - Instructables