Robotarm: Jensen: 4 stappen

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

Jensen is een robotarm gebouwd op het Arduino-platform met een focus op intuïtieve bewegingsplanning, uitgevoerd als een onafhankelijk project van 1 credit onder mentorschap van Charles B. Malloch, PhD. Het kan een reeks bewegingen nabootsen die zijn geprogrammeerd door de arm handmatig te bewegen. Ik kreeg de inspiratie om het te bouwen door andere robotarmen te zien die zijn gebouwd in de UMass Amherst M5-makerruimte. Verder wilde ik CAD-software leren gebruiken en een geavanceerd Arduino-project maken. Ik zag dit als een kans om al die dingen te doen.

Stap 1: Origineel ontwerp en toepassingsgebied

De CAD-software die ik koos om te leren voor dit project was OnShape, en het eerste dat ik modelleerde was een HiTec HS-422 analoge servo. Ik koos de servo omdat deze lokaal voor mij beschikbaar was en het een redelijke prijs was. Het diende ook als een goede oefening om OnShape te leren voordat ik verder ging met het ontwerpen van mijn eigen onderdelen. Op dit vroege punt in het project had ik een algemeen idee van wat ik wilde dat de arm zou kunnen. Ik wilde dat het een behoorlijke bewegingsvrijheid had en een grijper om dingen op te pakken. Deze algemene specificaties vormden de basis voor het ontwerp terwijl ik het in CAD bleef modelleren. Een andere ontwerpbeperking die ik op dit punt had, was de grootte van het printbed op mijn 3D-printer. Daarom is de basis die je op de foto hierboven ziet een relatief primitief vierkant.

Tijdens deze fase van het project was ik ook aan het brainstormen hoe ik de arm wilde besturen. Een robotarm waar ik door geïnspireerd was in de makerspace gebruikte een poppenarm voor controle. Een andere gebruikte een intuïtieve padprogrammeringsmethode waarbij de arm door de gebruiker in verschillende posities werd bewogen. De arm zou dan terug fietsen door die posities.

Mijn oorspronkelijke plan was om de constructie van de arm af te maken en vervolgens beide controlemethoden te implementeren. Ik wilde later ook een computerapplicatie maken om het te besturen. Zoals je waarschijnlijk wel kunt zien, heb ik uiteindelijk de reikwijdte van dit aspect van het project verkleind. Toen ik aan die eerste twee besturingsmethoden begon te werken, ontdekte ik al snel dat de intuïtieve padprogrammering ingewikkelder was dan ik dacht. Toen besloot ik er mijn focus op te maken en de andere controlemethoden voor onbepaalde tijd in de wacht te zetten.

Stap 2: Controle

De manier van besturen die ik heb gekozen werkt als volgt: je beweegt de arm met je handen in verschillende standen en "slaat" die standen op. Elke positie heeft informatie over de hoek tussen elke schakel van de arm. Nadat u klaar bent met het opslaan van posities, drukt u op een afspeelknop en keert de arm achtereenvolgens terug naar elk van die posities.

Bij deze controlemethode waren er veel dingen om uit te zoeken. Om ervoor te zorgen dat elke servo terugkeert naar een opgeslagen hoek, moest ik die hoeken op de een of andere manier "opslaan". Dit vereiste de Arduino Uno die ik gebruikte om de huidige hoek van elke servo te kunnen ontvangen. Mijn vriend Jeremy Paradie, die een robotarm maakte die deze besturingsmethode gebruikt, wees me op het gebruik van de interne potentiometer van elke hobbyservo. Dit is de potentiometer die de servo zelf gebruikt om zijn hoek te coderen. Ik koos een testservo, soldeerde een draad aan de middelste pen van de interne potentiometer en boorde een gat in de behuizing om de draad naar buiten te voeren.

Ik kon nu de huidige hoek ontvangen door de spanning op de middelste pin van de potentiometer af te lezen. Er waren echter twee nieuwe problemen. Ten eerste was er ruis in de vorm van spanningspieken op het signaal afkomstig van de middelste pin. Dit probleem werd later een echt probleem. Ten tweede was het bereik van waarden voor het verzenden van een hoek en het ontvangen van een hoek verschillend.

