Zelfbalancerende robot op twee wielen - Ajarnpa

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

Deze instructable doorloopt het ontwerp- en bouwproces voor een zelfbalancerende robot. Als een opmerking wil ik alleen maar zeggen dat zelfbalancerende robots geen nieuw concept zijn en dat ze door anderen zijn gebouwd en gedocumenteerd. Ik wil van deze gelegenheid gebruik maken om mijn interpretatie van deze robot met u te delen.

Wat is een zelfbalancerende robot?

Een zelfbalancerende robot is een systeem dat traagheidsmeetgegevens gebruikt, verzameld van een sensor aan boord, om zijn positie continu aan te passen om rechtop te blijven.

Hoe werkt het?

Een eenvoudige analogie om te overwegen is een omgekeerde slinger. Waar het zwaartepunt zich boven het draaipunt bevindt. In ons geval beperken we de slinger echter tot 1 vrijheidsgraad door één rotatie-as te hebben, in ons geval de rotatie-as van de twee wielen. Aangezien elke vorm van verstoring ervoor zorgt dat de robot valt, hebben we een methode nodig om de robot actief in balans te houden. Dit is waar ons closed-loop-algoritme (PID-controller) in het spel komt, wetende in welke richting onze robot valt, kunnen we de draairichting van onze motoren aanpassen om het systeem in evenwicht te houden.

Hoe werkt het closed-loop-algoritme?

Het basisprincipe om de robot in evenwicht te houden, is dat als de robot naar voren valt, dit zal compenseren door de onderkant van de robot naar voren te bewegen om zichzelf op te vangen en dus verticaal te blijven. Evenzo, als de robot achterover valt, wordt dit gecompenseerd door de onderkant van de robot naar achteren te bewegen om zichzelf op te vangen.

We moeten hier dus twee dingen doen: eerst moeten we de hellingshoek (Roll) berekenen die de robot ervaart en als resultaat moeten we de draairichting van de motoren regelen.

Hoe gaan we de hellingshoek meten?

Om de hellingshoek te meten, gebruiken we een traagheidsmeeteenheid. Deze modules bevatten een versnellingsmeter en een gyroscoop.

• De versnellingsmeter is een elektromagnetisch apparaat dat de juiste versnelling meet, dit is de versnelling van een lichaam in een ogenblikkelijk rustframe.
• Een gyroscoop is een elektromechanisch apparaat dat de hoeksnelheid meet en wordt gebruikt om de oriëntatie van het apparaat te bepalen.

Het probleem met het gebruik van dergelijke sensoren is echter dat:

• De versnellingsmeter maakt veel lawaai, maar is consistent in de tijd, de hoek varieert met plotselinge horizontale bewegingen
• De gyroscoopwaarde zal daarentegen in de loop van de tijd afdrijven, maar in eerste instantie is deze redelijk nauwkeurig

Voor deze instructable ga ik geen filter implementeren, maar gebruik ik de ingebouwde Digital Motion Processing (DMP). Anderen hebben een complementair filter gebruikt om een soepel signaal te krijgen, je kunt kiezen welke methode je wilt. als de robot balanceert met beide implementaties.

Benodigdheden

Onderdelen:

1. Arduino Pro Mini 3.3V 8 met een 8 Mhz ATMEGA328
2. FT232RL 3.3V 5.5V FTDI USB naar TTL seriële adaptermodule
3. GY-521-module met MPU-6050
4. Een paar N20 micro-reductiemotor 6V - 300rpm
5. L298N-motorstuurprogramma
6. LM2596S DC naar DC buck-converter
7. Batterij (oplaadbaar 9,7 V Li-ion batterijpakket)
8. Batterij riem
9. Twee prototypen van printplaten
10. Overbruggingsdraden mannelijke en vrouwelijke koppennen

Gereedschap:

1. Soldeerbout en soldeer
2. Nylon zeskantafstandhouder
3. Precisie-schroevendraaierset
4. 3D-printer

Stap 1: constructie

