6-Achsen Roboterarm mit ATMega328 und Servomotoren

Dieser Beitrag wurde uns von unserem Gastautoren Miguel Torres Gordo zugesandt. Viel Spaß beim Lesen und Nachbauen:

Es hat mich schon immer fasziniert, die Bewegungen von Roboterarmen zu sehen, wenn sie alle möglichen Arbeiten ausführen. Ihre Bewegungen sind präzise und kontinuierlich, als wäre ich in einem Tanzkurs. Diese Industrieroboter verfügen über leistungsstarke Motoren und spezielle elektronische Schaltungen, um die Bewegungen nach programmierten Koordinaten zu steuern. Wäre es möglich, einen kleinen Roboterarm mit einfachen elektronischen Modulen und Komponenten zu bauen?

Das Hauptproblem ist das Gewicht der Struktur des Roboterarms und der Aktuatoren, die ihn bewegen sollen. Idealerweise sollte die Struktur aus Metall sein und die Aktuatoren müssten Schrittmotoren sein, aber dieses Set ist schwer und teuer. Die Frage ist: Könnte man es mit Servomotoren machen?

Wir müssen nach einem Material suchen, das nicht sehr schwer und kostengünstig ist. Für Intarsien (Einlegearbeiten) wird Balsaholz verwendet, das nicht schwer und trotzdem widerstandsfähig ist. So ist es möglich, dass die Servomotoren das Set bewegen, wobei dort bereits die Elektronik zur Steuerung integriert ist. Wir werden einen Roboterarm entwickeln, der Teile mit einem Greifer aufnimmt und sie an einem anderen Ort ablegt.

Die für dieses Projekt benötigten Materialien sind:

• 1x Mikrocontroller Board ATmega328
• 1x PCA9685 16 Kanal 12 Bit PWM Servotreiber
• 3x MG995 Micro Digital Servo Motor
• 2x MG90S Micro Servomotor
• 1x SG90 Micro Servo Motor 9G
• Jumper Wire Kabel
• Externe Spannungsversorgung (min. 5V)
• 3mm Sperrholzplatten
• Holzleim
• Holzdübel

Die erforderliche Software ist:

• Arduino IDE
• Robotarm scketch und Adjustment Sketches
• Wire Bibliothek (integriert)
• Adafruit_PWMServoDriver library (über Bibliotheksverwalter oder ZIP von Github)

Der erste Schritt besteht darin, die Struktur unseres Roboterarms aus 3 mm dickem Balsaholz zu entwerfen. Damit die verschiedenen Teile unseres Roboters das Gewicht des nächsten Teils aushalten können, müssen wir die Dicke dieser Teile erhöhen, indem wir mehrere gleiche Stücke verleimen (das Gewicht steigt nicht sehr stark an, wie Sie bemerken werden). Um die Bewegungen der Servomotoren zu unterstützen, müssen wir die Gewichte der Arme ein wenig ausgleichen, wobei wir das Gewicht des Arms am anderen Ende berücksichtigen.

Zeichnungen als ZIP-Download (im neuen Fenster rechts oben auf "Herunterladen" klicken)

Für den Betrieb unseres Roboterarms ist es sehr wichtig, die Pulsbreitendaten der Servomotoren zu kennen, um den minimalen und maximalen Winkel mit den Einstellsketches zu positionieren und den Roboterarm in die gewünschte Position zu bringen. Laut Datenblatt dreht sich der MG995-Servomotor um 120 Grad, während die MG90S- und SG90-Servomotoren um 180 Grad drehen. Um die erforderlichen Impulsbreitendaten zu ermitteln, verwenden wir die Sketches Servo_check_120_degrees_slow_motion.ino und Servo_check_180_degrees.ino und einen Winkelmesser, wie in der Zeichnung gezeigt.

Die beiden Sketches sind sich sehr ähnlich, deshalb werden wir die wichtigsten Zeilen einer der beiden Skizzen erläutern. Die folgenden Zeilen gehören zur Skizze der MG995-Servomotoren. Die ersten beiden Zeilen, die wir analysieren, sind die Mindest- und Höchstwerte der Impulsbreite für jeden Servomotor, die den Positionen 0 Grad und 180 Grad entsprechen.

 #define SERVOMIN  100         // This is the 'minimum' pulse length count (out of 4096)
 #define SERVOMAX  500         // This is the 'maximum' pulse length count (out of 4096)

