Include à rajouter

#include <MTobjects.h> // Voir http://arduino.dansetrad.fr/MTobjects

Je conseille fortement de laisser le commentaire, si une autre personne voulait essayer le programme, elle aurait directement un lien de téléchargement. C'est valable pour toutes les bibliothèques que vous utilisez.

Constantes utiles

RPM
RPS
NON_CONNECTEE
SENS_PAR_DEFAUT
SENS_INVERSE
CONTINUE
PAS_D_ACTION
PAS_D_ACCELERATION

RPM indique une constante en tr/mn (rotate per minute)
RPM indique une constante en tr/s (rotate per second)
NON_CONNECTEE pour une broche EN ou DIR non connectée
SENS_PAR_DEFAUT, SENS_INVERSE pour inverser ou non le sens
CONTINUE permet la rotation continue pour move, moveTo
PAS_D_ACTION paramètre par défaut si on n'appelle pas de fonction en fin de rotation

Commentaires utiles

micro_pas
pas_ou_micro_pas
micro_secondes
micro_secondes_par_pas
position_absolue
accelerations_sur
pin_Step
pin_Dir
pin_EN

Ces commentaires sont des mots que l'on peut rajouter n'importe où et qui sont ignorés par le compilateur.

Constructeur

MTstepStepper(pinStep, 
              pinDir = NON_CONNECTEE,
              pinEn = NON_CONNECTEE,
              acceleration = 16*200 pas_ou_micro_pas,
              microsteps = 16 micro_pas,
              speed = 1.0 RPS,
              reverse = SENS_PAR_DEFAUT,
              onStopFunction = PAS_D_ACTION,
              stepsPerTurn = 200);

• pinStep (int8_t): broche arduino qui commande l'ordre STEP pour avancer d'un pas
• pinDir (int8_t): broche arduino qui indique le sens de rotation (entrée DIR du driver)
• pinEn (int8_t): broche arduino qui commande autorise ou non la rotation (entrée EN du driver)
• acceleration (int_t): nombre de pas de l'accélération et la décélération
• microsteps (word): Nombre de micros pas, par défaut 16.
• speed (float): vitesse de rotation que l'on peut exprimer dans divers unités:
  • <valeur numérique> micro_secondes_par_pas → temps entre deux pas ou deux micro-pas, entre 1 fois et 3600000 fois la base de temps. Par défaut entre 100µs et 1h.
  • <valeur numérique> RPS → en tour/s (rotation par seconde en traduisant l'anglais)
  • <valeur numérique> RPM → en tour/mn (rotation par minute en traduisant l'anglais)
• reverse (boolean): inversion des sens de rotation, on peut aussi inverser pinA1 et pinA2
  • SENS_PAR_DEFAUT → par défaut
  • SENS_INVERSE → inverse toutes les rotations
• onStopFunction: ce que l'on fait quand le moteur atteint sa position et à l'initialisation
  • PAS_D_ACTION → on ne fait rien
  • maFonction → appel d'une fonction « void maFonction(void) » au moment de l'arrêt
• stepsPerTurn (word): nombre de vrais pas par tour, 200 par défaut

Fonctions utiles

void setSpeed(float speed);
void move(int32_t nbSteps);
void moveTo(int_t position = 0);
void moveAndWait(int32_t nbSteps);
void moveToAndWait(int_t position);
void stop(void);
void wait(void);
bool stopped(void);
void setPosition(int_t position);
int32_t getPosition(void);
void setOrigin(void);
int32_t getRest(void);
void onStop(void);

setSpeed(<valeur numérique> micro_secondes_par_pas): programme une vitesse de rotation
setSpeed(<valeur numérique> RPS): programme une vitesse de rotation
setSpeed(<valeur numérique> RPM): programme une vitesse de rotation
move(<valeur numérique>): avance (si nbSteps>0) ou recule (si nbSteps<0) de nbSteps pas. Par défaut les nombres de pas sont sur 32 bits, mais on peut les passer en 16 bits, voir MTobjects.h . La fonction n'est pas bloquante, on sort immédiatement, le moteur continuera sa course sans que l'on s'en occupe
move(CONTINUE): avance sans arrêt (on peut l'arrêter par stop(); !)
move(-CONTINUE): recule sans arrêt
moveTo(<valeur numérique>): va à la position absolue
moveAndWait: avance ou recule mais la fonction attend l'arrêt
moveAndWait(CONTINUE): avance ou recule (avec -CONTINUE) mais la fonction attend l'arrêt, dans ce cas uniquement par stop()
moveToAndWait(<valeur numérique>): va à la position absolue mais la fonction attend l'arrêt
stop(): arrête le moteur
wait(): fonction bloquante tant que le moteur tourne
stopped(): retourne true si le moteur est arrêté
setPosition(<valeur numérique>): fixe arbitrairement une position
getPosition: retourne la position du moteur
setOrigin(<valeur numérique>): fixe ici la position d'origine (p.ex après une mise en origine machine)
getRest(): retourne le nombre de pas restant à faire
onStop: fonction à surcharger appelée quand le moteur s'arrête et à l'initialisation

Fonctions bonus

void setReverse(boolean);
void setOnStopFunction(onStopFunction);
void setMicroStepsPerTurn(word stepsPerTurn);
word getMicroStepsPerTurn(void);
float getSpeedMicrosecond(void);
float getSpeedRPS(void);
float getSpeedRPM(void);
void setAcceleration(int_t acceleration);

setReverse(SENS_INVERSE): permet d'inverser le sens de rotation
setReverse(SENS_PAR_DEFAUT:) permet de ne plus inverser le sens de rotation
setOnStopFunction: change la fonction à appeler lors de l'arrêt
setOnStopFunction: sans paramètres supprime la fonction appelée lors de l'arrêt
setMicroStepsPerTurn: fixe le nombre de pas ou demi-pas par tour
setMicroStepsPerTurn: sans paramètres fixe le nombre de pas par tour à 2048
getMicroStepsPerTurn: retourne le nombre de pas ou demi-pas par tour
getSpeedMicrosecond: retourne le temps entre 2 pas en µs
getSpeedRPS: retourne la vitesse en tr/s
getSpeedRPM: retourne la vitesse en tr/mn
setAcceleration: change l'accélération (en pas)

Exemples

• Essuie-glace
• Un tour de plus
• Aller-retours
• Homming
• 40000 pas par seconde