English

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 :

  1. voir comment quatre interrupteurs peuvent inverser un moteur,
  2. découvrir la carte DRV8833, qui contient deux ponts en H,
  3. faire tourner un moteur en avant, en arrière, avec frein ou en roue libre, et choisir sa vitesse.
Inverse les deux fils, le moteur tourne dans l’autre sens Un petit moteur à courant continu avec une pile, dessiné deux fois côte à côte. a : le fil rouge va du plus de la pile à la languette A du moteur, le fil noir du moins à la languette B ; la flèche sur la roue tourne dans le sens des aiguilles d’une montre. b : les fils sont inversés, rouge du plus vers la languette B, noir du moins vers la languette A ; la flèche tourne dans l’autre sens. Un pont en H fait cette inversion avec des interrupteurs, sur commande. FIG. 1 — UN MOTEUR, DEUX SENSaRouge vers A+pileMABrouge : + → Anoir : − → Bsens horairebFils inversés+pileMABrouge : + → Bnoir : − → Asens antihoraireUn pont en H fait cette inversion avec des interrupteurs, sur commande.
Touche le schéma pour l’ouvrir en plein écran.

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.

Clique sur les quatre interrupteurs (interactif)
Clique sur les quatre interrupteurs (interactif) Simulation interactive, pas un vrai circuit. Un pont en H : la ligne plus en haut, la ligne moins en bas, quatre interrupteurs sur lesquels cliquer, S1 en haut à gauche, S2 en haut à droite, S3 en bas à gauche, S4 en bas à droite, et le moteur au milieu ; sa roue est dessinée à droite. Ferme S1 et S4 : le chemin du courant est dessiné en orange et la roue tourne en marche avant. Ferme S2 et S3 : elle tourne en marche arrière. Ferme les deux du bas ou les deux du haut : frein. Tous ouverts : roue libre. Ferme deux interrupteurs du même côté, S1 et S3 ou S2 et S4 : un chemin de court-circuit rouge apparaît, le pont est grisé et le texte dit que cette combinaison est interdite. simulation, pas un vrai circuit+−S1S3S2S4Mroue

Simulation : des interrupteurs à cliquer, pas un vrai circuit.

Étatroue libre

Aucun chemin fermé par le moteur : il est lâché et ralentit doucement.

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.

Quatre interrupteurs autour du moteur : un H En haut : le pont en H dessiné comme un H. La ligne plus en haut, la ligne moins en bas, un interrupteur sur chacun des quatre bras : S1 en haut à gauche, S2 en haut à droite, S3 en bas à gauche, S4 en bas à droite ; le moteur est la barre du milieu. En dessous, trois petites copies. a, marche avant : S1 et S4 fermés, le courant va du plus par S1, traverse le moteur de gauche à droite, passe par S4 vers le moins, dessiné en bande orange. b, marche arrière : S2 et S3 fermés, le courant traverse le moteur de droite à gauche. c, interdit : S1 et S3 fermés : le plus va droit au moins par deux interrupteurs et sans moteur, un court-circuit, dessiné en chemin rouge épais en pointillés avec une croix. FIG. 2 — LE PONT EN H+−S1S3S2S4MTous les interrupteurs ouverts : le moteur est libre.aAvant : S1 + S4+−S1S3S2S4MbArrière : S2 + S3+−S1S3S2S4McInterdit : S1 + S3+−S1S3S2S4Mcourt-circuit !
Touche le schéma pour l’ouvrir en plein écran.

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.

