Moteur pas à pas piloté par une carte A3967

Dans ce tutoriel, nous allons apprendre à utiliser le pilote de moteur pas à pas A3967.

Le module A3967 est un pilote pouvant commander des moteurs pas à pas bipolaires avec un courant se situant entre 150mA et 700mA par phase.

Le circuit intégré A3967 permet de piloter des moteurs à 4, 6 ou 8 fils. Il permet le fonctionnement avec des valeurs d'alimentations de 3,3V ou 5V, idéal avec un microcontrôleur tel qu'une carte ARDUINO©.

En bas à gauche de la carte, se situe deux petites soudures notées 3/5V. Si vous souhaitez rester en 5V, alors il faudra laisser par défaut celle-ci. En revanche, si vous souhaitez alimenter la carte en 3.3V, il faudra relier une soudure entre ces deux points.

Un peu plus à droite des deux point 3/5V, on retrouve deux autres soudures intitulées APWR.

En réalité, ce sont deux bornes pour récupérer du 5V: Une soudure pour le positif, et une seconde pour la masse.
Toujours à gauche au centre la carte, on constate un potentiomètre et un régulateur de tension LM317.

A : Correspond à la bobine A du moteur pas à pas.
B : Correspond à la bobine B du moteur pas à pas.
PFD : Tension d'entrée sélectionnant le mode de décroissance de la sortie courant.
RST : Il correspond au Reset, lorsque celui-ci est activé (HIGH) toutes les fonctions de commandes moteur sont désactivées, et remet toutes les broches à "0".
ENABLE : Entrée logique.
MS1 et MS2 : Correspondent à la résolution de pas.
- Lorsque MS1 et MS2 sont désactivés (HIGH), le moteur effectue un pas complet.
- Lorsque MS1 est activé et MS2 désactivé (LOW), le moteur effectue un demi-pas.
- Lorsque MS1 est désactivé et MS2 est activé, le moteur effectue un quart de pas.
GND : correspond à la masse
M+ : Alimentation externe comprise entre 6 et 30V.
SLP : Lorsqu'elle est désactivée (LOW), les sorties sont désactivées. La consommation d'énergie devient très faible.
STEP : Permet de faire avancer le moteur.
DIR : Permet de donner l'information du sens de rotation au moteur.

Passons à la pratique.

Sur le pilote du moteur, les broches du haut, de gauche à droite :

- A connecté à la première bobine du moteur
- B connecté à la seconde bobine du moteur
- ENABLE connecté à la PIN 6 de la carte NANO
- MS2 connecté à la PIN 5 de la carte NANO
- GND et M+ (non câblé sur le schéma) à une alimentation externe allant de 6 à 30 Volts.

Sur le pilote du moteur, les broches du bas, de gauche à droite :

- GND à la masse de la carte NANO
- 5V à l'alimentation de la carte NANO
- MS1 connecté à la PIN 4 de la carte NANO
- STEP connecté à la PIN 2 de la carte NANO
- DIR connecté à la PIN 3 de la carte NANO

/* Bienvenue sur les tutoriels d'IHM-3D, vous pouvez retrouver le module A3967 ainsi que les moteurs pas à pas sur notre boutique en ligne sur le site www.ihm3d.fr */

//Declaration des pins du driver
#define stp 2
#define dir 3
#define MS1 4
#define MS2 5
#define EN 6

char user_input;
int x;
int y;
int state;

//Déclaration des boutons

int BP1 = A0;
int BP2 = A1;
int BP3 = A2;

void setup() {

Serial.begin (9600);
Serial.println ("Bienvenue sur les tutoriels d'IHM-3D");
Serial.println ("Attente d'une nouvelle commande");
Serial.println ("");
Serial.println ("====================================================");
Serial.println ("");
pinMode(stp, OUTPUT);
pinMode(dir, OUTPUT);
pinMode(MS1, OUTPUT);
pinMode(MS2, OUTPUT);
pinMode(EN, OUTPUT);
pinMode (BP1, INPUT_PULLUP);
pinMode (BP2, INPUT_PULLUP);

resetEDPins(); //reset par défaut des pin du module
}

