Je suis en train de raisonner dans un autre sens pour faire avancer le moteur pas à pas. Si je travaille en 16ème de pas, l'ai une résolution de 80 pas par mm. Et c'est à partir de là que je fais le reste. Le nombre de tours du moteur est un intermédiaire qui ne m'intéresse pas. J'ai d'un côté des impulsions à mettre, de l'autre des mm. Mon résultat c'est plutôt les mm.
Pour moi, le nombre de tours est intéressant quand on met le moteur sur la table, nu, avec un bout de scotch pour indiquer le repère, et que l'on fait des essais pour voir si il décroche ou pas.
Du coup, si je parle en mm, je n'ai plus de problèmes de résolution, je suis toujours au maximum de résolution. Et quand j'ai parcouru 17m les déplacements relatifs à la fin sont toujours avec la même précision.
Pour la mesure du temps et du nombre de cycles je fais comme tout le monde, on lit micros, on fait des boucles, on relit micros et on fait la différence divisé par le nombre de boucles. Je me suis fait un petit programme qui me permet facilement une fois pour toutes de mettre tout e place.
Dans ce que j'utilise, il y a deux boucles, la première est la tare et ne comporte qu'un NOP. la deuxième comporte un NOP et le code à mesurer. Ainsi en faisant la différence je n'ai que le temps de ce que je cherche à mesurer.
La résolution de micros est de 4µs avec une Uno, il faut au moins faire 4000 boucles pour avoir une résolution de 1ns (un nop dure 62,5 ns). Je pourrais faire 8000 boucles et afficher le nombre juste, mais cela n'a pas une grossi importance. Cela compliquerait un peu l'affichage.
Le chronométrage est interrompu par le timer 0 qui s'occupe de micros. En faisant plus de boucles la division va éliminer le petit temps dû au rafraîchissement de micros et millis. J'ai donc choisi de faire 100000 boucles. Pour mesurer un NOP, j'utilise ce nombre et j'ai le temps affiché à une ns près. Si c'est pour une fonction qui dure plus longtemps, je divise par 1000 le nombre de boucles et pense que les ns sont en réalité des ms... Si c'est très long, je ne fait qu'une boucle et j'ai le résultat en 1/10s. Ça marche comme cela avec un peu de calcul mental, je ne me suis pas fatigué plus.
Dans les tests,on utilise des 8, des 16 bits. j'en déclare quelques uns au début, une fois pour toutes.
Pour chaque variable, je lui affecte une valeur inconnue du compilateur pour qu'il ne transforme pas ma variable en constante, et je l'affiche en fin de programme pour qu'il ne me la supprime pas. le test est toujours faux, mais le compilateur ne le sait pas (encore).
Voici mon code:
byte b, b2, b3;
word w, w2;
float f;
void setup()
{
randomSeed(analogRead(0));
b = random(2);
b2 = random(2);
b3 = random(2);
w = random(0x10000);
w2 = random(0x10000);
f = random(0x10000);
Serial.begin(115200);
unsigned long t1, t2, t3; // Chronomètres
t1 = micros();
for (unsigned long x = 100000ul; x > 0; x--) _NOP(); // Tarer le temps d'une boucle
t2 = micros();
for (unsigned long x = 100000ul; x > 0; x--) // Boucle de mesure
{
_NOP();
// Mettre ici le code à tester
}
t3 = micros();
t1 = t3 + t1 - 2 * t2;
Serial.println();
Serial.println(String(t1 / 100ul) + "ns");
Serial.println(String(t1 / 6250ul) + "cycle(s)\n");
if (t1 > 1000000000l)
{
Serial.print(b);
Serial.print(b2);
Serial.print(b3);
Serial.print(w);
Serial.print(w2);
Serial.print(f);
}
}
void loop()
{
}