La carte DRV8833 : le rôle de chaque broche Vue de dessus d’une carte de commande de moteur DRV8833, notre propre dessin avec les noms de broches de la carte d’Adafruit. Côté puissance : le bornier à vis VMotor, plus et moins, alimentation des moteurs de 2,7 à 10,8 V, protégé contre une erreur de polarité sur son plus ; la broche VM nue n’est pas protégée ; GND est commun à la logique et aux moteurs. Côté logique : AIN1 et AIN2 pour le moteur A, BIN1 et BIN2 pour le moteur B, entrées de 2,7 V ou plus ; SLP, veille, tirée vers le bas sur la carte : haut veut dire réveillée ; FLT, la sortie de défaut, pas utilisée dans cette leçon. Sorties moteur : AOUT1 et AOUT2 pour le moteur A, BOUT1 et BOUT2 pour le moteur B. Chaque canal est limité à environ 1 A. FIG. 3 — LA CARTE DRV8833DRV8833+−VMotorVMGNDAIN1AIN2BIN1BIN2SLPFLTAOUT1AOUT2BOUT2BOUT1moteur Amoteur Bsorties moteurpuissanceentrées : 2,7 V ou plusAIN → moteur A, BIN → moteur BSLP : haut = réveilléeFLT : sortie de défaut,pas utilisée ici2,7 à 10,8 Valim. des moteurscôté + protégécontre l’inversionbroche VM : pas protégée,utilise le bornierGND : commun à la logique et aux moteursenviron 1 Apar canalDessin maison : vérifie les noms imprimés sur ta carte.
Touche le schéma pour l’ouvrir en plein écran.

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é.

Deux entrées, quatre comportements, et la vitesse En haut, la table de vérité en quatre petits cadres, chacun avec les deux niveaux d’entrée dessinés en barres haut ou bas et le résultat sur la roue. AIN1 bas, AIN2 bas : roue libre, la roue tourne librement et ralentit. AIN1 haut, AIN2 bas : marche avant, une flèche dans le sens horaire. AIN1 bas, AIN2 haut : marche arrière, une flèche dans l’autre sens. Les deux hauts : frein, un cadenas : le moteur est tenu. En bas, la vitesse : un signal PWM sur AIN1 avec AIN2 bas. À 30 % de rapport cyclique, la roue tourne lentement, une flèche courte ; à 80 %, elle tourne vite, une flèche longue. Le sens de la marche avant dépend du câblage du moteur. FIG. 4 — LES QUATRE COMPORTEMENTSroue libreAIN1basAIN2baslibre, ralentitavantAIN1hautAIN2bastourne dans un sensarrièreAIN1basAIN2hauttourne dans l’autrefreinAIN1hautAIN2hauttenu immobilesVitesse : PWM sur AIN1, AIN2 bas30 %AIN1AIN2lent80 %AIN1AIN2rapide
Touche le schéma pour l’ouvrir en plein écran.

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 GND de 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.

