Utiliser un servomoteur avec une carte ESP32 en MicroPython

Fonctionnement d’un servomoteur

Un petit moteur CC est relié à un potentiomètre par l’intermédiaire d’un circuit électronique, ce qui permet de réguler finement la vitesse du moteur selon la position du potentiomètre. Une série d’engrenages est attachée à l’axe de sortie du moteur, afin de multiplier le couple tout en réduisant sa vitesse de rotation. Lorsque le moteur tourne, les engrenages entraînent le mouvement du bras qui à son tour actionne le potentiomètre. Si le mouvement s’arrête, le circuit électronique ajuste en continu la vitesse du moteur pour maintenir le potentiomètre et donc le bras à la même position. Cette fonctionnalité est notamment très pratique pour les bras d’un robot qui ne retombe pas sous l’effet de son propre poids lorsque le mouvement s’arrête.

Ce petit servomoteur est commandé en utilisant un signal modulé en largeur d’impulsion (PWM) de 50 Hz de fréquence, soit une impulsion toute les 20ms. La position du servomoteur est déterminée par la durée des impulsions, généralement variant entre 1ms et 2ms.

Comment alimenter le servomoteur avec un ESP32

Dans la fiche technique du servo SG90 , l’alimentation optimale est de 5V. Ceci dit, il semblerait fonctionner également en 3.3V.

Un servomoteur consomme beaucoup de courant, surtout quand il exerce un couple important. Puisque la broche 5V de la plupart des cartes ESP32 provient directement du bus USB, vous serez limité au maximum à 500mA. Avec 1 ou 2 servomoteurs de branché l’ESP32 devrait tenir la charge.

Au-delà de 2, utilisez plutôt une alimentation distincte. Dans ce cas, assurez-vous de connecter une broche GND de la carte à la borne négative de l’alimentation du servomoteur 😉.

Branchements du servomoteur SG90 sur l’ESP32 d’uPesy

Un servomoteur SG90 contient 3 fils : 2 pour l’alimentation et 1 pour le signal de commande en PWM. Les couleurs des fils permettent de les différencier :

On peut utiliser n’importe quelle broche de sortie de l’ESP32 pour contrôler le servomoteur car les broches de l’ESP32 sont toutes capables de produire une sortie PWM.

Circuit pour piloter un servomoteur avec une ESP32

Script Python basique pour piloter le servo avec ses propres calculs

Avec le servo SG90 de TowerPro, la position minimale correspond à une largeur impulsion de 0.5ms et la position maximale à une de 2.4ms. En faisant des calculs, on peut en déduire le duty-cycle du PWM, puis la valeur en bits de la largeur d’impulsion. Je ne vais pas détailler les calculs, car on va plutôt utiliser une libraire toute faite pour la suite.

Voici tout de même un script basique :

from machine import Pin,PWM
import time

sg90 = PWM(Pin(22, mode=Pin.OUT))
sg90.freq(50)

# 0.5ms/20ms = 0.025 = 2.5% duty cycle
# 2.4ms/20ms = 0.12 = 12% duty cycle

# 0.025*1024=25.6
# 0.12*1024=122.88

while True:
    sg90.duty(26)
    time.sleep(1)
    sg90.duty(123)
    time.sleep(1)

Je vous l’accorde ce n’est pas très facile à comprendre. C’est pour cela que nous allons utiliser une librairie !

Piloter un servo via un script Python avec la librairie servo.py

Je vous propose d’utiliser cette libraire MicroPython suivante pour facilement contrôler le servomoteur. Elle s’installe comme les autres librairies MicroPython : copier-coller le fichier sur votre carte ESP32 dans le gestionnaire de fichiers de MicroPython.

from machine import Pin, PWM

class Servo:
    # these defaults work for the standard TowerPro SG90
    __servo_pwm_freq = 50
    __min_u10_duty = 26 - 0 # offset for correction
    __max_u10_duty = 123- 0  # offset for correction
    min_angle = 0
    max_angle = 180
    current_angle = 0.001


    def __init__(self, pin):
        self.__initialise(pin)


    def update_settings(self, servo_pwm_freq, min_u10_duty, max_u10_duty, min_angle, max_angle, pin):
        self.__servo_pwm_freq = servo_pwm_freq
        self.__min_u10_duty = min_u10_duty
        self.__max_u10_duty = max_u10_duty
        self.min_angle = min_angle
        self.max_angle = max_angle
        self.__initialise(pin)


    def move(self, angle):
        # round to 2 decimal places, so we have a chance of reducing unwanted servo adjustments
        angle = round(angle, 2)
        # do we need to move?
        if angle == self.current_angle:
            return
        self.current_angle = angle
        # calculate the new duty cycle and move the motor
        duty_u10 = self.__angle_to_u10_duty(angle)
        self.__motor.duty(duty_u10)

    def __angle_to_u10_duty(self, angle):
        return int((angle - self.min_angle) * self.__angle_conversion_factor) + self.__min_u10_duty


    def __initialise(self, pin):
        self.current_angle = -0.001
        self.__angle_conversion_factor = (self.__max_u10_duty - self.__min_u10_duty) / (self.max_angle - self.min_angle)
        self.__motor = PWM(Pin(pin))
        self.__motor.freq(self.__servo_pwm_freq)

Pour utiliser la librairie, c’est extrême simple. Après avoir importé la classe Servo , on définit un objet Servo qui représente notre servomoteur bleu. On lui précise la broche utilisée pour le piloter dans les paramètres du constructeur.

Ensuite on indique la position angulaire voulue avec la fonction .move(angle) .

from servo import Servo
import time

motor=Servo(pin=22) # A changer selon la broche utilisée
motor.move(0) # tourne le servo à 0°
time.sleep(0.3)
motor.move(90) # tourne le servo à 90°
time.sleep(0.3)
motor.move(180) # tourne le servo à 180°
time.sleep(0.3)
motor.move(90) # tourne le servo à 90°
time.sleep(0.3)
motor.move(0) # tourne le servo à 0°
time.sleep(0.3)

Voici une vidéo de démonstration avec le code ci-dessus :