quickStepRotationAbsolu?()
Ces fonctions demandent un déplacement absolu d'un moteur
quickStepRotationAbsolu?(position, vitesse, nbPasAcceleration, nbPasDeceleration);
Variantes
// Pour le moteur sans nom: quickStepRotationAbsolu(...); // Pour le moteur X: quickStepRotationAbsoluX(...); // Pour le moteur Y: quickStepRotationAbsoluY(...); ...
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
position
// forme générale: quickStepRotationAbsolu?(position, ...); // valeurs numériques: quickStepRotationAbsolu?(0, ...); // Revenir à la position de référence quickStepRotationAbsolu?(200 pas_ou_micro_pas, ...); // Aller à la position 200 quickStepRotationAbsolu?(-200 pas_ou_micro_pas, ...); // Aller à la position -200 // Si unTour? est défini: quickStepRotationAbsolu?(unTour?, ...); // Aller un tour après la référence quickStepRotationAbsolu?(-3 * unTour?, ...); // Aller 3 tours après la référence
Le nombre de pas doit être un entier signé sur 16 ou 32 bits (suivant ce qui a été configuré). Sur 16 bits, les positions absolues sont repérées -32767 à +32767. Mais le fonctionnement n'est garanti que pour les positions -16384 à +16383, voir Plage de fonctionnement.
vitesse
// formes générales: quickStepRotation?(..., vitesse, ...); quickStepRotationAbsolu?(..., vitesse, ...); // valeurs numériques: quickStepRotation?(..., 100 micro_secondes_par_pas, ...); quickStepRotationAbsolu?(..., 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: quickStepRotationAbsolu?(..., nbPasAcceleration, nbPasDeceleration); // valeurs numériques: quickStepRotationAbsolu?(..., acceleration_sur 1000 pas_ou_micro_pas, 0); quickStepRotationAbsolu?(..., acceleration_sur 2000 pas_ou_micro_pas); quickStepRotationAbsolu?(..., acceleration_sur 1000 pas_ou_micro_pas, deceleration_sur 2000 pas_ou_micro_pas); // Si unTour? est défini: quickStepRotationAbsolu?(..., 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.1012 pas/s2, je crois), un palier
à la vitesse de 100 µs/pas pendant 7000 pas et une décélération de A/2 pas/s2 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/s2 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/s2. 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:
Plage de fonctionnement
Les infos données ici suppose que l'on est en 16 bits pour les nombres de pas. Mais le raisonnement est le même si les nombres de pas sont définis sur 32 bits, à la différence qu'il est difficile d'atteindre un dépassement des valeurs. Il est rare que l'on ait à accélérer sur plusieurs heures.
Les positions sont définies sur une plage de -32767 à +32767, mais le fonctionnement est garanti que sur la plage moitié de -16383 à +16383. En effet si l'ancienne position et la position souhaitée sont comprises dans ces limites, le déplacement pour aller du départ à l'arrivée est compris entre -32767 à +32767. Il en est d'ailleurs de même pour toutes les plages de 32767 de large, par exemple le fonctionnement est garanti pour la plage 0 à 32767.
Supposons maintenant que l'on soit à la position -20000 et que l'on demande:
quickStepRotationAbsolu?(20000 pas_ou_micro_pas, vitesse);
Il faut alors faire un déplacement de 40000 pas, ce qui n'est possible qu'en deux fois. Ce ne serait pas compliqué à coder. On pourrait traduire la demande par deux ordres:
quickStepRotation?(20000 pas_ou_micro_pas, vitesse); quickStepRotation?(20000 pas_ou_micro_pas, vitesse);
Si on est toujours en position -20000 et que l'on demande:
quickStepRotationAbsolu?(20000 pas_ou_micro_pas,
vitesse,
acceleration_sur 1000 pas_ou_micro_pas,
deceleration_sur 2000 pas_ou_micro_pas);
On pourait encore traduire la demande par deux ordres:
quickStepRotation?(20000 pas_ou_micro_pas,
vitesse,
acceleration_sur 1000 pas_ou_micro_pas);
quickStepRotation?(20000 pas_ou_micro_pas,
vitesse,
acceleration_sur 0 pas_ou_micro_pas,
deceleration_sur 2000 pas_ou_micro_pas);
Mais si on est toujours en position -20000 et que l'on demande:
quickStepRotationAbsolu?(20000 pas_ou_micro_pas,
vitesse,
acceleration_sur 30000 pas_ou_micro_pas);
Il faudrait traduire pour être tranquille traduire cet ordre en trois partie, l'accélération d'abord, le palier à vitesse constante ensuite et enfin un ordre pour la décélération. Sachant que le palier à vitesse constante peut se traduire par un ordre unique ou par deux ordres si il est trop grand. Décomposer systématiquement n'est pas une bonne chose (prend de la place dans la pile des ordres). En fait ce cas arrive peu et i vaut mieux passer en 32 bits car on a extrêmement peu de cas ou il faille revenir de 2 millions de pas pour regagner la position souhaitée.
C'est faisable, mais cela augmenterait le code inutilement pour 99,9% des cas. Cest pour cela que cela n'a pas été retenu.
Valeur retournée
Aucune