Moteur pas à pas et Arduino : branchement, code et schéma complet

Connecter un moteur pas à pas à une carte Arduino ouvre la porte à des mouvements précis, reproductibles et parfaitement contrôlés. Encore faut‑il choisir le bon driver, dimensionner l’alimentation, régler le courant et structurer le code pour éviter pertes de pas, vibrations et surchauffe.

Entre les moteurs NEMA, le 28BYJ‑48, les drivers type A4988, DRV8825 ou TB6600 et les différentes méthodes de pilotage, chaque décision influence directement le couple, la vitesse et la fiabilité de l’installation. Les points clés se nichent dans le câblage, les paramètres de micro‑pas et la gestion logicielle de la vitesse et de l’accélération.

📌

Télécharger l’image Partager l’image

Moteur pas à pas et Arduino : principes de fonctionnement et types de moteurs

Un moteur pas à pas convertit des impulsions électriques en déplacements angulaires précis. Chaque impulsion avance l’axe d’un nombre de degrés défini, ce qui permet un positionnement sans capteur intégré. Sur Arduino, ce comportement se contrôle via des signaux numériques de type STEP / DIR ou via une commande directe des bobines selon le driver choisi.

Ce type de motorisation convient aux systèmes de positionnement, traceurs, imprimantes 3D, axes de CNC, micro‑robots, systèmes de dosage ou encore volets motorisés. Le point fort vient de la répétabilité : le moteur revient exactement à la même position tant que les pertes de pas restent maîtrisées.

22 septembre 2026

Code erreur E03 sur un lave-linge Candy : 3 contrôles avant d’appeler un réparateur

0 commentaires

Les grandes familles de moteurs pas à pas

Les moteurs pas à pas se regroupent en deux grandes catégories pour les projets Arduino :

• Moteurs unipolaires : plusieurs bobines avec point milieu, câblage plus simple avec certains modules basiques (ULN2003, L293D), couple plus limité.
• Moteurs bipolaires : deux enroulements principaux, couple plus élevé, très utilisés avec les drivers modernes (A4988, DRV8825, TMC2208, TB6600, DRV8434S).

Le choix influe sur le driver compatible, la tension, le courant à régler et la stratégie de pilotage logiciel. Un même Arduino peut piloter plusieurs références, à condition d’adapter le schéma et le code pour chaque moteur.

Exemples concrets : NEMA17, NEMA34 et 28BYJ‑48

Voici un récapitulatif des caractéristiques fournies, utiles pour dimensionner le montage :

Le 28BYJ‑48, très répandu en kit, utilise un réducteur intégré. En mode simple pas, la résolution atteint environ 2048 pas/tour et en demi‑pas, 4096 pas/tour. Ce moteur reste adapté aux faibles vitesses, autour de 30 tr/min maximum, avec un couple modéré.

« Un moteur pas à pas dimensionné avec une marge de couple fonctionne mieux, chauffe moins et garde sa précision même sous charge variable. »

Choisir son driver pour moteur pas à pas avec Arduino

La liaison entre Arduino et moteur passe quasiment toujours par un driver dédié. Celui‑ci gère le courant dans les bobines, limite l’échauffement, autorise le micro‑pas et protège la carte. Sans driver adapté, la carte Arduino se retrouve rapidement surchargée et le moteur perd en couple ou vibre.

21 septembre 2026

Code erreur sur un lave-linge Bosch : décoder la panne et éviter une réparation inutile

0 commentaires

Panorama des drivers compatibles

Les principales références mentionnées se répartissent en plusieurs familles :

• Drivers de puissance à impulsions (STEP/DIR) : A4988, DRV8825, TB6600, TMC2208. Une impulsion STEP = un pas ou micro‑pas, la broche DIR fixe le sens.
• Drivers à interface SPI : DRV8434S, TMC avancés. Configuration fine des micro‑pas, du courant et des rampes via une liaison série.
• Ponts en H et circuits simples : L293D, ULN2003 pour les petits moteurs comme le 28BYJ‑48.

Parmi les modèles cités dans les données :

• DRV8825 : cible les moteurs bipolaires (NEMA17, certains NEMA23). Pilotage STEP/DIR, micro‑pas avancés, plage de tension compatible avec du 12 à 24 V.
• L293D : pont en H double, 600 mA nominaux par canal (pics 1,2 A). Conviendra au 28BYJ‑48 ou à de petits moteurs, moins adapté aux moteurs gourmands.
• DRV8434S : pilotage SPI, micro‑pas fins, réglages dynamiques. Intéressant pour projets exigeants en douceur et en silence.
• TMC2208 : pilotage silencieux, compatible moteurs unipolaires/bipolaires, très répandu en imprimantes 3D.
• TB6600 : driver externe pour moteurs plus puissants, commandé par fréquence STEP/DIR. Approprié pour NEMA de gabarit supérieur ou applications CNC.

