In onze nieuwste "How-to"-post leggen we uit hoe je de timing van de beweging van een lineaire actuator met een microcontroller kunt regelen. Microcontrollers bieden veel vrijheid in bewegingsbesturing en dit is slechts één voorbeeld uit een bijna eindeloze reeks mogelijkheden. Afhankelijk van uw toepassing kan het voorbeeldproject in dit artikel worden aangepast aan uw wensen: of u nu een extra getimede actuator toevoegt of de voeding zwaarder uitvoert om een krachtigere lineaire actuator aan te sturen, het is helemaal aan u.
Bewegingsbesturing met een microcontroller
We gebruiken een Arduino‑microcontroller om de bewegingstiming van een lineaire actuator te regelen, maar elke microcontroller werkt. Omdat we echter een shield gebruiken, moet de microcontroller compatibel zijn. We nemen u mee door de verschillende parameters die u kunt aanpassen om de Snelheid van een lineaire actuator te wijzigen.
Wat u nodig hebt
Voor dit voorbeeld gebruiken we de volgende componenten om een lineaire actuator te besturen:
- 1 x MegaMoto Plus
- 1 x Arduino Uno Rev3
- 1 x Mini‑industriële actuator (PA-09, maar elke lineaire actuator volstaat)
- 1 x Voeding (PS-20-12, maar elke 12V‑voeding volstaat)
Componenten aansluiten
Nu we onze onderdelen hebben, moeten we alles verbinden. Gelukkig zijn de aansluitingen eenvoudig door een shield te gebruiken in plaats van een aparte printplaat die extra bedrading en soldeerwerk vereist.
Verbind eerst onze actuator met ons LC-80 MegaMoto Plus‑shield door de twee draadaansluitingen van de actuator op de A/B‑schroefklemmen van de LC-80 aan te sluiten. Vervolgens moeten we de LC-80 verbinden met onze voeding, in dit geval de PS-20-12. Dat doen we door de positieve en negatieve draden van de voeding op de BAT +/-‑klemmen van de LC-80 aan te sluiten.
Tot slot moeten we de LC-80 met de LC-066 verbinden; dat is zo eenvoudig als ze op elkaar steken, zoals in de afbeelding hieronder te zien is.
De code aanpassen
Om volledige controle over de beweging van onze actuator te krijgen, schrijven we wat code voor de lineaire actuator met onze Arduino‑unit. We hebben een voorbeeldcode voorbereid die onze actuator 10 seconden uitschuift en daarna 10 seconden inschuift binnen een cyclus van 300 seconden.
//Gebruik de jumpers op de print om te selecteren welke pinnen worden gebruikt
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;
int extendtime = 10 * 1000; // 10 seconden, maal 1000 om om te zetten naar milliseconden
int retracttime = 10 * 1000; // 10 seconden, maal 1000 om om te zetten naar milliseconden
int timetorun = 300 * 1000; // 300 seconden, maal 1000 om om te zetten naar milliseconden
int duty;
int elapsedTime;
boolean keepMoving;
void setup() {
Serial.begin(9600);
pinMode(EnablePin1, OUTPUT);//Schakel de print in
pinMode(PWMPinA1, OUTPUT);
pinMode(PWMPinB1, OUTPUT);//Motoruitgangen instellen
elapsedTime = 0; // Tijd op 0 zetten
keepMoving = true; //Het systeem zal bewegen
}//einde setup
void loop() {
if (keepMoving)
{
digitalWrite(EnablePin1, HIGH); // motor inschakelen
pushActuator();
delay(extendtime);
stopActuator();
delay(10);//kleine vertraging voordat wordt ingetrokken
pullActuator();
delay(retracttime);
stopActuator();
elapsedTime = millis();//hoe lang is het geleden?
if (elapsedTime > timetorun) {//als er 300 seconden zijn verstreken, stoppen
Serial.print("De verstreken tijd overschrijdt de maximale looptijd. Maximale looptijd: ");
Serial.println(timetorun);
keepMoving = false;
}
}//einde if
}//einde hoofdlus
void stopActuator() {
analogWrite(PWMPinA1, 0);
analogWrite(PWMPinB1, 0); // Snelheid 0-255
}
void pushActuator() {
analogWrite(PWMPinA1, 255);
analogWrite(PWMPinB1, 0); // Snelheid 0-255
}
void pullActuator() {
analogWrite(PWMPinA1, 0);
analogWrite(PWMPinB1, 255);//Snelheid 0-255
}
Het is belangrijk om de code regel voor regel door te lopen om te begrijpen wat er gebeurt. Zo kunt u de code aanpassen om nog veel meer taken uit te voeren. Voor nu zijn echter het eerste gedeelte en de setup‑loop het belangrijkst, waarin de pinnen worden toegewezen en de cyclussnelheid wordt ingesteld.
U moet de pinnen op onze LC-80 configureren zodat ze overeenkomen met wat in het eerste gedeelte van de code staat, door de jumpers op de LC-80 in te stellen of de code aan te passen. Stel in dit geval de "Enable"-pin in op D13, de "PWMA"-pin op D11 en de "PWMB"-pin op D3. De "Enable"-pin is wat de Motor aanstuurt en van stroom voorziet; zonder deze stopt de actuator met bewegen en kan hij niet worden bestuurd. De pinnen "PWMA" en "PWMB" regelen het uitschuiven en inschuiven van de actuator. We hebben de "Sensor"-pinnen in dit voorbeeld niet nodig, dus maak u daar geen zorgen over.
De timerbesturing van een lineaire actuator is nu afgerond. U kunt de code uploaden naar de Arduino met hun IDE (te downloaden via de Arduino‑website). Zodra uw lineaire actuator kan uit- en inschuiven, waarom zou u dan niet een beetje met de code spelen? Probeer de uit-/inschuiftijd in de code aan te passen, upload opnieuw naar de Arduino en kijk hoe de lineaire actuator reageert. Door deze waarden in de code aan te passen, kunt u de Snelheid en de totale bewegingscyclustijd regelen op basis van uw toepassing.
Conclusie
Hieronder hebben we een video opgenomen van een timing‑actuator in actie. Voor het video‑voorbeeld wilden we een andere manier laten zien waarop u de timing kunt wijzigen, dus lieten we hem 5 seconden per keer uit- en inschuiven binnen een cyclus van 20 seconden.
Zoals eerder vermeld, is dit slechts één manier waarop u de beweging van een actuator kunt aanpassen met behulp van onze microcontrollers. Als u een eigen, aangepaste besturingsmethode in gedachten heeft, kunnen we met behulp van ons getalenteerde engineeringteam een besturingssysteem bouwen dat specifiek aan uw eisen voldoet. Zij begeleiden u door het proces en zorgen ervoor dat u volledige controle over uw units heeft. Wilt u meer weten over het proces van maatwerkbestellingen, bekijk dan onze pagina voor maatwerkbestellingen.