Maîtrisez le Contrôle d’un Moteur Pas à Pas avec Arduino : Guide Complet et Astuces Incontournables

Les moteurs pas à pas sont largement utilisés dans le domaine de la robotique et dans les applications nécessitant un mouvement précis. Cet article explore comment commander un moteur pas à pas avec une carte Arduino, en fournissant des exemples de code et des explications sur les différents types de moteurs et de méthodes de pilotage.

Les Moteurs Pas à Pas : Généralités

Les moteurs pas à pas se caractérisent par leur capacité à effectuer des mouvements très précis en petits angles. Ils offrent un bon compromis entre la facilité de contrôle de la vitesse et la précision de la position. On les retrouve fréquemment dans les imprimantes, les scanners et autres dispositifs nécessitant un positionnement exact.

Il existe plusieurs types de moteurs pas à pas, notamment :

Moteurs bipolaires : Ils possèdent 4 fils et sont commandés en inversant la polarité des bobinages.
Moteurs unipolaires : Ils possèdent 5 ou 6 fils et chaque bobinage est commandé séparément.
Moteurs à réluctance variable : Ils ne possèdent pas d'aimants permanents et sont plus complexes à piloter.

La désignation NEMA

La désignation NEMA (National Electrical Manufacturers Association) caractérise une famille de moteurs pas à pas dont l’interface de fixation est standardisée. Le plus connu dans la famille NEMA étant le NEMA 17. L’un des intérêt de ces pas à pas par rapport a un 28BYJ-48 étant le couple et la précision de mouvement obtenu. Les NEMA 17 les plus courants ont 200 pas par tour et certains 400 pas et aucun jeu mécanique sur l’axe.

Pilotage d'un Moteur Pas à Pas NEMA 17 avec Arduino

Pour commander un moteur pas à pas NEMA 17, on utilise majoritairement des Drivers Pololu A4988. Un NEMA 17 à 200 pas par tour piloté par un POLOLU A4988 en mode « sixteenth step » aura une précision de 200×16=3200 pas par tour soit pour un pas une précision angulaire en rotation de 360/3200=0,11 degré.

Le bout de programme ci dessous fait tourner le moteur d’un tour dans un sens puis d’un tour dans l’autre sens et ceci sans utiliser de librairie . La commande :» digitalWrite(8,LOW); » met le signal de la broche DIR n°8 a l’état bas soit dans le sens de rotation 1, puis la première boucle « for(int x = 0; x < 3200; x++) » envoi 3200 fois une alternance de signaux haut et bas ( avec delay d’1ms entre chaque alternance) sur la broche PULSE n° 9 . Chaque alternance fait avancer d’un pas , et comme le POLOLU A4988 est cablé en microstepping 1/16 avec un NEMA17 a 200 pas , le moteur va tourner de 3200 pas soit un tour. A raison d’1ms entre chaque alternance soit 2ms par pas, il faut 3200×2=6400 ms donc 6,4 secondes pour un tour.

Apres la fin de la première boucle for , le programme marque une pause de 500ms ( 1/2 seconde) et la commande « digitalWrite(8,HIGH); » met la broche DIR 8 a l’etat Haut pour changer le sens de rotation . Ensuite une nouvelle boucle « for » fait faire 3200 pas au moteur , puis la boucle loop reprends depuis le debut apres une pause de 500ms. Si on avait cablé les broche MS1/MS2/MS3 sur une sortie de l’ARDUINO de façon a pouvoir contrôler le microstepping par le programme . Si par exemple avec le programme ci dessous , on passe d’un stepping 1/16 a un full step et la boucle de comptage « for » avec 200 pas de comptage, on pourrait faire tourner le moteur d’un tour en 200ms soit 0,2 s ( a condition que le driver soit capable de fournir le courant nécessaire).

En résumer , on peut faire varier la vitesse de rotation de 2 façon; en faisant varier le temps de pause entre chaque impulsion, ou en changeant le microstepping . Sachant que la valeur de la commande »delay(1); » pourrait être remplacée par une variable, on pourrait très bien egalement asservir la vitesse a un potentiomètre branché sur une broche analogique de l’UNO.

Nous venons de voir comment commander un NEMA 17 avec des commandes simples , il est également possible d’utiliser des librairies . L’une des plus connue est « Stepper.h ».

Sur la base de ces principes il est bien entendu possible de piloter plusieurs moteurs NEMA 17 , la limite etant fixée par le nombre de broches ARDUINO disponibles a raison de 2 broche ( STEP/DIR) pour chaque NEMA soit au maximum 6 NEMA 17 avec les 13 broches Digitales de l’UNO. Le fonctionnement est parfaitement identique avec un Arduino NANO .

