[WIP] Een Drawbot maken die wordt bestuurd door een Myo-armband: 11 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

Hallo allemaal!

Een paar maanden geleden besloten we om het idee aan te pakken om een open-frame drawbot te bouwen die alleen een Myo-band gebruikte om hem te besturen. Toen we voor het eerst aan het project begonnen, wisten we dat het in een aantal verschillende fasen moest worden opgedeeld. Onze eerste hoofdfase was om te proberen ons hoofd rond een open frame-ontwerp voor onze tekenbot te wikkelen. Dit is een niet-standaard opstelling en we wilden zien wat de voordelen van dit ontwerp waren.

Ten tweede wisten we dat het bouwen van dit prototype alleen voor onszelf nuttig zou zijn. Ons ontwerp en plan was om ons laatste frame in metaal te verplaatsen en met behulp van een arduino onze positie te ontvangen van de versnellingsmeter en gyroscoop die in de Myo-band zijn ingebouwd. Die informatie zou dan naar de motoren worden gestuurd en de beweging van de gebruiker nabootsen. We wisten dat hierdoor onze tweede fase zou uitbreken in drie hoofdaspecten:

1. programmeren van Myo naar motoren, via de Arduino
2. elektrisch ontwerp om onze gegevens in beweging te vertalen
3. mechanisch ontwerp om een redelijk groot frame te creëren dat onze beweging zal vergemakkelijken

Elk lid van ons team voelde zich het meest op zijn gemak bij een uniek onderdeel van ons ontwerpproces, dus besloten we om ons werk onder elke persoon te verdelen. We hielden ook een blog bij tijdens ons hele ontwerpproces om ons dagelijkse denken bij te houden, in plaats van een meer globale look.

Stap 1: Wat we van plan waren te doen?

Ons doel was om deze twee producten te combineren op een manier die we nog niet eerder hebben gebruikt. We wilden een live relais maken tussen onze Myo-armband en onze eigen versie van een ontwerp geïnspireerd op AxiDraw van Evil Mad Scientist.

Stap 2: Prototype ingrediëntenlijst

2 2 x 4 houten planken 1 Riem of ketting van >= 65” 4 Houten spijkers 3 Tandwielen met tanden die passen op de riem of ketting 4 3 x 8 vex geperforeerde platen 30 ⅜” Rubber afstandhouders 8 1” diameter ringen 1 1” diameter houten deuvel 1' lang 8 Vex-schroeven 1”8 ½” Vex-schroeven 8 2” Vex-schroeven 8 ¼” Rubberen afstandhouders 48 Vex-moeren 1 Kleine ritssluiting

Stap 3: [Prototype] Houtbewerking Onze armen en koetsinterieur

We pakten twee 2x4's en sneden ze op gelijke lengtes (33 ¼ )

Met behulp van een tafelzaag maakten we een inkeping langs het smalle deel van de planken ¼” diep en ⅛” breed in het midden

Snijd de plug in 4 stukken van 2 "en boor een gat in het midden van de plug met een diameter van ongeveer ¼" met behulp van een kolomboormachine

Stap 4: [Prototype] Onze koets maken

In het ideale geval zouden we twee 7x7 stukken vex geperforeerd staal gebruiken, maar alles wat we tot onze beschikking hadden waren de 2x7 strips, dus we hebben ze aan elkaar vastgeschroefd in een "X" -configuratie

Stapel 5 van de ⅜” rubberen afstandhouders en bevestig de hoeken van de vexplaten aan elkaar

Maak de houten deuvels losjes vast zoals weergegeven in figuur 1, zodat ze vrij ronddraaien met ongeveer 5 cm ruimte ertussen. Gebruik de afbeelding om te zien waar de tandwielen moeten worden geplaatst op dit punt hebben we ringen gebruikt, maar later ontdekten we dat kleine plastic tandwielen beter werken.

Gebruik de ½ "vex-schroeven, ¼" rubberen afstandhouders en ringen met een diameter van 1 inch om de ringen in een verhoogde positie te bevestigen zoals weergegeven in afbeelding 1 (we gebruikten groene plastic tandwielen omdat we de juiste ringen niet konden vinden) en zorg ervoor dat de ringen in staat zijn om gemakkelijk te draaien en in de inkepingen van het bord te passen.