Omdat ik toegang had tot een 3D-printer, besloot ik het chassis in 3D te printen en afstandhouders te gebruiken om alles met elkaar te verbinden.

De robot bestaat uit 4 lagen

1. De onderste laag verbindt de motoren en heeft bevestigingspunten voor de L298N motor driver module
2. De volgende laag bevat het prototypebord met de Arduino pro mini en headers erop gesoldeerd
3. De derde laag monteert de IMU
4. De bovenste laag, die ik de "bumperlaag" noem, bevat de batterij, de buck-converter en een geldschakelaar

Mijn belangrijkste ontwerpprincipe was om alles modulair te houden. De reden hiervoor was dat als er iets mis ging met een van de componenten, ik het gemakkelijk kon vervangen of als ik een onderdeel nodig had voor een ander project, ik het gemakkelijk kon pakken zonder me zorgen te maken dat ik het systeem niet meer zou kunnen gebruiken.

Stap 2: Bedrading

Ik heb enkele vrouwelijke header-pinten op een perf-board gesoldeerd om overeen te komen met de Arduino pro mini-header-pinnen. Hierna heb ik mannelijke header-pinnen op het bord gesoldeerd om toegang tot de I / O mogelijk te maken. De rest van de componenten werden op het 3D-geprinte frame gemonteerd en verbonden met behulp van jumperdraden.

Stap 3: Controletheorie

Nu gaan we naar de kern van het project. Om de robot in evenwicht te houden, moeten we een geschikt stuursignaal genereren om de motoren in de juiste richting en met de juiste snelheid aan te drijven om de robot in evenwicht en stabiel te houden. Om dit te doen, zullen we een populair regellusalgoritme gebruiken dat bekend staat als een PID-controller. Zoals het acroniem suggereert, zijn er drie termen voor deze controller, dit zijn de proportionele, integrale en afgeleide termen. Elk daarvan gaat vergezeld van coëfficiënten die hun invloed op het systeem bepalen. Vaak is het meest tijdrovende onderdeel van de implementatie van de controller het afstemmen van de versterkingen voor elk uniek systeem om de meest optimale respons te krijgen.

• De proportionele term vermenigvuldigt de fout direct om een output te geven, dus hoe groter de fout, hoe groter de respons
• De integrale term genereert een reactie op basis van een accumulatie van de fout om de stationaire fout te verminderen. Hoe langer het systeem uit balans is, hoe sneller de motoren reageren
• De afgeleide term is de afgeleide van de fout die wordt gebruikt om de toekomstige respons te voorspellen en vermindert daarmee de oscillatie als gevolg van het overschrijden van de steady-state.

Het basisprincipe van dit algoritme is om continu de hellingshoek te berekenen die het verschil is tussen de gewenste positie en de huidige positie, dit staat bekend als de fout. Vervolgens gebruikt het deze foutwaarden en berekent het de som van de proportionele, integrale en afgeleide reacties om een output te krijgen, dit zijn de stuursignalen die naar de motoren worden gestuurd. Dientengevolge, als de fout groot is, zal het stuursignaal dat naar de motoren wordt gestuurd, de motoren met hoge snelheid draaien om in een gebalanceerde toestand te komen. Evenzo, als de fout klein is, zal het stuursignaal de motoren met lage snelheid laten draaien om de robot in evenwicht te houden.

Stap 4: MPU 6050. gebruiken

MPU6050-bibliotheek

github.com/jrowberg/i2cdevlib/tree/master/…

Offsets kalibreren Niet alle sensoren zijn exacte replica's van elkaar. Als u dus twee MPU 6050 test, krijgt u mogelijk verschillende waarden voor de versnellingsmeter en de gyroscoop wanneer ze nog steeds op hetzelfde oppervlak worden geplaatst. Om deze constante hoekafwijking te overwinnen, moeten we elke sensor die we gebruiken vieren. Dit script uitvoeren:

www.i2cdevlib.com/forums/topic/96-arduino-…

geschreven door Luis Rodenas, krijgen we compensaties. De offset-fouten kunnen worden geëlimineerd door de offset-waarden in de routine setup() te definiëren.

