Leçons · Leçon A3 · Actionneurs et moteurs · 35 min
Les moteurs à courant continu et les ponts en H
Comprends à quoi sert un pont en H, puis fais tourner un petit moteur à courant continu en avant, en arrière, avec frein ou en roue libre, à la vitesse que tu choisis, avec une carte DRV8833 et sa propre alimentation. Environ 35 minutes, avec des interrupteurs sur lesquels tu peux cliquer.
Inverser un moteur
Un petit moteur à courant continu a deux fils. Branche-le sur une pile : il tourne dans un sens. Échange les deux fils : il tourne dans l’autre sens [4].
Pour qu’un robot recule, il faut donc échanger ces fils, plusieurs fois par seconde si tu veux, sans les toucher. C’est le travail d’un pont en H : un circuit qui relie le moteur à l’alimentation dans un sens ou dans l’autre, sur commande. C’est la même idée que d’échanger les fils, réalisée avec des interrupteurs [4].
Dans cette leçon, tu vas :
- voir comment quatre interrupteurs peuvent inverser un moteur,
- découvrir la carte DRV8833, qui contient deux ponts en H,
- faire tourner un moteur en avant, en arrière, avec frein ou en roue libre, et choisir sa vitesse.
Le pont en H : quatre interrupteurs
Dessine le moteur au milieu. Mets un interrupteur entre chaque fil du moteur et le + de l’alimentation, et un interrupteur entre chaque fil du moteur et le −. Ça fait quatre interrupteurs, et le dessin ressemble à la lettre H, avec le moteur comme barre transversale.
- Ferme les interrupteurs en haut à gauche et en bas à droite : le courant traverse le moteur de gauche à droite.
- Ferme les interrupteurs en haut à droite et en bas à gauche : le courant traverse le moteur de droite à gauche. Le moteur tourne dans l’autre sens.
La combinaison interdite. Suis le fil, plutôt que d’apprendre une règle. Si les interrupteurs en haut à gauche et en bas à gauche sont fermés tous les deux, le + va droit au −, à travers deux interrupteurs fermés et sans moteur. Rien ne limite le courant : c’est un court-circuit. C’est pareil pour les deux interrupteurs de droite. Un bon pilote est conçu pour que tu ne puisses pas demander ça.
Une carte pilote cache les quatre interrupteurs. La DRV8833 contient deux ponts en H complets, chacun fait de deux moitiés, et chaque moitié a sa propre broche d’entrée [1]. Tu choisis parmi quatre comportements, et chaque combinaison des deux entrées est listée avec un résultat défini [3].
Clique sur les interrupteurs dans le widget ci-dessous et regarde le moteur.
Simulation : des interrupteurs à cliquer, pas un vrai circuit.
Aucun chemin fermé par le moteur : il est lâché et ralentit doucement.
Clique ou touche un interrupteur pour le fermer ou l’ouvrir. Tab passe d’un interrupteur à l’autre, Espace bascule.
Le DRV8833 ne te laisse jamais choisir une paire interdite : ses deux entrées choisissent seulement parmi les quatre comportements permis.
Voici l’état de départ : les commandes ont besoin de JavaScript.
La carte DRV8833
La carte DRV8833 d’Adafruit réunit deux ponts en H : elle peut piloter deux moteurs à courant continu ou un moteur pas à pas [1]. Voici ce qui compte pour un petit moteur :
- Le courant. Elle est prévue pour des moteurs qui demandent environ 1,2 A ou moins par canal. La carte est réglée pour limiter chaque canal à environ 1 A [1][2].
- L’alimentation du moteur. Elle arrive sur la borne à vis, et sa tension U peut aller de 2,7 V à 10,8 V [1][2]. Le côté + de la borne a une protection simple contre les erreurs de polarité, mais pas la broche VM nue [2] : amène donc l’alimentation du moteur par la borne à vis.
- Le niveau logique. Les entrées acceptent 2,7 V ou plus : les signaux à 3,3 V de l’ESP32 fonctionnent même si les moteurs tournent avec une tension plus haute [1][2].
- Les entrées. AIN1 et AIN2 commandent le moteur A, BIN1 et BIN2 le moteur B [2]. Nous utilisons le moteur A.
- La broche de veille. SLP est tirée vers le bas à l’intérieur de la carte : la puce dort tant que tu ne mets pas SLP à l’état haut [2].
- La protection. La puce contient des diodes qui absorbent le « coup de fouet » que fait un moteur quand on le coupe : tu n’as pas à en ajouter [1]. Nous retrouverons ce coup de fouet dans la leçon C2.
- GND est commun à la logique et à l’alimentation du moteur [2].
La carte a aussi une broche de défaut (FLT) [2]. Nous la laissons non connectée dans cette leçon.
Quatre comportements, et la vitesse
Pour un moteur, les deux entrées donnent quatre comportements [3] :
| AIN1 | AIN2 | Ce que fait le moteur |
|---|---|---|
| bas | bas | roue libre : le moteur est lâché et ralentit doucement |
| haut | bas | avant |
| bas | haut | arrière |
| haut | haut | frein : le moteur est retenu |
Quel sens est « avant » dépend de la façon dont tu as câblé le moteur. Échanger ses deux fils l’inverse [3].
La vitesse. Pour aller moins vite, garde une entrée à l’état bas et allume et éteins l’autre rapidement : c’est du PWM, l’astuce de la leçon A2 [3]. Plus la part « allumée » est longue, plus le moteur va vite. Avec AIN1 comme broche PWM, le moteur va en avant ; avec AIN2, il va en arrière [3].
Roue libre ou frein. Le tableau offre deux façons de s’arrêter. La roue libre coupe l’alimentation du moteur et le laisse ralentir [7]. Le frein utilise l’électricité que produit le moteur lui-même en tournant, ce qui le ralentit vite [7]. Adafruit appelle les deux façons d’utiliser le PWM « décroissance rapide » (l’entrée est basse pendant la partie éteinte, donc le moteur est en roue libre pendant ce temps) et « décroissance lente » (l’entrée est haute pendant la partie éteinte, donc le moteur est freiné pendant ce temps) [3][7]. Nous utilisons la première, la plus simple.
Un rappel de la leçon A2 : le rapport cyclique est la part de chaque période pendant laquelle le signal est allumé.
Alimentation et câblage : reste petit
Les moteurs sont gourmands et bruyants. Les règles :
- Le moteur a sa propre alimentation. Le guide de la DRV8833 explique que l’alimentation du moteur devient bruyante, et conseille des alimentations séparées quand il y a des parties sensibles [2]. La leçon moteur d’Adafruit dit aussi qu’un moteur plus puissant doit avoir une alimentation séparée [5]. Pour de petits moteurs TT prévus pour 3 à 6 V [6], un boîtier de 4 piles AA NiMH avec interrupteur donne 4,8 V (voir les leçons E4 et A2) [9]. N’alimente pas le moteur depuis les broches de l’ESP32.
- Relie les masses. La masse de l’alimentation du moteur va au GND du pilote et à une broche
GNDde l’ESP32 [2][5]. Sans cela, les signaux n’ont pas de zéro commun. - Petits moteurs seulement. Cette carte convient à des moteurs qui demandent environ 1,2 A ou moins [1]. Un moteur TT consomme environ 150 mA à vide sous 4,5 V, mais environ 1,2 A quand il est calé [6] : c’est tout le courant pour lequel la carte est prévue. C’est la limite de courant de la carte, environ 1 A par canal, qui la protège, et Adafruit recommande ce pilote pour les moteurs TT justement pour ça [2][6]. Ne ferme jamais avec de la soudure les deux pastilles (cavaliers) au dos de la carte : cela désactive la limite [2]. Et ne bloque jamais la roue quand le moteur est alimenté : le moteur et le boîtier de piles chauffent quand même. Un moteur plus gros qu’un TT ou qu’un moteur de loisir semblable demande un autre pilote, et sort de cette leçon.
- Vérifie deux fois la polarité avant d’allumer, et câble tout avec l’alimentation éteinte.
Le câblage : AIN1 sur la GPIO 25, AIN2 sur la GPIO 26, SLP sur la GPIO 33, un bouton sur la GPIO 27 (autre patte à GND), le moteur sur les deux sorties du canal A. Utilise les repères imprimés sur ta carte.
Commander le moteur
Câble selon le schéma. Garde le moteur libre de tourner, avec la roue en l’air ou sans roue du tout, et allume le boîtier de piles seulement quand tu as tout vérifié.
L’ESP32 a un matériel dédié pour générer du PWM, le périphérique LEDC [8]. Nous utilisons les deux mêmes fonctions que dans la leçon A2 : ledcAttach() et ledcWrite(). Ici, un canal est réglé pour chaque entrée, à 1000 impulsions par seconde et 8 bits : le rapport cyclique va donc de 0 à 255 [8].
// Tinker Mission, leçon A3 : commander un petit moteur à courant continu avec une carte DRV8833 (avant, roue libre, arrière, frein)
// Câblage (le moteur a sa PROPRE alimentation : ne la prends jamais sur la carte ESP32) :
// DRV8833 AIN1 -> GPIO 25
// DRV8833 AIN2 -> GPIO 26
// DRV8833 SLP -> GPIO 33 (broche de mise en veille : HIGH = pilote réveillé)
// DRV8833 GND -> une broche GND de l'ESP32 ET le - de l'alimentation du moteur (masse commune)
// + de l'alimentation du moteur -> la borne à vis + du DRV8833 (puissance moteur, 2,7 à 10,8 V ; par ex. 4 piles AA NiMH = 4,8 V)
// - de l'alimentation du moteur -> la borne à vis - (GND) du DRV8833
// (utilise les repères imprimés sur TA carte, et vérifie deux fois la polarité avant d'allumer)
// Fils du moteur -> les deux bornes OUT à vis du canal A (AOUT1 et AOUT2) ; les échanger ne fait que changer le sens
// Bouton : une patte à la GPIO 27, la patte diagonalement opposée à GND (pas de résistance nécessaire)
// Chaque appui passe au mode suivant : avant, roue libre, arrière, frein, avant, et ainsi de suite.
// Avant et arrière tournent à la vitesse SPEED (un nombre de 0 à 255) avec le matériel PWM de la carte (LEDC).
const int AIN1_PIN = 25;
const int AIN2_PIN = 26;
const int SLEEP_PIN = 33;
const int BUTTON_PIN = 27;
const int PWM_FREQ = 1000; // 1000 impulsions par seconde
const int PWM_BITS = 8; // rapport cyclique de 0 (toujours éteint) à 255 (toujours allumé)
const int MAX_DUTY = 255;
const int SPEED = 170; // 0 à 255 ; environ les deux tiers de la pleine vitesse
enum Mode { FORWARD, COAST, REVERSE, BRAKE, MODE_COUNT };
const char* MODE_NAMES[] = { "forward", "coast", "reverse", "brake" };
Mode mode = COAST;
bool wasPressed = false;
// Écrit les deux niveaux d'entrée (0 = bas, 255 = haut, entre les deux = PWM).
void setInputs(int in1, int in2) {
ledcWrite(AIN1_PIN, in1);
ledcWrite(AIN2_PIN, in2);
}
void applyMode(Mode m) {
switch (m) {
case FORWARD: setInputs(SPEED, 0); break; // IN1 = PWM, IN2 = bas
case REVERSE: setInputs(0, SPEED); break; // IN1 = bas, IN2 = PWM
case COAST: setInputs(0, 0); break; // les deux bas : le moteur est libre
case BRAKE: setInputs(MAX_DUTY, MAX_DUTY); break; // les deux à l'état haut : le moteur est retenu
default: break;
}
Serial.print("mode: ");
Serial.print(MODE_NAMES[m]);
if (m == FORWARD || m == REVERSE) {
Serial.print(", speed ");
Serial.print(SPEED * 100 / MAX_DUTY);
Serial.print(" %");
}
Serial.println();
}
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(SLEEP_PIN, OUTPUT);
ledcAttach(AIN1_PIN, PWM_FREQ, PWM_BITS); // broche, fréquence, résolution (bits)
ledcAttach(AIN2_PIN, PWM_FREQ, PWM_BITS);
applyMode(COAST); // départ avec le moteur libre
digitalWrite(SLEEP_PIN, HIGH); // réveille le pilote
}
void loop() {
bool pressed = (digitalRead(BUTTON_PIN) == LOW);
if (pressed && !wasPressed) { // vient d'être appuyé (pas maintenu)
mode = (Mode)((mode + 1) % MODE_COUNT);
applyMode(mode);
}
wasPressed = pressed;
delay(20); // masque aussi les rebonds du contact
}
Télécharger le dossier du croquis (.zip)
Ouvre le moniteur série à 115200 baud. Chaque appui passe au mode suivant et affiche son nom.
Comment le lire :
setInputs(in1, in2)écrit une valeur de rapport cyclique sur chaque entrée : 0 veut dire bas, 255 veut dire haut, et un nombre entre les deux veut dire PWM.- L’avant, c’est
setInputs(SPEED, 0): AIN1 reçoit le PWM, AIN2 reste bas, comme dans le tableau [3]. L’arrière les échange. - La roue libre, c’est
setInputs(0, 0). Le frein, c’estsetInputs(MAX_DUTY, MAX_DUTY). - Les modes vont dans l’ordre avant, roue libre, arrière, frein : on ne demande jamais au moteur de passer directement d’un sens à l’autre. C’est notre choix, pour que tu voies chaque comportement.
SLEEP_PINreste basse jusqu’à ce quesetup()ait réglé le mode, puis passe à l’état haut : le pilote se réveille avec le moteur libre [2].- Le bouton fonctionne sur front, comme dans la leçon A2 : un seul déplacement par appui.
Essaie tes propres changements
Change une seule chose, téléverse, observe.
- Une autre vitesse. Mets
SPEEDà 100, puis à 255. Le moteur change-t-il de vitesse en proportion ? À petite valeur, démarre-t-il seulement ? (Un essai avec un moteur TT a montré qu’il ne démarrait pas avant un certain niveau, et qu’à basse vitesse il se comportait autrement qu’à haute vitesse [7].) - Échange les fils. Alimentation éteinte, échange les deux fils du moteur. Qu’est-ce qui change ? [3]
- Frein ou roue libre ? Fais tourner le moteur en avant, puis appuie pour la roue libre : compte combien de temps la roue met à s’arrêter. Fais pareil avec le frein. Lequel arrête le plus vite ? [7]
- Une rampe. Remplace
SPEEDfixe par une boucle qui va de 0 à 255 en ajoutant 1 toutes les 10 ms, comme dans l’exemple d’Adafruit [3]. Pourquoi une rampe lente est-elle plus douce ? - Deux moteurs. Ajoute le deuxième canal (BIN1 et BIN2 sur deux autres broches, le moteur B sur ses sorties) et fais un virage de char : une roue en avant, une roue en arrière.
Quand ça ne marche pas
- Rien ne bouge, même pas un bourdonnement. Vérifie que SLP est à l’état haut : sans cela, la puce reste inactive [2]. Vérifie que l’alimentation du moteur est allumée et que sa masse est reliée à celle de la carte [2][5].
- Le moteur tourne dans le mauvais sens. Échange ses deux fils [3], ou échange les deux modes dans le programme.
- Il bourdonne ou sursaute à basse vitesse. Le moteur peut avoir besoin d’une poussée plus forte pour démarrer : augmente
SPEED[7]. - Le pilote chauffe, ou le moteur s’arrête puis repart. La carte limite le courant de chaque canal, et elle se coupe en cas de surchauffe ou de courant trop fort ; sa broche de défaut (FLT, non connectée ici) le signale [2]. Éteins, vérifie que le moteur n’est pas bloqué, et prends un moteur plus petit si besoin [1].
- Il ne tourne que dans un sens. Un des deux fils d’entrée est sur la mauvaise broche ou mal serré. Vérifie les GPIO 25 et 26.
- « ledcAttach was not declared » à la compilation. Ton paquet de cartes esp32 est trop ancien. Mets à jour « esp32 by Espressif Systems » vers la version 3 ou plus : ledcAttach() est arrivée avec la version 3 [10].
- Rien dans le moniteur série. Règle-le sur 115200 baud, comme
Serial.begin(115200).
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Sur la carte DRV8833, les deux entrées d’un canal (AIN1 et AIN2) sont toutes les deux à l’état haut. Que fait le moteur ?
- Il tourne en avant à pleine vitesse
- Il est retenu, comme avec un frein
- Il tourne en arrière
Ton programme tourne, les entrées changent, mais le moteur ne bouge jamais. Que vérifier en premier ?
- Que la broche SLP est maintenue à l’état haut, car la carte dort par défaut
- Que les fils du moteur ont les bonnes couleurs
- Que le moniteur série est réglé sur 9600 baud
Un petit moteur TT est bloqué (calé) alors qu’il est alimenté en 4,5 V. Quel courant consomme-t-il environ, par rapport aux 1,2 A par canal pour lesquels la carte est prévue ?
- Environ 0,15 A, bien moins que la valeur prévue
- Environ 1,2 A, juste à la valeur prévue
- Environ 12 A, dix fois la valeur prévue
Voir la réponse
Environ 1,2 A, juste à la valeur prévue. Adafruit a mesuré environ 1,2 A pour un moteur TT calé à 4,5 V, contre environ 150 mA à vide [6]. La carte est prévue pour environ 1,2 A au maximum par canal, et elle est réglée pour limiter chaque canal à environ 1 A, c’est ce qui la protège ici [1][2]. Ne retiens quand même jamais la roue avec la main quand le moteur est alimenté.
En bref
- Un pont en H utilise quatre interrupteurs pour relier un moteur à l’alimentation dans un sens ou dans l’autre. Ne ferme jamais les deux interrupteurs d’un même côté : c’est un court-circuit.
- La carte DRV8833 contient deux ponts en H : deux entrées par moteur donnent la roue libre, l’avant, l’arrière ou le frein [3], et la broche SLP doit être à l’état haut [2].
- Mets le PWM sur une entrée et garde l’autre basse pour choisir la vitesse [3].
- Le moteur a sa propre alimentation (de 2,7 à 10,8 V pour cette carte), les masses sont reliées, et le moteur est petit, prévu pour environ 1,2 A ou moins [1][2].
Prochaine étape : M3, les mécanismes, pour transformer un moteur qui tourne en mouvement utile.
Sources
Voir les 10 sources
- Adafruit, « Adafruit DRV8833 DC/Stepper Motor Driver Breakout Board » (référence 3297) (deux ponts en H complets, soit quatre demi-ponts ; jusqu’à 1,2 A par canal ; alimentation moteur de 2,7 V à 10,8 V ; limitation de courant réglée à 1 A ; pic de 2 A pendant un court instant si la limitation est désactivée ; diodes de roue libre intégrées ; deux entrées numériques par pont en H, une pour chaque moitié ; PWM sur une entrée pour la vitesse ; une logique de 2,7 V ou plus fonctionne avec une logique 3,3 V ; protection de polarité sur l’entrée de tension moteur) — https://www.adafruit.com/product/3297
- Adafruit, « Adafruit DRV8833 DC/Stepper Motor Driver Breakout Board », « Pinouts » (Vmotor de 2,7 V à 10,8 V et bruyante, séparer les alimentations pour les parties sensibles au bruit ; borne à vis, broche + protégée contre la polarité, broche VM non protégée ; GND commun à la logique et au moteur ; entrées AIN1/AIN2 et BIN1/BIN2, niveau logique de 2,7 V ou plus ; mettre en PWM la broche normalement haute ; sortie de défaut FLT à l’état bas en cas d’arrêt thermique ou de surintensité ; SLP tirée vers le bas par une résistance interne de 500 kΩ, donc puce inactive tant qu’elle n’est pas mise à l’état haut ; limite par défaut de 1 A par canal ; limite de courant = 0,2 V / RSENSE, deux résistances de 0,2 Ω donnent 1 A par canal ; souder les deux cavaliers au dos désactive la limitation) — https://learn.adafruit.com/adafruit-drv8833-dc-stepper-motor-driver-breakout-board/pinouts
- Adafruit, « Adafruit DRV8833 DC/Stepper Motor Driver Breakout Board », « Arduino DC Motor » (câblage avec SLP et alimentation moteur externe ; l’ordre des fils du moteur ne change que le sens ; table 1 de logique du pont en H : 00 roue libre/décroissance rapide, 01 arrière, 10 avant, 11 frein/décroissance lente ; modes PWM : décroissance rapide et lente ; exemple de rampe de rapport cyclique avec un pas de 10 ms) — https://learn.adafruit.com/adafruit-drv8833-dc-stepper-motor-driver-breakout-board/arduino-dc-motor
- Adafruit, « Arduino Lesson 15. DC Motor Reversing », « An Experiment » (échanger les fils du moteur inverse le sens ; les broches de commande font l’équivalent de cet échange ; les deux entrées basses ou les deux hautes arrêtent le moteur) — https://learn.adafruit.com/adafruit-arduino-lesson-15-dc-motor-reversing/an-experiment
- Adafruit, « Arduino Lesson 15. DC Motor Reversing », « L293D » (un moteur plus puissant a une alimentation séparée, et la masse de la seconde alimentation est reliée à la masse de l’Arduino) — https://learn.adafruit.com/adafruit-arduino-lesson-15-dc-motor-reversing/lm293d
- Adafruit, « DC Gearbox Motor - TT Motor - 200RPM - 3 to 6VDC » (référence 3777) (alimenté de 3 V à 6 V ; à 4,5 V, un exemplaire consommait 155 mA à vide et 1,2 A quand il était calé ; 1,1 A calé à 3 V et 1,5 A à 6 V ; Adafruit recommande le DRV8833 pour ces moteurs car il peut limiter le courant, le courant de calage pouvant devenir élevé) — https://www.adafruit.com/product/3777
- Adafruit, « Improve Brushed DC Motor Performance » (décroissance rapide : le moteur est en roue libre quand on le coupe ; décroissance lente : freinage avec le courant produit par le moteur lui-même, et la DRV8833 freine activement en décroissance lente ; un essai avec un moteur TT : un seuil de démarrage en décroissance rapide, et un comportement différent à basse vitesse en décroissance lente ; essai du moteur TT sur la page Motor Performance Charts) — https://learn.adafruit.com/improve-brushed-dc-motor-performance/current-decay-mode
- Espressif, documentation Arduino-ESP32, « LED Control (LEDC) » (ledcAttach(pin, freq, resolution) avec une résolution de 1 à 14 bits, 1 à 20 bits pour l’ESP32 ; ledcWrite(pin, duty) fixe le rapport cyclique ; exemple à 1000 Hz et 8 bits) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/ledc.html
- Adafruit, « Adafruit NeoPixel Überguide », « Powering NeoPixels » (quatre piles NiMH dans un support de 4 donnent 4,8 V ; quatre piles alcalines donnent 6 V) — https://learn.adafruit.com/adafruit-neopixel-uberguide/powering-neopixels
- Espressif, documentation Arduino-ESP32, « Migration from 2.x to 3.0 », « LEDC » (l’ancienne API LEDC, ledcSetup et ledcAttachPin, a été supprimée et remplacée par ledcAttach() dans la version 3.0) — https://docs.espressif.com/projects/arduino-esp32/en/latest/migration_guides/2.x_to_3.0.html