Pilote de moteur L298N - Interface Arduino, fonctionnement, codes, schémas

Dans ce didacticiel Arduino, nous apprendrons à contrôler les moteurs à courant continu à l'aide d'Arduino. Nous examinons bien quelques techniques de base pour contrôler les moteurs à courant continu et faisons deux exemples à travers lesquels nous apprendrons à contrôler les moteurs à courant continu à l'aide du pilote de moteur L298N et de la carte Arduino.

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

Nous pouvons contrôler la vitesse du moteur à courant continu en contrôlant simplement la tension d'entrée du moteur et la méthode la plus courante consiste à utiliser le signal PWM.

Contrôle de moteur CC PWM

PWM, ou modulation de largeur d'impulsion est une technique qui nous permet d'ajuster la valeur moyenne de la tension qui va à l'appareil électronique en allumant et en éteignant l'alimentation à un rythme rapide. La tension moyenne dépend du rapport cyclique ou de la durée pendant laquelle le signal est activé par rapport à la durée pendant laquelle le signal est désactivé sur une seule période de temps.

Ainsi, selon la taille du moteur, nous pouvons simplement connecter une sortie Arduino PWM à la base du transistor ou à la grille d'un MOSFET et contrôler la vitesse du moteur en contrôlant la sortie PWM. Le signal Arduino PWM à faible puissance allume et éteint la porte du MOSFET à travers lequel le moteur haute puissance est entraîné.

Contrôle du moteur CC du pont en H

D'un autre côté, pour contrôler le sens de rotation, il suffit d'inverser le sens du flux de courant dans le moteur, et la méthode la plus courante consiste à utiliser un pont en H. Un circuit H-Bridge contient quatre éléments de commutation, transistors ou MOSFET, avec le moteur au centre formant une configuration de type H. En activant deux interrupteurs particuliers en même temps, nous pouvons changer le sens du flux de courant, donc changer le sens de rotation du moteur.

Donc, si nous combinons ces deux méthodes, le PWM et le H-Bridge, nous pouvons avoir un contrôle complet sur le moteur à courant continu. Il existe de nombreux pilotes de moteur à courant continu dotés de ces fonctionnalités et le L298N en fait partie.

Pilote L298N

Le L298N est un pilote de moteur à double pont en H qui permet le contrôle de la vitesse et de la direction de deux moteurs à courant continu en même temps. Le module peut piloter des moteurs à courant continu ayant des tensions comprises entre 5 et 35 V, avec un courant de crête pouvant atteindre 2 A.

Examinons de plus près le brochage du module L298N et expliquons son fonctionnement. Le module possède deux borniers à vis pour le moteur A et B, et un autre bornier à vis pour la broche de terre, le VCC pour le moteur et une broche 5V qui peut être une entrée ou une sortie.

Cela dépend de la tension utilisée aux moteurs VCC. Le module dispose d'un régulateur 5V intégré qui est activé ou désactivé à l'aide d'un cavalier. Si la tension d'alimentation du moteur est jusqu'à 12V, nous pouvons activer le régulateur 5V et la broche 5V peut être utilisée comme sortie, par exemple pour alimenter notre carte Arduino. Mais si la tension du moteur est supérieure à 12V, nous devons déconnecter le cavalier car ces tensions endommageront le régulateur 5V embarqué. Dans ce cas, la broche 5V sera utilisée comme entrée car nous devons la connecter à une alimentation 5V pour que le CI fonctionne correctement.

On peut noter ici que ce CI fait une chute de tension d'environ 2V. Ainsi, par exemple, si nous utilisons une alimentation 12V, la tension aux bornes des moteurs sera d'environ 10V, ce qui signifie que nous ne pourrons pas obtenir la vitesse maximale de notre moteur 12V DC.

Viennent ensuite les entrées de commande logique. Les broches Enable A et Enable B sont utilisées pour activer et contrôler la vitesse du moteur. Si un cavalier est présent sur cette broche, le moteur sera activé et fonctionnera à la vitesse maximale, et si nous retirons le cavalier, nous pouvons connecter une entrée PWM à cette broche et ainsi contrôler la vitesse du moteur. Si nous connectons cette broche à une masse, le moteur sera désactivé.

