Ce code d’exemple utilise MegaMoto Plus et un Arduino Uno pour surveiller le courant d’un vérin linéaire; toutefois, des produits similaires peuvent être utilisés en remplacement.

/*  Code pour surveiller l’intensité de courant consommée par l’actionneur, et couper l’alimentation si elle
  dépasse un certain seuil.

  Rédigé par Progressive Automations
  19 août 2015

  Matériel:
  - Cartes de commande RobotPower MegaMoto
  - Arduino Uno
  - 2 boutons-poussoirs
 */

const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3; // broches pour Megamoto

const int buttonLeft = 4;
const int buttonRight = 5;//boutons pour déplacer le moteur

const int CPin1 = A5;  // rétroaction du moteur

int leftlatch = LOW;
int rightlatch = LOW;//verrous du moteur (utilisés pour la logique du code)

int hitLimits = 0;//commencer à 0
int hitLimitsmax = 10;//valeurs pour savoir si les limites de course ont été atteintes

long lastfeedbacktime = 0; // doit être de type long, sinon dépassement
int firstfeedbacktimedelay = 750; //premier délai pour ignorer le pic de courant
int feedbacktimedelay = 50; //délai entre les cycles de rétroaction, fréquence de vérification du moteur
long currentTimefeedback = 0; // doit être de type long, sinon dépassement

int debounceTime = 300; //durée d’anti-rebond des boutons, des valeurs plus faibles rendent les boutons plus sensibles
long lastButtonpress = 0; // minuterie pour l’anti-rebond
long currentTimedebounce = 0;

int CRaw = 0;      // valeur d’entrée pour les mesures de courant
int maxAmps = 0; // seuil de déclenchement 

bool dontExtend = false;
bool firstRun = true;
bool fullyRetracted = false;//logique du programme

void setup()
{
  Serial.begin(9600);
  pinMode(EnablePin, OUTPUT);
  pinMode(PWMPinA, OUTPUT);
  pinMode(PWMPinB, OUTPUT);//Définir les sorties du moteur
  pinMode(buttonLeft, INPUT);
  pinMode(buttonRight, INPUT);//boutons
  
  digitalWrite(buttonLeft, HIGH);
  digitalWrite(buttonRight, HIGH);//activer les pull-up internes
  pinMode(CPin1, INPUT);//définir l’entrée de rétroaction
  
  currentTimedebounce = millis();
  currentTimefeedback = 0;//Définir les temps initiaux

  maxAmps = 15;// DÉFINIR ICI LE COURANT MAXIMUM

}//fin setup

void loop()
{
  latchButtons();//vérifier les boutons, voir s’il faut bouger

  moveMotor();//vérifier les verrous, faire avancer ou reculer le moteur

}//fin boucle principale

void latchButtons()
{
  if (digitalRead(buttonLeft)==LOW)//gauche = avancer
  {
    currentTimedebounce = millis() - lastButtonpress;// vérifier le temps depuis la dernière pression
    if (currentTimedebounce > debounceTime && dontExtend == false)//une fois dontExtend déclenché, ignorer toutes les pressions vers l’avant
    {
      leftlatch = !leftlatch;// si le moteur est en mouvement, arrêter; s’il est arrêté, démarrer
      firstRun = true;// définir l’indicateur firstRun pour ignorer le pic de courant
      fullyRetracted = false; // une fois que vous avancez, il n’est plus entièrement rétracté
      lastButtonpress = millis();//enregistrer l’heure de la dernière pression sur un bouton
      return;
    }//fin if
  }//fin btnLEFT

  if (digitalRead(buttonRight)==LOW)//droite = reculer
  {
    currentTimedebounce = millis() - lastButtonpress;// vérifier le temps depuis la dernière pression

    if (currentTimedebounce > debounceTime)
    {
      rightlatch = !rightlatch;// si le moteur est en mouvement, arrêter; s’il est arrêté, démarrer
      firstRun = true;// définir l’indicateur firstRun pour ignorer le pic de courant
      lastButtonpress = millis();//enregistrer l’heure de la dernière pression sur un bouton
      return;    }//fin if
  }//fin btnRIGHT
}//fin latchButtons

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

}//fin moveMotor

void motorForward(int speeed)
{
  while (dontExtend == false && leftlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, speeed);
    analogWrite(PWMPinB, 0);//déplacer le moteur
    if (firstRun == true) delay(firstfeedbacktimedelay); // délai plus long pour ignorer le pic de courant
    else delay(feedbacktimedelay); //petit délai pour atteindre la vitesse

    getFeedback();
    firstRun = false;
    
    latchButtons();//revérifier les boutons
  }//fin while

}//fin motorForward

