Este código de ejemplo utiliza un MegaMoto Plus para monitorear la corriente de un actuador lineal.

 /* Código para monitorear el consumo de amperaje actual del actuador y para cortar la energía si
 supera cierta cantidad.

 Escrito por Automatizaciones Progresivas
 19 de agosto de 2015

 Hardware:
 - Tableros de control RobotPower MegaMoto
 -Arduino Uno
 - 2 pulsadores
 */

 const intEnablePin = 8;
 const intPWMPinA = 11;
 constanteintPWMPinB = 3; // pines para Megamoto

 const int botónIzquierda = 4;
 const int buttonRight = 5;//botones para mover el motor

 constante int CPin1 = A5; // retroalimentación motora

 int cierre izquierdo = BAJO;
 int rightlatch = LOW;//pestillos del motor (usados ​​para la lógica del código)

 int hitLimits = 0;//comienza en 0
 int hitLimitsmax = 10;//valores para saber si se alcanzaron los límites de viaje

 último tiempo de retroalimentación prolongado = 0; // debe ser largo, de lo contrario se desborda
 int retardo del tiempo de primera retroalimentación = 750; //primer retraso para ignorar el pico actual 
int tiempo de retroalimentación = 50; //retraso entre ciclos de retroalimentación, con qué frecuencia desea que se revise el motor
 retroalimentación de tiempo actual larga = 0; // debe ser largo, de lo contrario se desborda

 int tiempo de rebote = 300; //cantidad para evitar rebotes en los botones, los valores más bajos hacen que los botones sean más sensibles
 último botón presionado = 0; // temporizador para antirrebote
 long currentTimedebounce = 0;

 intCRaw = 0; // valor de entrada para las lecturas actuales
 int máxAmps = 0; // límite de viaje

 bool dontExtend = falso;
 bool primera ejecución = verdadero;
 boolfullyRetracted = false;//lógica del programa

 configuración nula()
 {
 Serie.begin(9600);
 pinMode(EnablePin, SALIDA);
 pinMode(PWMPinA, SALIDA);
 pinMode(PWMPinB, OUTPUT);//Establecer salidas del motor
 pinMode(botónIzquierdo, ENTRADA);
 pinMode(botónDerecha, ENTRADA);//botones

 digitalWrite(botónIzquierda, ALTA);
 digitalWrite(buttonRight, HIGH);//habilita pullups internos
 pinMode(CPin1, INPUT);//establecer entrada de retroalimentación

 currentTimedebounce = milis();
 currentTimefeedback = 0;//Establecer tiempos iniciales

 maxAmps = 15;// ESTABLEZCA LA CORRIENTE MÁXIMA AQUÍ

 }//finalizar configuración

 bucle vacío()
 { 
latchButtons();//verificar botones, ver si necesitamos movernos

 moveMotor();//revisa los pestillos, mueve el motor hacia adentro o hacia afuera

 }//finalizar el bucle principal

 Botones de cierre vacíos()
 {
 if (digitalRead(buttonLeft)==LOW)//izquierda es hacia adelante
 {
 currentTimedebounce = millis() - lastButtonpress;// comprobar el tiempo desde la última pulsación
 if (currentTimedebounce > debounceTime && dontExtend == false)//una vez que haya activado dontExtend, ignore todas las pulsaciones hacia adelante
 {
 leftlatch = !leftlatch;// si el motor se está moviendo, se detiene, si está parado, comienza a moverse
 firstRun = true;// establece el indicador firstRun para ignorar el pico actual
 completamente retraído = falso; // una vez que avanzas, no estás completamente retraído
 lastButtonpress = millis();//almacenar la hora de la última pulsación del botón
 devolver;
 }//terminara si
 }//fin de botón IZQUIERDA

 if (digitalRead(buttonRight)==LOW)//la derecha está al revés
 {
 currentTimedebounce = millis() - lastButtonpress;// comprobar el tiempo desde la última pulsación

 if (tiempo actual de rebote > tiempo de rebote)
 { 
rightlatch = !rightlatch;// si el motor se está moviendo, se detiene, si está parado, comienza a moverse
 firstRun = true;// establece el indicador firstRun para ignorar el pico actual
 lastButtonpress = millis();//almacenar la hora de la última pulsación del botón
 devolver; }//terminara si
 }//finalizar btnDERECHA
 }//finalizar botones de cierre

 movimiento vacíoMotor()
 {
 if (cierre izquierdo == ALTO) motorForward(255); //velocidad = 0-255
 if (cierre izquierdo == BAJO) motorStop();
 if (cierre derecho == ALTO) motorBack(255); //velocidad = 0-255
 if (cierre derecho == BAJO) motorStop();

 }//finalizar movimientoMotor

 motor vacíoAdelante(velocidad int)
 {
 mientras (dontExtend == false && leftlatch == ALTO)
 {
 escritura digital (EnablePin, ALTA);
 analogWrite(PWMPinA, velocidad);
 analogWrite(PWMPinB, 0);//mueve el motor
 si (primera ejecución == verdadero) retraso (primera demora en el tiempo de retroalimentación); // mayor retraso para ignorar el pico actual
 de lo contrario demora (retraso del tiempo de retroalimentación); //pequeño retraso para alcanzar la velocidad

 obtener comentarios();
 primera ejecución = falso;

 latchButtons();//verificar botones nuevamente
 }//finalizar mientras

 }//final del motorAdelante

 motor vacíoBack (velocidad int)
 { 
mientras (cierre derecho == ALTO)
 {
 escritura digital (EnablePin, ALTA);
 escritura analógica(PWMPinA, 0);
 analogWrite(PWMPinB, velocidad);//mueve el motor
 if (firstRun == true) delay(firstfeedbacktimedelay);// retraso mayor para ignorar el pico actual
 de lo contrario demora (retraso del tiempo de retroalimentación); //pequeño retraso para alcanzar la velocidad
 obtener comentarios();

 primera ejecución = falso;

 latchButtons();//verificar botones nuevamente

 }//finalizar mientras

 dontExtend = false;//permitir que el motor se extienda nuevamente, después de haber sido retraído

 }//final del motorVolver

 parada de motor anulada()
 {
 escritura analógica(PWMPinA, 0);
 escritura analógica(PWMPinB, 0);

 escritura digital (EnablePin, BAJO);
 firstRun = true;//una vez que el motor se haya detenido, vuelva a habilitar firstRun para tener en cuenta los picos de corriente de arranque

 }//finalizar paradaMotor

 anular la retroalimentación()
 {
 CRaw = analogRead(CPin1); // Leer actual

 if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
 de lo contrario hitLimits = 0; // verificamos si el motor está en los límites y la corriente se ha detenido

 if (hitLimits == hitLimitsmax && rightlatch == ALTO)
 { 
pestillo derecho = BAJO; //parar el motor
 completamente retraído = verdadero;
 }//terminara si

 de lo contrario, si (hitLimits == hitLimitsmax && leftlatch == ALTO)
 {
 pestillo izquierdo = BAJO;//detener el motor
 límites de impacto = 0;
 }//terminara si

 si (CRaw > maxAmps)
 {
 no extender = verdadero;
 pestillo izquierdo = BAJO; //se detiene si la retroalimentación supera el máximo
 }//terminara si

 lastfeedbacktime = millis();//almacenar la hora anterior para recibir comentarios
 }//finalizar obtener comentarios

