Externe IoT-besturing van een zelfgebouwde robotarm

Onderdelen en benodigdheden

Benodigde tools en machines

• Lasersnijder (standaard)

Apps en online services

• MATLAB
• Arduino IDE

Over dit project

Inleiding

Ik wilde graag een robotarm volledig vanaf nul ontwerpen. Er zijn veel open-source ontwerpen beschikbaar, maar ik vond het bevredigend om er een te ontwerpen, bouwen en programmeren vanaf het begin (en dat was het ook).

Ik bespreek zowel de ontwerp- als de programmeerfase, maar focus meer op de programmering omdat het niet alleen om het sturen van servo-hoeken gaat.

Hier is een video van het eindresultaat: Robotarm besturen via IoT.

Ik gebruikte Simulink om een Arduino MKR1000 te programmeren, de microcontroller die de robotarm stuurt. Vervolgens voegde ik de mogelijkheid toe om de robotarm vanaf praktisch overal te besturen via ThingSpeak, een open IoT-platform met MATLAB-analytics.

Benodigde hardware

• 15" x 20" 1/8-inch multiplex
• Arduino MKR1000
• 5x GS9025MG servo
• 2.1mm breadboard-voedingsconnector
• 6V DC voeding
• Draadbruggen
• 3x 2n2222a Transistors
• 10x M2 moeren
• 10x M2 x 10 schroeven
• 40x M3 moeren
• 40x M3 x 25 schroeven

Gebruikte software

• MATLAB
• Simulink
• MATLAB Support Package voor Arduino Hardware
• Simulink Support Package voor Arduino Hardware
• MATLAB Support Package voor ThingSpeak

Ontwerp

Ik wilde de kosten laag houden, dus ontwierp ik voor hobby-servo's, specifiek het GS-9025MG-model. Dit beperkte het eindgewicht en de afmetingen, omdat microservo's niet veel koppel kunnen leveren en zware hefboomarmen niet kunnen tillen.

Ik probeerde te prototypen met 1/4-inch multiplex, wat te zwaar bleek voor de servo's. Ik verkorte de armlengtes en gebruikte 1/8-inch multiplex, wat het servo-probleem oploste. Ik tekende het ontwerp in Fusion 360, exporteerde als .dxf-bestand en lasersnde dit.

Continue DC-spanning vanuit een stopcontact was noodzakelijk omdat de stroom die batterijpakketten leverden te hoog was en ze snel leegliepen.

Voor de motorbesturing: de Arduino MKR1000 heeft 4 PWM-pinnen, maar ik had 5 nodig voor de 5 servo's. Ik werd creatief en gebruikte één PWM-pin om 2 servo's te sturen en een digitale pin om tussen de twee te schakelen en ze één voor één te besturen.

Programmering

Er waren twee programmeerfasen: de prototypingfase waarin ik de arm samenstelde en de servo's liet bewegen naar een bepaalde positie, en de nauwkeurige besturingsfase waarin ik een locatie kon opdragen aan de servo via ThingSpeak.

Prototyping

Met schuifregelaars en constant-blokken kon ik de servo's op de Arduino opdragen om naar bepaalde hoeken te bewegen. Ik gebruikte dit model om de afwijkingen tussen de opgegeven hoek en de werkelijke hoeken van de arm te bepalen, evenals het bereik van toelaatbare hoeken per servo.

De blokken met het tandwieltje zijn de PWM-schrijfblokken voor het sturen van de servo naar een hoek tussen 0 en 180 graden. Ik gebruikte inverse kinematica voor een arm in 2D-planaire beweging om de benodigde hoeken te berekenen om de arm naar een XY-coördinaat te bewegen. Deze link legt de kinematica goed uit: appliedgo.net/roboticarm.

Nauwkeurige besturing

Hoewel dit model er ingewikkelder uitziet, is de logica dezelfde. De uitvoerblokken zijn nog steeds de servo-schrijfblokken met tandwieltjes. De invoerblokken zijn nu geen schuifregelaars/constanten meer, maar worden gelezen uit het ThingSpeak-kanaal. De invoeren zijn de X- en Y-positie van de arm, die via de MATLAB-functieblok loc2angles worden omgerekend naar opgegeven hoeken voor de arm. Het angles2loc-blok bovenaan is slechts een manier om het systeem te monitoren en te verifiëren dat de servo-hoeken de juiste invoerpositie vertalen via forward kinematica.

Eén van de coole Simulink-tools die ik gebruikte is External Mode. Hiermee kon ik het systeem monitoren terwijl het op de Arduino draaide.

De blokken met de grijze wolk zijn de ThingSpeak-leesblokken ingebouwd in het Simulink-ondersteuningspakket voor Arduino. Ik voer het kanaal-ID, het dataveldnummer dat ik wil ophalen, en de API-leessleutel in, en het blok geeft de data uit dat kanaal en veld.

ThingSpeak gebruiken: Kanaal aanmaken en gebruiken

1. Ga naar thingspeak.com
2. Klik rechtsboven op 'Sign in' en log in met je gratis MathWorks-account.
3. Op het dashboard klik op 'New Channel'.
4. Vul de gegevens in (zoals in de afbeelding getoond).
5. Klik onderaan op 'Save channel'.
6. Je hebt nu een ThingSpeak-kanaal aangemaakt.
7. In het MATLAB-commando-venster of via de MATLAB mobile app kun je commando's invoeren zoals:
   thingSpeakWrite(chID, [0.6963.94 -12 0 0], 'WriteKey', APIKEY, 'Fields', [1 2 3 4 5]);
   Dit schrijft nieuwe data naar de gespecificeerde velden in het ThingSpeak-kanaal. Je kunt de waarden in het tweede argument wijzigen om de waarde van het bijbehorende veld te veranderen.

Het model draaien

Als het ThingSpeak-kanaal ingesteld is, kun je het model op de Arduino draaien in External Mode of deployen naar de hardware. In het Simulink-model, ga naar 'Model Configuration Parameters' (kleint tandwieltje in de bovenste balk), selecteer 'Hardware Implementation' en zorg dat 'Hardware Board' de Arduino MKR1000 is. Onder 'Target Hardware Resources', klik op WiFi-eigenschappen en voer de WiFi-gegevens in.

Klik op de groene run-knop voor External Mode of de blauwe deploy-knop om naar de hardware te deployen. Zodra het model draait, kun je vanuit MATLAB of MATLAB Mobile op je telefoon nieuwe data naar de velden in het ThingSpeak-kanaal schrijven en kijken hoe de robotarm reageert!

Code

MATLAB Central File Exchange – Robotarm besturen via IoT