Stap 5: [Prototype] Alles bij elkaar brengen

Plaats een plank op een oppervlak en schuif de wagen naar het midden zodat de ringen de wagen boven de plank houden en aan weerszijden van de plank de tandwielen vastspijkeren zodat ze vrij kunnen ronddraaien. Spijker een tandwiel aan het ene uiteinde van het tweede bord en zorg ervoor dat het gecentreerd is en schuif het op de wagen loodrecht op het eerste bord.

Nu moet de riem door het systeem worden gelust zoals afgebeeld, let goed op hoe de deuvels zich aan de buitenkant van de riem bevinden en of er niets in het midden van het chassis is dat de riem zou kunnen hinderen terwijl deze beweegt.

Nu moet de riem worden vastgemaakt aan de kant van het bord die geen versnelling heeft. We gebruikten een extra spijker en ritssluiting om de onze vast te maken. Maar de gebruikte methode maakt niet uit, zolang de riem maar op die plek verankerd is

Stap 6: [Prototype] Klaar en in beweging

Dat zou het moeten zijn, trek aan de riem in verschillende combinaties en zie de verschillende effecten die het heeft op de arm!

Stap 7: Ons model vertalen naar ons voltooide ontwerp

Toen we ons prototype eenmaal hadden voltooid, waren we extatisch. Niemand van ons wist zeker hoe het systeem werkte voorafgaand aan de montage. Maar toen onze onderdelen eenmaal bij elkaar kwamen, ontdekten we al snel wat we leuk vonden en hoe we het zouden verbeteren bij het maken van het definitieve ontwerp. Onze belangrijkste klachten over het op te lossen systeem waren:

1. Schaal

   1. Ons prototype was enorm en onhandelbaar, waardoor het vatbaar was voor kantelen aan de rand van onze armen
   2. De koets was veel groter dan nodig was en er was veel verloren ruimte
   3. Onze riem (een vex tankloopvlak) was veel groter dan nodig was, waardoor er extra ruimte tussen de armen ontstond

2. Wrijving

   1. Onze vex-loopvlakken gingen niet op alle punten gemakkelijk over de houten deuvelrollen
   2. Door plastic op hout wilde de koets in veel gevallen niet bewegen

3. Motoriseren

   We moesten het systeem stroomvaardig maken

Met deze zaken in het achterhoofd tekenden we onze plannen voor het definitieve ontwerp. We wilden dat de drawbot bestuurd zou worden met een Myo via een arduino, en we wilden het frame aluminium en kleiner maken.

Om dit te doen, hebben we een percentage van ons oorspronkelijke prototype genomen en zijn we vanaf dat formaat aan de slag gegaan. Door plaatstaal te gebruiken dat machinaal zou worden bewerkt om kanalen te hebben die breed genoeg zijn om een afgeschermd lager door te laten, zouden we een licht maar robuust ontwerp hebben dat een hogere gebruikstolerantie zou hebben.

Ons prototype stelde ons ook in staat om in slechts een paar minuten te bepalen hoe de motorrotatie de kop van onze drawbot beïnvloedde. Dit bracht ons ertoe te begrijpen dat ons besturingsontwerp eenvoudiger zou zijn dan we hadden verwacht. Bij nadere inspectie kwamen we erachter dat de beweging van de motor additief is! Dit betekent dat elke motor een onafhankelijk gewenst effect heeft op onze beweging, maar wanneer we ze samen combineren, beginnen ze op te heffen.

Als het bijvoorbeeld als een coördinatenvlak wordt beschouwd, zal de motor die in het negatieve x-uiteinde ligt altijd de neiging hebben om onze lade in het tweede en vierde kwadrant te trekken. Omgekeerd zal de motor die op het positieve x-uiteinde ligt, de lade altijd naar het eerste en derde kwadrant neigen. Als we de beweging van onze motoren combineren, annuleert het de delen van het sturen van dat conflict, en versterkt het de delen die overeenkomen.

Stap 8: Coderen