Lire aussi: Autoradio Renault Mégane

Utilisation de la Bibliothèque Stepper.h

La bibliothèque Stepper.h simplifie le contrôle des moteurs pas à pas unipolaires et bipolaires. Elle permet de définir le nombre de pas par tour et de contrôler la vitesse de rotation.

Les fonctions principales de cette bibliothèque sont :

Stepper(pas, pin1, pin2, pin3, pin4) : Crée un nouvel objet moteur connecté à la carte Arduino.
moteur.setSpeed(rpm) : Configure la vitesse en tours par minute (RPM).
moteur.step(pas) : Indique le nombre de pas que le moteur doit avancer.

Pour inverser le sens de rotation, il suffit d'indiquer un nombre de pas négatif.

Pilotage du Moteur 28BYJ-48

Le moteur pas à pas 28BYJ-48 est un modèle économique souvent utilisé dans les projets de robotique et de contrôle de mouvement. Il est généralement fourni avec le module UNL2003, qui fournit le courant nécessaire au moteur.

Connexion du Moteur 28BYJ-48 et du Module UNL2003 à Arduino

La connexion entre le module contrôleur et le moteur est simple, grâce à un connecteur avec des rainures qui guide l’union entre les deux dispositifs. Les pins IN1, IN2, IN3 et IN4 du module UNL2003 se connectent aux sorties digitales d’Arduino :

Lire aussi: Tout savoir sur la carte grise

pin 8 -> IN1
pin 9 -> IN2
pin 10 -> IN3
pin 11 -> IN4

La sortie de 5V de la plaque Arduino est suffisante pour alimenter le moteur, mais une source externe de 5V peut être nécessaire si le projet comporte d'autres éléments connectés.

Méthodes de Programmation

Le moteur pas à pas 28BYJ-48 peut être programmé de deux manières :

Manuellement, en activant chaque bobine par séquence.
Avec la bibliothèque Stepper.h.

Programmation Manuelle

Il existe plusieurs séquences pour piloter le moteur en mode manuel :

Pas complet (4 bobines) : Chaque bobine est activée par séquence, ce qui réduit la force et la retenue du moteur.
Pas complet (2 bobines) : Deux bobines sont activées simultanément, ce qui maximise la force.
Mi-pas : Alterne l'activation d'une seule bobine et de deux bobines, augmentant la précision.

Séquences Pas à Pas

Les séquences suivantes illustrent les différentes méthodes de pilotage :

Séquence Pas à Pas Unipolaire avec 2 Bobines, Mi-Pas

Dans ce cas, nous avons 8 pas pour compléter un cycle. Cela permet au rotor de tourner dans un angle mineur mais augmentant la précision. Dans le pas 1 uniquement s’active la bobine A, tandis que dans le pas 2 on active la bobine A et B provocant un pivotement de 45º.Ici, un cycle demande 8 pas, le tour complet du rotor exige 8 cycles, et un tour complet de l’axe extérieur a besoin de 64 tours.

Utilisation de Drivers et Shields

Pour piloter des moteurs pas à pas, il est souvent nécessaire d'utiliser des drivers ou des shields. Les drivers, comme le Pololu A4988, permettent de contrôler le courant et la tension envoyés aux bobines du moteur. Les shields, comme l'Arduino Motor Shield Rev3, intègrent des drivers et facilitent le câblage.

L'Arduino Motor Shield Rev3 utilise un circuit intégré L298P, qui permet d'inverser les tensions aux bornes des bobines et de supporter des tensions et courants élevés. Il est possible d'améliorer la résolution du moteur au 1/2, 1/4, 1/8 ou 1/16 en connectant des cavaliers (jumpers) sur les broches M0, M1 et M2.

Exemple de Code Arduino

Voici un exemple de code pour piloter un moteur pas à pas avec la bibliothèque Stepper.h :

Ce code s’inspire de l’exemple fourni avec la librairie qu’on a modifié pour faire fonctionner le stepper 28BYJ-48 130061869.

Considérations sur la Vitesse et le Couple

La vitesse de rotation d'un moteur pas à pas peut être ajustée en modifiant le temps de pause entre chaque impulsion ou en changeant le microstepping. Cependant, il est important de noter que l'augmentation de la vitesse peut réduire le couple disponible.

Si une charge demande trop de couple, le moteur peut "sauter" des pas. Dans ce cas, il peut être nécessaire de réduire la vitesse ou d'utiliser un moteur plus puissant.

