Este código de ejemplo utiliza MegaMoto Plus y un Arduino Uno para monitorear la corriente de un actuador lineal; sin embargo, pueden utilizarse productos similares como sustitutos.

/*  Code to monitor the current amp draw of the actuator, and to cut power if it
  rises above a certain amount.

  Written by Progressive Automations
  August 19th, 2015

  Hardware:
  - RobotPower MegaMoto control boards
  - Arduino Uno
  - 2 pushbuttons
 */

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

long lastfeedbacktime = 0; // must be long, else it overflows
int firstfeedbacktimedelay = 750; //first delay to ignore current spike
int feedbacktimedelay = 50; //delay between feedback cycles, how often you want the motor to be checked
long currentTimefeedback = 0; // must be long, else it overflows

int debounceTime = 300; //amount to debounce buttons, lower values makes the buttons more sensitive
long 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 moving
      firstRun = 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

Este código de ejemplo muestra cómo controlar hasta 4 de nuestros actuadores lineales con el Arduino Uno y la Shield Arduino MultiMoto LC-82; no obstante, se pueden usar productos similares como sustitutos. Este código está destinado únicamente a usarse con modelos de actuadores dentro de las limitaciones actuales de cada canal de la MultiMoto, como los PA-14 y PA-14P.

/*    Código de ejemplo para controlar hasta 4 actuadores, usando el controlador Robot Power MultiMoto.
   Hardware:
    - Robot Power MultiMoto
    - Arduino Uno

    Cableado:
  - Conecta los actuadores a las conexiones M1, M2, M3 y M4 en la placa MultiMoto.
  - Conecta el negativo (negro) a la conexión derecha y el positivo (rojo) a la izquierda.
  - Conecta una fuente de 12 voltios (mínimo 1 A por motor sin carga, 8 A por motor a plena carga) a los terminales BAT. Asegúrate de que el positivo y el negativo estén en los lugares correctos.

   Código modificado por Progressive Automations a partir del código de ejemplo proporcionado por Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Demostración Robot Power MultiMoto v1.0
    Este software se publica en el dominio público
*/

// incluir la biblioteca SPI:

#include <SPI.h>
// Pines de selección del esclavo (SS) del L9958 para SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// Pines de dirección del L9958
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// Pines PWM del L9958
#define PWM_M1 9
#define PWM_M2 10    // Timer1
#define PWM_M3 5
#define PWM_M4 6     // Timer0


// Habilitación del L9958 para los 4 motores
#define ENABLE_MOTORS 8

int pwm1, pwm2, pwm3, pwm4;
boolean dir1, dir2, dir3, dir4;

