Tämä esimerkkikoodi käyttää MegaMoto Plussaa ja Arduino Uno -lautaa lineaarisen toimilaitteen virran seurantaan; vastaavat tuotteet voivat toimia korvaavina.

/*  Koodi toimilaitteen virrankulutuksen (A) valvontaan ja virran katkaisuun,
  jos se nousee tietyn raja-arvon yli.

  Kirjoittanut Progressive Automations
  19. elokuuta 2015

  Laitteisto:
  - RobotPower MegaMoto -ohjainkortit
  - Arduino Uno
  - 2 painiketta
 */

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // Megamoto-nastat

const int buttonLeft = 4;
const int buttonRight = 5;//painikkeet moottorin liikuttamiseen

const int CPin1 = A5;  // moottorin palaute

int leftlatch = LOW;
int rightlatch = LOW;//moottorin lukot (koodilogiikkaa varten)

int hitLimits = 0;//start at 0
int hitLimitsmax = 10;//arvot, joista tiedetään, onko liikerajat saavutettu

long lastfeedbacktime = 0; // oltava long, muuten ylivuoto
int firstfeedbacktimedelay = 750; // ensimmäinen viive käynnistysvirtapiikin ohittamiseksi
int feedbacktimedelay = 50; // viive palautesykleissä; kuinka usein moottori tarkistetaan
long currentTimefeedback = 0; // oltava long, muuten ylivuoto

int debounceTime = 300; // painikkeiden poimintojen suodatus; pienempi arvo = herkempi
long lastButtonpress = 0; // ajastin poimintojen suodatukseen
long currentTimedebounce = 0;

int CRaw = 0;      // syötearvo virtalukemille
int maxAmps = 0; // laukaisuraja 

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

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Aseta moottorin lähdöt
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//painikkeet
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//ota sisäiset vetovastukset käyttöön
  pinMode(CPin1, INPUT);//aseta palautteen tulo
  
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Aseta alkuarvot

  maxAmps = 15;// ASETTAA MAKSIMIVIRRAN TÄHÄN

}//setup loppu

void loop()
{
  latchButtons();//tarkista painikkeet, pitääkö liikuttaa

  moveMotor();//tarkista lukot, liikuta moottoria sisään tai ulos

}//pääsilmukan loppu

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//vasen = eteenpäin
  {
    currentTimedebounce = millis() - lastButtonpress;// aika viime painalluksesta
    if (currentTimedebounce > debounceTime && dontExtend == false)//kun dontExtend on aktivoitu, ohita kaikki eteenpäin-painallukset
    {
      leftlatch = !leftlatch;// jos moottori liikkuu, pysäytä; jos pysähdyksissä, käynnistä
      firstRun = true;// ohita käynnistysvirtapiikki
      fullyRetracted = false; // kun liikut eteenpäin, et ole enää täysin sisäänvedetty
      lastButtonpress = millis();//tallenna viime painalluksen aika
      return;
    }//if loppu
  }//btnLEFT loppu

  if (digitalRead(buttonRight)==LOW)//oikea = taaksepäin
  {
    currentTimedebounce = millis() - lastButtonpress;// aika viime painalluksesta

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// jos moottori liikkuu, pysäytä; jos pysähdyksissä, käynnistä
      firstRun = true;// ohita käynnistysvirtapiikki
      lastButtonpress = millis();//tallenna viime painalluksen aika
      return;    }//if loppu
  }//btnRIGHT loppu
}//latchButtons loppu

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

}//moveMotor loppu

