Dans ce tutoriel, je vais vous fournir toutes les informations nécessaires pour contrôler la vitesse et la direction d’un moteur DC avec un circuit intégré pilote de moteur L293D en utilisant une carte Arduino UNO.
J’ai inclus un schéma de câblage ainsi que les détails du code Arduino pour contrôler le moteur DC en envoyant des caractères depuis le Moniteur Série de l’IDE Arduino, avec plusieurs exemples.
Fournitures
Composants matériels
| Arduino Uno Rev3 | × 1 | Amazon |
| Câble USB type A/B | × 1 | Amazon |
| Moteur DC avec réducteur | × 1 | Amazon |
| Circuit intégré pilote L293D | × 1 | Amazon |
| Plaque d’essai (breadboard) | × 1 | Amazon |
| Fils de connexion (jumper wires) | × 15 | Amazon |
| Alimentation (5V) | × 1 | Amazon |
Logiciel
| Arduino IDE | Arduino_IDE |
Makerguides.com participe au programme d’affiliation Amazon Services LLC Associates, un programme publicitaire conçu pour permettre aux sites de percevoir des commissions en faisant la promotion et en créant des liens vers des produits sur Amazon.com.
À propos du circuit intégré pilote de moteur L293D
Le L293D est un circuit intégré pilote de moteur quadruple demi-pont en H à courant élevé, adapté au contrôle de moteurs DC. Il peut fournir un courant de pilotage bidirectionnel jusqu’à 1 A à des tensions de 4,5 V à 36 V. Vous trouverez ci-dessous la fiche technique du composant.
Brochage du circuit intégré L293D
Le L293D est un circuit intégré pilote de moteur à 16 broches, permettant de contrôler deux moteurs DC ou un moteur pas à pas sous un courant de 600 mA.
Broches d’alimentation
La broche 8 (VCC_2) et la broche 16 (VCC_1) servent à alimenter le circuit intégré pilote L293D.
VCC_2 alimente le pont en H interne du circuit intégré, et peut être comprise entre 4,5 V et 36 V. VCC_1 est utilisée pour la logique interne et doit être à 5 V. Les broches 4, 5, 12 et 13 (GND) sont la masse du dispositif et les broches de dissipateur thermique.
Broches de contrôle de direction
Les broches 2 (Input_1), 7 (Input_2), 10 (Input_3) et 15 (Input_4) contrôlent les interrupteurs du circuit en pont en H à l’intérieur du L293D.
Input_1 et Input_2 sont connectées aux deux bornes du moteur DC_1 pour contrôler sa direction. De même, Input_3 et Input_4 contrôlent la direction du moteur_2.
J’utiliserai un Arduino UNO pour générer les signaux de direction sur toutes les broches Input, et selon leur niveau (haut ou bas), le moteur tournera en avant ou en arrière.
Vous pouvez consulter les détails dans le tableau ci-dessous pour le contrôle de la direction du moteur.
| Input_1 / Input_3 | Input_2 / Input_4 | Direction du moteur |
| Bas | Bas | Frein, moteur arrêté |
| Bas | Haut | Arrière (sens antihoraire) |
| Haut | Bas | Avant (sens horaire) |
| Haut | Haut | Frein, moteur arrêté |
Broches de contrôle de vitesse
Les moteurs DC peuvent tourner à une vitesse spécifiée selon la valeur définie par l’Arduino UNO sur la broche 1 (Enable_A) pour le moteur_1 et la broche 9 (Enable_B) pour le moteur_2.
Un signal actif haut sur la broche enable active le canal du pilote du L293D, permettant au moteur de tourner à pleine vitesse.
Un signal actif bas sur la broche enable désactive le canal du pilote du L293D, arrêtant le moteur. Pour contrôler la vitesse du moteur DC, vous devez envoyer des signaux PWM sur la broche enable du L293D. La vitesse du moteur varie selon le cycle de service des signaux PWM.
Les détails sont expliqués dans la section code.
Broches de sortie moteur
Le circuit intégré pilote L293D fournit un courant de sortie jusqu’à 600 mA au moteur DC via la broche 3 (Output_1), la broche 6 (Output_2) pour le moteur_1, et la broche 11 (Output_3), la broche 14 (Output_4) pour le moteur_2.
Spécifications du moteur DC
Tension
Une variété de moteurs DC est disponible sur le marché, avec des tensions nominales de 3 V à 100 V ; cependant, pour les applications robotiques, les moteurs DC de 6 V, 12 V ou 24 V sont largement utilisés. Dans ce tutoriel, nous considérerons des moteurs DC avec réducteur de 3 V à 6 V.
Courant
Vous devez choisir un moteur DC avec un courant maximal de 600 mA, car au-delà, le circuit pilote L293D chauffera et pourrait brûler.
Couple
Le couple moteur est un facteur important lorsqu’il y a une charge sur le moteur. Si votre application nécessite une charge plus importante, vous devez choisir un moteur avec un couple plus élevé. Une autre façon d’augmenter le couple est d’utiliser un réducteur avec le moteur.
Dans ce tutoriel, j’utilise un moteur DC avec un réducteur ayant un rapport de démultiplication de 1:48.
Câblage du circuit intégré pilote L293D avec Arduino UNO
Dans cette section, vous apprendrez à interfacer les moteurs DC avec le circuit pilote L293D et la carte Arduino UNO.
Étape 1 : Connexions des moteurs au circuit L293D
Commencez par connecter les fils des moteurs aux broches de sortie du circuit L293D.
Connectez les fils du moteur_1 aux broches 3 (Output_1) et 6 (Output_2), et les fils du moteur_2 aux broches 11 (Output_3) et 14 (Output_4).
Étape 2 : Connexions Arduino UNO au circuit L293D
Connectez maintenant la broche numérique 10 et 9 de l’Arduino aux broches 2 (Input_1) et 7 (Input_2) du L293D pour le moteur_1.
De même, connectez les broches numériques 4 et 3 de l’Arduino aux broches 10 (Input_3) et 15 (Input_4) du L293D pour le moteur_2.
Ensuite, vous devez fournir des signaux PWM sur les broches Enable pour contrôler la vitesse des moteurs DC.
Connectez la broche PWM 11 de l’Arduino UNO à la broche 1 (Enable_A) du L293D pour le moteur_1, et la broche PWM 5 de l’Arduino UNO à la broche 9 (Enable_B).
Étape 3 : Connexions d’alimentation au circuit L293D
Vous pouvez maintenant fournir une alimentation 5 V au L293D en connectant la broche 8 (VCC_2) et la broche 16 (VCC_1) au 5 V (borne positive de l’alimentation).
Connectez toutes les masses du circuit intégré à la masse commune sur la breadboard.
Toutes les connexions sont illustrées sur l’image.
Code Arduino – Contrôle d’un moteur DC via le terminal série
Si vous souhaitez tester votre moteur DC, vous devez pouvoir le contrôler.
Le code suivant vous permet de contrôler la vitesse et la direction des deux moteurs DC individuellement et simultanément en envoyant des caractères depuis le Moniteur Série de l’IDE Arduino.
Vous pouvez copier le code en cliquant sur le bouton en haut à droite du champ de code et le téléverser sur votre carte Arduino UNO.
Ensuite, je vais expliquer le fonctionnement du code.
// Motor_1 Connection
#define ENABLE_1 11
#define MOTOR_1_A 10
#define MOTOR_1_B 9
// Motor_2 Connection
#define ENABLE_2 5
#define MOTOR_2_A 4
#define MOTOR_2_B 3
// other variables
char serial_data;
int speed_value_m1;
int speed_value_m2;
void setup() {
Serial.begin(9600);
Serial.println("Motor Init..");
motor_1_init();
motor_2_init();
speed_value_m1 = 0;
speed_value_m2 = 0;
}
void loop() {
motor_speed_dir_control();
}
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
void motor_speed_dir_control() {
while (Serial.available()) {
serial_data = Serial.read();
switch (serial_data) {
case 's':
analogWrite(ENABLE_1, 255);
Serial.println("Enable Motor_1");
break;
case 'S':
analogWrite(ENABLE_2, 255);
Serial.println("Enable Motor_2");
break;
case 'h':
analogWrite(ENABLE_1, 0);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
speed_value_m1 = 0;
Serial.println("Stop Motor_1");
break;
case 'H':
analogWrite(ENABLE_2, 0);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
speed_value_m2 = 0;
Serial.println("Stop Motor_2");
break;
case 'f':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Serial.println("Motor_1 Forward Direction");
break;
case 'F':
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
Serial.println("Motor_2 Forward Direction");
break;
case 'b':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
Serial.println("Motor_1 Backward Direction");
break;
case 'B':
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
Serial.println("Motor_2 Backward Direction");
break;
case 'a':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_1, i);
}
Serial.println("Motor_1 acceleration");
break;
case 'A':
for (int i = 0; i < 256; i++) {
analogWrite(ENABLE_2, i);
}
Serial.println("Motor_2 acceleration");
break;
case 'd':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_1, i);
delay(5);
}
Serial.println("Motor_1 deceleration");
break;
case 'D':
for (int i = 255; i > 1; i--) {
analogWrite(ENABLE_2, i);
delay(5);
}
Serial.println("Motor_2 deceleration");
break;
case 'i':
if (speed_value_m1 <= 245) {
speed_value_m1 += 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 increased Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'I':
if (speed_value_m2 <= 245) {
speed_value_m2 += 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 increased Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Maximum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'r':
if (speed_value_m1 >= 10) {
speed_value_m1 -= 10;
analogWrite(ENABLE_1, speed_value_m1);
Serial.println("Motor_1 reduced Speed value: ");
Serial.print(speed_value_m1);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_1: ");
Serial.print(speed_value_m1);
}
break;
case 'R':
if (speed_value_m2 >= 10) {
speed_value_m2 -= 10;
analogWrite(ENABLE_2, speed_value_m2);
Serial.println("Motor_2 reduced Speed value: ");
Serial.print(speed_value_m2);
} else {
Serial.println("Minimum Speed Limit Reached for Motor_2: ");
Serial.print(speed_value_m2);
}
break;
case 'X':
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, HIGH);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Forward Direction");
break;
case 'Y':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, HIGH);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, HIGH);
analogWrite(ENABLE_1, 255);
analogWrite(ENABLE_2, 255);
Serial.println("Motor_1 and Motor_2 Backward Direction");
break;
case 'Z':
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_1, 0);
analogWrite(ENABLE_2, 0);
Serial.println("Motor_1 and Motor_2 Stop");
break;
default:
break;
}
}
}
Fonctionnement du code
D’abord, j’ai défini les variables pour les broches Arduino UNO selon les connexions, ainsi que d’autres variables pour stocker les données série et la valeur de vitesse.
//Motor_1 Connection #define ENABLE_1 11 #define MOTOR_1_A 10 #define MOTOR_1_B 9 //Motor_2 Connection #define ENABLE_2 5 #define MOTOR_2_A 4 #define MOTOR_2_B 3 //other variables char serial_data; int speed_value_m1; int speed_value_m2;
Comme je vais tester les moteurs DC avec des commandes depuis le Moniteur Série, je dois initialiser la connexion série de la carte Arduino UNO. J’ai fixé le débit en bauds à 9600.
Serial.begin(9600);
Ensuite, j’ai configuré les broches Arduino UNO en sortie pour fournir les signaux au circuit pilote L293D, et initialement, toutes les broches sont mises à l’état bas.
void motor_1_init() {
pinMode(MOTOR_1_A, OUTPUT);
pinMode(MOTOR_1_B, OUTPUT);
pinMode(ENABLE_1, OUTPUT);
digitalWrite(MOTOR_1_A, LOW);
digitalWrite(MOTOR_1_B, LOW);
analogWrite(ENABLE_1, LOW);
}
void motor_2_init() {
pinMode(MOTOR_2_A, OUTPUT);
pinMode(MOTOR_2_B, OUTPUT);
pinMode(ENABLE_2, OUTPUT);
digitalWrite(MOTOR_2_A, LOW);
digitalWrite(MOTOR_2_B, LOW);
analogWrite(ENABLE_2, LOW);
}
Enfin, dans void loop(), qui est une boucle infinie, j’appelle la fonction motor_speed_dir_control() pour effectuer différentes opérations sur les moteurs DC selon le caractère reçu du Moniteur Série.
J’ai utilisé la fonction Serial.read() pour lire la broche Rx de l’Arduino UNO, et ce caractère reçu est stocké dans serial_data.
Différents cas sont maintenant écrits pour contrôler les moteurs DC dans des instructions switch.
Vous pouvez utiliser les commandes série mentionnées ci-dessous pour le contrôle de la vitesse et de la direction des moteurs DC :
| Moteur_1 | Moteur_2 | Sortie |
| s | S | Activer le moteur DC |
| h | H | Arrêter le moteur DC |
| f | F | Définir la direction avant pour le moteur DC |
| b | B | Définir la direction arrière pour le moteur DC |
| a | A | Accélérer le moteur DC de zéro à la vitesse maximale |
| d | D | Décélérer le moteur DC de la vitesse maximale à zéro |
| i | I | Augmenter la vitesse du moteur DC de 10 |
| r | R | Réduire la vitesse du moteur DC de 10 |
| X | Faire tourner les deux moteurs DC en direction avant |
| Y | Faire tourner les deux moteurs DC en direction arrière |
| Z | Arrêter les deux moteurs DC |
Comment contrôler la position d’un moteur DC avec Arduino ?
Pour contrôler la position dans une direction particulière, vous devez d’abord définir la direction du moteur DC, puis appliquer le signal PWM sur les broches enable.
Prenons l’exemple de faire avancer le moteur_1 à pleine vitesse. Vous devez d’abord définir la direction avant dans le code Arduino.
digitalWrite(MOTOR_1_A, HIGH);
digitalWrite(MOTOR_1_B, LOW);
Ensuite, mettez la broche enable à l’état haut pour faire avancer le moteur_1.
analogWrite(ENABLE_1, 255);
De même, vous pouvez définir une direction différente pour chaque moteur et changer leur position comme je l’ai fait dans les différents cas.
Comment contrôler la vitesse d’un moteur DC avec Arduino ?
Pour contrôler la vitesse du moteur DC, vous devez fournir une modulation de largeur d’impulsion (PWM) sur la broche enable.
| Enable_A / Enable_B | Vitesse du moteur |
| Bas | Zéro (arrêt) |
| Haut | Vitesse maximale |
| PWM | Contrôle de la vitesse selon la valeur du signal PWM |
analogWrite(pin, value) est utilisé pour définir le PWM sur les broches Enable du L293D. Avec Arduino UNO, vous pouvez régler la vitesse de zéro (0) à maximum (255). Reportez-vous aux cas ‘a’, ‘A’, ‘d’, ‘D’, ‘i’, ‘I’, ‘r’ et ‘R’ dans le code.
Test des moteurs DC
Une fois le code téléversé sur la carte Arduino UNO, dans l’IDE Arduino, allez dans “Tools” et cliquez sur “Serial Monitor” ou utilisez le raccourci “Ctrl+Shift+M”.
Assurez-vous d’abord d’avoir sélectionné le bon débit en bauds, c’est-à-dire 9600. Maintenant, dans le Moniteur Série, vous pouvez tester votre code avec les moteurs DC que vous avez connectés à l’IDE Arduino en envoyant des commandes depuis le Moniteur Série.
Exemple 1 : Faire tourner le moteur_1 en avant, puis décélérer, accélérer, augmenter, réduire la vitesse, inverser la direction et enfin arrêter le moteur.
Envoyez les caractères suivants un par un en minuscules depuis le Moniteur Série :
f, s, d, a, i, i, i, i, i, i, i, i, i, i, i, i, r, r, r, r, r, r, r, r, r, r, r, r, b, s, h
De même, vous pouvez contrôler le moteur_2 en envoyant les caractères ci-dessus en majuscules. Notez que vous pouvez faire fonctionner les deux moteurs en envoyant les caractères selon vos besoins.
Exemple 2 : Faire tourner simultanément le moteur_1 et le moteur_2 en avant, puis en arrière, et arrêter les deux moteurs.
Envoyez les caractères suivants :
X, Y, Z
Conclusion
Après ce tutoriel, vous pourrez appliquer la logique utilisée pour contrôler la vitesse et la direction des moteurs DC afin de réaliser des projets électroniques innovants et créatifs avec des moteurs DC et une carte Arduino.
Si vous avez des questions, des suggestions, ou si vous pensez que certains points manquent dans ce tutoriel, n’hésitez pas à laisser un commentaire ci-dessous.
