Comment contrôler les servomoteurs avec Arduino - Guide complet

Contrôle du servomoteur Arduino

Mettons ce qui précède pour tester et faire un exemple pratique de contrôle d'un servo de loisir à l'aide d'Arduino. J'utiliserai le MG996R qui est un servo à couple élevé doté d'un engrenage en métal avec un couple de décrochage de 10 kg-cm. Le couple élevé a un prix et c'est le courant de décrochage du servo qui est de 2,5 A. Le courant de fonctionnement est de 500mA à 900mA et la tension de fonctionnement est de 4,8 à 7,2V.

Les valeurs nominales actuelles indiquent que nous ne pouvons pas connecter directement ce servo à l'Arduino, mais nous devons utiliser une alimentation séparée pour cela.

Schéma du circuit

Voici le schéma de circuit pour cet exemple.

Nous devons simplement connecter la broche de commande du servo à n'importe quelle broche numérique de la carte Arduino, connecter la masse et les fils positifs à l'alimentation externe 5V, et également connecter la masse Arduino à la masse du servo.

Si nous utilisons un petit servo de loisir, le S90 Micro Servo, il est possible de l'alimenter directement à partir de la broche Arduino 5V.

Le S90 Micro Servo a une consommation de courant plus faible, environ 100 à 200 mA de courant à vide, mais environ 500 à 700 mA de courant de décrochage. D'autre part, la broche Arduino 5 V ne peut produire qu'environ 500 mA si elle est alimentée via USB, ou jusqu'à 1 A via le connecteur cylindrique.

Même s'il est possible de faire fonctionner ces servomoteurs 9g directement sur Arduino, pour un travail plus stable, je suggérerais de toujours utiliser une alimentation externe pour eux.

Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :

• Servomoteur MG996R ………………………….
• ou S90 Micro Servo ………..……………………
• Carte Arduino …………………………………………….
• Alimentation CC 5V 2A …………………..…..

Code Arduino de contrôle de servomoteur

Examinons maintenant le code Arduino pour contrôler le servomoteur. Le code est très simple. Nous avons juste besoin de définir la broche à laquelle le servo est connecté, de définir cette broche comme une sortie et, dans la section de boucle, de générer des impulsions avec la durée et la fréquence spécifiques, comme nous l'avons expliqué précédemment.

/*
     Servo Motor Control - 50Hz Pulse Train Generator
           by Dejan, https://howtomechatronics.com
*/

#define servoPin 9

void setup() {
  pinMode(servoPin, OUTPUT);
}

void loop() {
   // A pulse each 20ms
    digitalWrite(servoPin, HIGH);
    delayMicroseconds(1450); // Duration of the pusle in microseconds
    digitalWrite(servoPin, LOW);
    delayMicroseconds(18550); // 20ms - duration of the pusle
    // Pulses duration: 600 - 0deg; 1450 - 90deg; 2300 - 180deg
}Code language: Arduino (arduino)

Après quelques tests, j'ai trouvé les valeurs suivantes pour la durée des impulsions qui fonctionnent avec mon servo. Les impulsions d'une durée de 0,6 ms correspondaient à la position 0 degré, 1,45 ms à 90 degrés et 2,3 ms à 180 degrés.

J'ai connecté un multimètre en série avec le servo pour vérifier la consommation de courant. La consommation de courant maximale que j'ai remarquée était de 0,63 A au décrochage. Eh bien, c'est parce que ce n'est pas le servo TowerPro MG996R d'origine, mais une réplique moins chère, qui a évidemment de moins bonnes performances.

Néanmoins, examinons un moyen plus pratique de contrôler les servos à l'aide d'Arduino. Cela utilise la bibliothèque servo Arduino.

/*
     Servo Motor Control using the Arduino Servo Library
           by Dejan, https://howtomechatronics.com
*/

#include <Servo.h>

Servo myservo;  // create servo object to control a servo

void setup() {
  myservo.attach(9,600,2300);  // (pin, min, max)
}

void loop() {
  myservo.write(0);  // tell servo to go to a particular angle
  delay(1000);
  
  myservo.write(90);              
  delay(500); 
  
  myservo.write(135);              
  delay(500);
  
  myservo.write(180);              
  delay(1500);                     
}Code language: Arduino (arduino)

