ESP32 avec moteur à courant continu – Contrôle de la vitesse et de la direction

Ce didacticiel montre comment contrôler la direction et la vitesse d’un moteur à courant continu à l’aide d’un ESP32 et du pilote de moteur L298N. Tout d’abord, nous examinerons rapidement le fonctionnement du pilote de moteur L298N. Ensuite, nous vous montrerons un exemple de la façon de contrôler la vitesse et la direction d’un moteur à courant continu avec le pilote de moteur L298N à l’aide de l’ESP32 programmé avec l’IDE Arduino.

Mis à jour le 11 juin 2024

Remarque : il existe de nombreuses façons de contrôler un moteur à courant continu. Nous utiliserons le pilote de moteur L298N. Ce didacticiel est également compatible avec des modules de commande de moteur similaires.

Table des matières

Ce didacticiel couvre les sujets suivants :

Utilisez-vous un ESP8266 ? Suivez plutôt ce tutoriel : ESP8266 NodeMCU avec moteur à courant continu et pilote de moteur L298N – Contrôle de la vitesse et de la direction (Arduino IDE)

Conditions préalables

Avant de continuer, assurez-vous de vérifier les prérequis suivants :

ESP32 avec l’IDE Arduino

Nous allons programmer l’ESP32 à l’aide de l’IDE Arduino. Assurez-vous donc que le module complémentaire ESP32 est installé. Suivez le tutoriel suivant si ce n’est pas déjà fait :

Alternativement, vous souhaiterez peut-être également programmer l’ESP32 à l’aide de VS Code et de l’extension platformIO :

Pièces requises

Pour réaliser ce didacticiel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Présentation du pilote de moteur L298N

Il existe plusieurs façons de contrôler un moteur à courant continu. La méthode que nous utiliserons ici convient à la plupart des moteurs amateurs, qui nécessitent 6 V ou 12 V pour fonctionner.

Nous allons utiliser le pilote de moteur L298N qui peut gérer jusqu’à 3 A à 35 V. De plus, cela nous permet de piloter deux moteurs à courant continu simultanément, ce qui est parfait pour construire un robot.

Le pilote de moteur L298N est illustré dans la figure suivante :

Brochage du pilote de moteur L298N

Jetons un coup d’œil au brochage du pilote de moteur L298N et voyons comment il fonctionne.

Le pilote de moteur dispose d’un bornier à deux bornes de chaque côté pour chaque moteur. OUT1 et OUT2 à gauche et OUT3 et OUT4 à droite.

• OUT1 : moteur à courant continu A + borne
• OUT2 : Moteur à courant continu A – borne
• OUT3 : moteur à courant continu B + borne
• OUT4 : Moteur à courant continu B – borne

En bas, vous avez un bornier à trois bornes avec +12V, GND et +5V. Le bornier +12V sert à alimenter les moteurs. La borne +5V est utilisée pour alimenter la puce L298N. Cependant, si le cavalier est en place, la puce est alimentée par l’alimentation du moteur et vous n’avez pas besoin de fournir du 5 V via la borne +5 V.

Important : malgré le nom de la borne +12 V, vous pouvez fournir n’importe quelle tension comprise entre 5 V et 35 V (mais 6 V à 12 V est la plage recommandée).

Remarque : si vous fournissez plus de 12 V, vous devez retirer le cavalier et fournir 5 V à la borne +5 V.

Dans ce didacticiel, nous utiliserons 4 piles AA 1,5 V qui combinent une puissance d’environ 6 V, mais vous pouvez utiliser toute autre alimentation appropriée. Par exemple, vous pouvez utiliser une alimentation de banc pour tester ce tutoriel.

En résumé:

• +12V : La borne +12V est l’endroit où vous devez connecter l’alimentation du moteur
• GND: alimentation GND
• +5V : fournit 5V si le cavalier est retiré. Agit comme une sortie 5 V si le cavalier est en place
• Cavalier : cavalier en place – utilise l’alimentation du moteur pour alimenter la puce. Jumper retiré : vous devez fournir du 5V à la borne +5V. Si vous fournissez plus de 12 V, vous devez retirer le cavalier

En bas à droite, vous avez quatre broches d’entrée et deux bornes d’activation. Les broches d’entrée sont utilisées pour contrôler la direction de vos moteurs à courant continu et les broches d’activation sont utilisées pour contrôler la vitesse de chaque moteur.