De hobby-servomotoren vertellen om naar een hoek tussen 0 en 180 graden te gaan, houdt in dat er een PWM-signaal wordt verzonden met een hoge tijd die overeenkomt met de hoek. Integendeel, het gebruik van een analoge ingangspen van de Arduino om de spanning op de middelste pen van de potentiometer te lezen terwijl de servohoorn tussen 0 en 180 graden wordt bewogen, levert een afzonderlijk waardenbereik op. Daarom was er wat rekenwerk nodig om een opgeslagen invoerwaarde om te zetten in de corresponderende PWM-uitvoerwaarde die nodig is om de servo in dezelfde hoek terug te brengen.

Mijn eerste gedachte was om een eenvoudige bereikkaart te gebruiken om de corresponderende output PWM voor elke opgeslagen hoek te vinden. Dit werkte, maar het was niet erg nauwkeurig. In het geval van mijn project was het bereik van PWM-hoge tijdwaarden die overeenkomen met een hoekbereik van 180 graden veel groter dan het bereik van analoge ingangswaarden. Bovendien waren beide bereiken niet continu en bestonden ze alleen uit gehele getallen. Daarom ging de precisie verloren toen ik een opgeslagen invoerwaarde toewijste aan een uitvoerwaarde. Het was op dit punt dat ik dacht dat ik een regellus nodig had om mijn servo's te krijgen waar ze moesten zijn.

Ik schreef code voor een PID-regellus waarin de ingang de middelste pinspanning was en de uitgang de PWM-uitgang, maar ontdekte al snel dat ik alleen integrale besturing nodig had. In dit scenario vertegenwoordigden de uitvoer en de invoer beide hoeken, dus het toevoegen van proportionele en afgeleide besturing had de neiging om te overschieten of ongewenst gedrag te vertonen. Na het afstellen van de integrale besturing waren er nog twee problemen. Ten eerste, als de initiële fout tussen de huidige en de gewenste hoek groot was, zou de servo te snel accelereren. Ik zou de constante voor de integrale besturing kunnen verlagen, maar dat maakte de algehele beweging te traag. Ten tweede was de beweging zenuwachtig. Dit was een gevolg van de ruis op het analoge ingangssignaal. De regelkring was dit signaal continu aan het lezen, dus de spanningspieken veroorzaakten een schokkerige beweging. (Op dit punt ben ik ook overgestapt van mijn ene testservo naar de hierboven afgebeelde assembly. Ik heb ook een regellusobject gemaakt voor elke servo in de software.)

Ik heb het probleem van te snelle acceleratie opgelost door een exponentieel gewogen voortschrijdend gemiddelde (EWMA) -filter op de uitvoer te plaatsen. Door de output te middelen, werden de grote bewegingspieken verminderd (inclusief de jitter van de ruis). De ruis op het ingangssignaal was echter nog steeds een probleem, dus de volgende fase van mijn project probeerde dat op te lossen.

Stap 3: Ruis

Hierboven afgebeeld

In rood: origineel ingangssignaal

In blauw: ingangssignaal na verwerking

De eerste stap bij het verminderen van de ruis op het ingangssignaal was het begrijpen van de oorzaak ervan. Bij het onderzoeken van het signaal op een oscilloscoop bleek dat de spanningspieken plaatsvonden met een snelheid van 50 Hz. Ik wist toevallig dat het PWM-signaal dat naar de servo's werd gestuurd ook een snelheid van 50 Hz had, dus ik vermoedde dat de spanningspieken daar iets mee te maken hadden. Ik veronderstelde dat de beweging van de servo's op de een of andere manier spanningspieken veroorzaakte op de V + -pin van de potentiometers, wat op zijn beurt de meting op de middelste pin vertroebelde.

Hier heb ik mijn eerste poging gedaan om het geluid te verminderen. Ik opende elke servo opnieuw en voegde een draad toe die uit de V + -pin op de potentiometer kwam. Ik had meer analoge ingangen nodig om ze te lezen dan de Arduino Uno had, dus ik ben op dit punt ook overgestapt op een Arduino Mega. In mijn code heb ik de hoekinvoer gewijzigd van een analoge aflezing van de spanning op de middelste pin in een verhouding tussen de spanning op de middelste pin en de spanning op de V + -pin. Ik hoopte dat als er een spanningspiek op de pinnen was, dit in de verhouding zou opheffen.