In den folgenden Zeilen erstellen wir zwei Schleifen, in denen wir die rot markierten Daten ändern müssen, um den Servomotor zwischen 30 Grad und 150 Grad zu positionieren. In diesem Fall erhalten wir die 120 Grad, mit denen der MG995 arbeitet. Die Bewegung erfolgt langsam mit 10 "Schritten" alle 50 Millisekunden von 30 Grad bis 150 Grad. Wir müssen diese Prozeduren mit allen Servomotoren, die wir verwenden werden, durchführen und die entsprechenden Werte für jeden einzelnen aufschreiben, da dies die Werte sind, zwischen denen er arbeitet, um sich zu positionieren.

for (int pos=165; pos<430; pos +=10) {       // Loop with movement slow from 30
   degrees to 150 degrees 
   pwm.setPWM(0, 0, pos );
   Serial.println("165 pulse length count --> 30 degrees");
   delay(50);
}
delay (5000);
​
for (int pos_m=430; pos_m>165; pos_m -=10) {   // Loop with movement slow from 150
   degrees to 30 degrees
   pwm.setPWM(0, 0, pos_m );
   Serial.println("430 pulse length count --> 150 degrees");
   delay(50);
}
delay (5000);

Montage

Sobald wir die minimalen und maximalen Impulswerte für den minimalen und maximalen Arbeitswinkel jedes Servomotors haben, ist es an der Zeit, alles zusammenzubauen. Um den Zusammenbau ordnungsgemäß durchzuführen, können Sie wie folgt vorgehen:

1. Wir beginnen die Montage an dem Greifer, wobei dieser geschlossen und der Servomotor um 90 Grad gedreht ist.

2. Der nächste Servomotor ist Nummer 1, mit der Position bei 0 Grad und dem Greifer in der Position, die auf dem Foto zu sehen ist, da die Drehung um 180 Grad im Uhrzeigersinn erfolgt.

3. Der dritte Servomotor ist Nummer 2, der sich, wie der vorherige, in der 0-Grad-Position befindet und den Greifer senkrecht nach oben bewegt, da er sich ebenfalls im Uhrzeigersinn dreht, um sich in Richtung 180 Grad zu bewegen.

4. Jetzt ist der Servomotor Nummer 3 an der Reihe, die Position des Servomotors belassen wir in diesem Fall bei 90 Grad und den Arm montieren wir in einer Linie mit dem nächsten, da wir so 60 Grad Bewegung in jede Richtung haben.

5. Für den Servomotor Nummer 4 belassen wir die Position bei 90 Grad und den Arm montieren wir horizontal (parallel zum Boden), wodurch wir wie beim vorherigen Servomotor einen großen Aktionsradius mit 60 Grad in jede Richtung haben.

6. Den letzten Servomotor, Nummer 5, lassen wir wie den vorherigen auf 90 Grad stehen und montieren die Drehplattform so, dass sich der Rest des Arms in der Mitte der Seitenkante der Basis befindet.

Schaltung und Beschreibung der Funktionsweise

Wie Sie im Schaltplan sehen können, ist die Schaltung sehr einfach. Wir haben den Mikrocontroller, das PCA9685 Modul und die 6 Servomotoren.

Die elektrischen Anschlüsse der Servomotoren an die PCA9685-Baugruppe werden entsprechend der Nummerierung des Servomotors mit der Nummer des entsprechenden PWM-Ausgangsports auf der Baugruppe verbunden, d.h. Servomotor Nummer 0 mit Ausgangsport 0.

Die 5V-Gleichstromversorgung wird an den grünen Schraubverbinder des Treiberboards angeschlossen, wobei auf die Polarität zu achten ist, da die Servomotoren über diesen Anschluss versorgt werden.

Die Verbindungen zwischen dem Atmega328P-Mikrocontroller und dem PCA9685-Modul sind die I2C-Kommunikation über seinen Port und die 5V für die Spannungsversorgung der Modulelektronik.

Die sechs Servomotoren werden vom Atmega328P-Mikrocontroller über das PCA9685-Modul gesteuert, das zwei wichtige Funktionen hat. Die erste besteht darin, die Servomotoren mit 5V von einer externen Stromversorgung mit genügend Leistung zu versorgen, um die 6 Servomotoren gleichzeitig zu bewegen. Die zweite besteht darin, das PWM-Signal zum jeweiligen Servomotor zu schicken, das über das I2C-Signal vom Mikrocontroller übermittelt wurde. Wie im Diagramm oben zu sehen ist, benötigen wir nur 2 Pins für die Kommunikation zwischen dem Mikrocontroller und dem PCA9685-Modul, wobei die anderen Pins für andere Verwendungen übrigbleiben.