• IN1 : Entrée 1 pour le moteur A
• IN2 : Entrée 2 pour le moteur A
• IN3 : Entrée 1 pour le moteur B
• IN4 : Entrée 2 pour le moteur B
• EN1 : Activer la broche pour le moteur A
• EN2 : Activer la broche pour le moteur B

Il y a des capuchons de cavalier sur les broches d’activation par défaut. Vous devez retirer ces capuchons de cavalier pour contrôler la vitesse de vos moteurs. Sinon, ils seront arrêtés ou tourneront à la vitesse maximale.

Contrôlez les moteurs à courant continu avec le pilote de moteur L298N

Maintenant que vous connaissez le pilote de moteur L298N, voyons comment l’utiliser pour contrôler vos moteurs à courant continu.

Activer les épingles

Les broches d’activation sont comme un interrupteur ON et OFF pour vos moteurs. Par exemple:

• Si vous envoyez un signal HIGH à la broche d’activation 1, le moteur A est prêt à être contrôlé et à la vitesse maximale ;
• Si vous envoyez un signal BAS à la broche d’activation 1, le moteur A s’éteint ;
• Si vous envoyez un signal PWM, vous pouvez contrôler la vitesse du moteur. La vitesse du moteur est proportionnelle au rapport cyclique. Cependant, notez que pour les petits cycles de service, les moteurs peuvent ne pas tourner et émettre un bourdonnement continu.

Broches d’entrée

Les broches d’entrée contrôlent la direction dans laquelle les moteurs tournent. Entrée 1 et entrée 2 du moteur de commande A et entrées 3 et 4 du moteur de commande B.

• Si vous appliquez LOW à l’entrée 1 et HIGH à l’entrée 2, le moteur tournera vers l’avant ;
• Si vous appliquez l’alimentation dans l’autre sens : HIGH à l’entrée 1 et LOW à l’entrée 2, le moteur tournera vers l’arrière. Le moteur B peut être contrôlé en utilisant la même méthode mais en appliquant HIGH ou LOW à l’entrée 3 et à l’entrée 4.

Par exemple, pour le moteur A, voici la logique :

Contrôler 2 moteurs à courant continu – idéal pour construire un robot

Si vous souhaitez construire une voiture robot en utilisant 2 moteurs à courant continu, ceux-ci doivent tourner dans des directions spécifiques pour faire avancer le robot, à gauche, à droite, en avant ou en arrière.

Par exemple, si vous souhaitez que votre robot avance, les deux moteurs doivent tourner vers l’avant. Pour le faire reculer, les deux doivent tourner vers l’arrière.

Pour faire tourner le robot dans une direction, vous devez faire tourner le moteur opposé plus rapidement. Par exemple, pour faire tourner le robot à droite, activez le moteur de gauche et désactivez celui de droite. Le tableau suivant montre les combinaisons d’état des broches d’entrée pour les directions du robot.

Lecture recommandée : Construire un kit de châssis de voiture robot pour ESP32, ESP8266, Arduino, etc…

Contrôle du moteur à courant continu avec ESP32 – Vitesse et direction

Maintenant que vous savez comment contrôler un moteur à courant continu avec le pilote de moteur L298N, créons un exemple simple pour contrôler la vitesse et la direction d’un moteur à courant continu.

Câblage d’un moteur à courant continu à l’ESP32 (pilote de moteur L298N)

Le moteur que nous allons contrôler est connecté aux broches de sortie du moteur A, nous devons donc câbler les broches ENABLEA, INPUT1 et INPUT2 du pilote de moteur à l’ESP32. Suivez le diagramme schématique suivant pour câbler le moteur à courant continu et le pilote de moteur L298N à l’ESP32.

Nous utilisons les GPIO du tableau précédent pour nous connecter au pilote du moteur. Vous pouvez utiliser n’importe quel autre GPIO approprié à condition de modifier le code en conséquence. En savoir plus sur les GPIO ESP32 : Guide de référence du brochage ESP32.

Alimentation du pilote de moteur LN298N

Le moteur à courant continu nécessite une forte augmentation du courant pour se déplacer, les moteurs doivent donc être alimentés à l’aide d’une source d’alimentation externe provenant de l’ESP32. A titre d’exemple, nous utilisons 4 piles AA, mais vous pouvez utiliser n’importe quelle autre alimentation appropriée. Dans cette configuration, vous pouvez utiliser une alimentation de 6V à 12V.