Microcontrôleur direct ou driver dédié ?

Deux approches existent pour piloter un moteur pas à pas avec Arduino :

Pour un projet sérieux incluant précision, couple et durabilité, un driver dédié reste la voie à privilégier. Les circuits simples servent surtout dans un contexte d’apprentissage ou pour des charges très légères.

21 septembre 2026

Erreur L11-06 sur Livebox 4 : 4 vérifications avant d’appeler Orange

0 commentaires

Dimensionner l’alimentation et le courant du moteur pas à pas

Le couple, la vitesse maximale et la durée de vie de l’ensemble moteur + driver dépendent directement de l’alimentation. Une alimentation sous‑dimensionnée crée des pertes de pas, des arrêts aléatoires et une chauffe anormale du driver. Une alimentation surdimensionnée en tension favorise les surtensions et les dégâts en cas de mauvais réglage.

Tension d’alimentation recommandée

Les indications fournies proposent une plage générale :

• Tension moteurs : entre 12 V et 24 V pour la plupart des installations Arduino avec moteurs bipolaires.
• Plage NEMA17 : 4,3 V à 36 V via driver comme le DRV8825 ou l’A4988, avec une tension nominale moteur de 12 V.

Une règle pratique consiste à calculer la tension moteur conseillée via la formule :

Tension recommandée ≈ 32 × √(Inductance en mH)

Ce calcul donne une estimation permettant de garantir une montée de courant suffisamment rapide dans les bobines à chaque pas. Coupler cette valeur à la plage supportée par le driver et par le moteur permet d’obtenir un montage équilibré.

Réglage du courant sur le driver

Le réglage du courant s’effectue généralement via un petit potentiomètre sur le driver. La recommandation fournie mentionne un réglage à environ 70 % du courant nominal du moteur. Pour un moteur donné :

• Courant nominal par phase : par exemple 1 A.
• Courant de réglage recommandé : 0,7 A.

Ce réglage assure un bon compromis entre couple et échauffement. Un courant plus haut améliore le couple mais augmente la température du moteur et du driver. Un courant plus bas réduit le couple et risque d’entraîner des pertes de pas sous charge.

Découplage et filtrage

Une alimentation stable limite les resets d’Arduino et les perturbations EMI :

• Placer des condensateurs de découplage au plus près du driver, entre Vmot et GND.
• Prévoir un condensateur électrolytique de quelques centaines de µF sur les rails d’alimentation.
• Partager la masse commune entre Arduino, alimentation et driver (GND unique pour la logique et la puissance).

Cette précaution se ressent dès que les moteurs montent en vitesse ou lors des inversions rapides de sens, qui provoquent des transitoires de courant notables.

Branchement détaillé : Arduino, driver et moteur pas à pas

Le câblage constitue la base de la fiabilité. Une erreur sur les bobines ou une masse flottante suffit à provoquer des saccades ou un comportement aléatoire. Deux scénarios dominent : le driver de type A4988/DRV8825 et le driver externe type TB6600.

Branchement typique avec module A4988

Un module A4988 s’insère facilement sur une breadboard ou un shield CNC. Les broches essentielles sont :

• VDD : alimentation logique 5 V depuis l’Arduino.
• GND : masse commune Arduino / driver / alimentation.
• VMOT : alimentation puissance du moteur (par exemple 12 V ou 24 V).
• STEP : entrée impulsion, chaque front actif produit un pas ou micro‑pas.
• DIR : entrée direction, définit le sens de rotation.
• ENABLE : activation du driver (souvent active à l’état bas).
• MS1, MS2, MS3 : configuration des micro‑pas (pas complet, 1/2, 1/4, 1/8, 1/16).
• Sorties moteur : deux paires A1/A2 et B1/B2 pour les enroulements.

La séquence de raccordement à respecter :

• Identifier les deux paires de bobines du moteur bipolaire (à l’ohmmètre ou via la documentation).
• Relier chaque paire sur A1/A2 puis B1/B2.
• Raccorder VMOT au + de l’alimentation moteur, GND au – et à la masse Arduino.
• Raccorder VDD au 5 V de l’Arduino.
• Relier STEP et DIR aux broches numériques choisies sur Arduino.
• Configurer les micro‑pas via MS1, MS2, MS3 (tirés au GND ou au VDD).

