Ioed gebruiken om een ​​robotarm op afstand te bedienen

Over dit project

Inleiding

Ik wilde echt proberen om een ​​robotarm helemaal opnieuw te ontwerpen. Er zijn veel open source-ontwerpen beschikbaar, maar ik dacht dat het leuk zou zijn als ik er een vanuit het niets kon ontwerpen, bouwen en programmeren (en dat was het ook).

Ik zal het hebben over zowel de ontwerp- als de programmeerfase. Maar ik zal me meer concentreren op de programmeerkant, omdat het niet alleen de servo-hoeken bestuurt.

Hier is een link naar een video van het uiteindelijke project in actie - https://www.mathworks.com/videos/how-to-control-a-robotic-arm-from-a-remote-location-using-iot-1538564659095. html.

Ik heb Simulink gebruikt om een ​​Arduino MKR1000 te programmeren, de MCU die de robotarm bestuurt. Vervolgens heb ik de mogelijkheid toegevoegd om de robotarm vrijwel overal te besturen via ThingSpeak, een open IoT-platform met MATLAB-analyse.

Hardware nodig

• 15” x 20” 1/8-inch multiplex

• Arduino MKR1000

• 5x GS9025MG-servo

• 2,1 mm breadboard-vriendelijke DC-cilinderaansluiting

• 6 V DC barrel jack-voeding

• Jumperdraden

• 3x 2n2222a Transistors

• 10x M2 moeren

• 10x M2 x 10 schroeven

• 40x M3-moeren

• 40x M3 x 25 schroeven

Gebruikte software

• MATLAB

• Simulink

• MATLAB-ondersteuningspakket voor Arduino-hardware

• Simulink-ondersteuningspakket voor Arduino-hardware

• MATLAB-ondersteuningspakket voor ThingSpeak

Ontwerp

Ik wilde de kosten van onderdelen laag houden, dus ontwierp ik dit voor hobbyservo's, met name het GS-9025MG-model. Dit betekende dat het uiteindelijke gewicht en de grootte beperkt waren. Dit kwam omdat micro-servo's niet veel koppel konden uitoefenen en als gevolg daarvan geen zware hefboomarmen konden optillen.

Ik probeerde een prototype te maken met 1/4 inch multiplex, wat te zwaar bleek te zijn voor de servo's. Ik verkleinde de lengte van de armen en gebruikte multiplex van 1/8 inch, en dat loste het probleem met de servobesturing op. Ik heb het ontwerp gemaakt met Fusion 360 en het ontwerp gedownload als a.dxf-bestand, dat ik vervolgens heb uitgesneden.

Ook bleek het leveren van continue gelijkspanning vanuit een stopcontact noodzakelijk omdat de stroom die uit accu's werd getrokken erg hoog was en ze zeer snel leegliepen.

Wat betreft het aansturen van de motoren, de Arduino MKR1000 heeft 4 PWM-pinnen, maar ik had er 5 nodig om de 5 servo's te besturen. Ik werd creatief en gebruikte één PWM-pin om 2 servo's te besturen en een digitale pin om tussen de twee servo's te schakelen en één voor één te bedienen.

Hier is het circuit dat dat beschrijft:

Hier is de bedrading van de servo's naar de Arduino:

Programmeren

Er waren twee delen van de programmering, de prototypingfase waarin ik het assembleerde en de servo's naar een bepaalde locatie liet sturen, en de precieze besturingsfase waarin ik een locatie naar de servo kon sturen met behulp van ThingSpeak.

Prototyping

Met behulp van schuifregelaars en constante blokken kon ik de servo's op de Arduino opdracht geven om naar bepaalde hoeken te gaan. Ik heb dit model gebruikt om de vooroordelen tussen de opgedragen hoek en de werkelijke hoeken van de arm te achterhalen, evenals het bereik van toegestane hoeken voor elke servo.

De blokken met het tandwiel erop zijn de PWM-schrijfblokken voor het besturen van de service tot een bepaalde hoek tussen 0 en 180.