void motorBack (int speeed)
{
  while (rightlatch == HIGH)
  {
    digitalWrite(EnablePin, HIGH);
    analogWrite(PWMPinA, 0);
    analogWrite(PWMPinB, speeed);//déplacer le moteur
    if (firstRun == true) delay(firstfeedbacktimedelay);// délai plus long pour ignorer le pic de courant
    else delay(feedbacktimedelay); //petit délai pour atteindre la vitesse
    getFeedback();

    firstRun = false;
    
    latchButtons();//revérifier les boutons

  }//fin while

  dontExtend = false;//permettre au moteur de s’étendre à nouveau après rétraction

}//fin motorBack

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

  digitalWrite(EnablePin, LOW);
  firstRun = true;//une fois le moteur arrêté, réactiver firstRun pour tenir compte des pics de courant au démarrage

}//fin stopMotor

void getFeedback()
{
  CRaw = analogRead(CPin1); // Lire le courant

  if (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
  else hitLimits = 0; // vérifier si le moteur est aux limites et si le courant s’est arrêté 

  if (hitLimits == hitLimitsmax && rightlatch == HIGH)
  {
    rightlatch = LOW; // arrêter le moteur
    fullyRetracted = true;
  }//fin if

  else if (hitLimits == hitLimitsmax && leftlatch == HIGH)
  {
    leftlatch = LOW;//arrêter le moteur
    hitLimits = 0;
  }//fin if

  if (CRaw > maxAmps)
  {
    dontExtend = true;
    leftlatch = LOW; //arrêter si la rétroaction est supérieure au maximum
  }//fin if

  lastfeedbacktime = millis();//enregistrer l’heure précédente pour la réception de la rétroaction
}//fin getFeedback

Cet exemple de code montre comment contrôler jusqu’à 4 de nos vérins linéaires avec l’Arduino Uno et le LC-82 MultiMoto Arduino Shield; toutefois, des produits similaires peuvent être utilisés en remplacement. Ce code est uniquement destiné aux modèles d’actionneurs respectant les limites de courant de chaque canal du MultiMoto, tels que les PA-14 et PA-14P.

/*    Exemple de code pour piloter jusqu’à 4 actionneurs avec le pilote Robot Power MultiMoto.
   Matériel:
    - Robot Power MultiMoto
    - Arduino Uno

    Câblage:
  - Connecter les actionneurs aux connexions M1, M2, M3, M4 sur la carte MultiMoto.
  - Connecter le négatif (noir) à la borne de droite, le positif (rouge) à celle de gauche.
  - Connecter une source 12 volts (minimum 1 A par moteur à vide, 8 A par moteur à pleine charge) aux bornes BAT. Veillez à placer le positif et le négatif aux bons emplacements.

   Code modifié par Progressive Automations à partir du code d’exemple fourni par Robot Power
     <a href="http://www.robotpower.com/downloads/" rel="nofollow"> http://www.robotpower.com/downloads/</a>

    Robot Power MultiMoto v1.0 démo
    Ce logiciel est placé dans le domaine public
*/

// inclure la bibliothèque SPI:

#include <SPI.h>
// Broches de sélection esclave L9958 pour SPI
#define SS_M4 14
#define SS_M3 13
#define SS_M2 12
#define SS_M1 11
// Broches de direction L9958
#define DIR_M1 2
#define DIR_M2 3
#define DIR_M3 4
#define DIR_M4 7
// Broches PWM L9958
#define PWM_M1 9
#define PWM_M2 10    // Timer1
#define PWM_M3 5
#define PWM_M4 6     // Timer0


// Activation L9958 pour les 4 moteurs
#define ENABLE_MOTORS 8

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

void setup() {
  unsigned int configWord;

  // placez ici votre code d’initialisation, exécuté une seule fois:
  pinMode(SS_M1, OUTPUT); digitalWrite(SS_M1, LOW);  // HIGH = non sélectionné
  pinMode(SS_M2, OUTPUT); digitalWrite(SS_M2, LOW);
  pinMode(SS_M3, OUTPUT); digitalWrite(SS_M3, LOW);
  pinMode(SS_M4, OUTPUT); digitalWrite(SS_M4, LOW);

  // Broches de direction L9958
  pinMode(DIR_M1, OUTPUT);
  pinMode(DIR_M2, OUTPUT);
  pinMode(DIR_M3, OUTPUT);
  pinMode(DIR_M4, OUTPUT);

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

  // Activation L9958 pour les 4 moteurs
  pinMode(ENABLE_MOTORS, OUTPUT); 
 digitalWrite(ENABLE_MOTORS, HIGH);  // HIGH = désactivé

/ /******* Configuration des puces L9958 *********
  ' Registre de configuration L9958
  ' Bit
  '0 - RES
  '1 - DR - réinitialisation
  '2 - CL_1 - limite de courant
  '3 - CL_2 - limite de courant
  '4 - RES
  '5 - RES
  '6 - RES
  '7 - RES
  '8 - VSR - vitesse de montée en tension (1 active la limitation, 0 la désactive)
  '9 - ISR - vitesse de montée du courant (1 active la limitation, 0 la désactive)
  '10 - ISR_DIS - désactivation de la limitation de montée du courant
  '11 - OL_ON - activation open‑load (circuit ouvert)
  '12 - RES
  '13 - RES
  '14 - 0 - toujours zéro
  '15 - 0 - toujours zéro
  */  // régler sur la limite de courant maximale et désactiver la limitation de montée ISR
  configWord = 0b0000010000001100;

  SPI.begin();
  SPI.setBitOrder(LSBFIRST);
  SPI.setDataMode(SPI_MODE1);  // polarité d’horloge = bas, phase = haut

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

  // Définir les réglages initiaux de l’actionneur pour tirer à vitesse 0 par sécurité
  dir1 = 0; dir2 = 0; dir3 = 0; dir4 = 0; // Définir la direction
  pwm1 = 0; pwm2 = 0; pwm3 = 0; pwm4 = 0; // Définir la vitesse (0-255)

digitalWrite(ENABLE_MOTORS, LOW);// LOW = activé
} // Fin setup

void loop() {
    dir1 = 1;
    pwm1 = 255; //définir la direction et la vitesse 
    digitalWrite(DIR_M1, dir1);
    analogWrite(PWM_M1, pwm1); // écrire sur les broches

    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); // attendre une fois que les quatre moteurs sont réglés

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

}//fin void loop

