Introduction

Un moteur pas à pas (stepper motor en anglais) permet de transformer une impulsion électrique en un mouvement angulaire.

On trouve trois types de moteur pas à pas :

  • Le moteur à reluctance variable
  • Le moteur à aimants permanents
  • Le moteur hybride, qui est une combinaison des deux technologies précédentes

Nous allons utiliser un moteur à aimant permanent -> 28BYJ-48

Les moteurs pas à pas sont utilisés pour les positionnements angulaires précis (imprimantes, scanners, disques durs …).

Les moteurs pas à pas possèdent de nombreux avantages. Ils sont bon marché et faciles à utiliser. Ils tiennent leur position, peuvent également tourner sans limites et changer de direction. La rotation peut être contrôlée de façon précise.

Quel est la différence entre moteur à courant continu, moteur pas à pas et Servo Moteur ?

Il existe plusieurs types de moteurs : moteur à courant continu, moteur pas à pas ou servomoteur qui ont différentes qualités, on va voir quel moteur est adapté à quel type de projet.

Le servomoteur est un moteur qui tourne qu’à 180 degrés. C’est-à-dire qu’il ne pourra jamais faire un tour complet sur lui-même, il va soit faire 180 degrés dans un sens, ou bien 180 degrés dans l’autre sens. Il ne sera pas adapté pour des projets ou le moteur doit faire des tours complets comme faire tourner des hélices d’un hélicoptère. Néanmoins on peut contrôler la position du servomoteur très précisément sous forme d’angle, comme dans un moteur pas à pas.

Le moteur à courant continu lui peut tourner à 360 degrés. Il sera utile pour faire tourner des hélices ou bien faire avancer une voiture par exemple. Néanmoins on ne peut pas contrôler l’angle d’un moteur à courant continu, il ne sera pas utilisable pour des projets où l’on recherche de la précision. 

Vous l’aurez compris, le moteur pas à pas est une sorte d’hybride entre le moteur à courant continu et le servomoteur. Il n’a pas les contraintes d’un servo moteur, c’est-à-dire qu’il peut faire un tour sur lui-même. De plus, il permet d’être contrôlé avec un angle précis, pas comme un moteur à courant continu. Néanmoins les moteurs pas à pas ne peuvent pas tourner à des vitesses très importantes.

Quels composants utiliser ?

Dans ce cours nous utiliserons un moteur à aimant permanent : 28BYJ-48.

C’est un moteur 5 V donc nous n’avons pas besoin de d’alimentation externe pour le faire fonctionner. Néanmoins d’autre moteur pas à pas doivent être alimenté en 12 V. Veiller donc à avoir une alimentation externe afin de pouvoir alimenter celui-ci.

Pour pouvoir faire tourner votre moteur pas à pas dans les deux sens, vous aurez besoin d’un pont en h qui va permettre d’inverser la tension à ses bornes. Pour cela vous avez deux possibilités : 

Le pont en h fournit avec votre moteur pas à pas :

Le pont en h inclut dans la carte motorshield :

Utiliser un moteur pas à pas avec une librairie

Pour le schéma, nous ne pouvons pas le représenter ici mais il faut bien que les deux fils d’alimentation soit séparé de deux broches sur les 4 avec le fils + proches des résistances et l’autre à l’opposé des deux autres broches.

#include <Stepper.h> 
const int stepsPerRevolution = 2048; // A modifier pour qu'il corresponde au nombre de pas par tour
const int pasParMinute = 15; // La plage réglable du pas à pas est de 0 à 17
Stepper myStepper(stepsPerRevolution, 8, 10, 9, 11); // initialisation des pins stepper moteur

void setup(){
    myStepper.setSpeed(pasParMinute);
}

void loop(){
    myStepper.step(stepsPerRevolution); // dans une direction
    delay(500);
    myStepper.step(-stepsPerRevolution); // dans l’autre direction
    delay(500);
}

Une bibliothèque existe pour contrôler le mouvement des moteurs pas à pas : Stepper.h. Mais il est également possible de les contrôler sans librairie.

Utiliser un moteur pas à pas sans librairie

Voici un programme qui vous permet d’utiliser un stepper moteur sans librairie. On vous a mis en commentaire les lignes que vous devez changer pour

Vous avez en gris dans le code ce qu’il faut ajouter pour faire fonctionner le même programme sans la librairie.

Voici le programme sans la librairie :

