Contrôle de l'actionneur à entrée de position avec un arduino

La programmation d'un PLC pour contrôler votre actionneur peut être l'un des projets les plus difficiles à entreprendre. Il nécessite des essais et des erreurs, des tests et un tas de patience; Bien que les résultats puissent être incroyablement fonctionnels et enrichissants.

Ce code est pour un fonctionnel Actionneur réactif en série. Ceci est un code construit par le client de Nicola Buccoliero, un ingénieur italien de 24 ans de l'Universtà Campus Bio-Medico à Rome, travaillant sur leur thèse avec UPENN.

Le flux de série est un lait d'opérations qu'un Arduino prend, avec des données supplémentaires envoyées dans ou hors de l'unité Arduino comme programmée. Avec ce code, la saisie d'un nombre dans le moniteur série indiquera à votre Arduino où vous voulez que votre actionneur se déplace.

Voici ce que fait le code:

1. Initialisation (configuration):
   • Il établit les connexions au moteur et au capteur de rétroaction de l'actionneur.
2. Regarder le moniteur en série pour les instructions:
   • L'Arduino vous cherche pour saisir un nombre. Lorsqu'il voit un nombre entré dans le flux de série, il commence à déplacer le moteur.
3. Déplacer le moteur:
   • Lorsque la position cible est définie, l'Arduino commencera à déplacer l'actionneur vers la cible. Il garde un œil sur le capteur de savoir quand il atteint ce point.
4. Arrêt à l'emplacement:
   • Au fur et à mesure qu'il se déplace, il continue de vérifier le capteur. Une fois que le capteur dit qu'il est au bon endroit, le système arrête le moteur.
5. Attendez l'instruction suivante:
   • Le système attendra d'autres instructions. Lorsqu'il entend un nouveau message, il recommence à bouger, en suivant le même processus.

Ce code aide à contrôler un moteur pour aller dans un endroit spécifique, s'arrêter là et être prêt à recommencer lorsqu'il est dit.

Ce code est destiné à commencer par un actionneur entièrement rétracté, ce qui signifie que la position "0" est l'extrémité entièrement rétractée de la course. Cependant, ce code fonctionnera si l'actionneur est initialisé tout en étant étendu - vous devrez saisir une valeur entière négative pour faire reculer l'actionneur (ex: -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