Double pont en H L298n et le moteur pas a pas

[likiki]

Par ce sujet, je vous propose d'aborder la commande d'un moteur "pas à pas" avec un module L298n qui n'est rien d'autre qu'un double pont en H.


La carte l298n :

carte L298N-300x300.png

(131.29 Kio) Téléchargé 580 fois

.

Description des bornes :

Description_L298N.png

(223.21 Kio) Téléchargé 580 fois

.

Le schema interne du composant L298n :

schema pont en H.png

(130.78 Kio) Téléchargé 576 fois

.

Principe de fonctionnement :

marche av ar.png

(125.97 Kio) Téléchargé 576 fois

.

[likiki]

Suite :

Ce circuit, très populaire et bon marché (moins de 3€), offre un bon moyen de piloter jusqu’à deux moteurs à courant continu, ou bien un moteur pas à pas, voire même un moteur brushless.

Il peut délivrer jusqu’à 2A en pointe et 20W en continu.

Il possède son propre circuit d’alimentation logique (pouvant permettre d’alimenter une carte UNO Arduino).

Les ports ENA et ENB permettent de gérer l’amplitude de la tension délivrée au moteur, grâce à un signal PWM.

Les ports In1, In2 pour le moteur A et In3, In4 pour le moteur B, permettent de contrôler le pont en H et par conséquent le sens de rotation des moteurs.

Le câblage :

cablage 2 moteurs.jpg (67.14 Kio) Vu 3535 fois

.

Le module L298N est alimenté par une source de tension externe.
Chaque demi-pont nécessite 3 broches de sortie d’un microcontrôleur.

GND masse du circuit intégré relié à la masse du microcontrôleur et à la masse de l’alimentation

ENA enable du moteur M1 reliée à la broche 10
Input1 direction avant du moteur M1 reliée à la broche 9
Input2 direction arrière du moteur M1 reliée à la broche 8

ENB enable du moteur M2 reliée à la broche 5
Input3 direction avant du moteur M2 reliée à la broche 7
Input4 direction arrière du moteur M2 reliée à la broche 6

Prochaine étape, la programmation.

[herwat]

Cool, ce sujet !

Bonne idée , Christian .

[likiki]

Hervé.

Maintenant, c'est là que les choses se Corse (Oui, il parait qu'ils ont un fromage explosif là bas ).

Le programme (récupéré sur le net car j'ai pas envie de tout écrire ), sur lequel j'ai ajouter quelques définitions permet de contrôler 2 moteurs DC

Code : Tout sélectionner

//Constants
#define nbL298N 2
//Parameters


const int enaL298NPin[2] = {10, 5}; // Borne d'activation de l'alimentation du moteur ENA & ENB
const int fwdL298NPin[2] = {8, 9};  // Enroulement moteur A
const int bwdL298NPin[2] = {6, 7};  // Enroulement moteur B


//Variables

int Power = 200; 


void setup() 
{

 //Init Serial USB
 
 Serial.begin(9600);  // initialisation du port USB a 9600 bauds par seconde
 Serial.println(F("Initialize System")); // Affichage sur l'écran du PC de ce qui est entre les " " 
 
 //Init DCmotor
 
 for (int i = 0; i < nbL298N; i++) 
   {
   pinMode(fwdL298NPin[i], OUTPUT); // initialisation en SORTIE des bornes 8 & 9
   pinMode(bwdL298NPin[i], OUTPUT); // initialisation en SORTIE des bornes 6 & 7
   pinMode(enaL298NPin[i], OUTPUT); // initialisation en SORTIE des bornes 5 & 10
   }
}


void loop() 

{
 testL298N();
}

void testL298N() { /* function testL298N */


 ////Scenario to test H-Bridge
 
 for (int i = 0; i < nbL298N; i++) 
 {
   digitalWrite(enaL298NPin[i], HIGH);  // mise a 1 (soit 5V) les bornes ENA & ENB
   analogWrite(bwdL298NPin[i], 0); // Le moteur B ne fonctionne pas
   
   for (int j = 0; j <= Power; j = j + 10) 
   {
     analogWrite(fwdL298NPin[i], j);  // Le moteur A tourne dans un sens
     delay(20);
   }
   
   for (int j = Power; j >= 0; j = j - 10) 
   {
     analogWrite(fwdL298NPin[i], j); // le moteur A tourne dans l'autre sens
     delay(20);
   }
   
   delay(2000);
 }
}

Autre exemple de code bien plus détaillé, et a mon sens, beaucoup plus simple a comprendre pour un néophyte.
Ce petit programme est prévu pour un petit robot où chaque moteur fait tourner une roue.

Il peut donc avancer ou reculer (les deux moteurs fonctionne en même temps et dans le même sens), tourner dans un sens ou dans l'autre (dans ce cas les moteurs fonctionnent en même temps mais ne tournent pas dans le même sens).

Petit robot de ce genre là :

robot.jpg (188.63 Kio) Vu 3517 fois

.

Code : Tout sélectionner

// 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 (){ // fonction 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 (){ // fonction 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 (){ // fonction pour tourner a 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 (){ // fonction pout tourner a 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 (){ // fonction s'arrêter
 //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 (){ // boucle principal du programme où on fait appel aux fonctions ci-dessus pour les exécuter.
 
 Avancer (); // ont avance 
 delay (5000); // pendant 5 secondes
 
 Reculer (); // ont recule
 delay (2000); // pendant 2 secondes 
 
 Droite (); // ont vas a droite
 delay (2000); pendant 2 secondes
 
 Gauche (); // ont vas a gauche
 delay (2000); pendant 2 secondes
  
 Arreter (); // ont s'arrête
 delay (4000); pendant 4 secondes
 
 // Retour au début de la boucle principal du programme (le programme tourne donc en boucle indéfiniment).
 }
 
 
 

[likiki]

La petite vidéo qui suit explique l'utilisation des borne ENA & ENB pour faire varier la vitesse de rotation du moteur.


.