Este código de ejemplo muestra cómo controlar hasta 4 de nuestros actuadores lineales con el LC-82 MultiMoto Arduino Shield . Debido a las limitaciones actuales en cada canal del MultiMoto, este código solo está diseñado para usarse con nuestros modelos de actuador PA-14 , PA-14P .

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

 Alambrado:
 - Conectar los actuadores a las conexiones M1, M2, M3, M4 de la placa MultiMoto.
 - Conectar el negativo (negro) a la conexión derecha, el positivo (rojo) a la izquierda. 
- Conecte una fuente de 12 voltios (mínimo 1 A por motor si está descargado, 8 A por motor si está completamente cargado) a los terminales BAT. Asegúrese de que lo positivo y lo negativo estén colocados 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 de Robot Power MultiMoto v1.0
 Este software se libera al dominio público.
 */

 // incluye la biblioteca SPI:

 #incluir <SPI.h>
 // L9958 pines de selección esclavos para SPI
 #definir SS_M4 14
 #definir SS_M3 13
 #definir SS_M2 12
 #definir SS_M1 11
 // Pines de dirección L9958
 #definir DIR_M1 2
 #definir DIR_M2 3
 #definir DIR_M3 4
 #definir DIR_M4 7
 // pines L9958 PWM
 #definir PWM_M1 9
 #definir PWM_M2 10 // Temporizador1
 #definir PWM_M3 5
 #definir PWM_M4 6 // Temporizador0


 // L9958 Habilitado para los 4 motores
 #definir ENABLE_MOTORS 8

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

 configuración nula() {
 palabra de configuración int sin firmar;

 // pon tu código de configuración aquí, para ejecutarlo una vez: 
pinMode(SS_M1, SALIDA); escritura digital (SS_M1, BAJO); // ALTO = no seleccionado
 pinMode(SS_M2, SALIDA); escritura digital (SS_M2, BAJO);
 pinMode(SS_M3, SALIDA); escritura digital (SS_M3, BAJO);
 pinMode(SS_M4, SALIDA); escritura digital (SS_M4, BAJO);

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

 // pines L9958 PWM
 pinMode(PWM_M1, SALIDA); escritura digital (PWM_M1, BAJO);
 pinMode(PWM_M2, SALIDA); escritura digital (PWM_M2, BAJO); // Temporizador1
 pinMode(PWM_M3, SALIDA); escritura digital (PWM_M3, BAJO);
 pinMode(PWM_M4, SALIDA); escritura digital (PWM_M4, BAJO); // Temporizador0

 // L9958 Habilitado para los 4 motores
 pinMode(ENABLE_MOTORS, SALIDA);
 escritura digital (ENABLE_MOTORS, ALTA); // ALTO = deshabilitado

 / /******* Configurar chips L9958 *********
 ' L9958 Registro de configuración
 ' Poco
 '0-RES
 '1 - DR - restablecer
 '2 - CL_1 - límite actual
 '3 - CL_2 - límite_actual
 '4 - RES
 '5 - RES
 '6 - RES
 '7 - RES
 '8 - VSR - tasa de variación de voltaje (1 habilita el límite de variación, 0 lo deshabilita) 
'9 - ISR - velocidad de giro actual (1 habilita el límite de giro, 0 lo deshabilita)
 '10 - ISR_DIS - desactivación de giro actual
 '11 - OL_ON - habilitar carga abierta
 '12 - RES
 '13 - RES
 '14 - 0 - siempre cero
 '15 - 0 - siempre cero
 */ // establece el límite de corriente máximo y desactiva la limitación de giro de ISR
 palabra de configuración = 0b0000010000001100;

 SPI.begin();
 SPI.setBitOrder(LSBFIRST);
 SPI.setDataMode(SPI_MODE1); // reloj pol = bajo, fase = alta

 // Motor 1
 escritura digital (SS_M1, BAJO);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 escritura digital (SS_M1, ALTA);
 // Motor 2
 escritura digital (SS_M2, BAJO);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 escritura digital (SS_M2, ALTA);
 // Motor 3
 escritura digital (SS_M3, BAJO);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 escritura digital (SS_M3, ALTA);
 // Motor 4
 escritura digital (SS_M4, BAJO);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 escritura digital (SS_M4, ALTA);
 
//Establece la configuración inicial del actuador para tirar a velocidad 0 por seguridad
 directorio1 = 0; directorio2 = 0; directorio3 = 0; directorio4 = 0; // Establecer dirección
 pmm1 = 0; pmm2 = 0; pmm3 = 0; pmm4 = 0; // Establecer velocidad (0-255)

 digitalWrite(ENABLE_MOTORS, LOW);// LOW = habilitado
 } // Finalizar configuración

 bucle vacío() {
 directorio1 = 1;
 pmm1 = 255; //establecer dirección y velocidad
 escritura digital (DIR_M1, dir1);
 escritura analógica(PWM_M1, pwm1); //escribir en pines

 directorio2 = 0;
 pmm2 = 128;
 escritura digital (DIR_M2, dir2);
 escritura analógica(PWM_M2, pwm2);

 directorio3 = 1;
 pmm3 = 255;
 escritura digital (DIR_M3, dir3);
 escritura analógica(PWM_M3, pwm3);

 directorio4 = 0;
 pmm4 = 128;
 escritura digital (DIR_M4, dir4);
 escritura analógica(PWM_M4, pwm4);

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

 directorio1 = 0;
 pmm1 = 128;
 escritura digital (DIR_M1, dir1);
 escritura analógica(PWM_M1, pwm1);

 directorio2 = 1;
 pmm2 = 255;
 escritura digital (DIR_M2, dir2);
 escritura analógica(PWM_M2, pwm2);

 directorio3 = 0;
 pmm3 = 128;
 escritura digital (DIR_M3, dir3);
 escritura analógica(PWM_M3, pwm3);

 directorio4 = 1;
 pmm4 = 255; 
escritura digital (DIR_M4, dir4);
 escritura analógica(PWM_M4, pwm4);

 retraso(5000);

 }//finalizar bucle vacío

