MicroPython : moteur à courant continu ESP32/ESP8266 (pilote L298N

Dans ce guide, vous apprendrez à contrôler un moteur à courant continu avec les cartes NodeMCU ESP32 et ESP8266 programmées avec MicroPython. Vous apprendrez à le faire avancer, reculer, arrêter et contrôler sa vitesse en créant votre propre module MicroPython. Nous utiliserons le pilote de moteur L298N, mais d’autres pilotes de moteur similaires devraient également être compatibles.

Nous avons un didacticiel similaire utilisant l’IDE Arduino : ESP32 avec moteur à courant continu et pilote de moteur L298N – Contrôle de la vitesse et de la direction.

Table des matières

Ce didacticiel couvre les sujets suivants :

Conditions préalables

Avant de poursuivre ce tutoriel, assurez-vous de vérifier les prérequis suivants

Micrologiciel MicroPython

Pour suivre ce tutoriel, vous devez installer le firmware MicroPython sur vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre tableau. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

• ThonnyIDE :
• L’EDI uPyCraft :

Si vous aimez programmer en utilisant VS Code, il existe également une option : MicroPython : Programmer ESP32/ESP8266 en utilisant VS Code et Pymakr

En savoir plus sur MicroPython : Programmation MicroPython avec ESP32 et ESP8266

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.

Contrôlez le moteur à courant continu avec ESP32 ou ESP8266 – 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.

Câblage d’un moteur à courant continu au NodeMCU ESP8266 (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’ESP8266. Suivez le diagramme schématique suivant pour câbler le moteur à courant continu et le pilote de moteur L298N à l’ESP8266.

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 ESP8266 : Référence de brochage ESP8266 : Quelles broches GPIO devez-vous utiliser ?

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.)

Création d’un module MicroPython pour contrôler un moteur à courant continu

Écrire le code pour contrôler le moteur à courant continu n’est pas difficile, mais cela nécessite des commandes répétitives. Ce serait bien d’avoir un module (bibliothèque) qui nous permettrait de contrôler la vitesse et la direction du moteur avec une seule commande.

Dans cet esprit, nous allons créer un module Python simple avec les commandes de base pour initialiser un moteur et contrôler sa vitesse et sa direction.

Création du module moteur à courant continu

Avant d’écrire le code de ce module, il est important de noter ses fonctionnalités :

• La bibliothèque s’appellera dcmotor.py et aura une seule classe appelée DCMotor avec plusieurs méthodes.
• Nous devrions pouvoir initialiser le moteur en utilisant la broche d’entrée 1, la broche d’entrée 2 et la broche d’activation comme suit :

motor1 = DCMotor(Pin1, Pin2, enable)

Les broches 1 et 2 doivent être initialisées en tant que broches de sortie et l’activation doit être initialisée en tant que broche PWM.

• Pour faire avancer le moteur, nous souhaitons utiliser une méthode appelée forward() sur l’objet DCMotor qui accepte la vitesse comme paramètre. Par exemple:

motor1.forward(speed)

La vitesse doit être un nombre entier compris entre 0 et 100, où 0 correspond au moteur arrêté et 100 à la vitesse maximale.

• De même, pour faire reculer le moteur :

motor1.backwards(speed)

• Il est également pratique d’avoir une commande pour arrêter le moteur, comme suit :

motor1.stop() 

Importation du module dcmotor.py

Créez un nouveau fichier appelé dcmotor.py et copiez le code suivant dans ce fichier.

# Created by https://Raspberryme.com/micropython-esp32-esp8266-dc-motor-l298n/
#This file includes a class to control DC motors

class DCMotor:
  #the min_duty and max_duty are defined for 15000Hz frequency
  #you can pass as arguments
  def __init__(self, pin1, pin2, enable_pin, min_duty=750, max_duty=1023):
    self.pin1 = pin1
    self.pin2= pin2
    self.enable_pin = enable_pin
    self.min_duty = min_duty
    self.max_duty = max_duty
  
  #speed value can be between 0 and 100
  def forward(self, speed):
    self.speed = speed
    self.enable_pin.duty(self.duty_cycle(self.speed))
    self.pin1.value(1)
    self.pin2.value(0)

  def backwards(self, speed):
    self.speed = speed
    self.enable_pin.duty(self.duty_cycle(self.speed))
    self.pin1.value(0)
    self.pin2.value(1)

  def stop(self):
    self.enable_pin.duty(0)
    self.pin1.value(0)
    self.pin2.value(0)
        
  def duty_cycle(self, speed):
    if self.speed <= 0 or self.speed > 100:
      duty_cycle = 0
    else:
      duty_cycle = int (self.min_duty + (self.max_duty - self.min_duty)*((self.speed - 1)/(100-1)))
    return duty_cycle

Afficher le code brut

Téléchargez ce fichier sur votre carte ESP32 ou ESP8266 avec le nom suivant : dcmotor.py.

Si vous utilisez Thonny IDE, vous pouvez suivre les étapes suivantes :

1) Copiez le code fourni dans un nouveau fichier sur Thonny IDE.

