Connexion du moteur pas à pas 28BYJ-48 et le module UNL2003 à la carte d’Arduino.

Connexion du moteur pas à pas 28BYJ-48 et le module UNL2003 à la carte d'Arduino.
Connexion du moteur pas à pas 28BYJ-48 et le module UNL2003 à la carte d'Arduino.

Dans cet article on pratiquera avec le moteur pas à pas unipolaire 28BYJ-48. C’est un moteur économique que nous pouvons utiliser en plusieurs projets como la fabrication de petits robots, d’imprimantes 3D ou photocopieuses. Ici, nous allons nous centrer sur la connexion avec la plaque Arduino et sa programmation .

Les moteur pas à pas se caractérisent par effectuer des mouvements très précis en petits angles. Le moteur pas à pas unipolaire 20BYJ-48 est fourni avec le module UNL2003 qui proportionnera le courant nécessaire au moteur.

Schéma de montage.

La connexion entre le module contrôleur et le moteur est simple puisque il existe un connecteur avec des rainures qui sert à guider l’union entre les deux dispositifs.

Le module UNL2003 possède quatre diodes qui nous indiquerons quelle bobine est active à chaque moment.

La sortie de 5 V de la plaque Arduino est suffisante pour fournir d’énergie le moteur, néanmoins si notre projet a plus d’éléments connectés, on devrait utiliser une source externe de 5 V parce que on risque d’excéder le courant capable de approvisionner le microcontrôleur.

Les pins IN1, IN2, IN3, et IN4 se connectent aux quatre sorties digitales d’Arduino.

  • pin 8 -> IN1
  • pin 9 -> IN2
  • pin 10 -> IN3
  • pin 11 -> IN4
Connexion du moteur 28BYJ-48 et module UNL2003 à Arduino
Connexion du moteur 28BYJ-48 et module UNL2003 à Arduino

Nous pouvons programmer le moteur pas à pas de deux façons: manuelle ou bien avec la bibliothèque Stepper (elle nous permet de contrôler des moteurs pas à pas unipolaires et bipolaires).

Programmation du moteur unipolaire de 4 bobines pas complet simple.

Chaque bobine s’active par séquence, cela fait atténuer les pas du moteur mais contrairement le moteur aura moins de force et de retenue.

Séquence du moteur pas à pas unipolaire
Séquence du moteur pas à pas unipolaire

Regardant ce schéma on voit que le moteur est représenté avec quatre bobines, la flèche nous indique comment pivote le rotor. Dans le pas 1 on fait passer le courant par la bobine A, dans le pas 2 le courant passe par la bobine B, générant un champ magnétique et provocant la rotation du rotor 90º en sens horaire.

En somme, un cycle exige 4 pas, un tour complet du rotor exige 8 cycles et un tour complet de l’axe extérieur demande 64 tours du rotor, c’est pour cette raison qu’on nécessite 2048 pas pour une révolution (tour) du moteur.

Nº de pas pour un tour complet = 4 x 8 x 64 = 2048

Voici le code pour réussir un tour complet du moteur:

int IN1 = 8;      // pin digital 8 relié à IN1
int IN2 = 9;      // pin digital 9 à IN2
int IN3 = 10;     // pin digital 10 à IN3
int IN4 = 11;     // pin digital 11 à IN4
int temps = 20;  // temps entre les pas, minimum 10 ms.

void setup(){
  // tous les pins se configurent comme sorties
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
}

void loop(){
  // 512*4 = 2048 pas pour un tour complet
  for (int i = 0; i < 512; i++) {
    digitalWrite(IN1, HIGH);  // pas 1 
    digitalWrite(IN2, LOW);
    digitalWrite(IN3, LOW);
    digitalWrite(IN4, LOW);
    delay(temps);

    digitalWrite(IN1, LOW);   // pas 2
    digitalWrite(IN2, HIGH);
    digitalWrite(IN3, LOW);
    digitalWrite(IN4, LOW);
    delay(temps);

    digitalWrite(IN1, LOW);   // pas 3
    digitalWrite(IN2, LOW);
    digitalWrite(IN3, HIGH);
    digitalWrite(IN4, LOW);
    delay(temps);

    digitalWrite(IN1, LOW);   // pas 4
    digitalWrite(IN2, LOW);
    digitalWrite(IN3, LOW);
    digitalWrite(IN4, HIGH);
    delay(temps);
  }
  // pause de 5 secondes
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
  delay(5000);
}

C’est un code vraiment long, pour l’abréger on peut utiliser un array (matrice) bidimensionnel afin d’indiquer quelle bobine est active à chaque pas:

int IN1 = 8;      // pin digital 8 relié à IN1
int IN2 = 9;      // pin digital 9 à IN2
int IN3 = 10;     // pin digital 10 à IN3
int IN4 = 11;     // pin digital 11 à IN4
int temps = 20;  // temps entre les pas, minimun 10 ms.
// Array bidimensionnel avec la séquence des pas
int pas [4][4] = {
  {1, 0, 0, 0},
  {0, 1, 0, 0},
  {0, 0, 1, 0},
  {0, 0, 0, 1}
};

void setup(){
  // tous les pins se configurent comme sorties
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
}

void loop(){
  // 512*4 = 2048 pas
  for (int i = 0; i < 512; i++){
    // boucle repasse le array ligne à ligne
    for (int i = 0; i < 4; i++){
      // valeurs que nous allons appliquer
      digitalWrite(IN1, pas[i][0]);
      digitalWrite(IN2, pas[i][1]);
      digitalWrite(IN3, pas[i][2]);
      digitalWrite(IN4, pas[i][3]);
      delay(temps);
    }
  }
  // pause de 5 secondes
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
  delay(temps);
}

Vous remarquez la ressemblance entre le array et le tableaux schématique de la séquence pas à pas unipolaire du début?

Programmation du moteur unipolaire pas complet avec 2 bobines.

C’est la recommandée par le fabricant puisque elle permet un maximum de force.

Séquence pas à pas unipolaire avec 2 bobines
Séquence pas à pas unipolaire avec 2 bobines

Si nous observons le pas 1, le courant passe par les bobines A et B à la fois de façon que la flèche du rotor se situe entre les deux bobines. De cette manière pour compléter un cycle il faut 4 pas, un tour complet du rotor a besoin de 8 cycles, et le tour complet de l’axe extérieur exige 64 tours. Exactement comme le modèle antérieur.

Le code nécessaire pour faire un tour complet du moteur:

int IN1 = 8;      // pin digital 8 relié à IN1
int IN2 = 9;      // pin digital 9 à IN2
int IN3 = 10;     // pin digital 10 à IN3
int IN4 = 11;     // pin digital 11 à IN4
int temps = 20;  // temps entre les pas, minimum 10 ms.
// Array bidimensionnel indiquant la séquence des pas
int pas [4][4] ={
  {1, 1, 0, 0},
  {0, 1, 1, 0},
  {0, 0, 1, 1},
  {1, 0, 0, 1}
};

void setup(){
  // tous les pins se configurent comme sorties
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
}

void loop(){
  // 512*4 = 2048 pas
  for (int i = 0; i < 512; i++){
    // boucle repasse le array ligne à ligne
    for (int i = 0; i < 4; i++){
      // valeurs qu'on va appliquer
      digitalWrite(IN1, pas[i][0]);
      digitalWrite(IN2, pas[i][1]);
      digitalWrite(IN3, pas[i][2]);
      digitalWrite(IN4, pas[i][3]);
      delay(temps);
    }
  }
  // pause de 5 secondes
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
  delay(temps);
}

Programmation du moteur unipolaire à mi-pas.

Ce code permet que le moteur tourne dans un angle plus petit gagnant une majeure précision.

