Tento ukážkový kód používa MegaMoto Plus a Arduino Uno na sledovanie prúdu lineárneho aktuátora; podobné produkty však možno použiť ako náhrady.

/*  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; // piny pre Megamoto

const int buttonLeft = 4;
const int buttonRight = 5;//tlačidlá na pohyb motora

const int CPin1 = A5;  // spätná väzba motora

int leftlatch = LOW;
int rightlatch = LOW;//zámky motora (použité v logike kódu)

int hitLimits = 0;//začnite na 0
int hitLimitsmax = 10;//hodnoty na zistenie, či boli dosiahnuté koncové dorazy

long lastfeedbacktime = 0; // musí byť typu long, inak dôjde k pretečeniu
int firstfeedbacktimedelay = 750; // prvé oneskorenie na ignorovanie prúdovej špičky
int feedbacktimedelay = 50; // oneskorenie medzi cyklami spätnej väzby; ako často sa má kontrolovať motor
long currentTimefeedback = 0; // musí byť typu long, inak dôjde k pretečeniu

int debounceTime = 300; // čas na odrušenie zákmitov tlačidiel; nižšie hodnoty zvyšujú citlivosť
long lastButtonpress = 0; // časovač na odrušenie zákmitov
long currentTimedebounce = 0;

int CRaw = 0;      // vstupná hodnota pre meranie prúdu
int maxAmps = 0; // spúšťacia hranica 

bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//logika programu

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Nastavenie výstupov motora
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//tlačidlá
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//povoliť vnútorné pull‑up odpory
  pinMode(CPin1, INPUT);//nastaviť vstup spätnej väzby
  
  currentTimedebounce = millis();
  currentTimefeedback = 0;//nastaviť počiatočné časy

  maxAmps = 15;// NASTAVTE MAXIMÁLNY PRÚD TU

}//end setup

void loop()
{
  latchButtons();//skontroluje tlačidlá, či sa treba pohnúť

  moveMotor();//skontroluje zámky, vysunie alebo zasunie motor

}//end main loop

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//ľavé je dopredu
  {
    currentTimedebounce = millis() - lastButtonpress;// skontroluje čas od posledného stlačenia
    if (currentTimedebounce > debounceTime && dontExtend == false)//keď je nastavené dontExtend, ignorujú sa všetky stlačenia dopredu
    {
      leftlatch = !leftlatch;// ak sa motor hýbe, zastav; ak stojí, začni sa hýbať
      firstRun = true;// nastaví príznak firstRun na ignorovanie prúdovej špičky
      fullyRetracted = false; // po pohybe dopredu už nie je úplne zasunutý
      lastButtonpress = millis();//uloží čas posledného stlačenia tlačidla
      return;
    }//end if
  }//end btnLEFT

  if (digitalRead(buttonRight)==LOW)//pravé je dozadu
  {
    currentTimedebounce = millis() - lastButtonpress;// skontroluje čas od posledného stlačenia

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// ak sa motor hýbe, zastav; ak stojí, začni sa hýbať
      firstRun = true;// nastaví príznak firstRun na ignorovanie prúdovej špičky
      lastButtonpress = millis();//uloží čas posledného stlačenia tlačidla
      return;    }//end if
  }//end btnRIGHT
}//end latchButtons

void moveMotor()
{
  if (leftlatch == HIGH) motorForward(255); //rýchlosť = 0-255
  if (leftlatch == LOW) motorStop();
  if (rightlatch == HIGH) motorBack(255); //rýchlosť = 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);//pohnúť motorom
    if (firstRun == true) delay(firstfeedbacktimedelay); // väčšie oneskorenie na ignorovanie prúdovej špičky
    else delay(feedbacktimedelay); //malé oneskorenie na dosiahnutie rýchlosti

    getFeedback();
    firstRun = false;
    
    latchButtons();//znova skontrolovať tlačidlá
  }//end while

}//end motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//pohnúť motorom
    if (firstRun == true) delay(firstfeedbacktimedelay);// väčšie oneskorenie na ignorovanie prúdovej špičky
    else delay(feedbacktimedelay); //malé oneskorenie na dosiahnutie rýchlosti
    getFeedback();

    firstRun = false;
    
    latchButtons();//znova skontrolovať tlačidlá

  }//end while

  dontExtend = false;//po zasunutí opäť umožní vysúvanie motora

}//end motorBack

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

  digitalWrite(EnablePin, LOW);
  firstRun = true;//po zastavení motora znova povolí firstRun kvôli nábehovým prúdovým špičkám

}//end stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Čítať prúd

  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // skontrolovať, či je motor na dorazoch a prúd sa zastavil 

  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // zastaviť motor
    fullyRetracted = true;
  }//end if

  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//zastaviť motor
    hitLimits = 0;
  }//end if

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //zastaviť, ak je prúd nad maximom
  }//end if

  lastfeedbacktime = millis();//uložiť predchádzajúci čas prijatia spätnej väzby
}//end getFeedback

Tento ukážkový kód ukazuje, ako ovládať až 4 naše lineárne aktuátory pomocou Arduino Uno a LC-82 MultiMoto Arduino Shield; podobné produkty však možno použiť ako náhrady. Tento kód je určený iba pre modely aktuátorov v rámci prúdových obmedzení na každom kanáli MultiMoto, ako sú PA-14 a PA-14P.

/*    Example code to control up to 4 actuators, using the Robot Power MultiMoto driver.
   Hardware:
    - Robot Power MultiMoto
    - Arduino Uno

    Wiring:
  - Connect actuators to the M1, M2, M3, M4 connections on the MultiMoto board.
  - Connect the negative (black) to the right connection, positive (red) to the left.
  - Connect a 12 volt source (minimum 1A per motor if unloaded, 8A per motor if fully loaded)to the BAT terminals. Ensure that positive and negative are placed in the correct spots.

   Code modified by Progressive Automations from the example code provided by Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Robot Power MultiMoto v1.0 demo
    This software is released into the Public Domain
*/

