SCARA-robot | Hoe u uw eigen op Arduino gebaseerde robot kunt bouwen

In deze tutorial leren we hoe we een op Arduino gebaseerde SCARA-robot kunnen bouwen. Ik zal je het hele proces van het bouwen laten zien, van het ontwerpen van een robot tot het ontwikkelen van onze eigen grafische gebruikersinterface om het te besturen.

Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.

Overzicht

De robot heeft 4 vrijheidsgraden en wordt aangedreven door 4 NEMA 17 stappenmotoren. Bovendien heeft hij een kleine servomotor voor het aansturen van de eindeffector of in dit geval de robotgrijper. Het brein van deze SCARA-robot is een Arduino UNO-bord dat is gekoppeld aan een CNC-schild en vier A4988-stappendrivers voor het besturen van de motoren.

Met behulp van de ontwikkelomgeving Processing heb ik een grafische gebruikersinterface gemaakt met zowel Forward als Inverse Kinematics-besturing. Met de Forward Kinematics kunnen we elk robotgewricht handmatig verplaatsen om de gewenste positie te krijgen. Met behulp van de schuifregelaars aan de linkerkant kunnen we de hoek van elke verbinding instellen. De uiteindelijke positie van de eindeffector, de X-, Y- en Z-waarden worden berekend en aan de rechterkant van het scherm afgedrukt.

Aan de andere kant kunnen we met Inverse Kinematics de gewenste positie van de eindeffector instellen, en het programma berekent automatisch de hoeken voor elk gewricht zodat de robot in die gewenste positie komt.

Ik heb het programma eigenlijk zo gemaakt dat we beide methoden tegelijkertijd kunnen gebruiken, op hetzelfde scherm. De hoeken van de gewrichten en de X-, Y- en Z-waarden van de eindeffector zijn verbonden en altijd aanwezig op het scherm.

Natuurlijk kan de robot ook automatisch werken. Met behulp van de knop "Opslaan" in het programma kunnen we elke beweging of positie van de robot opslaan. Wanneer we vervolgens op de knop "Run" drukken, voert de robot de opgeslagen bewegingen in een lus uit, van de eerste tot de laatste, steeds opnieuw. We kunnen de bewegingssnelheid en de versnelling ook aanpassen via de gebruikersinterface.

SCARA Robot 3D-model

Laten we om te beginnen eens naar het 3D-model kijken.

Ik heb deze SCARA-robot ontworpen met behulp van 3DEXPERIENCE SOLIDWORKS, die ook de sponsor van deze video zijn.

3 3DEXPERIENCE SOLIDWORKS is in feite SOLIDWORKS met cloudmogelijkheden die we krijgen via het 3DEXPERIENCE-platform. Alles werkt via de cloud, dus jij of iemand van je team heeft op elk moment en overal ter wereld toegang tot de gegevens of de modellen. Het 3DEXPERIECE-platform bevat ook veel handige productiviteits- en beheer-apps.

De Project Planer is bijvoorbeeld een geweldige manier om uw taken te organiseren, deadlines in te stellen en uw voortgang bij te houden. Met de 3D Markup-app kun je de modellen bekijken, verkennen en notities maken vanaf elk apparaat, zoals een notebook, tablet of zelfs een smartphone.

Er is ook een aparte, cloudgebaseerde 3D-modeler genaamd SOLIDWORKS xDesign, die in uw browser wordt uitgevoerd. Het kan in combinatie met Solidworks of op zichzelf worden gebruikt en is geweldig voor modellering, overal, altijd en op elk apparaat.

Dus veel dank aan Solidworks voor het sponsoren van educatieve inhoud zoals deze. Als je wilt weten of SOLIDWORKS en het 3DEXPERIENCE-platform voor jou kunnen werken, kijk dan op de volgende links hieronder.

Probeer 3DEXPERIENCE gratis met mijn speciale link:www.solidworks.com/HTMTryNow

