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

/*  Kód na monitorovanie odberu prúdu aktuátora a na odpojenie napájania,
  ak stúpne nad určitú hodnotu.

  Napísali Progressive Automations
  19. augusta 2015

  Hardvér:
  - RobotPower MegaMoto riadiace dosky
  - Arduino Uno
  - 2 tlačidlá
 */

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ávery motora (použité na logiku kódu)

int hitLimits = 0;//start at 0
int hitLimitsmax = 10;//values to know if travel limits were reached

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

int debounceTime = 300; // čas na odrušenie stlačení tlačidiel, nižšia hodnota = citlivejšie tlačidlá
long lastButtonpress = 0; // časovač na odrušenie
long currentTimedebounce = 0;

int CRaw = 0;      // vstupná hodnota pre čítanie prúdu
int maxAmps = 0; // prahová hodnota vypnutia 

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);//Nastaviť výstupy motora
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//tlačidlá
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//povoliť interné pullupy
  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();//skontrolovať tlačidlá, či je potrebný pohyb

  moveMotor();//skontrolovať závery, pohnúť motorom dnu alebo von

}//end main loop

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//ľavé je dopredu
  {
    currentTimedebounce = millis() - lastButtonpress;// skontrolovať čas od posledného stlačenia
    if (currentTimedebounce > debounceTime && dontExtend == false)//keď sa aktivuje dontExtend, ignorovať všetky stlačenia dopredu
    {
      leftlatch = !leftlatch;// ak sa motor hýbe, zastaviť; ak stojí, spustiť
      firstRun = true;// nastaviť príznak firstRun na ignorovanie počiatočnej špičky prúdu
      fullyRetracted = false; // po pohybe dopredu už nie je úplne zasunutý
      lastButtonpress = millis();//uložiť čas posledného stlačenia
      return;
    }//end if
  }//end btnLEFT

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

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// ak sa motor hýbe, zastaviť; ak stojí, spustiť
      firstRun = true;// nastaviť príznak firstRun na ignorovanie počiatočnej špičky prúdu
      lastButtonpress = millis();//uložiť čas posledného stlačenia
      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);//pohyb motora
    if (firstRun == true) delay(firstfeedbacktimedelay); // väčšie oneskorenie na ignorovanie špičky prúdu
    else delay(feedbacktimedelay); // malé oneskorenie na dosiahnutie rýchlosti

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

}//end motorForward

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

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

  }//end while

  dontExtend = false;//po zasunutí znova povoliť vysúvanie motora

}//end motorBack

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

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

}//end stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Čítanie prúdu

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

  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 spätná väzba prekročí maximum
  }//end if

  lastfeedbacktime = millis();//uložiť čas predchádzajúceho čítania 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 na použitie s modelmi aktuátorov, ktoré spĺňajú aktuálne limity každého kanála MultiMoto, ako napríklad PA-14 a PA-14P.

/*    Ukážkový kód na ovládanie až 4 aktuátorov s použitím ovládača Robot Power MultiMoto.
   Hardvér:
    - Robot Power MultiMoto
    - Arduino Uno

    Zapojenie:
  - Pripojte aktuátory na konektory M1, M2, M3, M4 na doske MultiMoto.
  - Záporný (čierny) pripojte na pravý konektor, kladný (červený) na ľavý.
  - Pripojte 12 V zdroj (minimálne 1 A na motor bez zaťaženia, 8 A na motor pri plnom zaťažení) na svorky BAT. Uistite sa, že kladný a záporný pól sú zapojené správne.

   Kód upravený spoločnosťou Progressive Automations z ukážkového kódu poskytnutého Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Robot Power MultiMoto v1.0 demo
    Tento softvér je uvoľnený do verejnej domény
*/

// zahrnúť knižnicu SPI:

#include <SPI.h>
// L9958 piny výberu slave pre SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// L9958 piny smeru (DIRection)
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// L9958 PWM piny
#define PWM_M1 9
#define PWM_M2 10    // Timer1
#define PWM_M3 5
#define PWM_M4 6     // Timer0


// L9958 povolenie pre všetky 4 motory
#define ENABLE_MOTORS 8

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

void setup() {
  unsigned int configWord;

  // nastavovací kód, spúšťa sa raz:
  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 piny smeru
  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é

/ /******* Nastavenie čipov L9958 *********
  ' L9958 konfiguračný register
  ' Bit
  '0 - RES
  '1 - DR - reset
  '2 - CL_1 - limit prúdu
  '3 - CL_2 - limit prúdu
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - rýchlosť nábehu napätia (1 obmedzenie povolené, 0 zakázané)
  '9 - ISR - rýchlosť nábehu prúdu (1 obmedzenie povolené, 0 zakázané)
  '10 - ISR_DIS - zakázať obmedzenie nábehu prúdu
  '11 - OL_ON - povoliť detekciu otvoreného obvodu
  '12 - RES
  '13 - RES
  '14 - 0 - vždy nula
  '15 - 0 - vždy nula
  */  // nastaviť na maximálny limit prúdu a vypnúť obmedzenie ISR nábehu
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // polarita hodinového signálu = low, fáza = 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);

  // Počiatočné nastavenia aktuátorov: zasúvať rýchlosťou 0 (z bezpečnostných dôvodov)
  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é
} // koniec setup

