Questo esempio di codice utilizza MegaMoto Plus e un Arduino Uno per monitorare la Corrente di un Attuatore lineare; tuttavia, prodotti simili possono essere usati come sostituti.

/*  Codice per monitorare l'assorbimento di Corrente dell'Attuatore e togliere alimentazione se
  sale oltre una certa soglia.

  Scritto da Progressive Automations
  19 agosto 2015

  Hardware:
  - Schede di controllo RobotPower MegaMoto
  - Arduino Uno
  - 2 pulsanti
 */

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // pin per Megamoto

const int buttonLeft = 4;
const int buttonRight = 5;//pulsanti per muovere il Motore

const int CPin1 = A5;  // Feedback del Motore

int leftlatch = LOW;
int rightlatch = LOW;//latch del Motore (usati per la logica del codice)

int hitLimits = 0;//inizia a 0
int hitLimitsmax = 10;//valori per sapere se sono stati raggiunti i limiti di Corsa

long lastfeedbacktime = 0; // deve essere long, altrimenti va in overflow
int firstfeedbacktimedelay = 750; // primo ritardo per ignorare il picco di Corrente
int feedbacktimedelay = 50; // ritardo tra i cicli di Feedback, quanto spesso vuoi che il Motore venga controllato
long currentTimefeedback = 0; // deve essere long, altrimenti va in overflow

int debounceTime = 300; // tempo per il debounce dei pulsanti; valori più bassi rendono i pulsanti più sensibili
long lastButtonpress = 0; // timer per il debounce
long currentTimedebounce = 0;

int CRaw = 0;      // valore di ingresso per le letture di Corrente
int maxAmps = 0; // soglia di intervento 

bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//logica del programma

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Imposta le uscite del Motore
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//pulsanti
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//abilita le pull-up interne
  pinMode(CPin1, INPUT);//imposta l'ingresso di Feedback
  
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Imposta i tempi iniziali

  maxAmps = 15;// IMPOSTA QUI LA CORRENTE MASSIMA

}//fine setup

void loop()
{
  latchButtons();//controlla i pulsanti, verifica se dobbiamo muoverci

  moveMotor();//controlla i latch, muovi il Motore avanti o indietro

}//fine main loop

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//sinistra = avanti
  {
    currentTimedebounce = millis() - lastButtonpress;// controlla il tempo dall'ultima pressione
    if (currentTimedebounce > debounceTime && dontExtend == false)//una volta attivato dontExtend, ignora tutte le pressioni in avanti
    {
      leftlatch = !leftlatch;// se il Motore è in movimento, fermalo; se è fermo, avvialo
      firstRun = true;// imposta il flag firstRun per ignorare il picco di Corrente
      fullyRetracted = false; // una volta che ti muovi in avanti, non sei completamente retratto
      lastButtonpress = millis();//memorizza l'ora dell'ultima pressione del pulsante
      return;
    }//fine if
  }//fine btnLEFT

  if (digitalRead(buttonRight)==LOW)//destra = indietro
  {
    currentTimedebounce = millis() - lastButtonpress;// controlla il tempo dall'ultima pressione

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// se il Motore è in movimento, fermalo; se è fermo, avvialo
      firstRun = true;// imposta il flag firstRun per ignorare il picco di Corrente
      lastButtonpress = millis();//memorizza l'ora dell'ultima pressione del pulsante
      return;    }//fine if
  }//fine btnRIGHT
}//fine latchButtons

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

}//fine moveMotor

void motorForward(int speeed)
{
  while (dontExtend == false && leftlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//muovi il Motore
    if (firstRun == true) delay(firstfeedbacktimedelay); // ritardo maggiore per ignorare il picco di Corrente
    else delay(feedbacktimedelay); //breve ritardo per raggiungere la Velocità

    getFeedback();
    firstRun = false;
    
    latchButtons();//controlla di nuovo i pulsanti
  }//fine while

}//fine motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//muovi il Motore
    if (firstRun == true) delay(firstfeedbacktimedelay);// ritardo maggiore per ignorare il picco di Corrente
    else delay(feedbacktimedelay); //breve ritardo per raggiungere la Velocità
    getFeedback();

    firstRun = false;
    
    latchButtons();//controlla di nuovo i pulsanti

  }//fine while

  dontExtend = false;//consenti di nuovo l'estensione del Motore, dopo che è stato retratto

}//fine motorBack

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

  digitalWrite(EnablePin, LOW);
  firstRun = true;//una volta che il Motore si è fermato, riabilita firstRun per tenere conto dei picchi di Corrente all'avvio

}//fine stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Leggi la Corrente

  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // verifica se il Motore è ai limiti e la Corrente si è fermata 

  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // ferma il Motore
    fullyRetracted = true;
  }//fine if

  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//ferma il Motore
    hitLimits = 0;
  }//fine if

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //ferma se il Feedback supera il massimo
  }//fine if

  lastfeedbacktime = millis();//memorizza l'ora precedente per la ricezione del Feedback
}//fine getFeedback

