Sommaire
Pourquoi utiliser le Shield I2C 16 Servomoteurs avec l’ESP32 ?
Le Shield I2C 16 Servomoteurs pour ESP32 (avec lecteur microSD intégré) est une carte d’extension conçu par l’Atelier de la Robotique.
Elle permet de piloter jusqu’à 16 servomoteurs via le bus I2C tout en offrant la possibilité d’enregistrer ou de lire des données grâce à son lecteur microSD.
Atouts principaux du Shield 16 Servos ESP32
- Décharge l’ESP32 de la génération de signaux PWM multiples, en centralisant le pilotage via I2C.
- Adresse I2C configurable via des jumpers, permettant d’empiler plusieurs shields ou d’éviter les conflits d’adresse.
- Slot microSD intégré pour stocker des positions, configurations ou journaux de mouvements.
- Format “shield” compact pour une intégration facile sur tout système basé sur ESP32.
- Alimentation externe recommandée pour les servos puissants, afin d’éviter de surcharger la carte ESP32.
Grâce à ce module, la gestion de nombreux servomoteurs devient simple et stable :
idéal pour un bras articulé, un robot humanoïde ou tout projet de robotique complexe nécessitant l’enregistrement de mouvements sur microSD.
Basé sur la puce PCA9685, ce shield peut être empilé pour piloter jusqu’à 1024 servomoteurs en ajustant les adresses I2C.
👉 Pour aller plus loin, découvrez notre article sur l’utilisation du contrôleur PCA9685.
Présentation du Shield servomoteurs ESP32
Le Shield servomoteurs pour ESP32 est une carte d’extension pratique pour piloter plusieurs servomoteurs tout en simplifiant le câblage et la gestion via I2C.
Elle intègre également un lecteur microSD pour enregistrer les données de mouvements ou configurations.
Caractéristiques principales
- 16 connecteurs pour servomoteurs
- Configuration d’adresse I2C (0x40 par défaut)
- Bornier d’alimentation pour les servomoteurs
- Indicateur LED de bon fonctionnement
- Connecteurs pour la carte ESP32
- Lecteur de carte microSD
Montage et préparation du matériel
Avant de piloter vos servomoteurs, il est essentiel de préparer le montage ESP32 + Shield I2C 16 servomoteurs et de vérifier votre matériel.
Compatibilité et recommandations
Le Shield servomoteurs ESP32 est compatible avec l’ensemble des cartes ESP32. Pour plus de praticité, nous recommandons la Carte de Développement ESP32-DevKitC Version-2 16 MB – ESP32-WROOM-32.
Matériel nécessaire
- 1 Carte ESP32-DevKitC Version-2 16 MB
- 1 Carte Shield 16 servomoteurs pour ESP32
- Au moins 1 servomoteur (MG995, MG996R ou DS3218)
- 1 Câble USB Type C pour alimenter la carte ESP32
- 1 Coupleur de piles 18650 avec bouton ON/OFF et couvercle de protection
- 2 piles rechargeables 3.7V 18650
-
-
-
-
-
-
Carte de Développement ESP32-DevKitC Version-2 16 MB – ESP32-WROOM-32
19,99 €
Vous économisez Ajouter au panier -
-
Montage physique
- Connecter le Shield 16 servomoteurs sur la carte ESP32.
- Alimenter la carte ESP32 via le câble USB Type C.
- Prévoir une alimentation externe stable pour les servomoteurs puissants afin de ne pas surcharger la carte ESP32.
Programmation Arduino
Une fois le montage terminé, nous allons installer les librairies nécessaires et tester le pilotage des servomoteurs.
Librairies Arduino
Pour assurer le bon fonctionnement du shield, installez la librairie suivante depuis le gestionnaire de l’IDE Arduino : Adafruit_PWMServoDriver.h.
Les autres librairies sont déjà incluses par défaut : SD.h, SPI.h, Wire.h.
Exemple 1 : Pilotage simple de servomoteurs via I2C
Cet exemple montre comment initialiser la communication I2C vers le shield, et piloter quelques servos de façon simple (mettre un angle, balayage). Nous allons piloter 6 servomoteurs pour l’exemple. Libre à vous d’en rajouter à partir de cet exemple (jusqu’à 16 maximum).
#include <Adafruit_PWMServoDriver.h>
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
// valeurs approximatives qui peuvent varier d'un servomoteur à l'autre:
#define SERVOMIN 150 // Position minimale
#define SERVOMAX 600 // Position maximale
int pulseLen;
//Attribution des broches Servomoteurs
uint8_t servo1 = 0;
uint8_t servo2 = 1;
uint8_t servo3 = 2;
uint8_t servo4 = 3;
uint8_t servo5 = 4;
uint8_t servo6 = 5;
void setup() {
pwm.begin();
pwm.setPWMFreq(60);
delay(1000);
pulseLen = map( 90, 0, 180, SERVOMIN, SERVOMAX );
pwm.setPWM(servo1, 0, pulseLen);
delay(100);
pwm.setPWM(servo2, 0, pulseLen);
delay(100);
pwm.setPWM(servo3, 0, pulseLen);
delay(100);
pwm.setPWM(servo4, 0, pulseLen);
delay(100);
pwm.setPWM(servo5, 0, pulseLen);
delay(100);
pwm.setPWM(servo6, 0, pulseLen);
delay(3000);
}
void loop() {
pulseLen = map( 20, 0, 180, SERVOMIN, SERVOMAX ); //Positionnement des servomoteurs à 20 degrés
pwm.setPWM(servo1, 0, pulseLen);
pwm.setPWM(servo2, 0, pulseLen);
pwm.setPWM(servo3, 0, pulseLen);
pwm.setPWM(servo4, 0, pulseLen);
pwm.setPWM(servo5, 0, pulseLen);
pwm.setPWM(servo6, 0, pulseLen);
delay(2000);
pulseLen = map( 160, 0, 180, SERVOMIN, SERVOMAX ); //Positionnement des servomoteurs à 130 degrés
pwm.setPWM(servo1, 0, pulseLen);
pwm.setPWM(servo2, 0, pulseLen);
pwm.setPWM(servo3, 0, pulseLen);
pwm.setPWM(servo4, 0, pulseLen);
pwm.setPWM(servo5, 0, pulseLen);
pwm.setPWM(servo6, 0, pulseLen);
delay(2000);
// Balayage de 0° à 180°
for (int angle = 0; angle <= 180; angle++) {
int pulseLen = map(angle, 0, 180, SERVOMIN, SERVOMAX);
// Bouge les 6 servos en même temps
for (int servo = 0; servo < 6; servo++) {
pwm.setPWM(servo, 0, pulseLen);
}
delay(15); // petite pause pour mouvement fluide
}
delay(500);
// Retour de 180° à 0°
for (int angle = 180; angle >= 0; angle--) {
int pulseLen = map(angle, 0, 180, SERVOMIN, SERVOMAX);
for (int servo = 0; servo < 6; servo++) {
pwm.setPWM(servo, 0, pulseLen);
}
delay(15);
}
delay(500);
}
Exemple 2 : Pilotage avec enregistrement sur microSD
Cet exemple plus avancé permet de piloter plusieurs servomoteurs tout en enregistrant les positions sur une carte microSD. Le shield 16 servomoteurs peut accepter les carte microSD jusqu’à 32 Go.
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
#include <SPI.h>
#include <SD.h>
#define I2C_ADDR 0x40
#define SERVO_FREQ 50
#define SD_CS 5 // broche CS du lecteur microSD sur l’ESP32
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver(I2C_ADDR);
File logFile;
void setup() {
Serial.begin(115200);
Wire.begin();
pwm.begin();
pwm.setPWMFreq(SERVO_FREQ);
delay(10);
Serial.println("Initialisation du module SD...");
if (!SD.begin(SD_CS)) {
Serial.println("Erreur : impossible d'initialiser la carte SD");
while (1) {
delay(1000);
}
}
Serial.println("Carte SD initialisée.");
// Ouvrir ou créer un fichier de log
logFile = SD.open("/servo_log.txt", FILE_WRITE);
if (!logFile) {
Serial.println("Erreur : impossible d'ouvrir le fichier de log");
} else {
logFile.println("Log démarré");
logFile.flush();
}
}
void loop() {
// Exemple : balayer les servos 0 et 1
for (uint16_t p = 150; p < 600; p += 10) {
pwm.setPWM(0, 0, p);
pwm.setPWM(1, 0, p);
delay(50);
// Enregistrer les positions
if (logFile) {
uint8_t angle0 = map(p, 150, 600, 0, 180);
uint8_t angle1 = map(p, 150, 600, 0, 180);
logFile.printf("Servo0: %u°, Servo1: %u°\n", angle0, angle1);
logFile.flush();
}
}
// Revenir en arrière
for (uint16_t p = 600; p > 150; p -= 10) {
pwm.setPWM(0, 0, p);
pwm.setPWM(1, 0, p);
delay(50);
if (logFile) {
uint8_t angle0 = map(p, 150, 600, 0, 180);
uint8_t angle1 = map(p, 150, 600, 0, 180);
logFile.printf("Servo0: %u°, Servo1: %u°\n", angle0, angle1);
logFile.flush();
}
}
delay(1000);
}
Après les tests, vous pouvez désactiver l’alimentation des servomoteurs, déconnecter la carte ESP32 de l’ordinateur, retirer la carte microSD du shield et accéder au fichier de log sur votre ordinateur.
Aller plus loin avec votre Shield ESP32
Après avoir testé le pilotage simple et l’enregistrement sur microSD, vous pouvez explorer des projets plus avancés et tirer pleinement parti de votre Shield I2C 16 servomoteurs.
Extensions et projets possibles
- Empiler plusieurs shields pour piloter jusqu’à 1024 servomoteurs grâce à la configuration des adresses I2C.
- Créer des robots articulés plus complexes : bras robotisés, robots humanoïdes ou pantographes.
- Enregistrer et analyser les positions des servos sur la carte microSD pour automatiser des séquences ou répéter des mouvements.
- Intégrer des capteurs (distance, pression, inclinaison) pour piloter vos servos en temps réel.
Conseils pratiques
- Vérifiez toujours l’alimentation des servomoteurs afin de ne pas surcharger l’ESP32.
- Commencez par de petits projets pour bien comprendre les limites de votre shield.
- Documentez vos expériences et partagez vos projets pour inspirer la communauté.
En explorant ces extensions, vous maximisez l’utilisation de votre Shield servomoteurs ESP32 et créez des projets robotiques avancés tout en gardant un contrôle précis sur vos servos.
