SCARA-Roboter | So bauen Sie Ihren eigenen Arduino-basierten Roboter
In diesem Tutorial lernen wir, wie man einen Arduino-basierten SCARA-Roboter baut. Ich werde Ihnen den gesamten Bauprozess zeigen, beginnend mit dem Roboterdesign bis hin zur Entwicklung unserer eigenen grafischen Benutzeroberfläche für die Steuerung.
Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.
Der Roboter hat 4 Freiheitsgrade und wird von 4 NEMA 17 Schrittmotoren angetrieben. Zusätzlich verfügt es über einen kleinen Servomotor zur Steuerung des Endeffektors oder in diesem Fall des Robotergreifers. Das Gehirn dieses SCARA-Roboters ist ein Arduino UNO-Board, das mit einem CNC-Schild und vier A4988-Schritttreibern zur Steuerung der Motoren gekoppelt ist.
Unter Verwendung der Processing-Entwicklungsumgebung habe ich eine grafische Benutzeroberfläche erstellt, die sowohl Vorwärts- als auch Rückwärtskinematik-Steuerung bietet. Mit der Vorwärtskinematik können wir jedes Robotergelenk manuell bewegen, um die gewünschte Position zu erreichen. Mit den Schiebereglern auf der linken Seite können wir den Winkel jedes Gelenks einstellen. Die Endposition des Endeffektors, die X-, Y- und Z-Werte werden berechnet und auf der rechten Seite des Bildschirms ausgedruckt.
Andererseits können wir mit der inversen Kinematik die gewünschte Position des Endeffektors einstellen, und das Programm berechnet automatisch die Winkel für jedes Gelenk, damit der Roboter die gewünschte Position erreicht.
Ich habe das Programm tatsächlich so erstellt, dass wir beide Methoden gleichzeitig auf demselben Bildschirm verwenden können. Die Winkel der Gelenke sowie die X-, Y- und Z-Werte des Endeffektors sind verbunden und immer auf dem Bildschirm vorhanden.
Natürlich kann der Roboter auch automatisch arbeiten. Mit der Schaltfläche „Speichern“ im Programm können wir jede Bewegung oder Position des Roboters speichern. Wenn wir dann die „Run“-Taste drücken, führt der Roboter die gespeicherten Bewegungen in einer Schleife aus, von der ersten bis zur letzten, immer und immer wieder. Wir können auch die Bewegungsgeschwindigkeit und die Beschleunigung über die Benutzeroberfläche anpassen.
Werfen wir zunächst einen Blick auf das 3D-Modell.
Ich habe diesen SCARA-Roboter mit 3DEXPERIENCE SOLIDWORKS entworfen, die auch der Sponsor dieses Videos sind.
3 3DEXPERIENCE SOLIDWORKS ist im Grunde genommen SOLIDWORKS mit Cloud-Funktionen, die wir über die 3DEXPERIENCE Plattform erhalten. Alles funktioniert über die Cloud, sodass Sie oder jeder aus Ihrem Team jederzeit und von überall auf der Welt auf die Daten oder Modelle zugreifen können. Die 3DEXPERIECE-Plattform umfasst auch viele nützliche Produktivitäts- und Management-Apps.
Der Projektplaner ist beispielsweise eine großartige Möglichkeit, Ihre Aufgaben zu organisieren, Fristen festzulegen und Ihren Fortschritt zu verfolgen. Mit der 3D-Markup-App können Sie die Modelle von jedem Gerät aus anzeigen, erkunden und sich Notizen machen, z. B. einem Notebook, Tablet oder sogar einem Smartphone.
Es gibt auch einen separaten, Cloud-basierten 3D-Modellierer namens SOLIDWORKS xDesign, der in Ihrem Browser ausgeführt wird. Es kann in Verbindung mit Solidworks oder allein verwendet werden und eignet sich hervorragend zum Modellieren, überall, jederzeit und auf jedem Gerät.
Also vielen Dank an Solidworks für das Sponsoring solcher Bildungsinhalte. Wenn Sie wissen möchten, ob SOLIDWORKS und die 3DEXPERIENCE-Plattform für Sie geeignet sind, sehen Sie sich die folgenden Links unten an.
Testen Sie 3DEXPERIENCE kostenlos über meinen speziellen Link:www.solidworks.com/HTMTryNow
Erfahren Sie mehr über 3DEXPERIENCE SOLIDWORKS: www.solidworks.com/HTMLearnMore
Ok, also zurück zum Modell und erklären, wie ich auf dieses Design gekommen bin. Mein Ziel für den Roboter war, die meisten Teile in 3D zu drucken. Alles, was Sie hier sehen, kann also auch auf einem 3D-Drucker mit kleinerem Druckbett in 3D gedruckt werden. Die GT2-Riemenscheiben sind auch 3D-druckbar. Ich habe parametrisches Design verwendet, um sie zu erstellen, sodass wir bei Bedarf ihre Größe leicht ändern können. Wir müssen nur die Anzahl der Zähne ändern, und alle Abmessungen werden automatisch aktualisiert, um der Riemenscheibe die richtige Größe zu geben.
Für das erste Gelenk haben wir ein Untersetzungsverhältnis von 20:1, das mit diesen kundenspezifischen Riemenscheiben in zwei Stufen erreicht wird. Die beiden GT2-Riemen, die ich hier verwende, sind geschlossene Schleifen mit 200 mm und 300 mm Länge. Die Robotergelenke bestehen aus zwei Axiallagern und einem Radiallager.
Für das zweite Gelenk haben wir ein Untersetzungsverhältnis von 16:1, das auf die gleiche Weise erreicht wird, und das dritte Gelenk hat ein Untersetzungsverhältnis von 4:1 mit nur einer Untersetzungsstufe. Die Gelenke sind hohl, damit wir die Drähte von den Motoren und den Mikroschaltern durchziehen können. Für jeden der Riemen gibt es Schlitze, an denen wir Umlenkrollen zum Spannen anbringen können.
Der Robotergreifer wird von einem MG996R-Servomotor angetrieben und wir können die Greiferenden einfach wechseln, um unterschiedliche Greifgrößen zu erreichen. Die Z-Achse des Roboters wird von einer 8-mm-Leitspindel angetrieben, während die gesamte Armbaugruppe auf vier glatten 10-mm-Stangen und Linearkugellagern gleitet. Die Höhe des Roboters hängt einfach von der Länge der glatten Stäbe ab, die in diesem Fall 40 cm betragen. Die Leitspindel muss 2 cm kürzer sein, um in diese Konfiguration zu passen, oder wenn nicht, kann der Z-Motor mit Distanzmuttern um 2 cm angehoben werden.
Sie können dieses 3D-Modell finden und herunterladen sowie es in Ihrem Browser auf Thangs erkunden:
Laden Sie das 3D-Montagemodell unter Thangs herunter.
STL-Dateien für den 3D-Druck:
In Ordnung, also können wir mit dem 3D-Druck der Teile fortfahren. Ich habe meinen Creality CR-10 3D-Drucker zum Drucken aller Teile verwendet, was ein wirklich großartiger 3D-Drucker zu einem erschwinglichen Preis ist. Wie ich bereits erwähnt habe, sind die Teile so konzipiert, dass sie auch auf einen kleineren 3D-Drucker passen, zum Beispiel den Ender3.
Für die meisten Teile habe ich PLA+ Material verwendet, das blaue, sowie normales PLA für die Umlenkrollen und den Greifer. Ich habe ungefähr 120 Stunden gebraucht, um alle Teile mit einer Druckgeschwindigkeit von 60 mm/s zu drucken. Die Basis war der größte Teil des Drucks, der etwa 32 Stunden dauerte. Wenn wir jedoch die Druckgeschwindigkeit erhöhen, können wir die Teile definitiv schneller drucken.
Siehe auch: Die besten 3D-Drucker für Anfänger und Entwickler [Aktualisierung 2021]
Hier sind alle 3D-gedruckten Teile.
Nur eine kurze Anmerkung hier, dass ich alle mit aktivierter horizontaler Ausdehnung von –0,1 mm in der Slicing-Software gedruckt habe. Dadurch können die Teile genauere Abmessungen haben und besser zu den anderen mechanischen Teilen wie den Lagern, den Stangen und den Bolzen passen.
Hier ist eine Liste der Komponenten, die zum Zusammenbau dieses Arduino-basierten SCARA-Roboters benötigt werden. Die Liste der Elektronikkomponenten finden Sie weiter unten im Schaltplanteil des Artikels.
Hier sind die für dieses Projekt erforderlichen Schraubengrößen:
Wir beginnen die Montage mit Basis. Hier setzen wir zuerst ein Radialkugellager mit 35mm Innen- und 47mm Außendurchmesser ein.
Dann geht es an das erste Axiallager, das 40 mm Innen- und 60 mm Außendurchmesser hat. Dieses Lager sitzt zwischen der Riemenscheibe und der Basis.
Auf der anderen Seite der Basis verwenden wir ein weiteres Axiallager der gleichen Größe zusammen mit der Gelenkkupplung.
Dann können wir die Riemenscheibe und den oberen Teil mit vier M4-Schrauben mit 55 mm Länge koppeln. Wir müssen hier selbstsichernde Muttern verwenden und sie entsprechend anziehen, damit das Gelenk stabil ist und sich frei drehen kann.
Als nächstes müssen wir die mittlere Riemenscheibe installieren. Diese Riemenscheibe ist mit der gemeinsamen Riemenscheibe mit einem 300-mm-GT2-Riemen gepaart. Für die Installation dieser Riemenscheibe verwenden wir zwei 608-Kugellager, eines oben und das andere unten an der Basis. Dann können wir die Riemenscheibe mit einer 45-mm-M8-Schraube, einer Unterlegscheibe und einer selbstsichernden Mutter befestigen.
Als nächstes müssen wir den Schrittmotor für dieses Gelenk installieren. Der Stepper wird mit einem 200-mm-Riemen mit der mittleren Riemenscheibe gekoppelt. Zur Befestigung an der Basis benötigen wir vier M3-Schrauben.
Bevor wir die Schrauben festziehen, müssen wir den Riemen so weit wie möglich dehnen. Nur eine kurze Anmerkung hier, dass ich tatsächlich die M8-Schraube für die mittlere Riemenscheibe mit ihrem Kopf nach unten ersetzt habe, damit sie in die Basis passt.
An dieser Stelle sollten wir prüfen, ob die Gurte straff genug sind. Wenn nicht, können wir einige Umlenkrollen verwenden, um sie besser festzuziehen. Hier verwende ich eine 35-mm-M5-Schraube und einige Muttern, um die Spannrolle herzustellen.
Es kann an den Schlitzen auf beiden Seiten des Gürtels befestigt werden, sodass wir den Gürtel so festziehen können, wie wir möchten. Am Ende habe ich den Gürtel auf beiden Seiten festgezogen. Damit ist die erste Fuge fertig.
Ich fuhr mit der Installation des Mikroschalters für dieses Gelenk fort. Bevor ich es an Ort und Stelle befestige, habe ich bereits die Drähte daran gelötet, da es hier etwas eng ist, um das nachher zu tun. Wir benötigen 20 mm M3-Schrauben und eine Mutter, um den Mikroschalter zu befestigen.
Die Gelenkkupplung geht so nah am Schalter vorbei, dass ich am Ende nur eine Schraube zum Befestigen des Schalters verwendet habe. Am anderen Loch habe ich einfach eine kürzere Schraube eingesetzt und auf der Unterseite geklebt. Auf diese Weise ist der Schalter sicher genug und kann ordnungsgemäß funktionieren.
Ok, als nächstes können wir mit dem Zusammenbau der Z-Achse beginnen. Zuerst müssen wir oben auf der Gelenkkupplung das untere Plattenteil der Z-Achse befestigen.
Darauf können wir die vier Klemmen für die glatten Stangen befestigen. Dann können wir die glatten Stäbe einsetzen. Sie sollten eng anliegen und bis zum Gelenkkupplungsteil reichen. Wir können dann die Stangen mit den Klemmen mit einigen M4-Schrauben und Muttern festziehen.
An dieser Stelle müssen wir das Lager für die Leitspindel einfügen. Um diesen Abschnitt abzuschließen, können wir einfach eine einfache Abdeckung einschieben, die alles verbirgt und dem Roboter ein saubereres Aussehen verleiht.
Als nächstes können wir mit der Montage des ersten Arms des Roboters fortfahren. Der Arm besteht aus zwei miteinander verschraubten Teilen. Der erste Teil ist, wo wir die Linearlager installieren müssen, die durch die glatten Stangen gleiten. Das Einsetzen kann etwas schwierig sein, da sie ziemlich fest sitzen.
Tatsächlich hängt dies davon ab, wie genau Ihr Drucker die Teile drucken kann. Daher schlage ich vor, beim Drucken der Teile die Funktion Horizonal Expansion zu verwenden und sie entsprechend Ihrem Drucker anzupassen. In meinem Fall konnte ich zwei der Lager nicht ganz nach unten montieren, aber das ist keine große Sache.
Ok, jetzt können wir die beiden Teile des Arms zusammenkoppeln. Zu diesem Zweck verwenden wir vier 25-mm-M5-Schrauben.
Als nächstes können wir den zweiten Schrittmotor installieren. Hier verwende ich eine 3D-gedruckte GT2-Riemenscheibe mit 20 Zähnen. Ich habe diese Riemenscheibe mit dem zuvor erwähnten parametrischen Design hergestellt und es funktioniert recht gut. Hier müssen wir auch die Leitspindelmutter an Ort und Stelle sichern.
Als nächstes können wir die Riemen und Riemenscheiben für das zweite Gelenk installieren. Hier benötigen wir einen Riemen mit 400mm und einen mit 300mm Länge. Das Verfahren zum Installieren ist im Wesentlichen das gleiche wie für das erste Gelenk erklärt.
Hier verwenden wir für das zweite Gelenk und das dritte tatsächlich kleinere Lager im Vergleich zum ersten. Das Radialkugellager hat 30 mm Innen- und 42 mm Außendurchmesser und das Drucklager hat 35 mm Innen- und 52 mm Außendurchmesser.
Vor der Installation der zweiten Gelenkkupplung müssen wir sechs 20-mm-M4-Schrauben in die Sechskantschlitze einsetzen.
Sie dienen zur Befestigung des zweiten Arms am Gelenk. Falls erforderlich, können wir zum Spannen der Riemen die gleiche Methode anwenden, die zuvor mit Umlenkrollen erklärt wurde. Schließlich sicherte ich den zweiten Mikroschalter an Ort und Stelle und die Montage des Arms Nummer eins war abgeschlossen.
Ich fuhr fort, den zweiten Arm an der Gelenkkupplung zu befestigen. Hier verwenden wir die Schrauben in der Gelenkkupplung, die wir zuvor installiert haben, um den oberen Teil des zweiten Arms zu sichern.
An dieser Stelle wollte ich testen, wie viel Spiel die Gelenke hatten. Sicher, ich habe aufgrund der Riemen ein gewisses Spiel erwartet, aber es gab tatsächlich viel mehr Spiel zwischen zwei Teilen der Gelenke. Mir ist aufgefallen, dass das Problem darin bestand, dass die Löcher, in die die Schrauben gehen, etwas größer sind als die Schrauben selbst. Um das Problem zu lösen, brauchen wir eine engere Passung zwischen den Bolzen und den Löchern.
Also habe ich in meinem Fall die Löcher mit einem 4,5-mm-Bohrer erweitert und M5-Schrauben anstelle der M4-Schrauben verwendet, um die beiden Teile des Gelenks aneinander zu befestigen. Ich habe das 3D-Modell jedoch so aktualisiert, dass die Löcher 3,5 mm groß sind und Sie die M4-Schrauben verwenden können, um diese beiden Teile miteinander zu verbinden. Ich ging auch zurück zum ersten Joint und tat dasselbe. Jetzt ist das Spiel in den Gelenken fast verschwunden, abgesehen von dem kleinen Spiel, das wir von den Riemen bekommen.
So, jetzt können wir mit der Montage des zweiten Arms fortfahren. Hier müssen wir zuerst den Schrittmotor für das dritte Gelenk einbauen.
Ich verwende in diesem Fall einen kleineren Schrittmotor, damit der Arm etwas leichter ist. Trotzdem ist es ein NEMA 17-Schrittmotor, aber mit einer kürzeren Länge von 24 cm.
Auch hier haben wir das gleiche Verfahren für die Installation der Riemen und der Riemenscheibe für das dritte Gelenk, außer dass wir hier nur eine einstufige Untersetzung mit einem 400-mm-Riemen verwenden. Als nächstes müssen wir, bevor wir diesen unteren Teil des Arms am oberen Teil befestigen, den Motor und den Mikroschalter anschließen und ihre Drähte durch das zweite Gelenk führen.
An dieser Stelle müssen wir auch die Drähte für den Endeffektor einführen. In meinem Fall habe ich ein 4-adriges Kabel von einem Schrittmotor eingefügt, das ich zum Antreiben des Servomotors für meinen Greifer verwenden werde, der 3 Adern benötigt.
Als nächstes müssen wir M4-Muttern in die Schlitze des oberen Arms einsetzen, die dazu dienen, den unteren Teil daran zu befestigen.
Unmittelbar vor dem Zusammenführen sollten wir die Drähte unter diesen Haken hindurchführen, damit sie von den beweglichen Teilen fern bleiben.
Die Drähte, die aus dem zweiten Gelenk kommen, können tatsächlich von den Muttern auf der Rolle erfasst werden, deshalb habe ich einen einfachen Drahthalter gemacht, um die Drähte von den Muttern fernzuhalten.
Wir sollten die Drähte so anordnen, dass sie auf einer Seite des Arms verlaufen, um einen Kontakt mit den beweglichen Teilen zu vermeiden. Schließlich können wir die Abdeckung des ersten Arms einsetzen.
Die Abdeckung ist mit einer Schnappverbindung am Arm befestigt. Damit ist die Montage der Roboterarme abgeschlossen.
Als nächstes können wir diese ganze Baugruppe in die Z-Achsen-Stangen einfügen.
Dann müssen wir die obere Platte der Z-Achse vorbereiten, die die oberen Enden der Stangen hält. Hier können wir zuerst den Mikroschalter für die Z-Achse einbauen und die für Klemmen an der Platte befestigen.
Bevor ich die obere Platte an Ort und Stelle setzte, habe ich zuerst eine einfache Abdeckung wie die unten eingefügt, um die Klemmen, die Schrauben und den Mikroschalter zu verbergen. Dann können wir die obere Platte mit den Klemmen an den Stangen einsetzen und festziehen.
Als nächstes müssen wir die Leitspindel einsetzen.
Die, die ich hatte, war etwas länger, also habe ich sie mit einer Metallhandsäge auf 38 cm gekürzt. Als nächstes können wir den vierten Schrittmotor anbringen. Hier müssen wir einen 5 mm bis 8 mm Wellenkoppler verwenden, um den Motor mit der Leitspindel zu verbinden.
Schließlich können wir die Drähte durch die Abdeckung führen und sie mit zwei Schrauben an der oberen Platte befestigen.
Ok, als nächstes können wir etwas Kabelmanagement machen. Ich habe Kabelmuffen verwendet, um die Drähte zusammenzufügen und das Chaos zu beseitigen. Ich habe auch einige Kabelbinder für diesen Zweck verwendet.
Bevor Sie die Drähte in die Kabelmuffen stecken, ist es eine gute Idee, jeden von ihnen zu markieren, damit Sie nichts falsch anschließen.
Was jetzt noch übrig bleibt, ist der Endeffektor des Roboters. Wir können tatsächlich jede Art von Endeffektor herstellen und am Roboter befestigen. Ich entschied mich für einen einfachen Greifer, der von einem MG996R-Servomotor angetrieben wird. Der Greifer basiert auf zwei 6-mm-Stäben, auf denen die beiden Seiten gleiten.
Die beiden Gleitseiten werden mit einem Servohorn, einigen 3D-gedruckten Gliedern und M3-Schrauben und Muttern mit dem Servo verbunden. Ich habe M3-Schrauben und Muttern für die gesamte Greiferbaugruppe verwendet. Eine vollständige Liste der für dieses Projekt erforderlichen Schrauben und Muttern finden Sie im Website-Artikel. Der Platz zum Befestigen der Schrauben und Muttern ist recht knapp bemessen, so dass man für den Zusammenbau mancher dieser Teile einige Nerven braucht.
Das Gute an diesem Design ist jedoch, dass wir die Greiferenden leicht wechseln können. Sie können breiter oder schmaler sein oder eine bestimmte Form haben. Wir können den Greifer mit einigen M4-Schrauben und Muttern am Roboterarm befestigen.
Schließlich können wir den Servomotor an die zuvor installierten Drähte anschließen.
Und fertig, unser SCARA-Roboterarm ist fertig montiert. Jetzt müssen nur noch die Elektronikkomponenten dieses Projekts angeschlossen werden.
Wir werden also ein Arduino UNO-Board in Kombination mit einem CNC-Schild und vier A4988-Schrittantrieben verwenden.
Obwohl es ein Roboter ist und komplizierter erscheint, ist das die gesamte Elektronik, die wir für dieses Projekt benötigen. Es ist erwähnenswert, dass wir anstelle von Arduino UNO auch ein Arduino MEGA in Kombination mit einer RAMPS 3D-Drucker-Steuerplatine verwenden könnten.
Trotzdem habe ich ein Gehäuse für den Arduino UNO 3D-gedruckt, das einfach an der Basis des Roboters befestigt werden kann. Ich werde eine Viertelschrittauflösung zum Ansteuern der Stepper verwenden, also habe ich einige Jumper in die entsprechenden Pins gesteckt. Jetzt können wir Schrittmotoren und die Mikroschalter an das CNC-Schild anschließen.
Hier ist der Schaltplan dieses SCARA-Roboters und wie alles angeschlossen werden muss.
Die für dieses Projekt benötigten Komponenten erhalten Sie über die folgenden Links:
Für die Stromversorgung des Roboters benötigen wir ein 12-V-Netzteil, das mindestens 4 A liefern kann, aber ich würde ein 12-V-6-A-Netzteil vorschlagen. Dies hängt natürlich davon ab, wie die Strombegrenzung des Stepper-Treibers eingestellt ist, und ich würde vorschlagen, sie auf das niedrigstmögliche Niveau einzustellen.
Am Ende quetschte ich alle Kabel in das Gehäuse, während ich versuchte, die Kühlkörper der Laufwerke frei zu lassen, und fügte die Abdeckung hinzu.
Der SCARA-Roboter ist jetzt fertig, und was wir jetzt tun müssen, ist, die Basis an etwas zu befestigen. Zu diesem Zweck werde ich 20 mm Zeckenstück Holz verwenden. An der Unterseite der Roboterbasis haben wir 12 Löcher zur Befestigung zur Verfügung. Also druckte ich eine Zeichnung der Roboterbasis aus und benutzte sie, um die Löcher in das Holz zu bohren.
An der Unterseite habe ich sie versenkt, da ich Flachkopfschrauben verwenden werde, damit sie mit der Holzoberfläche blitzen. Ich habe M4-Muttern in die Basisschlitze eingesetzt und dann die Holzbasis an der Roboterbasis befestigt.
Nun, um den Roboter an Ort und Stelle zu fixieren, könnten wir ihn idealerweise an den Tisch schrauben, oder ich verwende einfach Klemmen für diesen Zweck.
Das war's also, unser SCARA-Roboter ist nun komplett fertig. In diesem Video bleibt jedoch übrig, einen Blick darauf zu werfen, wie der Roboter funktioniert.
Siehe auch: DIY-Arduino-Roboterarm mit Smartphone-Steuerung
Es gibt zwei Methoden zur Steuerung von Robotern in Bezug auf Positionierung und Ausrichtung, und zwar die Verwendung von Vorwärts- oder Rückwärtskinematik.
Vorwärtskinematik wird verwendet, wenn wir die Position und Orientierung des Endeffektors aus den gegebenen Gelenkwinkeln finden müssen.
Andererseits wird die inverse Kinematik verwendet, wenn wir die Gelenkwinkel für eine gegebene Position des Endeffektors finden müssen. Diese Methode ist in der Robotik sinnvoller, da wir meistens möchten, dass der Roboter sein Werkzeug an einer bestimmten Position oder an bestimmten X-, Y- und Z-Koordinaten positioniert.
Mit inverser Kinematik können wir die Gelenkwinkel nach vorgegebenen Koordinaten berechnen.
Die Gleichungen, die ich sowohl für die Vorwärts- als auch für die Rückwärtskinematik verwenden werde, stammen aus trigonometrischen Regeln und Formeln.
Am Ende des Artikels finden Sie sowohl den Arduino- als auch den Processing-Code.
So sehen die Gleichungen in einem Code aus, der in der Processing-Entwicklungsumgebung geschrieben wurde.
Mit der Vorwärtskinematik berechnen wir also den X- und Y-Wert des Endeffektors gemäß den eingestellten Gelenkwinkeln der beiden Arme des Roboters, Theta1 und Theta2, sowie deren Längen L1 und L2.
Bei der inversen Kinematik hingegen berechnen wir die Gelenkwinkel, theta2 und theta1, entsprechend der gegebenen Position oder den X- und Y-Koordinaten.
Je nachdem, in welchem Quadranten die Position eingestellt ist, nehmen wir mit diesen „Wenn“-Anweisungen einige Anpassungen an den Gelenkwinkeln vor. Für diese Konfiguration des Roboters berechnen wir tatsächlich eine inverse Kinematik mit nur zwei Gliedern. Der dritte Winkel, den ich „Phi“ nenne, dient zum Einstellen der Ausrichtung des Greifers.
Die grafische Benutzeroberfläche wird unter Verwendung der controlP5-Bibliothek für die Verarbeitungs-IDE erstellt. Mit dieser Bibliothek können wir ganz einfach Schaltflächen, Schieberegler, Textfelder usw. erstellen.
Zum Beispiel verwenden wir die Schieberegler auf der linken Seite, um die Gelenkwinkel zu steuern, und mithilfe der Textfelder können wir die Position eingeben, an der unser Roboter fahren soll. Bei jeder Aktion, die wir hier mit dem Programm ausführen, senden wir Daten über die serielle Schnittstelle an das Arduino-Board.
Diese Daten umfassen die Gelenkwinkel, den Greiferwert, Geschwindigkeits- und Beschleunigungswerte und Indikatoren, um zu wissen, ob wir auf die Schaltfläche „Speichern“ oder „Ausführen“ geklickt haben.
All diese Daten kommen als ein langer String beim Arduino an. Hier müssen wir also zuerst die Daten aus dieser Zeichenfolge extrahieren und sie in separate Variablen einfügen.
Mit diesen Variablen können wir nun Aktionen mit dem Roboter durchführen. Wenn wir zum Beispiel die SAVE-Taste drücken, speichern wir die aktuellen Gelenkwinkelwerte in einem separaten Array.
If we click the RUN button, we execute the stored steps and so on.
For controlling the stepper motors, I used the AccelStepper library. Although this is a great library for controlling multiple steppers at the same time, it has some limitations when it comes to controlling a robot like this. When controlling multiple steppers, the library cannot implement acceleration and deceleration, which are important for smoother operation of the robot.
I still managed to implement acceleration and deceleration with the library, but they are not as smooth as I wanted to be.
Here are full Arduino and Processing codes for this Arduino SCARA robot project:
So finally, once we upload the code to the Arduino, we can run the processing program, connect the power and the scara robot will start moving to its home position.
From there on, we can do whatever we want the it. We can play around manually or set it to work automatically. Of course, we can attach any kind of end-effector and make cool stuff with it. For example, we can even attach a 3D printer hot end to the robot and so make the robot a 3D printer, or attach a laser head and make it a laser cutter. I do plan try these two ideas, so make sure you subscribe to my channel so you don’t miss them in some of my future videos.
Before this video ends, I would like to give you few more notes about this project. I found the robot to be not as rigid as I expected.
I guess the problem is that almost the entire SCARA robot, the Z-axis and the arms are supported only by the first joint. The whole weight and the inertial forces generated when moving, can make quite a stress to base where the first joint is located, and as it’s just a plastic it tends to bend a little bit. Also, these belts are not backlash free so we reduce the robot rigidity with that too. However, I think the overall project is good enough so you to learn how SCARA robots work, and gives you the courage to build one for yourself.
Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen und sehen Sie sich meine Arduino-Projektsammlung an.Übersicht
SCARA-Roboter 3D-Modell
3D-Druck der Roboterteile
Montage des Roboters
SCARA-Roboter-Schaltplan
Beenden der Montage
Wie der SCARA-Roboter funktioniert
Programmierung des SCARA-Roboters – Arduino und Verarbeitungscode
// FORWARD KINEMATICS
void forwardKinematics() {
float theta1F = theta1 * PI / 180; // degrees to radians
float theta2F = theta2 * PI / 180;
xP = round(L1 * cos(theta1F) + L2 * cos(theta1F + theta2F));
yP = round(L1 * sin(theta1F) + L2 * sin(theta1F + theta2F));
} Codesprache:Arduino (arduino) / INVERSE KINEMATICS
void inverseKinematics(float x, float y) {
theta2 = acos((sq(x) + sq(y) - sq(L1) - sq(L2)) / (2 * L1 * L2));
if (x < 0 & y < 0) {
theta2 = (-1) * theta2;
}
theta1 = atan(x / y) - atan((L2 * sin(theta2)) / (L1 + L2 * cos(theta2)));
theta2 = (-1) * theta2 * 180 / PI;
theta1 = theta1 * 180 / PI;
// Angles adjustment depending in which quadrant the final tool coordinate x,y is
if (x >= 0 & y >= 0) { // 1st quadrant
theta1 = 90 - theta1;
}
if (x < 0 & y > 0) { // 2nd quadrant
theta1 = 90 - theta1;
}
if (x < 0 & y < 0) { // 3d quadrant
theta1 = 270 - theta1;
phi = 270 - theta1 - theta2;
phi = (-1) * phi;
}
if (x > 0 & y < 0) { // 4th quadrant
theta1 = -90 - theta1;
}
if (x < 0 & y == 0) {
theta1 = 270 + theta1;
}
// Calculate "phi" angle so gripper is parallel to the X axis
phi = 90 + theta1 + theta2;
phi = (-1) * phi;
// Angle adjustment depending in which quadrant the final tool coordinate x,y is
if (x < 0 & y < 0) { // 3d quadrant
phi = 270 - theta1 - theta2;
}
if (abs(phi) > 165) {
phi = 180 + phi;
}
theta1=round(theta1);
theta2=round(theta2);
phi=round(phi);
cp5.getController("j1Slider").setValue(theta1);
cp5.getController("j2Slider").setValue(theta2);
cp5.getController("j3Slider").setValue(phi);
cp5.getController("zSlider").setValue(zP);
} Codesprache:Arduino (arduino) 
if (gripperValuePrevious != gripperValue) {
if (activeIK == false) { // Check whether the inverseKinematics mode is active, Executre Forward kinematics only if inverseKinematics mode is off or false
gripperAdd = round(cp5.getController("gripperValue").getValue());
gripperValue=gripperAdd+50;
updateData();
println(data);
myPort.write(data);
}
} Codesprache:Arduino (arduino) public void updateData() {
data = str(saveStatus)
+","+str(runStatus)
+","+str(round(cp5.getController("j1Slider").getValue()))
+","+str(round(cp5.getController("j2Slider").getValue()))
+","+str(round(cp5.getController("j3Slider").getValue()))
+","+str(round(cp5.getController("zSlider").getValue()))
+","+str(gripperValue)
+","+str(speedSlider)
+","+str(accelerationSlider);
} Codesprache:Arduino (arduino) if (Serial.available()) {
content = Serial.readString(); // Read the incomding data from Processing
// Extract the data from the string and put into separate integer variables (data[] array)
for (int i = 0; i < 10; i++) {
int index = content.indexOf(","); // locate the first ","
data[i] = atol(content.substring(0, index).c_str()); //Extract the number from start to the ","
content = content.substring(index + 1); //Remove the number from the string
}
/*
data[0] - SAVE button status
data[1] - RUN button status
data[2] - Joint 1 angle
data[3] - Joint 2 angle
data[4] - Joint 3 angle
data[5] - Z position
data[6] - Gripper value
data[7] - Speed value
data[8] - Acceleration value
*/ Codesprache:Arduino (arduino) // If SAVE button is pressed, store the data into the appropriate arrays
if (data[0] == 1) {
theta1Array[positionsCounter] = data[2] * theta1AngleToSteps; //store the values in steps = angles * angleToSteps variable
theta2Array[positionsCounter] = data[3] * theta2AngleToSteps;
phiArray[positionsCounter] = data[4] * phiAngleToSteps;
zArray[positionsCounter] = data[5] * zDistanceToSteps;
gripperArray[positionsCounter] = data[6];
positionsCounter++;
} Codesprache:Arduino (arduino) stepper1.moveTo(stepper1Position);
stepper2.moveTo(stepper2Position);
stepper3.moveTo(stepper3Position);
stepper4.moveTo(stepper4Position);
while (stepper1.currentPosition() != stepper1Position || stepper2.currentPosition() != stepper2Position || stepper3.currentPosition() != stepper3Position || stepper4.currentPosition() != stepper4Position) {
stepper1.run();
stepper2.run();
stepper3.run();
stepper4.run();
} Codesprache:Arduino (arduino) Wrap up
Herstellungsprozess
- Das Lego EV3 hacken:Bauen Sie Ihren eigenen Objektsensor „Augen“
- Bauen Sie Ihren internetgesteuerten Videostreaming-Roboter mit Arduino und Raspberry Pi
- Whitepaper:So finden Sie Ihr Roboterpotenzial
- So bauen Sie Sauron, den Herrn der Roboter
- So bauen Sie einen Arduino-Energiemonitor und einen Datenlogger
- Wie man IR-Fernbedienungen hackt
- Ultimate Guide:So wählen Sie einen richtigen SCARA-Roboter
- Littlearm 2C:Erstellen Sie einen 3D-gedruckten Arduino-Roboterarm
- Wie erstelle ich eine Arduino-basierte automatische Türöffnung
- So erstellen Sie Ihre Automatisierungs-Roadmap in 7 Schritten