Fonctionnement du module contrôleur de moteurs L298N.

Dans cet article on vous expliquera comment contrôler deux moteurs à courant continu avec le module L298N, on réalisera un petit exemple sans utiliser de bibliothèque, suivi d’ un autre exemple, cette fois ci, avec la bibliotèque LEANTEC_ControMotor.h.

Ce contrôleur de moteurs peut être utilisé pour piloter deux moteurs CC  jusque 2 A chacun, avec une tension entre 3 et 35 V. Il est très facile à programmer et on peut l’utiliser pour nombreuses applications car il permet de contrôler la vitesse et le sens des moteurs.

Connexion et fonctionnement.

Ce module intègre une entrée de tension. La plage de tensions bascule entre les 3 V et les 35 V, selon la configuration du cavalier régulateur de tension; et supporte une intensité de 2 A. Avec le cavalier régulateur on peut contrôler des moteurs de 5 à 12 V et on pourra utiliser la broche de 5 V du module pour ajouter d’autres shields. Sans ce cavalier régulateur, on peut contrôler des moteurs de 12 à 35 V, et dans ce cas la troisième broche agira comme entrée de 5 V pour alimenter la partie logique du driver.

Les sorties des moteurs 1 et 2 nous fournirons l’énergie nécessaire pour démarrer les moteurs. Assurez-vous que la polarité des moteurs est la même sur les deux entrées. Dans le cas contraire, vous devrez peut-être les échanger lorsque vous réglerez les deux moteurs vers l’avant et vers l’arrière!

Les pins IN 1 e IN 2 nous servent à contrôler le sens de rotation du moteur 1, et les pins IN 3 et IN 4, celui du moteur 2. Ces pins fonctionnent:

• IN 1 -> HIGH; IN 2 -> LOW: le moteur tourne dans un sens.
• IN 1 -> LOW; IN 2 -> HIGH: le moteur tourne dans le sens inverse.

Et c’est pareil pour les pins IN 3 et IN 4 du moteur 2.

Pour contrôler la vitesse de rotation des moteurs on doit retirer les cavaliers des pins ENA et ENB. On les connecte à deux sorties PWM de la plaque Arduino de façon qu’on puisse envoyer une valeur entre 0 et 255 pour gérer cette vitesse des moteurs. Avec les cavaliers installés, les moteurs tourneront toujours à la même vitesse.

Le schéma de montage que nous allons utiliser est le suivant, (sachez que vous pouvez relier le module aux pins que vous voulez, mais prenez en compte que les pins ENA et ENB doivent êtres reliés à des broches PWM d’Arduino).

Programmation du module sans bibliothèque.

Nous sommes, donc, prêts pour commencer à programmer. Nous allons faire un essai pour faire tourner les moteurs dans les deux sens, en avant et en arrière; puis, chacun dans un sens en variant aussi, la vitesse de rotation.

On commence par nommé les pins que nous allons utiliser, les reconnaissant comme sorties:

// Moteur 1
int ENA = 10;
int IN1 = 9;
int IN2 = 8;

// Motor 2
int ENB = 5;
int IN3 = 7;
int IN4 = 6;

void setup (){
 // on déclare les pins comme sorties
 pinMode (ENA, OUTPUT);
 pinMode (ENB, OUTPUT);
 pinMode (IN1, OUTPUT);
 pinMode (IN2, OUTPUT);
 pinMode (IN3, OUTPUT);
 pinMode (IN4, OUTPUT);
}
void Avancer (){
 //sens moteur A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 100); //Vitesse moteur A
 //sens moteur B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 100); //Vitesse moteur B
}
void Reculer (){
 //sens moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 128); //Vitesse moteur A
 //sens moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 128); //Vitesse moteur B
}
void Droite (){
 //sens moteur A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 200); //Vitesse moteur A
 //sens moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 100); //Vitesse moteur B
}
void Gauche (){
 //Sens moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 50); //Vitesse moteur A
 //sens moteur B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 150); //Vitesse motor B
}
void Arreter (){
 //Sens moteur A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 0); //Vitesse moteur A
 //Sens moteur B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 0); //Vitesse moteur B
}
void loop (){
 Avancer ();
 delay (5000);
 Reculer ();
 delay (2000);
 Droite ();
 delay (2000);
 Gauche ();
 delay (2000);
 Arreter ();
 delay (4000);
}

Vous pouvez observer que nous avons créé 4 fonctions pour gérer les différentes possibilités de mouvement (avancer, reculer, droite et gauche) et une cinquième fonction pour programmer l’arrêt (arrêter).

Programmation du module avec la bibliothèque LEANTEC_ControlMotor.h

Cette bibliothèque aide à contrôler la vitesse et le sens des moteurs.

On configure les pins avec l’instruction:

ControlMotor control (MoteurD1, MoteurD2, MoteurG1, MoteurG2, PWM_Droite, PWM_Gauche)

• MoteurD1: Enable 1 du moteur droit (pin 7)
• MoteurD2: Enable 2 du moteur droit (pin 6)
• MoteurG1: Enable 1 du moteur gauche (pin 9)
• MoteurG2: Enable 2 du moteur gauche (pin 8)
• PWM_droite: PWM du moteur droit (pin 5)
• PWM_gauche: PWM du moteur gauche (pin 10)

Pour gérer le moteur on utilise la fonction:

control.Motor(vitesse,rotation);

La première variable est la vitesse qui bascule entre 0 et 255, et la deuxième est le pourcentage de rotation, entre 0 et 100. Si la vitesse est positive le robot avance, si, par contre, elle est négative le robot recule. Pour tourner a droite la rotation doit être supérieur à 0, et pour tourner à gauche, inférieur à 0. Si la rotation est de 100, le robot tournera sur son axe (une roue avance et l’autre recule).

• Rotation à droite: >0
• Rotation à gauche: <0
• Rotation sur l’axe: 100

#include <LEANTEC_ControlMotor.h>//on insère la bibliothèque
// on configure les pins que nous allons utiliser
ControlMotor control(7,6,9,8,5,10); // MoteurD1,MoteurD2,MoteurG1,MoteurG2,PWM_Droite,PWM_Gauche

void setup(){ 
  //pas besoin de configurer les pins, comme dans le code précédent, puisque la bibliothèque s'en charge.
} 
 
void loop() {
  // avancer
  control.Motor(150,1);
  delay (3000);
  // reculer
  control.Motor(-150,1);
  delay(3000);
  // gauche
  control.Motor(150,100);
  delay(3000);
  // droite
  control.Motor(200,-100);
  delay(3000);
  // arrêter
  control.Motor(0,1);
  delay(3000);
}

« Précédent

Capteur à ultrasons HC-SR04 et Arduino.

Suivant »

Mesurer l’inclinaison avec le capteur SW-520D et Arduino.

Articles similaires

Module Bluetooth HC-06 compatible avec Arduino.

Capteur d’inclinaison SW-520D pour Arduino.

Créer des sons avec Arduino. Buzzer.