Synchrone beweging tussen meerdere lineaire actuatoren kan van vitaal belang zijn voor het succes van sommige klanttoepassingen, waaronder twee lineaire actuatoren die een luik openen. Om dit te bereiken raden we aan om de speciale Firgelli te gebruiken synchrone schakelkast FA-SYNC-2 en FA-SYNC-4. Sommige doe-het-zelvers en hackers geven echter de voorkeur aan de vrijheid die een microcontroller zoals de Arduino biedt en geven er de voorkeur aan om hun eigen synchrone besturingsprogramma te schrijven. Deze tutorial is bedoeld om een overzicht te geven van hoe u dit kunt bereiken met behulp van de Optische serie lineaire actuator.
Voorwoord
Deze tutorial is geen rigoureuze behandeling van de stappen die nodig zijn om synchrone besturing met Arduino te bereiken, maar een breed overzicht om je te helpen bij het schrijven van je eigen aangepaste programma. Deze tutorial is geavanceerd en gaat ervan uit dat je al bekend bent met Arduino-hardware en -software en idealiter ervaring hebt met pulsbreedtemodulatie (PWM) -signalen, interrupt-serviceroutine (ISR), debouncing van sensoren en motor-encoders. Het voorbeeld in deze tutorial is een primitieve proportionele controller. Veel verbeteringen kunnen worden geïmplementeerd op het volgende voorbeeld, inclusief, maar niet beperkt tot: het implementeren van een PID-regellus en schalen naar meer dan twee lineaire actuatoren. Houd er rekening mee dat we niet de middelen hebben om technische ondersteuning te bieden voor Arduino-toepassingen en we zullen geen fouten opsporen, bewerken, code of bedradingsschema's leveren buiten deze openbaar beschikbare tutorials.
Overzicht synchrone besturing
Synchrone controle wordt bereikt door de lengte van twee lineaire actuatoren te vergelijken en de snelheid proportioneel aan te passen; als de ene actuator sneller gaat bewegen dan de andere, zullen we deze vertragen. We kunnen de positie van de lineaire actuator aflezen via de ingebouwde optische encoder. De optische encoder is een kleine plastic schijf met 10 gaten erin die is aangesloten op de gelijkstroommotor zodat wanneer de motor draait, de plastic schijf dat ook doet. Een infrarood-LED wordt naar de plastic schijf gericht, zodat het licht tijdens het ronddraaien ofwel door de gaten in de optische schijf wordt uitgezonden of wordt geblokkeerd door het plastic van de schijf. Een infraroodsensor aan de andere kant van de schijf detecteert wanneer het licht door het gat wordt uitgezonden en geeft een blokgolfsignaal af. Door het aantal pulsen te tellen dat de ontvanger detecteert, kunnen we zowel het toerental van de motor berekenen als de afstand die de lineaire actuator heeft afgelegd. De 35lb optische lineaire actuator heeft 50 (+/- 5) optische pulsen per inch reizen, terwijl de 200lb en 400lb actuators beide 100 (+/- 5) pulsen per inch hebben. Door te vergelijken hoe ver elke lineaire actuator is uitgeschoven, kunnen we de snelheid van de twee actuatoren proportioneel aanpassen zodat ze altijd op dezelfde lengte blijven tijdens het uitschuiven.
Vereiste componenten
- Twee optische lineaire actuatoren
- Twee IBT-2 motordrivers
- Arduino Uno
- 12V voedingsbron
- 3 tijdelijke knoppen (niet verkocht door Firgelli)
- Extra bedrading
Schakelschema
Maak de bovenstaande bedradingsverbindingen. Controleer altijd de draadkleuren die uit de lineaire actuator komen, aangezien de kleurconventie kan veranderen van wat in het bovenstaande diagram wordt weergegeven.
Snelle handleiding
Als u uw twee lineaire actuatoren alleen synchroon wilt laten bewegen, volgt u gewoon deze stappen:
- Maak de aansluitingen zoals aangegeven in het bedradingsschema.
- Upload en voer het eerste programma hieronder uit.
- Kopieer de twee waarden die door dit programma worden uitgevoerd naar regel 23 van het tweede programma hieronder.
- Upload en start het tweede programma.
- Stem uw systeem nauwkeurig af door de variabele K_p (regel 37, tweede programma) te variëren. Dit is het gemakkelijkst te doen door een potentiometer aan te sluiten op analoge pin A0 en de code te wijzigen om de potentiometer te lezen en de map () functie te gebruiken: K_p = map (analogRead (A0), 0, 1023, 0, 20000);
In de rest van deze tutorial zullen enkele van de belangrijkste functies van de programma's meer in detail worden besproken. We herhalen nogmaals dat dit geen uitputtende tutorial is, maar eerder een overzicht van dingen die je moet overwegen bij het maken van je eigen programma.
Overzicht van kalibratieprogramma
Voordat synchrone regeling kan worden bereikt, moeten we eerst het systeem kalibreren. Hierbij wordt het aantal pulsen per activeringscyclus geteld omdat zoals vermeld in de productspecificaties er een tolerantie is van (+/- 5) pulsen per inch verplaatsing. Upload en voer het onderstaande programma uit. Dit programma zal de actuatoren volledig terugtrekken (lijn 53) en de variabele van de optische pulsteller op nul zetten, deze zal dan volledig uitgeschoven en volledig terugtrekken (respectievelijk lijn 63 en 74). Gedurende deze bekrachtigingscyclus zal het aantal pulsen worden geteld door de onderbrekingsserviceroutine (ISR), lijn 153 en 166. Zodra de bekrachtigingscyclus is voltooid, zal het gemiddelde aantal pulsen worden afgegeven, regel 88, noteer deze waarden voor later.
https://gist.github.com/Will-Firgelli/89978da2585a747ef5ff988b2fa53904
Overzicht van synchroon programma
Voordat u het synchrone besturingsprogramma uploadt, moet u eerst de waarden die door het kalibratieprogramma worden uitgevoerd naar regel 23 kopiëren en de huidige array: {908, 906} vervangen door uw eigen waarden. Als u de lineaire actuator van 35 lb gebruikt, moet u bovendien de waarde van de variabele in regel 29 wijzigen van 20 milliseconden in 8 milliseconden.
Na eenmaal volledig intrekken (om de oorsprong te identificeren) kunt u beide lineaire actuatoren synchroon bewegen door op de drie knoppen te drukken die overeenkomen met de uitschuif-, intrek- en stopopdrachten. De actuatoren blijven zelfs bij ongelijke belastingen synchroon door hun relatieve pulstellers te vergelijken en de snelheid ertussen aan te passen om altijd synchroon te blijven. Houd er rekening mee dat het huidige programma een eenvoudige proportionele regelaar implementeert, lijn 93, als zodanig onderhevig is aan doorschieten en oscillatie rond het evenwicht. U kunt dit afstemmen door de variabele K_p te variëren, gedefinieerd op regel 37. Dit is het gemakkelijkst te doen door een potentiometer aan te sluiten op analoge pin A0 en de code te wijzigen om de potentiometer te lezen en de map () functie te gebruiken: K_p = map (analogRead (A0), 0, 1023, 0, 20000);
Voor de beste resultaten raden we sterk aan om de proportionele regelaar te verwijderen en een PID-regellus te implementeren; dit valt echter buiten het bestek van deze inleidende tutorial en is opzettelijk weggelaten.
https://gist.github.com/Will-Firgelli/44a14a4f3cac3209164efe8abe3285b6
Gebruik van Bullet 36 en Bullet 50-actuators in synchroon
Naast onze lineaire actuator uit de optische serie bieden we ook twee lineaire actuatoren met ingebouwde encoders aan: de Bullet 36 Cal. en de Bullet 50 Cal, die beide een interne kwadratuur Hall Effect-encoder hebben. De Hall Effect-encoder werkt volgens hetzelfde principe als de optische encoder, maar in plaats van licht te gebruiken, gebruikt hij magnetisme. Bovendien is het een kwadratuur-encoder en heeft het twee signaaluitgangen, elk 90 graden uit fase. Als zodanig moet je een Arduino-bord met 4 of meer interruptpinnen gebruiken (de Arduino Uno heeft er maar twee) en de code aanpassen om de invoer van twee signalen per actuator te verwerken. Bovendien moet de tijdvariabele debounce, falsepulseDelay, samen met K_p worden afgestemd.
Tips voor het schrijven van uw eigen programma
Meer dan twee lineaire actuatoren
Bij gebruik van twee of meer lineaire actuatoren zal de Arduino Uno niet meer werken omdat er slechts twee interruptpinnen beschikbaar zijn. U moet een Arduino-bord gebruiken met het geschatte aantal beschikbare interrupt-pinnen, meer informatie: https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/
Ten tweede is het in het belang van de efficiëntie raadzaam om uw programmering te vectoriseren met behulp van arrays en for () lussen om elke actuator te herhalen.
Debouncen
Zoals bij veel sensoren is het belangrijk om op de hoogte te zijn van stuiterende signalen. Net als bij mechanische schakelaars kunnen ook encoders last hebben van stuiteren. In het bovenstaande voorbeeld is het debouncing-proces afgehandeld door een simpele vertraging (gedefinieerd door de falsepulseDelay-variabele), het is belangrijk om dit af te handelen bij eventuele softwarewijzigingen die je aanbrengt of met fysieke schakelingen om de stuiterende ruis weg te filteren.
Handling omrollen
Als u de code wijzigt, moet u rekening houden met rollover bij het omgaan met de millis () -functie. Zowel millis () als de lastDebounceTime-array worden gedeclareerd als niet-ondertekende lange variabelen, wat betekent dat ze waarden kunnen opslaan tot 4.294.967.295 (32 ^ 2-1). Dit vertaalt zich naar ongeveer een overgangsperiode van 49,7 dagen. Het huidige programma is ontworpen om rollover af te handelen in de ISR-functies (interrupt service routine): count_0 & count_1, maar als je dit programma aanpast, zorg er dan voor dat je de variabele rollover correct afhandelt, anders zal je programma crashen na ~ 49,7 dagen continu gebruik. Raadpleeg voor meer informatie: https://www.norwegiancreations.com/2018/10/arduino-tutorial-avoiding-the-overflow-issue-when-using-millis-and-micros/