Meer informatie over 3DEXPERIENCE SOLIDWORKS: www.solidworks.com/HTMLearnMore

Oké, laten we teruggaan naar het model en uitleggen hoe ik op dit ontwerp ben gekomen. Mijn doel voor de robot was om de meeste onderdelen in 3D te printen. Dus alles wat je hier ziet, kan 3D worden geprint, zelfs op een 3D-printer met een kleiner printbed. De GT2 katrollen zijn ook 3D printbaar. Ik heb parametrisch ontwerp gebruikt om ze te maken, dus indien nodig kunnen we hun maten gemakkelijk wijzigen. We hoeven alleen het aantal tanden te wijzigen en alle afmetingen worden automatisch bijgewerkt om de katrol de juiste maat te geven.

Voor de eerste verbinding hebben we een reductieverhouding van 20:1, bereikt in twee fasen met deze speciaal ontworpen katrollen. De twee GT2-riemen die ik hier gebruik, hebben een gesloten lus met een lengte van 200 mm en 300 mm. De robotverbindingen zijn samengesteld uit twee druklagers en één radiaallager.

Voor het tweede gewricht hebben we een reductieverhouding van 16:1, die op dezelfde manier wordt bereikt, en het derde gewricht heeft een reductieverhouding van 4:1 met slechts een reductie in één fase. De verbindingen zijn hol, dus die kunnen we gebruiken om de draden van de motoren en de microschakelaars door te voeren. Voor elk van de riemen zijn er sleuven waaraan we spanrollen kunnen bevestigen om ze te spannen.

De robotgrijper wordt aangedreven door een MG996R-servomotor en we kunnen de grijperuiteinden eenvoudig wisselen om verschillende grijpmaten te bereiken. De Z-as van de robot wordt aangedreven door een spindel van 8 mm, terwijl de hele armconstructie op vier gladde staven van 10 mm en lineaire kogellagers schuift. De hoogte van de robot hangt simpelweg af van de lengte van de gladde staven, in dit geval 40cm. De spindel moet 2 cm korter zijn om in deze configuratie te passen, anders kan de Z-motor 2 cm worden verhoogd met behulp van afstandsmoeren.

U kunt dit 3D-model vinden en downloaden, en het ook verkennen in uw browser op Thangs:

Download het montage 3D-model op Thangs.

STL-bestanden voor 3D-printen:

3D-printen van de robotonderdelen

Goed, dan kunnen we verder met het 3D printen van de onderdelen. Ik heb mijn Creality CR-10 3D-printer gebruikt om alle onderdelen af ​​te drukken, wat echt een geweldige 3D-printer is met een betaalbare prijs. Zoals ik al zei, zijn de onderdelen ontworpen om ook op een kleinere 3D-printer te passen, bijvoorbeeld de Ender3.

Voor de meeste onderdelen heb ik PLA+ materiaal gebruikt, het blauwe, evenals normaal PLA voor de katrollen en de grijper. Het kostte me ongeveer 120 uur om alle onderdelen af ​​te drukken met een afdruksnelheid van 60 mm/sec. De basis was het grootste deel om te printen, wat ongeveer 32 uur duurde. Als we echter de afdruksnelheid verhogen, kunnen we de onderdelen zeker sneller afdrukken.

Zie ook: Beste 3D-printers voor beginners en makers [update 2021]

Hier zijn alle 3D-geprinte onderdelen.

Even een korte opmerking hier, dat ik ze allemaal heb afgedrukt met ingeschakelde horizontale uitzetting van -0,1 mm in de snijsoftware. Hierdoor hebben de onderdelen nauwkeurigere afmetingen en passen ze beter bij de andere mechanische onderdelen zoals de lagers, de stangen en de bouten.

De robot in elkaar zetten

Hier is een lijst met componenten die nodig zijn voor het samenstellen van deze op Arduino gebaseerde SCARA-robot. De lijst voor de elektronische componenten vindt u hieronder in het gedeelte met het schakelschema van het artikel.

