Table équatoriale : Roulements

La réalisation d’une table équatoriale passe par la définition du plan et des cotes : Une table équatoriale doit être adaptée aux dimensions et au centre de gravité du télescope pour lequel elle est conçue. La hauteur entre les deux plateaux de la table équatoriale conditionne ces paramètres et cette hauteur dépend elle-même des roulements. Je commence donc par fabriquer ces roulements. Les pièces centrales sont des roulements de roller. Ils sont montés sur des équerres d’assemblage. Ces dernières ont l’avantage d’être pré percée pour la fixation. Il suffit d’agrandir ces trous afin d’y insérer l’axe des roulements : un boulon de M8. L’assemblage suit le principe proposé par le site dont je m’inspire pour ce projet.

Un double roulement de table équatoriale réalisé à partir de roulements de roller et d’équerres d’assemblage. Il en faudra quatre comme cela.

Astrophotographie 💫 Astronomie amateure 💫 Dobson 💫 Table équatoriale 💫 Télescope Newton 💫 Suivi stellaire 💫

Push & Go : Plan de câblage

La transformation de la motorisation de télescope afin d’inclure une fonction Push & Go nécessite l’ajout d’un bouton poussoir. Il est connecté entre la broche 10 de l’Arduino et une de ses broches Ground (notée GND). La modification est tellement modeste que le plan de câblage initialement proposé est quasi inchangé. Cependant, voici la nouvelle version ci-dessous. Ce plan de câblage fonctionne avec le code Arduino Push & Go préalablement publié.  

Plan de câblage de la motorisation d’un télescope par moteur pas à pas avec trois vitesses (de suivi, de centrage et de pointage) incluant la fonction Push & Go par bouton poussoir entre la broche 10 de l’Arduino et l’une de ses broches GND.

💫 Arduino 💫 Motorisation de télescopes 💫 Monture équatoriale 💫 Moteur pas à pas💫 Pointage 💫 Push & Go 💫 Télescope 💫

Porte oculaire Crayford : version tractopelle

« Tractopelle » car cette version utilise le châssis d’un tractopelle modèle réduit d’enfant comme chemin de roulement du tube porte coulissant. Je suis satisfait du fonctionnement. Après une première, puis une deuxième version, je pense que cette troisième version est la bonne. C’est toujours le meccano goBilda qui est utilisé pour sa réalisation. 

Porte oculaire Crayford réalisé en meccano goBilda avec pour chemin de roulement un châssis de modèle réduit de tractopelle. On voit les pneumatiques du tractopelle contre lesquels s'appuie le tube coulissant en PVC.   

💫 Crayford 💫 DIY 💫 goBilda 💫 Porte oculaire 💫 Newton💫

Push & Go : Push & Gag

Lors de mes essais de la fonction Push & Go, je me suis retrouvé confronté à un comportement erratique du déplacement. J’ai mis un moment à comprendre l’évidence : une monture allemande est asymétrique. Ainsi le tube du télescope peut se trouver soit à droite, soit à gauche de l’axe. Dans un cas, le sens du déplacement delta sera celui déterminé alors que dans le second, le sens sera inversé !

 

Deux positions de la monture allemande où le tube pointe le même champ. Le mouvement delta est inversé entre ces deux positions !

💫 Arduino 💫 Motorisation de télescopes 💫 Monture allemande 💫 Monture équatoriale 💫 Moteur pas à pas💫 Pointage 💫 Push & Go 💫 Télescope 💫

Push & Go : Paramétrage

Nous avons vu dans un billet précédent comment calculer le décalage entre une étoile repère et un objet cible du ciel profond pour une visée par Push & Go. Le paramétrage du Push & Go se fait directement dans le code Arduino déjà présenté. Il convient de repérer les lignes

AxeA.moveTo(AxeA.currentPosition() + 2425); // Push&Go alpha de 2425 pas vers l'avant (+)

AxeD.moveTo(AxeD.currentPosition() - 817); // Push&Go de 817 pas vers l'arrière (-)

