Contrôler un servomoteur avec une carte Arduino / Genuino

3, 2, 1, ça tourne !

par skywodd | May 4, 2016 | Licence (voir pied de page)

Catégories : Tutoriels Arduino | Mots clefs : Arduino Genuino Servomoteurs

Cet article a été modifié pour la dernière fois le May 5, 2016 at 11:43 a.m.

Cet article n'a pas été mis à jour depuis un certain temps, son contenu n'est peut être plus d'actualité.

Dans ce tutoriel, nous allons apprendre ensemble à utiliser des servomoteurs de modélisme avec une carte Arduino / Genuino. Nous étudierons la fonction d'un servomoteur et nous ferons quelques tests avec un modèle classique de servomoteur. En bonus, nous verrons comment tirer profit de toutes les fonctionnalités offertes par la bibliothèque Arduino "Servo".

Sommaire

• Principe de fonctionnement et de contrôle d'un servomoteur
• Utiliser un servomoteur avec une carte Arduino / Genuino
  • Le montage
  • Le code
    • Mise en oeuvre de la bibliothèque Servo
    • Initialisation de la bibliothèque Servo
    • Modification de l'angle du servomoteur
    • Exemple : Sweep
• Conclusion

Bonjour à toutes et à tous !

Dans ce tutoriel, on va s'intéresser aux servomoteurs et à l'utilisation de servomoteurs avec une carte Arduino / Genuino.

Les servomoteurs sont des moteurs un peu particuliers, qui peuvent tourner avec une liberté d'environ 180° et garder de manière relativement précise l'angle de rotation que l'on souhaite obtenir.