Ensuite, les broches d'entrée 1 et d'entrée 2 sont utilisées pour contrôler le sens de rotation du moteur A, et les entrées 3 et 4 pour le moteur B. En utilisant ces broches, nous contrôlons en fait les commutateurs du pont en H à l'intérieur du L298N IC. Si l'entrée 1 est BASSE et l'entrée 2 est HAUTE, le moteur avancera, et vice versa, si l'entrée 1 est HAUTE et l'entrée 2 est BASSE, le moteur reculera. Si les deux entrées sont identiques, BAS ou HAUT, le moteur s'arrêtera. Il en va de même pour les entrées 3 et 4 et le moteur B.

Pilote de moteur Arduino et L298N

Faisons maintenant quelques applications pratiques. Dans le premier exemple nous allons contrôler la vitesse du moteur à l'aide d'un potentiomètre et changer le sens de rotation à l'aide d'un bouton poussoir. Voici les schémas du circuit.

Nous avons donc besoin d'un pilote de moteur L298N, d'un moteur à courant continu, d'un potentiomètre, d'un bouton poussoir et d'une carte Arduino.

Vous pouvez obtenir les composants nécessaires pour ce didacticiel Arduino à partir des liens ci-dessous :

Pilote L298N ………………………………..
Moteur CC à couple élevé 12 V …………..
Moteur à courant continu avec roue à pneu en plastique …….
Carte Arduino ………………………………
Breadboard et Jump Wires …………

Code Arduino

Voici le code Arduino :