Et de remplacer la valeur + 2425 par le décalage calculé en ascension droite (alpha) et la valeur – 817 par le décalage calculé en déclinaison (delta). Ainsi, afin d’effectuer un Push & Go depuis Alkaid (Eta UMa) vers M51, on saisira + 1549 pour le déplacement alpha et + 743 pour le déplacement delta.

Copie d'écran de l'IDE Arduino affichant le code du Push & Go. La copie d'écran est centrée sur la boucle du Push & Go lui même et montre le paramétrage du déplacement depuis l'étoile repère Eta UMa et l'objet cible M51, soit + 1549 pas en alpha et + 743 pas en delta.

💫 Arduino 💫 Motorisation de télescopes 💫 Monture équatoriale 💫 Moteur pas à pas💫 Pointage 💫 Push & Go 💫 Télescope 💫

Table équatoriale : Centre de gravité

Mon projet central consiste en la construction d’un télescope Newton équatorial de 200 mm. Je découvre cependant la joie d’utiliser le petit Dobson Newton  T114. C’est tellement agréable que parfois je me demande pourquoi faire plus. J’ajoute donc à mon projet celui d’une table équatoriale pour le T200. La table équatoriale associe la simplicité du Dobson au confort du suivi stellaire équatorial. Pour me familiariser avec ce système que je ne connais pas, je vais commencer par réaliser une table équatoriale pour le Newton T114. Apparemment, la première étape consiste à déterminer le centre de gravité du télescope. Avec un aussi petit télescope que le T114, j’utilise une technique de poigne : je tiens le télescope avec sa monture entre deux doigts afin de trouver le point d’équilibre : c’est la hauteur du centre du gravité !  

Le centre de gravité du Newton T114 Dobson tel qu’indiqué par l’équilibre lors de la suspension entre deux doigts

💫 Astronomie amateure💫 Dobson💫 Table équatoriale💫 Télescope Newton💫 Suivi stellaire💫

Porte oculaire Crayford : Roulements

Le chemin de roulements de la nouvelle version du porte oculaire Crayford sera donc réalisé avec le châssis d’un engin de chantier miniature. Le jeu consiste à le désolidariser du modèle réduit et le fixer sur un élément de meccano goBilda.

 

Le châssis d’un engin de chantier miniature réalise le chemin de roulements pour un porte oculaire Crayford 

💫 Crayford 💫 DIY 💫 goBilda 💫 Porte oculaire 💫 Newton💫

Porte oculaire Crayford : Tractopelle 1:50

J’avais présenté le porte oculaire Crayford réalisé en meccano goBilda alors que je n’étais pas convaincu par le chemin de roulement du tube porte oculaire réalisé en joints toriques de plomberie. Je proposais l’utilisation d’un chemin de roulement constitué par un châssis de petite voiture. Mieux qu’une petite voiture, un engin de chantier avec ses gros pneumatiques et ses roues rapprochées me semble une très bonne option.

Le tractopelle Siku posé sur le tube PVC de 50 mm.

💫 Crayford 💫 DIY 💫 Porte oculaire 💫 Newton💫

Push & Go : Bouton poussoir

L’ajout de la fonction Push & Go à la motorisation du télescope impose un nouveau bouton poussoir sur le boitier du Télescopilote (selon le principe de la simplexification !). Ce n’était pas prévu initialement et je le case sur la façade où je peux. Une autre limite du boitier apparait : le Push & Go nécessite de téléverser le code Arduino comportant les valeurs de chacun des Push & Go souhaités alors que la connexion de la carte Arduino n’avait pas été pensée pour être accessible. Il me faudra donc refaire un nouveau boitier plus fonctionnel.

Façade modifiée du Télescopilote qui incorpore le bouton poussoir rouge du Push & Go

💫 Arduino 💫 Motorisation de télescopes 💫 Monture équatoriale 💫 Moteur pas à pas💫 Pointage 💫 Push & Go 💫 Télescope 💫

Push & Go : Calcul du déplacement