« Un A4988 ou un DRV8825 fournit un bon équilibre entre simplicité de câblage et possibilités de réglage. Avec un simple signal STEP/DIR, un Arduino Uno gère déjà un axe précis et fluide. »

Branchement avec driver TB6600

Le TB6600 s’utilise surtout pour des moteurs plus puissants comme des NEMA23 ou certains NEMA34. Le principe reste similaire :

• Entrées PUL+ / PUL− pour le signal STEP.
• Entrées DIR+ / DIR− pour le sens.
• Entrées ENA+ / ENA− pour l’activation.
• Borniers pour le moteur : A+, A−, B+, B−.
• Borniers pour l’alimentation externe (souvent 12 à 36 V, selon modèle).

Les entrées différentielles PUL+/− et DIR+/− se relient aux sorties Arduino en suivant les recommandations du fabricant, souvent via une résistance ou un câblage en commun avec le 5 V.

Cas du moteur 28BYJ‑48 et des drivers simples

Le 28BYJ‑48, souvent vendu avec un module ULN2003, se branche directement sur plusieurs sorties numériques Arduino. Dans ce cas, l’Arduino gère la séquence des bobines lui‑même. Pour un L293D, le principe reste similaire : l’Arduino active les entrées IN1 à IN4 en suivant un cycle prédéfini (pas complet, demi‑pas).

Ce type de pilotage convient à de petites charges et à des vitesses modestes. Les projets qui exigent un mouvement plus fluide ou un couple supérieur bénéficient davantage d’un driver spécialisé et d’un moteur bipolaire.

Modes de pas et micro‑pas : précision, couple et bruit

La résolution d’un moteur pas à pas dépend du nombre de pas par tour et du mode de pilotage. Un NEMA17 classique offre 200 pas mécaniques par tour, soit 1,8° par pas en mode plein pas. Les drivers modernes divisent chaque pas en micro‑pas pour améliorer la finesse.

Pas complet, demi‑pas, micro‑pas

Les données fournies rappellent deux notions :

• Pas complet : couple maximal, chaque impulsion STEP correspond au déplacement mécanique nominal (1,8° pour un moteur 200 pas/tour).
• Micro‑pas : résolution angulaire augmentée, mouvement plus fluide, bruit réduit, mais couple instantané légèrement plus faible.

Sur un A4988 ou DRV8825, les combinaisons de MS1/MS2/MS3 permettent d’obtenir plusieurs modes :

• Pas complet (1/1)
• 1/2 pas
• 1/4 pas
• 1/8 pas
• 1/16 pas (voire 1/32 sur certains drivers)

Pour un moteur 200 pas/tour en 1/16 micro‑pas, la résolution atteint 3200 micro‑pas par tour. Un 28BYJ‑48 en 4096 pas/tour avec réducteur fournit déjà une très bonne finesse sur un axe lent.

Méthodes de pilotage avec Arduino : fréquence, interruptions et SPI

L’Arduino envoie soit une séquence de signaux pour activer les bobines, soit des impulsions STEP régulières. La stratégie choisie influe sur la qualité de la trajectoire, la réactivité et la capacité à piloter plusieurs moteurs.

Pilotage par drivers à impulsions (A4988, DRV8825, TB6600)

Les drivers à impulsions utilisent une logique simple :

• 1 impulsion STEP = 1 pas ou micro‑pas.
• DIR fixe le sens, modifiable à chaud.
• Les micro‑pas se configurent via des broches ou des DIP switch.

La vitesse angulaire du moteur correspond à la fréquence des impulsions STEP. Une fréquence élevée produit une rotation rapide, une fréquence faible donne un mouvement lent et précis. La consigne de fréquence dépend du mode de pas choisi, car le nombre de micro‑pas par tour augmente avec la division.

Pilotage direct des bobines via transistors ou L293D

Une autre option consiste à contrôler directement les bobines avec l’Arduino. Les données mentionnent la commande par drivers transistors hacheurs, où la carte génère des signaux PWM pour gérer le courant. Cette approche devient vite limitée :

• Le microcontrôleur doit gérer la séquence de commutation.
• La régulation de courant reste approximative.
• La précision en micro‑pas reste inférieure aux drivers spécialisés.