Câblage A3 : DRV8833 sur 25, 26, 33, moteur sur son propre bloc 4,8 V, GND commun Deux cadres. a, vue de montage. La DevKitC est hors de la plaque, en dessous, USB à gauche, alimentée par son câble USB ; des fils à embout femelle vont sur ses broches du haut. La carte DRV8833 est à cheval sur la rainure centrale de la plaque, rangées 5 à 19, notre propre dessin avec les noms de la carte d’Adafruit. Ses broches logiques sont en colonne e : VM rangée 6, GND rangée 7, AIN1 rangée 8, AIN2 rangée 9, BIN1 rangée 10, BIN2 rangée 11, SLP rangée 12, FLT rangée 13 ; ses sorties moteur en colonne f : AOUT1 rangée 15, AOUT2 rangée 16. 1 jaune, GPIO 25 vers AIN1 ; 2 vert, GPIO 26 vers AIN2 ; 3 blanc, GPIO 33 vers SLP. 4 noir, la rangée GND de la carte vers le rail moins du bas. 5 noir, un fil épais étiqueté GND commun, d’une broche GND de la DevKitC vers le rail moins. Le bouton est à cheval sur la rainure en rangées 1 et 3 : 6 bleu, GPIO 27 vers la rangée 3 ; 7 noir, rangée 1 vers le rail moins. Les deux fils du moteur vont en rangées 15 et 16, AOUT1 et AOUT2. Un boîtier de 4 piles AA NiMH, 4,8 V, avec interrupteur, éteint pendant le câblage : son fil rouge au plus du bornier à vis, son fil noir au moins, qui est le GND de la carte. Une ligne rouge en pointillés part de la broche 3V3, barrée : n’alimente jamais le moteur par la 3V3. b, schéma : GPIO 25 vers AIN1, GPIO 26 vers AIN2, GPIO 33 vers SLP. Le moteur entre AOUT1 et AOUT2. La pile, 4 NiMH, 4,8 V, avec son interrupteur, alimente le bornier VMotor. Un trait épais relie le moins de la pile, le GND du DRV8833 et le GND de l’ESP32 : GND commun. Le bouton est entre la GPIO 27 et GND. Une ligne en pointillés barrée va de la 3V3 à l’alimentation du moteur. FIG. 5 — CÂBLAGE, MOTEUR SUR SA PROPRE ALIMENTATIONaVue de montage+−−+jihgfedcba15101520VMGNDAIN1AIN2BIN1BIN2SLPFLTAOUT1AOUT2BOUT2BOUT1carte DRV8833+−4 × NiMH AA, 4,8 V++++ONOFFMmoteur(TT, 3 à 6 V)boutonENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GNDGND commun3V3 → moteur : jamaisGND27262533GNDGNDcâble USB :alimente lacarte12345671jaune : GPIO 25 → AIN1 (rangée 8)2vert : GPIO 26 → AIN2 (rangée 9)3blanc : GPIO 33 → SLP (rangée 12)4noir : GND du DRV8833 (rangée 7) → rail −5noir : broche GND → rail − : GND commun6bleu : GPIO 27 → bouton (rangée 3)7noir : bouton, autre patte (rangée 1) → rail −Les fils du bloc vont au bornier à vis : rouge au +, noir au − (le GND de la carte). Fils du moteur : rangées 15 et 16.L’alimentation du moteur ne touche jamais une broche de la DevKitC. Bloc éteint pendant le câblage ; vérifie deux fois la polarité.bSchémaESP323V325263327GNDDRV8833AIN1AIN2SLPGNDVMotorAOUT1AOUT2M+4 × NiMH4,8 Vinterr.GND communboutonjamais : la 3V3 n’alimente pas le moteur
Touche le schéma pour l’ouvrir en plein écran.

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’est setInputs(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_PIN reste basse jusqu’à ce que setup() 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.
Un appui, le mode suivant Les quatre modes du croquis en boucle de quatre stations, reliées par des flèches marquées appui : avant, puis roue libre, puis arrière, puis frein, puis retour à avant. Sous chaque station, les deux entrées : avant, AIN1 PWM 170 et AIN2 bas ; roue libre, les deux bas, 0 et 0 ; arrière, AIN1 bas et AIN2 PWM 170 ; frein, les deux hauts, 255 et 255. Le croquis démarre en roue libre. Le moteur ne passe jamais directement d’un sens à l’autre. FIG. 6 — LA BOUCLE DES MODESavantAIN1PWM 170AIN20AIN1 = PWM, AIN2 basroue libreAIN10AIN20les deux basarrièreAIN10AIN2PWM 170AIN1 bas, AIN2 = PWMfreinAIN1255AIN2255les deux hautsappuiappuiappuiappuidépartPWM 170 sur 255 ≈ 66 %. Jamais directement d’un sens à l’autre.
Touche le schéma pour l’ouvrir en plein écran.

Essaie tes propres changements

Change une seule chose, téléverse, observe.

  1. 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].)
  2. Échange les fils. Alimentation éteinte, échange les deux fils du moteur. Qu’est-ce qui change ? [3]
  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]
  4. Une rampe. Remplace SPEED fixe 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 ?
  5. 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.

  1. 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
    Voir la réponse

    Il est retenu, comme avec un frein. Dans la table de logique du pilote, les deux entrées à l’état haut correspondent au frein [3]. Les deux entrées à l’état bas, c’est la roue libre, et une entrée haute avec l’autre basse, c’est l’avant ou l’arrière [3].

  2. 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
    Voir la réponse

    Que la broche SLP est maintenue à l’état haut, car la carte dort par défaut. La broche de veille est tirée vers le bas à l’intérieur de la carte : la puce ne fait rien tant que tu ne la mets pas à l’état haut [2]. L’ordre des deux fils du moteur ne change que le sens [3].

  3. 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
  1. 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
  2. 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
  3. 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
  4. 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
  5. 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
  6. 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
  7. 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
  8. 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
  9. 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
  10. 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

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.