• 4x Gladde staafas – 10 mm 400 mm………… Amazon / Banggood / AliExpress
• 1x Loodschroef – 8 mm 400 mm  …………………… Amazon / Banggood / AliExpress
• 4x Lineaire lagers 10mm …………………..……. Amazon / Banggood / AliExpress
• 1x Stuwkracht kogellager 40x60x13mm   …..… Amazon / AliExpress
• 2x Thrust kogellager 35x52x12mm   …..… Amazon / AliExpress
• 5x Radiaal kogellager 8x22x7mm ……………. Amazon / Banggood / AliExpress
• Verschillende lengtes M3, M4 en M5 bouten en moeren

Dit zijn de benodigde bouten voor dit project:

We beginnen de montage met de basis. Hier plaatsen we eerst een radiaal kogellager met een binnendiameter van 35 mm en een buitendiameter van 47 mm.

Dan gaat het eerste druklager met een binnendiameter van 40 mm en een buitendiameter van 60 mm. Dit lager zit tussen de poelie en de basis.

Aan de andere kant van de basis gebruiken we een ander druklager van dezelfde maat samen met een verbindingskoppeling.

Dan kunnen we de poelie en het bovenste deel koppelen met behulp van vier M4-bouten met een lengte van 55 mm. We moeten hier zelfborgende moeren gebruiken en deze op de juiste manier aandraaien, zodat de verbinding stevig is en vrij kan draaien.

Vervolgens moeten we de middelste katrol installeren. Deze poelie is gekoppeld aan de gezamenlijke poelie met een 300 mm GT2-riem. Voor het installeren van deze katrol gebruiken we twee 608 kogellagers, één aan de bovenkant en de andere aan de onderkant van de basis. Vervolgens kunnen we met behulp van een M8-bout van 45 mm, een ring en een zelfborgende moer de poelie op zijn plaats vastzetten.

Vervolgens moeten we de stappenmotor voor deze verbinding installeren. De stepper wordt gekoppeld aan de middelste katrol met een riem van 200 mm. Om het aan de basis te bevestigen, hebben we vier M3-bouten nodig.

Voordat we de bouten aandraaien, moeten we de riem zo ver mogelijk strekken. Even een korte opmerking hier dat ik de M8-bout voor de middelste poelie heb vervangen met de kop aan de onderkant, zodat deze in de basis past.

Op dit punt moeten we controleren of de riemen strak genoeg zijn. Als dat niet het geval is, kunnen we enkele spanpoelies gebruiken om ze beter aan te spannen. Hier gebruik ik een 35 mm M5-bout en wat moeren om de spanrol te maken.

Het kan aan de sleuven aan beide zijden van de riem worden bevestigd en zo kunnen we de riem zo strak spannen als we willen. Uiteindelijk heb ik de riem aan beide kanten strakker gemaakt. Hiermee is de eerste verbinding voltooid.

Ik ging verder met het installeren van de microschakelaar voor deze verbinding. Voordat ik het op zijn plaats vastzette, heb ik de draden er al aan gesoldeerd, omdat het hier een beetje krap is om dat daarna te doen. We hebben 20 mm M3-bouten en een moer nodig om de microschakelaar op zijn plaats te bevestigen.

De gezamenlijke koppeling passeert zo dichtbij de schakelaar dat ik uiteindelijk maar één bout heb gebruikt om de schakelaar vast te zetten. Op het andere gat heb ik gewoon een kortere bout gestoken en aan de onderkant gelijmd. Op die manier is de schakelaar veilig genoeg en kan hij goed werken.

Ok, dus nu kunnen we beginnen met het monteren van de Z-as. Eerst moeten we bovenop de verbindingskoppeling het Z-as bodemplaatdeel vastzetten.

Daar bovenop kunnen we de vier klemmen voor de gladde staven vastzetten. Dan kunnen we de gladde staven op hun plaats plaatsen. Ze moeten strak passen en helemaal naar beneden gaan tot aan het verbindingsstuk. We kunnen dan de stangen met de klemmen vastzetten met wat M4 bouten en moeren.