Ici, il nous suffit d'inclure la bibliothèque, de définir l'objet servo et, à l'aide de la fonction attach(), de définir la broche à laquelle le servo est connecté ainsi que de définir les valeurs minimale et maximale des durées d'impulsions. Ensuite, en utilisant la fonction write(), nous définissons simplement la position du servo de 0 à 180 degrés.

Contrôler plusieurs servomoteurs avec Arduino

La bibliothèque servo Arduino prend en charge le contrôle simultané de jusqu'à 12 servos avec la plupart des cartes Arduino et de 48 servos avec la carte Arduino Mega. De plus, contrôler plusieurs servomoteurs avec Arduino est aussi simple que d'en contrôler un seul.

Voici un exemple de code pour contrôler plusieurs servos :

/*
     Controlling multiple servo motors with Arduino
     by Dejan, https://howtomechatronics.com
*/

#include <Servo.h>

Servo servo1;
Servo servo2;
Servo servo3;
Servo servo4;
Servo servo5;

void setup() {
  servo1.attach(8);
  servo2.attach(9);
  servo3.attach(10);
  servo4.attach(11);
  servo5.attach(12);
}

void loop() {
  // move all servos to position 0
  servo1.write(0);
  servo2.write(0);
  servo3.write(0);
  servo4.write(0);
  servo5.write(0);
  delay(2000);

  // move all servos to position 90
  servo1.write(90);
  servo2.write(90);
  servo3.write(90);
  servo4.write(90);
  servo5.write(90);
  delay(2000);

  // move all servos to position 180
  servo1.write(180);
  servo2.write(180);
  servo3.write(180);
  servo4.write(180);
  servo5.write(180);
  delay(2000);
}Code language: Arduino (arduino)

Il nous suffit donc de créer des objets de la classe Servo pour chaque servomoteur et de définir à quelle broche Arduino est connectée. Bien sûr, nous pouvons configurer n'importe quel servo pour qu'il se déplace vers n'importe quelle position, à tout moment.

À titre d'exemple, vous pouvez également consulter mon projet Arduino Ant Hexapod Robot où j'ai utilisé une carte Arduino MEGA pour contrôler 22 servomoteurs.

Pilote PWM/Servo Arduino et PCA9685

Il existe également une autre façon de contrôler les servos avec Arduino, et c'est en utilisant le servomoteur PCA9685. Il s'agit d'un servomoteur PWM 12 bits à 16 canaux qui communique avec Arduino à l'aide du bus I2C. Il dispose d'une horloge intégrée qui lui permet de piloter 16 servos en fonctionnement libre ou indépendamment d'Arduino.

Ce qui est encore plus cool, nous pouvons connecter en série jusqu'à 62 de ces pilotes sur un seul bus I2C. Donc, théoriquement, nous pouvons contrôler jusqu'à 992 servos en utilisant uniquement les deux broches I2C de la carte Arduino. Les 6 broches de sélection d'adresse sont utilisées pour définir différentes adresses I2C pour chaque pilote supplémentaire. Nous avons juste besoin de connecter les pastilles de soudure selon ce tableau.

Voici le schéma du circuit et nous pouvons encore une fois remarquer que nous avons besoin d'une alimentation séparée pour les servos.

Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :

• Servomoteur MG996R ………………………….
• Servopilote PWM PCA9685  ……………….
• Carte Arduino …………………………………………….
• Alimentation CC 5V 6A …………………..…..

Voyons maintenant le code Arduino. Pour contrôler ce servodriver, nous utiliserons la bibliothèque PCA9685 qui peut être téléchargée depuis GitHub.

Code Arduino et PCA9685

/*
     Servo Motor Control using Arduino and PCA9685 Driver
           by Dejan, https://howtomechatronics.com
           
     Library: https://github.com/NachtRaveVL/PCA9685-Arduino
*/

#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;

// PCA9685 outputs = 12-bit = 4096 steps
// 2.5% of 20ms = 0.5ms ; 12.5% of 20ms = 2.5ms
// 2.5% of 4096 = 102 steps; 12.5% of 4096 = 512 steps
PCA9685_ServoEvaluator pwmServo(102, 470); // (-90deg, +90deg)

