Deze voorbeeldcode gebruikt MegaMoto Plus en een Arduino Uno om de stroom van een lineaire actuator te bewaken; vergelijkbare producten kunnen echter als vervanging worden gebruikt.

/*  Code om de stroomafname (in ampère) van de actuator te bewaken en de voeding uit te schakelen als deze
  boven een bepaalde waarde komt.

  Geschreven door Progressive Automations
  19 augustus 2015

  Hardware:
  - RobotPower MegaMoto-besturingsborden
  - Arduino Uno
  - 2 drukknoppen
 */

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // pinnen voor Megamoto

const int buttonLeft = 4;
const int buttonRight = 5;//knoppen om de motor te bewegen

const int CPin1 = A5;  // motor-terugkoppeling

int leftlatch = LOW;
int rightlatch = LOW;//motorvergrendelingen (gebruikt voor codelogica)

int hitLimits = 0;//begin bij 0
int hitLimitsmax = 10;//waarden om te bepalen of de eindposities zijn bereikt

long lastfeedbacktime = 0; // moet long zijn, anders treedt overflow op
int firstfeedbacktimedelay = 750; //eerste vertraging om de stroompiek te negeren
int feedbacktimedelay = 50; //vertraging tussen terugkoppelingscycli; hoe vaak je de motor wilt controleren
long currentTimefeedback = 0; // moet long zijn, anders treedt overflow op

int debounceTime = 300; //tijd voor het debouncen van knoppen; lagere waarden maken de knoppen gevoeliger
long lastButtonpress = 0; // timer voor debouncen
long currentTimedebounce = 0;

int CRaw = 0;      // invoerwaarde voor stroommetingen
int maxAmps = 0; // afschakelgrens 

bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//programmalogica

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Motoruitgangen instellen
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//knoppen
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//interne pullups inschakelen
  pinMode(CPin1, INPUT);//terugkoppelingsinvoer instellen
  
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Initiële tijden instellen

  maxAmps = 15;// MAXIMALE STROOM HIER INSTELLEN

}//einde setup

void loop()
{
  latchButtons();//knoppen controleren, kijken of we moeten bewegen

  moveMotor();//vergrendelingen controleren, motor in- of uitschuiven

}//einde main loop

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//links is vooruit
  {
    currentTimedebounce = millis() - lastButtonpress;// controleer tijd sinds laatste druk
    if (currentTimedebounce > debounceTime && dontExtend == false)//als dontExtend is geactiveerd, alle vooruit‑drukken negeren
    {
      leftlatch = !leftlatch;// als de motor draait, stoppen; als hij stilstaat, starten
      firstRun = true;// firstRun‑vlag zetten om stroompiek te negeren
      fullyRetracted = false; // zodra je vooruit beweegt, ben je niet volledig ingetrokken
      lastButtonpress = millis();//tijd van laatste knopdruk opslaan
      return;
    }//einde if
  }//einde btnLEFT

  if (digitalRead(buttonRight)==LOW)//rechts is achteruit
  {
    currentTimedebounce = millis() - lastButtonpress;// controleer tijd sinds laatste druk

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// als de motor draait, stoppen; als hij stilstaat, starten
      firstRun = true;// firstRun‑vlag zetten om stroompiek te negeren
      lastButtonpress = millis();//tijd van laatste knopdruk opslaan
      return;    }//einde if
  }//einde btnRIGHT
}//einde latchButtons

void moveMotor()
{
  if (leftlatch == HIGH) motorForward(255); //snelheid = 0-255
  if (leftlatch == LOW) motorStop();
  if (rightlatch == HIGH) motorBack(255); //snelheid = 0-255
  if (rightlatch == LOW) motorStop();

}//einde moveMotor

void motorForward(int speeed)
{
  while (dontExtend == false && leftlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//motor bewegen
    if (firstRun == true) delay(firstfeedbacktimedelay); // grotere vertraging om stroompiek te negeren
    else delay(feedbacktimedelay); //kleine vertraging om op snelheid te komen

    getFeedback();
    firstRun = false;
    
    latchButtons();//knoppen opnieuw controleren
  }//einde while

}//einde motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//motor bewegen
    if (firstRun == true) delay(firstfeedbacktimedelay);// grotere vertraging om stroompiek te negeren
    else delay(feedbacktimedelay); //kleine vertraging om op snelheid te komen
    getFeedback();

    firstRun = false;
    
    latchButtons();//knoppen opnieuw controleren

  }//einde while

  dontExtend = false;//motor weer laten uitschuiven nadat hij is ingetrokken

}//einde motorBack