Cet exemple de code permet de combiner le contrôleur de vitesse monocanal Wasp avec l’Arduino Uno pour contrôler le mouvement d’un vérin linéaire; toutefois, des produits similaires peuvent être utilisés en remplacement.

/*Exemple de code pour le Robot Power Wasp. 

 Cet ESC est commandé à l’aide de signaux RC, avec des impulsions
  allant de 1000 à 2000 microsecondes.

  La boucle principale de ce programme maintient l’actionneur immobile pendant 1 seconde, s’étend pendant 2 secondes,
  s’arrête 1 seconde, se rétracte 2 secondes, puis répète.

  Modifié par Progressive Automations, à partir de l’exemple d’origine « Sweep » des 
  bibliothèques d’exemples Arduino. 
  
  Matériel:
  - 1 contrôleur Wasp
  - Arduino Uno
  
  Câblage:
  Côté commande:
  - Connecter le rouge/noir au +5 V et à la masse (GND)
  - Connecter le fil jaune à la broche de signal sur l’Arduino (dans cet exemple, la broche 9)
  Côté puissance:
  - Connecter le +/- de l’alimentation du moteur aux connexions +/- du Wasp
  - Connecter le +/- de l’actionneur aux deux connexions restantes

  Cet exemple de code est dans le domaine public.
*/ 

#include <servo.h>  
Servo myservo;  // créer un objet servo pour piloter un servo 
                // sur la plupart des cartes, on peut créer douze objets servo
 
int pos = 0;    // variable pour stocker la position du servo 
 
void setup() 
{ 
  myservo.attach(9);  // associe le servo sur la broche 9 à l’objet servo 
} 
 
void loop() 
{ 
 
    myservo.writeMicroseconds(1500); // signal d’arrêt
    delay(1000);  //1 seconde
    
    myservo.writeMicroseconds(2000); // signal : pleine vitesse avant
    delay(2000); //2 secondes  
    
    myservo.writeMicroseconds(1500); // signal d’arrêt
    delay(1000);  // 1 seconde
    
    myservo.writeMicroseconds(1000); // signal : pleine vitesse arrière
    delay(2000); //2 secondes   

}

Cet exemple de code utilise nos relais et un Arduino Uno pour commander un vérin linéaire; toutefois, des produits similaires peuvent être utilisés en remplacement. Vous pouvez lire notre article de blog complet pour plus de détails.

const int forwards = 7;
const int backwards = 6;//attribuer la broche INx du relais à une broche de l’Arduino

void setup() {
 
pinMode(forwards, OUTPUT);//définir le relais comme sortie
pinMode(backwards, OUTPUT);//définir le relais comme sortie

}

void loop() {
  
 digitalWrite(forwards, LOW);
 digitalWrite(backwards, HIGH);//Activer le relais dans un sens; les niveaux doivent être différents pour déplacer le moteur
 delay(2000); // attendre 2 secondes

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Désactiver les deux relais pour freiner le moteur
 delay(2000);// attendre 2 secondes
 
 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, LOW);//Activer le relais dans l’autre sens; les niveaux doivent être différents pour déplacer le moteur
 delay(2000);// attendre 2 secondes

 digitalWrite(forwards, HIGH);
 digitalWrite(backwards, HIGH);//Désactiver les deux relais pour freiner le moteur
 delay(2000);// attendre 2 secondes

}

Cet exemple de code utilise notre LC-80, un Arduino Uno, n’importe quel vérin linéaire et une source d’alimentation. Des produits similaires peuvent toutefois être utilisés en remplacement. Vous pouvez obtenir plus de détails sur le code et son fonctionnement dans notre article de blog.

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

Ce programme permet d’étendre et de rétracter en continu la course d’un vérin linéaire.

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
}