Pour chaque Push & Go que l’on souhaite réaliser, il convient de calculer le déplacement en nombre de pas à imposer au moteur alpha d’ascension droite et delta de déclinaison. C’est le même principe que le calcul déjà présenté de vitesse de suivi sidéral. Cependant, voici tout de même l’exemple de calcul pour le récent test sur le terrain Push & Go to Mars. Pollux a fait office d'étoile repère. C'est elle qui était pointée par l’observateur alors que le Push & Go a déplacé le pointage vers l'objet cible, Mars.

Calcul de la distance d’avec la cible

Le jeu consiste à trouver les coordonnées équatoriales des deux objets, l’étoile repère et l’objet cible. Un catalogue d’étoiles indique celles de Pollux, Right ascension: 7h 45m 18.953s Declination: 28° 1' 34.316''. On converti le tout en seconde. Soit (7 x 60 x 60) + (45 x 60) + 18.953 = 27918.95 s alpha et (28 x 60 x 60) + (1 x 60) + 34.316 = 100894.32’’ delta. Un site propose les éphémérides du système solaire et donne les coordonnées actualisées en direct. Soit pour Mars le jour du test : 7h 17min 40.62 s alpha et 25° 41’ 56.13’’ delta soit respectivement 26260.62 sec alpha et 92516.13’’ delta. La différence Pollux – Mars est donc 1658.33 sec alpha et 8378.19’’ delta.

Calcul du déplacement

Le code Arduino du Push & Go désactive le mode µpas utilisé en mode suivi. Les moteurs pas à pas de la petite monture équatoriale allemande font donc 200 pas par tour dans ce mode. Les roues dentées de l'axe d'ascension droite et de déclinaison ont 105 dents et leur pignon a 15 dents, le ratio est donc de 105/15 = 7. Les spécifications du motoréducteur m'indiquent que le ratio du réducteur est de 90,25 (il faut 90,25 tours de moteur pour obtenir un tour de l'axe de sortie du réducteur). Le ratio total est donc de 90,25 x 7 = 631,75. Il faut donc 631,75 tours de moteur afin d'avoir un tour d'axe d'ascension droite ou un tour d’axe de déclinaison et donc Il faut donc 200 x 631,75 = 126350 pas pour un tour d'axe alpha ou delta. Un tour complet d’axe d’ascension droite fait 24h ou 86400 s, un tour complet d’axe de déclinaison fait 360° ou 1296000’’. Une seconde alpha nécessite donc un déplacement de 126350/86400 = 1.462 pas alors qu’une seconde delta nécessite un déplacement de 126350/1296000 = 0.097 pas.

Calcul du nombre de pas de décalage d’avec la cible

Il n’y a plus qu’à multiplier la distance à la cible déterminée en secondes par le nombre de pas par seconde. Soit 1658.33 x 1.462 = 2425.116 pas pour le mouvement alpha que l’on arrondi à 2425 et soit 8378.19 x 0.097 = 816.809 pas pour le mouvement delta que l’on arrondi à 817 pas.

Il convient de saisir ces valeurs dans le code Arduino du Push & Go, puis de téléverser le code dans l'Arduino de pilotage du télescope. Une fois l'étoile repère positionnée dans le champ du télescope, la pression du poussoir du Push & Go réalisera le déplacement vers la cible. 

Ces calculs paraissent un peu lourd, mais une fois entrés dans un tableur, il suffit pour chaque Push & Go souhaité de saisir les coordonnées équatoriales de l’étoile repère qui sera pointée et celle de l’objet cible. Le décalage apparait alors immédiatement dans les cellules appropriées.

 

La mise au point et les préparations du test Push & Go to Mars

💫 Arduino 💫 Motorisation de télescopes 💫 Monture équatoriale 💫 Moteur pas à pas💫 Pointage 💫 Push & Go 💫 Télescope 💫

Push & Go : Code Arduino

