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 }