Der wirklich mühsame Teil dieses Projekts ist die Einstellung der Werte für jede Position des Arms und der Geschwindigkeiten der Bewegungen. Letzteres muss langsamer werden, wenn der Arm einen Gegenstand aufheben soll.

Für die Einstellung und Bewegung des Roboterarms in jeder Stufe wurde je ein Sketch pro Stufe erstellt. Damit lassen sich die Einstellungen einzeln vornehmen. Wenn wir alle Einstellungen richtig vorgenommen haben, werden wir sie alle in einem einzigen Sketch zusammenfassen. Dabei werden wir Methoden/Funktionen verwenden, so dass der Code sauberer und einfacher zu verfolgen ist. Analysieren Sie den Code für eine Stufe und Sie werden sehen, dass er sehr einfach ist. Für die übrigen Stufen ist die Anpassungsmethode ähnlich.

Der Code, den wir analysieren werden, sind die Einstellungen für den Roboterarm, um das erste Teil aufzunehmen. Der Sketch heißt pick_up_first_object.ino.

Die ersten beiden Zeilen des Codes sind die Bibliotheken, die wir benötigen, damit der Sketch korrekt läuft. Wire.h ist für die I2C-Kommunikation und Adafruit_PWMServoDriver ist für die Verwendung des PCA9685-Moduls zuständig.

#include <Wire.h>

#include <Adafruit_PWMServoDriver.h>

Die nächsten 4 Zeilen sind der Reihe nach die Implementierung eines Adafruit_PWMServoDriver-Objekts zur Steuerung der Servomotorpositionen, SERVOMIN und SERVOMAX sind die Werte der steigenden Flanke und der fallenden Flanke für die 0-Grad- bzw. 180-Grad-Position der Servomotoren. Die Geschwindigkeitsvariable wird für die Wartezeit bis zur Bewegung des nächsten Servomotors verwendet.

Adafruit_PWMServoDriver pca9685 = Adafruit_PWMServoDriver();

#define SERVOMIN  100             

#define SERVOMAX  500            

int velocidad = 450;

Die nächsten 4 Zeilen sind der Reihe nach die Implementierung eines Adafruit_PWMServoDriver-Objekts zur Steuerung der Servomotorpositionen, SERVOMIN und SERVOMAX sind die Werte der steigenden Flanke und der fallenden Flanke für die 0-Grad- bzw. 180-Grad-Position der Servomotoren. Die Geschwindigkeitsvariable wird für die Wartezeit bis zur Bewegung des nächsten Servomotors verwendet.In der setup() -Methode initialisieren wir den seriellen Monitor und geben eine Nachricht aus. In den nächsten beiden Zeilen initialisieren wir das PCA9685-Modul mit Hilfe seines zuvor implementierten Objekts und geben die Frequenz an, mit der die Servomotoren arbeiten, nämlich 50 Hz.

In der setup()-Methode initialisieren wir den seriellen Monitor und geben eine Nachricht aus. In den nächsten beiden Zeilen initialisieren wir das PCA9685-Modul mit Hilfe seines zuvor implementierten Objekts und geben die Frequenz an, mit der die Servomotoren arbeiten, nämlich 50 Hz.

void setup() {

   Serial.println("Ajusting to Pick up first object");

   pca9685.begin();

   pca9685.setPWMFreq(50);

}

Jetzt implementieren wir die loop()-Methode Hier beginnen wir mit den Einstellungen für jeden der Servomotoren, die für die Ausführung der Bewegung agieren müssen. Wir beginnen mit dem ersten Servomotor, den wir bewegen wollen. Servomotor 5 ist derjenige, der den Roboterarm dreht. Mit der Funktion pca9685.setPWM(5, 0, 350) geben wir dem PCA9685-Modul an, dass es den Motor 5 in die Position bewegen soll, die sich aus der Subtraktion des Wertes der steigenden Flanke (0) von der fallenden Flanke (350) ergibt, und mit der Funktion delay(velocidad ) warten wir 450 Millisekunden, um die nächste Funktion des folgenden Servomotors auszuführen.

