Ta vzorčna koda uporablja MegaMoto Plus in Arduino Uno za nadzor toka linearnega aktuatorja; uporabljeni so lahko tudi podobni izdelki kot zamenjave.

/*  Koda za nadzor tokovne porabe aktuatorja in za izklop napajanja,
  če preseže določeno vrednost.

  Napisal Progressive Automations
  19. avgust 2015

  Strojna oprema:
  - RobotPower MegaMoto kontrolne plošče
  - Arduino Uno
  - 2 potisna gumba
 */

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // pini za MegaMoto

const int buttonLeft = 4;
const int buttonRight = 5;//gumba za premik motorja

const int CPin1 = A5;  // povratna zveza motorja

int leftlatch = LOW;
int rightlatch = LOW;//zapahi motorja (za logiko kode)

int hitLimits = 0;//začetek pri 0
int hitLimitsmax = 10;//vrednosti za prepoznavo, ali so bili doseženi končni položaji

long lastfeedbacktime = 0; // mora biti tip long, sicer pride do prekoračitve
int firstfeedbacktimedelay = 750; // prvi zamik za ignoriranje tokovnega sunka
int feedbacktimedelay = 50; // zamik med cikli povratne zveze, kako pogosto želite preverjati motor
long currentTimefeedback = 0; // mora biti tip long, sicer pride do prekoračitve

int debounceTime = 300; // čas za odpravo tresenja kontaktov gumbov; nižje vrednosti povečajo občutljivost
long lastButtonpress = 0; // časovnik za odpravo tresenja
long currentTimedebounce = 0;

int CRaw = 0;      // vhodna vrednost za odčitke toka
int maxAmps = 0; // mejna vrednost sprožitve 

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

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//nastavite izhode motorja
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//gumba
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//omogočite notranje pull-up upore
  pinMode(CPin1, INPUT);//nastavite vhod za povratno zvezo
  
  currentTimedebounce = millis();
  currentTimefeedback = 0;//nastavite začetne čase

  maxAmps = 15;// TUKAJ NASTAVITE NAJVEČJI TOK

}//konec setup

void loop()
{
  latchButtons();//preverite gumba in ali je treba premakniti

  moveMotor();//preverite zapaha; premaknite motor naprej ali nazaj

}//konec glavne zanke

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//levo je naprej
  {
    currentTimedebounce = millis() - lastButtonpress;// preveri čas od zadnjega pritiska
    if (currentTimedebounce > debounceTime && dontExtend == false)//ko se sproži dontExtend, ignoriraj vse pritiske za naprej
    {
      leftlatch = !leftlatch;// če se motor premika, ustavi; če stoji, začni premikati
      firstRun = true;// nastavi zastavico firstRun za ignoriranje tokovnega sunka
      fullyRetracted = false; // ko se premakneš naprej, ni več popolnoma uvlečeno
      lastButtonpress = millis();//shrani čas zadnjega pritiska gumba
      return;
    }//konec if
  }//konec btnLEFT

  if (digitalRead(buttonRight)==LOW)//desno je nazaj
  {
    currentTimedebounce = millis() - lastButtonpress;// preveri čas od zadnjega pritiska

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// če se motor premika, ustavi; če stoji, začni premikati
      firstRun = true;// nastavi firstRun za ignoriranje tokovnega sunka
      lastButtonpress = millis();//shrani čas zadnjega pritiska gumba
      return;    }//konec if
  }//konec btnRIGHT
}//konec latchButtons

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

}//konec moveMotor

void motorForward(int speeed)
{
  while (dontExtend == false && leftlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//premakni motor
    if (firstRun == true) delay(firstfeedbacktimedelay); // večji zamik za ignoriranje tokovnega sunka
    else delay(feedbacktimedelay); //manjši zamik za dosego hitrosti

    getFeedback();
    firstRun = false;
    
    latchButtons();//ponovno preveri gumba
  }//konec while

}//konec motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//premakni motor
    if (firstRun == true) delay(firstfeedbacktimedelay);// večji zamik za ignoriranje tokovnega sunka
    else delay(feedbacktimedelay); //manjši zamik za dosego hitrosti
    getFeedback();

    firstRun = false;
    
    latchButtons();//ponovno preveri gumba

  }//konec while

  dontExtend = false;//motoru ponovno dovoli izvlek po uvleku

}//konec motorBack

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

  digitalWrite(EnablePin, LOW);
  firstRun = true;//ko se motor ustavi, znova omogoči firstRun zaradi začetnih tokovnih sunkov

}//konec stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Preberite tok

  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // preveri, ali je motor na končnih položajih in se je tok ustavil 

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

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

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //ustavi, če je povratna zveza nad največjo
  }//konec if

  lastfeedbacktime = millis();//shrani prejšnji čas za prejem povratne zveze
}//konec getFeedback

Ta vzorčna koda prikazuje, kako z Arduino Uno in LC-82 MultiMoto Arduino Shield upravljati do 4 naših linearnih aktuatorjev; kot zamenjave se lahko uporabijo tudi podobni izdelki. Koda je namenjena le modelom aktuatorjev, ki so znotraj tokovnih omejitev posameznega kanala MultiMoto, kot sta PA-14 in PA-14P.