Op dit punt moeten we het lager voor de spindel plaatsen. Om dit gedeelte af te maken, kunnen we gewoon een eenvoudige hoes erin schuiven die alles verbergt en de robot een schoner uiterlijk geeft.

Vervolgens kunnen we verder gaan met het monteren van de eerste arm van de robot. De arm bestaat uit twee delen die aan elkaar zijn vastgeschroefd. Het eerste deel is waar we de lineaire lagers moeten installeren die door de gladde staven zullen schuiven. Het kan een beetje moeilijk zijn om ze op hun plaats te plaatsen, omdat ze vrij strak zitten.

Dit hangt eigenlijk af van hoe nauwkeurig uw printer de onderdelen kan afdrukken. Daarom raad ik aan om de functie Horizontale uitbreiding te gebruiken bij het afdrukken van de onderdelen en deze aan te passen aan uw printer. In mijn geval kon ik niet twee van de lagers passen om helemaal naar beneden te gaan, maar dat is niet erg.

Oké, dus nu kunnen we de twee delen van de arm aan elkaar koppelen. Voor dat doel gebruiken we vier 25 mm M5-bouten.

Vervolgens kunnen we de tweede stappenmotor installeren. Hier zal ik een 3D-geprinte GT2-poelie met 20 tanden gebruiken. Ik heb deze katrol gemaakt met behulp van het parametrische ontwerp dat ik eerder noemde en het werkt best goed. Hier moeten we ook de spindelmoer op zijn plaats vastzetten.

Vervolgens kunnen we de riemen en katrollen voor het tweede gewricht installeren. Hier hebben we een riem nodig met 400 mm en een met 300 mm lengte. De procedure om ze te installeren is vrijwel hetzelfde als uitgelegd voor de eerste verbinding.

Hier gebruiken we voor het tweede en het derde gewricht kleinere lagers in vergelijking met het eerste. Het radiale kogellager heeft een binnendiameter van 30 mm en een buitendiameter van 42 mm, en het druklager heeft een binnendiameter van 35 mm en een buitendiameter van 52 mm.

Voordat we de tweede verbindingskoppeling installeren, moeten we zes 20 mm M4-bouten in de zeskantige sleuven plaatsen.

Ze zullen dienen om de tweede arm aan het gewricht te bevestigen. Indien nodig kunnen we voor het spannen van de riemen dezelfde methode gebruiken als eerder uitgelegd met spanrollen. Ten slotte heb ik de tweede microschakelaar op zijn plaats vastgezet en de montage van arm nummer één was voltooid.

Ik ging verder met het bevestigen van de tweede arm aan het verbindingsstuk. Hier gebruiken we die bouten in de verbindingskoppeling die we eerder hebben geïnstalleerd, om het bovenste deel van de tweede arm te bevestigen.

Op dit punt wilde ik testen hoeveel speling de gewrichten hadden. Natuurlijk verwachtte ik wat speling vanwege de riemen, maar er was eigenlijk veel meer speling tussen twee delen van de gewrichten. Ik merkte dat het probleem was dat de gaten waar de bouten gaan, iets groter zijn dan de bouten zelf. Om het probleem op te lossen, hebben we een strakkere pasvorm tussen de bouten en de gaten nodig.

Dus in mijn geval heb ik de gaten vergroot met een boor van 4,5 mm en M5-bouten gebruikt in plaats van de M4-bouten om de twee delen van de verbinding aan elkaar te bevestigen. Ik heb het 3D-model echter bijgewerkt, zodat de gaten 3,5 mm zijn en je de M4-bouten kunt gebruiken om deze twee delen aan elkaar te koppelen. Ik ging ook terug naar de eerste joint en deed hetzelfde. Nu is de speling in de gewrichten bijna verdwenen, behalve de kleine speling die we van de riemen krijgen.