void motorForward(int speeed)
{
  while (dontExtend == false && leftlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//liikuta moottoria
    if (firstRun == true) delay(firstfeedbacktimedelay); // pidempi viive, jotta käynnistysvirtapiikki ohitetaan
    else delay(feedbacktimedelay); //pieni viive nopeuteen pääsemiseksi

    getFeedback();
    firstRun = false;
    
    latchButtons();//tarkista painikkeet uudelleen
  }//while loppu

}//motorForward loppu

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//liikuta moottoria
    if (firstRun == true) delay(firstfeedbacktimedelay);// pidempi viive, jotta käynnistysvirtapiikki ohitetaan
    else delay(feedbacktimedelay); //pieni viive nopeuteen pääsemiseksi
    getFeedback();

    firstRun = false;
    
    latchButtons();//tarkista painikkeet uudelleen

  }//while loppu

  dontExtend = false;//salli moottorin pidentyä uudelleen sisäänvedon jälkeen

}//motorBack loppu

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

  digitalWrite(EnablePin, LOW);
  firstRun = true;//kun moottori on pysähtynyt, ota firstRun uudelleen käyttöön käynnistysvirtapiikkien varalta

}//stopMotor loppu

void getFeedback()
{
  CRaw = analogRead(CPin1); // Lue virta

  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // tarkista, onko moottori rajoissa ja onko virta loppunut 

  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // pysäytä moottori
    fullyRetracted = true;
  }//if loppu

  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//pysäytä moottori
    hitLimits = 0;
  }//if loppu

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //pysäytä, jos palaute ylittää maksimin
  }//if loppu

  lastfeedbacktime = millis();//tallenna edellinen palautteen vastaanottoaika
}//getFeedback loppu

Tämä esimerkkikoodi näyttää, kuinka ohjata jopa neljää lineaarista toimilaitettamme Arduino Unolla ja LC-82 MultiMoto Arduino Shield -kortilla; vastaavat tuotteet voivat toimia korvaavina. Koodi on tarkoitettu vain sellaisille toimilaitemalleille, jotka pysyvät MultiMoto-kortin kunkin kanavan virrarajoitusten puitteissa, kuten PA-14 ja PA-14P.

/*    Esimerkkikoodi jopa 4 toimilaitteen ohjaamiseen Robot Power MultiMoto -ajurilla.
   Laitteisto:
    - Robot Power MultiMoto
    - Arduino Uno

    Kytkentä:
  - Kytke toimilaitteet MultiMoto-kortin M1-, M2-, M3- ja M4-liitäntöihin.
  - Kytke negatiivinen (musta) oikeaan liitäntään, positiivinen (punainen) vasempaan.
  - Kytke 12 V virtalähde (vähintään 1 A per moottori kuormittamattomana, 8 A per moottori täysin kuormitettuna) BAT-liittimiin. Varmista, että napaisuus on oikein.

   Koodia on muokattu Progressive Automationsilla Robot Powerin tarjoamasta esimerkkikoodista
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Robot Power MultiMoto v1.0 -demo
    Tämä ohjelmisto on julkaistu Public Domain -lisenssillä
*/

// sisällytä SPI-kirjasto:

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


// L9958 Enable kaikille 4 moottorille
#define ENABLE_MOTORS 8

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

void setup() {
  unsigned int configWord;

  // kirjoita alustuskoodi tänne; ajetaan kerran:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = ei valittuna
  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 DIRection -nastat
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

  // L9958 PWM -nastat
  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 kaikille 4 moottorille
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = pois käytöstä

/ /******* L9958-piirien käyttöönotto *********
  ' L9958:n konfigurointirekisteri
  ' Bitti
  '0 - RES
  '1 - DR - reset
  '2 - CL_1 - current limit
  '3 - CL_2 - curr_limit
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - jännitteen nousunopeus (1 = rajaus käytössä, 0 = pois käytöstä)
  '9 - ISR - virran nousunopeus (1 = rajaus käytössä, 0 = pois käytöstä)
  '10 - ISR_DIS - virran nousun rajoituksen poisto
  '11 - OL_ON - open load -tunnistus päälle
  '12 - RES
  '13 - RES
  '14 - 0 - aina nolla
  '15 - 0 - aina nolla
  */  // aseta maksimi virtarajoitus ja poista ISR-nousun rajoitus käytöstä
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // kellon polariteetti = matala, vaihe = korkea

  // Moottori 1
  digitalWrite(SS_M1, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M1, HIGH);
  // Moottori 2
  digitalWrite(SS_M2, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M2, HIGH);
  // Moottori 3
  digitalWrite(SS_M3, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M3, HIGH);
  // Moottori 4
  digitalWrite(SS_M4, LOW);
  SPI.transfer(lowByte(configWord));
  SPI.transfer(highByte(configWord));
  digitalWrite(SS_M4, HIGH);

  //Aseta alkuasetukset: vedä sisään nopeudella 0 turvallisuuden vuoksi
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Suunta
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Nopeus (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = käytössä
} // setup-loppu

void loop() {
    dir1 = 1;
    pwm1 = 255; //aseta suunta ja nopeus 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // kirjoita nastoille

    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); // odota, kun kaikki neljä moottoria on asetettu

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

}//void loop loppu

