UTILISER UN MOTEUR PAS À PAS

Auteur : Damien MUTI DESGROUAS

Date : 05/11/2020

Licence : libre !

Contexte : Apprentissage

Fichiers : liens éventuels

https: tutoriel Arduino

Présentation

Principe de fonctionnement

Un moteur pas à pas est un moteur contrôlé par une série de bobines électromagnétiques. L’arbre central est équipé d’une série d’aimants sur lequel ils sont fixés.

Les bobines entourant l’arbre sont alternativement alimentées en courant électrique créant des champs magnétiques qui repoussent ou attirent les aimants sur l’arbre, provoquant ainsi la rotation du moteur.

Cette conception permet un contrôle très précis du moteur. En effet en alimentant le moteur par des impulsions appropriées, la rotation de l'arbre peut être décomposé en rotation élémentaire dont l'angle d’incréments est très précis (par exemple, incréments de deux degrés, incréments de demi-degré, etc.).

Les moteurs pas à pas sont utilisés dans les imprimantes, les lecteurs de disque et d’autres dispositifs où le positionnement précis du moteur est nécessaire.

Différentes explications en vidéos sont accessibles sur les liens suivants :

U=RI

Retro Geek

Référence : Tutoriel sur les moteurs pas à pas de Tom Igoe

Moteur unipolaire pas à pas 28BYJ-48

Nous proposons ici d'utiliser le moteur unipolaire pas à pas 28BYJ-48 :

Description des connexions

La couleur des fils du moteur dont nous disposons ici n'est pas la même que le schéma ci-dessus.

La fiche technique du moteur est accessible sur les liens suivants :

sur le web : 28BYJ-48

En local : 28BYJ-48

Il est à noter que le couple de rotation de ce moteur est de 34.3mN.m (à 120Hz).

Ligne de transistor ULN2004 - Driver du moteur

Ce moteur nécessite l'utilisation d'une ligne de transistor ULN2003A ou ULN2004 représentant un Driver. La datasheet de ce composant est disponible sur le lien suivant :

Datasheet UNL2003 et UNL2004

La disposition des broches est la suivante :

Précaution d'emploi (À vérifier)

La datasheet du moteur 28BYJ-48 donne :

Speed Variation Ratio (rapport de variation de vitesse) : 1/64

Stride Angle (incrément angulaire): 5.625° /64

Nombre de pas par tour (360°)

On remarque que l'angle 5.625° = 360°/64. Par conséquent, la datasheet stipule que théoriquement le plus petit angle de variation de l'axe du moteur est de 5.625°/64 soit (360°/64)/64 = 360°/4096.

Il faut donc théoriquement 4096=2^11 pas (steps) pour effectuer un tour complet à la vitesse définie par la méthode myStepper.setSpeed() de la librairie Stepper.h sur Arduino.

En pratique un tour complet (360°) est effectué en 2048=2^10 pas.

Vitesse angulaire

La vitesse de rotation angulaire du moteur est définie par la méthode myStepper.setSpeed() de la librairie Stepper.h sur Arduino. Cette méthode prend en argument un paramètre exprimée dans la documentation d'Arduino en rpm (round per minute, nombre de coup par minutes).

ATTENTION : Sur la documentation d'Arduino de cette fonction, l'argument rpm est exprimé en “rotation per minute” ce qui est faux !! Il s'agit bien de “round per minute”, c'est à dire “coup par minute” ou encore “nombre de step (pas) par minute”.

Une expérience montre qu'avec le moteur 28BYJ-48 le paramètre rpm fixé à 200 entraîne une période de rotation T=9600ms, soit 2048 pas effectués en 9,600s. Ceci implique, par proportionnalité un rpm (nombre de pas par minute) de 12800. On remarque que cette valeur (12800) est 64 fois plus importante que le rpm fixé initialement comme paramètre d'entrée de la fonction myStepper.setSpeed(). On retrouve le rapport (1/64) précisé dans la datasheet concernant le “Speed Variation Ratio”.

A VOIR: Le facteur 64 peut aussi venir du paramètre stepsPerRevolution fixé lors de l'instanciation de la classe Stepper, au tout début du programme (voir Code2 ci-après).

En pratique cela signifie que, si rpm est le paramètre d'entrée de la méthode myStepper.setSpeed(), le nombre de coup par minute effectué par le système (arduino+moteur) est:

rpm' = rpm*64.

ATTENTION : L'expérience montre qu'un paramètre rmp supérieur à 500 entraîne un dysfonctionnement du moteur 28BYJ-48. L'axe de celui-ci ne se met plus tout le temps en rotation...

Un exemple pratique

Nous souhaitons, par exemple, qu'une bobine entraîne un fil de nylon sur 2 tours complets à la vitesse fixée par le paramètre d'entrée de la fonction myStepper.setSpeed(), rpm = 200 (rpm/64). On rappelle que pour le moteur 28BYJ-48, le nombre de pas pour un tour complet est tour=2048.