void setup() {
  unsigned int configWord;

  // Pon aquí tu código de configuración; se ejecuta una vez:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = no seleccionado
  pinMode(SS_M2, OUTPUT); digitalWrite(SS_M2, LOW);
  pinMode(SS_M3, OUTPUT); digitalWrite(SS_M3, LOW);
  pinMode(SS_M4, OUTPUT); digitalWrite(SS_M4, LOW);

  // Pines de dirección del L9958
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

  // Pines PWM del L9958
  pinMode(PWM_M1, OUTPUT);  digitalWrite(PWM_M1, LOW);
  pinMode(PWM_M2, OUTPUT);  digitalWrite(PWM_M2, LOW);    // Timer1
  pinMode(PWM_M3, OUTPUT);  digitalWrite(PWM_M3, LOW);
  pinMode(PWM_M4, OUTPUT);  digitalWrite(PWM_M4, LOW);    // Timer0

  // Habilitación del L9958 para los 4 motores
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = deshabilitado

/ /******* Configurar los chips L9958 *********
  ' Registro de configuración del L9958
  ' Bit
  '0 - RES
  '1 - DR - reinicio
  '2 - CL_1 - límite de corriente
  '3 - CL_2 - límite de corriente
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - pendiente de voltaje (1 habilita el límite de pendiente, 0 deshabilita)
  '9 - ISR - pendiente de corriente (1 habilita el límite de pendiente, 0 deshabilita)
  '10 - ISR_DIS - deshabilitar pendiente de corriente
  '11 - OL_ON - habilitar carga abierta
  '12 - RES
  '13 - RES
  '14 - 0 - siempre cero
  '15 - 0 - siempre cero
  */  // configurar al límite máximo de corriente y desactivar la limitación de pendiente ISR
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // polaridad del reloj = baja, fase = alta

  // Motor 1
  digitalWrite(SS_M1, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M1, HIGH);
  // Motor 2
  digitalWrite(SS_M2, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M2, HIGH);
  // Motor 3
  digitalWrite(SS_M3, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M3, HIGH);
  // Motor 4
  digitalWrite(SS_M4, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M4, HIGH);

  // Configurar inicialmente los actuadores para retraer a velocidad 0 por seguridad
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Establecer dirección
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Establecer velocidad (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = habilitado
} // Fin de la configuración

void loop() {
    dir1 = 1;
    pwm1 = 255; //establecer dirección y velocidad 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // escribir en los pines

    dir2 = 0;
    pwm2 = 128;
    digitalWrite(DIR_M2, dir2);
    analogWrite(PWM_M2, pwm2);

    dir3 = 1;
    pwm3 = 255;
    digitalWrite(DIR_M3, dir3);
    analogWrite(PWM_M3, pwm3);

    dir4 = 0;
    pwm4 = 128;
    digitalWrite(DIR_M4, dir4);
    analogWrite(PWM_M4, pwm4);

    delay(5000); // espera una vez que los cuatro motores estén configurados

    dir1 = 0;
    pwm1 = 128;
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1);

    dir2 = 1;
    pwm2 = 255;
    digitalWrite(DIR_M2, dir2);
    analogWrite(PWM_M2, pwm2);

    dir3 = 0;
    pwm3 = 128;
    digitalWrite(DIR_M3, dir3);
    analogWrite(PWM_M3, pwm3);

    dir4 = 1;
    pwm4 = 255;
    digitalWrite(DIR_M4, dir4);
    analogWrite(PWM_M4, pwm4);

   delay(5000); 

}//fin de void loop

Este código de ejemplo combina el controlador de velocidad de un solo canal Wasp con el Arduino Uno para controlar el movimiento de un actuador lineal; sin embargo, pueden utilizarse productos similares como sustitutos.

/*Sample code for the Robot Power Wasp. 

 This ESC is controlled using RC signals, with pulses
  ranging from 1000 - 2000 microseconds.

  The main loop of this program holds the actuator still for 1 second, extends for 2 seconds,
  stops for 1 second, retracts for 2 seconds, and repeats.

  Modified by Progressive Automations, using the original example code "Sweep" from the 
  Arduino example libraries. 
  
  Hardware:
  - 1 Wasp Controller
  - Arduino Uno
  
  Wiring:
  Control side:
  - Connect the red/black to +5v and GND
  - Connect the yellow wire to your signal pin on the Arduino (in this example, pin 9)
  Power Side:
  - Connect the +/- of the motors power supply to the +/- connections on the Wasp
  - Connect the +/- of the actuator to the remaining two connections

  This example code is in the public domain.
*/ 

#include <servo.h>  
Servo myservo;  // create servo object to control a servo 
                // twelve servo objects can be created on most boards
 
int pos = 0;    // variable to store the servo position 
 
void setup() 
{ 
  myservo.attach(9);  // attaches the servo on pin 9 to the servo object 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // stop signal
    delay(1000);  //1 second
    
    myservo.writeMicroseconds(2000); // full speed forwards signal
    delay(2000); //2 seconds  
    
    myservo.writeMicroseconds(1500); // stop signal
    delay(1000);  // 1 second
    
    myservo.writeMicroseconds(1000); // full speed reverse signal
    delay(2000); //2 seconds   

}

Este código de ejemplo utiliza nuestros relés y un Arduino Uno para controlar un actuador lineal; no obstante, se pueden usar productos similares como sustitutos. Puedes leer nuestra entrada del blog completa para más detalles.

const int forwards = 7;
const int backwards = 6;//asignar el pin INx del relé al pin de Arduino

void setup() {
 
pinMode(forwards, OUTPUT);//configurar el relé como salida
pinMode(backwards, OUTPUT);//configurar el relé como salida

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Activar el relé en una dirección; deben ser diferentes para mover el motor
 delay(2000); // esperar 2 segundos

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Desactivar ambos relés para frenar el motor
 delay(2000);// esperar 2 segundos
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Activar el relé en la otra dirección; deben ser diferentes para mover el motor
 delay(2000);// esperar 2 segundos

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Desactivar ambos relés para frenar el motor
 delay(2000);// esperar 2 segundos

}

