Deel I: Hoe monitor je de terugkoppeling van een lineaire actuator?

In de gids van vandaag laten we zien hoe je kunt achterhalen hoeveel kracht een lineaire actuator uitoefent door de hoeveelheid stroom te monitoren die hij gebruikt. Dit is een van onze meer geavanceerde gidsen en vereist complexe codering, kalibratie en programmering. We behandelen het monitoren van de analoge ingang en hoe die functies worden benut. Voor dit project gebruiken we een MegaMoto Plus, een lineaire actuator (we gebruiken onze PA-14 mini‑actuator), een Arduino Uno en een voeding van minimaal 12 V.

Om te beginnen moeten we de bekabeling doen om alles met elkaar te verbinden. Begin door de MegaMoto op de Arduino aan te sluiten; plaats de MegaMoto hiervoor bovenop de Uno. Verbind vervolgens een draad van de BAT+-terminal op de MegaMoto met de Vin‑pin op de Uno.

Nu moeten we de draden van de lineaire actuators op de A- en B‑terminals van de MegaMoto aansluiten en de 12V‑voeding verbinden met BAT+ en GND met BAT-. We moeten ook twee knoppen bedraden voor de bediening door ze elk tussen een ongebruikte pin en GND te verbinden. We raden aan om de knoppen op een breadboard te bedraden.

Nu is het tijd voor wat coderen met de Arduino Uno. We willen de knoppen zo programmeren dat ze kunnen bepalen wanneer de actuator uitschuift en intrekt. De stroom wordt gemonitord zodra de actuator uitschuift en dit laat ons zien of de maximale stroomlimiet wordt overschreden of niet. Als de limiet wordt overschreden, stopt de actuator automatisch totdat je ervoor kiest deze in te trekken. Omdat de motoren in actuators bij het inschakelen een grote stroompiek hebben, bevat de code die we invoeren een korte vertraging voordat de stroom wordt gemonitord. Deze code kan detecteren wanneer de actuator zijn eindschakelaars heeft bereikt, namelijk wanneer de stroom naar 0 daalt.

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // pins for Megamoto
const int buttonLeft = 4;
const int buttonRight = 5;//buttons to move the motor
const int CPin1 = A5;  // motor feedback

int leftlatch = LOW;
int rightlatch = LOW;//motor latches (used for code logic)
int hitLimits = 0;//start at 0
int hitLimitsmax = 10;//values to know if travel limits were reached

longlastfeedbacktime = 0; // must be long, else it overflows
int firstfeedbacktimedelay = 750; //first delay to ignore current spik
int feedbacktimedelay = 50; //delay between feedback cycles, how often you want the motor to be checked
currentTimefeedback = 0; // must be long, else it overflows
unceTime = 300; // hoeveelheid om knoppen te debouncen; lagere waarden maken de knoppen gevoeligerlong lastButtonpress = 0; // timer voor debouncen
long currentTimedebounce = 0;
int CRaw = 0;      // inputwaarde voor stroommetingen
int maxAmps = 0; // triplimiet 
bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//programmalogica

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//motoruitgangen instellen
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//buttons 
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//interne pull-ups inschakelen
  pinMode(CPin1, INPUT);//feedbackinvoer instellen
  currentTimedebounce = millis();
  currentTimefeedback = 0;//begintijden instellen
  maxAmps = 15;// HIER MAXIMALE STROOM INSTELLEN
}//end setup

void loop()
{
  latchButtons();//knoppen controleren, kijken of we moeten bewegen
  moveMotor();//latches controleren, motor in of uit bewegen
}//end main loop

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//links is vooruit
 {
    currentTimedebounce = millis() - lastButtonpress;// tijd sinds de laatste indruk controleren
    if (currentTimedebounce > debounceTime && dontExtend == false)//zodra dontExtend is geactiveerd, alle voorwaartse indrukken negeren
    {
      leftlatch = !leftlatch;// if motor is moving, stop, if stopped, start movingfirstRun = true;// firstRun-vlag zetten om stroompiek te negeren
      fullyRetracted = false; // zodra je vooruit beweegt, ben je niet volledig ingetrokken
      lastButtonpress = millis();//tijd van de laatste knopindruk opslaan
      return;
    }//end if
  }//end btnLEFT

  if (digitalRead(buttonRight)==LOW)//rechts is achteruit
  {
    currentTimedebounce = millis() - lastButtonpress;// tijd sinds de laatste indruk controleren
    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// als de motor beweegt, stoppen; als hij stilstaat, starten
      firstRun = true;// firstRun-vlag zetten om stroompiek te negeren
      lastButtonpress = millis();//tijd van de laatste knopindruk opslaan
      return;    
    }//end if
  }//end btnRIGHT
}//end latchButtons

void moveMotor()
{
  if (leftlatch == HIGH) motorForward(255); //snelheid = 0-255
  if (leftlatch == LOW) motorStop();
  if (rightlatch == HIGH) motorBack(255); //snelheid = 0-255
  if (rightlatch == LOW) motorStop();
}//end moveMotor

void motorForward(int speeed)
{
  while (dontExtend == false && leftlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//motor bewegen
    if (firstRun == true) delay(firstfeedbacktimedelay); // grotere vertraging om stroompiek te negeren
    else delay(feedbacktimedelay); //kleine vertraging om op snelheid te komen
    getFeedback();
    firstRun = false;
    latchButtons();//knoppen opnieuw controleren
  }//end while
}//end motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//motor bewegen
    if (firstRun == true) delay(firstfeedbacktimedelay);// grotere vertraging om stroompiek te negeren
    else delay(feedbacktimedelay); //kleine vertraging om op snelheid te komen
    getFeedback();
    firstRun = false;
    latchButtons();//knoppen opnieuw controleren
  }//end while
  dontExtend = false;//motor opnieuw laten uitschuiven nadat deze is ingetrokken
}//end motorBack

void motorStop()
{
  analogWrite(PWMPinA, 0);
  analogWrite(PWMPinB, 0);
  digitalWrite(EnablePin, LOW);
  firstRun = true;//zodra de motor is gestopt, firstRun opnieuw inschakelen om opstartstroompieken op te vangen
}//end stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // stroom lezen
  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // controleren of de motor de limieten heeft bereikt en de stroom is gestopt 
  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // motor stoppen
    fullyRetracted = true;
  }//end if
  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//motor stoppen
    hitLimits = 0;
  }//end if
  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //stoppen als de terugkoppeling boven het maximum ligt
  }//end if
  lastfeedbacktime = millis();//vorige tijd voor het ontvangen van terugkoppeling opslaan
}//end getFeedback

De nieuwe en verbeterde PA-01 mini‑actuator (PA-14 upgrade) is het huidige model dat we aanbieden, met diverse extra voordelen. Vergelijk de tabellen hieronder en upgrade met vertrouwen!

Met deze basiscode kun je de terugkoppeling van je lineaire actuator succesvol monitoren. In Deel II gaan we dieper in op hoe de code werkt en hoe je die naar wens kunt aanpassen. Hopelijk vond je dit bericht nuttig en blijf op de hoogte voor Deel II in de komende weken. Als je een van de units wilt bestellen die we in dit voorbeeld hebben gebruikt of meer wilt weten over onze producten, neem dan contact met ons op.