Parte I: Como monitorar o feedback de um atuador linear?

No guia de hoje, veremos como descobrir quanta força um atuador linear está aplicando monitorando a quantidade de corrente que ele está consumindo. Este será um dos nossos guias mais avançados e exigirá codificação, calibração e programação complexas. Abordaremos o monitoramento da entrada analógica e como utilizar suas funções. Para este projeto, usaremos um MegaMoto Plus, um atuador linear (estamos usando nosso mini atuador PA-14), um Arduino Uno e uma fonte de alimentação de pelo menos 12V.

Para começar, vamos fazer a fiação para conectar tudo. Comece encaixando o MegaMoto no Arduino; basta posicionar o MegaMoto sobre o Uno. Em seguida, conecte um fio do terminal BAT+ do MegaMoto ao pino Vin do Uno.

Agora precisamos conectar os fios dos atuadores lineares aos terminais A e B do MegaMoto e ligar a fonte de 12V ao BAT+ e o GND ao BAT-. Também será necessário ligar dois botões de controle, cada um entre um pino não utilizado e o GND. Recomendamos ligar os botões em uma protoboard.

Agora é hora de fazer um pouco de programação com o Arduino Uno. Queremos programar os botões para que possam controlar quando o atuador irá estender e retrair. A corrente começará a ser monitorada assim que o atuador estender, o que nos permitirá observar se ela ultrapassa o limite máximo de corrente ou não. Se ultrapassar o limite, o atuador parará automaticamente até você optar por retraí-lo. Considerando que os motores dentro dos atuadores apresentam um grande pico de corrente quando são energizados pela primeira vez, o código terá um pequeno atraso antes de começar a monitorar a corrente. Esse código também conseguirá detectar quando o atuador atingir seus fins de curso, momento em que a corrente cai para 0.

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; //amount to debounce buttons, lower values makes the buttons more sensitivelong lastButtonpress = 0; // timer for debouncing
long currentTimedebounce = 0;
int CRaw = 0;      // input value for current readings
int maxAmps = 0; // trip limit 
bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//program logic

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Set motor outputs
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//buttons 
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//enable internal pullups
  pinMode(CPin1, INPUT);//set feedback input
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Set initial times
  maxAmps = 15;// SET MAX CURRENT HERE
}//end setup

void loop()
{
  latchButtons();//check buttons, see if we need to move
  moveMotor();//check latches, move motor in or out
}//end main loop

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//left is forwards
 {
    currentTimedebounce = millis() - lastButtonpress;// check time since last press
    if (currentTimedebounce > debounceTime && dontExtend == false)//once you've tripped dontExtend, ignore all forwards presses
    {
      leftlatch = !leftlatch;// if motor is moving, stop, if stopped, start movingfirstRun = true;// set firstRun flag to ignore current spike
      fullyRetracted = false; // once you move forwards, you are not fully retracted
      lastButtonpress = millis();//store time of last button press
      return;
    }//end if
  }//end btnLEFT

  if (digitalRead(buttonRight)==LOW)//right is backwards
  {
    currentTimedebounce = millis() - lastButtonpress;// check time since last press
    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// if motor is moving, stop, if stopped, start moving
      firstRun = true;// set firstRun flag to ignore current spike
      lastButtonpress = millis();//store time of last button press
      return;    
    }//end if
  }//end btnRIGHT
}//end latchButtons

void moveMotor()
{
  if (leftlatch == HIGH) motorForward(255); //speed = 0-255
  if (leftlatch == LOW) motorStop();
  if (rightlatch == HIGH) motorBack(255); //speed = 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);//move motor
    if (firstRun == true) delay(firstfeedbacktimedelay); // bigger delay to ignore current spike
    else delay(feedbacktimedelay); //small delay to get to speed
    getFeedback();
    firstRun = false;
    latchButtons();//check buttons again
  }//end while
}//end motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//move motor
    if (firstRun == true) delay(firstfeedbacktimedelay);// bigger delay to ignore current spike
    else delay(feedbacktimedelay); //small delay to get to speed
    getFeedback();
    firstRun = false;
    latchButtons();//check buttons again
  }//end while
  dontExtend = false;//allow motor to extend again, after it has been retracted
}//end motorBack

void motorStop()
{
  analogWrite(PWMPinA, 0);
  analogWrite(PWMPinB, 0);
  digitalWrite(EnablePin, LOW);
  firstRun = true;//once the motor has stopped, reenable firstRun to account for startup current spikes
}//end stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Read current
  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // check to see if the motor is at the limits and the current has stopped 
  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // stop motor
    fullyRetracted = true;
  }//end if
  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//stop motor
    hitLimits = 0;
  }//end if
  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //stop if feedback is over maximum
  }//end if
  lastfeedbacktime = millis();//store previous time for receiving feedback
}//end getFeedback

O novo e aprimorado mini atuador PA-01 (atualização do PA-14) é o modelo atual que oferecemos, com vários benefícios adicionais. Para comparar, confira as tabelas abaixo e faça o upgrade com confiança!

Com este código básico, você conseguirá monitorar com sucesso o Feedback do seu atuador linear. Na Parte II entraremos em mais detalhes sobre como o código funciona e como editá-lo do seu jeito. Esperamos que este post tenha sido útil e fique de olho na Parte II nas próximas semanas. Se quiser pedir qualquer uma das unidades usadas neste exemplo ou saber mais sobre nossos produtos, por favor entre em contato conosco.