Tämä esimerkkikoodi yhdistää Wasp-yksikanavaisen nopeussäätimen Arduino Unoon lineaarisen toimilaitteen ohjaamiseksi; vastaavat tuotteet voivat toimia korvaavina.

/*Esimerkkikoodi Robot Power Waspille. 

 Tämä ESC ohjataan RC-signaaleilla, joiden pulssit
  vaihtelevat välillä 1000–2000 mikrosekuntia.

  Ohjelman pääsilmukka pitää toimilaitteen paikallaan 1 sekunnin, pidentää 2 sekuntia,
  pysäyttää 1 sekunniksi, vetää sisään 2 sekuntia ja toistaa tämän.

  Muokannut Progressive Automations alkuperäisestä "Sweep"-esimerkkikoodista
  Arduino-esimerkkikirjastoista. 
  
  Laitteisto:
  - 1 Wasp-ohjain
  - Arduino Uno
  
  Kytkentä:
  Ohjauspuoli:
  - Kytke punainen/musta +5 V:iin ja GND:hen
  - Kytke keltainen johto Arduinon signaalinastaan (tässä esimerkissä nasta 9)
  Tehopuoli:
  - Kytke moottorin virtalähteen +/- Waspin +/- -liitäntöihin
  - Kytke toimilaitteen +/- kahteen jäljellä olevaan liitäntään

  Tämä esimerkkikoodi on public domain -lisensoitu.
*/ 

#include <servo.h>  
Servo myservo;  // luo servo-olion servon ohjaamiseen 
                // useimmilla alustoilla voidaan luoda kaksitoista servo-oliota
 
int pos = 0;    // muuttuja servon asentoa varten 
 
void setup() 
{ 
  myservo.attach(9);  // liittää servon nastaan 9 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // pysäytyssignaali
    delay(1000);  //1 sekunti
    
    myservo.writeMicroseconds(2000); // täysi nopeus eteenpäin -signaali
    delay(2000); //2 sekuntia  
    
    myservo.writeMicroseconds(1500); // pysäytyssignaali
    delay(1000);  // 1 sekunti
    
    myservo.writeMicroseconds(1000); // täysi nopeus taaksepäin -signaali
    delay(2000); //2 sekuntia   

}

Tämä esimerkkikoodi käyttää releistämme ja Arduino Uno -lautaa lineaarisen toimilaitteen ohjaamiseen; vastaavat tuotteet voivat toimia korvaavina. Voit lukea lisää yksityiskohtia täydellisestä blogikirjoituksestamme.

const int forwards = 7;
const int backwards = 6;//määritä releen INx-nasta Arduinon nastaan

void setup() {
 
pinMode(forwards, OUTPUT);//aseta rele lähdöksi
pinMode(backwards, OUTPUT);//aseta rele lähdöksi

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Aktivoi rele yhteen suuntaan; arvojen on oltava erilaiset, jotta moottori liikkuu
 delay(2000); // odota 2 sekuntia

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Poista molemmat releet käytöstä jarruttaaksesi moottoria
 delay(2000);// odota 2 sekuntia
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Aktivoi rele toiseen suuntaan; arvojen on oltava erilaiset, jotta moottori liikkuu
 delay(2000);// odota 2 sekuntia

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Poista molemmat releet käytöstä jarruttaaksesi moottoria
 delay(2000);// odota 2 sekuntia

}