Séquence pas à pas avec deux bobines, mi-pas.
Séquence pas à pas avec deux 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. Pour un tour complet du moteur sont nécessaires: 8 x 8 x 64 = 4096 pas pour une révolution.

Le code:

int IN1 = 8;      // pin digital 8 relié à IN1
int IN2 = 9;      // pin digital 9 à IN2
int IN3 = 10;     // pin digital 10 à IN3
int IN4 = 11;     // pin digital 11 à IN4
int temps = 20;  // temps entre les pas, minimum 10 ms.
// Array bidimensionnel qu'indique la séquence des pas 
int pas [8][4] ={
  {1, 0, 0, 0},
  {1, 1, 0, 0},
  {0, 1, 0, 0},
  {0, 1, 1, 0},
  {0, 0, 1, 0},
  {0, 0, 1, 1},
  {0, 0, 0, 1},
  {1, 0, 0, 1}
};

void setup(){
  // tous les pins se configurent comme sorties
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
}

void loop(){
  // 512*8 = 4096 pas
  for (int i = 0; i < 512; i++){
    // boucle repasse le array ligne à ligne
    for (int i = 0; i < 8; i++){
      // valeurs qu'on va appliquer 
      digitalWrite(IN1, pas[i][0]);
      digitalWrite(IN2, pas[i][1]);
      digitalWrite(IN3, pas[i][2]);
      digitalWrite(IN4, pas[i][3]);
      delay(temps);
    }
  }
  // pause de 5 secondes
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, LOW);
  digitalWrite(IN3, LOW);
  digitalWrite(IN4, LOW);
  delay(temps);
}

Bibliothèque Stepper pour le contrôle du moteur pas à pas.

Cette bibliothèque nous assurera le contrôle des moteurs pas à pas unipolaires et bipolaires.

Les fonctions que nous devons connaître sont:

  • stepper(pas, pin1, pin2, pin3, pin4)

Cette fonction crée un nouvel objet connecté à la plaque Arduino. Les paramètres de ce mandat sont:

pas -> nombre de pas dans une révolution du moteur.

pin1, pin2, pin3, pin4 -> pins connectés au moteur.

  • setSpeed(rpm)

Sert à configurer la vitesse du moteur en révolutions par minute.

  • step(pas)

Sert à démarrer le moteur pendant un nombre determiné de pas.

Code:

#include <Stepper.h>

//  nous créons l'objet moteur
Stepper moteur(2048, 8, 10, 9, 11);
 
void setup() {
  moteur.setSpeed(2);
}
 
void loop() {
  moteur.step(200); // nombre de pas
  delay(2000);      // pause de 2 secondes
}

L’en-tête du programme inclut la bibliothèque et génère un nouvel objet nommé « moteur ».

#include <Stepper.h>
Stepper moteur(2048, 8, 10, 9, 11);

Dans la fonction stepper() on indique le nombre de pas (2048) et le pins auxquels est connecté le moteur. À savoir: cette bibliothèque uniquement autorise la méthode du moteur à pas complet avec deux bobines.

Nous avons rangé les pins dans cet ordre (8,10,9,11) afin de faire tourner le moteur dans le sens contraire des aiguilles d’une montre.

Dans la fonction setup() on configure la vitesse en rpm, nous devons choisir entre 1, 2 ou 3. Nous avons configuré la vitesse 2.

void setup() {
  moteur.setSpeed(2);
}

Dans la fonction loop() on indique le nombre de pas que avancera le moteur:

moteur.step(200);

Pour inverser le sens de rotation, on doit tout simplement indiquer le nombre de pas avec des chiffres négatifs. Par exemple:

#include <Stepper.h>

// nous créons l'objet moteur
Stepper moteur(2048, 8, 10, 9, 11);
 
void setup() {
  moteur.setSpeed(1);
}
 
void loop() {
  moteur.step(200); // nombre de pas
  delay(2000);      // pause
  moteur.step(-300); // nombre de pas
  delay(2000);      // pause
}
Articles similaires
Laisser un commentaire