Je veux en parler parce que cette spécificité "pas à pas" mérite qu'on s'y étende un peu.
- Nema 17
- Nema17.jpg (32.32 Kio) Consulté 26851 fois
Ce moteur de base ne tourne pas, ce n'est donc pas un moteur au sens habituel.
Son fonctionnement ressemble plus à un électroaimant rotatif. Une bobine excitée par un courant entrainera un changement d'angle de l'axe du moteur.
En combinant l'excitation des enroulements il pourra en revanche tourner dans un sens ou dans un autre.
Suivant sa constitution interne et son nombre de bobines il faudra faire un certain nombre de pas pour effectuer une révolution entière.
Le Nema que nous utilisons est de type 200 pas (step) par tour avec deux bobines distinctes soit 4 fils d'alimentation.
Le Pololu (driver) gèrera la combinaison des pas en interne ainsi que le courant afin de décharger complètement le contrôleur (Arduino) de la gestion du moteur. Le système se contentera de monter un signal indiquant la direction (dir) et enverra des impulsions avec un autre signal pour le faire tourner.
- Pololu A4988
- A4988.jpg (3.96 Kio) Consulté 26851 fois
Dans nos imprimantes équipées de A4988 on est à 1/16 et 1/32 pour les nouvelles Hephestos ou W2
Avec 1/16 de pas et 200 pas par tour, il faudra donc 16*200 pas pour faire un tour complet soit 3200 pas ou imputions électrique sur la broche "step"
Sa vitesse sera donc liée au temps entre chaque impulsion "step". Avec 3200 impulsions par seconde notre moteur tournera à 1 tour par seconde.
A la réflexion on a du mal à comprendre pourquoi se compliquer la vie à gérer des pas...
Simplement parce que ce type de moteur offre l'énorme avantage de pouvoir contrôler sa position angulaire de manière extrêmement précise, on sait exactement ou il en est simplement en additionnant les pas en avant ou en soustrayant les pas en arrière dans le programme du microcontrôleur.
En effet un Nema de 200*16 avec une poulie de 20 dents de 2mm d'écartement entrainera la courroie de très exactement 12,5µ pour un pas.
Démonstration :
Notre moteur fait 200 pas, le Pololu a un diviseur de 16, il faudra donc 16*200 pas soit 3200 micro pas pour faire un tour. Mais aussi une impulsion représentera 1/3200ième de tour.
Une poulie qui a 20 dents de 2mm d'espacement donnera un avancement égal à 20 x 2mm soit 40mm par tour.
Sachant cela il suffit de diviser 40mm (1 tour moteur) par 3200 (1 pas) et nous avons son avancement linéaire pour un pas soit 40mm/3200= 0,0125mm soit 12,5µM
On a donc un système d'entrainement qui peut donner une position très précise à notre tête ou notre plateau durant tout un travail aussi long soit-il, une impression entière pas exemple.
On a un avancement très précis, Il nous manque pourtant une chose importante, comment synchroniser la position physique de la tête avec la position véritable de l'électronique à la mise en marche de notre imprimante.
Cette "synchronisation" se fait au début d'une impression ou lors d'une demande de "home position". A ce moment l'électronique va demander un mouvement lent du moteur afin de rapprocher la tête ou le plateau du "end-stop". A chaque pas l'électronique va controler le switch afin de savoir si celui-ci est appuyé. S'il ne l'est pas, un nouveau pas est envoyé ainsi de suite. Au moment ou le switch sera appuyé l'électronique mettra à 0 la position de l'axe en question et arrêtera le mouvement, l'axe étant alors à 0 mécaniquement et électroniquement.
A ce moment cet axe sera parfaitement contrôlé par l'électronique de l'imprimante, peu importe le temps ou le nombre de mouvements que l'imprimante demandera.
On est donc dans un monde parfait ou tout est sous control....
Oui et non.
En effet, tout ca est bien beau mais que se passe-t'il si le moteur est bloqué mécaniquement pour une raison ou une autre. En fait il va grogner en tentant de bouger mais va surtout se désynchroniser avec l'électronique. Dans le cas de notre imprimante nous aurons des couches qui seront décalées pour tout le reste de l'impression.
On pourrait alors imaginer un système de control avec une cellule sur l'axe moteur chargée de nous renseigner sur le véritable mouvement effectué. Ce système complexe n'existe pas dans l'industrie traditionnelle. Que ce soit une petite machine comme une grosse, le moteur est prévu pour avoir une puissance suffisante pour accepter une charge maximum. Au mieux on pourrait vérifier cycliquement que le 0 switch correspond au 0 électronique et si c'est mauvais on arrête le travail en signalant une erreur mécanique à l'opérateur.
Pas moyen non plus de contrôler le courant pour déterminer un éventuel blocage, le courant dans les bobine ne dépend pas de la charge mais est constant. Ce courant constant lui permet aussi de conserver une position à l'arrêt très stable.
On a donc un moteur extrêmement précis mais il ne faut pas dépasser ses limites en terme de couple mais aussi d'accélération et de vitesse maxi.
Dans nos imprimantes l'accélération et la vitesse maxi son déterminées par le firmware qui limitera automatiquement les accélérations mais surtout la vitesse maximum des déplacements.
Pour ceux qui veulent aller plus loin, vous pouvez très simplement faire un montage avec une carte Arduino, un Pololu et un moteur Nema (ou autre)
La bibliothèque "stepper" peut être utilisée pour vous simplifier la vie mais un code très simple peut suffire pour contrôler un tel moteur.
L'exemple suivant fait tourner le moteur dans un sens 1 tour et dans l'autre sens 2 tours
Il est simple à lire et à réaliser. Le moteur est un Nema sans subdivision soit 200 pas/tour.
Alimentez la carte Arduino avec l'USB du PC et le montage avec le transfo 12V de votre imprimante.
Le lien de ce montage http://howtomechatronics.com/tutorials/ ... d-arduino/
- Stepper.JPG (51.12 Kio) Consulté 26851 fois
Code : Tout sélectionner
/* Simple Stepper Motor Control Exaple Code
*
* by Dejan Nedelkovski, www.HowToMechatronics.com
*
*/
// defines pins numbers
const int stepPin = 3;
const int dirPin = 4;
void setup() {
// Sets the two pins as Outputs
pinMode(stepPin,OUTPUT);
pinMode(dirPin,OUTPUT);
}
void loop() {
digitalWrite(dirPin,HIGH); // Enables the motor to move in a particular direction
// Makes 200 pulses for making one full cycle rotation
for(int x = 0; x < 200; x++) {
digitalWrite(stepPin,HIGH);
delayMicroseconds(500);
digitalWrite(stepPin,LOW);
delayMicroseconds(500);
}
delay(1000); // One second delay
digitalWrite(dirPin,LOW); //Changes the rotations direction
// Makes 400 pulses for making two full cycle rotation
for(int x = 0; x < 400; x++) {
digitalWrite(stepPin,HIGH);
delayMicroseconds(500);
digitalWrite(stepPin,LOW);
delayMicroseconds(500);
}
delay(1000);
}