// include the SPI library:

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


// L9958 Enable for all 4 motors
#define ENABLE_MOTORS 8

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

void setup() {
  unsigned int configWord;

  // put your setup code here, to run once:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = nevybraný
  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 smerové piny
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

  // L9958 PWM piny
  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 povolenie pre všetky 4 motory
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = zakázané

/ /******* Nastaviť čipy L9958 *********
  ' Konfiguračný register L9958
  ' Bit
  '0 - RES
  '1 - DR - reset
  '2 - CL_1 - obmedzenie prúdu
  '3 - CL_2 - obmedzenie prúdu
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - rýchlosť nárastu napätia (1 zapne obmedzenie nárastu, 0 vypne)
  '9 - ISR - rýchlosť nárastu prúdu (1 zapne obmedzenie nárastu, 0 vypne)
  '10 - ISR_DIS - vypnutie obmedzenia nárastu prúdu
  '11 - OL_ON - povoliť otvorenú záťaž
  '12 - RES
  '13 - RES
  '14 - 0 - vždy nula
  '15 - 0 - vždy nula
  */  // nastaviť na maximálne obmedzenie prúdu a vypnúť obmedzenie nárastu ISR
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // clock pol = low, phase = high

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

  //Nastaviť počiatočné nastavenia aktuátorov na zasúvanie pri rýchlosti 0 ako bezpečnostné opatrenie
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Nastaviť smer
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Nastaviť rýchlosť (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = povolené
} // End setup

void loop() {
    dir1 = 1;
    pwm1 = 255; //nastaviť smer a rýchlosť 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // zápis na piny

    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); // počkať po nastavení všetkých štyroch motorov

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

}//koniec void loop

Tento ukážkový kód je určený na kombináciu jednokanálového regulátora rýchlosti Wasp s Arduinom Uno na riadenie pohybu lineárneho aktuátora; podobné produkty však možno použiť ako náhrady.

/*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;  // vytvorí objekt servo na ovládanie serva 
                // na väčšine dosiek možno vytvoriť dvanásť objektov servo
 
int pos = 0;    // premenná na uloženie polohy serva 
 
void setup() 
{ 
  myservo.attach(9);  // pripojí servo na pine 9 k objektu servo 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // stop signál
    delay(1000);  //1 sekunda
    
    myservo.writeMicroseconds(2000); // signál: plná rýchlosť dopredu
    delay(2000); //2 sekundy  
    
    myservo.writeMicroseconds(1500); // stop signál
    delay(1000);  // 1 sekunda
    
    myservo.writeMicroseconds(1000); // signál: plná rýchlosť dozadu
    delay(2000); //2 sekundy   

}

Tento ukážkový kód využíva naše relé a Arduino Uno na ovládanie lineárneho aktuátora; podobné produkty však možno použiť ako náhrady. Viac podrobností nájdete v našom úplnom blogovom príspevku.

const int forwards = 7;
const int backwards = 6;//priraďte pin INx relé k pinu Arduina

void setup() {
 
pinMode(forwards, OUTPUT);//nastaviť relé ako výstup
pinMode(backwards, OUTPUT);//nastaviť relé ako výstup

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Aktivujte relé v jednom smere; úrovne musia byť odlišné, aby sa motor pohol
 delay(2000); // počkať 2 sekundy

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Deaktivujte obe relé, aby sa motor zabrzdil
 delay(2000);// počkať 2 sekundy
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Aktivujte relé v opačnom smere; úrovne musia byť odlišné, aby sa motor pohol
 delay(2000);// počkať 2 sekundy

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Deaktivujte obe relé, aby sa motor zabrzdil
 delay(2000);// počkať 2 sekundy

}

Tento ukážkový kód používa náš LC-80, Arduino Uno, ľubovoľný lineárny aktuátor a zdroj napájania; podobné produkty však možno použiť ako náhradu. Viac podrobností o kóde a o tom, čo robí, nájdete v našom blogovom príspevku.

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

Tento program možno použiť na nepretržité vysúvanie a zasúvanie zdvihu lineárneho aktuátora.

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
}