Este código de ejemplo es para combinar nuestro LC-85 Wasp con nuestro LC-066 para controlar el movimiento de un actuador lineal .

 /*Código de muestra para Robot Power Wasp.

 Este ESC se controla mediante señales RC, con pulsos
 que van desde 1000 - 2000 microsegundos.

 El bucle principal de este programa mantiene el actuador quieto durante 1 segundo, se extiende durante 2 segundos,
 se detiene durante 1 segundo, se retrae durante 2 segundos y se repite.

 Modificado por Automatizaciones progresivas, utilizando el código de ejemplo original "Sweep" del
 Bibliotecas de ejemplo de Arduino.

 Hardware:
 - 1 controlador de avispa
 -Arduino Uno

 Alambrado:
 Lado de control: 
- Conecte el rojo/negro a +5v y GND
 - Conecte el cable amarillo a su pin de señal en el Arduino (en este ejemplo, pin 9)
 Lado de potencia:
 - Conectar el +/- de la alimentación de los motores a las conexiones +/- del Wasp.
 - Conectar el +/- del actuador a las dos conexiones restantes.

 Este código de ejemplo es de dominio público.
 */

 #incluir <servo.h>
 Servo myservo; // crea un objeto servo para controlar un servo
 // se pueden crear doce objetos servo en la mayoría de las placas

 int pos = 0; // variable para almacenar la posición del servo

 configuración nula()
 {
 myservo.attach(9); // conecta el servo en el pin 9 al objeto servo
 }

 bucle vacío()
 {

 myservo.writeMicrosegundos(1500); // señal de parada
 retraso(1000); //1 segundo

 myservo.writeMicrosegundos(2000); // señal de avance a toda velocidad
 retraso(2000); //2 segundos

 myservo.writeMicrosegundos(1500); // señal de parada
 retraso(1000); // 1 segundo

 myservo.writeMicrosegundos(1000); // señal de marcha atrás a máxima velocidad
 retraso(2000); //2 segundos

 }

