Astro-Tracker - Astroduino

Systeme de suivi equatorial type "planchette" pour l'astrophotographie pose longue , motorisé par un moteur pas a pas bi-polaire et un Arduino uno.
La tige filetée est démontable pour faciliter le transport.
Le moteur est dispo chez Go-tronic: http://www.gotronic.fr/art-moteur-24byj48-19028.htm
Les blocs sont assemblés a l'aide de tiges lisse en acier inox diametre 8mm et longueur 220mm(précis). Les tiges sont collées dans leur logement a l'aide de colle epoxy bi-composant.
La tige filetée courbée est du M8 (laiton).

Le code arduino gere le moteur en augmentant ou reduisant le nombre de MicroSecondes de delai entre chaque pas. Les touches du shield LCD permet d'incrementer ou de reduire la vitesse de 1Ms avec les touches haut/bas ou 10Ms avec les touches droite/gauche.
Un compteur de temps de poursuite est ajouté (le compte s'arrete lorsque le systeme est arrèté.

materiel necessaire:

MECANIQUE:
2 vis M3x16mm + 2ecrous M3 (platine moteur)
2 vis M6x65mm + 4 ecrous M6 (fixation tige courbée , boutons de serrage)
4 tiges acier inox diametre 8mm long.220mm
1 tige acier inox long. 155mm filetée aux 2 extremités sur 7mm + 2 ecrous M8(ou tige filetée M8 (axe charnière)
mais moins bon car diametre legerement plus petit et cause de jeu)
1 tige filetée M8 laiton courbée (rayon 285.7mm) + 3 ecrous M8 dont un borgne
3 vis chc M4x20mm + 3 ecrous M4 (cale de compensation - support rotule)
2 vis chc M5x30mm + 2 ecrous M5 (fixation rapide trepied photo)
3 vis chc M5x30mm + 3 ecrous M5 (support viseur polaire)
4 roulements type "roller" 8x22
1 roulement 12x32 (epaisseur 10)

ELECTRONIQUE:
1 arduino uno r3
1 shield LCD DFrobot
1 driver moteur Easydriver V4
interrupteur
batterie 6v 2 ou 4 Ah

Ajout du boitier pour l'electronique: ( l'arduino+lcd+easyDriver sont maintenus dans le boitier par des vis plastique et des ecrous M3 )

Les premiers tests m'ont permis de realiser la photo de la voie lactée jointe , 180 secondes de pose a 24mm f4.5 1200 iso.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//  ASTRODUINO - STARTRACKER
//  motorisation d'une "planchette equatoriale" a tige filetée courbée 
//  controle de vitesse du moteur PAP par gestion du delai "microseconde" entre les          fronts montants et descendants
//  compteur de temps de poursuite en utilisant un timer


  #include
 <TimerOne.h>               // librairie pour le timer d'horloge                
  #include
 <LiquidCrystal.h>          // librairie ecran LCD
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);    // declaration des pins utilisées par l'ecran lcd


  #define
 motorPinStep  13   // commande de pas moteur sur pin 13
  #define
 motorPinDir  12    // commande de direction du moteur sur pin 12 


int adc_key_val[5] ={50, 200, 400, 600, 800 };  // valeurs analogiques des boutons
int NUM_KEYS = 5;                               // declaration du nombre de boutons
int adc_key_in;                                 // valeur analogique du bouton appuyé
int key=-1;                                     // 
int isRun;                                      // variable "en marche" ou "arret"


int DelaiPas = 458;        // delai en microsecondes entre chaque pas moteur
int minspeed = 8000;        // delai max pour vitesse minimum

char message[16] = "";      // taille d'une ligne de l'ecran pour affichage de l'horloge
int heures,minutes,secondes;  // variables pour horloge

volatile unsigned long blinkCount = 0; //iterations du timer