Questo esempio di codice mostra come controllare fino a 4 dei nostri attuatori lineari con Arduino Uno e la LC-82 MultiMoto Arduino Shield; tuttavia è possibile utilizzare prodotti simili in sostituzione. Questo codice è destinato esclusivamente all'uso con modelli di attuatori che rientrano nei limiti di corrente di ciascun canale del MultiMoto, come PA-14 e PA-14P.

/*    Codice di esempio per controllare fino a 4 attuatori, utilizzando il driver Robot Power MultiMoto.
   Hardware:
    - Robot Power MultiMoto
    - Arduino Uno

    Cablaggio:
  - Collegare gli attuatori alle connessioni M1, M2, M3, M4 sulla scheda MultiMoto.
  - Collegare il negativo (nero) al collegamento destro, il positivo (rosso) a quello sinistro.
  - Collegare un'alimentazione a 12 volt (minimo 1 A per motore a vuoto, 8 A per motore a pieno carico) ai terminali BAT. Assicurarsi che positivo e negativo siano posizionati nei punti corretti.

   Codice modificato da Progressive Automations a partire dal codice di esempio fornito da Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Dimostrazione Robot Power MultiMoto v1.0
    Questo software è rilasciato nel Pubblico Dominio
*/

// includere la libreria SPI:

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


// Abilitazione L9958 per tutti e 4 i motori
#define ENABLE_MOTORS 8

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

void setup() {
  unsigned int configWord;

  // inserire qui il codice di setup, eseguito una sola volta:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = non selezionato
  pinMode(SS_M2, OUTPUT); digitalWrite(SS_M2, LOW);
  pinMode(SS_M3, OUTPUT); digitalWrite(SS_M3, LOW);
  pinMode(SS_M4, OUTPUT); digitalWrite(SS_M4, LOW);

  // Pin di direzione L9958
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

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

  // Abilitazione L9958 per tutti e 4 i motori
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = disabilitato

/ /******* Configurare i chip L9958 *********
  ' Registro di configurazione L9958
  ' Bit
  '0 - RES
  '1 - DR - reset
  '2 - CL_1 - limite di corrente
  '3 - CL_2 - limite di corrente
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - velocità di variazione della tensione (1 abilita il limite di variazione, 0 disabilita)
  '9 - ISR - velocità di variazione della corrente (1 abilita il limite di variazione, 0 disabilita)
  '10 - ISR_DIS - disabilita la variazione della corrente
  '11 - OL_ON - abilita rilevamento di carico aperto
  '12 - RES
  '13 - RES
  '14 - 0 - sempre zero
  '15 - 0 - sempre zero
  */  // impostare il limite di corrente massimo e disabilitare il limite alla variazione ISR
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // polarità del clock = bassa, fase = alta

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

  //Impostare inizialmente l'attuatore per ritrarre a velocità 0 per sicurezza
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Imposta direzione
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Imposta velocità (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = abilitato
} // Fine setup

void loop() {
    dir1 = 1;
    pwm1 = 255; // imposta direzione e velocità 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // scrivi sui pin

    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); // attendi dopo che tutti e quattro i motori sono stati impostati

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

}//fine void loop

Questo esempio di codice serve per combinare il regolatore di Velocità Wasp a canale singolo con l'Arduino Uno per controllare il movimento di un Attuatore lineare, tuttavia, prodotti simili possono essere usati come sostituti.

/*Codice di esempio per il Robot Power Wasp. 

 Questo ESC è controllato tramite segnali RC, con impulsi
  compresi tra 1000 e 2000 microsecondi.

  Il loop principale di questo programma mantiene l'Attuatore fermo per 1 secondo, estende per 2 secondi,
  si ferma per 1 secondo, retrae per 2 secondi e ripete.

  Modificato da Progressive Automations, utilizzando il codice di esempio originale "Sweep" dalle 
  librerie di esempio di Arduino. 
  
  Hardware:
  - 1 Controller Wasp
  - Arduino Uno
  
  Cablaggio:
  Lato controllo:
  - Collega rosso/nero a +5v e GND
  - Collega il filo giallo al tuo pin di segnale sull'Arduino (in questo esempio, pin 9)
  Lato alimentazione:
  - Collega il +/- dell'alimentatore del Motore alle connessioni +/- sul Wasp
  - Collega il +/- dell'Attuatore alle restanti due connessioni

  Questo esempio di codice è di pubblico dominio.
*/ 

#include <servo.h>  
Servo myservo;  // crea un oggetto servo per controllare un servo 
                // sulla maggior parte delle schede si possono creare fino a dodici oggetti servo
 
int pos = 0;    // variabile per memorizzare la posizione del servo 
 
void setup() 
{ 
  myservo.attach(9);  // collega il servo sul pin 9 all'oggetto servo 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // segnale di stop
    delay(1000);  //1 secondo
    
    myservo.writeMicroseconds(2000); // segnale di Velocità massima in avanti
    delay(2000); //2 secondi  
    
    myservo.writeMicroseconds(1500); // segnale di stop
    delay(1000);  // 1 secondo
    
    myservo.writeMicroseconds(1000); // segnale di Velocità massima in retro
    delay(2000); //2 secondi   

}

