Table equatoriale astronomie

Salut à tous je suis nouveau sur ce forum.

Je fais de l'astronomie et j'ai comme projet de faire ce qu'on appelle une table équatoriale :

En gros on pose un télescope sur une table en bois qui pivote grâce à un moteur Nema.

Le système fonctionne grâce à un moteur Nema 17 alimenté par une carte Arduino.

D'un naturel optimiste j'ai essayé de tout faire moi-même pour la partie électronique.... Et je galère :frowning:

Bref j'ai besoin d'aide !

J'ai besoin de faire tourner un moteur Nema 17 à vitesse constante. Vitesse que je vais devoir ajuster car elle dépend de la rotation de la Terre et il faut que je calcule la dite vitesse. Pour l'instant j'essaie juste de faire tourner le moteur.

Mon montage=

Imgur

Imgur

Imgur

Je n'arrive pas à trouver un code fonctionnel (ou mon montage est peut être mal fait).

Partez du principe que je suis un débutant complet.

J'ai téléchargé le logiciel Arduino , j'ai essayé avec des codes trouvé sur internet...mais le moteur ne tourne pas.

Merci de votre aide !

monsieurtoc64:
Salut à tous je suis nouveau sur ce forum.

Je fais de l’astronomie et j’ai comme projet de faire ce qu’on appelle une table équatoriale :

En gros on pose un télescope sur une table en bois qui pivote grâce à un moteur Nema.

Le système fonctionne grâce à un moteur Nema 17 alimenté par une carte Arduino.

D’un naturel optimiste j’ai essayé de tout faire moi-même pour la partie électronique… Et je galère :frowning:

Bref j’ai besoin d’aide !

J’ai besoin de faire tourner un moteur Nema 17 à vitesse constante. Vitesse que je vais devoir ajuster car elle dépend de la rotation de la Terre et il faut que je calcule la dite vitesse. Pour l’instant j’essaie juste de faire tourner le moteur.

Mon montage=

https://flic.kr/p/2k9kA6p

https://flic.kr/p/2k9m2Ly

https://flic.kr/p/2k9gKgJ

Je n’arrive pas à trouver un code fonctionnel (ou mon montage est peut être mal fait).

Partez du principe que je suis un débutant complet.

J’ai téléchargé le logiciel Arduino , j’ai essayé avec des codes trouvé sur internet…mais le moteur ne tourne pas.

Merci de votre aide !

bonjour
la 1ere chose à faire est de “valider” la partie driver/moteur
faire un test simple connections uno/a4988/moteur avec le cablage et le simple code ci-dessous