#define IN1 8 //Les define IN correspond aux broches ou vous allez brancher votre stepper motor
#define IN2 9
#define IN3 10
#define IN4 11

int Steps= 0; // On déclare les variables pour le sens du moteur, le nombre de pas et le temps pour lequel il va rester sur une position
boolean Direction = true;
unsigned long last_time;
unsigned long currentMillis ;
int steps_left=4095;
long time;

void setup(){
    Serial.begin(9600);
    pinMode(IN1, OUTPUT); // On declare les pins IN en sortie pour pouvoir les déclarer
    pinMode(IN2, OUTPUT);
    pinMode(IN3, OUTPUT);
    pinMode(IN4, OUTPUT);
}

void loop() {
    while(steps_left>0){
        currentMillis= micros();
        if(currentMillis-last_time>=1000){
            stepper(1);
            time=time+micros()-last_time;
            last_time=micros();
            steps_left--;
        }
    }
    Serial.println(time);
    Serial.println("Wait...!");
    delay(2000);
    Direction=!Direction;
    steps_left=4095;
}

void stepper(int xw){
    for (int x=0;x<xw;x++){
        switch(Steps){
        
        case 0:
        digitalWrite(IN1, LOW); // On controle ensuite les broches IN un à un pour faire tourner le moteur. Il y a beaucoup de digitalwrite mais ils sont tous utile pour faire tourner le moteur dans un sens puis un autre
        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;
        }
        SetDirection();
    }
}

void SetDirection(){
    if(Direction==1){
        Steps++;
    }
    if(Direction==0){
        Steps--;
    }
    if(Steps>7){
        Steps=0;
    }
    if(Steps<0){
        Steps=7;
    }
}

Pour le schéma, c’est exactement le même que celui avec librairie.

Utiliser un moteur pas à pas avec carte Motorshield

On va maintenant voire comment contrôler un stepper moteur avec une carte motorshield.

Voici le code sans librairie permettant de faire tourner le moteur dans le sens anti-horaire  :

void setup() {
    //On établit les broches de direction du moteur
    pinMode(12, OUTPUT); //Première partie du moteur pas à pas
    pinMode(13, OUTPUT); //Deuxième partie du moteur pas à pas
    
    //établir pin moteur
    pinMode(9, OUTPUT); //(disable)CH A
    pinMode(8, OUTPUT); //(disable) CH B
}

void loop(){
    digitalWrite(9, LOW); //ENABLE CH A
    digitalWrite(8, HIGH); //DISABLE CH B
    digitalWrite(12, HIGH); //Change de direction CH A
    analogWrite(3, 255); //Tourne CH A
    delay(5);
    digitalWrite(9, HIGH); //DISABLE CH A
    digitalWrite(8, LOW); //ENABLE CH B
    digitalWrite(13, LOW); //Change de direction CH B
    analogWrite(11, 255); //Tourne CH B
    delay(5);
    digitalWrite(9, LOW); //ENABLE CH A
    digitalWrite(8, HIGH); //DISABLE CH B
    digitalWrite(12, LOW); //Change de direction CH A
    analogWrite(3, 255); //Tourne CH A
    delay(5);
    digitalWrite(9, HIGH); //DISABLE CH A
    digitalWrite(8, LOW); //ENABLE CH B
    digitalWrite(13, HIGH); //Change de direction CH B
    analogWrite(11, 255); //Tourne CH B
    delay(5);
}

Ci-contre le schéma associé au code.

Comme vous pouvez voir vous n’avez pas besoin de la borne rouge.

Variation de vitesse du moteur pas à pas

1. Problème de seul de tension

Je pense que vous avez tous vu des circuits ou l’on modifie la vitesse d’un moteur à courant continu avec un potentiomètre. Dans ce cas ce ne sera pas possible car entre le moteur pas à pas  et la carte arduino uno il y a un pont en h.

Le pont en h pour fonctionner à besoin d’une certaine tension et il se coupe quand on lui applique une tension trop faible.

2. Variation de la vitesse dans le programme

Une des solutions au problème précédant est de faire varier la vitesse dans le programme du moteur pas à pas.

En reprenant le premier code de ce cours, on voit qu’il faut modifier cette ligne :

const int pasParMinute = 15; // La plage réglable du pas à pas est de 0 à 17

La plage réglable du pas à pas est de 0 à 17

Si on règle à 17 on est au plus vite et à 0 le moteur pas à pas ne tourne plus.