Este código de ejemplo usa nuestro LC-80, un Arduino Uno, cualquier actuador lineal y una fuente de alimentación; sin embargo, se pueden usar productos similares como sustitutos. Puedes obtener más detalles sobre el código y lo que hace en nuestra entrada del blog.

//Use the jumpers on the board to select which pins will be used
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;


int extendtime = 10 * 1000;  // 10 seconds, times 1000 to convert to milliseconds
int retracttime = 10 * 1000; // 10 seconds, times 1000 to convert to milliseconds
int timetorun = 300 * 1000; // 300 seconds, times 1000 to convert to milliseconds


int duty;
int elapsedTime;
boolean keepMoving;


void setup() {
  Serial.begin(9600);
  pinMode(EnablePin1, OUTPUT);//Enable the board
  pinMode(PWMPinA1, OUTPUT);
  pinMode(PWMPinB1, OUTPUT);//Set motor outputs
  elapsedTime = 0; // Set time to 0
  keepMoving = true; //The system will move
  
}//end setup
void loop() {
  if (keepMoving) 
  {
    digitalWrite(EnablePin1, HIGH); // enable the motor
    pushActuator();
    delay(extendtime);
    stopActuator();
    delay(10);//small delay before retracting
    
    pullActuator();
    delay(retracttime);
    stopActuator();
    
    elapsedTime = millis();//how long has it been?
    if (elapsedTime > timetorun) {//if it's been 300 seconds, stop

      Serial.print("Elapsed time is over max run time. Max run time: ");
      Serial.println(timetorun);
      keepMoving = false;  
    }
  }//end if
}//end main loop


void stopActuator() {
  analogWrite(PWMPinA1, 0);
  analogWrite(PWMPinB1, 0); // speed 0-255
}


void pushActuator() {
  analogWrite(PWMPinA1, 255);
  analogWrite(PWMPinB1, 0); // speed 0-255
}


void pullActuator() {
  analogWrite(PWMPinA1, 0);
  analogWrite(PWMPinB1, 255);//speed 0-255
}

Este programa se puede utilizar para extender y retraer continuamente la carrera de un actuador lineal.

 CÓDIGO DE BUCLE DE CONFIGURACIÓN
 configuración nula() {
 Serie.begin(9600); // inicializa la comunicación serie a 9600 bits por segundo

 pinMode(out_lim, INPUT_PULLUP); // configura el pin 45 como pin de entrada
 pinMode(in_lim, INPUT_PULLUP); // configura el pin 53 como pin de entrada
 pinMode(run_f, SALIDA); // configura el pin 25 como pin de salida
 pinMode(run_r, SALIDA); // configura el pin 30 como pin de salida

 retraer(); // retrae el trazo al iniciar
 retraso(500);
 }
 void extend() // esta función permite que el motor funcione
 {
 escritura digital (run_f, BAJO); 
escritura digital (ejecutar_r, ALTA);
 }

 void retract() // esta función invierte la dirección del motor
 {
 escritura digital (run_f, BAJO);
 escritura digital (run_r, BAJO);
 }

 void run_stop() // esta función desactiva el motor
 {
 escritura digital (run_f, ALTA);
 escritura digital (ejecutar_r, ALTA);
 }
 bucle vacío() {
 int out_lim_state = digitalRead(out_lim); // lee los finales de carrera y guarda su valor
 int in_lim_state = digitalRead(in_lim);

 Serial.print("valor del interruptor de límite exterior "), Serial.println(out_lim_state); // 0 -> se presiona el interruptor de límite
 Serial.print("valor del interruptor de límite interno "), Serial.println(in_lim_state); // 1 -> el interruptor de límite no está presionado

 if (out_lim_state == 0 && in_lim_state == 1) // si se presiona el interruptor de límite externo y el interno no (extendido por completo)
 {
 retraer(); // retraer el trazo
 }

 else if (out_lim_state == 1 && in_lim_state == 0) // si se presiona el interruptor de límite interno y el externo no (se vuelve a colocar completamente)
 {
 extender(); // extender el trazo
 }

 else // de lo contrario no hacer nada
 {

 } 
retraso(5); // retraso entre lecturas para mayor estabilidad
 }