L’un des objectifs principaux de la robotique est d’articuler des objets. Pour se faire, il est très courant d’utiliser des moteurs électriques comme des moteurs pas à pas notamment lorsqu’on veut obtenir une bonne précision de mouvement en boucle ouverte.

Dans ce tutoriel, nous étudions l’utilisation de circuits intégrés pour le contrôle de moteur pas-à-pas. Pour vous simplifié la vie, il existe des Shields intégrant ces ICs et permettant de piloter plusieurs moteurs (Motor Shield V1 et Motor Shield V2). Il existe aussi des drivers spécifiques permettant d’obtenir des fonctionnalités et performances plus avancées comme le A4988 ou les TMC souvent utilisés dans les CNC.

prérequis: Programmez avec Arduino

Matériel

• Ordinateur
• Carte Arduino UNO
• Câble USB pour connecter la carte Arduino au PC
• ULN2003APG x1
• Breadboard x1
• Moteur pas-à-pas x1
• câbles de connexion

Moteur Pas-à-pas

Les moteurs pas-à-pas possèdent différentes phases qui permettent d’orienter la position du rotor. On peut donc transformer une séquence d’impulsions sur les différentes phases en déplacement angulaire. Comme la séquence à envoyer pour obtenir un certain déplacement est connue, on peut connaitre la position sans capteur supplémentaire et donc de piloter le moteur précisément en boucle ouverte.

Ils existent deux types principaux de moteur pas-à-pas unipolaire (5 ou 6 fils) et  bipolaire (4 fils) avec des caractéristiques pouvant varier comme le nombre de pas par révolution. Ces différences entrainent des modifications sur les paramètres de pilotage notamment sur le nombre de sorties nécessaires pour piloter le moteur. Afin de piloter correctement votre moteur, il est impératif d’avoir ces informations.

Transistor

Les moteurs pas-à-pas, comme leur nom l’indique, peuvent être pilotés pas à pas en appliquant la puissance électrique par séquence d’impulsions aux différentes phases du moteur. Pour les moteurs unipolaires, un réseau de transistor sera utilisé comme le ULN2003A qui possèdent un réseau de 7 transistors.

Pour les moteurs bipolaires, nous utilisons un pont en H, SN754410NE, qui peut piloter les deux bobines indépendantes du moteur.

Cas du moteur pas-à-pas 28BYJ-48

Schéma de connexion

Les moteurs pas-à-pas selon leurs caractéristiques nécessitent une tension d’alimentation de 3V, 5V ou plus. Une source d’énergie autre que la carte électronique doit être utiliser pour alimenter ces actionneurs si la tension est supérieur à 5V. Dans notre cas, le moteur peut être alimenté par la carte en 5V et la carte Arduino peut être alimentée par l’ordinateur via le port USB.

Code de base

Pour piloter le moteur, il faut activer les transistor en suivant une séquence précise. Le moteur pas à pas 28BYJ-48 effectue 2048 pas lors d’une rotation

#define IN1  11
#define IN2  10
#define IN3  9
#define IN4  8

int Steps = 0;
int Direction = 0;
int number_steps=512;//= 2048/4


void setup()
{
Serial.begin(9600);
pinMode(IN1, OUTPUT); 
pinMode(IN2, OUTPUT); 
pinMode(IN3, OUTPUT); 
pinMode(IN4, OUTPUT); 
// delay(1000);

}
void loop()
{
  //1 rotation counter clockwise
  stepper(number_steps);
  delay(1000);

  //1 rotation clockwise
  stepper(-number_steps);
  delay(1000);

  //Keep track of step number
  for(int thisStep=0;thisStep<number_steps;thisStep++){
    stepper(1);
  }
  delay(1000);

  for(int thisStep=number_steps;thisStep>0;thisStep--){
    stepper(-1);
  }
  delay(1000);
}

void stepper(double nbStep){
  if(nbStep>=0){
      Direction=1;
  }else{
      Direction=0;
      nbStep=-nbStep;
  }
  for (int x=0;x<nbStep*8;x++){
    switch(Steps){
       case 0:
         digitalWrite(IN1, LOW); 
         digitalWrite(IN2, LOW);
         digitalWrite(IN3, LOW);
         digitalWrite(IN4, HIGH);
       break; 
       case 1:
         digitalWrite(IN1, LOW); 
         digitalWrite(IN2, LOW);
         digitalWrite(IN3, HIGH);
         digitalWrite(IN4, HIGH);
       break; 
       case 2:
         digitalWrite(IN1, LOW); 
         digitalWrite(IN2, LOW);
         digitalWrite(IN3, HIGH);
         digitalWrite(IN4, LOW);
       break; 
       case 3:
         digitalWrite(IN1, LOW); 
         digitalWrite(IN2, HIGH);
         digitalWrite(IN3, HIGH);
         digitalWrite(IN4, LOW);
       break; 
       case 4:
         digitalWrite(IN1, LOW); 
         digitalWrite(IN2, HIGH);
         digitalWrite(IN3, LOW);
         digitalWrite(IN4, LOW);
       break; 
       case 5:
         digitalWrite(IN1, HIGH); 
         digitalWrite(IN2, HIGH);
         digitalWrite(IN3, LOW);
         digitalWrite(IN4, LOW);
       break; 
         case 6:
         digitalWrite(IN1, HIGH); 
         digitalWrite(IN2, LOW);
         digitalWrite(IN3, LOW);
         digitalWrite(IN4, LOW);
       break; 
       case 7:
         digitalWrite(IN1, HIGH); 
         digitalWrite(IN2, LOW);
         digitalWrite(IN3, LOW);
         digitalWrite(IN4, HIGH);
       break; 
       default:
         digitalWrite(IN1, LOW); 
         digitalWrite(IN2, LOW);
         digitalWrite(IN3, LOW);
         digitalWrite(IN4, LOW);
       break; 
    }
  delayMicroseconds(1000);
  if(Direction==1){ Steps++;}
  if(Direction==0){ Steps--;}
  if(Steps>7){Steps=0;}
  if(Steps<0){Steps=7;}
} 
} 

Librairie

Une librairie bien pratique existe pour gérer les mouvement de votre actionneur: Stepper.h.

#include <Stepper.h> 

double stepsPerRevolution = 2048;

Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11);  // Pin inversion to make the library work

void setup() { 
  myStepper.setSpeed(10);  
  Serial.begin(9600); 
  } 
  
  void loop() {  
    // 1 rotation counterclockwise:  
    Serial.println("counterclockwise");    
    myStepper.step(stepsPerRevolution);  
    delay(1000); 
     
   // 1 rotation clockwise: 
   Serial.println("clockwise");  
   myStepper.step(-stepsPerRevolution); 
   delay(1000); 
}

Ce code s’inspire de l’exemple fourni avec la librairie qu’on a modifié pour faire fonctionner le stepper  28BYJ-48 130061869. Les moteurs pas-à-pas peuvent être assez différents, il vous faut donc vérifier votre matériel avant de pouvoir le piloter.

Cas du moteur pas-à-pas 42HS34

Schéma de connexion

Dans ce cas, le moteur peut s’alimenter par la borne 3,3V (il est préférable d’utiliser une source extérieure) de la carte et la carte Arduino peut être alimentée par l’ordinateur via le port USB.

Code de base

Pour piloter le moteur bipolaire, nous utilisons une séquence de 4 étapes. Le modèle 42HS34 effectue 200 pas par rotation.

#define IN1  11
#define IN2  10
#define IN3  9
#define IN4  8

int Steps = 0;
int Direction = 0;
int number_steps=50; //= 200/4

void setup() {
  Serial.begin(9600);
  pinMode(IN1, OUTPUT); 
  pinMode(IN2, OUTPUT); 
  pinMode(IN3, OUTPUT); 
  pinMode(IN4, OUTPUT); 
}

void loop()
{
  //1 rotation counter clockwise
  stepper4(number_steps);
  delay(1000);

  //1 rotation clockwise
  stepper4(-number_steps);
  delay(1000);

  //Keep track of step number
  for(int thisStep=0;thisStep<number_steps;thisStep++){
    stepper4(1);
  }
  delay(1000);

  for(int thisStep=number_steps;thisStep>0;thisStep--){
    stepper4(-1);
  }
  delay(1000);
}

void stepper4(double nbStep){
  if(nbStep>=0){
      Direction=1;
  }else{
      Direction=0;
      nbStep=-nbStep;
  }
  for (int x=0;x<nbStep*4;x++){
    switch (Steps) {
      case 0:  // 1010
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, HIGH);
        digitalWrite(IN4, LOW);
      break;
      case 1:  // 0110
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, HIGH);
        digitalWrite(IN3, HIGH);
        digitalWrite(IN4, LOW);
      break;
      case 2:  //0101
        digitalWrite(IN1, LOW);
        digitalWrite(IN2, HIGH);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, HIGH);
      break;
      case 3:  //1001
        digitalWrite(IN1, HIGH);
        digitalWrite(IN2, LOW);
        digitalWrite(IN3, LOW);
        digitalWrite(IN4, HIGH);
      break;
    }
  delayMicroseconds(2000);
  if(Direction==1){ Steps++;}
  if(Direction==0){ Steps--;}
  if(Steps>3){Steps=0;}
  if(Steps<0){Steps=3;}
} 
} 

Librairie

Avec la librairie Stepper.h.

#include <Stepper.h>

const int stepsPerRevolution = 200;  

Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);

void setup() {
  myStepper.setSpeed(100);
  Serial.begin(9600);
}

void loop() {
  // 1 rotation clockwise: 
  Serial.println("clockwise");
  myStepper.step(stepsPerRevolution);
  delay(2000);

  // 1 rotation counterclockwise:
  Serial.println("counterclockwise");
  myStepper.step(-stepsPerRevolution);
  delay(2000);
}

Si vous rencontrez des difficultés pour faire réaliser ce tutoriel, n’hésitez pas à laisser un commentaire ou à nous contacter. Nous serons heureux de vous aider.

Prochaines étapes

• Piloter des moteurs avec un Motor Shield V1
• Piloter plusieurs moteurs avec le Motor Shield V2

Sources

• Librairie Stepper.h
• Description des moteurs pas-à-pas
• Prérequis: Programmez avec Arduino