Le code Arduino du Push & Go est une simple évolution du code Arduino de suivi stellaire à trois vitesses (pointage, centrage, suivi). Le Push & Go nécessite l’ajout d’un poussoir entre la broche 10 de l’Arduino et une broche GND. Il n’y a pas besoin de résistance car le code utilise la résistance interne virtuelle de l’Arduino par la fonction PULLUP : pinMode(pinPuGo, INPUT_PULLUP). Je reviendrai sur le calcul du nombre de pas à indiquer dans le code afin d’obtenir le déplacement Push & Go souhaité.

/*
 * Motorisation d'une monture équatoriale Contrôlée par joystick avec fonction Push&Go
 * Vitesse de suivi stellaire, de centrage et de pointage, bascule par le bouton poussoir du joystick
 * Voyant LED pour le mode pointage, 1/2 éclairé pour le mode centrage, éteint en suivi stellaire
 * Push&Go par bonton poussoir 
 * Seuil à 100 pour la détection de l'actionnement du joystick (sur 1024)
 * Délai à 100 ms contre l'incertitude du bouton poussoir
 * Motorisation via driver de moteur pas à pas DRV8825
 * Broches Arduino organisées pour le blindage grand format Electrocookie
 * Utilise les bibliothèques Arduino AccelStepper et Bounce2
 * Voir le blog Astronomie par les trois bouts
 * astronomiebbb.blogspot.com/
 */ 

//Inclusion des bibliothèques
#include <AccelStepper.h> // Gestions moteur pas à pas
#include <Bounce2.h> // Gestion bouton poussoir

//Déclaration des broches d'Arduino
const int pinM012 = 4; //Contrôle du mode micropas
//(les broches M0, M1 et M2 des deux DRV8825 sont connectées entre elles)
const int pinLed = 3; // Broche de la LED
const int pinSwJoy = 2; //Broche du bouton du joystick
const int pinPuGo = 10; //Broche du bouton poussoir Push&Go

//Broches pour l'axeA
const int pinJA = A0; //Lecture AxeA du joystick
const int pinDirA = 6; //Contrôle la direction du moteur AxeA
const int pinStepA = 5; //Contrôle la vitesse du moteur AxeA

//Broches pour l'axeD
const int pinJD = A1; //Lecture AxeD du joystick
const int pinDirD = 8; //Contrôle la direction du moteur AxeD 
const int pinStepD = 7; //Contrôle la vitesse du moteur AxeD

//Déclaration des variables
long speedA, valA, mapA, bougeA; //variables de gestion des mouvements moteur AxeA
long speedD, valD, mapD, bougeD; //variables de gestion des mouvements moteur AxeD
boolean micropas; //Contrôle du mode microstepping

boolean actionA, actionD; //Gestion de mise en oeuvre des corrections

unsigned long debounceDelay = 100; //Délai contre l'incertitude du bouton poussoir
int mode; // mode de fonctionnement : suivi ou centrage ou pointage

//Paramètres d'AccelStepper
const int maxSpeed = 1000; //Définit la Vmax du moteur (indispensable)

const int threshold = 100; //Contre la faible fiabilité des potentiomètres
long thresholdUp, thresholdDown; //variables ancillaires à la précédente

//Déclaration des moteurs dans la bibliothèque AccelStepper
AccelStepper AxeA(AccelStepper::DRIVER, pinStepA, pinDirA);
AccelStepper AxeD(AccelStepper::DRIVER, pinStepD, pinDirD);

//Déclaration du bouton poussoir du joystick
Bounce swJoy = Bounce();
//Déclaration du bonton poussoir Push&Go
Bounce PuGo = Bounce();