// Second Servo
// PCA9685_ServoEvaluator pwmServo2(102, 310, 505); // (0deg, 90deg, 180deg)


void setup() {
  Wire.begin();                 // Wire must be started first
  Wire.setClock(400000);        // Supported baud rates are 100kHz, 400kHz, and 1000kHz
  driver.resetDevices();        // Software resets all PCA9685 devices on Wire line

  driver.init(B000000);         // Address pins A5-A0 set to B000000
  driver.setPWMFrequency(50);   // Set frequency to 50Hz
}
void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  delay(1000);
}Code language: Arduino (arduino)

Nous devons donc d'abord inclure les bibliothèques et définir l'objet PCA9685. Ensuite, à l'aide de l'instance Servo_Evaluator, définissez la durée des impulsions ou la sortie PWM du pilote. Notez que les sorties sont en 12 bits, soit une résolution de 4096 pas. Ainsi, la durée d'impulsion minimale de 0,5 ms ou position 0 degrés correspondrait à 102 pas, et la durée d'impulsion maximale de 2,5 ms ou position 180 degrés à 512 pas. Mais comme expliqué précédemment, ces valeurs doivent être ajustées en fonction de votre servomoteur. J'avais une valeur de 102 à 470 qui correspondait à une position de 0 à 180 degrés.

Dans la section de configuration, nous devons définir la fréquence d'horloge I2C, définir l'adresse du pilote et définir la fréquence sur 50 Hz.

Dans la section boucle, en utilisant setChannelPWM() et pwmForAngle() fonctions, nous réglons simplement le servo à l'angle souhaité.

J'ai connecté un deuxième servo au pilote, et comme je m'y attendais, il ne se positionnait pas de la même manière que le premier, et c'est parce que les servos que j'utilise sont des copies bon marché et qu'ils ne sont pas si fiables. Cependant, ce n'est pas un gros problème car l'utilisation du Servo_Evaluator Par exemple, nous pouvons définir différents paramètres de sortie pour chaque servo. Nous pouvons également ajuster la position à 90 degrés au cas où ce ne serait pas exactement au milieu. De cette façon, tous les servos fonctionneront de la même manière et se positionneront à l'angle exact.

Contrôle de nombreux servos avec Arduino et les pilotes PCA9685

Nous allons jeter un œil à un autre exemple et qui contrôle beaucoup de servos avec plusieurs pilotes PCA9685 chaînés.

Pour cela, nous devons connecter les pilotes les uns aux autres et connecter les pastilles de soudure de sélection d'adresse appropriée. Voici le schéma du circuit :

Jetons un coup d'œil au code Arduino maintenant.

/*
     Servo Motor Control using Arduino and PCA9685 Driver
           by Dejan, https://howtomechatronics.com
           
     Library: https://github.com/NachtRaveVL/PCA9685-Arduino
*/

#include <Wire.h>
#include "PCA9685.h"

PCA9685 driver;

// PCA9685 outputs = 12-bit = 4096 steps
// 2.5% of 20ms = 0.5ms ; 12.5% of 20ms = 2.5ms
// 2.5% of 4096 = 102 steps; 12.5% of 4096 = 512 steps
PCA9685_ServoEvaluator pwmServo(102, 470); // (-90deg, +90deg)

// Second Servo
PCA9685_ServoEvaluator pwmServo2(102, 310, 505); // (0deg, 90deg, 180deg)


void setup() {
  Wire.begin();                 // Wire must be started first
  Wire.setClock(400000);        // Supported baud rates are 100kHz, 400kHz, and 1000kHz
  driver.resetDevices();        // Software resets all PCA9685 devices on Wire line

  driver.init(B000000);         // Address pins A5-A0 set to B000000
  driver.setPWMFrequency(50);   // Set frequency to 50Hz
}
void loop() {
  driver.setChannelPWM(0, pwmServo.pwmForAngle(-90));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(0));
  delay(1000);
  driver.setChannelPWM(0, pwmServo.pwmForAngle(90));
  delay(1000);
}Code language: Arduino (arduino)

Nous devons donc créer un objet PCA9685 séparé pour chaque pilote, définir les adresses pour chaque pilote et définir la fréquence sur 50 Hz. Maintenant, en utilisant simplement les fonctions setChannelPWM() et pwmForAngle(), nous pouvons régler n'importe quel servo sur n'importe quel pilote pour positionner n'importe quel angle que nous voulons.

