Comment contrôler un servomoteur avec la Raspberry Pi

Ce tutoriel est la troisième partie d’un dossier consacré à la découverte de l’électronique avec la Raspberry Pi. Si vous ne l’avez pas lu, je vous conseille de consulter le premier tutoriel pour contrôler une LED avec la Raspberry Pi ainsi que le second tutoriel pour utiliser un lecteur RFID avec la Raspberry Pi.

Quand on commence la domotique, un besoin classique est de contrôler un mouvement physique dans la réalité depuis un programme.

Dans ce tutoriel nous allons voir comment utiliser la Raspberry Pi pour contrôler un servomoteur.

Les accessoires pour contrôler un servomoteur

Pour pouvoir suivre ce tutoriel et contrôler un servomoteur nous aurons besoin du matériel suivant :

• Une Raspberry Pi
• Son alimentation
• Une carte MicroSD
• Un servomoteur (nous utiliserons un SG90)
• Des câbles duponts et des résistances

C’est quoi la différence entre moteur, servomoteur et moteur pas à pas ?

Avant de commencer à brancher notre servomoteur sur notre Raspberry Pi, faisons un petit point sur les différents types de moteurs classiquement utilisés en électronique.

Sans rentrer dans les détails, on peut grossièrement découper les moteurs utilisés en électronique en trois catégories :

• Le moteur : Il tourne tant qu’il est alimenté. Il est adapté quand vous souhaitez effectuer un mouvement continu ne demandant pas une grande précision.
• Le moteur pas à pas : Il tourne par sorte de petits bonds successifs. C’est-à-dire que vous allez pouvoir lui demander de faire, par exemple, 50 sauts, ou 112 sauts, qui correspondrons à un certain déplacement (par exemple un quart de tour). Il est adapté quand vous souhaitez faire un mouvement continu de grande précision (ils sont par exemple utilisés dans les imprimantes 3D).
• Le servomoteur : Il tourne ave un certain angle, défini selon un signal de type PWM (Pulse Width Modulation). Souvent les petits moteurs sont limités et ne peuvent pas faire plus d’un tour. Ils sont donc plutôt utilisés pour un mouvement court de grande précision.

Il y aurait encore bien d’autres choses à dire sur ces différents moteurs, mais on rentrerai alors dans des questions de mécanique qui dépassent de loin la portée de notre tutoriel.

Dans notre cas nous allons utiliser un servomoteur car il s’agit du moteur de précision le plus simple à contrôler depuis une Raspberry Pi.

Brancher un servomoteur à la Raspberry Pi

La première chose à faire pour pouvoir utiliser notre servomoteur est de le brancher à la Raspberry Pi.

Les servomoteurs possèdent 3 connecteurs électriques. Les couleurs peuvent changer selon les constructeurs, mais généralement vous retrouverez quelque chose comme :

• Un fil rouge, qui sert d’alimentation.
• Un fil noir ou marron, qui sert de GDN.
• Un autre fil, qui sert à transmettre le signal PWM commandant la position du moteur.

Nous allons donc relier ces différents câbles à la Raspberry Pi, le fil rouge à un port GPIO 5 volts et le noir à un port GND.

Pour le port PWM en revanche, nous allons obligatoirement devoir le relier à la 12ème broche GPIO de la Raspberry Pi. En effet, c’est la seule broche GPIO supportant un signal PWM par défaut.

Vous devriez donc avoir un montage comme celui-ci.

À noter, ici nous alimentons notre servomoteur directement depuis la Raspberry Pi. Cela fonctionne car nous utilisons un très petit servomoteur, mais sur un modèle plus conséquent nous aurions besoin d’une alimentation dédiée.

Piloter le servomoteur en lignes de commande

Maintenant que nous avons branché notre servomoteur, nous allons pouvoir le piloter directement depuis la ligne de commande de la Raspberry Pi.

Pour cela, nous allons commencer par activer le mode PWM sur le port 12, soit le GPIO 18 selon la numérotation processeur.

gpio -o mode 18 pwm

Et nous allons activer le mode Mark/Space de PWM, qui permet d’avoir un signal plus adapté à notre usage.

gpio pwm-ms

Enfin, nous allons configurer la durée d’un cycle, des fréquences à employer, etc.