const int stepPin = 4;
const int dirPin = 3;
void setup() {
  // put your setup code here, to run once:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}

void loop() {
  // put your main code here, to run repeatedly:
 test();
}

void test(){
 digitalWrite(dirPin, HIGH);
  // Makes 200 pulses for making one full cycle rotation
  for (int i = 0; i < 200; i++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
    //Serial.println("we did it!.");
  }
}

IL y a de temps en temps sur le forum des astronomes amateurs éclairés qui passent

Merci pour la réponse.

En téléversant j'ai un message d'erreur =

Arduino : 1.8.13 (Windows 7), Carte : "Arduino Uno"

Le croquis utilise 804 octets (2%) de l'espace de stockage de programmes. Le maximum est de 32256 octets.

Les variables globales utilisent 9 octets (0%) de mémoire dynamique, ce qui laisse 2039 octets pour les variables locales. Le maximum est de 2048 octets.

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0xdf

Problème de téléversement vers la carte. Voir http://www.arduino.cc/en/Guide/Troubleshooting#upload pour suggestions.

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0xdf

avrdude: stk500_recv(): programmer is not responding

avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0xdf

J'ai la chance de n'avoir aucune compétance pour ce genre de message d'erreur que je ,'ai jamais eu, mais la lecture de Topic: ARDUINO : problèmes de téléversement (Read 25129 times) devrai aider.

Artouste:
la 1ere chose à faire est de "valider" la partie driver/moteur

La deuxième! La première est de régler le A4988 pour qu'il ne donne surtout pas un courant excessif. Le moteur est un moteur 1,7A . Soit chercher sur internet comment faire (ou avoir la datasheet du A4988 et savoir la lire), soit nous donner ce qui est écrit sur la résistance

A4988_Réglage.gif

A4988_Réglage.gif

Ça marche !!!

Quelle galère pfff… C’est une carte Aliexpress. J’ai dû télécharger le driver et le mettre à jour !

Mais ça fonctionne. Je voudrais que le moteur tourne de façon régulière dans le sens inverse des aiguilles d’une montre.

Puis je avoir un code. Et pouvez m’expliquer comment modifier le code pour modifier la vitesse.

En tt cas un grand merci !!!

Sur la résistance il y a écrit R100

Je pense que personne ne vous donnera un code tout fait.

Il faut que vous regardiez les exemples disponibles dans l'IDE Arduino, il me semble qu'il y en a quelques-uns pour les moteurs pas-à-pas. Vous pouvez aussi en chercher en ligne, cela devrait se trouver.

Dans les grandes lignes, un contrôleur de moteur pas-à-pas se contrôle souvent avec deux entrées :

  • dir, qui donne la direction dans laquelle doit tourner le moteur, et
  • step, qui est une impulsion permettant de dire au contrôleur d'avancer d'un pas.

Je crois qu'il y a une bibliothèque très basique fournie par Arduino qui fait ça. Ça c'est pour dire au moteur de bouger.

Ensuite, vous aurez besoin de savoir à quelle vitesse il doit tourner. (je soupçonne une rotation par 24h)
Il faudra inclure dans ce calcul la réduction éventuelle (je pense que ce sera nécessaire), le nombre de pas pour un tour de votre moteur, ainsi que le nombre de micro-pas réglés sur votre contrôleur (1/2, 1/4, 1/8, 1/16, etc.)

Sur la résistance il y a écrit R100

Pour régler le courant max du A4988, il faut régler l'ajustable pour avoir la bonne tension VREF. cette dernière est donné par la formule (dans la datasheet):
ITripMAX = VREF / ( 8 × RS)
En fonction de la résistance RS cerclée, on règle le voltmètre:
A4988_Réglage.gif
Le module a une résistance marquée R100, et ce sont des 0.1ohms (sauf si je me trompe)
Le moteur que j'ai est un 17HS4401 (1,7A)
Le A4988 peut aller jusqu'à 2A

On peut mettre VREF = ( 8 × RS) × ITripMAX soit 8 × 0.1 × 1.7 = 1.36V

Je crois qu’il y a une bibliothèque très basique fournie par Arduino qui fait ça. Ça c’est pour dire au moteur de bouger.

La bibliothèque Stepper est celle qui est fournie naturellement et documentée. C’est aussi une bibliothèque simple à utiliser.
Elle n’est à priori pas conçue pour être utilisée avec des drivers type A4988, mais si on dit que le moteur à 2 commandes (en fait c’est bobine 1 et bobine 2) et qu’on y mer STER et DIR, cela fait tourner les moteurs correctement et dans les deux sens. Par contre pour avancer d’un pas, il faut en demander 4.
Après il y a des choses moins drôles, je n’ai pas testé plus. Par exemple si on fait un pas dans un sens , un pas dans l’autre, soit cela n’avance pas (il n’y a pas de progression du tout), soit ce cycle fait progresser d’un pas.
Je ne sais pas si on perd des pas si on va dans les deux sens. C’est sûr si on ne fait pas les pas 4 par 4.
Le problème des bibliothèques est

  • qu’elles permettent la rotation constante. Je ne sais pas si cela répond au besoin
  • certaines sont bloquantes. Avec Stepper, je ne sais pas faire tourner un moteur et calculer autre chose.
  • elles ne sont pas forcément faites pour tourner lentement. Stepper dit:

Stepper: setSpeed(rpms)
rpms: the speed at which the motor should turn in rotations per minute - a positive number (long)

On ne peut sans doute pas tourner plus lentement que 1 tr/mn . En câblant le moteur en 16 micros pas, on peut descendre à 1/16 tr/mn. Mais ce sera dur pour tourner à la bonne vitesse (il n’y a rien entre 1 et 2 tr/mn!

Il est donc nécessaire de donner la vitesse de rotation

Maintenant quelle que soit la bibliothèque utilisée, elles fonctionnent sur le quartz d’origine. La précision est-elle suffisante ou pas?

Dans la mesure ou la table va très lentement, c’est sans doute plus simple de gérer le moteur. Pour déclarer le moteur:

#define STEP <n° de la pin correspondant à STEP>
#define DIR <n° de la pin correspondant à DIR>
pinMode(STEP, OUTPUT);
pinMode(DIR, OUTPUT);

Pour aller dans un sens à partir de maintenant jusqu’à ce que l’on dise le contraire:

digitalWrite(DIR, LOW);

Pour aller dans l’autre sens à partir de maintenant jusqu’à ce que l’on dise le contraire:

digitalWrite(DIR, HIGH);

Pour avancer d’un pas:

digitalWrite(STEP, HIGH);
digitalWrite(STEP, LOW);

On peut câbler la broche ENABLE sur une pin (permet de ne pas alimenter le moteur) ou la mettre à la masse.
Pareil pour les tris IN1, IN2 et IN3 qui sont en général fixes. Il y a des fortes chances pour que sur le board photographié le mode soit en pas entiers, car cela permet de mettre à la fois des moteurs pilotés en courant et des moteurs 12V.

OK j'avance doucement mais sûrement :).

OK pour la vitesse il me faut du 0,0226 tour /MN.

Le sens il me faut du sens inverse des aiguilles d'une montre.

Pb. De ce que j'ai lu c'est impossible avec un moteur nema 17...

Pourriez-vous me le confirmer. Merci !

monsieurtoc64:
OK j'avance doucement mais sûrement :).

OK pour la vitesse il me faut du 0,0226 tour /MN.

Le sens il me faut du sens inverse des aiguilles d'une montre.

Pb. De ce que j'ai lu c'est impossible avec un moteur nema 17...

Pourriez-vous me le confirmer. Merci !

Bonsoir
de ce que j'ai pu lire sur la motorisation de monture equatoriale avec du PAP , il semblent etre quasi toujours utilisé un reducteur coaxial planetaire avec le pap de ratio ~ entre 50 et 100/1
un exemple
NEMAxx est là plus une notion d'encombrement "mecanique"que de puissance electrique/moteur

Pb. De ce que j'ai lu c'est impossible avec un moteur nema 17..

De le faire tourner dans le sens que l'on veut? :grin:

Pour la vitesse, la plupart des bibliothèques ne permettent pas des vitesses trop lentes. Mais depuis le premier post, j'ai appris qu'il y avait un autre problème. La fréquence d'un Arduino n'est pas exactement de 16MHz, je sais que celui que j'utilise va un peu trop lentement. La fréquence n'est pas parfaitement définie, et n'est pas forcément compensée en température. Se baser sur la fréquence interne ne fonctionnera pas des masses. Si cela marche bien avec 15°C, on risque d'avoir des décalages de vitesse si la température varie.
C'est pour cela que dans ton cas, il faut quasiment une horloge externe. Certains y mettraient une RTC. Ne sachant pas trop quels sont les signaux que l'on récupère, je ne peux pas en dire plus. Si c'était moi, il y a des chances que j'utiliserai une montre car c'est assez stable.

Par contre pour faire tourner un moteur à des vitesses aussi faible est facile. C'est si on veut le faire tourner vite que cela pose problème. Surtout qu'avec un driver A5988, il suffit de faire une impulsion sur step pour faire avancer le moteur d'un pas. C'est aussi simple que de faire clignoter une led.

Sans vouloir abuser de votre patience. Est-il possible d'avoir un code pour l'arduino que je pourrais copier /coller pour faire tourner le moteur à la vitesse de 0,0226 tour/min.?

À moins que ce soit pas possible car il faudrait absolument le réducteur coaxiale planétaire.

Pour les écarts de température. En isolant le moteur je pourrais peut être limiter le problème...

Sans vouloir abuser de votre patience. Est-il possible d'avoir un code pour l'arduino que je pourrais copier /coller pour faire tourner le moteur à la vitesse de 0,0226 tour/min.?

En général non, mais il se trouve que je souhaite faire par ailleurs un petit logiciel pour voir et mesurer la dérive de l'horloge système qui peut s'adapter assez facilement à ce cas.
J'aurais besoin de savoir:

  • quelle carte est utilisée (Nano? Uno?...)
  • Le A4988 est il connecter en mode pas, 1/2 pas 1/4 pas... Des micropas permettent surtout de diminuer le "cran" à chaque fois que l'on avance d'un pas. Au delà de 4 microspas, cela ne sert plus à grand chose pour ce type de rotation. Mais j'ai besoin de savoir si M, M2, M3 sont accessibles, branchées et à quoi.
  • j’ai besoin de savoir si la bibliothèque servo est envisagée car elle utilise le timer 1. Quels sont les timers utilisés ("je ne sais pas" indique qu'à priori seul le timer de l'horloge système est utilisé). C'est plus simple si le timer 1 est libre, mias je peux adapter sans trop de difficultés mon code.
  • la sortie LED_BUITLTIN (13 sur Uno) est utilisée pour la led, j'ai besoin d'avoir accès à une sortie pour y mettre une led. Si la sortie LED_BUITLTIN est libre je l'utilise. Si tu utilise cette sortie, quelle autre sortie puis-je utiliser?
    Pour la vitesse, cela ne pose pas de problèmes
    Si la fréquence de la carte est fausse mais constante, ce n'est pas un problème, l'ajustement que j'ai permet de compenser. En fait, j'ai le problème inverse, je veux avoir des impulsions à des instants repérés, mais ce qui m'intéresse c'est la correction. Dans ton cas que l'on corrige de 1% ou de 2%, on s'en moque.
    Pour la température, c'est aussi une correction (en fait la même). Si la température était fixe tout au long de la journée, il suffirait de dire pour telle température, il faut telle correction. Si la température varie, il faudrait éventuellement la mesurer et adapter la correction en fonction.

À moins que ce soit pas possible car il faudrait absolument le réducteur coaxiale planétaire.

Le seul intérêt d'un réducteur c'est pour la résolution de l'angle. En gros on transforme un moteur 200 pas par tour en un 200000 pas par tour. Si le télescope n'avait que 100 positions discrètes, ce ne serait pas terrible. Par contre c'est plus facile de faire un réducteur logiciel (moins d'impulsions) que matériel. Et moins cher!

Je vais avoir du mal à répondre à toutes ces questions...
J'ai mis des photos du montage sur le premier message du post. Si ça peut aider....
La carte c'est une Uno. Température 10°c.
Le reste faudrait m'expliquer où chercher.
En tt cas merci c'est vraiment sympa de votre part de m'aider !

J'avais vu les photos, mais tant d'eau a coulé sous les ponts depuis....
Y a-t-il autre chose de branché à par le moteur?
A priori tes réponses me donnent les renseignements manquants.

Je suis en train d'écrire un programme pour moi, je vais ensuite l'adapter.

Non rien d'autre que le moteur.

OK merci pour le code

Pour commencer:
A vérifier:
Pour tourner à 0,0226 tr/mn:
Cela fait :
44,24 mn/tr (en fait on programme des intervalles de temps)
2650 s/tr
13.27 s/pas (le moteur est un 200 pas par tour)
ou encore 4 fois 3.31s (les interruptions ne peuvent pas être plus espacées que 4s, il me faut un temps inférieur)
3.31s c’est
3318000µs
51853 fois 64µs (64µs c’est le temps possible pour mon horloge)
Le programme qui suit appelle la fonction ISR(TIMER1_COMPA_vect) toutes les 3,31s et une fois sur 4 (soit toutes les 13.27s fait avancer le moteur d’un pas comme calculé plus haut. Pour vérifier même sans le moteur, à chaque pas la led de la carte change d’état, et est envoyé sur la console série (réglée à 115200 bauds, mais qui peut être changée dans le setup du progamme) le nombre de pas faits pour chronométrage.
Le programme travaille par interruption, et est invisible pour la programmation. Si on démarre le moteur, celui ci tourne jusqu’à l’ordre contraire. On peut donc mettre n’importe quoi dans le loop, y compris du code bloquant. Cela n’a aucune influence sur le moteur. Le code principal peut aussi faire tourner le moteur en même temps, si loop demande d’avancer de 100 pas, le moteur fera alors les 100 pas en plus ou en moins du pas toutes les 13s.
J’ai mis quelques ordres dans loop(). Pour les faire marcher il faut copier la ligne correspondante et enlever le // du début. Deux lignes on été mises pour l’exemple.
Si tu as des problèmes, profite de mon confinement. Le cas contraire est improbable.
La résolution temporelle d’un pas est de 4*64µs soit 256µs (une fois sur 4, et la base est 64µs).
La précision quand à elle dépend de cette résolution et de la fréquence théorique des 16MHz.
J’ai besoin du même programme (avec 1s au lieu de 13) mais avec la possibilité de faire des corrections. Le principe est simple, si au lieu de 51853, j’ai besoin de 51853,25, il faudra mettre parfois 51853, parfois 51854.
Je le fais pour moi, je n’airai plus qu’à changer 1s en 13s.
// Definition des broches utilisées par le moteur
const int stepPin = 4;
const int dirPin = 3;
// Routine d’interruption appelée toutes les 3,31s et qui une fois
// sur 4 fait progresser le moteur d’un pas.
uint32_t diviseurPar4 = 0;
ISR(TIMER1_COMPA_vect) // appelée toutes les 3,31s
{
~~ diviseurPar4++;
if ((diviseurPar4 & 3) == 0) // Une fois sur 4~~
~~ {
// Avance d’un pas pour le moteur~~
~~ digitalWrite(stepPin, HIGH);
digitalWrite(stepPin, LOW);
// Change d’état la led de la carte pour contrôler sur la carte~~
~~ digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
// Affiche le nomre de pas faits si on va lentement~~
~~ if (OCR1A > 5185)
Serial.print(diviseurPar4 >> 2); Serial.println(" pas faits");
}
}
void setup()
{
// Initialisation led~~
~~ digitalWrite(LED_BUILTIN, LOW);
pinMode(LED_BUILTIN, OUTPUT);
// initialisation du moteur~~
~~ digitalWrite(stepPin, LOW);
pinMode(stepPin, OUTPUT);
digitalWrite(dirPin, LOW);
pinMode(dirPin, OUTPUT);
// Preparation de l’affichage facilite la mise au point~~
~~ Serial.begin(115200);
// Mettre en route le timer 1 (16 bits)
TCCR1A = 0b00000000; // Pas de comparaisons, mode CTC mode 4~~
~~ TCCR1B = 0b00001101; // Mode CTC ICR (4), base de temps 64µs, division 1024~~
~~ OCR1A = 51852; // Interruption toutes les 3,31s → T = (OCR1A + 1)*64µs~~
~~ // Les autres initialisation si tu en as~~
}
void loop()
{
~~ // TIMSK1 = 0b00000010; // Faire tourner le moteur~~
~~ // TIMSK1 = 0b00000000; // arrêter la rotation~~
~~ // digitalWrite(dirPin, LOW); // Pour que le moteur tourne dans l’autre sens~~
~~ // digitalWrite(dirPin, LOW); // Pour que le moteur tourne dans le sens de départ~~
~~ // OCR1A = 518; // Pour aller environ 100 fois plus vite (pour les essais)
// OCR1A = 5185; // Pour aller environ 10 fois plus vite (pour les essais)
// OCR1A = 51852; // Pour aller à la meilleure vitesse~~
~~ // OCR1A = 51851; // Pour aller un poil plus vite~~
~~ // OCR1A = 51853; // Pour aller un poil plus lentement~~
~~ OCR1A = 5185; // Pour aller environ 10 fois plus vite (pour les essais)
TIMSK1 = 0b00000010; // Faire tourner le moteur~~
}

A vérifier:
Pour tourner à 0,0226 tr/mn:
Cela fait :
44,24 mn/tr (en fait on programme des intervalles de temps)
2650 s/tr
13.27 s/pas (le moteur est un 200 pas par tour)
ou encore 4 fois 3.31s (les interruptions ne peuvent pas être plus espacées que 4s, il me faut un temps inférieur)

3.31s c'est
3318000µs
51853 fois 64µs (64µs c'est le temps possible pour mon horloge)


Le programme qui suit appelle la fonction ISR(TIMER1_COMPA_vect) toutes les 3,31s et une fois sur 4 (soit toutes les 13.27s fait avancer le moteur d'un pas comme calculé plus haut. Pour vérifier même sans le moteur, à chaque pas la led de la carte change d'état, et est envoyé sur la console série (réglée à 115200 bauds, mais qui peut être changée dans le setup du progamme) le nombre de pas faits pour chronométrage.

Le programme travaille par interruption, et est invisible pour la programmation. Si on démarre le moteur, celui ci tourne jusqu'à l'ordre contraire. On peut donc mettre n'importe quoi dans le loop, y compris du code bloquant. Cela n'a aucune influence sur le moteur. Le code principal peut aussi faire tourner le moteur en même temps, si loop demande d'avancer de 100 pas, le moteur fera alors les 100 pas en plus ou en moins du pas toutes les 13s.

J'ai mis quelques ordres dans loop(). Pour les faire marcher il faut copier la ligne correspondante et enlever le // du début. Une ligne a été mise pour l'exemple à la fin du setup.

Si tu as des problèmes, profite de mon confinement. Le cas contraire est improbable.


La résolution de ce programme est liée aux précision des double car le nombre de périodes d'horloge pour le timer est un réel (et plus un entier).
La précision quand à elle dépend de cette résolution et de la fréquence théorique des 16MHz.
J'ai eu besoin du même programme (avec 1s au lieu de 13) mais avec la possibilité de faire des corrections. Le principe est simple, si au lieu de 51853, j'ai besoin de 51853,25, il faudra mettre parfois 51853, parfois 51854.
Je l'ai fait pour moi, je n'ai eu qu'à changer 1s en 13s.

La première ligne est à ajuster, c'est elle qui peut faire comme un ajustement de la fréquence du quartz. On essaie le programme sans correction (1.0), et si le temps est trop long ou trop court, on ajuste.

double correction = 1.0; // Peut ainsi changer légèrement les temps 1.0 -> 100%;  1.01 -> on augmente le temps de 1%
double base = 51852.8761; // 51853  * 64µs = 3,31s





double erreur = 0.0; // ce qui n'est pas pris en compte et qui sera rajouté à la prochaine interruption

// Definition des broches utilisées par le moteur
const int stepPin = 4;
const int dirPin = 3;



// Routine d'interruption appelée toutes les 3,31s et qui une fois
// sur 4 fait progresser le moteur d'un pas.
uint32_t diviseurPar4 = 0;
ISR(TIMER1_COMPA_vect) // appelée toutes les 3,31s
{
  // Temps pour la prochaine interruption
  erreur = base * correction + erreur; // valeur temporaire, rien à voir avec erreur
  OCR1A = round(erreur)-1; // la bonne valeur est base * correction, mais ce n'est pas un entier; le -1 est harware
  erreur -= OCR1A+1; // Cette fraction ne rentrait pas, on la rajoutera au calcul suivant
  diviseurPar4++;
  if ((diviseurPar4 & 3) == 0) // Une fois sur 4
  {
    // Avance d'un pas pour le moteur
    digitalWrite(stepPin, HIGH);
    digitalWrite(stepPin, LOW);

    // Change d'état la led de la carte pour contrôler sur la carte
    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));

    // Affiche le nombre de pas faits si on va lentement
    if (OCR1A > 5000)
    {
      Serial.print("Pas n°");Serial.println(diviseurPar4 >> 2); 
    }
  }
}




void setup()
{
  // Initialisation led
  digitalWrite(LED_BUILTIN, LOW);
  pinMode(LED_BUILTIN, OUTPUT);

  // initialisation du moteur
  digitalWrite(stepPin, LOW);
  pinMode(stepPin, OUTPUT);
  digitalWrite(dirPin, LOW);
  pinMode(dirPin, OUTPUT);

  // Preparation de l'affichage facilite la mise au point
  Serial.begin(115200);

  // Mettre en route le timer 1 (16 bits)
  TCCR1A = 0b00000000; // Pas de comparaisons, mode CTC mode 4
  TCCR1B = 0b00001101; // Mode CTC ICR (4), base de temps 64µs, division 1024

  // Les autres initialisation si tu en as
  TIMSK1 = 0b00000010; // Faire tourner le moteur

}


void loop()
{


  //  Pour aller à la vitesse prévue, correction = 1.0; (première ligne, mais peut être changée dans le programme)
  //  Si le temps est 1% trop long, il faut prendre 99% du temps prévu -> correction = 0.99;   
  //  Si on veut aller 100 fois plus vite pour tester le programme -> correction = 0.01;
  //  On ne peut aller 20% plus lentement pas plus, sinon il y a débordement. Le programme est prévu pour 13s +20% -100%
  //  TIMSK1 = 0b00000010; // Faire tourner le moteur
  //  TIMSK1 = 0b00000000; // arrêter la rotation
  //  digitalWrite(dirPin, LOW); // Pour que le moteur tourne dans l'autre sens
  //  digitalWrite(dirPin, LOW); // Pour que le moteur tourne dans le sens de départ


}

Salut.
J'ai copié /collé le code fourni dans la carte Arduino.
Le téléverserment c'est effectué sans aucun soucis. Le code est bien sur la carte.... Et le moteur tourne pas :).
Peut-être ai-je mal compris. Il ne fallait peut-être pas copier /collé bêtement le code. Et enlever le texte d'explication "//"?

Je pense avoir saisi la manipulation pour augmenter /diminuer la vitesse par contre.

ce qui est derrière // sont des commentaires, cela permet d'expliquer le code, et c'est ignoré à la compilation. En principe on les laissent

Le moteur devrait tourner, mais à raison de 1 pas toutes les 13s? En gros il doit tourner arrêté si les calculs sont bons. Pour la vitesse de 0,0226 tr/mn au bout d'une minute, il n'a tourné que de 0,0226 tours, c'est à dire à peine.

Pour voir si cela fonctionne, il faut l'accélérer par exemple de 100 fois:

double correction = 100.0; // Peut ainsi changer légèrement les temps 1.0 -> 100%;  1.01 -> on augmente le temps de 1%

Il devrait tourner à 2,26 tr/mn ce qui devrait être visible.

Pour chahuter un peu, je dirais que si le moteur ne tourne pas, c'est bon pour le télescope, car les étoiles ne bougent pas non plus. Un fois j'ai attendu au moins 10 mn, je n'ai rien vu bouger...