Hoewel ik een paar jaar geleden redelijk uitgebreid in C werkte, had ik geen ervaring met lua of C++, en dit betekende dat ik een aanzienlijke hoeveelheid tijd moest besteden aan het doorzoeken van documentatie. Ik wist dat de algemene taak die ik zou proberen te volbrengen was om met tussenpozen de positie van de gebruiker te bepalen en deze vervolgens door te geven aan de motoren. Ik besloot de taak voor mezelf op te splitsen om de onderdelen die ik nodig had beter te verteren.

1. Krijg gegevens van Myo (lua)

Ik wist dat ik een manier moest bedenken om de informatie van de Myo te verzamelen. Dit was het eerste deel van de uitdaging die ik wilde aangaan. Om dit te doen, wilde ik dat de gebruiker zijn canvasgrootte kalibreerde voordat hij begon te tekenen. Hierdoor zou ik een grens hebben om vanuit te werken. Ik zou dan het programma tussen verschillende gebruikers kunnen normaliseren door simpelweg een percentage van het maximale canvas te nemen als mijn gegevenspunten om door te geven. Ik besloot om een scriptgebeurtenis te hebben die elke halve seconde een getOrientation-controle zou uitvoeren, omdat de controles hierdoor nooit een wilde sprong zouden maken waarvan je zou moeten raden (bijvoorbeeld als de gebruiker wild terugzwaaide en vooruit).

Dit maakte de eerste wegversperring die ik raakte. Ik ontdekte een zeer grote beperking van lua, en dat het me niet zou toestaan om te wachten voordat ik verder ging met het script. De enige manier om deze actie uit te voeren was om ofwel de CPU te pauzeren (waardoor het globaal zou worden onderbroken, zelfs de systeemklok zou worden vastgehouden), of door OS-specifieke opdrachten te gebruiken. In mijn voorbeeldcode heb ik de oorspronkelijke OS-controle achtergelaten die ik heb uitgevoerd (opgemerkt). Dit was na een grote hoeveelheid onderzoek in de documentatie van lua en werd gedaan door de opmaak van het systeempad te controleren. Dit was het moment waarop ik besloot dat ik de documentatie moest bekijken voor projecten die eerder waren gepubliceerd. Ik realiseerde me meteen hoeveel tijd ik verspilde en werd meteen naar de platformvariabele geleid. Hiermee kon ik vrijwel onmiddellijk OS-specifieke wachtcommando's implementeren, in tegenstelling tot de dagen die ik nodig had om mijn vorige oplossing in elkaar te flansen.

Het was rond deze tijd van ontwerp dat het werk aan het elektrische aspect begon, en ik heb het werk aan dit aspect van de code opgeschort. De bedoeling is om te leren hoe onze motoren zijn gekoppeld aan de Arduino.

2. Werken rond de Arduino (C++)

Toen het werken met ons breadboard steeds complexer werd, kwam ik erachter dat de arduino niet in staat was tot multithreading. Dit was een grote sleutel in mijn oorspronkelijke codeontwerp, en nadat ik meer had gelezen over de beperkingen van onze controller, kwam ik erachter dat ik zou moeten programmeren hoe de arduino tussen de twee zou schakelen. Dit werd de focus van mijn inspanningen toen onze deadline naderde. Ik moest grote delen van mijn originele script schrappen omdat ze waren ontworpen om gegevens naar een bestand te schrijven synchroon met de motorcontroller die het bestand las. Dit was om een wachtrijfunctie mogelijk te maken om ervoor te zorgen dat zelfs als de gebruiker onze lade voor was, dit het project niet zou verpesten.

Ik besloot dat de wachtrijfunctie moest worden opgeslagen, zo niet op dezelfde manier geïmplementeerd als voorheen. Om dit te doen, heb ik een vector van arrays gemaakt. Hierdoor kon ik niet alleen de geest van mijn vorige ontwerp relatief intact houden, het betekende ook dat ik mijn plaats in het dossier niet hoefde bij te houden voor lezen of schrijven. In plaats daarvan hoefde ik nu alleen maar een nieuwe waarde aan mijn vector toe te voegen als de gebruiker in beweging was (voorlopige tests waren minder dan 1% van het verschil in canvasgrootte in zowel x als y vanaf de laatste geregistreerde positie resulteerde in geen opname van gegevens). Ik zou dan de oudste waarde in mijn vector kunnen nemen en in één klap naar de motorbesturing sturen, het naar ons bestand schrijven en het dan uit mijn vector verwijderen. Dit heeft veel van mijn zorgen weggenomen over het hebben van een constante IO-stream.