void setup() {
  mode = 0; //Démarre en mode suivi stellaire
  
  //Définition des modalités des broches
  pinMode(pinM012, OUTPUT);
  pinMode(pinLed, OUTPUT);
  pinMode(pinSwJoy, INPUT_PULLUP);
  pinMode(pinPuGo, INPUT_PULLUP);
  
  analogWrite(pinLed, 0); //LED- puisque mode suivi stellaire

  //Active le microstepping par défaut
  micropas = true;
  digitalWrite(pinM012, micropas);

  //Calcule la plage du joystick devant être considérée comme "Centré"
  thresholdDown = (1024 / 2) - threshold;
  thresholdUp = (1024 / 2) + threshold;

  //Configure les paramètres des moteurs
  AxeA.setMaxSpeed(maxSpeed);
  AxeD.setMaxSpeed(maxSpeed);

  //Configure le bouton poussoir du joystick
  swJoy.attach(pinSwJoy); // Bouton relié à la broche pinSwJoy
  swJoy.interval(debounceDelay); //Délai d'incertitude

  //Configure le bouton poussoir Push&Go
  PuGo.attach(pinPuGo); // Bonton relié à la broche pinPuGo
  PuGo.interval(debounceDelay); //Délai d'incertitude
}

void loop() {
  checkSwJoy(); // Lance la void ainsi nommée
  if (mode == 0) {
    analogWrite(pinLed,0); //mode suivi, éteind la LED  
  }
  if (mode == 1) {
    analogWrite(pinLed,10); //mode centrage, LED 1/2 allumée
  }
  if (mode == 2) {
    analogWrite(pinLed,255); //mode pointage, LED allumée
  }
  
  //Par défaut, pas d'action sur le joystick 
  actionA = false;
  actionD = false;
   
  //Lecture des potentiomètres du joystick
  valA = analogRead(pinJA);
  valD = analogRead(pinJD);

  //Vérifie si le joystick est actionné en AxeA
  //Si "oui", code la valeur du potentiomètre en pas/s
  if (valA>thresholdUp || valA<thresholdDown)
  {
    mapA = map(valA, 0, 1023, -950, 950);
    actionA = true;
  }
    
  //Vérifie si le joystick est actionné en AxeD
  //Si "oui", code la valeur du potentiomètre en pas/s
  if (valD>thresholdUp || valD<thresholdDown)
  {
    mapD = map(valD, 0, 1023, -950, 950);
    actionD = true;
  }


   //Vérifie si le bouton poussoir Push&Go est actionné
   //Si "oui", autorise la mise en oeuvre du Push&Go
    PuGo.update(); // Mise à jour du bouton
  if (PuGo.fell()) // Actionné ?
    {
      micropas = false; // Désactive le microstepping
      digitalWrite (pinM012, micropas); // Désactive le microstepping
      // Mise en oeuvre du Push&Go sur le moteur alpha
      AxeA.setCurrentPosition(0); // Attribue 0 à la position actuelle
      AxeA.setSpeed(800); // Fixe la vitesse du Push&Go
      AxeA.setAcceleration(200); // Fixe l'accélération du Push&Go
      AxeA.moveTo(AxeA.currentPosition() + 2425);  // Push&Go alpha de 2425 pas vers l'avant (+)
      while(AxeA.distanceToGo() != 0) // Fait tourner le moteur du nombre de pas ci-dessus
        {
          AxeA.run(); // Mise en oeuvre du moteur Alpha
        }
        // Mise en oeuvre du Push&Go sur le moteur delta
      AxeD.setCurrentPosition(0); // Attribue 0 à la position actuelle
      AxeD.setSpeed(800); // Fixe la vitesse du Push&Go
      AxeD.setAcceleration(200); // Fixe l'accélération du Push&Go
      AxeD.moveTo(AxeD.currentPosition() - 817);  // Push&Go delta de 817 pas vers l'arrière (-)
      while(AxeD.distanceToGo() != 0) // Fait tourner le moteur du nombre de pas ci-dessus
        {
          AxeD.run(); // Mise en oeuvre du moteur Delta
        }
      // Reprendre en mode suivi stellaire
      mode = 0; 
      micropas = true;
      digitalWrite(pinM012,micropas);
      AxeA.setSpeed(46.924);// Vitesse alpha de suivi stellaire
      AxeA.runSpeed();
      AxeD.stop(); // Moteur delta à l'arrêt
    } 

 //Fait bouger les moteurs si action sur le joystick
  if (actionA) // Si le joystick est actionné en A
    {  
    if (mode == 0) // Si mode suivi stellaire
      {
        bougeA = (mapA/100)+46.924; // Vitesse de suivi stellaire +/- correction
        micropas = true; // Active le microspepping
      }
     if (mode == 1) // Si mode centrage
      {
        bougeA = (mapA);
        micropas = true; // Active le microspepping
      } 
     if (mode == 2) // Si mode pointage
        {
          bougeA = (mapA);
          micropas = false; // Désactive le microstepping
        }
       
    digitalWrite(pinM012, micropas);
    AxeA.setSpeed(bougeA);
    AxeA.runSpeed();
    mapA = 0;
    }
    else // Si pas d'action sur le joystick en A
      {
        micropas = true;
        digitalWrite(pinM012,micropas);
        AxeA.setSpeed(46.924);// Vitesse de suivi stellaire
        AxeA.runSpeed();
      }
  if (actionD) // Si le joystick est actionné en D
    {
    if (mode == 0) // Si mode suivi stellaire
      {
        bougeD = (mapD/100); // Vitesse proportionnelle à l'axe A 
        micropas = true; // Active le microstepping
      }
     if (mode == 1) // Si mode centrage
        {
          bougeD = (mapD);
          micropas = true; // Désactive le microstepping
        }
     if (mode == 2) // Si mode pointage
        {
          bougeD = (mapD);
          micropas = false; // Désactive le microstepping
          // Pas besoin de calculer la vitesse du moteur, on utilise mapD
        }
    digitalWrite(pinM012, micropas);    
    AxeD.setSpeed(bougeD);
    AxeD.runSpeed();
    }
    else // Si pas d'action sur le joystick en D
      {
        AxeD.stop(); // Moteur à l'arrêt
      }
}