Goed, dus nu kunnen we doorgaan met het monteren van de tweede arm. Hier moeten we eerst de stappenmotor voor het derde gewricht installeren.

Ik gebruik in dit geval een kleinere stappenmotor, zodat die arm wat lichter is. Toch is het een NEMA 17 stappenmotor maar met een kortere lengte van 24 cm.

Nogmaals, we hebben dezelfde procedure voor het installeren van de riemen en de poelie voor het derde gewricht, behalve dat we hier slechts een eentraps reductie gebruiken met een riem van 400 mm. Voordat we dit onderste deel van de arm aan het bovenste deel bevestigen, moeten we vervolgens de motor en de microschakelaar aansluiten en hun draden door het tweede gewricht leiden.

Op dit punt moeten we ook de draden voor de eindeffector plaatsen. In mijn geval heb ik een 4-aderige kabel van een stappenmotor ingebracht die ik zal gebruiken voor het aandrijven van de servomotor voor mijn grijper waarvoor 3 draden nodig zijn.

Vervolgens moeten we M4-moeren in de sleuven van de bovenarm plaatsen die dienen om het onderste deel eraan te bevestigen.

Vlak voordat we ze samenvoegen, moeten we de draden onder die haken doorvoeren, zodat ze uit de buurt van de bewegende delen blijven.

De draden die uit het tweede gewricht komen, kunnen echt vast komen te zitten door de moeren op de poelie, dus daarom heb ik een eenvoudige draadhouder gemaakt om de draden weg te houden van de moeren.

We moeten de draden zo plaatsen dat ze aan één kant van de arm lopen om contact met de bewegende delen te voorkomen. Ten slotte kunnen we de hoes van de eerste arm plaatsen.

Het deksel wordt met een klikverbinding aan de arm bevestigd. Hiermee is de montage van de robotarmen voltooid.

Dus vervolgens kunnen we dit hele samenstel in de Z-asstaven plaatsen.

Vervolgens moeten we de Z-as bovenplaat voorbereiden die de bovenste uiteinden van de staven zal vasthouden. Hier kunnen we eerst de microschakelaar voor de Z-as installeren en vervolgens de voorklemmen op de plaat bevestigen.

Voordat ik de bovenplaat plaatste, heb ik eerst een eenvoudig deksel geplaatst, net zoals hieronder, om de klemmen, de bouten en de microschakelaar te verbergen. Daarna kunnen we de bovenplaat op de stangen plaatsen en vastzetten met behulp van de klemmen.

Vervolgens moeten we de spindel op zijn plaats plaatsen.

Degene die ik had was een beetje langer, dus ik sneed het tot 38 cm met behulp van een metalen handzaag. Vervolgens kunnen we de vierde stappenmotor op zijn plaats bevestigen. Hier moeten we een askoppeling van 5 mm tot 8 mm gebruiken om de motor met de draadspil te verbinden.

Ten slotte kunnen we de draden door het deksel halen en met twee bouten aan de bovenplaat bevestigen.

Oké, nu kunnen we wat kabelbeheer doen. Ik gebruikte kabelhulzen om de draden bij elkaar te brengen en de rommel op te ruimen. Ik heb daarvoor ook wat kabelbinders gebruikt.

Voordat u de draden in de kabelhulzen plaatst, is het een goed idee om ze allemaal te markeren, zodat u niets verkeerd aansluit.

Wat nu overblijft is om de eindeffector van de robot te maken. We kunnen elke soort eindeffector maken en aan de robot bevestigen. Ik heb ervoor gekozen om een ​​eenvoudige grijper te maken die wordt aangedreven door een MG996R servomotor. De grijper is gebaseerd op twee staven van 6 mm waarop de twee zijden schuiven.

De twee glijdende zijkanten zijn verbonden met de servo met een servohoorn, enkele 3D-geprinte schakels en M3-bouten en -moeren. Ik gebruikte M3-bouten en moeren voor de hele grijpermontage. U kunt een volledige lijst met bouten en moeren vinden die nodig zijn voor dit project op het website-artikel. De ruimte voor het vastzetten van de bouten en moeren is vrij krap, dus je hebt wat zenuwen nodig om sommige van deze onderdelen te monteren.

