MK2 Plus Roboterarmsteuerung

Notwendige Werkzeuge und Maschinen

3D-Drucker (generisch)

Apps und Onlinedienste

Arduino-IDE

Über dieses Projekt

Der EEZYBOT MK2 Arm

Wenn Sie auf thingiverse.com nach coolen Roboterarmen gesucht haben, sind Sie wahrscheinlich darauf gestoßen. Der EEZYBOT MK2-Arm (entworfen von dem brillanten Daghizmo) teilt die kinematische Verbindung des ABB IRB460, verkleinert mit einem Verhältnis von 1:7. Dieser Arm ist jedoch für Servos ausgelegt, was ihn etwas wackelig und weniger anmutig macht. Es gibt jedoch eine bessere Lösung da draußen. Der hier gefundene MK2 Plus-Arm, https://www.thingiverse.com/thing:2520572, ist eine neu gemischte Version des ursprünglichen MK2-Arms, der 3 Schrittmotoren verwendet, um seine Gestänge zu bewegen.

Das Drucken dauert eine Weile, also setzen Sie ein Lesezeichen für diesen Artikel, lassen Sie alles ausdrucken und kommen Sie zurück, wenn Sie fertig sind! (Es dauert ein paar Tage)

Wenn Sie Probleme beim Zusammenbauen des Arms haben, gibt es viele Tutorials online.

Auswählen einer Ausgangsposition

Im Gegensatz zu Servos haben Schrittmotoren kein Positionsbewusstsein. Wir müssen dies beheben, indem wir zuerst eine Referenzfahrtroutine einrichten, wenn der Arm eingeschaltet ist. Wir verwenden 3 Endschalter, um unsere Ausgangsposition einzustellen. Die Gestänge funktionieren etwas komplex, aber Sie werden leicht verstehen, wo Sie die Schalter positionieren müssen, sobald Sie den Arm zusammengebaut haben und sehen, wie sich alles bewegt.

(d.h. es gibt kein XY wie ein kartesisches System, aber wir nennen es trotzdem so, um die Dinge zu vereinfachen)

Sie können den Z-Endschalter überall auf der Hauptbasis des Arms einstellen. Fügen Sie einen kleinen Klecks Heißkleber hinzu, damit sich Ihre Drähte nicht lösen, wenn sich der Arm bewegt.

Verkabelung

Die Verdrahtung ist recht einfach, da alle Klemmen auf dem CNC-Schirm markiert sind. Schließen Sie Ihre A4988-Treiber nur nicht falsch an! Der Schrittmotor an der Seite mit dem Y-Endschalter muss in die Klemme für den Y-Schrittmotor in Ihrem CNC-Shield eingesteckt werden. Gleiches gilt für den Motor an der Seite des X-Endschalters. (Wir nennen diese X und Y, da es auf diese Weise einfacher ist, mit der CNC-Abschirmung umzugehen) Verbinden Sie den letzten Stepper, der die Basis des Arms dreht, mit dem Z-Anschluss und verdrahten Sie die Endanschläge entsprechend ihren Namen. Polarität spielt keine Rolle.

Finden Sie ein anständiges 12-V-Netzteil, das den Strom liefert, damit die Motoren ohne Abwürgen laufen.

Code

Kommen wir zur Sache. Wir werden die AccelStepper-Bibliothek für Arduino verwenden, um die Stepper reibungslos zu steuern. Mit dieser Bibliothek können Sie problemlos mehrere Schrittmotoren gleichzeitig beschleunigen, abbremsen und betreiben. Sie können diese Bibliothek direkt über die Arduino-IDE abrufen, indem Sie den Bibliotheksmanager verwenden (Skizze> Bibliothek einschließen> Bibliotheksmanager)

Sie können es auch von der ursprünglichen Creators-Seite auf Airspayce erhalten. https://www.airspayce.com/mikem/arduino/AccelStepper/

Da wir nun alles haben, was wir brauchen, gehen wir den Code Schritt für Schritt durch.

