Driver A4988 et NEMA 17 avec Arduino : Vref, micropas et code

Piloter un NEMA 17 avec l'A4988 est le moyen le moins cher d'apporter à ton propre projet le mouvement précis des imprimantes 3D, des fraiseuses CNC et des graveurs laser. L'A4988 est un driver de moteur pas à pas bipolaire fabriqué par Allegro et vendu sur un module grand comme le bout d'un doigt : chaque impulsion STEP envoyée par l'Arduino fait avancer le moteur d'un pas, la broche DIR choisit le sens, et le driver maintient le courant dans les bobines à la valeur que tu as réglée. Autrement dit, pour faire tourner le moteur, il te suffit de deux broches et d'une alimentation entre 8 et 35 V.

Dans ce guide, tu vas apprendre comment fonctionne l'A4988, comment trouver les bobines d'un NEMA 17 au multimètre, comment le câbler et pourquoi il faut un condensateur de 100 µF sur l'alimentation. Ensuite, nous passerons à l'étape la plus critique, le réglage du courant avec Vref, avec la formule et la mesure au multimètre pas à pas. Au programme aussi : les micropas avec les broches MS1–MS3, un premier code sans bibliothèque, une accélération douce avec AccelStepper, le CNC Shield, du code pour ESP32 et Raspberry Pi Pico, la chauffe et le dissipateur, une comparaison avec le DRV8825 et le TMC2208, et les solutions au fameux problème « le moteur vibre mais ne tourne pas ».

Qu'est-ce que l'A4988 et comment fonctionne-t-il ?

L'A4988 contient deux ponts en H complets (un par bobine), un traducteur (translator) et un circuit de régulation du courant. Le traducteur transforme chaque front LOW→HIGH sur la broche STEP en la bonne séquence de courant pour les bobines ; tu n'as donc pas à calculer l'ordre des bobines dans ton code. La régulation du courant fonctionne par découpage (chopper) : le driver mesure en permanence le courant de chaque bobine à travers une petite résistance de mesure (Rs) et coupe la sortie un très court instant dès que le courant atteint la limite réglée. C'est pourquoi le courant reste à une valeur sûre même si tu alimentes le moteur bien au-dessus de sa tension nominale, par exemple en 12 ou 24 V. La puce est aussi protégée contre la surchauffe, la sous-tension, les courts-circuits de la charge et les courts-circuits à la masse.

Moteur pas à pas NEMA 17 : caractéristiques et identification des bobines

NEMA 17 n'est pas un modèle de moteur mais un standard de taille pour les moteurs dont la face avant mesure 42 × 42 mm ; l'intérieur dépend de la longueur du corps et du fabricant. Le 17HS4401, le modèle le plus courant dans les projets amateurs, fait 200 pas par tour (1,8°), avec un courant nominal de 1,7 A par phase, une résistance de bobine d'environ 1,5 Ω et un couple de maintien d'environ 40 N·cm. La tension indiquée sur son étiquette n'est que de 1,7 A × 1,5 Ω ≈ 2,6 V, mais ne te laisse pas tromper : comme l'A4988 limite lui-même le courant, le moteur est alimenté en 12–24 V. Une tension plus élevée fait monter le courant plus vite à chaque pas, et le moteur perd moins de couple à haute vitesse. Si tu te demandes en quoi il diffère des petits moteurs unipolaires comme le 28BYJ-48, consulte 28BYJ-48 et ULN2003.

Les 4 fils du moteur appartiennent à deux bobines indépendantes, et avant de le brancher à l'A4988 tu dois savoir quels fils forment la même bobine. Sur beaucoup de modèles, noir-vert forment une bobine et rouge-bleu l'autre, mais les couleurs varient selon le fabricant ; le plus fiable est donc de mesurer :

1. Règle ton multimètre sur la mesure de résistance (Ω) ; si tu n'es pas sûr de toi, jette un œil au guide du multimètre.
2. Garde un fil fixe et mesure-le avec chacun des trois autres. Le fil qui donne 1–4 Ω est l'autre extrémité de la même bobine ; avec les deux autres, l'écran affiche un circuit ouvert (OL).
3. Les deux fils restants forment la seconde bobine et doivent donner la même résistance. Avec la résistance mesurée et le courant nominal, tu peux vérifier la tension de l'étiquette grâce au calculateur de loi d'Ohm.
4. Pas de multimètre ? Mets en contact les extrémités de deux fils et tourne l'axe à la main : s'il devient nettement plus dur à tourner, ces deux fils appartiennent à la même bobine.
5. Branche une bobine sur les broches 1A–1B de l'A4988 et l'autre sur 2A–2B. Si le moteur tourne dans le mauvais sens, il suffit d'inverser les deux fils d'une seule bobine.

