> >

Shield moteur L293D contrôler moteur à courant continu Shield L293D - Raccordement et programme Arduino pour varier la vitesse d'un moteur DC 👨‍💻


Comment faire varier la vitesse d'un moteur à courant continu avec une Arduino et un L293D

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


Arduino 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).

Matériel utilisé pour faire varier la vitesse d'un moteur à courant continu
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.
Tutoriel utilisation Shield L293D pour contrôler un moteur à courant continu

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.
Symbole électrique d'une alimentation à découpage pour alimenter en courant continu un moteur à courant continu
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.

explication signal PWM arduino et moteur 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).
Signal de sortie Arduino de type Tout ou Rien (TOR)
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.
Signal PWM égal à 255 émis par la carte Arduino et alimentant un voyant, rapport cyclique 100%

• 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.
Signal PWM égal à 230 émis par la carte Arduino et alimentant un voyant, rapport cyclique 90%

• 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.
Signal PWM égal à 128 émis par la carte Arduino et alimentant un voyant, rapport cyclique 50%

• 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.
Signal PWM égal à 25 mis par la carte Arduino et alimentant un voyant, rapport cyclique 10%

• 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.
Signal PWM égal à 0 émis par la carte Arduino et alimentant un voyant, rapport cyclique 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.


Branchement Arduino Shield motor L293D et moteur à courant continu 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.
Plan de câblage du Shield L293D motor

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.
identification des entrées EN1 et EN2 pour la variation de vitesse PWM et des shunts à enlever pour activer la modificaiton de la vitesse

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.
Cavalier arduino jumper, shunt pont de court-circuit ou pontage
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.
Enlever le cavalier EN1 du Shield L293D pour activer la variation de vitesse du moteur

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
Broches PWM disponibles sur l'arduino MEGA

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.
Plan de raccordement du Shield L293D avec l'arduino et le moteur à courant continu

Schéma électrique :
Pour vous aider à relier votre matériel (Alim-L293D-Arduino-moteur), vous pouvez également consulter le schéma électrique ci-dessous.
Schéma électrique Shield L293D au moteur et à l'Arduino

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.
Utilisation d'un potentiomètre linéaire rotatif pour faire varier une valeur analogique et pour la variation de vitesse du moteur

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 :
branchement d'un potentiomètre sur l'arduino pour faire varier la vitesse du moteur à courant continu

Schéma électrique avec le potentiomètre :
Schéma électrique Shield L293D au moteur et à l'Arduino avec un 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é).
Variation de vitesse moteur à courant continu avec arduino et joystick dual-axis
Montage réalisé avec certains éléments du Super starter kit Uno R3 projet | Elegoo


programmer l'Arduino pour faire varier la vitesse du moteur à courant continu 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
}

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 :
Graphe variation de la vitesse du moteur en fonction du temps

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.
Programme varier la vitesse moteur courant continu sous Arduino IDE
Arduino IDE
Vue du moniteur série Arduino IDE pour la variation de vitesse d'un moteur DC
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
}

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
}

En utilisant le moniteur série, vous n'aurez plus qu'à relever la valeur analogique affichée.
Programme Arduino pour réaliser la lecture d'une entrée analogique A0 et l'affichage sur le moniteur série
Programme Arduino IDE pour la lecture analogique sur l'entrée A0
Affichage sur le moniteur série de la valeur analogique A0 du potentiomètre
Affichage du moniteur série sur Arduino IDE

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.
Utilisation d'un joystick arduino pour commander la vitesse de rotation d'un moteur à courant continu
Joystick pour commander la vitesse de fonctionnement du moteur DC

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.
lecture analogique arduino sur le joystick dual-axis
Précisions sur la lecture analogique sur le joystick
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
}
}


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



Arduino Variateur de vitesse en vidéo :

Retrouvez le principe du variateur de vitesse pour moteur à courant continu en vidéo :



Si vous aimez les articles, n'hésitez pas à faire vos achats sur Amazon via ce lien, ils me permettront de recevoir une commission grâce au programme Partenaires Amazon EU.