Teil I: Wie man die Rückmeldung eines Linearantriebs überwacht?

In der heutigen Anleitung werden wir besprechen, wie man herausfindet, wie viel Kraft ein Linearaktuator ausübt, indem man die Menge an Strom überwacht, die er verwendet. Dies wird eine unserer fortgeschritteneren Anleitungen sein und erfordert einige komplexe Programmierungen, Kalibrierungen und Einstellungen. Wir werden die Überwachung des analogen Eingangs und wie er seine Funktionen nutzt, behandeln. Für dieses Projekt verwenden wir einen MegaMoto Plus, einen Linearaktuator (wir verwenden unseren PA-14 Miniaktuator), ein Arduino Uno und ein Netzteil von mindestens 12 V.

Um zu beginnen, müssen wir die Verkabelung vornehmen, um alles miteinander zu verbinden. Beginnen Sie damit, den MegaMoto mit dem Arduino zu verbinden, indem Sie den MegaMoto einfach auf den Uno legen. Verbinden Sie dann ein Kabel vom BAT+-Anschluss des MegaMoto mit dem Vin-Pin des Uno.

Jetzt müssen wir die Kabel der Linearaktuatoren mit den A- und B-Anschlüssen am MegaMoto verbinden und die 12V-Stromquelle an BAT+ und GND an BAT- anschließen. Wir müssen auch zwei Tasten für die Steuerung verkabeln, indem wir sie jeweils zwischen einem ungenutzten Pin und GND anschließen. Wir empfehlen, die Tasten auf ein Breadboard zu stecken.

Jetzt ist es Zeit für etwas Programmierung mit dem Arduino Uno. Wir möchten die Tasten so programmieren, dass sie steuern können, wann der Aktuator sich ausfahren und einfahren wird. Der Strom wird überwacht, sobald der Aktuator sich ausfährt, und dies ermöglicht es uns zu beobachten, ob er das maximale Stromlimit überschreitet oder nicht. Wenn er das Limit überschreitet, stoppt der Aktuator automatisch, bis Sie entscheiden, ihn einzufahren. Da die Motoren in den Aktuatoren beim ersten Einschalten einen großen Stromstoß haben, wird der Code, den wir eingeben, eine kurze Verzögerung haben, bevor er mit der Überwachung des Stroms beginnt. Dieser Code kann lesen, wenn der Aktuator seine Endschalter erreicht hat, was der Fall ist, wenn der Strom auf 0 fällt.

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // Pins für Megamoto
const int buttonLeft = 4;
const int buttonRight = 5;//Tasten zum Bewegen des Motors
const int CPin1 = A5;  // Motorfeedback

int leftlatch = LOW;
int rightlatch = LOW;//Motorverriegelungen (für die Logik des Codes verwendet)
int hitLimits = 0;//beginnt bei 0
int hitLimitsmax = 10;//Werte, um zu wissen, ob die Reisegrenzen erreicht wurden

long lastfeedbacktime = 0; // muss lang sein, sonst überläuft es
int firstfeedbacktimedelay = 750; //erste Verzögerung, um den Stromstoß zu ignorieren
int feedbacktimedelay = 50; //Verzögerung zwischen Feedbackzyklen, wie oft Sie den Motor überprüfen möchten
currentTimefeedback = 0; // muss lang sein, sonst überläuft es
int debounceTime = 300; //Menge, um die Tasten zu entprellen, niedrigere Werte machen die Tasten empfindlicher
long lastButtonpress = 0; // Timer für Entprellen
long currentTimedebounce = 0;
int CRaw = 0;      // Eingabewert für Strommessungen
int maxAmps = 0; // Auslöseschwelle
bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//Programmlogik

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Motor-Ausgänge festlegen
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//Tasten 
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//interne Pullups aktivieren
  pinMode(CPin1, INPUT);//Feedback-Eingang festlegen
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Anfangszeiten festlegen
  maxAmps = 15;// MAXIMALEN STROM HIER FESTLEGEN
} //Ende Setup