Dépannage

Le servomoteur tremble et réinitialise ma carte Arduino

Il s'agit d'un problème courant avec ces servomoteurs de loisir, le SG90 Micro Servo et le MG996R. La raison en est que, comme mentionné précédemment, ils peuvent consommer une quantité de courant assez importante lorsqu'ils sont en charge. Cela peut entraîner la réinitialisation de la carte Arduino, en particulier si vous alimentez le servo directement à partir de la broche Arduino 5V.

Afin de résoudre ce problème, vous pouvez utiliser un condensateur entre le GND et la broche 5V. Il agira comme un condensateur de découplage qui fournira un courant supplémentaire au système au démarrage lorsque le moteur à courant continu démarre.

Le servomoteur ne se déplace pas sur toute la plage de 0 à 180 degrés

C'est un autre problème courant avec ces servos de loisirs. Comme nous l'avons expliqué précédemment, une largeur d'impulsion de 1 ms (0,5 ms) correspond à la position 0 degré et de 2 ms (2,5 ms) à 180 degrés. Cependant, ces valeurs peuvent varier d'un servo à l'autre et entre différents fabricants.

Afin de résoudre ce problème, nous devons ajuster la largeur d'impulsion que nous envoyons au servomoteur avec l'Arduino. Heureusement, en utilisant la bibliothèque Arduino Servo, nous pouvons facilement ajuster les valeurs de largeur d'impulsion dans attach() fonction.

Le attache() La fonction peut prendre deux paramètres supplémentaires, et c'est la largeur d'impulsion minimale et maximale en microsecondes. Les valeurs par défaut sont 544 microsecondes (0,544 millisecondes) pour un angle minimum (0 degré) et 2400 microsecondes (2,4 ms). Ainsi, en ajustant ces valeurs, nous pouvons affiner la plage de moment du servo.

  myservo.attach(9,600,2300);  // (pin, min, max)Code language: Arduino (arduino)

Dimensions et modèle 3D

J'ai réalisé des modèles 3D des deux servomoteurs les plus populaires, le SG90 Micro Servo et le servomoteur MG996R. Vous pouvez les télécharger à partir des liens ci-dessous.

Micro-servo SG90

Modèle 3D :Télécharger à partir de Thangs.

Dimensions :

Servomoteur MG996R

Modèle 3D du servomoteur MG996R :Télécharger à partir de Thangs.

Dimensions :

Conclusion

Nous avons donc couvert presque tout ce que nous devons savoir sur l'utilisation de servomoteurs avec Arduino. Bien sûr, il existe de nombreux fabricants et modèles de ce type de servomoteurs de loisir ou RC, et chacun d'eux a ses propres caractéristiques uniques qui peuvent différer de ce que nous avons expliqué ci-dessus.

Les possibilités de créer de superbes projets de robotique, d'automatisation et de RC à l'aide de moteurs sont infinies, mais il est très important de choisir le bon modèle pour votre application.

J'espère que vous avez apprécié ce tutoriel et appris quelque chose de nouveau. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous, ainsi qu'à vous assurer que vous pouvez accéder à ma collection de projets Arduino.

Foire aux questions (FAQ)

L'utilisation d'un servomoteur avec Arduino est assez simple. Le servomoteur n'a que 3 fils, dont deux sont GND et 5V pour l'alimentation, et le troisième fil est la ligne de commande qui va à la carte Arduino.

Nous pouvons faire fonctionner des servomoteurs directement à partir d'Arduino, mais nous pourrions avoir des problèmes d'alimentation. Si le servomoteur consomme plus de 500 mA de courant, la carte Arduino peut perdre son alimentation et se réinitialiser. Il est préférable de toujours utiliser une source d'alimentation séparée pour les servomoteurs.

En utilisant la bibliothèque Arduino Servo, nous pouvons contrôler jusqu'à 12 servomoteurs avec la plupart des cartes Arduino et jusqu'à 48 servomoteurs avec la carte Arduino Mega. Bien sûr, nous devons utiliser une source d'alimentation dédiée pour les servomoteurs.