Control del actuador de entrada de posición con un Arduino

La programación de un PLC para controlar su actuador puede ser uno de los proyectos más difíciles de emprender. Requiere prueba y error, pruebas y un montón de paciencia; Aunque los resultados pueden ser increíblemente funcionales y gratificantes.

Este código es para un funcional Actuador de respuesta en serie. Este es un código construido con el cliente de Nicola Buccoliero, un ingeniero italiano de 24 años de Universtà Campus Bio-Medico en Roma, trabajando en su tesis con Upenn.

El alimento en serie es un Leger de operaciones que toma un Arduino, con datos adicionales enviados dentro o fuera de la unidad Arduino según lo programado. Con este código, escribir un número en el monitor en serie le indicará a su Arduino dónde desea que su actuador se mueva.

Esto es lo que hace el código:

1. Inicialización (configuración):
   • Establece las conexiones con el motor y el sensor de retroalimentación del actuador.
2. Viendo el monitor en serie para obtener instrucciones:
   • El Arduino está buscando que ingrese un número. Cuando ve un número ingresado en la alimentación en serie, comienza a mover el motor.
3. Moviendo el motor:
   • Cuando se establece la posición objetivo, el Arduino comenzará a mover el actuador hacia el objetivo. Mantiene un ojo en el sensor para saber cuándo alcanza ese punto.
4. Parada en la ubicación:
   • A medida que se mueve, sigue revisando el sensor. Una vez que el sensor dice que está en el lugar correcto, el sistema detiene el motor.
5. Espere la siguiente instrucción:
   • El sistema esperará más instrucciones. Cuando escucha un nuevo mensaje, comienza a moverse nuevamente, siguiendo el mismo proceso.

Este código ayuda a controlar un motor para ir a un lugar específico, detenerse allí y estar listo para hacerlo de nuevo cuando se lo indique.

Este código está destinado a comenzar con un actuador completamente retirado, lo que significa que la posición "0" es el extremo del trazo completamente retraído. Sin embargo, este código funcionará si el actuador se inicializa mientras se extiende; deberá ingresar un valor entero negativo para mover el actuador hacia atrás (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