De Digital Motion Processor gebruiken

De MPU6050 bevat een DMP (Digital Motion Processor).

Wat is een DMP? Je kunt de DMP zien als een ingebouwde microcontroller die de complexe beweging van de 3-assige gyroscoop en 3-assige versnellingsmeter aan boord van de mpu6050 verwerkt, met behulp van zijn eigen bewegingsfusie-algoritmen. De verwerking ontlasten die anders door de Arduino zou worden gedaan

Hoe te gebruiken? Om erachter te komen hoe u de DMP moet gebruiken, gaat u door de voorbeeldschets MPU6050_DMP6 die bij de MPU6050-bibliotheek wordt geleverd (in de Arduino IDE: Bestand->Voorbeeld->MPU6050->MPU6050_DMP6). Dit is ook een goede gelegenheid om te controleren of uw sensor echt werkt en of de bedrading correct is

Stap 5: Coderen

Ik gebruikte de Arduino IDE en een FTDI-interface om de Arduino pro mini te programmeren.

Met behulp van de voorbeeldschets (MPU6050_DMP6) die bij de MPU6050-bibliotheek wordt geleverd als mijn basiscode, heb ik een PID()- en MotorDriver()-functies toegevoegd.

Voeg de bibliotheek toe

• MPU6050: Om de MPU6050-sensor te gebruiken, moeten we de I2C-ontwikkelaarsbibliotheek van Jeff Rowberg downloaden en deze toevoegen aan de Arduino-map "bibliotheken" in de programmabestanden op uw computer.
• Wire: we hebben ook de Wire-bibliotheek nodig om met I2C-apparaten te kunnen communiceren.

Pseudo-code

Bibliotheken opnemen:

• Draad.h
• MPU6050
• I2Cdev.h

Initialiseer variabelen, constanten en objecten

Opstelling ()

• Pin-modus instellen voor het aansturen van motoren
• Pin-modus instellen voor de status-LED
• Initialiseer de MPU6050 en stel offsetwaarden in

PID ()

Bereken PID-waarde

MotorDriver (PID-reactie)

Gebruik de PID-waarde om de snelheid en richting van de motoren te regelen;

lus ()

• Gegevens ophalen uit DMP
• Roep PID() een MotorDriver()-functie aan

Stap 6: PID-afstemmingsprocedure

Dit is het meest vervelende deel van het project en vereist een beetje geduld, tenzij je veel geluk hebt. Dit zijn de stappen:

1. Stel I- en D-term in op 0
2. Houd de robot vast en stel P zo af dat de robot net begint te oscilleren over de balanspositie
3. Met P ingesteld, verhoogt u I zodat de robot sneller accelereert wanneer hij uit balans is. Als P en I goed zijn afgesteld, moet de robot in staat zijn om zichzelf minstens een paar seconden in evenwicht te houden, met wat oscillatie
4. Verhoog ten slotte D en verminder de oscillatie

Als de eerste poging geen bevredigende resultaten oplevert, herhaalt u de stappen met een andere waarde van P. Houd er ook rekening mee dat u de PID-waarden daarna kunt verfijnen om de prestaties verder te verbeteren. De waarden hier zijn afhankelijk van de hardware, wees niet verbaasd als u zeer grote of zeer kleine PID-waarden krijgt.

Stap 7: conclusie

De gebruikte micro-tandwielmotoren waren te traag om te reageren op grote storingen en aangezien het systeem te licht was, was er niet genoeg traagheid om het gewenste slingereffect te krijgen, dus als de robot naar voren leunt, leunt hij gewoon in een hoek en racet naar voren. Ten slotte zijn 3D-geprinte wielen een slechte keuze omdat ze blijven slippen.

Suggesties voor verbetering:

• Snellere motoren met een hoger koppel, d.w.z. voor gelijkstroommotoren is de nominale spanning hoger, hoe hoger het koppel
• neem een zwaardere batterij of verplaats de massa gewoon wat hoger
• Vervang 3D-geprinte wielen door rubberen wielen voor meer tractie