Shield L293D - Raccordement et programme Arduino pour varier la vitesse d'un moteur DC 👨💻
Lorsque l'on souhaite commander un moteur à courant continu, il est parfois nécessaire de choisir le sens de rotation du moteur mais également de modifier la vitesse de rotation de l'arbre moteur.
Pour simplifier la variation de la vitesse d'un moteur DC, j'utilise une Arduino et une carte L293D qui me permettra de changer la vitesse de rotation du moteur à partir d'une consigne PWM.
Comment raccorder l'Arduino, le Shield motor L293D et le moteur à courant continu ? Quel programmes permettent de gérer la vitesse du moteur à courant continu ?
Découvrez les réponses à ces questions en lisant cet article dédié à la variation de vitesse.
Sommaire :
• Quels est le matériel utilisé dans ce tutoriel ?• Qu'est-ce que le signal PWM généré par l'Arduino ?
• Comment raccorder l'arduino et le Shield moteur L293D ?
• Programmation Arduino pour la variation de vitesse
• Variateur de vitesse en vidéo
Quels est le matériel utilisé dans ce tutoriel ? :
Pour réaliser les différentes expériences ou pour reproduire les explications chez vous, vous aurez besoin du matériel suivant : • Une Arduino et son câble USB.
• Un module L293D (Mini 4-Channel Motor Drive Shield L293D).
• Des conducteurs pour plaque d'essai ou fils de prototypage (mâle/mâle, mâle/femelle, femelle/femelle).
• Un moteur à courant continu, personnellement je l'ai récupéré d'une vieille imprimante.
• Une alimentation à découpage pour l'alimentation du moteur.
• Un potentiomètre rotatif permettant de faire varier la résistance.
• Un joystick Dual-axis XY permettant de faire varier la résistance comme le potentiomètre.
• Une platine d'expérimentation ou plaque d'essai breadboard (optionnel).
Si vous ne connaissez pas le Shield L293D permettant de contrôler un moteur à courant continu (inversion du sens de rotation du moteur, variation de vitesse) en sécurité avec une arduino consultez ce tutoriel Arduino.
Alimentation à découpage (courant continu)
L'alimentation à découpage permet de fournir la tension et la puissance nécessaire afin de faire tourner le moteur de façon optimale. Le moteur à courant continu que j'ai démonté d'une imprimante HP supporte une alimentation jusqu'à 24V DC, mais arrive à tourner à vide (sans aucune charge), avec une pile de 9V.
Si le moteur que vous utilisez supporte également une tension assez faible, vous pouvez expérimenter vos montages avec une alimentation simple de type pile 9V. Lorsque tous vos essais seront terminés, vous pourrez finaliser votre montage avec une alimentation à découpage fournissant la puissance électrique nécessaire au moteur à courant continu.
L'alimentation à courant continu ci-dessous dispose de deux bornes d'alimentation repérée L et N pour alimenter le boitier avec une tension secteur de 230V alternatif (AC). Le signal en courant continu est sur les bornes V+ et V-, la valeur de tension est réglable sur une plage qui dépend de chaque alimentation à découpage.
Le réglage de la valeur de la tension continue en sortie se fait avec la molette ADJ sur la droite. En utilisant un voltmètre calibré sur VDC, en le plaçant en sortie de l'alimentation continue V+ V- vous pourrez régler la tension souhaitée.
Qu'est-ce que le signal PWM généré par l'Arduino ?
Le signal logique ou TOR
L'Arduino est capable d'émettre en sortie un signal de type Tout ou Rien (TOR) ou Logique, c'est à dire soit :• High et dans ce le signal émis vaut 5V ou 3,3V en sortie de la borne.
• Low et dans ce le signal émis vaut 0V en sortie de la borne.
Le signal logique ou Tout ou Rien ne peut donc prendre que 2 valeurs possibles (High ou Low). En tant que sortie avec ce signal on peut soit activer la sortie (HIGH) ou bien la désactiver (LOW).
C'est une logique binaire composée de deux valeur, elle correspond à un bit (2 valeurs = 21).
Le signal PWM est également connu sous la désignation MLI ou Modulation de Largeur d'Impulsions et Pulse Width Modulation, soit PWM en anglais. La MLI est utilisé dans les variateurs pour machine asynchrone pour réaliser la variation de la vitesse.
PWM de l'Arduino
L'information PWM peut être générée par certaines sorties de l'Arduino (voir tableau des sorties PWM Arduino).Contrairement au signal logique, le signal PWM de l'Arduino est codé sur 8 bits, il propose donc 256 valeurs possibles 28=256 valeurs de 0 à 255.
PWM et le rapport cyclique
Pour différencier les 256 combinaisons, on ne va pas jouer sur les niveaux de la tension (HIGH ou LOW) mais sur le cycle de changement des valeurs HIGH et LOW.Ainsi, en fonction du temps ou l'information LOW est envoyé et le temps pendant lequel HIGH est émix pendant une même période, on obtiendra des combinaisons différentes.
L'information portée par le signal PWM se fait sur une fréquence d'environ 500 HZ soit une période de 2 ms.
Pour comprendre, regardez les animations ci-dessous qui présente différent rapport cyclique ou différente valeur de PWM et la conséquence pour une led raccordé en sortie.
• Pour un rapport cyclique de 100% le signal est toujours actif (HIGH), c'est à dire que si on raccorde un voyant sur cette sortie, il sera tout le temps allumé. La valeur correspondante est PWM = 255.
• Pour un rapport cyclique de 90% le signal alterne LOW pendant 10% du temps et HIGH les 90% du temps restant, si on raccorde un voyant sur cette sortie, il sera allumé allumé pendant 90% du temps et éteint pendant 10% du temps. La valeur correspondante est PWM ≈ 230.
• Pour un rapport cyclique de 90% le signal alterne LOW pendant 10% du temps et HIGH les 90% du temps restant, si on raccorde un voyant sur cette sortie, il sera allumé allumé pendant 50% du temps et éteint pendant 50% du temps. La valeur correspondante est PWM = 127.
• Pour un rapport cyclique de 10% le signal alterne LOW pendant 90% du temps et HIGH les 10% du temps restant, si on raccorde un voyant sur cette sortie, il sera allumé allumé pendant 10% du temps et éteint pendant 90% du temps. La valeur correspondante est PWM ≈ 25.
• Pour un rapport cyclique de 0% le signal est toujours inactif (LOW), si on raccorde un voyant sur cette sortie, il sera tout le temps éteint. La valeur correspondante est PWM = 0.
Si vous vous posez encore la question à quoi sert la PWM ?, consultez l' article dédié au signal PWM et à son application dans les montages électroniques.
Comment raccorder l'arduino et le Shield L293D ?
Repérage des broches du Shield L293D
Repérage des bornes de raccordement du Shield L293D :
• VIN GND Alimentation logique du cicuit L293D jusqu'à 24V.
• VCC GND Alimentation des moteurs à courant continu de 3,5V à 24V.
Moteur à courant continu n°1 :
• A+ A- Alimentation du moteur DC n°1.
• IN1 IN2 Commande du sens de rotation ou le freinage du moteur n°1.
Moteur à courant continu n°2 :
• B+ B- Alimentation du moteur DC n°2.
• IN3 IN4 Commande du sens de rotation ou le freinage du moteur n°2.
• VIN GND Alimentation logique du cicuit L293D jusqu'à 24V.
• VCC GND Alimentation des moteurs à courant continu de 3,5V à 24V.
Moteur à courant continu n°1 :
• A+ A- Alimentation du moteur DC n°1.
• IN1 IN2 Commande du sens de rotation ou le freinage du moteur n°1.
Moteur à courant continu n°2 :
• B+ B- Alimentation du moteur DC n°2.
• IN3 IN4 Commande du sens de rotation ou le freinage du moteur n°2.
Broches PWM du Shield L293D
Tout d'abord pour comprendre comment on peut faire varier la vitesse d'un moteur à courant continu avec l'Ardunino, nous allons nous intéresser plus précisément au Shield L293D et identifier la ou les broches permettant de recevoir l'information de vitesse.Sur la carte du Shield L293D les bornes d'entrées repérées EN1 et EN2 permettent respectivement de recevoir l'information de vitesse en provenance de l'Arduino. Ce signal est de forme PWM est doit être généré par la carte Arduino.
Cavaliers sur les Broches PWM
Sur un Shield L293D d'origine sont présents sur EN1 et EN2 deux cavaliers de pontage (Shunt ou jumpers) permettant de court-circuiter les entrées pour désactiver la variation de vitesse.
Pour autoriser la variation de vitesse du moteur n°1, il faut donc enlever le cavalier présent sur EN1 et envoyer un premier signal PWM sur EN1.
La broche EN1 du L293D est celle la plus proche du repère EN1 (voir photo ci-dessus), la seconde est directement reliée au contact Vcc. Ainsi en plaçant le cavalier sur EN1 on shunte Vcc et EN1, la vitesse maximale est envoyée au moteur, sans variation ou réglage possible de la vitesse du moteur.
Pour permettre la gestion de la vitesse sur le moteur n°2, il faut faire de même et retirer le shunt noir présent sur EN2 et envoyer un seconde signal PWM sur EN2.
Broches Arduino pour le signal PWM
Les signaux PWM devront être générés par l'Arduino en utilisant l'une des broches ou bornes repérées PWM et en lui attribuant la fonction Output (sortie).| Type ou Modèle d'Arduino | Broches disponibles PWM |
|---|---|
| Uno, Pro Mini, Nano | 3, 5, 6, 9, 10 et 11 |
| Leonardo | 3, 5, 6, 9, 10, 11 et 13 |
| Due | 2 à 13 |
| Zero | 2 à 13 |
| Mega | 2 à 13 et 44 à 46 |
J'utilise pour ce tutoriel une Arduino Mega, et j'affecterai la broche n°10 en tant qu'émettrice du signal PWM sur le Shield L293D.
Schéma de raccordement Arduino Shield L293D Moteur
Pour commander un seul moteur dans les deux sens de rotation et pour faire varier sa vitesse il faut respecter le schéma de raccordement ci-dessous.
Schéma électrique :
Pour vous aider à relier votre matériel (Alim-L293D-Arduino-moteur), vous pouvez également consulter le schéma électrique ci-dessous.
L'alimentation à découpage délivre la tension nécessaire au fonctionnement optimal du moteur à courant continu.
Pour faciliter les branchements de votre matériel, respecter un code couleur des conducteurs en mettant en rouge les potentiels positifs (+) et en noir les masses ou potentiels négatifs (-).
Branchement du potentiomètre
Pour changer manuellement la vitesse du moteur DC, j'utilise un vieux potentiomètre linéaire rotatif (120Ω dans l'exemple), vous pouvez trouver des kits de potentiomètres plus pratiques sur le net.
Le potentiomètre possède 3 bornes, je les relie sur les broches GND, 5V et A0 de l'Arduino. Le potentiomètre n'est autre qu'une résistance variable à l'aide d'un bouton rotatif. En fonction de la position de la molettre ou du curseur la valeur ohmmique du potentiomètre change de sa valeur minimale à sa valeur maximale. à l'aide d'une molette ou d'un curseur. Pour un potentiomètre de 120Ω, la résistance varie de 0Ω jusqu'à 120Ω.
Plan de branchement de l'ensemble avec le potentiomètre :
Schéma électrique avec le potentiomètre :
Raccordements avec un joystick dual-axis :
Pour faire varier la vitesse, il est possible d'utiliser une commande via joystick, une lecture analogique de la position du joystick permettra d'envoyer la consigne de vitesse du moteur (voir programme associé).
Programmation Arduino pour la variation de vitesse :
Afin d'écrire de programmer l'Arduino, j'utiliserai Arduino IDE, l'application permettant d'écrire et de télécharger les programmes dans votre carte arduino ou compatible.
Vous trouverez une liste de programmes permettant de faire de la variation de vitesse mais selon des logiques différentes :
• Accélération et décélération automatiques du moteur.
• Variation de la vitesse du moteur à partir d'un potentiomètre.
• Varier la vitesse d'un moteur avec deux boutons poussoir un pour accélérer, l'autre pour ralentir le moteur.
Accélération et décélération automatiques du moteur
Avec ce programme, le moteur DC accélère et décélère automatiquement sans aucune manipulation externe.
int Moteur_sens1=4; // Pin 4 Arduino vers broche A+ du L293D
int Moteur_sens2=5; // Pin 5 Arduino vers broche A- du L293D
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
int PWM=0; // Variable PWM image de la vitesse
void setup() {
Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
pinMode(moteur1_PWM, OUTPUT); // Pin 10 Arduino en sortie PWM
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
delay( 1000 ); // Attendre 1 secode avant le lancement de la fonction accélération
Acceleration(); // Lance la fonction Acceleration()
}
void loop() {
}
// Le temps d'accélération est réglage avec le changement du delay
void Acceleration(){
for (PWM = 0; PWM <= 255; PWM++){ // Boucle pour augmenter PWM de 0 jusqu'à 255
delay( 10 ); // Attendre 10ms avant la prochaine incrémentation du PWM
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.print("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
delay( 3000 ); // Attente de 3 secondes
Deceleration();
}
// Le temps de décélération est réglage avec le changement du delay
void Deceleration(){
for (PWM = 255; PWM >= 0; --PWM){// Boucle pour dminuer PWM de 255 jusqu'à 0
delay( 10 ); // Attendre 10ms avant la prochaine décrémentation du PWM
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.print("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
// Arrêt du moteur
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
delay( 3000 ); // Attente de 3 secondes
Acceleration(); // On relance l'accélération du moteur
}
int Moteur_sens2=5; // Pin 5 Arduino vers broche A- du L293D
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
int PWM=0; // Variable PWM image de la vitesse
void setup() {
Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
pinMode(moteur1_PWM, OUTPUT); // Pin 10 Arduino en sortie PWM
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
delay( 1000 ); // Attendre 1 secode avant le lancement de la fonction accélération
Acceleration(); // Lance la fonction Acceleration()
}
void loop() {
}
// Le temps d'accélération est réglage avec le changement du delay
void Acceleration(){
for (PWM = 0; PWM <= 255; PWM++){ // Boucle pour augmenter PWM de 0 jusqu'à 255
delay( 10 ); // Attendre 10ms avant la prochaine incrémentation du PWM
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.print("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
delay( 3000 ); // Attente de 3 secondes
Deceleration();
}
// Le temps de décélération est réglage avec le changement du delay
void Deceleration(){
for (PWM = 255; PWM >= 0; --PWM){// Boucle pour dminuer PWM de 255 jusqu'à 0
delay( 10 ); // Attendre 10ms avant la prochaine décrémentation du PWM
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.print("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
// Arrêt du moteur
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
delay( 3000 ); // Attente de 3 secondes
Acceleration(); // On relance l'accélération du moteur
}
Le programme précédent va générer la variation de la vitesse du moteur DC selon la logique présentée sur le graphe suivant :
Pour changer la rampe d'accélération ou la rampe de décélération, il faut modifier les temps delay (10 ms) placés dans les boucles for. En augmentant la valeur ce temps, le moteur DC démarrera plus en douceur et il atteindra sa vitesse maximale moins rapidement.
Pour afficher le moniteur série sur le logiciel Arduino IDE, il faut cliquer sur le menu Outils et puis sur Moniteur Série ou alors en pressant la combinaison de touches Ctrl + Maj + M.
Arduino IDE
Moniteur Série avec le logiciel Arduino IDE
Varier la vitesse d'un moteur avec un potentiomètre
Info : Pour exploiter ce programme, il faut vous référer au schéma de branchement Arduino avec potentiomètre.
int Moteur_sens1=4; // Pin 4 Arduino vers broche A+ du L293D
int Moteur_sens2=5; // Pin 5 Arduino vers broche A- du L293D
int Potentiometre = A0; // Pin A0 Arduino vers broche variable du potentiomètre
int ValeurPot=0; // Variable potentiomètre
int PWM; // Variable PWM image de la vitesse
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
// Code de configuration exécuté une seule fois
void setup() {
Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
pinMode(moteur1_PWM, OUTPUT); // Pin 10 Arduino en sortie PWM
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
}
// Boucle du programme
void loop() {
ValeurPot=analogRead(Potentiometre); // Lecture de la valeur analogique en sortie du potentiomètre
PWM=map(ValeurPot,0,1020,0,255); // Associer la valeur du potentiomètre au signal PWM
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
// Condition Si la vitesse est supérieure à zéro alors on fait tourner le moteur
if(PWM>0){
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
}
else{// Sinon on arrête le moteur
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
}
Serial.print("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
int Moteur_sens2=5; // Pin 5 Arduino vers broche A- du L293D
int Potentiometre = A0; // Pin A0 Arduino vers broche variable du potentiomètre
int ValeurPot=0; // Variable potentiomètre
int PWM; // Variable PWM image de la vitesse
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
// Code de configuration exécuté une seule fois
void setup() {
Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
pinMode(moteur1_PWM, OUTPUT); // Pin 10 Arduino en sortie PWM
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
}
// Boucle du programme
void loop() {
ValeurPot=analogRead(Potentiometre); // Lecture de la valeur analogique en sortie du potentiomètre
PWM=map(ValeurPot,0,1020,0,255); // Associer la valeur du potentiomètre au signal PWM
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
// Condition Si la vitesse est supérieure à zéro alors on fait tourner le moteur
if(PWM>0){
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
}
else{// Sinon on arrête le moteur
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
}
Serial.print("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
La ligne PWM=map(ValeurPot,0,1020,0,255); utilise la fonction map afin de convertir, selon un produit en croix, les valeurs analogiques du potentiomètre en signal PWM allant de 0 jusqu'à 255.
Pour information, la valeur 1020 est propre à mon potentiomètre.
Pour connaître la valeur maximale de votre potentiomèter à noter dans votre programme, il faut lire l'entrée analogique A0 du potentiomètre quand celui-ci est réglé à la résistance maximale :
void setup() {
Serial.begin(9600); // Ouverture du port série pour utilisé le moniteur série
}
void loop() {
Serial.print("valeur du potentiomètre = "); // Affichage du texte dans le moniteur série
Serial.println(analogRead(A0)); // Valeur lue du potentiomètre
}
Serial.begin(9600); // Ouverture du port série pour utilisé le moniteur série
}
void loop() {
Serial.print("valeur du potentiomètre = "); // Affichage du texte dans le moniteur série
Serial.println(analogRead(A0)); // Valeur lue du potentiomètre
}
En utilisant le moniteur série, vous n'aurez plus qu'à relever la valeur analogique affichée.
Accélération et décélération avec un joystick
En utilisant un module joystick Dual-axis XY, il est possible de commander la vitesse de fonctionnement du moteur dans les deux sens de marche.
Pour cela, j'utilise un seul axe du jostick, par exemple l'axe horizontal (axe X), lorsque le joystick est vers la droite, le moteur tourne dans le sens normal et la vitesse dépendra de l'inclinaison du joystick.
Pour arrêter le moteur, il lâcher le joystick qui se remet dans sa position initiale. Enfin, pour inverser le sens de rotation du moteur, j'oriente le joystick vers la gauche et son inclinaison fera varier la vitesse du moteur à courant continu.
int Moteur_sens1=4; // Pin 4 Arduino vers broche A+ du L293D
int Moteur_sens2=5; // Pin 5 Arduino vers broche A- du L293D
int Potentiometre = A0; // Pin A0 Arduino vers broche X du Joystick
int ValeurPot=0; // Valeur du Joystick
int PWM; // Variable PWM image de la vitesse
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
// Code de configuration exécuté une seule fois
void setup() {
Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
pinMode(moteur1_PWM, OUTPUT); // Pin 10 Arduino en sortie PWM
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
}
// Boucle du programme
void loop() {
ValeurPot=analogRead(Potentiometre); // Lecture de la valeur analogique en sortie du Joystick
if(ValeurPot>498) // Joystick vers la droite (sens normal)
{
PWM=map(ValeurPot,498,1023,0,255); // Associer la valeur x+ du Joystick au signal PWM
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur sens normal"); // Affichage sur le moninteur série du texte
Serial.println("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
else if(ValeurPot<494) // Joystick vers la gauche (sens inverse)
{
PWM=map(ValeurPot,494,0,0,255); //Associer la valeur x- du Joystick au signal PWM
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,HIGH); // Activation de la broche A- du L293D
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur sens inverse"); // Affichage sur le moninteur série du texte
Serial.println("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
else // Joystick au centre arrêt moteur
{
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
analogWrite(moteur1_PWM,0); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur à l'arrêt"); // Affichage sur le moninteur série du texte
}
}
int Moteur_sens2=5; // Pin 5 Arduino vers broche A- du L293D
int Potentiometre = A0; // Pin A0 Arduino vers broche X du Joystick
int ValeurPot=0; // Valeur du Joystick
int PWM; // Variable PWM image de la vitesse
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
// Code de configuration exécuté une seule fois
void setup() {
Serial.begin(9600); // Ouverture du port série et debit de communication fixé à 9600 bauds
pinMode(moteur1_PWM, OUTPUT); // Pin 10 Arduino en sortie PWM
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
}
// Boucle du programme
void loop() {
ValeurPot=analogRead(Potentiometre); // Lecture de la valeur analogique en sortie du Joystick
if(ValeurPot>498) // Joystick vers la droite (sens normal)
{
PWM=map(ValeurPot,498,1023,0,255); // Associer la valeur x+ du Joystick au signal PWM
digitalWrite(Moteur_sens1,HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur sens normal"); // Affichage sur le moninteur série du texte
Serial.println("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
else if(ValeurPot<494) // Joystick vers la gauche (sens inverse)
{
PWM=map(ValeurPot,494,0,0,255); //Associer la valeur x- du Joystick au signal PWM
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,HIGH); // Activation de la broche A- du L293D
analogWrite(moteur1_PWM,PWM); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur sens inverse"); // Affichage sur le moninteur série du texte
Serial.println("Valeur PWM : "); // Affichage sur le moninteur série du texte
Serial.println(PWM); // Affichage sur le moninteur série de la valeur PWM
}
else // Joystick au centre arrêt moteur
{
digitalWrite(Moteur_sens1,LOW); // Désactivation de la broche A+ du L293D
digitalWrite(Moteur_sens2,LOW); // Désactivation de la broche A- du L293D
analogWrite(moteur1_PWM,0); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur à l'arrêt"); // Affichage sur le moninteur série du texte
}
}
Accélération et décélération avec deux boutons poussoirs
Ce scénarion utilise deux boutons poussoirs reliés aux entrées digitales 11 et 12.• Dès que l'un appui sur le premier bouton on incrémente la vitesse PWM de 5.
• Dès que l'un appui sur le second bouton on diminu la vitesse PWM de 5.
Programme correspondant :
int commande_plus=11; // Bouton plus
int commande_moins=12; // Bouton Droit
int Moteur_sens1 = 4; // Pin 4 Arduino vers broche A+ du L293D
int Moteur_sens2 = 5; // Pin 5 Arduino vers broche A- du L293D
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
int vitesse_PWM=0; // On affecte 0 au PWM
boolean etat_bp_plus,etat_bp_moins; // Déclaration des variables logiques moins et plus
boolean mem_g,mem_d; // Déclaration des mémoires plus et moins
void setup()
{
pinMode(commande_plus, INPUT_PULLUP); // On définit la broche 11 en entrée digitale
pinMode(commande_moins, INPUT_PULLUP); // On définit la broche 12 en entrée digitale
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
Serial.begin(9600); //Initialisation de la liaison série à 9600 bauds
}
void loop()
{
etat_bp_plus=!digitalRead(commande_plus); // Inverse de la lecture sur entrée BP plus
etat_bp_moins=!digitalRead(commande_moins); // Inverse de la lecture sur entrée BP moins
if(etat_bp_plus!=mem_plus) // Changement d'état du bouton poussoir plus (front montant ou descendant)
{
if(etat_bp_plus && !etat_moins) // Appui sur BP plus mais pas sur le moins
{
Accelerer(); // Lancer la fonction accélérer
}
}
mem_plus=etat_bp_plus; // Mémorisation du nouvel état du bouton plus
if(etat_bp_moins!=mem_moins) // Changement d'état du bouton poussoir droit (front montant ou descendant)
{
if(etat_bp_moins && !etat_bp_plus) // Appui sur BP Moins mais pas sur le plus
{
Decelerer(); // Lancer la fonction décélérer
}
}
mem_moins=etat_bp_moins; // Mémorisation du nouvel état du bouton droit
delay(100); // Attendre 100ms
};
void Accelerer() {
if(vitesse_PWM<=250) {
vitesse_PWM=vitesse_PWM+5;
}
analogWrite(moteur1_PWM,vitesse_PWM); // Envoi du signal PWM sur la sortie analogique 10
digitalWrite(Moteur_sens1, HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2, LOW); // Désactivation de la broche A- du L293D
Serial.print("On accélère le moteur | PWM = ");
Serial.println(vitesse_PWM);
}
void Decelerer()
{
if(vitesse_PWM>=5)
{
vitesse_PWM=vitesse_PWM-5;
}
analogWrite(moteur1_PWM,vitesse_PWM); // Envoi du signal PWM sur la sortie analogique 10
digitalWrite(Moteur_sens1, HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2, LOW); // Désactivation de la broche A- du L293D
Serial.print("On ralentit le moteur | PWM = ");
Serial.println(vitesse_PWM);
}
int commande_moins=12; // Bouton Droit
int Moteur_sens1 = 4; // Pin 4 Arduino vers broche A+ du L293D
int Moteur_sens2 = 5; // Pin 5 Arduino vers broche A- du L293D
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D
int vitesse_PWM=0; // On affecte 0 au PWM
boolean etat_bp_plus,etat_bp_moins; // Déclaration des variables logiques moins et plus
boolean mem_g,mem_d; // Déclaration des mémoires plus et moins
void setup()
{
pinMode(commande_plus, INPUT_PULLUP); // On définit la broche 11 en entrée digitale
pinMode(commande_moins, INPUT_PULLUP); // On définit la broche 12 en entrée digitale
pinMode(Moteur_sens1, OUTPUT); // Pin 4 Arduino en sortie digitale
pinMode(Moteur_sens2, OUTPUT); // Pin 5 Arduino en sortie digitale
Serial.begin(9600); //Initialisation de la liaison série à 9600 bauds
}
void loop()
{
etat_bp_plus=!digitalRead(commande_plus); // Inverse de la lecture sur entrée BP plus
etat_bp_moins=!digitalRead(commande_moins); // Inverse de la lecture sur entrée BP moins
if(etat_bp_plus!=mem_plus) // Changement d'état du bouton poussoir plus (front montant ou descendant)
{
if(etat_bp_plus && !etat_moins) // Appui sur BP plus mais pas sur le moins
{
Accelerer(); // Lancer la fonction accélérer
}
}
mem_plus=etat_bp_plus; // Mémorisation du nouvel état du bouton plus
if(etat_bp_moins!=mem_moins) // Changement d'état du bouton poussoir droit (front montant ou descendant)
{
if(etat_bp_moins && !etat_bp_plus) // Appui sur BP Moins mais pas sur le plus
{
Decelerer(); // Lancer la fonction décélérer
}
}
mem_moins=etat_bp_moins; // Mémorisation du nouvel état du bouton droit
delay(100); // Attendre 100ms
};
void Accelerer() {
if(vitesse_PWM<=250) {
vitesse_PWM=vitesse_PWM+5;
}
analogWrite(moteur1_PWM,vitesse_PWM); // Envoi du signal PWM sur la sortie analogique 10
digitalWrite(Moteur_sens1, HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2, LOW); // Désactivation de la broche A- du L293D
Serial.print("On accélère le moteur | PWM = ");
Serial.println(vitesse_PWM);
}
void Decelerer()
{
if(vitesse_PWM>=5)
{
vitesse_PWM=vitesse_PWM-5;
}
analogWrite(moteur1_PWM,vitesse_PWM); // Envoi du signal PWM sur la sortie analogique 10
digitalWrite(Moteur_sens1, HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2, LOW); // Désactivation de la broche A- du L293D
Serial.print("On ralentit le moteur | PWM = ");
Serial.println(vitesse_PWM);
}
Variateur de vitesse en vidéo :
Retrouvez le principe du variateur de vitesse pour moteur à courant continu en vidéo :Quid des variateurs de vitesse WEG ?
Maintenant que nous avons parlé de plusieurs aspects autour des variateurs de vitesse classiques, il va être important de s'attarder quelques instants sur un produit dans la même ligne, mais qui se distingue par sa qualité et par son intensité : le variateur de vitesse de la marque WEG. Pour ceux qui ne sauraient pas, WEG est une entreprise qui s'est spécialisée il y a plusieurs années déjà dans la motorisation et notamment dans les variateurs de vitesse. C'est pourquoi il nous semblait important de vous en parler aujourd'hui. Concrètement, un variateur de vitesse va avoir pour objectif de modifier la fréquence d'un moteur afin d'en changer la vitesse. En général, ces variateurs sont utilisés sur des moteurs à induction triphasés. Bien entendu, cela permet donc de pouvoir être intégré à un très grand nombre d'outils et de produits, que cela soit dans le secteur de l'industrie ou alors dans le secteur du chauffage ou de la ventilation.
Le véritable avantage de cette entreprise et de leur variateur réside surtout dans la polyvalence. En effet, les variateurs de vitesse peuvent, parfois, ne pas s'adapter à un circuit fermé et peuvent surtout mettre en péril tout un produit si ceux-ci ne fonctionnent pas à la même intensité. Avec la gamme de produits WEG, tous ces problèmes seront effacés puisque tout a été mis en oeuvre afin que les variateurs de vitesse soit le plus polyvalent possible. En clair, ils pourront se poser sur n'importe lequel des produits et des moteurs que vous souhaiterez modifier. C'est aussi cet aspect qui est très intéressant. Il s'agit d'un produit modulable à votre guise et qui pourra faire l'effet d'un passe-partout dans tous les domaines que nous avons précédemment cités. En clair, n'hésitez plus et au lieu d'acheter des variateurs de vitesse dans le commerce, commandez chez WEG, vous ne serez pas déçus.
Actus
- Batterie Storey Sunology - 05/12/24
- Batterie Hoymiles MS-A2 - 03/12/2024
- Sphere LED Olight - 30/11/24
- Installation Hyper 2000 Zendure - 22/11/24
- Tuto reparer pompe immergee - 29/10/24
- Augmenter la production des panneaux solaires - 08/10/24
- Reparation moteur volet roulant - 01/10/24
- Pince Kaiweets HT208D - 23/09/24
- Extension du simple allumage - 13/09/24
- Prise de courant Plexo - 04/09/24
- Faire un simple allumage en video - 25/07/24
- Interrupteur va-et-vient Plexo - 05/07/24
- Nouvelle station solaire Sunethic - 25/10/24
- Automatiser le chauffe-eau - 20/06/2024
- Comment localiser un defaut d'isolement - 29/05/24
- Comparatif station solaire et kit solaire toiture - 27/05/24
Les promos du moment
Offre Black Friday : Zendure Hyper 2000 + AB2000 à 1163€03 tapez le code M7JC4V8F
100€ de réduction avec le code sunethic_electrotoile100 sur les stations F1000 et kits toiture T1000 du 25/10/24 au 30/11/24
Les vidéos electrotoile
- Retrouvez l'ensemble des vidéos sur Humix
Réseau sociaux