void loop() {
    dir1 = 1;
    pwm1 = 255; // nastaviť smer a rýchlosť 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // zapísať 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); 

}//end void loop

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

/*Ukážkový kód pre Robot Power Wasp. 

 Tento ESC je riadený RC signálmi s pulzmi
  v rozsahu 1000 - 2000 mikrosekúnd.

  Hlavná slučka programu podrží aktuátor 1 sekundu v pokoji, 2 sekundy vysúva,
  1 sekundu zastaví, 2 sekundy zasúva a opakuje.

  Upravené spoločnosťou Progressive Automations podľa pôvodného príkladu "Sweep"
  z ukážkových knižníc Arduina. 
  
  Hardvér:
  - 1 ovládač Wasp
  - Arduino Uno
  
  Zapojenie:
  Riadiaca strana:
  - Pripojte červený/čierny na +5 V a GND
  - Žltý vodič pripojte na signálový pin Arduina (v tomto príklade pin 9)
  Výkonová strana:
  - Pripojte +/- napájania motora na +/- svorky Wasp
  - Pripojte +/- aktuátora na zostávajúce dve svorky

  Tento ukážkový kód je vo verejnej doméne.
*/ 

#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);  // priradí 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 príklad využíva naše relé a Arduino Uno na ovládanie lineárneho aktuátora; podobné produkty možno použiť ako náhrady. Podrobnosti nájdete v našom blogovom článku.

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é jedným smerom; ú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 ste motor brzdili
 delay(2000);// počkať 2 sekundy
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Aktivujte relé opačným smerom; ú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 ste motor brzdili
 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áhrady. Viac podrobností o kóde a jeho fungovaní nájdete v našom blogovom článku.

//Použite prepojky na doske na výber, ktoré piny sa použijú
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;


int extendtime = 10 * 1000;  // 10 sekúnd, krát 1000 pre prevod na milisekundy
int retracttime = 10 * 1000; // 10 sekúnd, krát 1000 pre prevod na milisekundy
int timetorun = 300 * 1000; // 300 sekúnd, krát 1000 pre prevod na milisekundy


int duty;
int elapsedTime;
boolean keepMoving;


void setup() {
  Serial.begin(9600);
  pinMode(EnablePin1, OUTPUT);//Povoliť dosku
  pinMode(PWMPinA1, OUTPUT);
  pinMode(PWMPinB1, OUTPUT);//Nastaviť výstupy motora
  elapsedTime = 0; // Nastaviť čas na 0
  keepMoving = true; //Systém sa bude hýbať
  
}//end setup
void loop() {
  if (keepMoving) 
  {
    digitalWrite(EnablePin1, HIGH); // povoliť motor
    pushActuator();
    delay(extendtime);
    stopActuator();
    delay(10);//krátke oneskorenie pred zasunutím
    
    pullActuator();
    delay(retracttime);
    stopActuator();
    
    elapsedTime = millis();//ako dlho to beží?
    if (elapsedTime > timetorun) {//ak uplynulo 300 sekúnd, zastaviť

      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); // rýchlosť 0-255
}


void pushActuator() {
  analogWrite(PWMPinA1, 255);
  analogWrite(PWMPinB1, 0); // rýchlosť 0-255
}


void pullActuator() {
  analogWrite(PWMPinA1, 0);
  analogWrite(PWMPinB1, 255);//rýchlosť 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);  // inicializuje sériovú komunikáciu rýchlosťou 9600 bitov za sekundu

  pinMode(out_lim, INPUT_PULLUP); // konfiguruje pin 45 ako vstupný pin
  pinMode(in_lim, INPUT_PULLUP); // konfiguruje pin 53 ako vstupný pin
  pinMode(run_f, OUTPUT); // konfiguruje pin 25 ako výstupný pin
  pinMode(run_r, OUTPUT); // konfiguruje pin 30 ako výstupný pin
  
  retract(); // pri štarte zasunie zdvih
  delay(500);
}
void extend() // táto funkcia umožní chodu motora
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, HIGH);
}

void retract() // táto funkcia zmení smer motora
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, LOW);
 }

void run_stop() // táto funkcia deaktivuje motor
{
  digitalWrite(run_f, HIGH);
  digitalWrite(run_r, HIGH);
}
void loop() {
  int out_lim_state = digitalRead(out_lim);     // prečíta koncové spínače a uloží ich hodnotu
  int in_lim_state = digitalRead(in_lim);

  Serial.print("outer limit switch value "), Serial.println(out_lim_state); // 0 -> koncový spínač je stlačený
  Serial.print("inner limit switch value "), Serial.println(in_lim_state);  // 1 -> koncový spínač nie je stlačený
  
  if (out_lim_state == 0 && in_lim_state == 1) // ak je vonkajší koncový spínač stlačený a vnútorný nie (úplne vysunuté)
  {
    retract(); // zasunúť zdvih
  }
 
else if (out_lim_state == 1 && in_lim_state == 0) // ak je vnútorný koncový spínač stlačený a vonkajší nie (úplne zasunuté)
  {
    extend(); // vysunúť zdvih
  }

  else // inak nerob nič
  {
    
  }
delay(5);        // oneskorenie medzi čítaniami pre stabilitu
}