Projet de Pilotage d'un Moteur Pas à Pas avec Arduino

Déclaration des variables démarrage :

unsigned long-> déclare une variable de type long non signé pour la base de temps il y a 1 000 microsecondes dans une milliseconde et 1 000 000 microsecondes dans une seconde.unsigned long demarrage = micros();

Déclaration des variables :

int -> declare une variable du type int (pour integer, entier en anglais) elles peuvent stocker des valeurs de - 32 768 à 32 767int base_de_temps1 = 1 ;

Affectation des sorties de la carte Ardunio pour le pilotage du driver DRI0043 :

une impulsion montante ou descendante sur cette entrée fait avancer le moteur d’un pas. La tension de l’impulsion doit être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS.
La largeur d’impulsion doit être de minimum 2,5 μs pour un fonctionnement correct.

int PUL=12; // Definit le sens de rotation en fonction de l'etat bas ou hautint DIR=10;// ce signal est utilisé pour permettre ou interdire l’utilisation du driver. Le moteur est hors tensionint ENA=11;

déclaration de l'entrée du bouton branché sur la broche 14 de votre carte Arduino pour le bouton depart cycle avec la fonction telerupteur int bouton14 = 14;// variable du type int pour stocker les valeurs de passage du bouton14int bouton14v;// creation d'une memoire_2 et forçage a 0 de la variable // etat du telerupteur int memoire_2=0;// etat precedent du bouton et forçage a 0 de la variable int etat_bouton14v=0 ;// déclaration de l'entrée du bouton branché sur la broche 15// pour le debrayage du moteurint bouton_debrayage = 15;int bouton_debrayage_v;// déclaration de l'entrée du bouton branché sur la broche 16// de votre carte Arduino pour le bouton marche avant ou arriere int bp_avant_arriere = 16;// variable du type int pour stocker les valeurs de passage du bouton// bp_avant-arriereint bp_avant_arrierev;// creation d'une memoire_avant_arriere et forçage a 0 de la variable // etat du telerupteur int memoire_avant_arriere=0;// etat precedent du bouton et forçage a 0 de la variable int etat_avant_arriere=0 ;// Declaration de pin pour le voyant depart cycle int voyant_depart_cycle = 8; // Declaration de pin pour le voyant marche avant vertint voyant_vert_mar = 20; // Declaration de pin pour le voyant marche arriere rougeint voyant_rouge_arr = 21;

Un programme Arduino doit impérativement contenir cette fonction. Elle ne sera exécutee une seule fois au démarrage du microcontroleur. Elle sert à configurer globalement les entrées sorties.

Configure la broche spécifiée pour qu'elle se comporte soit en entrée, soit en sortie. Configuration des broches pour le driver pinMode (PUL, OUTPUT); pinMode (DIR, OUTPUT); pinMode (ENA, OUTPUT); Configuration des broches pour les boutons et le voyants pinMode(bouton14,INPUT); pinMode(bouton_debrayage,INPUT); pinMode(bp_avant_arriere,INPUT); pinMode(voyant_depart_cycle,OUTPUT); pinMode(voyant_vert_mar,OUTPUT); pinMode(voyant_rouge_arr,OUTPUT);

Le programme principal s’exécute par une boucle infinie appelée Loop () :

Demande de depart cycle :

bouton14v = digitalRead(bouton14);

Creation un telerupteur :

Compare la variable à gauche avec la valeur ou la variable à droite . Renvoie l'information vraie lorsque les deux variables ne sont pas égales.

if (bouton14v!=etat_bouton14v) { if (!bouton14v) { Inversion de la valeur de la variable memoire memoire_2=!memoire_2; } Inversion de la valeur de la variable memoire memoire_2=!memoire_2; }// operation consitant a memoriser l'anciennne valeur de la variable etat_bouton14v=bouton14v;if ( memoire_2 == 1) { digitalWrite(voyant_depart_cycle,HIGH); //appel de la fonction de deplacement moteur deplacement(); }else if ( memoire_2 == 0) { digitalWrite(voyant_depart_cycle,LOW); }

Fin de demande de depart cycle :

Demande de debrayage du moteur :

debrayage du moteur de son driverbouton_debrayage_v = digitalRead(bouton_debrayage); if ( bouton_debrayage_v == 1 ) { digitalWrite(ENA,LOW); }

Fin de demande debrayage :

Selection du sens de deplacement de l'actionneur :

selection du sens de deplacement du moteur bp_avant_arrierev = digitalRead(bp_avant_arriere);