Ik heb inverse kinematica gebruikt voor een arm in 2D-vlakke beweging om de hoeken op te lossen die nodig zijn om de arm naar een XY-coördinaat te verplaatsen. Ik ontdekte dat deze link de kinematica vrij goed uitlegt:https://appliedgo.net/roboticarm/

Nauwkeurige controle

Hoewel dit er ingewikkelder uitziet dan de andere, is de logica nog steeds hetzelfde. De uitgangsblokken zijn nog steeds de servoschrijfblokken met de tandwielen. De invoerblokken zijn nu niet de schuifregelaar/constante blokinvoer, maar worden gelezen van het ThingSpeak-kanaal. Ik zal later ingaan op het gebruik van ThingSpeak. De ingangen zijn de X- en Y-positie van de arm, die met behulp van het loc2angles MATLAB-functieblok worden geconverteerd naar opgedragen hoeken voor de arm. Het angles2loc-blok bovenaan het model is slechts een manier om het systeem te controleren om ervoor te zorgen hoeken vertaald naar de juiste invoerpositie met behulp van voorwaartse kinematica. Een van de coole tools van Simulink die ik in dit project heb gebruikt, is Externe modus . Hierdoor kon ik het systeem in de gaten houden terwijl het op de Arduino zelf draaide.

De blokken met de grijze wolk erop zijn het ThingSpeak-leesblok dat is ingebouwd in het Simulink-ondersteuningspakket voor Arduino. Ik voer de kanaal-ID in, het gegevensveldnummer dat ik wil ophalen en de API-leessleutel, en het geeft de gegevens van dat kanaal en veld weer. Maak je geen zorgen, als je niet bekend bent met een van deze termen, zal ik het binnenkort uitleggen.

ThingSpeak gebruiken:een kanaal maken en gebruiken

1. Ga naar https://thingspeak.com/

2. Klik op 'aanmelden' in de rechterbovenhoek en log in met uw gratis MathWorks-account.

3. Klik op de dashboardpagina op 'Nieuw kanaal'

4. Vul de gegevens in zoals hieronder. De getoonde gegevens zijn alles wat u hoeft in te vullen.

5. Klik onderaan op 'Kanaal opslaan'

6. Je hebt nu een ThingSpeak-kanaal gemaakt

7. In het MATLAB-opdrachtvenster of met behulp van de MATLAB mobiele app, kunt u opdrachten invoeren die eruitzien als:thingSpeakWrite(chID, [0.6963.94 -12 0 0], 'WriteKey', APIKEY, 'Fields', [1 2 3 4 5]);

Dit schrijft nieuwe gegevens naar de opgegeven velden in het ThingSpeak-kanaal. U kunt de waarden in het tweede argument van de functieaanroep wijzigen om de waarde van het corresponderende veld te wijzigen. Na het wijzigen van de waarden, zouden de kanaalgegevens er als volgt uit moeten zien:

Het model besturen

Wanneer u klaar bent met het instellen van het ThingSpeak-kanaal, kunt u het model op de Arduino in externe modus uitvoeren of door de hardware te implementeren. Ga in het Simulink-model naar 'Modelconfiguratieparameters' door op het kleine tandwiel in het bovenste menupaneel te klikken, selecteer 'Hardware-implementatie' en zorg ervoor dat het 'Hardwarebord' de Arduino MKR 1000 is. Onder 'Target Hardware Resources' in hetzelfde tabblad, klik op WiFi-eigenschappen en voer de WiFi-inloggegevens in om toegang te krijgen tot het netwerk.

Klik op de groene knop Uitvoeren om het model in de externe modus uit te voeren of op de blauwe knop Implementeren om het op hardware te implementeren.

Zodra het model draait, kun je nieuwe gegevens naar de velden in het ThingSpeak-kanaal schrijven vanuit MATLAB of MATLAB mobiel op je telefoon en kijken hoe het je robotarm beweegt!

Code

https://www.mathworks.com/matlabcentral/fileexchange/68880-controlling-a-robotic-arm-from-anywhere-using-iot