Les paramètres à fixer dans le programme sont donc les suivants :

tour=2048

rpm=200 => rpm' = rpm*64 = 12800 steps/min

nbTour = 2

La période de rotation du moteur pas à pas est donc : T = tour/rpm' = 2048/12800 = 0,16 min = 9,6 s.

Matériel

Quelques revendeurs :

Gotronic

Amazon 1 , Amazon 2

Montage

Tutoriel Arduino

Le montage est le suivant :

Code 1 : Réglage de la vitesse de rotation avec un potentiomètre

/*
Stepper Motor Control - speed control
This program drives a unipolar or bipolar stepper motor.
The motor is attached to digital pins 8 - 11 of the Arduino.
A potentiometer is connected to analog input 0.
The motor will rotate in a clockwise direction. The higher the potentiometer value,
the faster the motor speed. Because setSpeed() sets the delay between steps,
you may notice the motor is less responsive to changes in the sensor value at
low speeds.
Created 30 Nov. 2009
Modified 28 Oct 2010
by Tom Igoe
*/
#include <Stepper.h>
const int stepsPerRevolution = 200; // change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
//Stepper myStepper = Stepper(steps, pin1, pin2, pin3, pin4)
int stepCount = 0; // number of steps the motor has taken
void setup() {
// nothing to do inside the setup
}
void loop() {
// read the sensor value:
int sensorReading = analogRead(A0);
// map it to a range from 0 to 100:
int motorSpeed = map(sensorReading, 0, 1023, 0, 100);
// set the motor speed:
if (motorSpeed > 0) {
myStepper.setSpeed(motorSpeed);
// step 1/100 of a revolution:
myStepper.step(stepsPerRevolution / 100);
}
}

Le code Arduino est le suivant : stepper_speedcontrol_1.ino.zip

Une vidéo de test est disponible sur ce lien Youtube : Arduino - Moteur pas à pas 28BYJ-48 - Réglage de la vitesse de rotation

Code 2 : tour complet et sens inverse - mesure de la période

/*
Stepper Motor Control - one revolution
This program drives a unipolar or bipolar stepper motor.
The motor is attached to digital pins 8 - 11 of the Arduino.
The motor should revolve one revolution in one direction, then
one revolution in the other direction.
*/
#include <Stepper.h>
const int stepsPerRevolution = 64; // change this to fit the number of steps per revolution
// for your motor
// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
int compteurLoop = 0, tour = 2048, nbTour = 2; // 1 tour représente 2048 pas du moteur
unsigned long timer0 = 0;
void setup() {
// set the speed at N steps/s:
myStepper.setSpeed(200);
// initialize the serial port:
Serial.begin(9600);
}
void loop() {
// step one revolution in one direction:
if (compteurLoop == 0) {
timer0 = millis();
}
// step one revolution in one direction:
//Serial.println("clockwise");
timer0 = millis(); // lancer chrono
myStepper.step(nbTour * tour); // effectuer nbTour=2 tours c'est à dire 2*2048 pas
unsigned long t = (millis() - timer0);
Serial.print("Période : ");
Serial.print(t/2);
Serial.println("ms");
delay(500);
// step one revolution in the other direction:
//Serial.println("counterclockwise");
timer0 = millis(); // lancer chrono
myStepper.step(-nbTour * tour); // effectuer 1 tour et demi en sens inverse, c'est à dire 1.5*2048 pas
t = (millis() - timer0);
Serial.print("Période : ");
Serial.print(t/2);
Serial.println("ms");
delay(500);
}

Le code Arduino est le suivant : stepper_test_angle_roration.ino.zip

Voir aussi la documentation d'Arduino : Stepper One Revolution.

Moteur pas à pas 28BYJ-48 avec module de contrôle basé sur un UNL2003ARG

Câblage

Programme Arduino

Le programme de test consiste à effectuer des Aller et Retour de 360° ad vitam æternam. Le programme se trouve sur le site Anacorp. Téléchargeable ici : ...

#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;
}
}
}

Tutoriel

https://www.aranacorp.com/fr/pilotez-un-moteur-pas-a-pas-avec-arduino/

https://www.youtube.com/watch?v=ThJ6nTEJG-U

achat sur Amazon

https://www.amazon.fr/gp/product/B07VGV1XFT/ref=ppx_yo_dt_b_asin_title_o01_s00?ie=UTF8&psc=1

Références

Sites :

tutoriel Arduino

Tutoriel sur les moteurs pas à pas de Tom Igoe

Tutoriel YoupiLab

Vidéos :

U=RI

Retro Geek

Utilisation pratique du driver A4988 pour un moteur bipôlaire