Cette solution garde un intérêt pédagogique mais s’adapte moins à un projet final orienté performance.

Drivers avancés pilotés en SPI (exemple DRV8434S)

Les drivers modernes à interface SPI ajoutent des fonctionnalités avancées :

• Réglage du courant par registre, sans potentiomètre.
• Choix du nombre de micro‑pas directement dans la configuration.
• Gestion des rampes d’accélération et de décélération.
• Fonctions de diagnostic (sur‑courant, sur‑température, etc.).

L’Arduino communique alors avec le driver via MOSI, MISO, SCK et un chip‑select dédié, en plus des éventuelles broches STEP/DIR. Cette architecture crée une plate‑forme flexible pour des projets complexes, par exemple une machine CNC multi‑axes.

Calcul de fréquence, contrôle de la vitesse et gestion des accélérations

La vitesse d’un moteur pas à pas piloté par Arduino dépend directement du rythme des impulsions. Une approche naïve basée uniquement sur des délais delay() conduit souvent à des pertes de pas lors des accélérations brutales. Une gestion soignée de la fréquence et des rampes améliore nettement le comportement.

Formule de fréquence et paramètres de tempo

Les données mentionnent une relation entre la période T2 et la fréquence :

Fréquence = 1 / (T2 × 0,1 ms × 2)

Avec quelques repères :

• T2 = 10 → 500 Hz.
• T2 = 100 → 50 Hz.
• T2 = 1000 → 0,5 Hz.
• T2 = 1 → 5000 Hz.

La donnée « paramètre_tempo : 1 = rapide / 100 = lent » illustre cette logique : un délai court entre deux impulsions STEP donne une rotation rapide, un délai long une rotation lente.

Gestion des accélérations : trapézoïdale et courbes en S

Un moteur pas à pas supporte mal les variations instantanées de fréquence. Un démarrage à pleine vitesse déclenche souvent des glissements de pas ou un blocage mécanique. Les recommandations fournies citent plusieurs approches :

• Accélération trapézoïdale : montée progressive de la fréquence, palier constant, puis décélération progressive.
• Courbes en S : variation plus douce de la dérivée de la vitesse, réduction des chocs et des résonances mécaniques.
• Test de la vitesse maximale : validation pratique selon la charge réelle et les inversions de sens.

Intégrer une rampe d’accélération dans le code rend l’ensemble bien plus tolérant aux variations de charge et préserve la précision de positionnement.

Programmation Arduino : interruptions, gestion multi‑moteurs et contrôle manuel

Le code embarqué sur l’Arduino organise la génération des impulsions, la lecture des capteurs éventuels et la gestion de l’interface utilisateur. Un simple boucle loop() avec des delay() suffit pour un seul moteur lent, mais atteint vite ses limites sur des projets multi‑axes ou des vitesses élevées.

Génération des impulsions en interruption (Timer1)

Les données mentionnent l’usage de Timer1 pour une interruption toutes 100 µs. Cette approche fournit une base solide :

• Une interruption périodique déclenche l’envoi d’une impulsion STEP.
• Le code dans loop() gère la consigne de vitesse et la position cible.
• La modification de la fréquence se fait en ajustant la période du timer.

Ce schéma donne une horloge stable pour la motorisation tout en laissant du temps processeur pour la logique et les interfaces. La précision temporelle dépasse largement celle de simples délais.

Pilotage séquentiel de plusieurs moteurs (Arduino Uno / Mega)

Les informations fournies indiquent que l’Arduino Uno ou Mega gère plusieurs moteurs en mode séquentiel, c’est‑à‑dire que les actions s’exécutent l’une après l’autre :

• Les impulsions destinées à chaque moteur se génèrent successivement.
• Les vitesses restent correctes pour un nombre limité de moteurs.
• La synchronisation absolue entre axes nécessite une planification rigoureuse.

Pour des applications complexes comme une CNC, des solutions dédiées ou des firmwares spécialisés gèrent mieux la coordination multi‑axes. Pour des projets plus simples (tourne‑plateau, caméra motorisée, volet), un contrôle séquentiel répond déjà au besoin.

Contrôle manuel de la vitesse et de la position par potentiomètre

Les données mentionnent l’usage d’un potentiomètre multitours et de la fonction analogRead() associée à map(). Ce montage donne un contrôle fin :

• Lecture de la valeur analogique (0 à 1023 sur Arduino Uno).
• Conversion de cette valeur en consigne de vitesse ou en angle cible.
• Mise à jour de la fréquence STEP ou du nombre de pas à envoyer.