Stap 9: Elektrisch

Terwijl ik in het verleden een elektronicales heb gevolgd en behoorlijk wat met arduino's heb gewerkt. Ik heb nooit diep gedoken om de arduino informatie te laten ontvangen van een externe bron (myo), ik heb alleen ervaring met het uitvoeren van informatie via de arduino. Ik begon echter de motoren op onze drawbot te bedraden en werkte aan code zodat ze met de myo-code konden werken.

Materialen die ik heb gebruikt:

2 x Stappenmotoren

1 x Breadboard

1 x Arduino (Uno)

2 x stuurprogramma-IC L293DE

40 x jumperdraden

2 x ventilatoren

1. Stappenmotoren en de ventilator aansluiten op het breadboard

Volgens het schakelschema kunnen we één stappenmotor aansluiten op de driver op het breadboard. Vervolgens, volgens hetzelfde diagram, geldt dat voor de tweede driver en motor, maar de jumperdraden moeten worden aangesloten op een andere set pinnen in de Arduino (aangezien de eerste motor de ruimte inneemt van 4 anderen).

Waarschuwing/Tip:

De drivers zijn erg klein en de pinnen zitten erg dicht bij elkaar. Het zou verstandig zijn om de twee stuurprogramma's uit elkaar te plaatsen, zodat de draden niet verwarrend worden.

