quickStepRotation?()

Cette fonction demande un déplacement relatif d'un moteur

quickStepRotation?(nbPas, vitesse, nbPasAcceleration, nbPasDeceleration);

Variantes

// Pour le moteur sans nom:
quickStepRotation(...);

// Pour le moteur X:
quickStepRotationX(...);

// Pour le moteur Y:
quickStepRotationY(...);

...

Les moteurs sont repérés par une lettre X, Y, Z, T, U, V ou W ou une absence de lettre. Dans la suite le caractère ? doit être remplacé par une de ces lettres ou par rien

Paramètres passés

nbPas

// forme générale:
quickStepRotation?(nbPas, ...);

// valeurs numériques:
quickStepRotation?(-1000 pas_ou_micro_pas, ...); // 1000 pas en arrière
quickStepRotation?(10 * 100 pas_ou_micro_pas, ...); // 1000 pas en avant

// Si unTour? est défini:
quickStepRotation?(-10 * unTour?, ...); // 10 tours
quickStepRotation?(unTour? * 10, ...); // 10 tours
quickStepRotation?(unTour? / 2, ...); // Un demi-tour

Le nombre de pas doit être un entier signé sur 16 ou 32 bits (suivant ce qui a été configuré). Une valeur positive fait tourner le moteur dans un sens, une valeur négative dans l'autre. Sur 16 bits, on peut avancer de MIN_PAS (-32767) à MAX_PAS (+32767) pas ou micros-pas en un seul ordre. Demander -32768 pas se traduira par -32767 pas.

vitesse

// formes générales:
quickStepRotation?(..., vitesse, ...);

// valeurs numériques:
quickStepRotation?(..., 100 micro_secondes_par_pas, ...);
quickStepRotation?(..., 60 RPM, ...); // 60 tr/mn
quickStepRotation?(..., 1.5 RPS, ...); // 1,5tr/s

Vitesse est un float et la vitesse est strictement positive. Pour aller dans l'autre sens, jouer sur le paramètre nbPas. On conseille une de ces trois forme. En fait une valeur positive est comprise comme le nombre de micro-secondes par pas ou par micro-pas et une valeur négative comme l'opposé du nombre de tours par minute. La valeur réelle de la vitesse peut être légèrement arrondie à 1/256ème de la base de temps et elle est mise dans la fourchette [base de temps, 255,996 * base de temps].

nbPasAcceleration, nbPasDeceleration

// formes générales:
quickStepRotation?(..., nbPasAcceleration, nbPasDeceleration);

// valeurs numériques:
quickStepRotation?(..., acceleration_sur 1000 pas_ou_micro_pas, 0);
quickStepRotation?(..., acceleration_sur 2000 pas_ou_micro_pas);
quickStepRotation?(..., , acceleration_sur 1000 pas_ou_micro_pas, deceleration_sur 2000 pas_ou_micro_pas);

// Si unTour? est défini:
quickStepRotation?(..., acceleration_sur 5 * unTour?, deceleration_sur 10 * unTour?);

On peut omettre nbPasDeceleration. On peut omettre nbPasAcceleration si il n'y a pas le paramètre nb PasDeceleration. Un paramètre oublié est compté comme 0. A priori c'est un nombre positif, mais mettre une valeur ou son opposé revient au même.

Si on accélère sur 1000 pas, on va passer de la vitesse nulle à la vitesse maximale définie par le paramètre vitesse si il y a suffisamment de pas pour les faire. Il en est de même pour la décélération. Dans le cas ou il n'y a pas suffisamment de pas pour accélérer et/ou décélérer, tout se fera au prorata.
  quickStepRotation?(10000 pas_ou_micro_pas, 100 micro_secondes_par_pas, acceleration_sur 1000 pas_ou_micro_pas, deceleration_sur 2000 pas_ou_micro_pas);
fera une accélération pendant 1000 pas (accélération A = 5.10¹² pas/s², je crois), un palier à la vitesse de 100 µs/pas pendant 7000 pas et une décélération de A/2 pas/s² pendant 2000 pas.
  quickStepRotation?(1000 pas_ou_micro_pas, 100 micro_secondes_par_pas, acceleration_sur 1000 pas_ou_micro_pas, deceleration_sur 2000 pas_ou_micro_pas);
fera une accélération toujours de A pas/s² pendant 333 pas car on a moins de 3000 pas en tout, il n'y aura pas de palier à la vitesse constante, et une décélération de A/2 pas/s². L'accélération est calculée comme si on avait le temps d'atteindre la vitesse finale, ainsi quel que soit le nombre de pas réel à faire, l'accélération est la même. Le nombre de paliers d'accélération est le même, les paliers sont simplement plus petits. La vitesse finale ne sera que d'environ 3 µs/pas environ car on n'a accéléré que sur le tiers des pas.

Pour convertir les accélérations, on peut utiliser la relation:

Valeur retournée

Aucune