void loop()
{
  latchButtons();//Tasten überprüfen, sehen, ob wir uns bewegen müssen
  moveMotor();//Verriegelungen überprüfen, Motor ein- oder ausfahren
} //Ende Hauptschleife

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//links ist vorwärts
 {
    currentTimedebounce = millis() - lastButtonpress;// Zeit seit der letzten Betätigung überprüfen
    if (currentTimedebounce > debounceTime && dontExtend == false)//sobald Sie dontExtend ausgelöst haben, ignorieren Sie alle Vorwärtsbetätigungen
    {
      leftlatch = !leftlatch;// wenn der Motor sich bewegt, stoppen, wenn er stoppt, anfangen zu bewegen
      firstRun = true;// setze firstRun-Flag, um den Stromstoß zu ignorieren
      fullyRetracted = false; // sobald Sie vorwärts bewegen, sind Sie nicht vollständig eingefahren
      lastButtonpress = millis();//Zeit der letzten Betätigung speichern
      return;
    }//Ende wenn
  }//Ende btnLEFT

  if (digitalRead(buttonRight)==LOW)//rechts ist rückwärts
  {
    currentTimedebounce = millis() - lastButtonpress;// Zeit seit der letzten Betätigung überprüfen
    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// wenn der Motor sich bewegt, stoppen, wenn er stoppt, anfangen zu bewegen
      firstRun = true;// setze firstRun-Flag, um den Stromstoß zu ignorieren
      lastButtonpress = millis();//Zeit der letzten Betätigung speichern
      return;    
    }//Ende wenn
  }//Ende btnRIGHT
} //Ende latchButtons

void moveMotor()
{
  if (leftlatch == HIGH) motorForward(255); //Geschwindigkeit = 0-255
  if (leftlatch == LOW) motorStop();
  if (rightlatch == HIGH) motorBack(255); //Geschwindigkeit = 0-255
  if (rightlatch == LOW) motorStop();
} //Ende 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); // größere Verzögerung, um den Stromstoß zu ignorieren
    else delay(feedbacktimedelay); //kleine Verzögerung, um die Geschwindigkeit zu erreichen
    getFeedback();
    firstRun = false;
    latchButtons();//Tasten erneut überprüfen
  }//Ende während
} //Ende motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//Motor bewegen
    if (firstRun == true) delay(firstfeedbacktimedelay);// größere Verzögerung, um den Stromstoß zu ignorieren
    else delay(feedbacktimedelay); //kleine Verzögerung, um die Geschwindigkeit zu erreichen
    getFeedback();
    firstRun = false;
    latchButtons();//Tasten erneut überprüfen
  }//Ende während
  dontExtend = false;//Erlauben, dass der Motor wieder ausfährt, nachdem er eingefahren wurde
} //Ende motorBack

void motorStop()
{
  analogWrite(PWMPinA, 0);
  analogWrite(PWMPinB, 0);
  digitalWrite(EnablePin, LOW);
  firstRun = true;//sobald der Motor gestoppt ist, firstRun wieder aktivieren, um die Stromstoßspitzen zu berücksichtigen
} //Ende stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Strom lesen
  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // überprüfen, ob der Motor an den Grenzen ist und der Strom gestoppt hat 
  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // Motor stoppen
    fullyRetracted = true;
  }//Ende wenn
  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//Motor stoppen
    hitLimits = 0;
  }//Ende wenn
  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //stoppen, wenn das Feedback über dem Maximum liegt
  }//Ende wenn
  lastfeedbacktime = millis();//vorherige Zeit für den Empfang von Feedback speichern
} //Ende getFeedback

Mit diesem grundlegenden Code werden Sie erfolgreich das Feedback Ihres Linearaktuators überwachen. In Teil II werden wir näher darauf eingehen, wie der Code funktioniert und wie Sie ihn nach Ihren Wünschen bearbeiten können. Wir hoffen, dass Sie diesen Beitrag hilfreich fanden und bleiben Sie dran für Teil II in den kommenden Wochen. Wenn Sie eine der Einheiten bestellen möchten, die wir in diesem Beispiel verwendet haben, oder mehr über unsere Produkte erfahren möchten, kontaktieren Sie uns.