/*    Vzorčna koda za upravljanje do 4 aktuatorjev z gonilnikom Robot Power MultiMoto.
   Strojna oprema:
    - Robot Power MultiMoto
    - Arduino Uno

    Ožičenje:
  - Aktuatorje povežite na priključke M1, M2, M3, M4 na plošči MultiMoto.
  - Negativni (črn) povežite na desni priključek, pozitivni (rdeč) na levi.
  - Na sponke BAT priključite 12-voltni vir (najmanj 1 A na motor brez obremenitve, 8 A na motor pri polni obremenitvi). Poskrbite, da sta plus in minus povezana pravilno.

   Kodo je prilagodil Progressive Automations iz vzorčne kode, ki jo je zagotovil Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Robot Power MultiMoto v1.0 demo
    Ta programska oprema je objavljena v javni domeni
*/

// vključite knjižnico SPI:

#include <SPI.h>
// L9958 pin-i za izbiro sužnja (slave select) za SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// L9958 pini za smer
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// L9958 PWM pini
#define PWM_M1 9
#define PWM_M2 10    // Timer1
#define PWM_M3 5
#define PWM_M4 6     // Timer0


// L9958 Enable za vse 4 motorje
#define ENABLE_MOTORS 8

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

void setup() {
  unsigned int configWord;

  // tukaj postavite nastavitveno kodo; zažene se enkrat:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = ni izbran
  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 pini za smer
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

  // L9958 PWM pini
  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 za vse 4 motorje
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = onemogočeno

/ /******* Nastavitev čipov L9958 *********
  ' L9958 Config Register
  ' Bit
  '0 - RES
  '1 - DR - reset
  '2 - CL_1 - omejitev toka
  '3 - CL_2 - omejitev toka
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - hitrost spreminjanja napetosti (1 omogoči omejitev, 0 onemogoči)
  '9 - ISR - hitrost spreminjanja toka (1 omogoči omejitev, 0 onemogoči)
  '10 - ISR_DIS - onemogoči omejitev hitrosti spreminjanja toka
  '11 - OL_ON - omogoči odprto breme
  '12 - RES
  '13 - RES
  '14 - 0 - vedno nič
  '15 - 0 - vedno nič
  */  // nastavi na največjo omejitev toka in onemogoči ISR omejevanje hitrosti
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // ura pol. = nizko, faza = visoka

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

  //Začetne nastavitve aktuatorjev: zaradi varnosti uvlečeno pri hitrosti 0
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // nastavi smer
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // nastavi hitrost (0–255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = omogočeno
} // Konec setup

void loop() {
    dir1 = 1;
    pwm1 = 255; // nastavi smer in hitrost 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // zapis na pine

    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čakaj, ko so vsi štirje motorji nastavljeni

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

}//konec void loop

Ta vzorčna koda združuje enokanalni regulator hitrosti Wasp z Arduino Uno za upravljanje gibanja linearnega aktuatorja; kot zamenjave se lahko uporabijo tudi podobni izdelki.

/*Vzorčna koda za Robot Power Wasp. 
 
 Ta ESC se upravlja z RC-signali s pulzi
  v razponu 1000–2000 mikrosekund.

  Glavna zanka tega programa drži aktuator 1 sekundo pri miru, 2 sekundi izteguje,
  ustavi za 1 sekundo, 2 sekundi uvleče in ponavlja.

  Prilagojeno pri Progressive Automations na osnovi izvirne vzorčne kode "Sweep" iz
  Arduino knjižnic.
  
  Strojna oprema:
  - 1 krmilnik Wasp
  - Arduino Uno
  
  Ožičenje:
  Nadzorna stran:
  - Rdečo/črno povežite na +5 V in GND
  - Rumeno žico povežite s signalnim pinom na Arduinu (v tem primeru pin 9)
  Močnostna stran:
  - +/- napajalnika motorja povežite na +/- priključke na Wasp
  - +/- aktuatorja povežite na preostala dva priključka

  Ta vzorčna koda je v javni domeni.
*/ 

#include <servo.h>  
Servo myservo;  // ustvarite objekt servo za upravljanje servomotorja 
                // na večini plošč je mogoče ustvariti dvanajst servo objektov
 
int pos = 0;    // spremenljivka za shranjevanje položaja serva 
 
void setup() 
{ 
  myservo.attach(9);  // servo na pinu 9 poveže z objektom servo 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // signal za ustavitev
    delay(1000);  // 1 sekunda
    
    myservo.writeMicroseconds(2000); // signal: polna hitrost naprej
    delay(2000); // 2 sekundi  
    
    myservo.writeMicroseconds(1500); // signal za ustavitev
    delay(1000);  // 1 sekunda
    
    myservo.writeMicroseconds(1000); // signal: polna hitrost nazaj
    delay(2000); // 2 sekundi   

}

Ta vzorčna koda uporablja naše releje in Arduino Uno za upravljanje linearnega aktuatorja; kot zamenjave se lahko uporabijo tudi podobni izdelki. Več podrobnosti si lahko preberete v našem blog prispevku.