Un potentiomètre multitours se combine bien avec un moteur pas à pas à haute résolution : l’utilisateur ressent directement la correspondance entre sa rotation manuelle et la position de l’axe final.

« Associer un contrôle manuel par potentiomètre et une motorisation pas à pas fournit une interface intuitive pour régler précisément un angle, une hauteur ou une ouverture sans interface complexe. »

Fonctionnement continu, limites thermiques et fiabilité

Un moteur pas à pas sous tension consomme même à l’arrêt, car le courant dans les bobines maintient la position. Les données fournies listent plusieurs points clés sur le fonctionnement continu.

Points forts du fonctionnement continu

Les avantages mis en avant :

• Haute précision du positionnement, particulièrement utile pour des applications récurrentes.
• Répétabilité : la position finale reste identique d’un cycle à l’autre.
• Vitesse contrôlée sans capteur : la fréquence des impulsions suffit pour déterminer la vitesse.
• Faible entretien : aucun balai, usure limitée.

Les moteurs pas à pas se montrent adaptés aux cadences répétitives, aux réglages de butées, aux systèmes d’avance contrôlée. L’Arduino ajoute une logique souple pour automatiser ces cycles.

Limites : consommation, chauffe et couple mécanique

Les limites mentionnées rappellent plusieurs réalités :

• Consommation constante : le moteur consomme même à l’arrêt pour maintenir le couple de retenue.
• Efficacité réduite à haute vitesse : le couple chute lorsque la fréquence augmente, surtout sur des moteurs à forte inductance.
• Chauffe : un refroidissement passif (dissipateurs) ou actif (ventilation) reste souvent nécessaire.
• Dépendance au couple mécanique : une charge trop lourde ou un frottement élevé provoquent des pertes de pas.

Un dimensionnement attentif du couple, de l’inertie et des frottements évite de solliciter inutilement le moteur. Un simple test à vitesse croissante, avec la charge réelle, offre une méthode fiable pour évaluer la marge de fonctionnement.

Schémas de tests, simulation et validation d’un montage Arduino + moteur pas à pas

Avant d’assembler la version finale d’un projet, une phase de test et de simulation évite beaucoup de retours en arrière. Les données mentionnent plusieurs outils et méthodes pour valider un montage.

Outils de simulation et de test

Les outils cités comprennent :

• ISIS (Proteus) pour une simulation basique des circuits et des signaux.
• Le moniteur série Arduino pour suivre en temps réel les valeurs de consigne, les positions et les diagnostics.
• Des logiciels CNC pour générer des signaux STEP/DIR et tester la compatibilité du driver.
• Un potentiomètre multitours pour vérifier la correspondance entre consigne et position réelle.

Cette combinaison permet de valider autant la logique logicielle que le comportement électrique et mécanique.

Validation du câblage et de la régulation de courant

Les recommandations pratiques insistent sur le réglage du courant dès la mise en service :

• Relier correctement VDD de l’Arduino à la logique du driver.
• Établir une masse commune GND entre Arduino, driver et alimentation moteur.
• Régler le courant via le potentiomètre en se basant sur le courant nominal du moteur.

Un test simple consiste à lancer une séquence lente d’allers‑retours sur quelques dizaines de tours. En absence de perte de pas perceptible et avec une température raisonnable, le montage se trouve sur une base saine.

Aller plus loin : DC, servomoteurs et autres architectures avec Arduino

Un projet d’automatisation ne se limite pas toujours aux moteurs pas à pas. D’autres technologies se combinent avec Arduino pour répondre à des besoins différents de couple, de vitesse ou de retour de position.

Comparaison avec les moteurs DC classiques

Un moteur à courant continu tourne librement en fonction de la tension appliquée, la vitesse se contrôle essentiellement par PWM. Cette approche fournit souvent une vitesse plus élevée et une réponse plus souple, mais sans positionnement natif. Pour un aperçu détaillé du pilotage de ce type de moteur, un guide dédié comme Arduino et moteur DC structure clairement les solutions.

Intégration avec des servomoteurs

Les servomoteurs embarquent un retour de position et une électronique de contrôle. Ils répondent bien aux exigences d’angle précis sur un secteur limité, sans devoir gérer les micro‑pas et les rampes. Pour un axe articulé, un servo piloté par PWM simplifie la conception. Un tutoriel orienté code, comme exemples de code pour servomoteur Arduino, complète utilement les connaissances acquises avec les moteurs pas à pas.