void loop() {

if (digitalRead (BP1) == LOW) {
digitalWrite(EN, LOW);
Rotationmoteurdefaut();
}
else if (digitalRead (BP2) == LOW) {
//Button two is pressed!
digitalWrite(EN, LOW);
Rotationmoteurinverse();
}
resetEDPins();
}
//Fonction Reset
void resetEDPins()
{
digitalWrite(stp, LOW);
digitalWrite(dir, LOW);
digitalWrite(MS1, LOW);
digitalWrite(MS2, LOW);
digitalWrite(EN, HIGH);
}

//Fonctionnement du moteur dans sa rotation par défaut
void Rotationmoteurdefaut()
{
Serial.println("Fonctionnement du moteur dans sa rotation par defaut");
digitalWrite(dir, LOW);
for (x = 1; x < 1000; x++)
  {
    digitalWrite(stp, HIGH);
    delay(1);
    digitalWrite(stp, LOW);
    delay(1);
  }
  Serial.println ("Attente d'une nouvelle commande");
  Serial.println ("");
  Serial.println ("====================================================");
  Serial.println ("");
}
//Fonctionnement du moteur dans sa rotation inverse
void Rotationmoteurinverse()
{
  Serial.println ("Fonctionnement du moteur dans sa rotation inverse");
  digitalWrite(dir, HIGH);
  for (x = 1; x < 1000; x++)
  {
    digitalWrite(stp, HIGH);
    delay(1);
    digitalWrite(stp, LOW);
    delay(1);
  }
  Serial.println ("Attente d'une nouvelle commande");
  Serial.println ("");
  Serial.println ("====================================================");
  Serial.println ("");
}

En pressant sur le premier bouton, le moteur tourne dans son sens de rotation par défaut.

En appuyant sur le second bouton, le moteur tourne dans le sens inverse.

Une fois le cycle terminé, le moniteur série indique qu'il est en attente d'une nouvelle commande.

Nous venons d'étudier comment piloter un moteur pas à pas avec un driver A3967 piloter par deux boutons, un bouton pour que le moteur puisse tourner dans son sens de rotation par défaut, et le second bouton dans le sens inverse de rotation par défaut.

Cependant, le moteur fonctionnera toujours avec le nombre de pas qui lui est assigné dans le programme. On retrouve les valeurs de pas dans la fonction "Rotationmoteurdéfaut" et "Rotationmoteurinverse".

Dans la suite, nous allons rajouter deux boutons et un potentiomètre. Les deux boutons serviront à augmenter ou diminuer le nombre de pas désirés. Comme il peut être fastidieux, par exemple, de presser 1000 fois sur le bouton pour que le moteur puisse effectuer 1000 pas, le potentiomètre servira de coefficient multiplicateur. Nous pourrons le configurer dans le programme comme ceci :

Nous effectuons la fonction map du microcontrôleur. Il exécute un produit en croix avec les valeurs du potentiomètre (0 à 1023) et nos valeurs attribuées (1 à 21 pour notre exemple). Si je règle mon potentiomètre à une valeur de 500, il suffit d'effectuer le calcul suivant pour connaître notre coefficient :
500 x 21 / 1023 ≈ 10
Notre coefficient multiplicateur sera 10. Si je presse 10 fois sur le bouton qui augmente le nombre de pas, alors, lorsque le moteur démarrera, il effectuera 100 pas.
Si tout est clair, passons aux montages et à la programmation.

- Nous sélectionnons le même matériel que pour le montage du précédent chapitre en rajoutant :

- Une petite bread board

- Un potentiomètre de 10kΩ

- Deux boutons

Nous appliquons le même montage que précédemment en rajoutant un platine d'essai sur lequel viennent se greffer les deux boutons poussoir et le potentiomètre. Ne pas oublier d'alimenter la bread board aux extrémités avec une masse (GND) et le 5V.
- Le premier bouton sera connecté sur la PIN 7 de la carte.
- Le second bouton connecté sur la PIN 8 de la carte.
- Pour finir, la consigne du potentiomètre sur la PIN 9 de la carte.

/* Bienvenue sur les tutoriels d'IHM-3D, vous pouvez retrouver le module A3967 ainsi que les moteurs pas à pas sur notre boutique en ligne sur le site www.ihm3d.fr */
 
//Déclaration des pins du driver
 
#define stp 2
#define dir 3
#define MS1 4
#define MS2 5
#define EN  6
 
char user_input;
int x;
int y;
int state;
 
//Déclaration des boutons de commande moteur
 
int BP1 = A0;
int BP2 = A1;
 
//Déclaration des boutons qui déterminent le nombre de pas
 
int BPDOWN = A2;
int BPUP = A3;
 
// variable interruption + mémoire du comptage de pas
 
int comptage = 0, ETATBP1, ETATBP2, Memoire = LOW;
 
//la valeur correspond au résultat finale du nombre de pas souhaité
 
int valeur;
 
//Temps pour le réglage de la valeur du coefficient multiplicateur du nombre de pas
 
unsigned long previousMillis = 0;
const long interval = 2000;
 
int coeff = A4; // potentiometre multiplicateur
int steps = coeff; // la valeur steps = coeff
 
void setup() {
 
  Serial.begin (9600);
  Serial.println ("Bienvenue sur les tutoriels d'IHM-3D");
  Serial.println ("Attente d'une nouvelle commande");
  Serial.println ("");
  Serial.println ("====================================================");
  Serial.println ("");
  pinMode(stp, OUTPUT);
  pinMode(dir, OUTPUT);
  pinMode(MS1, OUTPUT);
  pinMode(MS2, OUTPUT);
  pinMode(EN, OUTPUT);
 
  //Déclaration des boutons de commande moteur
 
  pinMode (BP1, INPUT_PULLUP);
  pinMode (BP2, INPUT_PULLUP);
 
  // Déclaration des boutons du nombre de pas moteur
 
  pinMode (BPDOWN, INPUT_PULLUP);
  pinMode (BPUP, INPUT_PULLUP);
 
 
  resetEDPins(); //reset par défaut des pin du module
}
 
void loop() {
 
  if (digitalRead (BP1) == LOW) {
    digitalWrite(EN, LOW);
    Rotationmoteurdefaut();
  }
  else if (digitalRead (BP2) == LOW) {
   
    digitalWrite(EN, LOW);
    Rotationmoteurinverse();
  }
  resetEDPins();
 
  steps = analogRead (coeff);
  steps = map (steps, 0, 1023, 1, 21);// produit en croix pour déterminer la valeur du coefficient multiplicateur de pas.
 
  unsigned long currentMillis = millis();
 
  if (currentMillis - previousMillis >= interval) {
 
    previousMillis = currentMillis;
 
    Serial.println ("=====================================================");
    Serial.println ("VALEUR POTENTIOMETRE MULTIPLICATEUR");
    Serial.println (steps);
  }
  /*====================================================================*/
 
  ETATBP1 = digitalRead(BPUP);
 
  if ((ETATBP1 != Memoire) && (ETATBP1 == HIGH))
  {
 
    comptage++;// je monte le nombre de pas
    valeur = (comptage * steps);// je multiplie le comptage qui x1 au multiplicateur qui est x le nombre choisie
    Serial.println ("=====================================================");
    Serial.println ("VALEUR AVEC COEFF");
    Serial.println (valeur);
 
    delay(250);
  }
  Memoire = ETATBP1;
 
  ETATBP2 = digitalRead(BPDOWN);
 
  if ((ETATBP2 != Memoire) && (ETATBP2 == HIGH))
  {
    comptage--;// je descends le nombre de pas
 
    valeur = (comptage * steps);
 
    Serial.println ("=====================================================");
    Serial.println ("VALEUR AVEC COEFF");
    Serial.println (valeur);
 
    delay(250);
  }
  Memoire = ETATBP2;
 
}
//Fonction Reset
void resetEDPins()
{
  digitalWrite(stp, LOW);
  digitalWrite(dir, LOW);
  digitalWrite(MS1, LOW);
  digitalWrite(MS2, LOW);
  digitalWrite(EN, HIGH);
}
 
//Fonctionnement du moteur dans sa rotation par défaut
void Rotationmoteurdefaut()
{
  Serial.println("Fonctionnement du moteur dans sa rotation par defaut");
  digitalWrite(dir, LOW);
  for (x = 1; x < valeur; x++)
  {
    digitalWrite(stp, HIGH);
    delay(1);
    digitalWrite(stp, LOW);
    delay(1);
  }
  Serial.println ("Attente d'une nouvelle commande");
  Serial.println ("");
  Serial.println ("====================================================");
  Serial.println ("");
}
 