const int forwards = 7;
const int backwards = 6;//dodeli pin INx releja Arduino pinu

void setup() {
 
pinMode(forwards, OUTPUT);//nastavi rele kot izhod
pinMode(backwards, OUTPUT);//nastavi rele kot izhod

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Aktiviraj rele v eno smer; ravni morajo biti različni, da se motor premika
 delay(2000); // počakaj 2 sekundi

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Deaktiviraj oba releja za zaviranje motorja
 delay(2000);// počakaj 2 sekundi
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Aktiviraj rele v drugo smer; ravni morajo biti različni, da se motor premika
 delay(2000);// počakaj 2 sekundi

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Deaktiviraj oba releja za zaviranje motorja
 delay(2000);// počakaj 2 sekundi

}

Ta vzorčna koda uporablja naš LC-80, Arduino Uno, katerikoli linearni aktuator in vir napajanja; kot zamenjave se lahko uporabijo tudi podobni izdelki. Več podrobnosti o kodi in njenem delovanju najdete v našem blog prispevku.

//Uporabite jumpers na plošči za izbiro, kateri pini bodo uporabljeni
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;


int extendtime = 10 * 1000;  // 10 sekund, krat 1000 za pretvorbo v milisekunde
int retracttime = 10 * 1000; // 10 sekund, krat 1000 za pretvorbo v milisekunde
int timetorun = 300 * 1000; // 300 sekund, krat 1000 za pretvorbo v milisekunde


int duty;
int elapsedTime;
boolean keepMoving;


void setup() {
  Serial.begin(9600);
  pinMode(EnablePin1, OUTPUT);//omogoči ploščo
  pinMode(PWMPinA1, OUTPUT);
  pinMode(PWMPinB1, OUTPUT);//nastavi izhode motorja
  elapsedTime = 0; // nastavi čas na 0
  keepMoving = true; //sistem se bo premikal
  
}//konec setup
void loop() {
  if (keepMoving) 
  {
    digitalWrite(EnablePin1, HIGH); // omogoči motor
    pushActuator();
    delay(extendtime);
    stopActuator();
    delay(10);//majhen zamik pred uvlekom
    
    pullActuator();
    delay(retracttime);
    stopActuator();
    
    elapsedTime = millis();//koliko časa je minilo?
    if (elapsedTime > timetorun) {//če je minilo 300 sekund, ustavi

      Serial.print("Elapsed time is over max run time. Max run time: ");
      Serial.println(timetorun);
      keepMoving = false;  
    }
  }//konec if
}//konec glavne zanke


void stopActuator() {
  analogWrite(PWMPinA1, 0);
  analogWrite(PWMPinB1, 0); // hitrost 0-255
}


void pushActuator() {
  analogWrite(PWMPinA1, 255);
  analogWrite(PWMPinB1, 0); // hitrost 0-255
}


void pullActuator() {
  analogWrite(PWMPinA1, 0);
  analogWrite(PWMPinB1, 255);//hitrost 0-255
}

Ta program lahko uporabite za neprekinjeno iztegovanje in uvlačenje hoda linearnega aktuatorja.

SETUP LOOP CODE
void setup() {
  Serial.begin(9600);  // inicializira serijsko komunikacijo pri 9600 bitih na sekundo

  pinMode(out_lim, INPUT_PULLUP); // konfigurira pin 45 kot vhodni pin
  pinMode(in_lim, INPUT_PULLUP); // konfigurira pin 53 kot vhodni pin
  pinMode(run_f, OUTPUT); // konfigurira pin 25 kot izhodni pin
  pinMode(run_r, OUTPUT); // konfigurira pin 30 kot izhodni pin
  
  retract(); // ob zagonu uvleče hod
  delay(500);
}
void extend() // ta funkcija omogoči delovanje motorja
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, HIGH);
}

void retract() // ta funkcija obrne smer motorja
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, LOW);
 }

void run_stop() // ta funkcija onemogoči motor
{
  digitalWrite(run_f, HIGH);
  digitalWrite(run_r, HIGH);
}
void loop() {
  int out_lim_state = digitalRead(out_lim);     // prebere končni stikali in shrani njuno vrednost
  int in_lim_state = digitalRead(in_lim);

  Serial.print("vrednost zunanjega končnega stikala "), Serial.println(out_lim_state); // 0 -> končno stikalo je pritisnjeno
  Serial.print("vrednost notranjega končnega stikala "), Serial.println(in_lim_state);  // 1 -> končno stikalo ni pritisnjeno
  
  if (out_lim_state == 0 && in_lim_state == 1) // če je zunanje končno stikalo pritisnjeno in notranje ne (popolnoma iztegnjeno)
  {
    retract(); // uvleci hod
  }
 
else if (out_lim_state == 1 && in_lim_state == 0) // če je notranje končno stikalo pritisnjeno in zunanje ne (popolnoma uvlečeno)
  {
    extend(); // iztegni hod
  }

  else // sicer ne naredi nič
  {
    
  }
delay(5);        // zamik med branji za stabilnost
}