2) Téléchargez le code sur votre tableau. Si vous utilisez Thonny IDE, accédez à Fichier > Enregistrer sous… puis sélectionnez le périphérique MicroPython.

3) Enregistrez votre fichier sous dcmotor.py. Il devrait y avoir un fichier appelé boot.py. Ce fichier est créé par défaut lorsque vous gravez le micrologiciel MicroPython.

4) Enfin, cliquez sur OK pour continuer. Le module dcmotor.py devrait avoir été téléchargé avec succès sur votre carte.

Comment fonctionne le module moteur à courant continu

Le module dcmotor contient une seule classe appelée DCMotor.

class DCMotor:

Nous utilisons la méthode constructeur (__init__) pour initier les données dès qu’un objet de la classe DCMotor est instancié.

def __init__(self, pin1, pin2, enable_pin, min_duty=750, max_duty=1023):
  self.pin1 = pin1
  self.pin2= pin2
  self.enable_pin = enable_pin
  self.min_duty = min_duty
  self.max_duty = max_duty

Un objet DCMotor accepte comme paramètres :

• pin1 : GPIO (sortie) qui se connecte à l’entrée 1 du L298N.
• pin2 : GPIO (sortie) qui se connecte à l’entrée 2 broches du L298N.
• Enable_pin : GPIO (broche PWM) qui se connecte au L298N pour activer 1 broche.
• min_duty : cycle de service minimum pour faire bouger le moteur. Ce paramètre est facultatif et est défini sur 750 par défaut. Vous devrez peut-être modifier ce paramètre en fonction de la fréquence requise pour contrôler votre moteur à courant continu.
• max_duty : cycle de service maximum pour faire bouger le moteur. Ce paramètre est défini par défaut sur 1023.

Ensuite, créez plusieurs méthodes pour contrôler le moteur à courant continu : forward(), forwards() et stop().

Les méthodes forward() et forwards() font tourner le moteur respectivement vers l’avant et vers l’arrière. La méthode stop() arrête le moteur.

Les méthodes forward() et forwards() acceptent la vitesse comme paramètre. La vitesse doit être un nombre entier compris entre 0 et 100.

Examinons de plus près la méthode forward() :

def forward(self, speed):
  self.speed = speed
  self.enable_pin.duty(self.duty_cycle(self.speed))
  self.pin1.value(1)
  self.pin2.value(0)

Pour faire avancer le moteur, réglez la broche 1 sur 1 et la broche 2 sur 0. Le cycle de service de la broche d’activation est réglé sur la vitesse correspondante. La vitesse est un nombre entier compris entre 0 et 100, mais le rapport cyclique doit être un nombre compris entre max_duty et min_duty. Nous avons donc une autre méthode à la fin du code, appelée duty_cycle() qui calcule la valeur du rapport cyclique correspondante en fonction de la vitesse.

def duty_cycle(self, speed):
  if self.speed <= 0 or self.speed > 100:
    duty_cycle = 0
  else:
    duty_cycle = int (self.min_duty + (self.max_duty - self.min_duty)*((self.speed - 1)/(100-1)))
  return duty_cycle

La méthode forwards() fonctionne de la même manière, mais pin1 est défini sur 0 et pin2 est défini sur 1.

def backwards(self, speed):
  self.speed = speed
  self.enable_pin.duty(self.duty_cycle(self.speed))
  self.pin1.value(0)
  self.pin2.value(1)

Contrôler le moteur à courant continu

