Composants utilisés
- 1 Module de contrôle de moteurs L298N (prêt à l'emploi)
- 1 Carte Arduino UNO
- Des Câbles de branchement Dupont
- 1 ou 2 moteurs à courant continu
- 1 Moteur pas à pascomportant 4 fils, deux phases
- 1 multimètre
- 1 Alimentation de puissance 9V
Principe de fonctionnement
Le module L298N permet de commander séparément 2 moteurs à courant continu DC de 3 à 30 V, ou un moteur pas à pas bipolaire (2 phase step motor).
Il fonctionne avec une interface de commande TTL 5V (donc compatible avec Arduino ou avec de nombreux autres micro-contrôleurs en basse tension).
Il comporte deux ponts en H pour commuter les courants (2A par pont en crête, 20W maxi).
Ce module permet de faire varier la vitesse de rotation (en modulation PWM) et d'inverser le sens de rotation des moteurs.
Il peut piloter des charges inductives (bobinages, relais), les sorties de puissances sont protégées par des diodes de roue libre anti-retour.
Applications
Ce composant est idéal pour piloter un robot à deux roues motrices, en faisant varier la vitesse de rotation d'une roue par rapport à l'autre pour tourner.
Il permet de faire fonctionner divers ensembles mécanisés, des voitures téléguidées, des pompes, des treuils, etc...
Il permet également de commander simplement un moteur pas à pas à 2 phases (4 fils).
Alimentation de puissance
Utiliser une alimentation de puissance pour les moteurs : piles, batterie, transformateur, alimentation par convertisseur de tension.
Le petit convertisseur de tension de la carte Arduino n'est en effet pas prévu pour générer de la forte puissance.
Le double pont en H de la carte L298N est équipé d'un radiateur de refroidissement (75 °C).
Câblage, pour 2 moteurs DC
Le bornier à vis bleu (3 pins) :
- VMS --> Tension VMS de la partie puissance de 5 à 35 Volts (sur la source de puissance).
- GND, --> Relié à la masse de l'alimentation de puissance.
- +V --> Sortie du régulateur de la carte L298N en +5V. Permet d'alimenter des composants externes éventuels (Intensité de 0 à 36 mA), sinon non connecté.
Les 2 borniers à vis verts (2 x 2 pins)
MotorA et MotorB servent à brancher séparément 1 ou 2 moteurs à courant continu, ou les 2 bobines d'un moteur pas à pas à 2 phases et 4 fils.
- A- --> Moteur A- (inverser les 2 fils pour inverser le sens de rotation)
- A+ --> Moteur A+
- B- --> Moteur B-
- B+ --> Moteur B+
LEDs témoin
- Sens de rotation des moteurs
- Alimentation 5V
Signaux de commande sur les 6 pins (logique TTL : 5V = high, 0V = low).
- EnA --> Enable moteur A, sur niveau High TTL --> vers le micro contrôleur Arduino, sortie PWM si on veut commander la vitesse.
- In1 --> Input 1 (pont-en-H A) broches de commande digitales (1 et 2) qui sont utilisées pour commander le sens de rotation du moteur A
- In2 --> Input 2 (pont A)
- In3 --> Input 3 (pont B) idem pour moteur B
- In4 --> Input 4 (pont B)
- EnB --> Enable moteur B, sur niveau High TTL
Commandes de fonctionnement
- Faire tourner le moteur A sens normal : IN1=H, IN2=L, ENA=H
- Faire tourner le moteur A à l'envers : IN1=L, IN2=H, ENA=H
- Pour arrêter rapidement le moteur A : IN1=L, IN2=L, ENA=H (ou IN1=H, IN2=H, ENA=H)
- Pour arrêter doucement le moteur (arrêt en roue libre): ENA=L (IN1 et IN2 ignorés)
Commande simultanée de deux moteurs à courant continu
Branchement (avec 6 pins utilisées sur l'Arduino)
Note : On peut utiliser seulement les 2 pins EnA et EnB si la carte Arduino n'a pas besoin de gérer les sens de rotation des moteurs mais juste leur vitesse.
Exemple de code pour 2 moteurs DC
- Code: Tout sélectionner
//************************************************
// Exemple d'utilisation module L298
// Commande de 2 moteurs DC
// tiptopboards.com 04 11 2013
//
//**************************************************
int ENA=5;//Branché sur Arduino pin 5(output pwm)
int IN1=2;//Sur Arduino pin 2
int IN2=3;//Sur Arduino pin 3
int ENB=6;//Sur Arduino pin 6(output pwm)
int IN3=4;//Sur Arduino pin 4
int IN4=7;//Sur Arduino pin 7
void setup()
{
pinMode(ENA,OUTPUT);//Configuré en sorties
pinMode(ENB,OUTPUT);
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
digitalWrite(ENA,LOW);
digitalWrite(ENB,LOW);//stop driving
digitalWrite(IN1,LOW);
digitalWrite(IN2,HIGH);//setting motorA's direction
digitalWrite(IN3,HIGH);
digitalWrite(IN4,LOW);//setting motorB's direction
Serial.begin(9600); //Serial monitor
}
void loop()
{ //Augmenter progressivement la vitesse des 2 moteurs
for (int vitesse=0; vitesse <= 255; vitesse++){
analogWrite(ENB,vitesse);//start driving motorB
analogWrite(ENA,vitesse);//start driving motorA
Serial.println(vitesse);
delay(100);
}
//Une vitesse trop lente fait vibrer sans tourner le moteur
}
Ce code démarre les 2 moteurs DC et accélère leur vitesse de rotation.
.
Commande d'un moteur pas à pas (4 fils, 2 phases)
On commence par identifier quels sont les fils de phase avec un multimètre, en mesurant la résistance électrique des fils pris 2 à 2.
Ici on a 6 fils sur le moteur : noir, marron , rouge(2x), orange, jaune.
Mesurer la résistance en Ohm des fils pris 2 à 2
Noir Marron Rouge Orange Jaune
Noir 150 75
Marron 150
Rouge 75 74
Orange 74 147
Jaune 147
Donc bobine_A = noir-marron, et bobine_B = jaune-orange.
Câblage à réaliser
- MotA- = noir
- MotA+ = marron
- MotB- = jaune
- MotB+ = orange
Exemple de code pas à pas
- Code: Tout sélectionner
//*******************************************
// Module L298N pour commander un
// Moteur 2 phases pas à pas (4 fils)
//
// Rolland tiptopboards.com 09 10 2013
//
//============================================
//Câblage du steper, utilise 6 broches
int ENA=2; // Arduino Pin 2
int IN1=3; // Arduino Pin 3
int IN2=4; // Arduino Pin 4
int ENB=5; // Arduino Pin 5
int IN3=6; // Arduino Pin 6
int IN4=7; // Arduino Pin 7
void setup() {
pinMode(ENA,OUTPUT); //Les 6 pins configurées en sorties
pinMode(ENB,OUTPUT);
pinMode(IN1,OUTPUT);
pinMode(IN2,OUTPUT);
pinMode(IN3,OUTPUT);
pinMode(IN4,OUTPUT);
//Enable A et B, utilise les 2 ponts en H
digitalWrite(ENA,HIGH);// Activer pont A
digitalWrite(ENB,HIGH);// Activer pont B
}
void loop(){
// Un moteur Pas-à-pas se contrôle à l'aide de 4 battements
// Séquences AB A-B A-B- AB- ou séquence AB AB- A-B- A-B
int tps = 20; //Délai en ms entre deux commandes de changement de pas (vitesse du moteur)
digitalWrite(IN1,LOW); //0110 A-B
digitalWrite(IN2,HIGH);
digitalWrite(IN3,HIGH);
digitalWrite(IN4,LOW);
delay(tps);
digitalWrite(IN1,LOW); //0101 A-B-
digitalWrite(IN2,HIGH);
digitalWrite(IN3,LOW);
digitalWrite(IN4,HIGH);
delay(tps);
digitalWrite(IN1,HIGH); //1001 AB-
digitalWrite(IN2,LOW);
digitalWrite(IN3,LOW);
digitalWrite(IN4,HIGH);
delay(tps);
digitalWrite(IN1,HIGH); //1010 AB
digitalWrite(IN2,LOW);
digitalWrite(IN3,HIGH);
digitalWrite(IN4,LOW);
delay(tps);
}
Jumpers de configuration
Le jumper jaune 5V-EN est laissé en place pour activer le régulateur 78M05 de la carte qui fournit du 5V à la partie logique du L298N. Si on le retire il faut alimenter en 5V le module.
Les jumpers jaunes CSA, CSB déterminent les sens des courants des ponts A et B et peuvent être utilisés pour changer le sens de rotation de ces moteurs.
Les jumpers U1, U2, U3, U4 sont destinés aux résistances de pull up. Les laisser en place pour tirer Int1-Int4 à 5V.
Les retirer uniquement pour un contrôle complet des ponts en H (A et B) avec les entrées Int1-Int4 connectées sur un micro-contrôleur capable d'asservir correctement le potentiel de ces sorties.
Test des moteurs en 9V : il faut un rapport cyclique d'impulsions PWM suffisant pour que le moteur commence à tourner (sinon trop d'inertie au démarrage).
- ici, le moteur 12V axe 4mm tourne en PWM à partir de pwm = 90 environ
- le micro moteur tourne à PWM=40
- la pompe à eau tourne à PWM=90
Références
Ce tutoriel est basé de sur ce document (en anglais)
http://www.geekonfire.com/wiki/index.ph ... tor_Driver