void loop() {

       // Servomotor 5

       pca9685.setPWM(5, 0, 350);

       delay(velocidad);

Die nächsten beiden Funktionsaufrufe führen die Bewegungen der Servomotoren 4 und 2 aus. Die Ausführung ist ähnlich wie bei der vorhergehenden Funktion, zuerst den Servomotor 4 bewegen, 450 Millisekunden warten und nach dieser Zeit den Servomotor 2 an die Position der Differenz zwischen der steigenden und der fallenden Flanke bewegen.

       // Servomotor 4

       pca9685.setPWM(4, 0, 210);

       delay(velocidad);

       // Servomotor 2

       ca9685.setPWM(2, 0, 405);

       delay(velocidad);

Die folgenden zwei Funktionen führen die Bewegungen der Servomotoren 3 und 2 aus. Erklären wir, warum wir dafür Schleifen implementiert haben. Die Bewegung der vorherigen Servomotoren erfolgt mit der normalen Geschwindigkeit, die sehr abrupt ist. Um das Gefühl einer langsamen Geschwindigkeit zu vermitteln, haben wir eine Schleife implementiert, in der sich der Servomotor alle 10 Millisekunden um einen "Schritt" von der Startposition (150) der Variablen pos bis zu ihrer Endposition (180) des Servomotors 3 bewegt. Die tatsächliche Bewegung ist eine intermittierende Bewegung, aber da die Wartezeit zwischen den einzelnen Bewegungen nur 10 Millisekunden beträgt, vermittelt die Bewegung ein Gefühl der Kontinuität bei geringer Geschwindigkeit. Da die Bewegung dadurch glatt ist, hilft sie uns, eine gute Präzision zu erreichen.

       // Servomotor 3

       for (int pos=150; pos<180; pos +=1) {

           pca9685.setPWM(3, 0, pos);

           delay(10);

       }

       // Servomotor 2

       for (int pos=405; pos>350; pos -=1) {

             pca9685.setPWM(2, 0, pos);

             delay(10);

       }

Die Entwicklung der letzten beiden Funktionen, die die Servomotoren 1 und 0 (Greifer) bewegen, ist ähnlich wie oben beschrieben. Der Servomotor 1 bewegt sich mit normaler Geschwindigkeit und der Servomotor 0, der den Greifer darstellt, schließt ihn mit langsamer Geschwindigkeit, da er sich in einer Schleife befindet.

       // Servomotor 1

       pca9685.setPWM(1, 0, 300);

       delay(velocidad);

       // Servomotor 0

       for (int pos=200; pos>166; pos -=1) {

           pca9685.setPWM(0, 0, pos);

           delay(10);

       }

Die letzte Wartezeit in einigen der einzelnen Sketches beträgt 60 Sekunden, da es sich um Bewegungen innerhalb von Schleifen handelt, die kontinuierlich ausgeführt werden. Auf diese Weise können wir überprüfen, welche Koordinaten in welchen Positionen korrekt sind, und wir können die Werte der Variablen pos jedes Servomotors so anpassen, dass der Roboterarm an den gewünschten Koordinaten positioniert ist.

       delay(60000);

}

Um die Einstellung an jeder Stufe vorzunehmen, müssen wir den entsprechenden Sketch ausführen und die Werte der pos-Variablen der einzelnen Servomotoren variieren, bis der Roboterarm die gewünschte Position erreicht hat.

Der vorbereitete Sketch robot_arm.ino führt eine Bahn aus, die von einer Sicherheitsposition ausgeht, zwei Teile bewegt und zur Sicherheitsposition zurückkehrt. Ich habe versucht, die Programmierung dieser Skizze so weit wie möglich zu vereinfachen. Deshalb habe ich den Code für jeweiligen Stufen als separate Sketches hinterlegt und sie in der loop()-Methode des robot_arm.ino-Sketches mit den gleichen Namen als Funktionen programmiert. So wissen wir jederzeit, in welcher Position sich unser Roboterarm befindet.

Wenn die Servomotoren an das Modul PCA9685 angeschlossen sind und dieses mit Spannung versorgt wird, behalten die Servos die Position bei, in der sie sich befinden. Das habe ich ausgenutzt, um die Anzahl der Funktionen in einigen Stufen zu reduzieren. Wenn wir in der vorherigen Stufe einen Servomotor in einer Position haben und die nächste die gleiche ist, brauchen wir nicht zu wechseln, so dass wir die letztere eliminieren, da sie die Position beibehält, die sie vorher hatte.

Ich wünsche Ihnen viel Spaß mit diesem Projekt.

Miguel Torres Gordo