Maintenant que nous comprenons comment fonctionne le module dcmotor.py et que nous l’avons déjà importé sur votre carte ESP32 ou ESP8266, nous pouvons créer un nouveau script pour contrôler le moteur DC en utilisant les fonctionnalités de la bibliothèque.

Le code suivant montre comment utiliser les fonctionnalités de la bibliothèque pour contrôler le moteur à courant continu. Le code est compatible avec les cartes ESP32 et ESP8266.

# Complete project details at https://Raspberryme.com/micropython-esp32-esp8266-dc-motor-l298n/

from dcmotor import DCMotor
from machine import Pin, PWM
from time import sleep

frequency = 15000

pin1 = Pin(12, Pin.OUT)
pin2 = Pin(14, Pin.OUT)
enable = PWM(Pin(13), frequency)

dc_motor = DCMotor(pin1, pin2, enable)
#Set min duty cycle (350) and max duty cycle (1023)
#dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)

dc_motor.forward(50)
sleep(2)
dc_motor.stop()
sleep(3)
dc_motor.backwards(100)
sleep(2)
dc_motor.forward(5)
sleep(5)
dc_motor.stop()

Afficher le code brut

Importation de bibliothèques

Pour utiliser les fonctionnalités de la bibliothèque, vous devez importer la bibliothèque dans votre code. Nous importons la classe DCMotor de la bibliothèque dcmotor que nous avons créée précédemment.

from dcmotor import DCMotor

Vous devez également importer les classes Pin et PWM pour contrôler les GPIO et la méthode sleep().

from machine import Pin, PWM
from time import sleep

Régler la fréquence

Réglez la fréquence du signal PWM sur 15 000 Hz. Vous pouvez choisir d’autres valeurs de fréquence. Notez que pour des valeurs de fréquence inférieures, le moteur peut ne pas tourner et émettre un bip étrange.

frequency = 15000

Initialisation des GPIO

Nous créons trois variables qui font référence aux broches pin1, pin2 et d’activation du pilote de moteur. Ceux-ci sont connectés respectivement aux GPIO 12, 14 et 13. Les broches 1 et 2 sont des broches de sortie et l’activation est une broche PWM.

pin1 = Pin(12, Pin.OUT)
pin2 = Pin(14, Pin.OUT)
enable = PWM(Pin(13), frequency)

Ensuite, initialisez un objet DCMotor avec les pin1, pin2 et activez définis précédemment :

dc_motor = DCMotor(pin1, pin2, enable)

Remarque : vous devrez peut-être transmettre les paramètres min_duty et max_duty en fonction du moteur et de la carte que vous utilisez. Par exemple:

dc_motor = DCMotor(pin1, pin2, enable, 350, 1023)

Vous disposez maintenant d’un objet DCMotor appelé dc_motor. Vous pouvez utiliser les méthodes pour contrôler le moteur. Faire avancer le moteur à une vitesse de 50 % :

dc_motor.forward(50)

Arrêtez le moteur :

dc_motor.stop()

Faire reculer le moteur à la vitesse maximale :

dc_motor.backwards(100)

Faites avancer le moteur à une vitesse de 5 % :

dc_motor.forward(5)

Démonstration

Exécutez le code précédent sur votre carte ESP32 ou ESP8266. Le moteur avancera à une vitesse de 50 %, reculera à une vitesse de 100 %, puis avancera à nouveau à une vitesse de 5 %. Vous pouvez expérimenter les méthodes et transmettre différentes vitesses comme argument pour voir comment se comporte votre moteur à courant continu.

Dans ce didacticiel, vous avez appris à contrôler un moteur à courant continu à l’aide du pilote de moteur L298N avec l’ESP32 ou l’ESP8266 programmé avec MicroPython. Nous avons créé un module Python avec des méthodes pour contrôler facilement le moteur : la bibliothèque dcmotor.py.

Désormais, vous pouvez utiliser cette bibliothèque dans vos projets pour créer des objets DCMotor et utiliser les méthodes de la bibliothèque pour contrôler le moteur : forward(), forwards() et stop().

Si vous préférez programmer avec l’IDE ​​Arduino, jetez plutôt un œil au tutoriel suivant :

Si vous souhaitez en savoir plus sur MicroPython avec les cartes ESP32 et ESP8266, consultez :

Plongez dans l’histoire de Raspberry Pi avec cette vidéo :