Brochage de l'A4988 et schéma de câblage

Pourquoi le condensateur de 100 µF est-il indispensable ?

Les cartes A4988 ne portent que de petits condensateurs céramiques. Associés à l'inductance des câbles d'alimentation, ces condensateurs à faible ESR provoquent des pics de tension à la mise sous tension ou quand le moteur appelle brusquement du courant. Ces pics peuvent dépasser la limite de 35 V de la puce même avec une alimentation de seulement 12 V et endommager définitivement le driver. La solution est simple : place entre VMOT et GND, le plus près possible de la carte, un condensateur électrolytique d'au moins 47 µF, idéalement de 100 µF. Sa tension de service doit être nettement supérieure à celle de l'alimentation : 25 V pour du 12 V, 35 V ou 50 V pour du 24 V. Les condensateurs électrolytiques sont polarisés ; la patte longue (+) va sur VMOT et la patte courte (–), repérée par la bande sur le boîtier, va sur GND. Pour les types de condensateurs, consulte Qu'est-ce qu'un condensateur ?, et pour choisir le bon adaptateur, l'article sur l'alimentation de l'Arduino.

Régler le courant avec Vref : la formule

Le petit potentiomètre de l'A4988 règle Vref (la tension de référence), qui fixe le courant maximal du moteur. Le driver compare cette tension à celle des deux résistances de mesure (Rs) de la carte, et le courant de crête dans la bobine vaut : I = Vref / (8 × Rs). Pour trouver la Vref à régler, il suffit d'inverser la formule : Vref = I × 8 × Rs. Pour connaître Rs, lis le marquage des deux petites résistances CMS à côté de la puce : R100 signifie 0,1 Ω, R068 0,068 Ω et R050 0,05 Ω. Si tu as du mal avec ces codes, utilise le calculateur de code de résistance CMS ou l'article sur les codes des résistances CMS.

Quel courant choisir ? Le courant indiqué sur l'étiquette du moteur (1,7 A pour le 17HS4401) est un plafond à ne jamais dépasser. Sans dissipateur, l'A4988 supporte sans peine environ 1 A ; 0,8–1 A est donc un bon point de départ. Sur les cartes courantes avec des résistances R100, cela correspond à une Vref de 0,64–0,80 V. Si le moteur perd des pas en charge, augmente le courant par paliers de 0,1 A ; au-delà de 1,2 A, ajoute un dissipateur et un ventilateur sur la puce. Un courant plus élevé que nécessaire chauffe le driver et le moteur bien plus qu'il ne rend le moteur réellement plus fort.

Mesurer Vref au multimètre : pas à pas

1. Toutes alimentations coupées, débranche le moteur du driver. Le moteur n'est pas nécessaire pour mesurer Vref.
2. Alimente les broches VDD et GND de l'A4988 avec la tension logique (le 5V de l'Arduino suffit). Vref est tirée de cette tension, tu ne peux donc pas la mesurer sans VDD ; laisser VMOT branché ne pose pas de problème.
3. Règle le multimètre en tension continue (calibre 2 V ou 20 V). Pose la pointe noire sur GND et la rouge sur le dessus métallique du potentiomètre ; certaines cartes ont à la place un petit point de mesure marqué VREF.
4. Tourne très légèrement le potentiomètre avec un petit tournevis en plastique ou en céramique et surveille la valeur. Sur la plupart des cartes, le sens horaire augmente Vref, mais cela peut varier ; certains potentiomètres repartent au début après un tour complet, avance donc par petits pas.
5. Une fois la valeur calculée atteinte, coupe l'alimentation, branche le moteur et seulement ensuite remets sous tension.
6. Fais tourner le moteur quelques minutes et vérifie la température de la puce. Si tu ne peux pas garder le doigt dessus ne serait-ce que quelques secondes, baisse un peu Vref ou ajoute un dissipateur.

Micropas avec MS1, MS2 et MS3