Maar wat goed is aan dit ontwerp, is dat we de uiteinden van de grijper gemakkelijk kunnen veranderen. Ze kunnen breder of smaller zijn of ze kunnen een specifieke vorm hebben. We kunnen de grijper aan de robotarm bevestigen met behulp van enkele M4-bouten en moeren.

Ten slotte kunnen we de servomotor aansluiten op de draden die we eerder hebben geïnstalleerd.

En dat is alles, onze SCARA-robotarm is volledig gemonteerd. Wat nu nog rest, is het aansluiten van de elektronische componenten van dit project.

SCARA Robot-schakelschema

We zullen dus een Arduino UNO-bord gebruiken in combinatie met een CNC-shield en vier A4988-stappenaandrijvingen.

Hoewel het een robot is en het lijkt ingewikkelder, is dat alle elektronica die we nodig hebben voor dit project. Het is vermeldenswaard dat we in plaats van Arduino UNO ook een Arduino MEGA kunnen gebruiken in combinatie met een RAMPS 3D-printercontrollerkaart.

Desalniettemin heb ik een behuizing voor de Arduino UNO in 3D geprint die eenvoudig aan de basis van de robot kan worden bevestigd. Ik zal een kwartstapresolutie gebruiken voor het aansturen van de steppers, dus ik heb wat jumpers in de juiste pinnen geplaatst. Nu kunnen we stappenmotoren en de microschakelaars aansluiten op de CNC-afscherming.

Hier is het schakelschema van deze SCARA-robot en hoe alles moet worden aangesloten.

U kunt de componenten die nodig zijn voor dit project verkrijgen via de onderstaande links:

• Stappenmotor – NEMA 17……………… 
• A4988 Stepper-stuurprogramma………………..… 
• Arduino CNC-schild ………………………. Amazon / Banggood / AliExpress
• Arduino Uno………………………………..… 
• MG996R servomotor……………….….
• Eindschakelaar …………………………………. Amazon / Banggood / AliExpress
• DC-voeding …………………………. Amazon  / Banggood / AliExpress

Voor het aandrijven van de robot hebben we een 12V-voeding nodig die minimaal 4A kan leveren, maar ik zou een voeding van 12V 6A aanraden. Dit hangt natuurlijk af van hoe de huidige limiet van de stepper driver is ingesteld, en ik zou willen voorstellen om deze op het laagst mogelijke niveau in te stellen.

Aan het einde heb ik alle draden in de behuizing geperst, terwijl ik probeerde de koellichamen van de schijven vrij te laten, en de hoes eraan toegevoegd.

De montage afmaken

De SCARA-robot is nu voltooid en wat we nu moeten doen, is de basis ergens aan vastzetten. Voor dat doel gebruik ik een stuk hout van 20 mm. Aan de onderkant van de robotbasis hebben we 12 gaten beschikbaar om deze vast te zetten. Dus ik drukte een tekening van de robotbasis af en gebruikte die om de gaten in het hout te maken.

Aan de onderkant heb ik ze verzonken omdat ik platkopbouten zal gebruiken zodat ze flitsen met het houtoppervlak. Ik heb M4-moeren in de basissleuven gestoken en vervolgens de houten basis aan de robotbasis vastgemaakt.

Idealiter, om de robot op zijn plaats te bevestigen, kunnen we hem aan de tafel vastschroeven of ik gebruik daarvoor gewoon klemmen.

Dus dat was het, onze SCARA-robot is nu helemaal klaar. Wat je in deze video echter nog moet doen, is kijken hoe de robot werkt.

Zie ook: DIY Arduino-robotarm met smartphonebediening

Hoe de SCARA-robot werkt

Er zijn twee methoden om robots te besturen in termen van positionering en oriëntatie, en dat is het gebruik van voorwaartse of inverse kinematica.