L’interrupteur entre le support de batterie et le pilote du moteur est facultatif, mais il est très pratique pour couper et appliquer l’alimentation. De cette façon, vous n’avez pas besoin de connecter puis de déconnecter constamment les fils pour économiser de l’énergie.

Nous recommandons de souder un condensateur céramique de 0,1 uF aux bornes positives et négatives du moteur à courant continu, comme indiqué dans le schéma, pour aider à atténuer les pics de tension. (Remarque : les moteurs fonctionnent également sans condensateur.)

Code : ESP32 avec un moteur à courant continu – Contrôle de la vitesse et de la direction

Le code suivant contrôle la vitesse et la direction du moteur à courant continu. Ce code n’a peut-être pas d’application pratique dans le monde réel, mais constitue un excellent exemple pour comprendre comment contrôler la vitesse et la direction d’un moteur à courant continu avec l’ESP32.

/*********
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-dc-motor-l298n-motor-driver-control-speed-direction/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.  
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/
// Motor A
int motor1Pin1 = 27; 
int motor1Pin2 = 26; 
int enable1Pin = 14; 

// Setting PWM properties
const int freq = 30000;
const int pwmChannel = 0;
const int resolution = 8;
int dutyCycle = 200;

void setup() {
  // sets the pins as outputs:
  pinMode(motor1Pin1, OUTPUT);
  pinMode(motor1Pin2, OUTPUT);
  pinMode(enable1Pin, OUTPUT);
  
  // configure LEDC PWM
  ledcAttachChannel(enable1Pin, freq, resolution, pwmChannel);

  Serial.begin(115200);

  // testing
  Serial.print("Testing DC Motor...");
}

void loop() {
  // Move the DC motor forward at maximum speed
  Serial.println("Moving Forward");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, HIGH); 
  delay(2000);

  // Stop the DC motor
  Serial.println("Motor stopped");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, LOW);
  delay(1000);

  // Move DC motor backwards at maximum speed
  Serial.println("Moving Backwards");
  digitalWrite(motor1Pin1, HIGH);
  digitalWrite(motor1Pin2, LOW); 
  delay(2000);

  // Stop the DC motor
  Serial.println("Motor stopped");
  digitalWrite(motor1Pin1, LOW);
  digitalWrite(motor1Pin2, LOW);
  delay(1000);

  // Move DC motor forward with increasing speed
  digitalWrite(motor1Pin1, HIGH);
  digitalWrite(motor1Pin2, LOW);
  while (dutyCycle <= 255){
    ledcWrite(enable1Pin, dutyCycle);   
    Serial.print("Forward with duty cycle: ");
    Serial.println(dutyCycle);
    dutyCycle = dutyCycle + 5;
    delay(500);
  }
  dutyCycle = 200;
}

Afficher le code brut

Téléchargez le code sur votre ESP32. Assurez-vous d’avoir sélectionné la bonne carte et le bon port COM. Jetons un coup d’œil au fonctionnement du code.

Déclaration des broches du moteur

Tout d’abord, vous définissez les GPIO auxquels les broches du moteur sont connectées. Dans ce cas, l’entrée 1 du moteur A est connectée au GPIO 27, l’entrée 2 au GPIO 26 et la broche Enable au GPIO 14.

int motor1Pin1 = 27; 
int motor1Pin2 = 26; 
int enable1Pin = 14;

Définition des propriétés PWM pour contrôler la vitesse

Comme nous l’avons vu précédemment, vous pouvez contrôler la vitesse du moteur à courant continu en appliquant un signal PWM à la broche d’activation du pilote de moteur L298N. La vitesse sera proportionnelle au rapport cyclique. Pour utiliser PWM avec l’ESP32, vous devez d’abord définir les propriétés du signal PWM.

const int freq = 30000;
const int pwmChannel = 0;
const int resolution = 8;
int dutyCycle = 200;

Dans ce cas, nous générons un signal de 30 000 Hz sur le canal 0 avec une résolution de 8 bits. Nous commençons avec un rapport cyclique de 200 (vous pouvez définir une valeur de rapport cyclique de 0 à 255).

Pour la fréquence que nous utilisons, lorsque vous appliquez des cycles de service inférieurs à 200, le moteur ne bouge pas et émet un bourdonnement étrange. C’est pourquoi nous avons fixé un cycle de service de 200 au départ.

Remarque : les propriétés PWM que nous définissons ici ne sont qu’un exemple. Le moteur fonctionne bien avec d’autres fréquences.

installation()

Dans setup(), vous commencez par définir les broches du moteur comme sorties.

pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(enable1Pin, OUTPUT);

Vous devez configurer une broche LEDC avec les propriétés PWM que vous avez définies précédemment en utilisant la fonction ledcAttachChannel() qui accepte comme arguments la broche que vous souhaitez contrôler, la fréquence, la résolution et le pwmChannel comme suit :

// configure LEDC PWM
ledcAttachChannel(enable1Pin, freq, resolution, pwmChannel);

Faire avancer le moteur à courant continu

Dans la boucle(), c’est là que le moteur se déplace. Le code est bien commenté sur ce que fait chaque partie du code. Pour faire avancer le moteur, vous réglez la broche d’entrée 1 sur LOW et l’entrée 2 pint sur HIGH. Dans cet exemple, le moteur avance pendant 2 secondes (2 000 millisecondes).

// Move the DC motor forward at maximum speed
Serial.println("Moving Forward");
digitalWrite(motor1Pin1, LOW);
digitalWrite(motor1Pin2, HIGH); 
delay(2000);

Faire reculer le moteur à courant continu

Pour déplacer le moteur à courant continu vers l’arrière, vous appliquez l’alimentation aux broches d’entrée du moteur dans l’autre sens. HIGH à l’entrée 1 et LOW à l’entrée 2.

// Move DC motor backwards at maximum speed
Serial.println("Moving Backwards");
digitalWrite(motor1Pin1, HIGH);
digitalWrite(motor1Pin2, LOW); 
delay(2000);

Arrêtez le moteur à courant continu

Pour arrêter le moteur à courant continu, vous pouvez soit régler la broche d’activation sur FAIBLE, soit régler les broches d’entrée 1 et d’entrée 2 sur FAIBLE. Dans cet exemple, nous définissons les deux broches d’entrée sur LOW.

// Stop the DC motor
Serial.println("Motor stopped");
digitalWrite(motor1Pin1, LOW);
digitalWrite(motor1Pin2, LOW);
delay(1000);

Contrôler la vitesse du moteur à courant continu

Pour contrôler la vitesse du moteur à courant continu, nous devons modifier le cycle de service du signal PWM. Pour cela, vous utilisez la fonction ledcWrite() qui accepte comme arguments le GPIO qui génère le signal et le rapport cyclique, comme suit.

ledcWrite(enable1Pin, dutyCycle);

Dans notre exemple, nous avons une boucle while qui augmente le rapport cyclique de 5 à chaque boucle.

// Move DC motor forward with increasing speed
digitalWrite(motor1Pin1, HIGH);
digitalWrite(motor1Pin2, LOW);
while (dutyCycle <= 255){
  ledcWrite(enable1Pin, dutyCycle);
  Serial.print("Forward with duty cycle: ");
  Serial.println(dutyCycle);
  dutyCycle = dutyCycle + 5;
  delay(500);
}

Lorsque la condition while n’est plus vraie, nous remettons le rapport cyclique à 200.

dutyCycle = 200;

Regardez la démonstration vidéo

Regardez la vidéo suivante pour voir le projet en action :

Conclusion

Dans ce didacticiel, nous vous avons montré comment contrôler la direction et la vitesse d’un moteur à courant continu à l’aide d’un ESP32 et du pilote de moteur L298N. En résumé:

• Pour contrôler la direction dans laquelle tourne le moteur à courant continu, vous utilisez les broches d’entrée 1 et d’entrée 2 ;
• Appliquez LOW à l’entrée 1 et HIGH à l’entrée 2 pour faire tourner le moteur vers l’avant. Appliquez de la puissance dans l’autre sens pour le faire tourner vers l’arrière ;
• Pour contrôler la vitesse du moteur à courant continu, vous envoyez un signal PWM à la broche d’activation. La vitesse du moteur à courant continu est proportionnelle au rapport cyclique.

Nous espérons que vous avez trouvé ce tutoriel utile.

Ceci est un extrait de notre cours : Apprenez l’ESP32 avec l’IDE Arduino. Si vous aimez l’ESP32 et souhaitez en savoir plus, nous vous recommandons de vous inscrire au cours Apprendre l’ESP32 avec l’IDE Arduino.

Apprenez-en plus sur l’ESP32 avec nos ressources :

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :