Maîtriser le contrôle de moteur pas à pas avec Arduino et pilote A4988 – Guide Étape par Étape

Introduction

Dans ce tutoriel Arduino, nous allons apprendre à contrôler un moteur pas à pas en utilisant le pilote de moteur pas à pas A4988. Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous.

Vue d'ensemble

L'A4988 est un pilote micro-pas pour contrôler les moteurs pas à pas bipolaires qui a un traducteur intégré pour un fonctionnement facile. Cela signifie que nous pouvons contrôler le moteur pas à pas avec seulement 2 broches de notre contrôleur, une pour contrôler le sens de rotation et l'autre pour contrôler les pas.

Le pilote fournit cinq résolutions de pas différentes : pas complet, demi-pas, quart de pas, huitième de pas et seizième de pas. Il a aussi un potentiomètre pour régler le courant de sortie, une protection thermique contre la surchauffe et une protection contre les courants de croisement.

Sa tension logique est de 3 à 5,5 V et le courant maximum par phase est de 2A si un bon refroidissement additionnel est fourni ou 1A courant continu par phase sans dissipateur thermique ou refroidissement.

Brochage du pilote pas à pas A4988

Regardons de près le brochage du pilote et connectons-le avec le moteur pas à pas et le contrôleur. Nous commencerons avec les 2 broches en bas à droite pour alimenter le pilote, les broches VDD et Ground que nous devons connecter à une alimentation de 3 à 5,5 V et dans notre cas ce sera notre contrôleur, la carte Arduino qui fournira 5 V. Les 4 broches suivantes sont pour connecter le moteur. Les broches 1A et 1B seront connectées à une bobine du moteur et les broches 2A et 2B à l'autre bobine du moteur. Pour alimenter le moteur, nous utilisons les 2 broches suivantes, Ground et VMOT que nous devons connecter à une alimentation de 8 à 35 V et nous devons aussi utiliser un condensateur de découplage d'au moins 47 µF pour protéger la carte du pilote des pics de tension.

Les 2 broches suivantes, Step et Direction, sont les broches que nous utilisons réellement pour contrôler les mouvements du moteur. La broche Direction contrôle le sens de rotation du moteur et nous devons la connecter à l'une des broches numériques de notre microcontrôleur, ou dans notre cas je la connecterai à la broche numéro 4 de ma carte Arduino.

Avec la broche Step, nous contrôlons les micro-pas du moteur et à chaque impulsion envoyée à cette broche, le moteur fait un pas. Cela signifie que nous n'avons pas besoin de programmation complexe, de tables de séquence de phases, de lignes de contrôle de fréquence, etc., car le traducteur intégré du pilote A4988 s'occupe de tout. Ici, nous devons aussi mentionner que ces 2 broches ne sont pas tirées vers aucune tension en interne, donc nous ne devrions pas les laisser flottantes dans notre programme.

Vient ensuite la broche SLEEP et un niveau logique bas met la carte en mode veille pour minimiser la consommation d'énergie quand le moteur n'est pas utilisé.

Ensuite, la broche RESET remet le traducteur à un état Home prédéfini. Cet état Home ou position de micro-pas Home peut être vu sur ces figures de la fiche technique A4988. Ce sont les positions initiales d'où le moteur démarre et elles sont différentes selon la résolution de micro-pas. Si l'état d'entrée sur cette broche est un niveau logique bas, toutes les entrées STEP seront ignorées. La broche Reset est une broche flottante donc si nous n'avons pas l'intention de la contrôler dans notre programme, nous devons la connecter à la broche SLEEP afin de la mettre à l'état haut et activer la carte.

Les 3 broches suivantes (MS1, MS2 et MS3) sont pour sélectionner l'une des cinq résolutions de pas selon le tableau de vérité ci-dessus. Ces broches ont des résistances de pull-down internes donc si nous les laissons déconnectées, la carte fonctionnera en mode pas complet.

La dernière, la broche ENABLE, est utilisée pour activer ou désactiver les sorties FET. Un niveau logique haut maintiendra les sorties désactivées.

Composants nécessaires pour ce tutoriel Arduino

Vous pouvez obtenir les composants sur les sites ci-dessous :

• Moteur pas à pas (NEMA17)
• Pilote pas à pas A4988
• Adaptateur 12V 2A
• Connecteur d'alimentation (Power Jack)
• Carte Arduino
• Plaque d'essai et fils de connexion

Schéma de câblage

Voici le schéma de câblage complet. J'utiliserai le pilote en mode Pas Complet donc je laisserai les 3 broches MS déconnectées et je connecterai juste les broches Direction et Step du pilote aux broches numéros 3 et 4 sur la carte Arduino ainsi que la masse et le 5V pour alimenter la carte. J'utiliserai aussi un condensateur de 100µF pour le découplage et un adaptateur 12V, 1,5A pour alimenter le moteur. J'utiliserai un moteur pas à pas bipolaire NEMA 17 et ses fils A et C seront connectés aux broches 1A et 1B et les fils B et D aux broches 2A et 2B.

Limitation de courant A4988

Avant de connecter le moteur, nous devrions régler la limitation de courant du pilote pour être sûr que le courant est dans les limites du moteur. Nous pouvons le faire en ajustant la tension de référence en utilisant le potentiomètre sur la carte et en considérant cette équation :

Cependant, cette équation n'est pas toujours correcte car il y a différents fabricants de la carte de pilote A4988. Voici une démonstration de mon cas : j'ai ajusté le potentiomètre et mesuré 0,6V de tension de référence. Donc la limitation de courant devrait être cette valeur de 0,6*2, égale 1,2 A.

Maintenant, comme j'utilise le pilote en mode Pas Complet et selon la fiche technique A4988, dans ce mode le courant de bobinage pourrait atteindre seulement 70% de la limite de courant, le 1,2A*0,7 donnerait 0,84A. Afin de vérifier cela, j'ai téléversé un code simple qui envoie un niveau logique haut continu à la broche Step (afin que nous puissions mieux remarquer le courant) et connecté mon multimètre en série avec un bobinage du moteur et l'ai alimenté. Ce que j'ai obtenu était 0,5A ce qui signifie que l'équation n'était pas correcte pour mon cas.

Code Arduino et A4988

Voici un exemple de code. D'abord, nous devons définir les broches Step et Direction. Dans notre cas, ce sont les broches numéros 3 et 4 sur la carte Arduino et elles sont nommées stepPin et dirPin et dans la section setup, nous devons les définir comme sorties.

/* Exemple simple de contrôle moteur pas à pas
 * 
 * by Dejan Nedelkovski, www.HowToMechatronics.com
 */
// Définit les numéros de broches
const int stepPin = 3;
const int dirPin = 4;

void setup() {
  // Définit les deux broches comme sorties
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}

void loop() {
  digitalWrite(dirPin, HIGH); // Permet au moteur de bouger dans une direction particulière
  // Fait 200 impulsions pour faire une rotation complète
  for(int x = 0; x < 200; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000); // Délai d'une seconde
  digitalWrite(dirPin, LOW); // Change le sens de rotation
  // Fait 400 impulsions pour faire deux rotations complètes
  for(int x = 0; x < 400; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}

Dans la section loop, d'abord nous mettrons la broche Direction à l'état haut ce qui permettra au moteur de bouger dans une direction particulière. Maintenant, en utilisant cette boucle for, nous ferons faire au moteur une rotation complète. Comme le pilote est réglé en mode Pas Complet et que notre moteur pas à pas a un angle de pas de 1,8 degrés, ou 200 pas, nous devons envoyer 200 impulsions dans la broche Step pour faire une rotation complète. Donc la boucle for aura 200 itérations et chaque fois elle mettra la broche Step à l'état haut puis bas pour créer les impulsions. Entre chaque digitalWrite, nous devons ajouter un délai dont la vitesse du moteur dépendra.

Après cette rotation complète, nous ferons un délai d'une seconde, puis changerons le sens de rotation en mettant la dirPin à l'état bas et maintenant ferons 2 rotations complètes avec cette boucle de 400 itérations. À la fin, il y a une seconde de délai supplémentaire. Maintenant, téléversons le code et voyons comment ça fonctionne.

J'ai fait un exemple de plus pour ce tutoriel, où je contrôle la vitesse du moteur en utilisant un potentiomètre. Voici le code source de cet exemple :

/* Exemple simple de contrôle moteur pas à pas
 * 
 * by Dejan Nedelkovski, www.HowToMechatronics.com
 */
// Définit les numéros de broches
const int stepPin = 3;
const int dirPin = 4;
int customDelay, customDelayMapped; // Définit les variables

void setup() {
  // Définit les deux broches comme sorties
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
  digitalWrite(dirPin, HIGH); // Permet au moteur de bouger dans une direction particulière
}

void loop() {
  customDelayMapped = speedUp(); // Obtient les valeurs de délai personnalisées de la fonction speedUp personnalisée
  // Fait des impulsions avec délai personnalisé, selon le potentiomètre, dont la vitesse du moteur dépend
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
}

// Fonction pour lire le potentiomètre
int speedUp() {
  int customDelay = analogRead(A0); // Lit le potentiomètre
  int newCustom = map(customDelay, 0, 1023, 300, 4000); // Convertit les valeurs lues du potentiomètre de 0 à 1023 en valeurs de délai désirées (300 à 4000)
  return newCustom;
}