Cet exemple de code utilise un MegaMoto Plus pour surveiller le courant d'un actionneur linéaire.

 /* Code pour surveiller la consommation actuelle de l'actionneur et pour couper l'alimentation s'il
 dépasse un certain montant.

 Écrit par Progressive Automations
 19 août 2015

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

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

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

 const int CPin1 = A5 ; // retour moteur

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

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

 long dernier temps de retour = 0 ; // ça doit être long, sinon ça déborde
 int premier délai de retour = 750 ; //premier délai pour ignorer le pic de courant 
int feedbacktimedelay = 50 ; //délai entre les cycles de retour, à quelle fréquence vous souhaitez que le moteur soit vérifié
 long currentTimefeedback = 0 ; // ça doit être long, sinon ça déborde

 int anti-rebondTime = 300 ; // montant pour anti-rebond des boutons, des valeurs plus faibles rendent les boutons plus sensibles
 long lastButtonpress = 0; // timer pour anti-rebond
 long currentTimedebounce = 0 ;

 int CRaw = 0 ; // valeur d'entrée pour les lectures actuelles
 int maxAmps = 0 ; // limite de déplacement

 bool dontExtend = false;
 bool firstRun = vrai ;
 bool FullyRetracted = false ; // logique du programme

 void setup()
 {
 Série.begin(9600);
 pinMode (EnablePin, SORTIE);
 pinMode(PWMPinA, SORTIE);
 pinMode (PWMPinB, OUTPUT); // Définir les sorties du moteur
 pinMode(boutonGauche, INPUT);
 pinMode(boutonDroite, INPUT);//boutons

 digitalWrite(boutonGauche, HAUT);
 digitalWrite(buttonRight, HIGH);//activer les pullups internes
 pinMode (CPin1, INPUT); // définir l'entrée de retour

 currentTimedebounce = millis();
 currentTimefeedback = 0;//Définir les heures initiales

 maxAmps = 15 ;// RÉGLER LE COURANT MAX ICI

 }//fin de la configuration

 boucle vide()
 { 
latchButtons();//vérifie les boutons, voir si nous devons bouger

 moveMotor();//vérifier les loquets, déplacer le moteur vers l'intérieur ou l'extérieur

 }//fin de la boucle principale

 annuler latchButtons()
 {
 if (digitalRead(buttonLeft)==LOW)//left est en avant
 {
 currentTimedebounce = millis() - lastButtonpress;// vérifier le temps depuis la dernière pression
 if (currentTimedebounce > debounceTime && dontExtend == false)//une fois que vous avez déclenché dontExtend, ignorez toutes les pressions vers l'avant
 {
 leftlatch = !leftlatch;// si le moteur est en mouvement, arrêtez-vous, s'il est arrêté, commencez à bouger
 firstRun = true ; // définit l'indicateur firstRun pour ignorer le pic actuel
 FullyRetracted = faux ; // une fois que vous avancez, vous n'êtes pas complètement rétracté
 lastButtonpress = millis();//stocker l'heure de la dernière pression sur le bouton
 retour;
 }//fin si
 }//fin btnGAUCHE

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

 if (currentTimedebounce > debounceTime)
 { 
rightlatch = !rightlatch;// si le moteur est en mouvement, arrêtez-vous, s'il est arrêté, commencez à bouger
 firstRun = true ; // définit l'indicateur firstRun pour ignorer le pic actuel
 lastButtonpress = millis();//stocker l'heure de la dernière pression sur le bouton
 retour; }//fin si
 }//fin btnDROITE
 }//fin des boutons de verrouillage

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

 }//fin du moteur de déplacement

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

 Avoir un retour();
 firstRun = faux ;

 latchButtons();//vérifier à nouveau les boutons
 }//fin pendant

 }//fin du moteurAvant

 void motorBack (vitesse int)
 { 
tandis que (rightlatch == HIGH)
 {
 digitalWrite (EnablePin, ÉLEVÉ);
 analogWrite (PWMPinA, 0);
 analogWrite (PWMPinB, vitesse); // déplacer le moteur
 if (firstRun == true) delay(firstfeedbacktimedelay);// délai plus long pour ignorer le pic de courant
 sinon délai (feedbacktimedelay); //petit délai pour arriver à la vitesse
 Avoir un retour();

 firstRun = faux ;

 latchButtons();//vérifier à nouveau les boutons

 }//fin pendant

 dontExtend = false;//permet au moteur de s'étendre à nouveau après qu'il ait été rétracté

 }//fin du moteurRetour

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

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

 }//fin d'arrêtMoteur

 annuler getFeedback()
 {
 CRaw = lectureanalogique(CPin1); // Lire le courant

 si (CRaw == 0 && hitLimits < hitLimitsmax) hitLimits = hitLimits + 1;
 sinon hitLimits = 0 ; // vérifie si le moteur est aux limites et si le courant s'est arrêté

 si (hitLimits == hitLimitsmax && rightlatch == HIGH)
 { 
verrou droit = ​​BAS ; // arrête le moteur
 FullyRetracted = vrai ;
 }//fin si

 sinon si (hitLimits == hitLimitsmax && leftlatch == HIGH)
 {
 loquet gauche = BAS ;//arrêt du moteur
 hitLimits = 0 ;
 }//fin si

 si (CRaw > maxAmps)
 {
 dontExtend = vrai ;
 verrou gauche = BAS ; // s'arrête si le feedback dépasse le maximum
 }//fin si

 lastfeedbacktime = millis();//stocke l'heure précédente pour recevoir des commentaires
 }//fin getFeedback

Cet exemple de code montre comment contrôler jusqu'à 4 de nos actionneurs linéaires avec le Shield Arduino MultiMoto LC-82 . En raison des limitations actuelles sur chaque canal du MultiMoto, ce code est uniquement destiné à être utilisé avec nos modèles d'actionneurs PA-14 , PA-14P .

 /* Exemple de code pour contrôler jusqu'à 4 actionneurs, à l'aide du pilote Robot Power MultiMoto.
 Matériel:
 - Robot Power MultiMoto
 -Arduino Uno

 Câblage :
 - Connectez les actionneurs aux connexions M1, M2, M3, M4 de la carte MultiMoto.
 - Connectez le négatif (noir) à la connexion droite, le positif (rouge) à gauche. 
- Connectez une source de 12 volts (minimum 1A par moteur si déchargé, 8A par moteur si complètement chargé) aux bornes BAT. Assurez-vous que le positif et le négatif sont placés aux bons endroits.

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

 Démo de Robot Power MultiMoto v1.0
 Ce logiciel est publié dans le domaine public
 */

 // inclut la bibliothèque SPI :

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


 // L9958 Activer pour les 4 moteurs
 #définir ENABLE_MOTORS 8

 int pwm1, pwm2, pwm3, pwm4 ;
 booléen dir1, dir2, dir3, dir4 ;

 void setup() {
 mot de configuration int non signé ;

 // mets votre code d'installation ici, à exécuter une fois : 
pinMode(SS_M1, SORTIE); digitalWrite (SS_M1, FAIBLE); // ÉLEVÉ = non sélectionné
 pinMode(SS_M2, SORTIE); digitalWrite(SS_M2, FAIBLE);
 pinMode(SS_M3, SORTIE); digitalWrite(SS_M3, FAIBLE);
 pinMode(SS_M4, SORTIE); digitalWrite (SS_M4, FAIBLE);

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

 // Broches L9958 PWM
 pinMode (PWM_M1, SORTIE); digitalWrite (PWM_M1, FAIBLE);
 pinMode (PWM_M2, SORTIE); digitalWrite (PWM_M2, FAIBLE); // Minuterie1
 pinMode(PWM_M3, SORTIE); digitalWrite (PWM_M3, FAIBLE);
 pinMode (PWM_M4, SORTIE); digitalWrite (PWM_M4, FAIBLE); // Minuterie0

 // L9958 Activer pour les 4 moteurs
 pinMode(ENABLE_MOTORS, SORTIE);
 digitalWrite(ENABLE_MOTORS, ÉLEVÉ); // ÉLEVÉ = désactivé

 / /******* Configurer les puces L9958 *********
 ' Registre de configuration L9958
 ' Peu
 '0 - RES
 '1 - DR - réinitialiser
 '2 - CL_1 - limite actuelle
 '3 - CL_2 - curr_limite
 '4 - RÉS
 '5 - RÉS
 '6 - RÉS
 '7 - RÉS
 '8 - VSR - taux de montée en tension (1 active la limite de montée, 0 désactive) 
'9 - ISR - taux de balayage actuel (1 active la limite de balayage, 0 désactive)
 '10 - ISR_DIS - désactivation de l'évolution actuelle
 '11 - OL_ON - activation de la charge ouverte
 '12 - RÉS
 '13 - RÉS
 '14 - 0 - toujours zéro
 '15 - 0 - toujours zéro
 */ // défini sur la limite de courant maximale et désactive la limitation de balayage ISR
 mot de configuration = 0b0000010000001100 ;

 SPI.begin();
 SPI.setBitOrder(LSBFIRST);
 SPI.setDataMode(SPI_MODE1); // horloge pol = faible, phase = élevée

 // Moteur 1
 digitalWrite (SS_M1, FAIBLE);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 digitalWrite (SS_M1, ÉLEVÉ);
 // Moteur 2
 digitalWrite(SS_M2, FAIBLE);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 digitalWrite (SS_M2, ÉLEVÉ);
 // Moteur 3
 digitalWrite(SS_M3, FAIBLE);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 digitalWrite (SS_M3, ÉLEVÉ);
 // Moteur 4
 digitalWrite (SS_M4, FAIBLE);
 SPI.transfer(lowByte(configWord));
 SPI.transfer(highByte(configWord));
 digitalWrite (SS_M4, ÉLEVÉ);
 
//Définissez les paramètres initiaux de l'actionneur pour tirer à une vitesse 0 pour des raisons de sécurité
 rép1 = 0 ; rép2 = 0 ; rép3 = 0 ; rép4 = 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 de l'installation

 boucle vide() {
 rép1 = 1 ;
 pwm1 = 255 ; //définir la direction et la vitesse
 digitalWrite(DIR_M1, dir1);
 analogWrite (PWM_M1, pwm1); // écrire sur les épingles

 rép2 = 0 ;
 pwm2 = 128 ;
 digitalWrite(DIR_M2, dir2);
 analogWrite (PWM_M2, pwm2);

 rép3 = 1 ;
 pwm3 = 255 ;
 digitalWrite(DIR_M3, dir3);
 analogWrite (PWM_M3, pwm3);

 rép4 = 0 ;
 pwm4 = 128 ;
 digitalWrite(DIR_M4, dir4);
 analogWrite (PWM_M4, pwm4);

 retard (5000); // attend une fois que les quatre moteurs sont réglés

 rép1 = 0 ;
 pwm1 = 128 ;
 digitalWrite(DIR_M1, dir1);
 analogWrite (PWM_M1, pwm1);

 rép2 = 1 ;
 pwm2 = 255 ;
 digitalWrite(DIR_M2, dir2);
 analogWrite (PWM_M2, pwm2);

 rép3 = 0 ;
 pwm3 = 128 ;
 digitalWrite(DIR_M3, dir3);
 analogWrite (PWM_M3, pwm3);

 rép4 = 1 ;
 pwm4 = 255 ; 
digitalWrite(DIR_M4, dir4);
 analogWrite (PWM_M4, pwm4);

 retard (5000);

 }//fin de la boucle vide

Cet exemple de code permet de combiner notre LC-85 Wasp avec notre LC-066 pour contrôler le mouvement d'un actionneur linéaire .

 /*Exemple de code pour le Robot Power Wasp.

 Cet ESC est contrôlé à l'aide de signaux RC, avec des impulsions
 allant de 1 000 à 2 000 microsecondes.

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

 Modifié par Progressive Automations, en utilisant l'exemple de code original "Sweep" du
 Bibliothèques d'exemples Arduino.

 Matériel:
 - 1 contrôleur de guêpe
 -Arduino Uno

 Câblage :
 Côté contrôle :
 - Connectez le rouge/noir au +5v et GND
 - Connectez le fil jaune à votre broche de signal sur l'Arduino (dans cet exemple, la broche 9)
 Côté puissance :
 - Connecter le +/- de l'alimentation des moteurs aux connexions +/- du Wasp
 - Connectez le +/- de l'actionneur aux deux connexions restantes

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

 #include <servo.h>
 Servo monservo ; // crée un objet servo pour contrôler un servo
 // douze objets servo peuvent être créés sur la plupart des cartes

 int pos = 0 ; // variable pour stocker la position du servo

 void setup()
 {
 monservo.attach(9); // attache le servo sur la broche 9 à l'objet servo
 }

 boucle vide()
 {

 monservo.writeMicroseconds(1500); // signal d'arrêt
 retard (1000); //1 seconde

 monservo.writeMicroseconds(2000); // signal d'avance à pleine vitesse
 retard(2000); //2 secondes

 monservo.writeMicroseconds(1500); // signal d'arrêt
 retard (1000); // 1 seconde

 monservo.writeMicroseconds(1000); // signal de marche arrière à pleine vitesse
 retard(2000); //2 secondes

 }

Cet exemple de code utilise nos relais et notre LC-066 pour contrôler un actionneur linéaire. Vous pouvez lire notre article de blog complet pour plus de détails.

 const int forwards = 7 ;
 const int à l'envers = 6 ; // attribuer la broche INx du relais à la broche Arduino

 void setup() {

 pinMode (forwards, OUTPUT); // définir le relais comme sortie
 pinMode (à l'envers, OUTPUT); // définir le relais comme sortie

 }

 boucle vide() {

 digitalWrite (avant, BAS);
 digitalWrite(backwards, HIGH);//Activer le relais dans un sens, ils doivent être différents pour déplacer le moteur
 retard(2000); // attends 2 secondes

 digitalWrite (avant, ÉLEVÉ);
 digitalWrite(backwards, HIGH);//Désactiver les deux relais pour freiner le moteur
 délai (2000); // attendre 2 secondes

 digitalWrite (avant, ÉLEVÉ);
 digitalWrite(backwards, LOW);//Activer le relais dans l'autre sens, ils doivent être différents pour faire bouger le moteur
 délai (2000); // attendre 2 secondes

 digitalWrite (avant, ÉLEVÉ);
 digitalWrite(backwards, HIGH);//Désactiver les deux relais pour freiner le moteur
 délai (2000); // attendre 2 secondes

 }

Cet exemple de code utilise notre LC-80 , n'importe quel actionneur linéaire et une source d'alimentation. Vous pouvez obtenir plus de détails sur le code et ce qu'il fait dans notre article de blog .

 //Utilisez les cavaliers sur la carte pour sélectionner les broches qui seront utilisées
 int EnablePin1 = 13 ;
 int PWMPinA1 = 11 ;
 int PWMPinB1 = 3 ;


 int prolongation = 10 * 1000 ; // 10 secondes, multiplié par 1000 pour convertir en millisecondes
 int temps de rétractation = 10 * 1000 ; // 10 secondes, multiplié par 1000 pour convertir en millisecondes
 int timetorun = 300 * 1000 ; // 300 secondes, multiplié par 1 000 pour convertir en millisecondes


 devoir international;
 int temps écoulé ;
 booléen keepMoving ;


 void setup() {
 Série.begin(9600);
 pinMode(EnablePin1, OUTPUT);//Activer la carte
 pinMode(PWMPinA1, SORTIE);
 pinMode (PWMPinB1, OUTPUT); // Définir les sorties du moteur
 temps écoulé = 0 ; // Fixe l'heure à 0
 keepMoving = vrai ; //Le système va bouger

 }//fin de la configuration
 boucle vide() {
 si (continuer à bouger)
 {
 digitalWrite (EnablePin1, HIGH); // active le moteur
 pushActuator();
 délai (prolongation du temps);
 stopActuator();
 delay(10);//petit délai avant de se rétracter

 pullActuator();
 délai (temps de rétraction);
 stopActuator();

 elapsedTime = millis();//combien de temps cela fait-il ?
 if (elapsedTime > timetorun) {//si cela fait 300 secondes, arrêtez

 Serial.print("Le temps écoulé dépasse la durée d'exécution maximale. Durée d'exécution maximale : ");
 Serial.println(timetorun);
 keepMoving = faux ;
 }
 }//fin si
 }//fin de la boucle principale


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


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


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

Ce programme peut être utilisé pour prolonger et rétracter en continu la course d'un actionneur linéaire.

CODE DE BOUCLE DE CONFIGURATION
void setup() {
Série.begin(9600); // initialise la communication série à 9600 bits par seconde

pinMode(out_lim, INPUT_PULLUP); // configure la broche 45 comme broche d'entrée
pinMode(in_lim, INPUT_PULLUP); // configure la broche 53 comme broche d'entrée
pinMode(run_f, SORTIE); // configure la broche 25 comme broche de sortie
pinMode(run_r, SORTIE); // configure la broche 30 comme broche de sortie

se rétracter(); // rétracte le trait au démarrage
retard (500);
}
void extend() // cette fonction permet au moteur de tourner
{
digitalWrite(run_f, LOW);
digitalWrite(run_r, HIGH);
}

void retract() // cette fonction inverse le sens du moteur
{
digitalWrite(run_f, LOW);
digitalWrite(run_r, LOW);
}

void run_stop() // cette fonction désactive le moteur
{
digitalWrite(run_f, HIGH);
digitalWrite(run_r, HIGH);
}
boucle vide() {
int out_lim_state = digitalRead(out_lim); // lit les fins de course et enregistre sa valeur
int in_lim_state = digitalRead(in_lim);

Serial.print("valeur de fin de course extérieure"), Serial.println(out_lim_state); // 0 -> l'interrupteur de fin de course est enfoncé
Serial.print("valeur de fin de course interne"), Serial.println(in_lim_state); // 1 -> l'interrupteur de fin de course n'est pas enfoncé

if (out_lim_state == 0 && in_lim_state == 1) // si l'interrupteur de fin de course extérieur est enfoncé et que l'intérieur ne l'est pas (étendu complètement)
{
se rétracter(); // retire le trait
}

else if (out_lim_state == 1 && in_lim_state == 0) // si l'interrupteur de fin de course intérieur est enfoncé et que l'extérieur ne l'est pas (réactualisé complètement)
{
se déployer(); // prolonge le trait
}

else // sinon ne rien faire
{

}
retard(5); // délai entre les lectures pour la stabilité
}