void motorStop()
{
  analogWrite(PWMPinA, 0);
  analogWrite(PWMPinB, 0);

  digitalWrite(EnablePin, LOW);
  firstRun = true;//wanneer de motor gestopt is, firstRun opnieuw inschakelen om opstartstroompieken op te vangen

}//einde stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Stroom uitlezen

  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // controleren of de motor de eindposities heeft bereikt en de stroom is gestopt 

  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // motor stoppen
    fullyRetracted = true;
  }//einde if

  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//motor stoppen
    hitLimits = 0;
  }//einde if

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; // stoppen als terugkoppeling boven maximum is
  }//einde if

  lastfeedbacktime = millis();//vorige tijd voor ontvangst van terugkoppeling opslaan
}//einde getFeedback

Deze voorbeeldcode laat zien hoe je tot 4 van onze lineaire actuatoren kunt aansturen met de Arduino Uno en LC-82 MultiMoto Arduino Shield; vergelijkbare producten kunnen echter als vervanging worden gebruikt. Deze code is alleen bedoeld voor actuatoren die binnen de stroombeperkingen per kanaal van de MultiMoto vallen, zoals de PA-14 en PA-14P.

/*    Voorbeeldcode om tot 4 actuatoren te besturen met de Robot Power MultiMoto-driver.
   Hardware:
    - Robot Power MultiMoto
    - Arduino Uno

    Bedrading:
  - Verbind actuatoren met de M1-, M2-, M3-, M4-aansluitingen op de MultiMoto-print.
  - Verbind de negatieve (zwarte) met de rechteraansluiting, de positieve (rode) met de linker.
  - Verbind een 12-volt bron (minimaal 1A per motor onbelast, 8A per motor volledig belast) met de BAT-klemmen. Zorg dat plus en min op de juiste plaatsen zijn aangesloten.

   Code aangepast door Progressive Automations op basis van de voorbeeldcode van Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Robot Power MultiMoto v1.0 demo
    Deze software is vrijgegeven in het Public Domain
*/

// neem de SPI-bibliotheek op:

#include <SPI.h>
// L9958 slave-select-pinnen voor SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// L9958 richtingpinnen
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// L9958 PWM-pinnen
#define PWM_M1 9
#define PWM_M2 10    // Timer1
#define PWM_M3 5
#define PWM_M4 6     // Timer0


// L9958 Enable voor alle 4 motoren
#define ENABLE_MOTORS 8

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

void setup() {
  unsigned int configWord;

  // plaats je setup-code hier; wordt één keer uitgevoerd:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = niet geselecteerd
  pinMode(SS_M2, OUTPUT); digitalWrite(SS_M2, LOW);
  pinMode(SS_M3, OUTPUT); digitalWrite(SS_M3, LOW);
  pinMode(SS_M4, OUTPUT); digitalWrite(SS_M4, LOW);

  // L9958 richtingpinnen
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

  // L9958 PWM-pinnen
  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

  // L9958 Enable voor alle 4 motoren
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = uitgeschakeld

/ /******* L9958-chips instellen *********
  ' L9958 Config-register
  ' Bit
  '0 - RES
  '1 - DR - reset
  '2 - CL_1 - stroomlimiet
  '3 - CL_2 - stroomlimiet
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - spanningsslewrate (1 schakelt slewl imiet in, 0 schakelt uit)
  '9 - ISR - stroomslewrate (1 schakelt slewlimiet in, 0 schakelt uit)
  '10 - ISR_DIS - stroomslew uitschakelen
  '11 - OL_ON - open-load inschakelen
  '12 - RES
  '13 - RES
  '14 - 0 - altijd nul
  '15 - 0 - altijd nul
  */  // instellen op maximale stroomlimiet en ISR-slew-begrenzing uitschakelen
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // klokpol = laag, fase = hoog

  // 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);

  //Initiële actuatorinstellingen op intrekken bij 0 snelheid zetten (veiligheidsmaatregel)
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Richting instellen
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Snelheid instellen (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = ingeschakeld
} // Einde setup

void loop() {
    dir1 = 1;
    pwm1 = 255; //richting en snelheid instellen 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // naar pinnen schrijven

    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); // wachten zodra alle vier motoren zijn ingesteld

    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); 

}//einde void loop

Deze voorbeeldcode is bedoeld om de enkelkanaals Wasp‑snelheidsregelaar te combineren met de Arduino Uno om de beweging van een lineaire actuator te regelen; vergelijkbare producten kunnen echter als vervanging worden gebruikt.