/////////////////////////////////////////////////////////////////////////////
void Horloge(void)     // fonction d'interruption timer pour affichage de l'horloge
{

    blinkCount = blinkCount + 1;  // incrementation du timer

// on commence par gérer le temps qui passe...
secondes++;
if(secondes == 60) // une minute est atteinte ?
{
    secondes = 0; // on recompte à partir de 0
    minutes++;
}
if(minutes == 60) // une heure est atteinte ?
{
    minutes = 0;
    heures++;
}
if(heures == 24) // une journée est atteinte ?
{
    heures = 0;
}

  sprintf(message,"%2d:%2d:%2d",heures,minutes,secondes); // formatage de l'horloge
  lcd.setCursor(8,0);           
  lcd.write(message);
}
//////////////////////////////////////////////////////////////////////

void motorrun()   // fonction moteur
{
digitalWrite( 13 , HIGH );
delayMicroseconds( DelaiPas );
digitalWrite( 13 , LOW );
delayMicroseconds( DelaiPas );

}



/////////////////////////////////////////////////////////////////////////////


void setup() {

pinMode( 12 , OUTPUT);  // declaration des broches en sorties
pinMode( 13 , OUTPUT);  //
digitalWrite( 12 , HIGH );  // on fixe le sens de rotation

heures = 0;       //
minutes = 0;      //  initialisation des variables de temps
secondes = 0;     //
Timer1.initialize(1000000);       // initialisation du timer (1000000 de microsecondes = 1        seconde)
Timer1.attachInterrupt(Horloge);  // affectation d'une fonction d'interruption ( quoi faire a chaque interruption du timer)
Timer1.stop();      // on stop le timer pour empecher le debut du compte

lcd.clear();       // efface l'ecran
lcd.begin(16, 2);  // initialise l'ecran
lcd.setCursor(0,0);   // place le curseur au premier caractere de la premiere ligne
lcd.print("***ASTRODUINO***");
lcd.setCursor(0,1);  
lcd.print("**STAR-TRACKER**");
delay(2000);
lcd.clear();
lcd.setCursor(0,0);
lcd.print("Stopped  0: 0: 0"); 
lcd.setCursor(0,1); 
lcd.print("Delay= "); 
lcd.print(DelaiPas);
lcd.print(" Msec");

isRun = 0;   

}



/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
void loop() {

adc_key_in = analogRead(0);    // lire la valeur du capteur
key = get_key(adc_key_in);  // convertir en " qulle touche a ete appuyée"
if (key >= 0)   // si appui d'une touche detecté..
 {
    if (key == 1) {
                 DelaiPas += 1;
                 delay(150);
                }

  if (key == 2 && DelaiPas > 0) {
                                 DelaiPas -= 1;
                                 delay(150);
                                }

  if (key == 0) {
                 DelaiPas += 10;
                 delay(150);
                }

  if (key == 3) {
                 DelaiPas -= 10;
                 delay(150);
                }

  if (DelaiPas>minspeed) {
                          DelaiPas = minspeed;
                         }

  if (DelaiPas<-minspeed) {
                           DelaiPas = -minspeed;
                          }

  if (key == 4) {        // si touche " select " appuyée > "running" ou "stopped"
                 isRun = 1 - isRun;   // bascule logique > si "marche" alors "arret" et vice   versa
                 lcd.setCursor(0,0); 
                 if (isRun == 1) {
                                  lcd.print("Running");
                                 } else {
                                         lcd.print("Stopped");
                                         Timer1.stop();    // arret du timer (donc de l'horloge) quand  passage de running a stopped
                                        }
                 delay(150);
                }

  lcd.setCursor(0, 1);
  lcd.print("Delay= "); 
  lcd.print(DelaiPas);
  lcd.print(" Msec  ");
  delay(50);

}

if (isRun == 1) {     // si "running"...
               motorrun();         // ... fonction moteur...
               Timer1.resume();        //... reprise de l' horloge 
              }

}

// fonction destinée a savoir quelle touche a ete appuyée
int get_key(unsigned int input)
{
int k;
for (k = 0; k < NUM_KEYS; k++)
  {
   if (input < adc_key_val[k])
        return k;
  }

if (k >= NUM_KEYS)
   k = -1;  // No valid key pressed
   return k;

}

-