Zuerst definieren wir einige Namen für die Pins, die wir verwenden werden. Ein Pin-Diagramm des CNC-Schildes finden Sie mit einer schnellen Google-Bildersuche. Wir erstellen auch die AccelStepper-Objekte für unsere 3 Schrittmotoren.

#define XSTEP 2 //Schrittmotor-Schritt-Pin
#define YSTEP 3
#define ZSTEP 4
#define XDIR 5 // Schrittmotor-Richtungssteuerpin
#define YDIR 6
#define ZDIR 7
#define ENABLE 8 // CNC Shield Enable Pin
#define XLIMIT 9 // Endschalterpins
#define YLIMIT 10
#define ZLIMIT 11
#define XMOTORACC 250 // Beschleunigungs- und Höchstgeschwindigkeitswerte
#define XMOTORMAXSPEED 1000
#define YMOTORACC 250
#define YMOTORMAXSPEED 1000
# include 
AccelStepper XMOTOR(1,XSTEP,XDIR);
AccelStepper YMOTOR(1,YSTEP,YDIR);
AccelStepper ZMOTOR(1,ZSTEP,ZDIR); 

Lassen Sie uns eine kleine Hilfsfunktion erstellen, um unsere Pins einzurichten.

void pinsetup(){
 pinMode(ENABLE,OUTPUT);
 digitalWrite(ENABLE,LOW);
 pinMode(XLIMIT,INPUT_PULLUP);
 pinMode( YLIMIT,INPUT_PULLUP);
 pinMode(ZLIMIT,INPUT_PULLUP);
} 

Nun, da dies erledigt ist, gehen wir die Logik unserer Homing-Routine durch.