//Fonctionnement du moteur dans sa rotation inverse
void Rotationmoteurinverse()
{
  Serial.println ("Fonctionnement du moteur dans sa rotation inverse");
  digitalWrite(dir, HIGH);
  for (x = 1; x < valeur; x++)
  {
    digitalWrite(stp, HIGH);
    delay(1);
    digitalWrite(stp, LOW);
    delay(1);
  }
  Serial.println ("Attente d'une nouvelle commande");
  Serial.println ("");
  Serial.println ("====================================================");
  Serial.println ("");
}

Pour terminer, je choisis la commande que je souhaite. Dans l'exemple, la fonction sens de rotation a été effectué en premier, et ensuite la fonction moteur par défaut.

Commande du moteur pas à pas à l'aide d'un joystick.

Le joystick est ni plus ni moins que deux potentiomètres pouvant contrôler deux axes x et y. Pour cet exemple nous utiliserons qu'un seul axe. Attention cet essai ne permet pas de faire varier la vitesse en fonction de l'action créé sur le Joystick :

Sur le pilote du moteur, les broches du haut, de gauche à droite :

- A connecté à la première bobine du moteur
- B connecté à la seconde bobine du moteur
- SLP connecté à la PIN 9 de la carte NANO
- MS2 connecté à la PIN 5 de la carte NANO
- GND et M+ (non câblé sur le schéma) à une alimentation externe allant de 6 à 30 Volts.

Sur le pilote du moteur, les broches du bas, de gauche à droite :

- GND à la masse de la carte NANO
- 5V à l'alimentation de la carte NANO
- MS1 connecté à la PIN 4 de la carte NANO
- STEP connecté à la PIN 2 de la carte NANO
- DIR connecté à la PIN 3 de la carte NANO
- La consigne du joystick sur A0 de la carte NANO

/* Bienvenue sur les tutoriels d'IHM-3D, vous pouvez retrouver le module A3967 ainsi que les moteurs pas à pas sur notre boutique en ligne.*/
 
//permet de contrôler le moteur pas à pas avec un joystick dans les deux sens de rotations.
//contrôleur EASY DRIVER A3967
//moteur pas à pas de type NEMA retrouvez le dans notre boutique.
 
#define stp 2
#define dir 3
#define MS1 4
#define MS2 5
#define SLEEP 9
 
#define Joystick A0
 
int steps = 1000;
 
void setup() {
 
  Serial.begin(9600);
  Serial.println ("Bienvenue sur les tutoriels d'IHM-3D");
 
  pinMode(MS1, OUTPUT);
  pinMode(MS2, OUTPUT);
  pinMode(dir, OUTPUT);
  pinMode(stp, OUTPUT);
  pinMode(SLEEP, OUTPUT);
 
  digitalWrite(SLEEP, HIGH);
  delay(5);
 
  digitalWrite(MS1, LOW);
  digitalWrite(MS2, LOW);
}
void loop() {
 
  while (analogRead(Joystick) >= 0 && analogRead(Joystick) <= 100) {
    if (steps > 0) {
      digitalWrite(dir, HIGH);
      digitalWrite(stp, HIGH);
      delay(1);
      digitalWrite(stp, LOW);
      delay(1);
      steps--;
    }
  }
 
  while (analogRead(Joystick) > 900 && analogRead(Joystick) <= 1024) {
    if (steps < 1000) {
      digitalWrite(dir, LOW);
      digitalWrite(stp, HIGH);
      delay(1);
      digitalWrite(stp, LOW);
      delay(1);
      steps++  ;
    }
  }
}
/******************************FIN DU PROGRAMME*****************************/
 

Ce document tutoriel est maintenant terminé. N'hésitez pas à parcourir le site d'IHM-3D et de découvrir ses activités et de poser vos questions à l'adresse située en pied de page.

6.68 €
Permet de piloter facilement des moteurs pas à pas. Livré avec les broches.

Plus...

10.10 €

Plus...