)
Dans le guide d'aujourd'hui, nous allons voir comment déterminer la force appliquée par un actionneur linéaire en surveillant le courant consommé. Ce guide, plus avancé, nécessitera des étapes de codage, d'étalonnage et de programmation complexes. Nous aborderons la surveillance d'une entrée analogique et son utilisation. Pour ce projet, nous utiliserons une MegaMoto Plus , un actionneur linéaire (nous utilisons notre mini-actionneur PA-14 ), un Arduino Uno et une alimentation d'au moins 12 V.
Pour commencer, il faut réaliser le câblage pour tout connecter. Commencez par brancher la MegaMoto sur l'Arduino. Pour cela, placez-la simplement sur l'Uno. Connectez ensuite un fil entre la borne BAT+ de la MegaMoto et la broche Vin de l'Uno.
Il faut maintenant connecter les fils des actionneurs linéaires aux bornes A et B de la MegaMoto, puis connecter l'alimentation 12 V à BAT+ et GND à BAT-. Il faudra également câbler deux boutons de commande en les reliant chacun à une broche libre et à GND. Nous recommandons de les connecter sur une platine d'expérimentation. 
Il est maintenant temps de coder avec l'Arduino Uno. Nous souhaitons programmer les boutons pour qu'ils contrôlent l'extension et la rétraction de l'actionneur. Le courant sera surveillé dès l'extension de l'actionneur, ce qui nous permettra de vérifier s'il dépasse la limite de courant maximale. S'il dépasse cette limite, l'actionneur s'arrêtera automatiquement jusqu'à ce que vous choisissiez de le rétracter. Compte tenu du pic de courant important que subissent les moteurs des actionneurs lors de leur première mise sous tension, le code saisi démarrera la surveillance du courant après un court délai. Ce code permettra de savoir quand l'actionneur a atteint ses fins de course, c'est-à-dire lorsque le courant chute à 0.
const int EnablePin = 8;
const int PWMPinA = 11;
const int PWMPinB = 3 ; // pins 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 = BAS ;
int rightlatch = LOW;//verrous de moteur (utilisés pour la logique du code)
int hitLimits = 0;//démarrer à 0
int hitLimitsmax = 10;//valeurs permettant de savoir si les limites de déplacement ont été atteintes
long lastfeedbacktime = 0; // doit être long, sinon il déborde
int firstfeedbacktimedelay = 750; // premier délai pour ignorer le pic actuel
int feedbacktimedelay = 50; //délai entre les cycles de rétroaction, à quelle fréquence vous souhaitez que le moteur soit vérifié
long currentTimefeedback = 0; // doit être long, sinon il déborde
int debounceTime = 300; //quantité de boutons anti-rebond, des valeurs inférieures rendent les boutons plus sensibles
long lastButtonpress = 0; // minuterie pour anti-rebond
long currentTimedebounce = 0;
int CRaw = 0; // valeur d'entrée pour les lectures actuelles
int maxAmps = 0; // limite de déclenchement
bool dontExtend = false;
booléen firstRun = vrai;
bool fullyRetracted = false;//logique du programme
configuration vide()
{
Serial.begin(9600);
pinMode(EnablePin, OUTPUT);
pinMode(PWMPinA, SORTIE);
pinMode(PWMPinB, OUTPUT);//Définir les sorties du moteur
pinMode(boutonGauche, ENTRÉE);
pinMode(boutonDroit, ENTRÉE);//boutons
digitalWrite(boutonGauche, HAUT);
digitalWrite(buttonRight, HIGH);//activer les pullups internes
pinMode(CPin1, INPUT);//définir l'entrée de rétroaction
currentTimedebounce = millis();
currentTimefeedback = 0;//Définir les heures initiales
maxAmps = 15;// RÉGLER LE COURANT MAXIMUM ICI
}//fin de la configuration
boucle vide()
{
latchButtons();//vérifier les boutons, voir si nous devons nous déplacer
moveMotor();//vérifier les verrous, déplacer le moteur vers l'intérieur ou vers l'extérieur
}//fin de la boucle principale
void latchButtons()
{
si (digitalRead(buttonLeft)==LOW)//gauche est en avant
{
currentTimedebounce = millis() - lastButtonpress;// vérifier le temps écoulé depuis la dernière pression
si (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éfinir l'indicateur firstRun pour ignorer le pic actuel
fullyRetracted = false; // une fois que vous avancez, vous n'êtes pas complètement rétracté
lastButtonpress = millis();//enregistre l'heure de la dernière pression sur le bouton
retour;
}//fin si
}//fin btnLEFT
si (digitalRead(buttonRight)==LOW)//droite est à l'envers
{
currentTimedebounce = millis() - lastButtonpress;// vérifier le temps écoulé depuis la dernière pression
si (currentTimedebounce > debounceTime)
{
rightlatch = !rightlatch;// si le moteur est en mouvement, arrêtez-vous, s'il est arrêté, commencez à bouger
firstRun = true;// définir l'indicateur firstRun pour ignorer le pic actuel
lastButtonpress = millis();//enregistre l'heure de la dernière pression sur le bouton
retour; }//fin si
}//fin btnRIGHT
}//fin des latchButtons
void moveMotor()
{
si (leftlatch == HIGH) motorForward(255); //vitesse = 0-255
si (leftlatch == LOW) motorStop();
si (rightlatch == HIGH) motorBack(255); //vitesse = 0-255
si (rightlatch == LOW) motorStop();
}//fin du déplacement du moteur
void motorForward(int vitesse)
{
while (dontExtend == false && leftlatch == HIGH)
{
digitalWrite(EnablePin, HAUT);
analogWrite(PWMPinA, vitesse);
analogWrite(PWMPinB, 0);//déplacer le moteur
if (firstRun == true) delay(firstfeedbacktimedelay); // délai plus long pour ignorer le pic actuel
else delay(feedbacktimedelay); //petit délai pour atteindre la vitesse
obtenir un retour d'information();
firstRun = faux;
latchButtons();//vérifier à nouveau les boutons
}//fin pendant que
}//fin du moteur en avant
void motorBack (vitesse int)
{
tandis que (rightlatch == HAUT)
{
digitalWrite(EnablePin, HAUT);
analogWrite(PWMPinA, 0);
analogWrite(PWMPinB, speed);//déplacer le moteur
si (firstRun == true) delay(firstfeedbacktimedelay);// délai plus long pour ignorer le pic actuel
else delay(feedbacktimedelay); //petit délai pour atteindre la vitesse
obtenir un retour d'information();
firstRun = faux;
latchButtons();//vérifier à nouveau les boutons
}//fin pendant que
dontExtend = false;//permettre au moteur de s'étendre à nouveau, après avoir été rétracté
}//fin du moteurRetour
void motorStop()
{
analogWrite(PWMPinA, 0);
analogWrite(PWMPinB, 0);
digitalWrite(EnablePin, BAS);
firstRun = true;//une fois le moteur arrêté, réactivez firstRun pour tenir compte des pics de courant de démarrage
}//fin de courseMoteur
void getFeedback()
{
CRaw = analogRead(CPin1); // Lire le courant
si (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é
si (hitLimits == hitLimitsmax && rightlatch == HAUT)
{
rightlatch = LOW; // arrêter le moteur
entièrement rétracté = vrai ;
}//fin si
sinon si (hitLimits == hitLimitsmax && leftlatch == HIGH)
{
leftlatch = LOW;//arrêter le moteur
hitLimits = 0;
}//fin si
si (CRaw > maxAmps)
{
dontExtend = vrai;
leftlatch = LOW; // arrêt si le retour est supérieur au maximum
}//fin si
lastfeedbacktime = millis();//stocke l'heure précédente de réception des commentaires
}//fin de getFeedback
Avec ce code de base, vous devriez être en mesure de surveiller efficacement le retour d'information de votre actionneur linéaire. Dans la partie 2, nous approfondirons le fonctionnement du code et vous expliquerons comment le modifier à votre guise. Nous espérons que cet article vous a été utile. Restez connectés pour la partie 2 dans les semaines à venir. Pour commander des unités utilisées dans cet exemple ou pour en savoir plus sur nos produits, n'hésitez pas à nous contacter .