void checkSwJoy() // Bouton poussoir joystick actionné ?
{
  swJoy.update(); // Mise à jour du bouton
  if (swJoy.fell()) // Actionné ?
  {
    ++mode; // incrémente le mode
    if (mode>2) // revient en mode suivi
    {
      mode = 0; // mode suivi
    }    
  }
  
}  

Push & Go to Mars

L’objectif est de démontrer sur le terrain la fonctionnalité du Push & Go ajouté à la motorisation de télescope. Le départ sera Pollux, le Push & Go activé amènera le pointage du télescope vers Mars. Les deux sont proches selon le ciel du soir. Je prévoyais d’utiliser la configuration « photo planétaire » mais il s’est avéré que l’appareil photo est bien trop lourd pour la petite monture équatoriale allemande. J’installe donc comme je peux un vieil appareil photo numérique compact pas du tout adapté à l’astronomie.  

Démonstration sur le terrain du Push & Go de la motorisation d’une monture équatoriale. Pointage manuel initial vers Pollux, Push & Go to Mars.  

💫 Arduino 💫 Motorisation de télescopes 💫 Monture équatoriale 💫 Moteur pas à pas💫 Pointage 💫 Push & Go 💫 Télescope 💫

Push & Go : Démonstration

Pour changer du T200, je reviens à mon projet d'évolution de la motorisation de télescope afin de disposer de la fonction Push & Go. Cela nécessite une modification du logiciel mais pas seulement puisqu’il faut ajouter un bouton poussoir. Après quelques tests de faisabilité, je modifie le code Arduino de motorisation à trois vitesses (pointage, centrage et suivi) assez facilement (je donnerai le code dans un prochain billet). L’essai du jour s’effectue à l’intérieur. La prochaine étape sera une démonstration sur le terrain. Il faudra pour chaque pointage Push & Go déterminer le nombre de pas en avançant ou en reculant pour chacun des moteurs alpha et delta. Une conversion déplacement angulaire / nombre de pas sera donc nécessaire selon le principe déjà exposé.

Démonstration "de salon" du Push & Go de la motorisation d’une monture équatoriale

💫 Arduino 💫 Motorisation de télescopes 💫 Monture équatoriale 💫 Moteur pas à pas💫 Pointage 💫 Push & Go 💫 Télescope 💫