void autohome(){ //Wir verwenden dies, um unsere Homing-Routine aufzurufen 
 xyhome();
 zhome();
}
void xyhome () {
 int initial_xhome =-1;
 int initial_yhome =-1;
 // Setze die maximale Geschwindigkeit und Beschleunigung jedes Steppers beim Start für die Referenzfahrt
 XMOTOR.setMaxSpeed(500.0 ); // Maximale Geschwindigkeit des Steppers einstellen (langsamer, um eine bessere Genauigkeit zu erzielen)
 XMOTOR.setAcceleration(50.0); // Beschleunigung des Steppers einstellen
 YMOTOR.setMaxSpeed(500.0); // Stellen Sie die maximale Geschwindigkeit des Steppers ein (langsamer, um eine bessere Genauigkeit zu erzielen)
 YMOTOR.setAcceleration(50.0); // Beschleunigung des Schrittmotors einstellen
 // Referenzfahrt des Schrittmotors beim Start starten
 while (digitalRead(YLIMIT)) { // Schrittmotor gegen den Uhrzeigersinn bewegen lassen, bis der Schalter aktiviert ist
 XMOTOR. moveTo(initial_xhome); // Setze die Position zum Verschieben
 YMOTOR.moveTo(initial_yhome); // Setze die Position zum Verschieben
 initial_xhome--; // Bei Bedarf für den nächsten Zug um 1 verringern
 initial_yhome--;
 XMOTOR.run(); // Bewegung des Steppers starten
 YMOTOR.run();
 delay(5);
 }
 XMOTOR.setCurrentPosition(0); // Aktuelle Position vorerst auf Null setzen
 YMOTOR.setCurrentPosition(0);
 initial_xhome =-1;
 initial_yhome =1;
 while(digitalRead(XLIMIT)){ 
 XMOTOR.moveTo(initial_xhome); // Setze die Position zum Verschieben
 YMOTOR.moveTo(initial_yhome); // Setze die Position zum Verschieben
 initial_xhome--; // Bei Bedarf für den nächsten Zug um 1 verringern
 initial_yhome++;
 XMOTOR.run(); // Bewegung des Steppers starten
 YMOTOR.run();
 delay(5);
 }
 YMOTOR.setCurrentPosition(0); // Setzt die aktuelle Position vorerst auf Null
 YMOTOR.setMaxSpeed(250.0); // Stellen Sie die maximale Geschwindigkeit des Steppers ein (langsamer, um eine bessere Genauigkeit zu erzielen)
 YMOTOR.setAcceleration (10.0); // Beschleunigung des Steppers setzen
 initial_yhome =1;
 while (!digitalRead(YLIMIT)) { // Stepper im Uhrzeigersinn bewegen lassen, bis der Schalter deaktiviert wird
 YMOTOR.moveTo(initial_yhome); 
 YMOTOR.run();
 initial_yhome++;
 delay(5);
 }
 YMOTOR.setCurrentPosition(0);
 YMOTOR.setMaxSpeed(YMOTORMAXSPEED ); // Max. Geschwindigkeit des Steppers einstellen (schneller für regelmäßige Bewegungen)
 YMOTOR.setAcceleration(YMOTORACC); // Beschleunigung des Steppers setzen
 XMOTOR.setCurrentPosition(0); // Setzt die aktuelle Position vorerst auf Null
 XMOTOR.setMaxSpeed(250.0); // Maximale Geschwindigkeit des Steppers einstellen (langsamer, um eine bessere Genauigkeit zu erzielen)
 XMOTOR.setAcceleration(10.0); // Beschleunigung des Steppers setzen
 initial_xhome =1;
 while (!digitalRead(XLIMIT)) { // Stepper im Uhrzeigersinn bewegen lassen, bis der Schalter deaktiviert wird
 XMOTOR.moveTo(initial_xhome); 
 XMOTOR.run();
 initial_xhome++;
 delay(5);
 }
 XMOTOR.setCurrentPosition(0);
 XMOTOR.setMaxSpeed(XMOTORMAXSPEED ); // Max. Geschwindigkeit des Steppers einstellen (schneller für regelmäßige Bewegungen)
 XMOTOR.setAcceleration(XMOTORACC); // Setze Beschleunigung des Steppers
}
void zhome() {
 int initial_zhome =-1;
 // Setze maximale Geschwindigkeit und Beschleunigung jedes Steppers beim Start für die Referenzfahrt
 ZMOTOR.setMaxSpeed(100.0); // Stellen Sie die maximale Geschwindigkeit des Steppers ein (langsamer, um eine bessere Genauigkeit zu erzielen)
 ZMOTOR.setAcceleration(100.0); // Beschleunigung des Schrittmotors einstellen
 // Referenzfahrt des Schrittmotors beim Start starten
 while (digitalRead(ZLIMIT)) { // Schrittmotor gegen den Uhrzeigersinn bewegen lassen, bis der Schalter aktiviert ist
 ZMOTOR. moveTo(initial_zhome); // Setze die Position zum Verschieben
 initial_zhome--; // Bei Bedarf für den nächsten Zug um 1 verringern
 ZMOTOR.run(); // Bewegung des Steppers starten
 delay(5);
 }
 ZMOTOR.setCurrentPosition(0); // Setzt die aktuelle Position vorerst auf Null
 ZMOTOR.setMaxSpeed(50.0); // Maximale Geschwindigkeit des Steppers einstellen (langsamer, um eine bessere Genauigkeit zu erzielen)
 ZMOTOR.setAcceleration(50.0); // Beschleunigung des Steppers setzen
 initial_zhome =1;
 while (!digitalRead(ZLIMIT)) { // Den Stepper im Uhrzeigersinn bewegen lassen bis der Schalter deaktiviert wird
 ZMOTOR.moveTo(initial_zhome); 
 ZMOTOR.run();
 initial_zhome++;
 delay(5);
 }
 ZMOTOR.setCurrentPosition(0);
 ZMOTOR.setMaxSpeed(1000.0 ); // Max. Geschwindigkeit des Steppers einstellen (schneller für regelmäßige Bewegungen)
 ZMOTOR.setAcceleration(1000.0); // Beschleunigung des Steppers einstellen
} 

Okay, das ist eine Menge Code. Was passiert hier wirklich? Der Arm führt zuerst eine Referenzfahrtroutine an den X- und Y-Motoren durch. Aufgrund der Funktionsweise der Verknüpfungen erfolgt dies in wenigen Schritten. (Sie können das Video am Ende sehen, um dies in Aktion zu sehen)