On utilise des servomoteurs couramment en modélisme pour contrôler des systèmes mécaniques (gouverne d'avion, accélérateur de moteur thermique, etc.). Les servomoteurs sont aussi couramment utilisés en robotique pour faire des mini-robots, des actionneurs ou des indicateurs rotatifs.

Principe de fonctionnement et de contrôle d'un servomoteur

Un servomoteur de modélisme se présente sous la forme d'un petit rectangle avec deux languettes sur les côtés pour la fixation et un axe décentré avec un bras (interchangeable) pour la liaison mécanique.

Il existe divers types de servomoteurs, de taille, poids et couple (force) différents. La photographie ci-dessus présente un servomoteur très classique en modélisme : le Futuba S3003. Un peu plus bas dans l'article, on utilisera un autre servomoteur, communément appelé "servomoteur 9 grammes", par souci de consommation électrique.

Le fonctionnement interne d'un servomoteur est assez basique.

Un petit circuit électronique permet de contrôler un moteur à courant continu en fonction de la position d'un potentiomètre intégré au servomoteur.

La sortie du moteur à courant continu est reliée mécaniquement à une série d'engrenages qui augmente la force (le couple) du servomoteur en réduisant la vitesse de rotation de celui-ci.

Quand le moteur tourne, les engrenages s'animent, le bras bouge et entraine avec lui le potentiomètre. Le circuit électronique ajuste continuellement la vitesse du moteur pour que le potentiomètre (et par extension le bras) reste toujours au même endroit.

Il suffit de donner une consigne au servomoteur ("reste à 45°" par exemple) et le servomoteur fera son maximum pour rester au plus près de cette consigne.

Cette consigne est transmise au moyen d'un signal numérique, d'une impulsion pour être précis.

Pour que le servomoteur reste à une position donnée, il faut transmettre toutes les 20 millisecondes (soit à une fréquence de 50Hz) une impulsion d'une longueur comprise entre 1 et 2 millisecondes.

• Une impulsion de 1 milliseconde correspond à un angle de 0°.

• Une impulsion de 2 millisecondes correspond à un angle de 180°.

• En envoyant une impulsion d'une longueur intermédiaire, on obtient des angles différents, 90° avec une impulsion de 1.5 milliseconde par exemple.

N.B. La plupart des servomoteurs fonctionnent en 5 volts, mais certains fonctionnent en 3.3 volts. Pensez à bien lire la documentation du servomoteur avant de l'utiliser.

Utiliser un servomoteur avec une carte Arduino / Genuino

Dans ce chapitre, nous allons mettre en oeuvre un petit servomoteur "9 grammes" avec une carte Arduino / Genuino.

Le montage

Pour réaliser ce montage, il va nous falloir :

• Une carte Arduino UNO (et son câble USB),

• Un servomoteur "9 grammes" ou assimilé,

• Des fils pour câbler notre servomoteur.

Le câblage est relativement simple : fil rouge du servomoteur sur la broche 5V de la carte Arduino, fil noir sur la broche GND et fil blanc (ou jaune en fonction des constructeurs) sur la broche D9 de la carte Arduino.

Dans le cas de mon servomoteur, le constructeur (chinois) s'est fait plaisir au niveau des couleurs. J'ai donc un fil marron à la place du noir et un fil orange à la place du rouge. Dans le doute, toujours consulter la documentation constructeur

PS Avec un servomoteur standard, l'alimentation est toujours sur le fil du milieu.

Le code

Pour faire bouger notre servomoteur, nous allons devoir utiliser une bibliothèque de code, nommée "Servo". Celle-ci est fournie de base avec l'environnement de développement Arduino.

La bibliothèque Servo permet de contrôler jusqu'à 12 servomoteurs simultanément avec une carte Arduino UNO et 48 avec une carte Arduino Mega.

Mise en oeuvre de la bibliothèque Servo

La bibliothèque Servo est fournie de base avec l'environnement de développement Arduino. Il n'y a donc pas d'installation à prévoir.

Il suffit d'importer la bibliothèque en ajoutant cette ligne en début de programme pour l'utiliser :

1

#include <Servo.h>

La bibliothèque Servo est une bibliothèque orientée object, cela signifie qu'elle fonctionne en assignant une variable (un objet) à chaque servomoteur que l'on souhaite utiliser.

Pour créer un objet Servo, il suffit de déclarer une variable (globale) de type "Servo", exemple :

1

Servo monServomoteur;

Si vous souhaitez utiliser plusieurs servomoteurs simultanément, il faut créer plusieurs variables, une par servomoteur.

PS Un exemple de code complet est disponible en fin de chapitre

Initialisation de la bibliothèque Servo

L'initialisation de la bibliothèque Servo se fait au moyen de la fonction attach() de chaque objet de type Servo. Exemple :

1
2
3

void setup() { 
  monServomoteur.attach(9);
}

1

Servo.attach(int broche);

La fonction attach() prend en argument un unique paramètre obligatoire correspond au numéro de broche sur laquelle le servomoteur est câblé.

1

Servo.attach(int broche, unsigned long min, unsigned long max);

La fonction attach() peut prendre en plus deux paramètres optionnels, "min" et "max", correspondant respectivement à la durée minimum et maximum en microsecondes de l'impulsion de contrôle vu en début d'article.

Les durées par défaut sont de 544µs pour 0° ~ 240µs pour 180°. Ces valeurs par défaut sont conçues pour fonctionner avec la grande majorité des servomoteurs du commerce.

Si plus tard dans votre code vous souhaitez vérifier qu'un objet Servo est bien attaché à une broche, vous pouvez utiliser la fonction attached().

1

bool Servo.attached();

La fonction attached() retourne un booléen, Vrai (true = 1) si l'objet Servo est attaché à une broche, Faux (false = 0) dans le cas contraire.

Et si vous souhaitez détacher un objet Servo d'une broche, il suffit d'appeler la fonction detach().

1

Servo.detach();

La fonction detach() ne prend aucun paramètre et ne retourne aucune valeur. Il suffit de l'appeler pour détacher l'objet Servo de sa broche.

N.B. Si vous détachez tous les objets Servo de leurs broches respectives, la bibliothèque Servo libère automatiquement les broches D9 et D10 (ou D11 et D12 sur Mega) qui redeviennent utilisables avec analogWrite().

Modification de l'angle du servomoteur

Pour modifier l'angle du bras du servomoteur, il existe deux solutions : write() et writeMicroseconds().

1

Servo.write(int angle);

La fonction write() permet de modifier l'angle du bras du servomoteur en donnant en paramètre l'angle en question, sous la forme d'un nombre entier compris entre 0° et 180°.

1

int Servo.read();

Si par la suite, vous voulez récupérer la dernière valeur d'angle affectée avec la fonction write(), il suffit d'appeler la fonction read() qui retourne la dernière valeur connue.

N.B. L'amplitude de rotation disponible dépend du modèle de servomoteur. Certains servomoteurs peuvent faire un 0° ~ 180° sans problème, quand d'autre arrive à peine à tourner de 60°. Pensez à bien lire les spécifications techniques

1

Servo.writeMicroseconds(unsigned long us);

La fonction writeMicroseconds() permet de modifier l'angle du bras du servomoteur en donnant en paramètre la durée de l'impulsion à transmettre au servomoteur.

Avec un servomoteur standard, une valeur de 1000µs donnera un angle de 0° et une valeur de 2000µs donnera un angle de 180°. Cependant, avec certains servomoteurs, ces valeurs peuvent aller jusqu'à une plage de l'ordre de 700 ~ 2300µs pour 0 ~ 180°.

Cette fonction permet de choisir précisément l'angle du bras en fonction du servomoteur utilisé. Il est cependant nécessaire de faire des tests aux préalables pour déterminer les limites du bras.

Exemple : Sweep

Pour illustrer l'utilisation des fonctions décrites ci-dessus, voici un petit exemple de code nommé "Sweep".

Son but est simple : faire tourner le bras du servomoteur dans un sens puis dans l'autre, indéfiniment.

Exemple Sweep utilisant Servo.write() avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
 * Exemple de code pour un servomoteur, il fait faire des va-et-vient à la tête du servomoteur.
 */

 /* Inclut la lib Servo pour manipuler le servomoteur */
#include <Servo.h>

/* Créer un objet Servo pour contrôler le servomoteur */
Servo monServomoteur;

void setup() {
    
  // Attache le servomoteur à la broche D9
  monServomoteur.attach(9);
}

void loop() {

  // Fait bouger le bras de 0° à 180°
  for (int position = 0; position <= 180; position++) {
    monServomoteur.write(position);
    delay(15);
  }
  
  // Fait bouger le bras de 180° à 10°
  for (int position = 180; position >= 0; position--) {
    monServomoteur.write(position);
    delay(15);
  }
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi). Exemple Sweep utilisant Servo.writeMicroseconds() avec commentaires :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/**
 * Exemple de code pour un servomoteur, il fait faire des va-et-vient à la tête du servomoteur.
 */

 /* Inclut la lib Servo pour manipuler le servomoteur */
#include <Servo.h>

/* Créer un objet Servo pour contrôler le servomoteur */
Servo monServomoteur;

void setup() {
    
  // Attache le servomoteur à la broche D9
  monServomoteur.attach(9);
}

void loop() {

  // Fait bouger le bras de 0° à 180°
  for (unsigned long position = 1000; position <= 2000; position += 5) {
    monServomoteur.writeMicroseconds(position);
    delay(15);
  }
  
  // Fait bouger le bras de 180° à 10°
  for (unsigned long position = 2000; position >= 1000; position -= 5) {
    monServomoteur.writeMicroseconds(position);
    delay(15);
  }
}

L'extrait de code ci-dessus est disponible en téléchargement sur cette page (le lien de téléchargement en .zip contient le projet Arduino prêt à l'emploi).

Conclusion

Ce tutoriel est désormais terminé.

Si ce tutoriel vous a plu, n'hésitez pas à le commenter sur le forum, à le diffuser sur les réseaux sociaux et à soutenir le site si cela vous fait plaisir.

Cliquez ici pour accéder aux commentaires de l'article.