Le micropas (microstepping) consiste pour le driver à faire varier progressivement le courant dans les deux bobines afin de diviser chaque pas entier en parties plus petites. L'A4988 choisit l'un des cinq modes selon les niveaux logiques des broches MS1–MS3. Ces broches ont des résistances de rappel au niveau bas (pull-down) internes : si tu laisses les trois non connectées, le moteur fonctionne en pas entier.

Le véritable avantage du micropas, c'est une rotation douce et silencieuse : en pas entier, le moteur donne un à-coup à chaque pas et entre en résonance à certaines vitesses, alors qu'en 1/16 le mouvement est presque continu. Mais ne t'attends pas à une précision réellement multipliée par 16. Le couple qui fait avancer un seul micropas ne vaut que sin(90° / 16) ≈ 10 % du couple de maintien ; si les frottements ou la charge dépassent cette petite force, le moteur reste quelques micropas en retard. Pour calculer la vitesse, utilise : pas/s = tr/min × 200 × micropas / 60. Par exemple, 60 tr/min en 1/16 demandent 3200 impulsions STEP par seconde. Si tu veux changer de mode par logiciel, tu peux aussi relier les broches MS à l'Arduino ; dans la plupart des projets, choisir un mode fixe avec des fils suffit.

Premier code : rotation avec STEP et DIR, sans bibliothèque

Le code ci-dessous fait tourner le moteur d'un tour en avant puis d'un tour en arrière sans aucune bibliothèque, simplement en envoyant des impulsions sur la broche STEP. On suppose que tu as relié MS1–MS3 au 5V, donc que le moteur fonctionne en 1/16 et qu'un tour fait 3200 pas.

1// A4988 + NEMA 17, kütüphanesiz / without a library
2const int STEP_PIN = 2;            // CNC Shield X ekseniyle aynı / same as CNC Shield X axis
3const int DIR_PIN  = 5;
4const int EN_PIN   = 8;            // aktif LOW / active LOW
5
6const long STEPS_PER_REV = 200L * 16;   // 1,8° motor, 1/16 mikro adım = 3200 / 1.8° motor, 1/16 microstep
7
8void setup() {
9  pinMode(STEP_PIN, OUTPUT);
10  pinMode(DIR_PIN, OUTPUT);
11  pinMode(EN_PIN, OUTPUT);
12  digitalWrite(EN_PIN, LOW);       // sürücüyü aç / enable the driver
13}
14
15void rotate(long steps, unsigned int pauseUs) {
16  digitalWrite(DIR_PIN, steps > 0 ? HIGH : LOW);   // yön / direction
17  delayMicroseconds(5);                           // DIR, STEP'ten önce otursun / let DIR settle before STEP
18  for (long i = 0; i < labs(steps); i++) {
19    digitalWrite(STEP_PIN, HIGH);
20    delayMicroseconds(5);                         // darbe en az 1 µs / pulse at least 1 µs
21    digitalWrite(STEP_PIN, LOW);
22    delayMicroseconds(pauseUs);                   // küçüldükçe hız artar / smaller = faster
23  }
24}
25
26void loop() {
27  rotate(STEPS_PER_REV, 500);      // 1 tur ileri, ~1,6 sn / one turn forward, ~1.6 s
28  delay(1000);
29  rotate(-STEPS_PER_REV, 500);     // 1 tur geri / one turn back
30  delay(1000);
31}

Trois temporisations comptent dans ce code. L'A4988 exige que les parties HIGH et LOW de l'impulsion STEP durent au moins 1 µs ; 5 µs est une valeur sûre. Après un changement de DIR, il faut attendre au moins 200 ns avant la première impulsion STEP ; le code attend 5 µs pour cela. La vitesse dépend de la pause entre les impulsions : avec 500 µs de pause, un pas dure environ 0,51 ms et un tour (3200 pas) environ 1,6 seconde, soit à peu près 36 tr/min. Ce code a deux faiblesses : le moteur démarre brutalement à pleine vitesse, et l'Arduino ne peut rien faire d'autre pendant la boucle. Si tu passes directement la pause à 100 µs, le moteur ne démarrera très probablement pas et se contentera de grogner.

Accélération et décélération avec AccelStepper