Le servomoteur est réglé pour fonctionner à une fréquence de 50 Hz soit 20 ms. Le signal de la Raspberry Pi fonctionne à une autre fréquence, 19.2 MHz. En utilisant ces deux chiffres, on peut calculer une période et un range (merci à framboise314.fr pour la formule) :

50 = 19.2 * 10^6 / 192 / 2000

Nous allons donc régler la Raspberry Pi pour utiliser ces valeurs :

gpio pwmc 192
gpio pwmr 2000

Enfin, nous allons pouvoir faire bouger notre moteur ! Sachez que l’on ne passe pas un angle au servomoteur, mais un chiffre qui sera converti en angle. Notre servomoteur va de 0° à 180°. Après quelques tests, il semblerait que 0° correspondant à 230, 90° à 150 et 180° à 70.

Pour envoyer notre moteur à 90° nous allons donc utiliser la commande :

gpio -g pwm 18 150

Et nous remplacerons 150 par 230 pour aller à 0°, 70 pour aller à 180° ou n’importe quelle valeur entre les deux selon nos besoins.

À noter, ces petits moteurs supportent un angle de 180° de façon précise, mais ils ont un peu de marge qui peuvent les amener à faire du 190° ou 200° et même à faire un tour complet si vous mettez une valeur suffisamment basse. C’est spécifique à chaque modèle de moteur.

Piloter le servomoteur avec Python

Comme pour les tutoriels précédents de cette série, l’objectif est plutôt de contrôler notre moteur avec Python plutôt que directement en lignes de commande. Je considère que vous avez maintenant les bases de Python, si ce n’est pas le cas allez lire les tutoriels précédents, des liens sont disponibles au début de cet article.

Pour contrôler notre moteur depuis un script Python nous allons encore une fois utiliser la lib Rpi.GPIO.

En Python et sur la Pi, l’angle du moteur est calculé comme un pourcentage du cycle. Ce pourcentage se nomme « Duty Cycle ».

Un signal de 0.5ms correspond à 0° et un signal de 2.5ms à 180°. Sachant que notre cycle est de 50 Hz, soit 20ms, cela nous permet de calculer les Duty Cycle pour 0° et 180° comme ceci :

x = 0.5 / 20
y = 2.5 / 20

On trouve alors que le Duty Cycle correspondant à 0° est 0.025, soit 2.5% et que celui correspondant à 180° est 0.125, soit 12.5%.

Petit problème néanmoins, si cette valeur est théoriquement bonne, dans les faits elle a tendance à déclencher un tour complet du moteur pour 0°… Je vous conseille donc plutôt d’utiliser 4% pour 0°. La valeur 12.5% pour 180, est bonne.

Pour contrôler le moteur, il nous suffit de définir le pin 12 comme notre signal PWM, et d’utiliser les fonctions start et ChangeDutyCycle.

Vous pouvez donc créer un fichier servo.py et y mettre le code suivant :

#!/usr/bin/env python3
#-- coding: utf-8 --
import RPi.GPIO as GPIO
import time


#Set function to calculate percent from angle
def angle_to_percent (angle) :
    if angle > 180 or angle < 0 :
        return False

    start = 4
    end = 12.5
    ratio = (end - start)/180 #Calcul ratio from angle to percent

    angle_as_percent = angle * ratio

    return start + angle_as_percent


GPIO.setmode(GPIO.BOARD) #Use Board numerotation mode
GPIO.setwarnings(False) #Disable warnings

#Use pin 12 for PWM signal
pwm_gpio = 12
frequence = 50
GPIO.setup(pwm_gpio, GPIO.OUT)
pwm = GPIO.PWM(pwm_gpio, frequence)

#Init at 0°
pwm.start(angle_to_percent(0))
time.sleep(1)

#Go at 90°
pwm.ChangeDutyCycle(angle_to_percent(90))
time.sleep(1)

#Finish at 180°
pwm.ChangeDutyCycle(angle_to_percent(180))
time.sleep(1)

#Close GPIO & cleanup
pwm.stop()
GPIO.cleanup()

Il ne vous reste plus qu’à lancer le script en faisant :

python3 ./servo.py

Vous devriez alors voir votre moteur démarrer à 0°, puis passer à 90° et enfin s’arrêter à 180°.

Il ne vous reste plus qu’à adapter ce script à vos propres besoins !