/*Voorbeeldcode voor de Robot Power Wasp. 
 
 Deze ESC wordt bestuurd met RC-signalen met pulsen
  van 1000 - 2000 microseconden.

  De hoofdlus van dit programma houdt de actuator 1 seconde stil, schuift 2 seconden uit,
  stopt 1 seconde, schuift 2 seconden in en herhaalt.

  Aangepast door Progressive Automations, op basis van de oorspronkelijke voorbeeldcode "Sweep" uit de 
  Arduino-voorbeeldbibliotheken. 
  
  Hardware:
  - 1 Wasp-controller
  - Arduino Uno
  
  Bedrading:
  Besturingszijde:
  - Verbind rood/zwart met +5v en GND
  - Verbind de gele draad met je signaalpin op de Arduino (in dit voorbeeld, pin 9)
  Vermogenszijde:
  - Verbind de +/- van de stroomvoorziening van de motor met de +/- aansluitingen op de Wasp
  - Verbind de +/- van de actuator met de overblijvende twee aansluitingen

  Deze voorbeeldcode is publiek domein.
*/ 

#include <servo.h>  
Servo myservo;  // servo-object maken om een servo aan te sturen 
                // op de meeste borden kunnen twaalf servo-objecten worden gemaakt
 
int pos = 0;    // variabele om de servo-positie op te slaan 
 
void setup() 
{ 
  myservo.attach(9);  // koppelt de servo op pin 9 aan het servo-object 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // stopsignaal
    delay(1000);  //1 seconde
    
    myservo.writeMicroseconds(2000); // signaal volle snelheid vooruit
    delay(2000); //2 seconden  
    
    myservo.writeMicroseconds(1500); // stopsignaal
    delay(1000);  // 1 seconde
    
    myservo.writeMicroseconds(1000); // signaal volle snelheid achteruit
    delay(2000); //2 seconden   

}

Deze voorbeeldcode maakt gebruik van onze relais en Arduino Uno om een lineaire actuator te besturen; vergelijkbare producten kunnen echter als vervanging worden gebruikt. Je kunt ons volledige blogbericht lezen voor meer details.

const int forwards = 7;
const int backwards = 6;//relais-INx-pin koppelen aan Arduino-pin

void setup() {
 
pinMode(forwards, OUTPUT);//relais als uitgang instellen
pinMode(backwards, OUTPUT);//relais als uitgang instellen

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Relais in één richting activeren; de niveaus moeten verschillend zijn om de motor te laten bewegen
 delay(2000); // 2 seconden wachten

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Beide relais deactiveren om de motor te remmen
 delay(2000);// 2 seconden wachten
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Relais in de andere richting activeren; de niveaus moeten verschillend zijn om de motor te laten bewegen
 delay(2000);// 2 seconden wachten

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Beide relais deactiveren om de motor te remmen
 delay(2000);// 2 seconden wachten

}

Deze voorbeeldcode gebruikt onze LC-80, een Arduino Uno, elke lineaire actuator en een stroombron; vergelijkbare producten kunnen echter als vervanging worden gebruikt. Meer details over de code en wat deze doet vind je in onze blogpost.

//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
}

Met dit programma kunt u de slaglengte van een lineaire actuator continu in- en uitschuiven.

SETUP LOOP CODE
void setup() {
  Serial.begin(9600);  // initialize serial communication at 9600 bits per second

  pinMode(out_lim, INPUT_PULLUP); // configures pin 45 as input pin
  pinMode(in_lim, INPUT_PULLUP); // configures pin 53 as input pin
  pinMode(run_f, OUTPUT); // configures pin 25 as output pin
  pinMode(run_r, OUTPUT); // configures pin 30 as output pin
  
  retract(); // retracts the stroke on startup
  delay(500);
}
void extend() // this function enables the motor to run
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, HIGH);
}

void retract() // this function reverses the direction of motor
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, LOW);
 }

void run_stop() // this function disables the motor
{
  digitalWrite(run_f, HIGH);
  digitalWrite(run_r, HIGH);
}
void loop() {
  int out_lim_state = digitalRead(out_lim);     // reads the limit switches and saves its value
  int in_lim_state = digitalRead(in_lim);

  Serial.print("outer limit switch value "), Serial.println(out_lim_state); // 0 -> limit switch is pressed
  Serial.print("inner limit switch value "), Serial.println(in_lim_state);  // 1 -> limit switch is not pressed
  
  if (out_lim_state == 0 && in_lim_state == 1) // if outer limit switch is pressed and inner is not (extended all the way)
  {
    retract(); // retract the stroke
  }
 
else if (out_lim_state == 1 && in_lim_state == 0) // if inner limit switch is pressed and outer is not (reracted all the way)
  {
    extend(); // extend the stroke
  }

  else // otherwise do nothing
  {
    
  }
delay(5);        // delay in between reads for stability
}