On ne peut pas faire passer un moteur pas à pas de l'arrêt à une vitesse élevée d'un seul coup ; le rotor et la charge ne suivent pas un changement aussi brusque, le moteur décroche et perd des pas. La solution consiste à augmenter la vitesse en rampe puis à la réduire à l'approche de la cible. AccelStepper, que tu peux installer depuis le gestionnaire de bibliothèques, le fait sans bloquer : tu appelles run() en continu dans loop() et la bibliothèque fait un pas chaque fois qu'il le faut. Tu peux ainsi lire des boutons, mettre à jour un écran ou mesurer des capteurs pendant que le moteur tourne ; ce principe est détaillé dans l'article millis() ou delay(). Sur un Uno, AccelStepper atteint de façon fiable quelques milliers de pas par seconde (sa documentation indique environ 4000 pas/s à 16 MHz) ; l'exemple utilise donc 2000 pas/s, soit environ 37 tr/min en 1/16.

1#include <AccelStepper.h>
2
3const int STEP_PIN = 2;
4const int DIR_PIN  = 5;
5const int EN_PIN   = 8;
6const long STEPS_PER_REV = 200L * 16;            // 1/16 mikro adımda 1 tur / one turn at 1/16 microstep
7
8AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
9
10void setup() {
11  stepper.setEnablePin(EN_PIN);
12  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
13  stepper.enableOutputs();
14  stepper.setMaxSpeed(2000);                     // adım/sn, Uno için güvenli / steps per second, safe on Uno
15  stepper.setAcceleration(1500);                 // adım/sn² / steps per second²
16  stepper.moveTo(STEPS_PER_REV * 3);             // 3 tur ileri / three turns forward
17}
18
19void loop() {
20  if (stepper.distanceToGo() == 0) {             // hedefe varıldı / target reached
21    delay(500);
22    stepper.moveTo(stepper.currentPosition() == 0 ? STEPS_PER_REV * 3 : 0);   // git-gel / back and forth
23  }
24  stepper.run();                                 // her döngüde çağır, bekletmez / call every loop, non-blocking
25}

Plusieurs moteurs avec le CNC Shield V3

Si tu pilotes plus d'un NEMA 17, le moyen le plus simple d'éviter le sac de nœuds est le CNC Shield V3 pour Arduino. Cette carte s'enfiche sur l'Uno et offre quatre emplacements A4988 (X, Y, Z et A), des cavaliers de micropas sous chaque driver, des connecteurs moteur, des entrées de fin de course et un bornier d'alimentation ; avec les trois cavaliers en place, l'A4988 fonctionne en 1/16. Dans le tableau de câblage, nous avons choisi exprès D2, D5 et D8 pour STEP, DIR et EN : ce sont les broches de l'axe X du shield, donc les codes ci-dessus y fonctionnent sans modification. Si tu flashes GRBL sur l'Uno, le shield devient un contrôleur CNC ou laser qui reçoit du G-code depuis l'ordinateur. Dans GRBL, tu indiques le nombre de pas par millimètre de chaque axe dans les réglages $100, $101 et $102 : avec une poulie GT2 de 20 dents et des micropas en 1/16, cela donne 200 × 16 / (20 × 2) = 80 pas/mm, et avec une vis trapézoïdale T8 au pas de 8 mm, 200 × 16 / 8 = 400 pas/mm.

Utiliser l'A4988 avec l'ESP32

Les broches de l'ESP32 délivrent 3,3 V. L'A4988 ne reconnaît une entrée comme HIGH de façon fiable que si elle dépasse 70 % de VDD ; avec VDD à 5 V, ce seuil est de 3,5 V, et un signal de 3,3 V reste en dessous. C'est pourquoi, avec l'ESP32 et le Pico, tu dois relier la broche VDD de l'A4988 au 3V3 : le driver fonctionne très bien entre 3 et 5,5 V et tu n'as pas besoin de convertisseur de niveau logique. Comme VDD a changé, pense à mesurer Vref à nouveau. Le code ci-dessous amène le moteur, avec accélération, à l'angle que tu tapes dans le moniteur série (par exemple 90 ou -45). L'ESP32 étant beaucoup plus rapide, AccelStepper y atteint sans peine 6000 pas par seconde ; pour aller plus vite, regarde la bibliothèque FastAccelStepper, qui utilise des timers matériels. Si l'ESP32 est nouveau pour toi, commence par Qu'est-ce que l'ESP32 ?.

