Maîtriser le driver moteur L298N : Contrôle Arduino, Schémas & Exemples de code

Dans ce tutoriel Arduino, nous allons apprendre à contrôler des moteurs à courant continu (DC) avec Arduino. Nous verrons quelques techniques de base pour contrôler les moteurs DC et réaliserons deux exemples pour apprendre à les contrôler en utilisant le driver moteur L298N et la carte Arduino.

Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous.

Nous pouvons contrôler la vitesse du moteur DC en contrôlant simplement la tension d'entrée du moteur, et la méthode la plus courante pour ce faire est d'utiliser un signal PWM.

Contrôle moteur DC par PWM

Le PWM (Modulation de Largeur d'Impulsion) est une technique qui permet d'ajuster la valeur moyenne de la tension envoyée à un composant électronique en allumant et éteignant l'alimentation à un rythme rapide. La tension moyenne dépend du cycle de service (duty cycle), c'est-à-dire la proportion de temps où le signal est ON par rapport au temps où il est OFF sur une période donnée.

Selon la taille du moteur, on peut simplement connecter une sortie PWM de l'Arduino à la base d'un transistor ou à la gate d'un MOSFET et contrôler la vitesse du moteur en contrôlant la sortie PWM. Le signal PWM de faible puissance de l'Arduino commute la gate du MOSFET à travers lequel le moteur de forte puissance est piloté.

Contrôle moteur DC par Pont en H

D'autre part, pour contrôler le sens de rotation, il suffit d'inverser le sens du courant dans le moteur. La méthode la plus courante est d'utiliser un Pont en H (H-Bridge). Un circuit en H contient quatre éléments de commutation (transistors ou MOSFETs), avec le moteur au centre formant une configuration en H. En activant deux interrupteurs particuliers simultanément, on change le sens du courant, donc le sens de rotation du moteur.

En combinant ces deux méthodes (PWM et Pont en H), on obtient un contrôle complet du moteur DC. Il existe de nombreux drivers moteur ayant ces fonctionnalités, et le L298N en fait partie.

Driver L298N

Le L298N est un driver double Pont en H qui permet le contrôle de vitesse et de direction de deux moteurs DC simultanément. Le module peut piloter des moteurs DC de 5 à 35V, avec un courant de pointe jusqu'à 2A.

Examinons de plus près le brochage du module L298N et son fonctionnement. Le module a deux bornes à vis pour les moteurs A et B, et une autre borne pour la masse (GND), le VCC moteur et une broche 5V qui peut être soit entrée soit sortie.

Cela dépend de la tension utilisée au VCC moteur. Le module a un régulateur 5V intégré qui est activé ou désactivé par un cavalier (jumper). Si la tension d'alimentation moteur est jusqu'à 12V, on peut activer le régulateur 5V et la broche 5V devient une sortie, par exemple pour alimenter l'Arduino. Mais si la tension moteur dépasse 12V, il faut retirer le cavalier car ces tensions endommageraient le régulateur 5V intégré. Dans ce cas, la broche 5V sert d'entrée : il faut y connecter une alimentation 5V pour que le circuit intégré fonctionne correctement.

Notons que ce circuit intégré cause une chute de tension d'environ 2V. Par exemple, avec une alimentation 12V, la tension aux bornes des moteurs sera d'environ 10V, ce qui signifie qu'on ne pourra pas atteindre la vitesse maximale d'un moteur DC 12V.

Viennent ensuite les entrées de commande logiques. Les broches Enable A et Enable B servent à activer et contrôler la vitesse des moteurs. Si un cavalier est présent sur cette broche, le moteur est activé et tourne à vitesse maximale. Si on retire le cavalier, on peut connecter une entrée PWM pour contrôler la vitesse. Si on connecte cette broche à la masse, le moteur est désactivé.

Ensuite, les broches Input 1 et Input 2 contrôlent le sens de rotation du moteur A, et Input 3 et 4 celui du moteur B. Avec ces broches, on commande en fait les interrupteurs du Pont en H à l'intérieur du L298N. Si Input 1 est LOW et Input 2 HIGH, le moteur avance ; inversement, si Input 1 est HIGH et Input 2 LOW, il recule. Si les deux entrées sont identiques (LOW ou HIGH), le moteur s'arrête. Même chose pour Input 3/4 et le moteur B.

Arduino et Driver Moteur L298N

Maintenant, faisons quelques applications pratiques. Dans le premier exemple, nous contrôlerons la vitesse du moteur avec un potentiomètre et changerons le sens de rotation avec un bouton poussoir. Voici le schéma :

Il nous faut un driver L298N, un moteur DC, un potentiomètre, un bouton poussoir et une carte Arduino.

Vous pouvez vous procurer les composants nécessaires via les liens ci-dessous :

• Driver L298N
• Moteur DC 12V couple élevé
• Moteur DC avec roue en plastique
• Carte Arduino
• Plaque d'essai (breadboard) et fils de liaison

Code Arduino

Voici le code Arduino :

/* Contrôle Moteur DC Arduino - PWM | Pont en H | L298N - Exemple 01
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 6
#define in2 7
#define button 4

int rotDirection = 0;
int pressed = false;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(button, INPUT);
  // Direction initiale
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}

void loop() {
  int potValue = analogRead(A0); // Lecture potentiomètre
  int pwmOutput = map(potValue, 0, 1023, 0, 255); // Map 0-1023 vers 0-255
  analogWrite(enA, pwmOutput); // Signal PWM vers broche Enable L298N
  
  // Lecture bouton - Anti-rebond
  if (digitalRead(button) == true) {
    pressed = !pressed;
  }
  while (digitalRead(button) == true);
  delay(20);
  
  // Si bouton pressé - changer sens rotation
  if (pressed == true && rotDirection == 0) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    rotDirection = 1;
    delay(20);
  }
  // Si bouton pressé - changer sens rotation
  if (pressed == false && rotDirection == 1) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    rotDirection = 0;
    delay(20);
  }
}

Description : On définit d'abord les broches et les variables nécessaires. Dans le setup, on configure les modes de broches et la direction initiale du moteur. Dans la loop, on commence par lire la valeur du potentiomètre, puis on mappe la valeur 0-1023 vers 0-255 pour le signal PWM (cycle de service 0-100%). Avec analogWrite(), on envoie le signal PWM à la broche Enable du L298N, qui pilote le moteur.

Ensuite, on vérifie si le bouton est pressé, et si c'est le cas, on change le sens de rotation en inversant les états Input 1 et Input 2. Le bouton fonctionne comme un toggle : chaque appui change le sens de rotation.

Contrôle voiture robot Arduino avec driver L298N

Une fois cela acquis, nous pouvons construire notre propre voiture robot Arduino. Voici le schéma :

Il nous faut 2 moteurs DC, le driver L298N, une carte Arduino et un joystick pour le contrôle. Pour l'alimentation, j'ai choisi trois batteries Li-ion 3.7V en série (11V total). J'ai fait le châssis en contreplaqué 3mm, fixé les moteurs avec des équerres métalliques, mis des roues sur les moteurs et une roue pivotante à l'avant.

Examinons maintenant le code Arduino et voyons comment il fonctionne. (Le code complet est plus bas)

int xAxis = analogRead(A0); // Lecture axe X joystick
int yAxis = analogRead(A1); // Lecture axe Y joystick

Après avoir défini les broches, dans la loop on commence par lire les axes X et Y du joystick. Celui-ci est composé de deux potentiomètres connectés aux entrées analogiques de l'Arduino, avec des valeurs de 0 à 1023. Au centre, les deux axes valent environ 512.

On ajoute une petite tolérance et on considère 470-550 comme zone centrale. Si on bouge l'axe Y vers l'arrière et que la valeur descend sous 470, on met les deux moteurs en marche arrière via les 4 broches d'entrée. Puis on convertit les valeurs descendantes 470→0 en valeurs PWM croissantes 0→255 (vitesse du moteur).

// Axe Y : avant/arrière
if (yAxis < 470) { // Arrière
  digitalWrite(in1, HIGH); digitalWrite(in2, LOW);
  digitalWrite(in3, HIGH); digitalWrite(in4, LOW);
  motorSpeedA = map(yAxis, 470, 0, 0, 255);
  motorSpeedB = map(yAxis, 470, 0, 0, 255);
}

De même, si on bouge l'axe Y vers l'avant (>550), on met les moteurs en marche avant et on convertit 550→1023 en PWM 0→255. Si le joystick reste au centre, la vitesse des moteurs est nulle.

Voyons maintenant comment on utilise l'axe X pour le contrôle gauche/droite.

// Axe X : gauche/droite
if (xAxis < 470) { // Gauche
  int xMapped = map(xAxis, 470, 0, 0, 255);
  motorSpeedA = motorSpeedA - xMapped; // Diminuer vitesse moteur gauche
  motorSpeedB = motorSpeedB + xMapped; // Augmenter vitesse moteur droit
  if (motorSpeedA < 0) motorSpeedA = 0;
  if (motorSpeedB > 255) motorSpeedB = 255;
}

On convertit d'abord les lectures de l'axe X en valeurs de vitesse 0-255. Pour tourner à gauche, on utilise cette valeur pour diminuer la vitesse du moteur gauche et augmenter celle du droit. À cause des opérations arithmétiques, on utilise deux "if" supplémentaires pour limiter la plage de vitesse de 0 à 255.

La même méthode s'applique pour tourner à droite.

Lien connexe : Comment réaliser un contrôleur de vitesse PWM pour moteur DC avec le timer 555

Selon la tension appliquée et le moteur, à basse vitesse le moteur ne démarre pas et produit un ronflement. Dans mon cas, les moteurs ne démarraient pas si la valeur PWM était inférieure à 70. J'ai donc limité la plage de vitesse de 70 à 255 avec ces deux if. À la fin, on envoie les vitesses finales (signal PWM) aux broches Enable du L298N.

// Éviter ronflement basse vitesse (ajuster selon vos moteurs)
if (motorSpeedA < 70) motorSpeedA = 0;
if (motorSpeedB < 70) motorSpeedB = 0;
analogWrite(enA, motorSpeedA); // PWM vers moteur A
analogWrite(enB, motorSpeedB); // PWM vers moteur B

Code complet de l'exemple voiture robot :

/* Contrôle Moteur DC Arduino - PWM | Pont en H | L298N Exemple 02 - Contrôle Voiture Robot
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9 #define in1 4 #define in2 5
#define enB 10 #define in3 6 #define in4 7

int motorSpeedA = 0, motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT); pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT); pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT); pinMode(in4, OUTPUT);
}

void loop() {
  int xAxis = analogRead(A0);
  int yAxis = analogRead(A1);
  
  // Axe Y : avant/arrière
  if (yAxis < 470) { // Arrière
    digitalWrite(in1, HIGH); digitalWrite(in2, LOW);
    digitalWrite(in3, HIGH); digitalWrite(in4, LOW);
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  } else if (yAxis > 550) { // Avant
    digitalWrite(in1, LOW); digitalWrite(in2, HIGH);
    digitalWrite(in3, LOW); digitalWrite(in4, HIGH);
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  } else { motorSpeedA = 0; motorSpeedB = 0; }
  
  // Axe X : gauche/droite
  if (xAxis < 470) { // Gauche
    int xMapped = map(xAxis, 470, 0, 0, 255);
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (xAxis > 550) { // Droite
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }
  
  // Éviter ronflement basse vitesse
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;
  
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}

C'est tout pour ce tutoriel. Dans ma prochaine vidéo, nous améliorerons cette voiture robot Arduino en ajoutant des modules Bluetooth et Radio pour permettre le contrôle par smartphone et sans fil.

N'hésitez pas à poser vos questions dans les commentaires ci-dessous et consultez ma collection de projets Arduino.