/*  Arduino DC Motor Control - PWM | H-Bridge | L298N  -  Example 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);
  // Set initial rotation direction
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}

void loop() {
  int potValue = analogRead(A0); // Read potentiometer value
  int pwmOutput = map(potValue, 0, 1023, 0 , 255); // Map the potentiometer value from 0 to 255
  analogWrite(enA, pwmOutput); // Send PWM signal to L298N Enable pin

  // Read button - Debounce
  if (digitalRead(button) == true) {
    pressed = !pressed;
  }
  while (digitalRead(button) == true);
  delay(20);

  // If button is pressed - change rotation direction
  if (pressed == true  & rotDirection == 0) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    rotDirection = 1;
    delay(20);
  }
  // If button is pressed - change rotation direction
  if (pressed == false & rotDirection == 1) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    rotDirection = 0;
    delay(20);
  }
}
Code language: Arduino (arduino)

Description : Nous devons donc d'abord définir les broches et certaines variables nécessaires au programme. Dans la section de configuration, nous devons définir les modes de broche et le sens de rotation initial du moteur. Dans la section de boucle, nous commençons par lire la valeur du potentiomètre, puis mappons la valeur que nous en obtenons, qui va de 0 à 1023, à une valeur de 0 à 255 pour le signal PWM, ou c'est un rapport cyclique de 0 à 100% du Signal PWM. Ensuite, en utilisant la fonction analogWrite(), nous envoyons le signal PWM à la broche Enable de la carte L298N, qui pilote réellement le moteur.

Ensuite, nous vérifions si nous avons appuyé sur le bouton, et si c'est vrai, nous changerons le sens de rotation du moteur en réglant les états de l'entrée 1 et de l'entrée 2 en sens inverse. Le bouton-poussoir fonctionnera comme un bouton à bascule et chaque fois que nous l'appuierons, il changera le sens de rotation du moteur.

Contrôle de voiture robot Arduino utilisant le pilote de moteur L298N

Donc, une fois que nous avons appris cela, nous pouvons maintenant construire notre propre voiture robot Arduino. Voici le schéma du circuit :

Tout ce dont nous avons besoin est de 2 moteurs à courant continu, du pilote de moteur L298N, d'une carte Arduino et d'un joystick pour le contrôle. En ce qui concerne l'alimentation, j'ai choisi d'utiliser trois batteries Li-ion de 3,7 V, fournissant un total de 11 V. J'ai fabriqué le châssis en contreplaqué de 3 mm, j'y ai fixé les moteurs à l'aide de supports métalliques, j'ai fixé des roues aux moteurs et j'ai fixé une roue pivotante à l'avant.

Examinons maintenant le code Arduino et voyons comment cela fonctionne. (En bas, vous trouverez le code complet)

int xAxis = analogRead(A0); // Read Joysticks X-axis
int yAxis = analogRead(A1); // Read Joysticks Y-axisCode language: Arduino (arduino)

Après avoir défini les broches, dans la section boucle, nous commençons par lire les valeurs des axes X et Y du joystick. Le joystick est en fait composé de deux potentiomètres qui sont connectés aux entrées analogiques de l'Arduino et ils ont des valeurs de 0 à 1023. Lorsque le joystick reste dans sa position centrale, la valeur des deux potentiomètres, ou axes, est d'environ 512.

Nous allons ajouter un peu de tolérance et considérer les valeurs de 470 à 550 comme centre. Donc, si nous déplaçons l'axe Y du joystick vers l'arrière et que la valeur descend en dessous de 470, nous réglerons le sens de rotation des deux moteurs sur arrière à l'aide des quatre broches d'entrée. Ensuite, nous convertirons les valeurs décroissantes de 470 à 0 en valeurs PWM croissantes de 0 à 255, ce qui correspond en fait à la vitesse du moteur.

// Y-axis used for forward and backward control
  if (yAxis < 470) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  }Code language: Arduino (arduino)

De même, si nous déplaçons l'axe Y du joystick vers l'avant et que la valeur dépasse 550, nous réglerons les moteurs pour qu'ils avancent et convertirons les lectures de 550 à 1023 en valeurs PWM de 0 à 255. Si le joystick reste en son centre, le la vitesse des moteurs sera nulle.

Ensuite, voyons comment nous utilisons l'axe X pour le contrôle gauche et droit de la voiture.

// X-axis used for left and right control
  if (xAxis < 470) {
    // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }Code language: Arduino (arduino)

Encore une fois, nous devons d'abord convertir les lectures de l'axe X en valeurs de vitesse de 0 à 255. Pour se déplacer vers la gauche, nous utilisons cette valeur pour diminuer la vitesse du moteur gauche et augmenter la vitesse du moteur droit. Ici, en raison des fonctions arithmétiques, nous utilisons deux instructions "if" supplémentaires pour limiter la plage de vitesse du moteur de 0 à 255.

La même méthode est utilisée pour déplacer la voiture vers la droite.

En relation : Comment créer un contrôleur de vitesse de moteur à courant continu PWM à l'aide du circuit intégré de minuterie 555

Selon la tension appliquée et le moteur lui-même, à des vitesses inférieures, le moteur ne peut pas démarrer et produit un bourdonnement. Dans mon cas, les moteurs n'étaient pas capables de bouger si la valeur du signal PWM était inférieure à 70. Par conséquent, en utilisant ces deux instructions if, je me suis en fait limité à la plage de vitesse de 70 à 255. À la fin, nous envoyons simplement les vitesses finales du moteur ou Signal PWM aux broches d'activation du pilote L298N.

// Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor BCode language: Arduino (arduino)

Voici le code complet de l'exemple de voiture robot Arduino :

/*  Arduino DC Motor Control - PWM | H-Bridge | L298N
         Example 02 - Arduino Robot Car Control
    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;
int 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); // Read Joysticks X-axis
  int yAxis = analogRead(A1); // Read Joysticks Y-axis

  // Y-axis used for forward and backward control
  if (yAxis < 470) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining Y-axis readings for going backward from 470 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  }
  else if (yAxis > 550) {
    // Set Motor A forward
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Convert the increasing Y-axis readings for going forward from 550 to 1023 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  }
  // If joystick stays in middle the motors are not moving
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }

  // X-axis used for left and right control
  if (xAxis < 470) {
    // Convert the declining X-axis readings from 470 to 0 into increasing 0 to 255 value
    int xMapped = map(xAxis, 470, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }
  if (xAxis > 550) {
    // Convert the increasing X-axis readings from 550 to 1023 into 0 to 255 value
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    // Move right - decrease right motor speed, increase left motor speed
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA > 255) {
      motorSpeedA = 255;
    }
    if (motorSpeedB < 0) {
      motorSpeedB = 0;
    }
  }
  // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
}Code language: Arduino (arduino)

Ce serait donc tout pour ce tutoriel, et dans ma prochaine vidéo, nous mettrons à niveau cette voiture robot Arduino, en ajoutant un Bluetooth et des appareils radio pour activer le smartphone et le contrôle sans fil.

N'hésitez pas à poser des questions dans la section des commentaires ci-dessous et n'oubliez pas de consulter ma collection de projets Arduino.

Contrôle sans fil de voiture robot Arduino utilisant les modules émetteurs-récepteurs Bluetooth HC-05, NRF24L01 et HC-12 Module de communication sans fil longue portée Arduino et HC-12