1#include <AccelStepper.h>
2
3// ESP32: STEP=25, DIR=26, EN=27, A4988 VDD → 3V3
4const int STEP_PIN = 25;
5const int DIR_PIN  = 26;
6const int EN_PIN   = 27;
7const float STEPS_PER_DEG = 200.0 * 16 / 360.0;  // 1/16'da derece başına 8,89 adım / 8.89 steps per degree at 1/16
8
9AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
10
11void setup() {
12  Serial.begin(115200);
13  stepper.setEnablePin(EN_PIN);
14  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
15  stepper.enableOutputs();
16  stepper.setMaxSpeed(6000);                     // adım/sn / steps per second
17  stepper.setAcceleration(4000);                 // adım/sn² / steps per second²
18  Serial.println("Aci yaz, ornek 90 / type an angle, e.g. 90");
19}
20
21void loop() {
22  if (Serial.available()) {
23    float angle = Serial.parseFloat();           // Seri Monitör'den açı / angle from the Serial Monitor
24    while (Serial.available()) Serial.read();    // satır sonunu at / drop the line ending
25    stepper.moveTo(lround(angle * STEPS_PER_DEG));
26    Serial.printf("Hedef / target: %.1f\n", angle);
27  }
28  stepper.run();                                 // bekletmeden adım at / step without blocking
29}

A4988 avec le Raspberry Pi Pico et MicroPython

Sur le Pico aussi, tu relies la broche VDD de l'A4988 à la broche 3V3 (OUT). Au lieu d'une bibliothèque d'accélération, tu peux écrire en MicroPython une rampe linéaire simple comme ci-dessous : la fonction move() fait varier progressivement la pause entre les impulsions de 2000 µs à 400 µs sur les 600 premiers et les 600 derniers pas, et tourne à pleine vitesse entre les deux. La boucle MicroPython ajoute quelques dizaines de microsecondes à chaque pas, la vitesse réelle est donc un peu inférieure au calcul. Si tu as besoin de dizaines de milliers de pas par seconde ou de plusieurs moteurs à la fois, les blocs PIO du Pico peuvent générer les impulsions sans occuper le processeur. Pour installer MicroPython sur le Pico, consulte Qu'est-ce que le Raspberry Pi Pico ?.