Voorwaartse kinematica wordt gebruikt wanneer we de positie en oriëntatie van de eindeffector moeten vinden vanuit de gegeven gewrichtshoeken.

Aan de andere kant wordt inverse kinematica gebruikt wanneer we de verbindingshoeken voor een bepaalde positie van de eindeffector moeten vinden. Deze methode is logischer in robotica, omdat we meestal willen dat de robot zijn gereedschap op een bepaalde locatie of bepaalde X-, Y- en Z-coördinaten plaatst.

Met inverse kinematica kunnen we de gewrichtshoeken berekenen volgens gegeven coördinaten.

De vergelijkingen die ik zal gebruiken voor zowel de voorwaartse als de inverse kinematica komen uit trigonometrische regels en formules.

De SCARA-robot programmeren - Arduino en verwerkingscode

Onderaan het artikel vind je zowel de Arduino als de Processing codes.

Zo zien de vergelijkingen eruit in een code, geschreven in de ontwikkelomgeving Processing.

// 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));
}Code language: Arduino (arduino)

Met voorwaartse kinematica berekenen we dus de X- en Y-waarde van de eindeffector, volgens de ingestelde gewrichtshoeken van de twee armen van de robots, theta1 en theta2, evenals hun lengtes L1 en L2.

Aan de andere kant berekenen we met inverse kinematica de gewrichtshoeken, theta2 en theta1, volgens de gegeven positie of de X- en Y-coördinaten.

/ 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);
}Code language: Arduino (arduino)

Afhankelijk van in welk kwadrant de positie is ingesteld, passen we de gewrichtshoeken aan met deze 'als'-statements. Voor deze configuratie van de robot berekenen we eigenlijk inverse kinematica met slechts twee schakels. De derde hoek die ik "phi" noem, wordt gebruikt om de oriëntatie van de grijper in te stellen.

De grafische gebruikersinterface is gemaakt met behulp van de controlP5-bibliotheek voor de verwerkings-IDE. Met deze bibliotheek kunnen we eenvoudig knoppen, schuifregelaars, tekstvelden enzovoort maken.

We gebruiken bijvoorbeeld de schuifregelaars aan de linkerkant om de gewrichtshoeken te regelen en met behulp van de tekstvelden kunnen we de positie invoeren waar we onze robot willen hebben. Bij elke actie die we hier met het programma ondernemen, sturen we gegevens naar het Arduino-bord via de seriële poort.

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);
    }
  }Code language: Arduino (arduino)

Deze gegevens omvatten de gewrichtshoeken, de grijperwaarde, snelheids- en acceleratiewaarden en indicatoren om te weten of we op de knop Opslaan of Uitvoeren hebben geklikt.

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);
}Code language: Arduino (arduino)

Al deze gegevens komen als één lange string bij de Arduino. Dus hier moeten we eerst de gegevens uit die string halen en in aparte variabelen plaatsen.

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
    */Code language: Arduino (arduino)

Met deze variabelen kunnen we nu acties ondernemen met de robot. Als we bijvoorbeeld op de SAVE-knop drukken, slaan we de huidige gewrichtshoekwaarden op in een aparte array.

// 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++;
    }Code language: Arduino (arduino)

Als we op de RUN-knop klikken, voeren we de opgeslagen stappen uit, enzovoort.

Voor het aansturen van de stappenmotoren heb ik de AccelStepper-bibliotheek gebruikt. Hoewel dit een geweldige bibliotheek is om meerdere steppers tegelijkertijd te besturen, heeft het enkele beperkingen als het gaat om het besturen van een robot als deze. Bij het aansturen van meerdere steppers kan de bibliotheek geen versnelling en vertraging implementeren, die belangrijk zijn voor een soepelere werking van de robot.

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();
  }Code language: Arduino (arduino)

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:

Wrap up

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.

Stel gerust een vraag in de opmerkingen hieronder en bekijk mijn Arduino Projects-collectie.