Tämä esimerkkikoodi käyttää LC-80-ohjaintamme, Arduino Uno -lautaa, mitä tahansa lineaarista toimilaitetta ja virtalähdettä; vastaavat tuotteet voivat toimia korvaavina. Saat lisätietoja koodista ja sen toiminnasta blogikirjoituksestamme.

//Käytä kortin hyppylankoja valitaksesi käytettävät nastat
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;


int extendtime = 10 * 1000;  // 10 sekuntia; kerrotaan 1000:lla millisekunneiksi
int retracttime = 10 * 1000; // 10 sekuntia; kerrotaan 1000:lla millisekunneiksi
int timetorun = 300 * 1000; // 300 sekuntia; kerrotaan 1000:lla millisekunneiksi


int duty;
int elapsedTime;
boolean keepMoving;


void setup() {
  Serial.begin(9600);
  pinMode(EnablePin1, OUTPUT);//Ota kortti käyttöön
  pinMode(PWMPinA1, OUTPUT);
  pinMode(PWMPinB1, OUTPUT);//Aseta moottorin lähdöt
  elapsedTime = 0; // Aseta aika nollaan
  keepMoving = true; //Järjestelmä liikkuu
  
}//setup loppu
void loop() {
  if (keepMoving) 
  {
    digitalWrite(EnablePin1, HIGH); // ota moottori käyttöön
    pushActuator();
    delay(extendtime);
    stopActuator();
    delay(10);//pieni viive ennen sisäänvetoa
    
    pullActuator();
    delay(retracttime);
    stopActuator();
    
    elapsedTime = millis();//kauanko on kulunut?
    if (elapsedTime > timetorun) {//jos 300 sekuntia on kulunut, pysäytä

      Serial.print("Elapsed time is over max run time. Max run time: ");
      Serial.println(timetorun);
      keepMoving = false;  
    }
  }//if loppu
}//pääsilmukan loppu


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


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


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

Tällä ohjelmalla voidaan jatkuvasti pidentää ja vetää sisään lineaarisen toimilaitteen iskua.

SETUP LOOP CODE
void setup() {
  Serial.begin(9600);  // alustetaan sarjaliikenne nopeudella 9600 bittiä sekunnissa

  pinMode(out_lim, INPUT_PULLUP); // määrittää nastan 45 tulonastaksi
  pinMode(in_lim, INPUT_PULLUP); // määrittää nastan 53 tulonastaksi
  pinMode(run_f, OUTPUT); // määrittää nastan 25 lähtönastaksi
  pinMode(run_r, OUTPUT); // määrittää nastan 30 lähtönastaksi
  
  retract(); // vetää iskun sisään käynnistyksessä
  delay(500);
}
void extend() // tämä funktio saa moottorin käymään
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, HIGH);
}

void retract() // tämä funktio kääntää moottorin suunnan
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, LOW);
 }

void run_stop() // tämä funktio pysäyttää moottorin
{
  digitalWrite(run_f, HIGH);
  digitalWrite(run_r, HIGH);
}
void loop() {
  int out_lim_state = digitalRead(out_lim);     // lukee rajakytkimet ja tallentaa niiden arvon
  int in_lim_state = digitalRead(in_lim);

  Serial.print("ulomman rajakytkimen arvo "), Serial.println(out_lim_state); // 0 -> rajakytkin on painettuna
  Serial.print("sisemmän rajakytkimen arvo "), Serial.println(in_lim_state);  // 1 -> rajakytkin ei ole painettuna
  
  if (out_lim_state == 0 && in_lim_state == 1) // jos ulompi rajakytkin on painettuna ja sisempi ei (täysin pidennetty)
  {
    retract(); // vedä isku sisään
  }
 
else if (out_lim_state == 1 && in_lim_state == 0) // jos sisempi rajakytkin on painettuna ja ulompi ei (täysin sisäänvedetty)
  {
    extend(); // pidennä isku
  }

  else // muuten älä tee mitään
  {
    
  }
delay(5);        // viive lukemisten välillä vakauden vuoksi
}