• Zuerst werden die X- und Y-Motoren in entgegengesetzte Richtungen bewegt, sodass der Y-Endschalter zuerst gedrückt wird.
• Sobald der Y-Endschalter gedrückt wird, drehen beide Motoren in die gleiche Richtung, sodass der X-Endschalter gedrückt wird.
• Nachdem der X-Schalter gedrückt wurde, werden die Motoren ein wenig bewegt, sodass die Schalter gedrückt werden (gedrückt wie in, nicht traurig gedrückt.)
• Schließlich wird der Z-Motor so gedreht, dass der Z-Endschalter gedrückt wird.

Sie müssen beim ersten Referenzieren sehr vorsichtig sein. Wenn sich Ihre Stepper in die andere Richtung bewegen, schalten Sie einfach den Strom aus und drehen Sie DANN den Stecker des Motors um.

Nachdem dies erledigt ist, rufen Sie autohome() aus Ihrer setup()-Funktion auf, damit sie nur einmal ausgeführt wird. Lassen Sie loop() leer. Und halten Sie eine Hand an Ihrem Netzteil, um es auszuschalten, wenn etwas schief geht.

void setup() {
 // Geben Sie Ihren Setup-Code hier ein, um ihn einmal auszuführen:
 Serial.begin(9600);
 pinsetup();
 autohome();
 Serial.println("HOMING OK");
} 

Wenn Sie Glück haben, drehen Ihre Motoren richtig, die Endschalter klicken genau richtig und die Referenzfahrt funktioniert problemlos. Aber wenn Sie wie ich sind, müssen Sie kleine Änderungen vornehmen, bevor alles läuft. Trennen Sie also immer die Stromversorgung, wenn die Referenzfahrt fehlschlägt, damit Sie Ihren 3D-gedruckten Arm nicht durcheinander bringen.

Schließlich können Sie Ihre eigene Logik in die Schleife() schreiben, damit sich Ihr Arm in die gewünschte Position bewegt. Aufgrund der Art und Weise, wie der Arm verbunden ist, steuern die X- und Y-Motoren den Endeffektor auf fast kartesische Weise.

void loop() {
 XMOTOR.runToNewPosition(100);
 delay(1000);
 YMOTOR.runToNewPosition(50);
 delay(1000);
 YMOTOR.runToNewPosition(-50);
 Verzögerung(1000);
 YMOTOR.runToNewPosition(0);
 Verzögerung(1000);
 XMOTOR.runToNewPosition( 0);
 Verzögerung(1000);
} 

Fazit

Ich habe viele Tutorials gesehen, wie man die beliebte GRBL-Firmware verwendet, um diesen Arm zu steuern. Dies bedeutet jedoch, dass Sie einen Computer benötigen, um serielle Befehle an den Arm zu senden, damit er sich bewegt. Wenn Sie den MK2-Arm nur für ein paar Bewegungen benötigen, können Sie sie einfach in den Arduino hartcodieren und ihn sein eigenes Ding machen lassen.

Das bedeutet nicht, dass Sie dies nicht mit seriellen Befehlen steuern können! Sie können einfach einen seriellen Trenncode in diesen einfügen und die XY- und Z-Motorschritte als String senden (getrennt mit Sonderzeichen - z das Z durch 7. Das * wird verwendet, um das Ende der Zeichenfolge anzuzeigen).

Sie können dies auch weiterentwickeln, um die 3D-Raumkoordinaten des Endeffektors zu senden und das Arduino die erforderlichen Schritte mit inverser Kinematik oder sogar einfacher Trigonometrie berechnen zu lassen.

Habe Spaß! Und meinen herzlichen Dank an all die brillanten Designer auf Thingiverse!

Code

• Roboterarm

RoboterArmArduino

Keine Vorschau (nur Download).

MK2 Roboterarm-Steuerung – Github

Kundenspezifische Teile und Gehäuse

Roboterarm MK2 Plus auf Thingiverse