====== UTILISER UN MOTEUR PAS À PAS ======
* Auteur : Damien MUTI DESGROUAS
* Date : 05/11/2020
* Licence : libre !
* Contexte : Apprentissage
* Fichiers : liens éventuels
* https: [[https://www.arduino.cc/en/Tutorial/LibraryExamples/StepperSpeedControl|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 :
* [[https://youtu.be/ThJ6nTEJG-U|U=RI ]]
* [[https://youtu.be/IJ0WSn7Oj9s|Retro Geek]]
Référence :
[[http://www.tigoe.com/pcomp/code/circuits/motors/stepper-motors/| 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 :
* [[https://components101.com/motors/28byj-48-stepper-motor|Description des connexions]]
{{ :wiki:tutoriels:arduino-capteurs:28byj-48-pinout-wirings.png?400 |}}
La couleur des fils du moteur dont nous disposons ici n'est pas la même que le schéma ci-dessus.
{{ :wiki:tutoriels:arduino-capteurs:connections_moteur_pap_1.png?400 |}}
La fiche technique du moteur est accessible sur les liens suivants :
* [[https://components101.com/sites/default/files/component_datasheet/28byj48-step-motor-datasheet.pdf|sur le web : 28BYJ-48]]
* {{ :wiki:tutoriels:arduino:28byj48-step-motor-datasheet.pdf |En local : 28BYJ-48}}
{{ :wiki:tutoriels:arduino:fiche_technique_moteur_pas_a_pas.png?400 |}}
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 :
* [[https://my.st.com/resource/en/datasheet/uln2003.pdf| Datasheet UNL2003 et UNL2004]]
La disposition des broches est la suivante :
{{:wiki:tutoriels:arduino-capteurs:pins_unl2004.png?200 |}}
{{ :wiki:tutoriels:arduino-capteurs:pins_unl2004_1.png?400 |}}
==== 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 [[https://www.arduino.cc/en/Reference/StepperSetSpeed|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 :
* [[https://www.gotronic.fr/art-moteur-28byj-48-08-5-vcc-21213.htm|Gotronic]]
* [[https://www.amazon.fr/dp/B06XKRM1P1/ref=asc_df_B06XKRM1P11604419200000/?tag=qwantcom75-21&creative=22950&creativeASIN=B06XKRM1P1&linkCode=df0|Amazon 1]] , [[https://www.amazon.fr/dp/B07W98H5GV/ref=asc_df_B07W98H5GV1604419200000/?tag=qwantcom75-21&creative=22950&creativeASIN=B07W98H5GV&linkCode=df0|Amazon 2]]
===== Montage =====
* [[https://www.arduino.cc/en/Tutorial/LibraryExamples/MotorKnob|Tutoriel Arduino]]
Le montage est le suivant :
{{ :wiki:tutoriels:arduino-capteurs:unipolarknob_schlg.png?700 |}}
===== 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
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 : {{ :wiki:tutoriels:arduino:stepper_speedcontrol_1.ino.zip |}}
Une vidéo de test est disponible sur ce lien Youtube : [[https://youtu.be/qvqsy-rCk5o|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
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 : {{ :wiki:tutoriels:arduino:stepper_test_angle_roration.ino.zip |}}
Voir aussi la documentation d'Arduino : [[https://www.arduino.cc/en/Tutorial/LibraryExamples/StepperOneRevolution|Stepper One Revolution]].
===== Moteur pas à pas 28BYJ-48 avec module de contrôle basé sur un UNL2003ARG =====
==== Matériel et tutoriels ====
* Gotronic : [[https://www.gotronic.fr/art-moteur-pas-a-pas-driver-stp01-23568.htm|Moteur pas-à-pas + driver STP01]]
==== Câblage ====
{{ :wiki:tutoriels:arduino:stepper-28byj48-arduino-wiring.png?600 |}}
====Programme Arduino====
Le programme de test consiste à effectuer des Aller et Retour de 360° ad vitam æternam. Le programme se trouve sur le site [[https://www.aranacorp.com/fr/pilotez-un-moteur-pas-a-pas-avec-arduino/| Anacorp]]. Téléchargeable ici : {{ :wiki:tutoriels:arduino:moteur_pas_a_pas_module_commande_ntours.zip |}}
///////////////// MOteur pas à pas
#define IN1 11
#define IN2 10
#define IN3 9
#define IN4 8
int Steps = 0;
int Direction = 0;
int number_steps = 512; //= 2048/4 : 512 pas correspond à un tour complet...
int unTour = 518; // valeur expérimentale
int nTours = 2;
void setup()
{
Serial.begin(9600);
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
// delay(1000);
// calcul du nombre de pas relatif à nTours
number_steps = nTours * unTour;
}
void loop()
{
//1 rotation counter clockwise
stepper(number_steps);
delay(500);
//1 rotation clockwise
stepper(-number_steps);
delay(500);
// //Keep track of step number
// for (int thisStep = 0; thisStep < number_steps; thisStep++) {
// stepper(1);
// }
// delay(500);
// for (int thisStep = number_steps; thisStep > 0; thisStep--) {
// stepper(-1);
// }
// delay(500);
}
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 :
* [[https://www.arduino.cc/en/Tutorial/LibraryExamples/StepperSpeedControl|tutoriel Arduino]]
* [[http://www.tigoe.com/pcomp/code/circuits/motors/stepper-motors/| Tutoriel sur les moteurs pas à pas de Tom Igoe]]
* [[https://apprendre.youpilab.com/piloter-un-moteur-pas-a-pas-avec-arduino/| Tutoriel YoupiLab]]
Vidéos :
* [[https://youtu.be/ThJ6nTEJG-U|U=RI ]]
* [[https://youtu.be/IJ0WSn7Oj9s|Retro Geek]]
* [[https://www.youtube.com/watch?v=nPx2PWKQ4RQ|Utilisation pratique du driver A4988 pour un moteur bipôlaire]]