Ik heb alles weer in elkaar gezet en getest, maar de spikes waren nog steeds aan de gang. Wat ik op dit punt had moeten doen, was mijn grond onderzoeken. In plaats daarvan was mijn volgende idee om de potentiometers volledig op een aparte voeding te plaatsen. Ik heb de V+-draden losgekoppeld van de analoge ingangen op de Arduino en aangesloten op een aparte voeding. Ik had de pinnen eerder gesondeerd, dus ik wist op welke spanning ze moesten worden aangesloten. Ik heb ook de verbinding tussen de besturingskaart en de V + -pin in elke servo geknipt. Ik heb alles weer in elkaar gezet, de hoekinvoercode teruggezet naar hoe het voorheen was en het vervolgens getest. Zoals verwacht waren er geen spanningspieken meer op de ingangspen. Er was echter een nieuw probleem: door de potentiometers op een aparte voeding te plaatsen, waren de interne regelkringen van de servo's volledig in de war. Hoewel de V+-pinnen dezelfde spanning ontvingen als voorheen, was de beweging van de servo's grillig en onstabiel.

Ik begreep niet waarom dit gebeurde, dus heb ik eindelijk mijn aardverbinding in de servo's onderzocht. Er was een gemiddelde spanningsval van ongeveer 0,3 volt over de grond, en deze piekte nog hoger toen de servo's stroom trokken. Het was me toen duidelijk dat die pinnen niet langer als "aarde" konden worden beschouwd en beter konden worden omschreven als "referentie" pinnen. De besturingskaarten in de servo's moeten de spanning op de middelste pen van de potentiometer hebben gemeten ten opzichte van zowel de spanning op de V+- als de referentiepennen. Door de potentiometers afzonderlijk van stroom te voorzien, werd die relatieve meting in de war gebracht, omdat nu in plaats van een spanningspiek op alle pinnen, dit alleen op de referentiepin gebeurde.

Mijn mentor, Dr. Malloch, hielp me dit alles te debuggen en stelde voor om ook de spanning op de middelste pin te meten ten opzichte van de andere pinnen. Dat is wat ik deed voor mijn derde en laatste poging om de ruis van de hoekinvoer te verminderen. Ik opende elke servo, bevestigde de draad die ik had afgeknipt, en voegde een derde draad toe die afkomstig was van de referentiepen op de potentiometer. In mijn code heb ik de hoekinvoer gelijk gemaakt aan de volgende uitdrukking: (middelste pin - referentiepin) / (V + pin - referentiepin). Ik heb het getest en het heeft met succes de effecten van de spanningspieken verminderd. Daarnaast heb ik op deze ingang ook nog een EWMA filter gezet. Dit bewerkte signaal en het originele signaal zijn hierboven afgebeeld.

Stap 4: dingen afronden

Nadat het geluidsprobleem naar mijn beste vermogen was opgelost, begon ik met het repareren en maken van de laatste delen van het ontwerp. De arm legde te veel gewicht op de servo in de basis, dus maakte ik een nieuwe basis die het gewicht van de arm ondersteunt met een groot lager. Ik heb ook de grijper geprint en er een beetje op geschuurd om het werkend te krijgen.

Ik ben erg blij met het uiteindelijke resultaat. De intuïtieve bewegingsplanning werkt consistent en de beweging is soepel en nauwkeurig, rekening houdend met alles. Als iemand anders dit project zou willen maken, zou ik ze eerst sterk aanmoedigen om er een eenvoudigere versie van te maken. Achteraf gezien was het erg naïef om zoiets te maken met behulp van hobby-servomotoren, en de moeilijkheid die ik had om het werkend te krijgen, laat dat zien. Ik beschouw het als een wonder dat de arm zo goed werkt. Ik wil nog steeds een robotarm maken die kan communiceren met een computer, complexere programma's kan uitvoeren en met grotere precisie kan bewegen, dus voor mijn volgende project zal ik dat doen. Ik zal digitale robot-servo's van hoge kwaliteit gebruiken en hopelijk kan ik daardoor veel van de problemen vermijden die ik in dit project tegenkwam.

CAD-document:

cad.onshape.com/documents/818ea878dda7ca2f…