Het volgende is om de ventilatoren te bedraden. Dit is vrij eenvoudig, de ventilatoren die ik beschikbaar had, waren standaard computerprocessorventilatoren, die een positieve en grond hebben. Steek die twee in hun respectievelijke +/- pinnen op het breadboard en draai ze elk naar elke driver. (We ontdekten dat, omdat de stappenmotoren gedurende een lange periode uitbarstingen van informatie en opdrachten ontvangen, de stuurprogramma's de neiging hebben oververhit te raken en te stinken. Door een ventilator toe te voegen om het af te koelen, werd dit probleem opgelost).

2. Arduino-code

Dit is het makkelijke gedeelte!

Open de Arduino IDE, ga naar het tabblad "Bestand" en ga vervolgens naar het tabblad "voorbeeld" dat nog verder naar beneden zal vallen en u een "stepper" -tabblad laat zien. Vervolgens wilt u "Stepper_OneStepAtATime" openen

Hiermee wordt een voorbeeldcode vooraf geladen die bijna plug-and-play is voor de arduino / motorbedrading. We zullen kleine aanpassingen moeten doen omdat we twee motoren gaan gebruiken, die ik hieronder zal laten zien. Mogelijk moet u ook kleine aanpassingen maken, afhankelijk van welke pinnen u hebt besloten te gebruiken, aangezien de Arduino IDE standaard is ingesteld op pinnen 8-11.

De code die ik heb gebruikt om de twee motoren "sync" te laten bewegen, staat hieronder:

//#erbij betrekken

const int stepsPerRevolution = 200;

Stepper myStepper1(stepsPerRevolution, 9, 10, 11, 12);

Stepper myStepper2(stepsPerRevolution, 4, 5, 6, 7);

int stepCount = 0;

void setup () {// initialiseer de seriële poort: Serial.begin (9600); }

lege lus() {

mijnStepper1.stap(1);

Serial.print("stappen:");

Serial.println(stepCount);

stepCount++;

vertraging (0,5);

mijnStepper2.stap(1); vertraging (0,5); }

3. Mogelijke problemen

Problemen die ik tijdens dit proces tegenkwam, waren het niet gebruiken van het juiste codevoorbeeld, het gebruik van een slechte jumperdraad, het gebruik van het verkeerde stuurprogramma-IC.

Zorg ervoor dat uw stuurprogramma dat u gebruikt een motor kan besturen

Controleer het serienummer en controleer de specificaties

Ik kwam een probleem tegen met een dode jumperdraad, waardoor mijn motoren vreemd gingen draaien

Ik moest een multimeter gebruiken om elke draad te controleren

En controleer uw code altijd dubbel op kleine fouten, zoals het missen van een einde ";" opdracht

Stap 10: Mechanisch

1. Materiaal:

Voor het volledige productiemodel van de armen wordt aanbevolen dat ze zijn gemaakt van sterk en toch lichtgewicht materiaal, we vonden dat aluminium een perfecte pasvorm was.

We gebruikten 032 gauge aluminiumplaten gesneden tot 9,125 "x 17,5" en volgden het patroon van de tekening die in de vorige stap werd getoond.

2. Fabricage:

Met behulp van de zoom (de blauwe machine) hebben we zomen toegevoegd die in tegengestelde richting wijzen, zodat wanneer het stuk wordt gebroken en gevouwen, de twee zomen in elkaar grijpen en een enkel compleet stuk vormen.

Voor de grote bochten gebruikten we de tennismith, vanwege zijn hoge precisie.

Voor de kleinere bochten wil je een machine met een kleinere voet gebruiken, dit is waar een machine zoals de roto-die om de hoek komt kijken. Door zijn kleinere voet kunnen er helaas kleinere pauzes worden gemaakt, de roto-die tot onze beschikking was nog steeds te groot voor onze rail en het was vervormd.

**Als alternatief, als u niet over de juiste apparatuur of gereedschappen beschikt, kan een vervanging worden gemaakt.**

In ons geval hebben we onze armen uit aluminium zonnepaneelrails gesneden met behulp van een plasmasnijder en de uiteinden glad geslepen en vervolgens rug aan rug vastgeschroefd om een dubbelzijdig railsysteem te maken. In het ideale geval zouden we de rails aan elkaar willen lassen, maar zonder toegang tot een lasstation hebben we in plaats daarvan de rails aan elkaar geklemd en doorboord en vervolgens aan elkaar vastgeschroefd. Maar als deze route wordt gevolgd, moet er speciaal op worden gelet dat een borgmoer en sluitring worden gebruikt om ervoor te zorgen dat het stuk zo min mogelijk buigt.

3. De riem

Voor de banden hebben we oude 3D-printerbanden gebruikt die we konden redden.

De riemen waren aanvankelijk niet lang genoeg, dus met behulp van wat krimpkous hebben we twee stukken gecombineerd om er een te maken die voldoende lang zou zijn.

De groene tandwielen en houten deuvels werden vervangen door schijflagers met extra brede ringen die werden gebruikt om te voorkomen dat de riem wegglijdt.

4. Vervoer:

En tot slot was de wagen gemaakt van een 5" x 5" plaat van 032 aluminium, met gaten geboord waar de corresponderende schroeven en ringen bedoeld zijn om te gaan. De afstand is afhankelijk van hoe breed uw rail is en hoeveel ruimte u op uw ringen hebt.

Stap 11: Reflecties

Helaas liep elke kant van ons project op de grote barricade van de tijd en konden we ons ontwerp niet op onze streefdatum voltooien. Elk lid van ons team werkte uiteindelijk tot op zekere hoogte samen in elk ander aspect van ons ontwerp, wat leidde tot een aantal leercurves die de tijd vergaten. Dit, in combinatie met de wens om een product te ontwerpen met zo min mogelijk externe middelen (omdat we allemaal onze respectieve onderdelen helemaal opnieuw wilden maken), leidde tot een groot aantal opnieuw uitgevonden wielen.

Iedereen die aan het project meewerkte, leerde meer over de andere aspecten van het project. Software een specifieke handeling laten uitvoeren is één ding, software laten samenwerken met hardware is iets anders. Ik zou zeggen dat het belangrijk is dat iedereen die aan het coderingsaspect van dit project werkt, net zo bekend is als onze projectcoder.

Al met al hebben we niet precies kunnen bereiken wat we wilden. Ik heb echter het gevoel dat we op de goede weg waren en we hebben allemaal nieuwe concepten ontdekt en geleerd die we kunnen toepassen op toekomstige projecten.