Este código de ejemplo utiliza nuestros relés y nuestro LC-066 para controlar un actuador lineal. Puede leer nuestra publicación de blog completa para obtener más detalles.

 constante int hacia adelante = 7;
 const int al revés = 6;//asigna el pin INx del relé al pin arduino

 configuración nula() {

 pinMode(forwards, OUTPUT);//establece el relé como salida
 pinMode(hacia atrás, SALIDA);//establece el relé como salida

 }

 bucle vacío() {

 escritura digital (hacia adelante, BAJO);
 digitalWrite(backwards, HIGH);//Activa el relé en una dirección, deben ser diferentes para mover el motor
 retraso(2000); // espera 2 segundos

 escritura digital (hacia adelante, ALTA);
 digitalWrite(hacia atrás, ALTA);//Desactiva ambos relés para frenar el motor
 retraso(2000);// espera 2 segundos

 escritura digital (hacia adelante, ALTA);
 digitalWrite(hacia atrás, LOW);//Activa el relé en la otra dirección, deben ser diferentes para mover el motor
 retraso(2000);// espera 2 segundos

 escritura digital (hacia adelante, ALTA);
 digitalWrite(hacia atrás, ALTA);//Desactiva ambos relés para frenar el motor
 retraso(2000);// espera 2 segundos

 }

Este código de ejemplo utiliza nuestro LC-80 , cualquier actuador lineal y una fuente de alimentación. Puede obtener más detalles sobre el código y lo que hace en nuestra publicación de blog .

 //Usa los puentes en el tablero para seleccionar qué pines se usarán
 intEnablePin1 = 13;
 intPWMPinA1 = 11;
 intPWMPinB1 = 3;


 int tiempo extendido = 10 * 1000; // 10 segundos, multiplicados por 1000 para convertir a milisegundos
 int tiempo de retracción = 10 * 1000; // 10 segundos, multiplicados por 1000 para convertir a milisegundos
 int tiempo de ejecución = 300 * 1000; // 300 segundos, multiplicados por 1000 para convertir a milisegundos


 deber internacional;
 int tiempo transcurrido;
 booleano keepMoving;


 configuración nula() {
 Serie.begin(9600);
 pinMode(EnablePin1, OUTPUT);//Habilita la placa
 pinMode(PWMPinA1, SALIDA);
 pinMode(PWMPinB1, OUTPUT);//Establecer salidas del motor
 tiempo transcurrido = 0; // Establece el tiempo en 0
 mantenerMovimiento = verdadero; //El sistema se moverá

 }//finalizar configuración
 bucle vacío() {
 si (sigue moviéndote)
 {
 escritura digital (EnablePin1, ALTA); // habilitar el motor
 empujarActuador();
 retraso (tiempo extendido);
 detenerActuador();
 delay(10);//pequeño retraso antes de retractarse

 pullActuador();
 retraso (tiempo de retracción);
 detenerActuador();

 elapsedTime = millis();//¿cuánto tiempo ha pasado?
 if (elapsedTime > timetorun) {//si han pasado 300 segundos, detente

 Serial.print("El tiempo transcurrido supera el tiempo máximo de ejecución. Tiempo máximo de ejecución: ");
 Serial.println(timetorun);
 mantenerMovimiento = falso;
 }
 }//terminara si
 }//finalizar el bucle principal


 parada vacíaActuador() {
 escritura analógica(PWMPinA1, 0);
 escritura analógica(PWMPinB1, 0); // velocidad 0-255
 }


 vacío pushActuator() {
 escritura analógica(PWMPinA1, 255);
 escritura analógica(PWMPinB1, 0); // velocidad 0-255
 }


 vacío pullActuator() {
 escritura analógica(PWMPinA1, 0);
 escritura analógica(PWMPinB1, 255);//velocidad 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
 }