1from machine import Pin
2import time
3
4step = Pin(2, Pin.OUT)              # STEP → GP2
5direction = Pin(3, Pin.OUT)         # DIR → GP3
6enable = Pin(4, Pin.OUT, value=0)   # EN → GP4, 0 = sürücü açık / 0 = driver enabled
7
8STEPS_PER_REV = 200 * 16            # 1/16 mikro adım / 1/16 microstep
9
10def move(steps, max_sps=2500, ramp_steps=600):
11    direction.value(1 if steps > 0 else 0)    # yön / direction
12    time.sleep_us(5)
13    n = abs(steps)
14    ramp = min(ramp_steps, n // 2)            # hızlanma ve yavaşlama adımı / accel and decel steps
15    fast = 1000000 // max_sps                 # en kısa bekleme, µs / shortest pause, µs
16    slow = 2000                               # 500 adım/sn ile başla / start at 500 steps/s
17    for i in range(n):
18        k = min(i, n - 1 - i)                 # başa ya da sona uzaklık / distance to start or end
19        pause = slow - (slow - fast) * k // ramp if k < ramp else fast
20        step.value(1)
21        time.sleep_us(3)                      # STEP darbesi / STEP pulse
22        step.value(0)
23        time.sleep_us(pause)
24
25while True:
26    move(STEPS_PER_REV)             # 1 tur ileri / one turn forward
27    time.sleep(1)
28    move(-STEPS_PER_REV // 2)       # yarım tur geri / half a turn back
29    time.sleep(1)

Chauffe, dissipateur et protection thermique

Il est normal que l'A4988 chauffe, car le courant des bobines traverse les MOSFET à l'intérieur de la puce. Le chemin du courant de chaque bobine présente typiquement une résistance totale de 0,64 Ω, et la puissance dissipée croît avec le carré du courant : environ P ≈ I² × 0,64 Ω. À 1 A, cela fait environ 0,65 W, et à 1,5 A environ 1,45 W ; en chauffant, la puce voit sa résistance augmenter et la valeur réelle est encore plus élevée. C'est beaucoup de chaleur pour une carte grande comme le bout d'un doigt. Quand la puce atteint 165 °C, la protection thermique coupe les sorties et les réactive après un refroidissement d'environ 15 °C. Un moteur qui tourne quelques secondes, s'arrête puis repart tout seul est le signe typique de cette protection.

• Pose un dissipateur : Colle un petit dissipateur en aluminium sur la puce avec de l'adhésif thermique ; vérifie qu'il ne touche ni les broches ni le potentiomètre.
• Assure une circulation d'air : Au-delà de 1,2 A ou dans un boîtier fermé, un petit ventilateur multiplie l'efficacité du dissipateur.
• Règle le courant selon le besoin : Si le moteur ne perd pas de pas en charge, baisse un peu Vref ; réduire le courant de 20 % réduit la chaleur d'environ 36 %.
• Coupe les bobines à l'arrêt : Si tu n'as pas besoin du couple de maintien, mets la broche EN à HIGH ou appelle disableOutputs() à la fin du mouvement ; le driver et le moteur refroidissent.
• Surveille aussi la température du moteur : Les moteurs pas à pas consomment du courant même à l'arrêt, ils deviennent donc tièdes, voire chauds. Si le boîtier dépasse 60 °C, baisse le courant ; à cette température, les pièces en PLA d'une imprimante 3D commencent à ramollir.
• Passe à un driver plus puissant : Si ton moteur a besoin de plus de 1,5 A, un driver comme le DRV8825 ou le TMC2209 convient mieux.

Différences entre A4988, DRV8825 et TMC2208

Les trois drivers utilisent le même format « StepStick » à 16 broches et peuvent souvent être échangés sur un CNC Shield, mais il y a des différences à surveiller. Le potentiomètre du DRV8825 est placé ailleurs et sa formule est différente ; la broche qui est VDD sur l'A4988 est la sortie FAULT sur le DRV8825. Avec le même code, le TMC2208 fait tourner le moteur dans le sens inverse de l'A4988 : il faut inverser DIR dans le code ou retourner le connecteur du moteur de 180°. Ses réglages avancés se font par UART, et si tu veux une prise d'origine sans capteur (StallGuard), regarde du côté du TMC2209. En bref, pour apprendre et pour les projets à petit budget, l'A4988 reste le point de départ le plus logique ; choisis le TMC2208 si le bruit compte et le DRV8825 s'il te faut plus de courant. Pour une comparaison générale des types de moteurs, lis différences entre moteur CC, servomoteur et pas à pas.

Le moteur vibre mais ne tourne pas : erreurs fréquentes et solutions

Idées de projets avec l'A4988 et le NEMA 17

• Slider pour appareil photo : Déplace un appareil photo millimètre par millimètre sur un rail avec une courroie et une poulie GT2 pour tourner des vidéos en time-lapse.
• Traceur à stylo (pen plotter) : Déplace un stylo sur deux axes avec un CNC Shield et GRBL pour reporter sur papier les dessins de ton ordinateur ; un servomoteur suffit pour lever et baisser le stylo.
• Plateau tournant : Fais tourner un objet par angles égaux pour des photos produit ou un scan 3D ; comme un tour fait 3200 pas en 1/16, tu fais environ 89 pas entre chacune des 36 photos.
• Suiveur solaire : Construis un montage qui oriente un panneau vers le soleil toute la journée ; l'idée complète est dans l'article sur le suiveur solaire.
• Base de bras robotique : Fais tourner la base d'un bras lourd avec un NEMA 17 et des engrenages plutôt qu'avec un servo ; pour les autres articulations, vois l'article sur le bras robotique.
• Positionnement manuel : Déplace le moteur rapidement avec un joystick et précisément, pas à pas, avec un encodeur rotatif.
• Rideau automatique ou couvercle coulissant : Au démarrage, trouve le point zéro avec un fin de course, enregistre-le avec setCurrentPosition(0) et amène le rideau à la position voulue.

En résumé, piloter un NEMA 17 avec l'A4988, c'est apparier correctement les bobines, mettre 100 µF sur l'alimentation, calculer Vref avec la formule et la régler au multimètre, choisir le micropas et faire tourner le moteur avec accélération. Une fois ces bases acquises, le fonctionnement des imprimantes 3D et des machines CNC devient lui aussi limpide. Dans l'application BlueGrays, tu trouveras des projets de mouvement comme l'utilisation d'un moteur pas à pas ou la transformation d'un moteur pas à pas en servo à 360 degrés, étape par étape, avec schémas de câblage et code.