Questo esempio di codice utilizza i nostri relè e un Arduino Uno per controllare un attuatore lineare; tuttavia è possibile utilizzare prodotti simili in sostituzione. Puoi leggere il nostro articolo del blog completo per maggiori dettagli.

const int forwards = 7;
const int backwards = 6;//assegna il pin INx del relè al pin Arduino

void setup() {
 
pinMode(forwards, OUTPUT);//imposta il relè come uscita
pinMode(backwards, OUTPUT);//imposta il relè come uscita

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Attiva il relè in una direzione; devono essere diversi per muovere il motore
 delay(2000); // attendi 2 secondi

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Disattiva entrambi i relè per frenare il motore
 delay(2000);// attendi 2 secondi
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Attiva il relè nell'altra direzione; devono essere diversi per muovere il motore
 delay(2000);// attendi 2 secondi

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Disattiva entrambi i relè per frenare il motore
 delay(2000);// attendi 2 secondi

}

Questo esempio di codice utilizza la nostra LC-80, un Arduino Uno, qualsiasi attuatore lineare e un'alimentazione; tuttavia è possibile utilizzare prodotti simili in sostituzione. Puoi trovare maggiori dettagli sul codice e sul suo funzionamento nel nostro articolo del blog.

//Usa i ponticelli sulla scheda per selezionare quali pin verranno utilizzati
int EnablePin1 = 13;
int PWMPinA1 = 11;
int PWMPinB1 = 3;


int extendtime = 10 * 1000;  // 10 secondi, moltiplicato per 1000 per convertire in millisecondi
int retracttime = 10 * 1000; // 10 secondi, moltiplicato per 1000 per convertire in millisecondi
int timetorun = 300 * 1000; // 300 secondi, moltiplicato per 1000 per convertire in millisecondi


int duty;
int elapsedTime;
boolean keepMoving;


void setup() {
  Serial.begin(9600);
  pinMode(EnablePin1, OUTPUT);//Abilita la scheda
  pinMode(PWMPinA1, OUTPUT);
  pinMode(PWMPinB1, OUTPUT);//Imposta le uscite del motore
  elapsedTime = 0; // Imposta il tempo a 0
  keepMoving = true; //Il sistema si muoverà
  
}//fine setup
void loop() {
  if (keepMoving) 
  {
    digitalWrite(EnablePin1, HIGH); // abilita il motore
    pushActuator();
    delay(extendtime);
    stopActuator();
    delay(10);//breve ritardo prima della ritrazione
    
    pullActuator();
    delay(retracttime);
    stopActuator();
    
    elapsedTime = millis();//quanto tempo è passato?
    if (elapsedTime > timetorun) {//se sono passati 300 secondi, fermarsi

      Serial.print("Il tempo trascorso supera il tempo massimo di funzionamento. Tempo massimo: ");
      Serial.println(timetorun);
      keepMoving = false;  
    }
  }//fine if
}//fine loop principale


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


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


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

Questo programma può essere usato per estendere e retrarre continuamente la corsa di un attuatore lineare.

SETUP LOOP CODE
void setup() {
  Serial.begin(9600);  // inizializza la comunicazione seriale a 9600 bit al secondo

  pinMode(out_lim, INPUT_PULLUP); // configura il pin 45 come pin di ingresso
  pinMode(in_lim, INPUT_PULLUP); // configura il pin 53 come pin di ingresso
  pinMode(run_f, OUTPUT); // configura il pin 25 come pin di uscita
  pinMode(run_r, OUTPUT); // configura il pin 30 come pin di uscita
  
  retract(); // ritrae la corsa all'avvio
  delay(500);
}
void extend() // questa funzione abilita il motore
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, HIGH);
}

void retract() // questa funzione inverte la direzione del motore
{
  digitalWrite(run_f, LOW);
  digitalWrite(run_r, LOW);
 }

void run_stop() // questa funzione disabilita il motore
{
  digitalWrite(run_f, HIGH);
  digitalWrite(run_r, HIGH);
}
void loop() {
  int out_lim_state = digitalRead(out_lim);     // legge i finecorsa e ne salva il valore
  int in_lim_state = digitalRead(in_lim);

  Serial.print("outer limit switch value "), Serial.println(out_lim_state); // 0 -> il finecorsa è premuto
  Serial.print("inner limit switch value "), Serial.println(in_lim_state);  // 1 -> il finecorsa non è premuto
  
  if (out_lim_state == 0 && in_lim_state == 1) // se il finecorsa esterno è premuto e quello interno no (completamente esteso)
  {
    retract(); // retrae la corsa
  }
 
else if (out_lim_state == 1 && in_lim_state == 0) // se il finecorsa interno è premuto e quello esterno no (completamente retratto)
  {
    extend(); // estende la corsa
  }

  else // altrimenti non fare nulla
  {
    
  }
delay(5);        // ritardo tra le letture per stabilità
}