Stellantriebskontrolle mit einem Arduino

Das Programmieren einer SPS zur Kontrolle Ihres Aktuators kann eines der schwierigeren Projekte sein. Es erfordert Versuch und Irrtum, Tests und eine Menge Geduld; Obwohl die Ergebnisse unglaublich funktional und lohnend sein können.

Dieser Code ist für eine funktionale Serieller Antriebsantrieb. Dies ist ein von Kunden gebautes Code von Nicola Buccoliero, ein 24-jähriger italienischer Ingenieur von Universtà Campus Bio-Medico in Rom, der mit Upenn an ihrer These arbeitet.

Der serielle Feed ist ein Leger von Operationen, die ein Arduino nimmt, wobei zusätzliche Daten in oder aus der Arduino -Einheit gesendet werden. Wenn Sie mit diesem Code eine Nummer in den Serienmonitor eingeben, teilt es Ihrem Arduino mit, wo sich Ihr Aktuator bewegen soll.

Hier ist, was der Code tut:

1. Initialisierung (einrichten):
   • Es stellt die Verbindungen zum Motor und zum Feedback -Sensor des Aktuators ein.
2. Beobachten Sie den Serienmonitor für Anweisungen:
   • Der Arduino sucht Sie, um eine Zahl einzugeben. Wenn eine in das serielle Futter eingegebene Zahl eingebracht wird, wird der Motor bewegt.
3. Den Motor bewegen:
   • Wenn die Zielposition festgelegt ist, wird der Arduino den Aktuator zum Ziel bewegen. Es hält den Sensor im Auge, zu wissen, wann er diesen Punkt erreicht.
4. Stoppen am Ort:
   • Wenn es sich bewegt, überprüft es den Sensor immer wieder. Sobald der Sensor sagt, dass er sich an der richtigen Stelle befindet, stoppt das System den Motor.
5. Warten Sie auf die nächste Anweisung:
   • Das System wartet auf weitere Anweisungen. Wenn es eine neue Nachricht hört, beginnt es sich wieder zu bewegen, und folgt dem gleichen Vorgang.

Dieser Code hilft, einen Motor zu kontrollieren, um an einen bestimmten Ort zu gelangen, dort anzuhalten und bereit zu sein, wenn man es noch einmal erledigt.

Dieser Code soll mit a beginnen vollständig zurückgezogener AktuatorDas bedeutet, dass die Position "0" das vollständig zurückgezogene Ende des Schlaganfalls ist. Dieser Code funktioniert jedoch, wenn der Aktuator während der Erweiterung initialisiert wird. Sie müssen einen negativen Ganzzahlwert eingeben, um den Aktuator rückwärts zu bewegen (z. B. -1200).

// Input / Output Pins
const int motorPin1 = 10; // Pin to control the motor forward
const int motorPin2 = 11; // Pin to control the motor backward
const int sensorPin = 3;  // Pin to read the sensor

// Variables
int speed = 255; // Adjust to change actuator speed (0-255)

int sensorValue = 0;
int previousSensorValue = 0;
int motorChangeCount = 0;
int lastStoppedCount = 0;
int targetNumber = 0;
bool motorEnabled = false;
bool waitForCommand = true;

void setup() {
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(sensorPin, INPUT);
  Serial.begin(115200);
}

void loop() {
  if (!motorEnabled && Serial.available() > 0) {
    targetNumber = Serial.parseInt();
    if (targetNumber != 0) {
      Serial.print("Target number: ");
      Serial.println(targetNumber);
      motorEnabled = true;
      analogWrite(motorPin1, speed); // Move forward
      analogWrite(motorPin2, 0);   // Stop
     
      // Set the counter to the stopped value, considering the difference between targetNumber and lastStoppedCount
      if (targetNumber > lastStoppedCount) {
        motorChangeCount = lastStoppedCount + 1; // Start from +1
      } else if (targetNumber < lastStoppedCount) {
        motorChangeCount = lastStoppedCount - 1; // Start from -1
      } else {
        motorChangeCount = lastStoppedCount; // Keep the same value
      }
     
      waitForCommand = true;    // Wait for a new input from the serial
    }
  }

  if (motorEnabled) {
    sensorValue = digitalRead(sensorPin);
    if (sensorValue == 1 && previousSensorValue == 0) {
      if (motorChangeCount < targetNumber) {
        motorChangeCount++;
      } else if (motorChangeCount > targetNumber) {
        motorChangeCount--;
      }

      Serial.print("Change from 0 to 1: ");
      Serial.print(motorChangeCount);
      Serial.print(" - Target number: ");
      Serial.println(targetNumber);
    }
    previousSensorValue = sensorValue;

    if (motorChangeCount < targetNumber) {
      analogWrite(motorPin1, speed); // Move forward
      analogWrite(motorPin2, 0);
    } else if (motorChangeCount > targetNumber) {
      analogWrite(motorPin1, 0);
      analogWrite(motorPin2, speed); // Move backward
    } else {
      analogWrite(motorPin1, 0); // Stop the motor when the motor count corresponds to the target number
      analogWrite(motorPin2, 0);
      motorEnabled = false;
      Serial.println("Motor stopped. Awaiting a new number.");
      lastStoppedCount = motorChangeCount; // Store the value of motorChangeCount when the motor stops
      waitForCommand = true; // Wait for new instructions
    }
  }
}
// Code by Nicola Buccoliero