> >

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


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.
• 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 est 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 est 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 910% d. La valeur correspondante est PWM = 127.
Signal PWM égal à 128 émis par la carte Arduino est 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 est 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 est alimentant un voyant, rapport cyclique 0%

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


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 PWM=0; // Variable PWM image de la vitesse
int moteur1_PWM = 10; // Pin 10 Arduino PWM vers EN1 du L293D

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 ); // Attente de 1 seconde
Acceleration(); // Lance la fonction Acceleration()
}
void loop() {
}
// L'accélération dure environ 2,5 secondes 256x10ms=2560ms≈2,5s
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();
}
// La décélération dure environ 2,5 secondes 256x10ms=2560ms≈2,5s
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 L293
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 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);
}

Commande du moteur dans les deux sens par deux boutons poussoirs

Ce scénario nécessite deux boutons poussoirs qui seront relisés aux entrées digitales 11 et 12.
• Lorsque le premier bouton poussoir est appuyé, on fait tourner le moteur dans le sens normal, quand il est relâché on arrête le moteur.
• Lorsque le second bouton poussoir est appuyé, on fait tourner le moteur dans le sens inverse, quand il est relâché on arrête le moteur.
La vitesse du moteur est réglée selon la consigne PWM = 128 soit une diminution de 50%.

Programme correspondant :
int commande_gauche=11; // Bouton Gauche
int commande_droite=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
boolean etat_bp_g,etat_bp_d; // Déclaration des variables droite et gauche
boolean mem_g,mem_d; // Déclaration des mémoires gauche et droite
void setup()
{
pinMode(commande_gauche, INPUT_PULLUP); // On définit la broche 11 en entrée digitale
pinMode(commande_droite, 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_g=!digitalRead(commande_gauche); // Inverse de la lecture sur entrée BP gauche
etat_bp_d=!digitalRead(commande_droite); // Inverse de la lecture sur entrée BP droit
if(etat_bp_g!=mem_g)// Changement d'état du bouton poussoir gauche (front montant ou descendant)
{
if(etat_bp_g && !etat_bp_d) // Appui sur BP Gauche mais pas sur le droit
{
Rotation_Sens_1(); // Lancer la fonction sens normal
}else{
Arret(); // Lancer la fonction arrêt du moteur
}
}
mem_g=etat_bp_g; // Mémorisation du nouvel état du bouton gauche
if(etat_bp_d!=mem_d) // Changement d'état du bouton poussoir droit (front montant ou descendant)
{
if(etat_bp_d && !etat_bp_g) // Appui sur BP Droit mais pas sur le gauche
{
Rotation_Sens_2(); // Lancer la fonction sens inverse
}else{
Arret(); // Lancer la fonction arrêt du moteur
}
}
mem_d=etat_bp_d; // Mémorisation du nouvel état du bouton droit
delay(100); // Attendre 100ms
};
void Rotation_Sens_1() {
digitalWrite(Moteur_sens1, HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens2, LOW); // Désactivation de la broche A- du L293D
Serial.println("Moteur marche avant");
}
void Arret()
{
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.println("Moteur arrêt");
}
void Rotation_Sens_2()
{
digitalWrite(Moteur_sens2, HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens1, LOW); // Désactivation de la broche A- du L293D
Serial.println("Moteur marche arrière");
}


Commande du moteur dans les deux sens par deux boutons poussoirs

Ce scénario nécessite deux boutons poussoirs qui seront relisés aux entrées digitales 11 et 12. • Lorsque le premier bouton poussoir est appuyé, on fait tourner le moteur dans le sens normal, quand il est relâché on arrête le moteur.
• Lorsque le second bouton poussoir est appuyé, on fait tourner le moteur dans le sens inverse, quand il est relâché on arrête le moteur.
La vitesse du moteur est réglée selon la consigne PWM = 128 soit une diminution de 50%.

Programme correspondant :
int commande_gauche=11; // Bouton Gauche
int commande_droite=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
boolean etat_bp_g,etat_bp_d; // Déclaration des variables droite et gauche
boolean mem_g,mem_d; // Déclaration des mémoires gauche et droite
void setup()
{
pinMode(commande_gauche, INPUT_PULLUP); // On définit la broche 11 en entrée digitale
pinMode(commande_droite, 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_g=!digitalRead(commande_gauche); // Inverse de la lecture sur entrée BP gauche
etat_bp_d=!digitalRead(commande_droite); // Inverse de la lecture sur entrée BP droit
if(etat_bp_g!=mem_g)// Changement d'état du bouton poussoir gauche (front montant ou descendant)
{
if(etat_bp_g && !etat_bp_d)// Appui sur BP Gauche mais pas sur le droit
{
Rotation_Sens_1();// Lancer la fonction sens normal
}else{
Arret(); // Lancer la fonction arrêt du moteur
}
}
mem_g=etat_bp_g; // Mémorisation du nouvel état du bouton gauche
if(etat_bp_d!=mem_d)// Changement d'état du bouton poussoir droit (front montant ou descendant)
{
if(etat_bp_d && !etat_bp_g)// Appui sur BP Droit mais pas sur le gauche
{
Rotation_Sens_2(); // Lancer la fonction sens inverse
}else{
Arret(); // Lancer la fonction arrêt du moteur
}
}
mem_d=etat_bp_d;// Mémorisation du nouvel état du bouton droit
delay(100); // Attendre 100ms
};
void Rotation_Sens_1() {
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,128); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur marche avant");
}
void Arret()
{
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.println("Moteur arrêt");
}
void Rotation_Sens_2()
{
digitalWrite(Moteur_sens2, HIGH); // Activation de la broche A+ du L293D
digitalWrite(Moteur_sens1, LOW); // Désactivation de la broche A- du L293D
analogWrite(moteur1_PWM,128); // Envoi du signal PWM sur la sortie analogique 10
Serial.println("Moteur marche arrière");
}

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.