Este código de exemplo usa o MegaMoto Plus e um Arduino Uno para monitorar a corrente de um atuador linear; no entanto, produtos similares podem ser utilizados como alternativas.

/* 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 exemplo mostra como controlar até 4 dos nossos atuadores lineares com o Arduino Uno e o Shield Arduino MultiMoto LC-82; no entanto, produtos similares podem ser usados como substitutos. Este código destina-se apenas ao uso com modelos de atuadores dentro das limitações de corrente de cada canal da MultiMoto, como os PA-14 e PA-14P.

/* Código de exemplo para controlar até 4 atuadores, usando o driver Robot Power MultiMoto.
 Hardware:
 - Robot Power MultiMoto
 - Arduino Uno

 Fiação:
 - Conecte os atuadores às conexões M1, M2, M3 e M4 na placa MultiMoto.
 - Conecte o negativo (preto) à conexão da direita e o positivo (vermelho) à da esquerda.
 - Conecte uma fonte de 12 volts (mínimo de 1 A por motor sem carga, 8 A por motor com carga total) aos terminais BAT. Certifique-se de que o positivo e o negativo estejam nos locais corretos.

 Código modificado pela Progressive Automations a partir do código de exemplo fornecido pela Robot Power
  http://www.robotpower.com/downloads/</a>

 Demonstração Robot Power MultiMoto v1,0
 Este software é disponibilizado em domínio público
*/

// incluir a biblioteca SPI:

#include 
// Pinos de seleção do escravo (SS) do L9958 para SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// Pinos de direção do L9958
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// Pinos PWM do L9958
#define PWM_M1 9
#define PWM_M2 10 // Timer1
#define PWM_M3 5
#define PWM_M4 6 // Timer0


// Habilitação do L9958 para os 4 motores
#define ENABLE_MOTORS 8

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

void setup() {
 unsigned int configWord;

 // Coloque aqui o seu código de configuração; será executado uma vez:
 pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW); // HIGH = não selecionado
 pinMode(SS_M2, OUTPUT); digitalWrite(SS_M2, LOW);
 pinMode(SS_M3, OUTPUT); digitalWrite(SS_M3, LOW);
 pinMode(SS_M4, OUTPUT); digitalWrite(SS_M4, LOW);

 // Pinos de direção do L9958
 pinMode(DIR_M1, OUTPUT);
 pinMode(DIR_M2, OUTPUT);
 pinMode(DIR_M3, OUTPUT);
 pinMode(DIR_M4, OUTPUT);

 // Pinos PWM do 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

 // Habilitação do L9958 para os 4 motores
 pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH); // HIGH = desabilitado

/ /******* Configurar os chips L9958 *********
 ' Registro de configuração do L9958
 ' Bit
 '0 - RES
 '1 - DR - reset
 '2 - CL_1 - limite de corrente
 '3 - CL_2 - limite de corrente
 '4 - RES
 '5 - RES
 '6 - RES
 '7 - RES
 '8 - VSR - taxa de variação de tensão (1 habilita o limite de taxa, 0 desabilita)
 '9 - ISR - taxa de variação de corrente (1 habilita o limite de taxa, 0 desabilita)
 '10 - ISR_DIS - desabilitar taxa de variação de corrente
 '11 - OL_ON - habilitar carga aberta
 '12 - RES
 '13 - RES
 '14 - 0 - sempre zero
 '15 - 0 - sempre zero
 */ // configurar para o limite máximo de corrente e desabilitar a limitação de taxa (slew) do ISR
 configWord = 0b0000010000001100;

 SPI.begin();
 SPI.setBitOrder(LSBFIRST);
 SPI.setDataMode(SPI_MODE1); // pol do clock = baixo, 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);

 //Set initial actuator settings to pull at 0 speed for safety
 dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Definir direção
 pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Definir velocidade (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = habilitado
} // Fim da configuração

void loop() {
 dir1 = 1;
 pwm1 = 255; //definir direção e velocidade 
 digitalWrite(DIR_M1, dir1);
 analogWrite(PWM_M1, pwm1); // escrever nos pinos

 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); // aguarde quando os quatro motores estiverem 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); 

}//fim do void loop

Este código de exemplo combina o controlador de velocidade de um canal Wasp com o Arduino Uno para controlar o movimento de um atuador linear; no entanto, produtos semelhantes podem ser usados como alternativas.

/*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 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 exemplo utiliza nossos relés e um Arduino Uno para controlar um atuador linear; no entanto, produtos semelhantes podem ser usados como substitutos. Você pode ler nossa postagem no blog completa para mais detalhes.

const int forwards = 7;
const int backwards = 6;//atribuir o pino INx do relé ao pino do Arduino

void setup() {
 
pinMode(forwards, OUTPUT);//configurar o relé como saída
pinMode(backwards, OUTPUT);//configurar o relé como saída

}

void loop() {
 
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Ativar o relé em uma direção; eles devem ser diferentes para mover o motor
 delay(2000); // aguardar 2 segundos

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Desativar ambos os relés para frear o motor
 delay(2000);// aguardar 2 segundos
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Ativar o relé na outra direção; eles devem ser diferentes para mover o motor
 delay(2000);// aguardar 2 segundos

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Desativar ambos os relés para frear o motor
 delay(2000);// aguardar 2 segundos

}

Este código de exemplo usa nosso LC-80, um Arduino Uno, qualquer atuador linear e uma fonte de alimentação; no entanto, produtos semelhantes podem ser usados como substitutos. Você pode obter mais detalhes sobre o código e o que ele faz em nossa publicação no 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 pode ser usado para estender e retrair continuamente o Recorrido de um atuador linear.

CÓDIGO DO SETUP E DO LOOP
void setup() {
 Serial.begin(9600); // inicializa a comunicação serial a 9600 bits por segundo

 pinMode(out_lim, INPUT_PULLUP); // configura o pino 45 como entrada
 pinMode(in_lim, INPUT_PULLUP); // configura o pino 53 como entrada
 pinMode(run_f, OUTPUT); // configura o pino 25 como saída
 pinMode(run_r, OUTPUT); // configura o pino 30 como saída
 
 retract(); // retrai o Recorrido na inicialização
 delay(500);
}
void extend() // esta função permite que o motor funcione
{
 digitalWrite(run_f, LOW);
 digitalWrite(run_r, HIGH);
}

void retract() // esta função inverte a direção do motor
{
 digitalWrite(run_f, LOW);
 digitalWrite(run_r, LOW);
 }

void run_stop() // esta função desativa o motor
{
 digitalWrite(run_f, HIGH);
 digitalWrite(run_r, HIGH);
}
void loop() {
 int out_lim_state = digitalRead(out_lim); // lê os interruptores de fim de curso e salva seu valor
 int in_lim_state = digitalRead(in_lim);

 Serial.print("valor do interruptor de fim de curso externo "), Serial.println(out_lim_state); // 0 -> o interruptor de fim de curso está pressionado
 Serial.print("valor do interruptor de fim de curso interno "), Serial.println(in_lim_state); // 1 -> o interruptor de fim de curso não está pressionado
 
 if (out_lim_state == 0 && in_lim_state == 1) // se o interruptor de fim de curso externo estiver pressionado e o interno não (totalmente estendido)
 {
 retract(); // retrai o Recorrido
 }
 
else if (out_lim_state == 1 && in_lim_state == 0) // se o interruptor de fim de curso interno estiver pressionado e o externo não (totalmente retraído)
 {
 extend(); // estende o Recorrido
 }

 else // caso contrário, não faça nada
 {
 
 }
delay(5); // atraso entre leituras para estabilidade
}