Changeset 648 for BAORadio

Timestamp:

Mar 7, 2012, 6:19:29 PM (12 years ago)

Author:

frichard

Message:

Méthode d'alignement TAKI et AFFINE

Location:

BAORadio/libindi/libindi

Files:

• BAOControl/baocontrol.cpp (modified) (73 diffs)
• BAOControl/baocontrol.h (modified) (5 diffs)
• BAOControl/baocontrol_params (modified) (1 diff)
• communs/alignement.cpp (modified) (15 diffs)
• communs/const.h (modified) (1 diff)
• drivers/telescope/BAO.cpp (modified) (74 diffs)
• drivers/telescope/BAO.h (modified) (4 diffs)
• result_recherche_bao (modified) (1 diff)

BAORadio/libindi/libindi/BAOControl/baocontrol.cpp

@@ -27 +27 @@
     ChoixCouleurs=1;
 
-    //Affichage de la version du porgramme
+    // Affichage de la version du programme
 
     AfficherLog("\n\n\n\n\n \
@@ -66 +66 @@
     client_socket          = NULL;
 
-    // chaines de caractÚres et tableaux
+    // chaînes de caractÚres et tableaux
 
     LatitudeChar           = "";
@@ -78 +78 @@
 
 
-    //on initalise aussi les structures
+    // on initialise aussi les structures
 
     for (int i=0; i<MAXANTENNES; i++)
@@ -147 +147 @@
     }
 
-
     // Ouverture du socket avec indi_BAO
 
@@ -218 +217 @@
 
 
-    // crée une fenêtre
+    // création d'une fenêtre
 
     w = XCreateSimpleWindow(d, RootWindow(d, DefaultScreen(d)),
@@ -226 +225 @@
 
 
-    // Création du double buffer
+    // Création d'un double buffer (pour éviter le scintillement de l'écran
+    // lors de l'actualisation de la fenêtre.)
 
     db = XCreatePixmap(d, w, larg_fenetre, haut_fenetre, DefaultDepth(d, DefaultScreen(d)));
@@ -265 +265 @@
 /**************************************************************************************
 ** Dessine les éléments dans la fenêtre graphique
+**
 ***************************************************************************************/
 
@@ -295 +296 @@
     // on évite les affichages de l'heure du genre 12:56:60 ou 24:00:00
 
-    if (s==60) {
+    if (s == 60) {
         s = 0;
         mi++;
@@ -350 +351 @@
             }
 
-            XFillArc(d, db ,color, 10+i*30, 20+j*30, 15, 15, 0, 360*64);
-
-            XDrawArc(d, db ,noir,  10+i*30, 20+j*30, 15, 15, 0, 360*64);
+            XFillArc(d, db ,color, 10 + i * 30, 20 + j * 30, 15, 15, 0, 360 * 64);
+
+            XDrawArc(d, db ,noir,  10 + i * 30, 20 + j * 30, 15, 15, 0, 360 * 64);
         }
     }
@@ -374 +375 @@
 
     // On n'affiche la fenêtre graphique que lorsque tous les éléments ont été dessinés à l'intérieur
-    // On évite ainsi le scientillement de la fenêtre...
+    // On évite ainsi le scintillement de la fenêtre...
 
     XCopyArea(d, db, w, noir, 0, 0, larg_fenetre, haut_fenetre, 0, 0);
 
 
-    // On force le rafraichissement de l'écran
+    // On force le rafraîchissement de l'écran
 
     XFlush(d);
@@ -439 +440 @@
             reponse = reponse.substr(reponse.find("message") + 9);
 
-            //(on en garde une trace)
+            // (on en garde une trace)
 
             memreponse = reponse;
@@ -481 +482 @@
 
             // erreur sur une antenne -> on change son état dans la fenêtre
-            // on trouve les erreurs dans les messages d'indi_BAO forumulée
-            // de la façon suivnate: "ALERTE antenne" ou bien "Erreur sur l antenne"
+            // on trouve les erreurs dans les messages d'indi_BAO formulée
+            // de la façon suivante: "ALERTE antenne" ou bien "Erreur sur l antenne"
 
             if  ((reponse.find("ALERTE antenne ") != string::npos) ||
@@ -531 +532 @@
 /**************************************************************************************
 ** Est-ce que la réponse du pilote indi_BAO est conforme à ce que l'on attendait ?
-** Retourne true si c'est bonne
+**
 **
 ***************************************************************************************/
@@ -557 +558 @@
             duree++;
         }
-        while (reponse.length() == 0 && duree < 20 ); // on attend un message pendant 10 ms max
+        while (reponse.length() == 0 && duree < MAX_DELAI_REPONSE ); // on attend un message pendant 10 ms max
 
         // on ajoute tous les messages reçus dans memmreponse
@@ -644 +645 @@
 
     // Tant que l'utilisateur n'a pas tapé la commande 'exit'
+
     while (NoExit)
     {
@@ -655 +657 @@
 
 
-        // Faut-il executer un fichier de mouvements ?
+        // Faut-il exécuter un fichier de mouvements ?
 
         if (run && numobjets > 1 && runnum < numobjets)
@@ -664 +666 @@
             if ( JJ >= objets[runnum].JJ && !objets[runnum].exec )
             {
-                // petit message pour l'utilisateur au début de l'execution du tout premier mouvement
+                // petit message pour l'utilisateur au début de l'exécution du tout premier mouvement
 
                 if ( runnum == 1 ) AfficherLog("Début de l'exécution du fichier de mouvements\n\n", true);
@@ -703 +705 @@
                     cout << ">";
 
-                    // on réinitiale toutes les variables impliquées dans la commande run
+                    // on réinitialise toutes les variables impliquées dans la commande run
 
                     run         = false;
@@ -709 +711 @@
                     numobjets   = 1;
 
-                    // On sort du programme dans le cas BAOControl -r fileName
+                    // On sort du programme dans le cas de BAOControl -r fileName
 
                     NoExit = !exitrun;
@@ -722 +724 @@
         }
 
-        // on lit et affiche la réponse des microcontrolleurs
+        // on lit et affiche la réponse des micro-contrÎleurs
 
         LireReponse();
@@ -734 +736 @@
             gettimeofday(&tv, NULL);
 
-            // on ne sauvegarde les paramÚtres des alignements que si l'horloge du systÚme vient juste
-            // de changer de seconde. Cela evite les conflits avec le pilote indi_BAO qui cherche
+            // On ne sauvegarde les paramÚtres des alignements que si l'horloge du systÚme vient juste
+            // de changer de seconde. Cela permet d'éviter les conflits d'accÚs avec le pilote indi_BAO qui cherche
             // quant à lui à charger ce même fichier en fin de seconde...
 
-            if (tv.tv_usec/1.0E6>0.0 && tv.tv_usec/1.0E6<0.1)
+            if (tv.tv_usec/1.0E6 > 0.0 && tv.tv_usec/1.0E6 < 0.1)
             {
-                for (int i=0; i<numAntennes; i++) if (Antennes[i].ok == 1) Antennes[i].AlignementAntenne->EnregistrementParametresAlignement(Antennes[i].ip, "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg");
+                for (int i=0; i<numAntennes; i++) if (Antennes[i].ok == 1)
+                    {
+                        if (MethodeAlignement == SIMPLE )
+                        {
+                            Antennes[i].AlignementAntenne->EnregistrementParametresAlignement(Antennes[i].ip, "/home/" + (string)getenv("USER") + "/AlignementAntennesSIMPLE.cfg");
+                        }
+                        else
+                        {
+                            Antennes[i].AlignementAntenne->EnregistrementParametresAlignement(Antennes[i].ip, "/home/" + (string)getenv("USER") + "/AlignementAntennesTAKI.cfg");
+                        }
+                    }
+
             }
         }
@@ -781 +794 @@
     size_t pos = chaine.find(commande);
 
-    // si la commande est présente dans chaine, on continue
+    // si la commande est présente dans chaîne, on continue
 
     if (pos != string::npos)
@@ -820 +833 @@
             // on prend tout d'un bloc aprÚs la commande -> chaine 1
             // utile pour une commande du type "goto m 42" qui doit retourner "m 42" dans une
-            // même chaine
+            // même chaîne
 
             *chaine1 = chaine;
@@ -833 +846 @@
 /**************************************************************************************
 ** Envoie la longitude et la latitude du lieu d'observation au pilote indi_BAO
+** sous la forme de vecteurs xml
+** (voir les particularités des drivers développés sous Indi)
 **
 ***************************************************************************************/
@@ -839 +854 @@
 {
     // la communication avec le pilote indi_BAO
-    // se fait par l'envoi de fichiers xml
+    // se fait par l'envoi de trames au format xml
 
     try
@@ -980 +995 @@
 
 /**************************************************************************************
-** Envoie les paramÚtres delaitransit et delaitracking au pilote indi_BAO
-** Ces paramÚtres définissent la durée (en sec) entre deux actualisations
-** dans les modes tracking et transit
+** Envoie la méthode d'alignement au pilote indi_bao
+** Ce paramÚtre peut être SIMPLE, AFFINE ou TAKI
 **
 ***************************************************************************************/
@@ -1000 +1014 @@
         *client_socket << "</oneSwitch>";
         *client_socket << "<oneSwitch name=\"TAKI\">";
-        (MethodeAlignement == TAKI) ? *client_socket << "On" : *client_socket << "Off";
+        (MethodeAlignement == TAKI)   ? *client_socket << "On" : *client_socket << "Off";
         *client_socket << "</oneSwitch>";
         *client_socket << "</newSwitchVector>";
@@ -1098 +1112 @@
 
 /**************************************************************************************
-** Diriger l'antenne vers les coordonnées ar et dec et suivre l'objet
-** en activant le mode transit ou tracking.
+** Dirige l'antenne vers les coordonnées ar et dec et suit l'objet  en activant le mode
+** transit ou tracking.
 **
 ** si J2000 == true, cela signifie que les coordonnées ar et dec sont données dans le
 ** le systÚme de coordonnées J2000 (écliptique et équinoxe du 1 janvier 2000 à 0 h TU)
 ** Des calculs supplémentaires (précession, nutation, aberration) sont alors réalisés
-** pour ramener les coordonnées ad et dec à l'écliptique et l'équinoxe de la date de
+** pour ramener les coordonnées horaires à l'écliptique et l'équinoxe de la date de
 ** l'observation.
 **
@@ -1124 +1138 @@
 
     arf  = ( ar1  + ar2 / 60.0  + ar3 / 3600.0 ) * 15.0 * Pidiv180;
+
     decf = ( fabs(dec1) + dec2 / 60.0 + dec3 / 3600.0 ) * Pidiv180;
 
     if (dec[0] == '-') decf = -decf;
 
-    // calculs pupplémentaires pour se ramener
+    // Calculs supplémentaires pour ramener les coordonnées horaires
     // à l'époque de l'observation
 
@@ -1157 +1172 @@
         *client_socket << "<newSwitchVector device=\"BAO\" name=\"ON_COORD_SET\">";
         *client_socket << "<oneSwitch name=\"TRANSIT\">";
-        if (Transit) *client_socket << "On";
-        else *client_socket << "Off";
+        (Transit) ? *client_socket << "On" : *client_socket << "Off";
         *client_socket << "</oneSwitch>";
 
         *client_socket << "<oneSwitch name=\"TRACKING\">";
-        if (Transit)  *client_socket << "Off";
-        else *client_socket << "On";
+        (Transit) ? *client_socket << "Off" : *client_socket << "On";
         *client_socket << "</oneSwitch>";
         *client_socket << "</newSwitchVector>";
@@ -1207 +1220 @@
 /**************************************************************************************
 ** Se connecte ou se déconnecte au pilote indi_BAO
+**
 ***************************************************************************************/
 
@@ -1215 +1229 @@
         *client_socket << "<newSwitchVector device=\"BAO\" name=\"CONNECTION\">";
 
-        if (connect) *client_socket << "<oneSwitch name=\"CONNECT\">";
-        else *client_socket << "<oneSwitch name=\"DISCONNECT\">";
+        (connect) ? *client_socket << "<oneSwitch name=\"CONNECT\">" : *client_socket << "<oneSwitch name=\"DISCONNECT\">";
 
         *client_socket << "On";
@@ -1253 +1266 @@
         AfficherLog("La connexion a été établie avec le pilote indi_BAO.\n\n", true);
 
+        // Au moment de la connexion avec le driver indi_BAO
+        // On transmet les paramÚtres du lieu de l'observation, le mode de suivi
+        // ainsi que la méthode d'alignement utilisée
+
         usleep(500000);
 
@@ -1273 +1290 @@
 
 /**************************************************************************************
-** Gestion du clavier en mode raw pour la procédure d'alignement
+** Gestion du clavier en mode raw pendant la procédure d'alignement
 ** Cela permet de ne pas avoir à taper sur la touche 'entrée' aprÚs avoir appuyé sur
 ** une flÚche de direction
+**
 ***************************************************************************************/
 
@@ -1308 +1326 @@
 ** Le principe consiste à utiliser des étoiles comme point de repÚre pour la calibration
 ** des antennes : on compare la position calculée de chaque objet avec la position
-** effectivement mesurée lors de la procédure d'alignement. On en tire alors une matrice
+** effectivement mesurée lors de la procédure d'alignement. On en tire  une matrice
 ** de rotation qui doit corriger les défauts d'alignement de l'antenne (le 0 pas codeur
 ** pas  parfaitement dirigé vers le sud et un axe de rotation az pas forcément
 ** perpendiculaire au sol...)
+**
 ***************************************************************************************/
 
@@ -1348 +1367 @@
     {
         // L'alignement de l'antenne 'num' est en cours. Il ne faut pas calculer la
-        // matrice de correction tant que ce n'est pas fini..
+        // matrice de correction tant que ce n'est pas fini...
 
         AfficherLog("Début de l'alignement de l'antenne.\n\n", true);
@@ -1354 +1373 @@
         // On charge les paramÚtres d'alignement existants s'ils existent
 
-        Antennes[num].AlignementAntenne->ChargementParametresAlignement(ip, "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg", atol(ip.c_str()), num);
+        if ( MethodeAlignement == SIMPLE )
+        {
+            Antennes[num].AlignementAntenne->ChargementParametresAlignement(ip, "/home/" + (string)getenv("USER") + "/AlignementAntennesSIMPLE.cfg", atol(ip.c_str()), num);
+        }
+        else
+        {
+            Antennes[num].AlignementAntenne->ChargementParametresAlignement(ip, "/home/" + (string)getenv("USER") + "/AlignementAntennesTAKI.cfg", atol(ip.c_str()), num);
+        }
 
         // l'antenne num est en cours d'alignement
@@ -1362 +1388 @@
         // Si on n'a pas encore effectué la premiÚre phase de l'alignement (viser la polaire) dans les méthode d'alignement AFFINE et TAKI
 
-        if ( Antennes[num].AlignementAntenne->delta_az_polar == 0 && MethodeAlignement!=SIMPLE)
+        /*
+        if ( Antennes[num].AlignementAntenne->delta_az_polar == 0 && MethodeAlignement != SIMPLE)
         {
             cout << "Le radiotélescope va pointer l'étoile polaire.\n";
-            cout << "Agissez sur les touches Q et D pour centrer l'étoile dans le viseur...\n";
-            cout << "Appuyez sur A pour envoyer un ABORT Ã  l'antenne.\n";
-            cout << "Puis, appuyez sur ESC pour valider...\n\n";
+            cout << "Agissez sur les touches Q et D pour centrer l'étoile dans le viseur...\n";
+             cout << "Appuyez sur S pour changer de vitesse et sur A pour envoyer un ABORT Ã  l'antenne.\n";
+                        cout << "Appuyez sur G pour reprendre le suivi de l'objet aprÚs un ABORT ou un message d'erreur.\n";
+             cout << "Puis, appuyez sur ESC pour valider...\n\n";
 
 
@@ -1398 +1426 @@
                     ModificationAlignement=true;
                     AfficherLog("delta_az - 1\n", true);
-                    
+
                     break;
+                    //abort
                 case 'a' :
                     Abort();
@@ -1406 +1435 @@
                     break;
 
-               
+                    // vitesse 1x ou 10x
+                case 's' :
+                    (Vitesse == 1 ) ? Vitesse = 10 : Vitesse = 1;
+                    os << "Vitesse=" << Vitesse << "x\n\n";
+                    AfficherLog(&os,  true);
+
+                    break;
+
+                    // reprise du goto
+                case 'g' :
+                    AfficherLog("Reprise du GOTO.\n\n", true);
+                    Goto("02:31:49.6", "89:15:50.9", Transit, true);
+                    sleep(2);
+
+                    break;
+
+
                 }
 
             } while (c!=27);
-        }
+        } */
 
 
         AfficherLog("\n\n\nListe des étoiles brillantes situées à plus de 30° au-dessus de l'horizon :\n\n", true);
+
+        // Mise à jour  du temps sidéral local
 
         UpdateTime();
@@ -1428 +1475 @@
             Etoiles[i].ha = RefractionAtmospherique(Etoiles[i].ha);
 
-            // Sélectionner et afficher les étoiles > 30°
+            // Sélectionne et affiche les étoiles > 30°
+            // et donc la magnitude < MAGNITUDEMAXETOILESCALIBRATION
 
             if ( Etoiles[i].selectionnee = ((Etoiles[i].ha > (HAUTMIN + 5.0) * Pidiv180) && (Etoiles[i].mag < MAGNITUDEMAXETOILESCALIBRATION)) )
@@ -1442 +1490 @@
             if (Etoiles[i].selectionnee)
             {
-                for (int j=1; j<=Antennes[num].AlignementAntenne->nbrcorrections; j++)
+                for (int j=1; j <= Antennes[num].AlignementAntenne->nbrcorrections; j++)
                 {
                     // LÃ , un point important: on ne prend pas en compte l'AD des objets dans le reste des calculs
-                    // Mais l'angle horaire de ces objets avec le méridien en retranchant le temps sidéral local
-                    // à l'ascension droite des objets. Voir les détails dans la documentation....
+                    // Mais l'angle horaire de ces objets avec le méridien. Voir les détails dans la documentation....
 
                     double distances = DistanceAngulaireEntre2Points(
@@ -1454 +1501 @@
                                            Etoiles[i].de);
 
-                    // Ici, on ne selectionne que des étoiles qui ne soont pas trop proches de positions ayant déjà servies à la calibration
+                    // Ici, on ne sélectionne que des étoiles qui ne sont pas trop proches de positions ayant déjà servies à la calibration
                     // de l'antenne et qui multiplierait les mesures sans amélioration de la précision
 
@@ -1473 +1520 @@
                 AfficherLog("(Tapez sur la touche f pour achever l'alignement de l'antenne et enregistrer les paramÚtres.)\n", true);
 
-                // activer le mode raw évite d'avoir à taper sur la touche entrée entre chaque pression
+                // activer le mode raw évite d'avoir à devoir taper sur la touche entrée entre chaque pression
                 // sur le clavier
 
@@ -1501 +1548 @@
                     // On sauvegarde les coordonnées de l'objet qui servira à la calibration de l'antenne num
 
-                    Antennes[num].AlignementAntenne->ad[Antennes[num].AlignementAntenne->nbrcorrections]  = Etoiles[i].ad;
-                    Antennes[num].AlignementAntenne->de[Antennes[num].AlignementAntenne->nbrcorrections]  = Etoiles[i].de;
+                    Antennes[num].AlignementAntenne->ad[Antennes[num].AlignementAntenne->nbrcorrections] = Etoiles[i].ad;
+                    Antennes[num].AlignementAntenne->de[Antennes[num].AlignementAntenne->nbrcorrections] = Etoiles[i].de;
 
                     do
@@ -1568 +1615 @@
                             break;
 
+                            //abort
                         case 'a' :
                             Abort();
@@ -1574 +1622 @@
                             break;
 
+                            // vitesse 1x ou 10x
                         case 's' :
                             (Vitesse == 1 ) ? Vitesse = 10 : Vitesse = 1;
@@ -1581 +1630 @@
                             break;
 
+                            // reprise du goto
                         case 'g' :
                             AfficherLog("Reprise du GOTO.\n\n", true);
@@ -1596 +1646 @@
                 case 'f':
                 {
-                    // on sort de la boucle en cas d'appuie sur la touche f
+                    // on sort de la boucle lorsque l'utilisateur tape sur 'f'
+
                     i = numEtoiles;
                 }
@@ -1606 +1657 @@
         AfficherLog("\nFin de la procédure d'alignement.\n\n", true);
 
-        // On indique au reste du programme que la calibration sur l'antenne num est terminée
+        // On indique au reste du programme que la calibration sur l'antenne num est achevée
 
         Antennes[num].AlignementAntenne->AlignementEnCours = false;
 
-        ModificationAlignement=true;
+        ModificationAlignement = true;
     }
     else
@@ -1625 +1676 @@
 
 /**************************************************************************************
-** Lance l'executution d'un fichier de mouvements
+** Lance l'exécution d'un fichier de mouvements
 **
 ***************************************************************************************/
@@ -1637 +1688 @@
     UpdateTime();
 
-    if ( exec && numobjets>1 )
+    if ( exec && numobjets > 1 )
     {
         // Si le chargement du fichier s'est bien déroulé et qu'il y a plus d'un mouvement dedans
@@ -1644 +1695 @@
         {
             ErreurLog("Le fichier contient des dates qui sont toutes périmées. Exécution annulée.\n\n");
+
             NoExit = !exitrun;
 
@@ -1650 +1702 @@
         else
         {
-            AfficherLog("Execution du fichier " + fichier + " en attente...\n\n", true);
+            AfficherLog("Exécution du fichier " + fichier + " en attente...\n\n", true);
             run = true;
         }
@@ -1657 +1709 @@
     {
         ErreurLog("\nLe fichier " + fichier + " contient des erreurs ou n'existe pas...\n\n\n");
+
         NoExit=!exitrun;
 
@@ -1670 +1723 @@
 ** Décomposition et vérification des dates, heures, AD et déclinaisons
 **
-** type = 0 -> chaine contient une déclinaison ou une latitude
-** type = 1 -> longitude
-** type = 2 -> AD ou heure
-** type = 3 -> date
+** type = 0 -> chaîne contient une déclinaison ou une latitude
+** type = 1 -> "        "      une longitude
+** type = 2 -> "        "      une AD ou une heure
+** type = 3 -> "        "      une date
 **
 ** Exemple de Décomposition("15:23:12", 2, a, b, c) retourne a=15, b=23, c=12
-** si la chaine a un format incorrect, la fct retourne false
+** si la chaîne a un format incorrect, la fct retourne false
 **
 ***************************************************************************************/
@@ -1691 +1744 @@
     (type == 3) ? car="/" : car=":";
 
-    // Y a-t-il 2 caractÚres ':' ou '/' dans la chaine ?
+    // Y a-t-il 2 caractÚres ':' ou '/' dans la chaîne ?
     // C'est indispensable dans tous les cas
 
@@ -1716 +1769 @@
     c = Arrondi(atof(s.c_str()) * 100.0) / 100.0;
 
-    //vérification de la cohérence des infos contenues dans la chaine
+    //vérification de la cohérence des infos contenues dans la chaîne
 
     if (type < 3 )
@@ -1752 +1805 @@
 ** identification des commandes entrées par l'utilisateur
 ** puis exécution des commandes
+** Chaine peut contenir par ex "goto betelgeuse", "goto 12:23:01 +22:53:00", "status" etc...
 **
 ***************************************************************************************/
@@ -1842 +1896 @@
             {
                 ErreurLog("Erreur goto : le format de la commande est goto AD DEC\n \
-                    L'AD doit être de la forme xx:yy:zz   (ex: 12:00:03 pour 12h 0m 3s)\n \
-                    La déclinaison doit être de la forme +/-xx:yy:zz (ex: -12:50:01.1 pour -12° 50' 01.1'')\n\n \
-                    Il est egalement possible de faire suivre la commande d'un nom d'un objet\n \
-                    Exemple goto M 31 ou encore goto ngc145.\n \
-                    Ne pas préciser dans ce cas J2000.\n\n");
+                 L'AD doit être de la forme xx:yy:zz  J2000 (ex: 12:00:03 pour 12h 0m 3s)\n \
+                 La déclinaison doit être de la forme +/-xx:yy:zz (ex: -12:50:01.1 pour -12° 50' 01.1'')\n \
+                 J2000 est un paramÚtre optionnel qui sert à indiquer que les coordonnées horaires\n \
+                 sont exprimées dans le repÚre du même nom.\n\n \
+                 Il est egalement possible de faire suivre la commande d'un nom d'un objet\n \
+                 Exemple goto M 31 ou encore goto ngc145.\n \
+                 Ne pas préciser dans ce cas J2000.\n\n");
             }
         }
@@ -2047 +2103 @@
 
                 Antennes[num].AlignementAntenne->InitAlignement();
+                
+                Antennes[num].AlignementAntenne->MethodeAlignement = MethodeAlignement;
 
                 ModificationAlignement = true;
@@ -2280 +2338 @@
     int rc;
 
-    //initialsation des variables de retour
+    //initialisation des variables de retour
 
     reponse.ar = "";
@@ -2426 +2484 @@
 ** Lecture d'un fichier ligne aprÚs ligne
 ** retourne -1 Ã  la fin
+**
 ***************************************************************************************/
 
@@ -2480 +2539 @@
 
     /////////////////////////////////////////
-    // Rubrique Coodonnées géographiques
+    // Rubrique Coordonnées géographiques
 
     section = "coordonnees geographiques";
@@ -2538 +2597 @@
     }
 
+    /////////////////////////////////////////
+    // Port de connexion du serveur Indi
 
     key = "port";
@@ -2593 +2654 @@
     }
 
+    /////////////////////////////////////////
+    // Rubrique alignement
+
+    section = "alignement";
+
+    key = "methode_alignement";
+
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        AfficherLog("methode d'alignement = " + (string)value + "\n", true);
+        switch (value[0])
+        {
+        case 's' :
+        case 'S' :
+            MethodeAlignement = SIMPLE;
+            break;
+
+        case 'a' :
+        case 'A' :
+            MethodeAlignement = AFFINE;
+            break;
+
+        case 't' :
+        case 'T' :
+            MethodeAlignement = TAKI;
+            break;
+        }
+
+        SAFEDELETE_TAB(value);
+    }
+    else
+    {
+        ErreurLog("Le paramÚtre methode_alignement est incorrect !\n");
+
+        return false;
+    }
+
+
 
     /////////////////////////////////////////
@@ -2609 +2708 @@
     else
     {
-        ErreurLog("Le paramÚtre mode est incorrect !\n");
+        ErreurLog("Le paramÚtre mode suivi est incorrect !\n");
 
         return false;
@@ -2969 +3068 @@
             SAFEDELETE_TAB(value);
 
-            Etoiles[numEtoiles].ad = (a1 + a2/60.0 + a3/3600.0) * 15.0 * Pidiv180;
+            Etoiles[numEtoiles].ad = (a1 + a2 / 60.0 + a3 / 3600.0) * 15.0 * Pidiv180;
         }
         else
@@ -2984 +3083 @@
                 && (Decomposition(value, 0, &a1, &a2, &a3)))
         {
-            Etoiles[numEtoiles].de = (fabs(a1) + a2/60.0 + a3/3600.0 ) * Pidiv180;
-
-            if (value[0] == '-')  Etoiles[numEtoiles].de = -Etoiles[numEtoiles].de;
+            Etoiles[numEtoiles].de = (fabs(a1) + a2 / 60.0 + a3 / 3600.0 ) * Pidiv180;
+
+            if (value[0] == '-')  Etoiles[numEtoiles].de = - Etoiles[numEtoiles].de;
 
             SAFEDELETE_TAB(value);
@@ -3005 +3104 @@
         if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
         {
-            Etoiles[numEtoiles].mag=(double)atof(value);
+            Etoiles[numEtoiles].mag = atof(value);
             SAFEDELETE_TAB(value);
         }
@@ -3019 +3118 @@
         // Passage du repÚre J2000 à l'écliptique et à l'équinoxe liée à la date de l'observation
 
-        Precession(&Etoiles[numEtoiles].ad, &Etoiles[numEtoiles].de);
-        NutationEtoile(&Etoiles[numEtoiles].ad, &Etoiles[numEtoiles].de);
+        Precession        (&Etoiles[numEtoiles].ad, &Etoiles[numEtoiles].de);
+        NutationEtoile    (&Etoiles[numEtoiles].ad, &Etoiles[numEtoiles].de);
         AberrationAnnuelle(&Etoiles[numEtoiles].ad, &Etoiles[numEtoiles].de);
 
@@ -3093 +3192 @@
 
     // si on a utilisé l'option -r en ligne de commande
-    // alors on charge et on execute le fichier de mouvements
+    // alors on charge et on exécute le fichier de mouvements
 
     if (argc == 3)
@@ -3158 +3257 @@
 
     // sauvegarder la position courante
+
     long pos = fichier.tellg();
+
     // se placer en fin de fichier
+
     fichier.seekg( 0 , ios_base::end );
+
     // récupérer la nouvelle position = la taille du fichier
+
     long size = fichier.tellg();
+
     return (size > 0);
 }

BAORadio/libindi/libindi/BAOControl/baocontrol.h

@@ -41 +41 @@
     double ha;                          // hauteur au-dessus de l'horizon (en rad)
     double mag;                         // magnitude
-    bool   selectionnee;                // l'objet a-t-il été sélectionné pour calibrer l'antenne 
-                                        // actuellement en mode alignement ?
+    bool   selectionnee;                // l'objet a-t-il été sélectionné pour calibrer l'antenne ?
 };
 
@@ -91 +90 @@
     void *my_thread_process ();
     
-    // intialise la clase
+    // initialise la classe
     
     int init(int argc, char **argv);
@@ -106 +105 @@
 
 
-    //communications entre les antennes et le microcontrÃŽleur
+    //communications entre les antennes et le micro-contrÃŽleur
 
     void LireReponse();
@@ -135 +134 @@
     
 
-    //Gestion serveur NED
+    // Gestion du serveur NED
     
     CoordonneesHoraires ServeurNED(string objet);
@@ -166 +165 @@
     
 
-    double Pression;                            // Pression atmosphérique en mBar
+    double Pression;                            // Pression atmosphérique en mbar
     double Temperature;                         // température de l'atmosphÚre en °C
 
     bool NoExit;                                // A-t-on tapé exit pour sortir ? Permet de fermer le thread à ce moment-là 
     bool Transit;                               // Si oui, le mode transit est activé, sinon, c'est le mode tracking
-    bool run;                                   // execute actuellement un fichier de mouvements
-    bool exitrun;                               // doit-on sortir du programme à la fin de l'execution de la commande run ?
+    bool run;                                   // exécute actuellement un fichier de mouvements
+    bool exitrun;                               // doit-on sortir du programme à la fin de l'exécution de la commande run ?
     bool J2000;                                 // est-ce que les coordonnées du fichier de mouvements sont en coordonnées J2000 ?
     bool ModificationAlignement;                // Est-ce que l'une des antennes est en cours d'alignement et est-ce qu'un paramÚtre 

BAORadio/libindi/libindi/BAOControl/baocontrol_params

@@ -11 +11 @@
 temperature=10
 
+[alignement]
+methode_alignement=SIMPLE
+
 [suivi]
 mode=tracking

BAORadio/libindi/libindi/communs/alignement.cpp

@@ -19 +19 @@
 {
     //Initialisation des paramÚtres des antennes
-    
+
     InitAlignement();
 }
@@ -88 +88 @@
 void Alignement::TransmettreParametresClasseAstro(double Annee, double Mois, double Jour, double Heu, double Min, double Sec, double Longitude, double Latitude, double Pression, double Temp)
 {
-    DefinirLongitudeLatitude(Longitude, Latitude); 
+    DefinirLongitudeLatitude(Longitude, Latitude);
     DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
-    DefinirPressionTemp(Pression, Temp);   
+    DefinirPressionTemp(Pression, Temp);
 }
 
@@ -118 +118 @@
 
 /**************************************************************************************
-**  Calcule la matrice de rotation d'un angle alpha autour d'un axe défini 
+**  Calcule la matrice de rotation d'un angle alpha autour d'un axe défini
 **  par les paramÚtres t et r dans un systÚme de coordonnées spĥériques
 **  Le signe - devant le cos permet seulement de rendre le repÚre compatible avec WinStars
 ** que j'utilise pour faire des vérifications...
 ** Fonction utile pour de débogage de la fct d'alignement
-**  
+**
 ***************************************************************************************/
 
@@ -397 +397 @@
 
     // Pour chaque variable coordonnées, on calcule d'abord l'azimut et la hauteur de l'objet correspondant
-    
+
     Azimut(a1.x, a1.y, &aa1.x, &aa1.y);
 
@@ -509 +509 @@
         MATRICE[3][3] = mm33;
 
-        //Pour vérifs
+        //Pour vérifs
         //RotationAutourDunAxe(0.3,Pi/2.0-0.1, 0.2);
-       
-        return 1;
+
+        return 1;
     }
     else
@@ -602 +602 @@
     int best2 = 0;
     int best3 = 0;
-    
-    
+
+
     // On calcule le temps sidéral local, etc...
-    
+
     CalculTSL();
 
@@ -738 +738 @@
         os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3]  << "\n" ;
 
-        c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
-        c1.y = de[map[best1]];
-        c1.z = 1.0;
-
-        c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
-        c2.y = de[map[best2]];
-        c2.z = 1.0;
-
-        c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
-        c3.y = de[map[best3]];
-        c3.z = 1.0;
+        if (MethodeAlignement == SIMPLE)
+        {
+            c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
+            c1.y = de[map[best1]];
+            c1.z = 1.0;
+
+            c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
+            c2.y = de[map[best2]];
+            c2.z = 1.0;
+
+            c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
+            c3.y = de[map[best3]];
+            c3.z = 1.0;
+        }
+        else
+        {
+            c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]]);
+            c1.y = de[map[best1]];
+            c1.z = 1.0;
+
+            c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]]);
+            c2.y = de[map[best2]];
+            c2.z = 1.0;
+
+            c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]]);
+            c3.y = de[map[best3]];
+            c3.z = 1.0;
+        }
+
 
         os << "Point 1 :  ho=" << DHMS(c1.x * N180divPi, false);
@@ -797 +815 @@
     os << MATRICE[1][3] << "   \t" << MATRICE[2][3] << "    \t" << MATRICE[3][3] << "\n";
 
-    
-    
-    
-
-    
+
+
+
+
+
     //Vérifications supp
     /*
@@ -811 +829 @@
     os << GetHeure() << ":" << GetMin() << ":" << GetSec() << "\n";
     os << DHMS(GetTSL()*N180divPi, true) << "\n\n";
-    
+
       Azimut(c3.x, c3.y, &mm1.x, &mm1.y);
 
@@ -848 +866 @@
     */
 
-    
-    
+
+
     //Afficher les messages de cette fonction
 
@@ -1018 +1036 @@
     os2.str("");
 
+    /*  char chaine[100];
+    sprintf(chaine, "************** %s\n",alignment_method_data);
+      cout << chaine;*/
+
     if (alignment_method_data)
     {
@@ -1038 +1060 @@
     {
         // Si la procédure d'alignement se termine, il faut calculer la matrice de correction
-        
+
         if (AlignementEnCours != atoi(align_data))
         {
@@ -1103 +1125 @@
     stringstream os;
 
-    
+
     //AfficherLog("Enregistrement de l'alignement des antennes dans le fichier " + fileName + "\n", true);
 
@@ -1111 +1133 @@
     section = os.str();
     os.str("");
-    
+
     os << "delta_az_polar";
     key     = os.str();
@@ -1137 +1159 @@
     os.str("");
 
+
     writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+    /*    char chaine[100];
+    sprintf(chaine, "s************** %i\n",MethodeAlignement);
+       cout << chaine;*/
 
 

BAORadio/libindi/libindi/communs/const.h

@@ -119 +119 @@
 /////////////////////////////////////////////
 
+// Port utilisé sur le réseau tcp/ip pour communiquer avec les antennes
+
+#define BAO_PORT 8000
+
+// Délai maximum en ms d'attente de la réponse des micro-contrÎleurs
+
+#define MAX_DELAI_REPONSE 40
+
 // Si une commande ne recoit pas d'acknowledge. Alors refaire 80 tentatives en renvoyant la commande
 

BAORadio/libindi/libindi/drivers/telescope/BAO.cpp

@@ -43 +43 @@
     init_properties();
 
-    // Le bouton connect de la boîte de dialogue d'indi8BAO
+    // Le bouton connect de la boîte de dialogue d'indi_BAO
     // est dans l'état IDLE au démarrage
 
@@ -52 +52 @@
     lastRA                = 0.0;
     lastDEC               = 0.0;
+    
+    // Jour julien de la derniÚre actualisation
+    
     JJAnc                 = 0.0;
 
     // Variables d'état
 
-    currentSet            =  0;         // Variables internes d'Indi, ne pas toucher
-    lastSet               = -1;         // Variable interne d'Indi, ne pas toucher
+    currentSet            =  0; 
 
     // Nombre d'antennes connectées
@@ -65 +67 @@
     // Le mode tracking est activé par défaut
 
-    TrackingMode          =  1;
+    TrackingMode          =  BAO_TRACKING;
+    
+    // Méthode d'alignement par défaut
+    
+    MethodeAlignement     = SIMPLE;
 
     // délais en sec entre deux actualisations
     // dans les modes transit et tracking
 
-    ActualisationTMTransit  = 15.0 * 60.0;    // Délai entre 2 actualisations dans le mode transit
+    ActualisationTMTransit  = 15.0 * 60.0;    // Délai entre 2 actualisations dans le mode transit (en sec)
+    
     ActualisationTMTracking = 5.0;            //                "                 "        tracking
 
@@ -86 +93 @@
     RealisationGoto       = false;
 
-    // vaut true si l'utilisateur demande l'annulation du mouvement en cours
+    // = true si l'utilisateur demande l'annulation du mouvement en cours
 
     Abort                 = false;
 
-    // vaut true si l'utilisateur demande de mettre les antennes en mode park
+    // = true si l'utilisateur demande de mettre les antennes en mode park
 
     Park                  = false;
 
-    // vaut true un objet est actuellement suivi par les antennes
+    // = true si un objet est actuellement suivi par les antennes
 
     Suivi                 = false;
 
-    // vaut true si l'utilisateur demande à sortir de l'application -> permet de fermer le thread
+    // = true si l'utilisateur sort de l'application -> permet de fermer le thread
 
     Exit                  = false;
+    
+    // Initialisation des paramÚtres atmosphériques par défaut
     
     Pression              = 1013.0;
@@ -141 +150 @@
 BAO::~BAO()
 {
-    //On informe le thread que nous allons sortir
+    // On informe le thread que nous allons sortir
 
     Exit = true;
@@ -161 +170 @@
 
     // Petit message à l'attention de l'utilisateur
-    // permet de savoir si le destructeur est bien atteint
+    // permet de savoir si le destructeur a bien été atteint
 
     IDLog("Sortie de indi_BAO\n");
@@ -257 +266 @@
 
 /**************************************************************************************
-** Initialisation de la boîte de dialogue INDI (suite)
-** Vider tous les vecteurs
+** Définition de tous les vecteurs de la boîte de dialogue INDI 
+** Cette procédure doit être obligatoirement présente dans tous pilotes Indi
 **
 ***************************************************************************************/
@@ -271 +280 @@
     IDDefSwitch(&ConnectSP, NULL);
     IDDefText(&ObjectTP, NULL);
-    IDDefNumber(&EquatorialCoordsWNP, NULL);
-    IDDefNumber(&GeographicCoordsWNP, NULL);
-    IDDefNumber(&PressionTempWNP, NULL);
+    IDDefNumber(&EquatorialCoordsWNP, NULL);      
     IDDefSwitch(&OnCoordSetSP, NULL);
     IDDefSwitch(&AlignmentSP, NULL);
@@ -282 +289 @@
     IDDefNumber(&ActualisationNP1, NULL);
     IDDefNumber(&ActualisationNP2, NULL);
-}
-
-
-/**************************************************************************************
-** Initialisation des vecteurs INDI
-** ParamÚtres par défaut
+    IDDefNumber(&PressionTempWNP, NULL);
+    IDDefNumber(&GeographicCoordsWNP, NULL);  
+}
+
+
+/**************************************************************************************
+** Initialisation des vecteurs de la boîte Indi
+** Cette procédure doit être obligatoirement présente dans tous pilotes Indi
 **
 ***************************************************************************************/
@@ -333 +342 @@
 ** En cas de changement de texte dans la boîte de dialogue (par exemple : changement du
 ** nom de l'objet) alors suivre l'objet...
-** Cette fonction n'est pas encore utilisée
-** TODO: faut-il pouvoir modifier le nom de l'objet depuis la boîte ?
-** pas sûr que cela soit utile: kstars et BAOcontrol permettent de faire cela
+** Cette fonction n'est pas utilisée
+** TODO: faut-il proposer cette fonction depuis la boîte alors qu'il est déjà 
+** possible de le faire depuis  Kstars et BAOcontrol ?
+**
 **
 ***************************************************************************************/
@@ -372 +382 @@
 ** Exemple : longitude, latitude, ar, dec etc...) -> prendre en compte les modifications
 **
+** const char *dev  contient le nom du dispositif recevant le message (ici indi_BAO)
+** const char *name reçoit  le nom de la rubrique modifiée par l'utilisateur 
+** (ex : les coordonnées géographiques, les coordonnées horaires de l'objet etc...)
+** double names[] contient la liste de tous les champs modifiables dans chaque rubrique
+** (ex : longitude et latitude dans la rubrique coordonnées géographiques
+** char *values[] contient toutes les valeurs (numériques ou non) mais toujours exprimées 
+** sous la forme d'une chaîne de caractÚres
+**
 ***************************************************************************************/
 
@@ -400 +418 @@
     if (!strcmp (name, GeographicCoordsWNP.name))
     {
-        // l'utilisateur a modifié un les coordonnées géographiques de la boite indi
+        // l'utilisateur a modifié une des coordonnées géographiques de la boite indi
 
         int i = 0, nset = 0;
 
         // En cas d'erreur, on doit pouvoir sortir avec des paramÚtres par défaut
-        //ici la latitude et la longitude vondront 0.0
+        // ici la latitude et la longitude valent 0.0
 
         Latitude  = 0.0;
@@ -412 +430 @@
         // pour ce vecteur, on sait qu'il y a n éléments possibles
         // Exemple pour la rubrique coordonnées géographique de la boîte indi
-        // il y a deux éléments : la longtude et la latitude
-        // pour la rubrique alignement, il y aen a trois par exemple :
-        // simple, affine et taki
+        // il y a deux éléments : la longitude et la latitude
+        // pour la rubrique alignement, il y a en a trois : simple, affine et taki
 
         for (i = 0; i < n; i++)
@@ -425 +442 @@
             if (eqp == &GeographicCoordsWN[0])
             {
-                //ici on a identifié la zone latitude de la boîte de dialogue
-                // Value[i] contient la chaine de caractÚre correspondante dans la boîte
+                // ici on a identifié la zone latitude de la boîte de dialogue
+                // Value[i] contient la chaîne de caractÚre correspondante dans la boîte
                 // C'est la valeur saisie par l'utilisateur
 
@@ -459 +476 @@
         if (nset == 2)
         {
-            //Vérification
-            //IDLog("Geographic : RA %5.2f - DEC %5.2f\n", Latitude, Longitude);
-
-            //nset vaut 2, on sommes donc sûrs qu'il n'y a pas de problÚme dans les valeurs
+            // Vérification
+            // IDLog("Geographic : RA %5.2f - DEC %5.2f\n", Latitude, Longitude);
+
+            // nset vaut 2, nous sommes donc sûrs qu'il n'y a pas de problÚme dans les valeurs
             // saisies par l'utilisateur
             // voir le code plus haut pour comprendre...
 
-            // On change la couleur de la "diode" de la rubrique coordonnées géographiques de la boîte
-            // en vert
+            // On change la couleur de la "diode" de la rubrique coordonnées 
+            // géographiques de la boîte en vert
 
             GeographicCoordsWNP.s = IPS_OK;
@@ -478 +495 @@
         {
             // quelque chose cloche
-            // peut-être l'une des veleurs saisies par l'utilisateur n'est-elle pas dans
+            // peut-être l'une des valeurs saisies par l'utilisateur n'est-elle pas dans
             // le bon intervalle ? ex : lat = 150°
 
@@ -496 +513 @@
 
         // c'est bon. On peut donc transmettre les nouvelles valeurs à la classe astro
-        // qui utilisera ces informations pur calculer l'azimut des objets et le tsl en particulier...
+        // qui utilisera ces informations pur calculer l'azimut des objets et le temps sidéral local en particulier...
 
         DefinirLongitudeLatitude(Longitude, Latitude);
@@ -533 +550 @@
             else if (eqp == &EquatorialCoordsWN[1])
             {
-                //même chose pour la déclinaison
+                // même chose pour la déclinaison
                 newDEC = values[i];
 
@@ -553 +570 @@
             targetDEC = newDEC;
 
-            // on les affiches dans les logs
+            // on les affiche dans les logs
 
             fs_sexa(RAStr, newRA, 2, 3600);
@@ -602 +619 @@
             if (eqp == &PressionTempWN[0])
             {
-                // on a compris que l'utilisateur avait changé l'ascension droite de l'objet
+                // on a compris que l'utilisateur a changé l'ascension droite de l'objet
 
                 // on affecte la nouvelle valeur à newRA
@@ -649 +666 @@
     if (!strcmp (name, ActualisationNP1.name))
     {
-        // on a ici exactement le même fonctionnement que précédement
-        // on régle ici les valeurs des delais entre deux actualisations
+        // on a ici exactement le même fonctionnement que précédemment
+        // on rÚgle ici les valeurs des délais entre deux actualisations
         // de la position en mode transit et tracking
-        // retourne un message d'erreur si les durées ne sont pas exprimées
-        // dans un intervalle > 0.0 et < 3600
+        // Retourne un message d'erreur si les durées ne sont pas exprimées
+        // dans un intervalle > 0 et < 3600
 
         double newAct1 = 1.0;
@@ -717 +734 @@
 /**************************************************************************************
 ** L'utilisateur clique sur l'un des boutons de la boîte Indi
-**
+** Même observation que pour la procédure précédente
+** 
 ***************************************************************************************/
 
@@ -767 +785 @@
             return;
 
-        currentSet = get_switch_index(&AlignmentSP);
-        AlignmentSP.s = IPS_OK;
+        MethodeAlignement = get_switch_index(&AlignmentSP) + 1 ;
+        
+        /*char chaine[100];     
+        sprintf(chaine, "****************************************** %i\n", MethodeAlignement);
+        IDLog(chaine);*/
+        
+        AlignmentSP.s = IPS_OK;
         IDSetSwitch(&AlignmentSP, NULL);
 
-        for (int i=0; i<MAXALIGNEMENTANTENNE; i++)
-        {
-            switch (currentSet)
+        for (int i=0; i<MAXHOSTNAME; i++)
+        {
+            switch (MethodeAlignement)
             {
             case 1 :
@@ -846 +869 @@
 ** l'utilisation d'un thread permet de contourner le problÚme de la fonction accept
 ** qui est bloquante.
+** L'adresse IP de l'antenne qui a effectué la connexion est consignée dans la variable IP
+** de la structure Sockets. L'état de l'antenne (connected) est placée à true
 **
 ***************************************************************************************/
@@ -858 +883 @@
 
             Sockets[SocketsNumber].IP = server.recupip(Sockets[SocketsNumber].new_sock);
-
-            Sockets[SocketsNumber++].Connected = true;
+            
+            Sockets[SocketsNumber].AlignementAntenne->MethodeAlignement = MethodeAlignement;
+
+            Sockets[SocketsNumber++].Connected = true;      
 
             InitThreadOK = true;
@@ -894 +921 @@
 /**************************************************************************************
 ** Extraction de la position de l'antenne aprÚs l'envoi de la commande P
-** Le retour de la commande P est POSITION/valeur_az/valeur_alt/
-** ExtractPosition retourne donc Valeur_az et Valeur_alt
+** Le retour de la commande P est POSITION/valeur_az/valeur_alt/ 
+** Ce retour est envoyé dans la chaîne str
+** ExtractPosition retourne une structure Position contenant Valeur_az et Valeur_alt
+** Ex: ExtractPosition("POSITION/0100/0001/", result)  retourne result.x=100 et result.y=1
 **
 ***************************************************************************************/
@@ -929 +958 @@
 
 /************************************************************************************
-** Cette procédure, aprÚs avoir appliqué la matrice de rotation aux coordonnées
-** visées par l'utilisateur, convertit les coordonnées équatoriales de l'objet visé
-** en unités de codeurs des paraboles
+** Cette procédure, aprÚs avoir appliqué la matrice de rotation aux coordonnées de l'objet
+** visées par l'utilisateur, effectue les conversions en unités codeurs des paraboles
 ** (cà d en nb de tours des deux axes moteurs depuis la position PARK)
 **
@@ -954 +982 @@
         if (Sockets[i].Connected)
         {
-            newRA = newRA2;
+            newRA  = newRA2;
             newDEC = newDEC2;
           
@@ -960 +988 @@
             // sur les coordonnées horaires de l'objet visé
 
-            // il faut vérifier auparavent que la matrice de rotation est disponible
+            // il faut vérifier auparavant que la matrice de rotation est disponible
             // pour l'antenne i
 
             if  (Sockets[i].AlignementAntenne->Matrice_ok)
             {
-                // On est bien dans le cas de l'allignement AFFINE ou Taki
+                // On est bien dans le cas de l'alignement AFFINE ou Taki
 
                 if (Sockets[i].AlignementAntenne->MethodeAlignement ==  AFFINE ||
-                        Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI)
+                    Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI)
                 {
                     // On crée un vecteur avec pour coordonnées
                     // x = Angle horaire de l'objet visé
-                    // y = déclainaison de l'objet
+                    // y = déclinaison de l'objet
                     // z = 1.0
                     // Voir la documentation pour plus d'explications sur le calcul affine/taki
@@ -999 +1027 @@
                     // On récupÚre les nouvelles coordonnées. z ne nous intéresse pas
 
-                    newRA  = VerifAngle(result.x+GetTSL());
+                    newRA  = VerifAngle(result.x + GetTSL());
                     newDEC = result.y;
 
@@ -1023 +1051 @@
                 }
             }
-                   IDLog("Nouvelles Coordonnées AD =%s  Dec = %s\n", DHMS(newRA*N180divPi, true).c_str(), DHMS(newDEC*N180divPi, false).c_str());                
-
-
+    
             // Calcule la hauteur et l'azimut de la zone du ciel pointée (en fonction de la date et du lieu d'observation)
 
@@ -1042 +1068 @@
 
                 // On constitue un vecteur vect
-                // Les coordonnées du vecteur correspondont à la position
-                // d'un point sur une sphÚre de rayon 1
-                // avec une latitude = targetAlt et une longitude=targetAz
-                // on reconnait bien les formules de passage des coordonnées
+                // Les coordonnées du vecteur correspondent à la position
+                // d'un point défini par une latitude targetAlt et une longitude targetAz
+                // sur une sphÚre de rayon 1.
+                // On reconnaît les formules de passage des coordonnées
                 // sphériques aux coordonnées rectangulaires
-                
                 
 
@@ -1067 +1092 @@
                     targetAz = atan( result.y / result.x );
                     
-                    if (result.x < 0) targetAz+=Pi;
+                    if (result.x < 0) targetAz += Pi;
                 }
                 else targetAz = Pidiv2;
@@ -1107 +1132 @@
 
 
-            //Conversion des deux angles en pas codeurs
+            // Conversion des deux angles en pas codeurs
 
             if ( targetAlt < HAUTMIN )
@@ -1140 +1165 @@
                 //4000 pas pour 360° sur l'axe az
 
-                Sockets[i].TargetPosition.x = (int) Arrondi( targetAz * 4000.0 / 360.0);
+                Sockets[i].TargetPosition.x = (int) Arrondi( targetAz * (double)NBREPASCODEURSAZ / 360.0);
                 
                 // Message de debug
 
-                IDLog("Nbre de pas codeurs Az = %i        Alt = %i\n", Sockets[i].TargetPosition.x, Sockets[i].TargetPosition.y);
+                IDLog("Nbre de pas codeurs Az = %i  Alt = %i\n", Sockets[i].TargetPosition.x, Sockets[i].TargetPosition.y);
             }
         }
@@ -1153 +1178 @@
 
 /************************************************************************************
-* Retourne le nombre d'antennes actuellement connectées
-*
+** Retourne le nombre d'antennes actuellement connectées
+**
 ************************************************************************************/
 
@@ -1187 +1212 @@
 ** Procédure principale
 ** Elle est appelée toutes les ms
+**
 ***************************************************************************************/
 
@@ -1199 +1225 @@
     struct timezone tz;
 
-    //si pas de connexion avec le seveur d'indi -> on sort
+    //si pas de connexion avec le serveur d'indi -> on sort
 
     if (!is_connected()) return;
@@ -1227 +1253 @@
         DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
 
-        //Puis on calule le temps sidéral local, le JJ etc.
+        // Puis on calcule le temps sidéral local, le JJ etc.
 
         CalculTSL();
@@ -1243 +1269 @@
                     Sockets[i].AlignementAntenne->TransmettreParametresClasseAstro(Annee, Mois, Jour, Heu, Min, Sec, Longitude, Latitude, Pression, Temp);         
                     
-                    Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
+                    if (Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE )
+                    {
+                      //IDLog("chargement simple\n");
+                      Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesSIMPLE.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
+                    }
+                    else
+                       {
+                        // IDLog("chargement taki\n");
+                      Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesTAKI.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
+                    }
                 }
             }
@@ -1268 +1303 @@
 
         /////////////////////////////////////////////////
-        // Début des échanges avec les microcontrÎleurs
-
-        // Analyse des réponses des microcontrÎleurs
+        // Début des échanges avec les micro-contrÎleurs
+
+        // Analyse des réponses des micro-contrÎleurs
 
         for (int i=1; i<SocketsNumber; i++)
@@ -1280 +1315 @@
                     string reponse, buffereponse;
 
-                    // on récupÚre la réponse du microcontrÎleur
+                    // on récupÚre la réponse du micro-contrÎleur
 
                     Sockets[i].new_sock >> reponse;
@@ -1336 +1371 @@
                             if (reponse.find("POSITION") != string::npos)
                             {
-                                // Il y a une erreur signalée par le microcontroleur
+                                // Il y a une erreur signalée par le micro-contrÎleur
 
                                 if (reponse.find("NACK") != string::npos)
@@ -1364 +1399 @@
                                     {
                                         // La fonction extractPositon confirme que les positions transmises
-                                        // par le microcontrÃŽleur sont valides
+                                        // par le micro-contrÃŽleur sont valides
 
                                         OnCoordSetSP.s = IPS_OK;
@@ -1393 +1428 @@
                                 if (reponse.find("NACK") != string::npos)
                                 {
-                                    // Une erreur  est retournée par le microcontroleur concernant la commande Park
+                                    // Une erreur  est retournée par le micro-contrÎleur concernant la commande Park
                                     // On affiche le voyant Park en rouge dans la boîte indi...
 
@@ -1418 +1453 @@
                                 if (reponse.find("NACK") != string::npos)
                                 {
-                                    // Une erreur  est retournée par le microcontroleur concernant la commande Abort
+                                    // Une erreur  est retournée par le micro-contrÎleur concernant la commande Abort
                                     // On affiche le voyant Park en rouge dans la boîte indi...
 
@@ -1443 +1478 @@
                                 if (reponse.find("NACK") != string::npos)
                                 {
-                                    // Une erreur  est retournée par le microcontroleur concernant la commande Goto
+                                    // Une erreur  est retournée par le micro-contrÎleur concernant la commande Goto
                                     // On affiche le voyant Park en rouge dans la boîte indi...
 
@@ -1452 +1487 @@
                                     IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : Erreur GOTO !\n",  Sockets[i].IP.c_str());
 
-                                    // On déconnecte l'antenne. Elle ne semble pas en mesure d'executer les ordres goto
+                                    // On déconnecte l'antenne. Elle ne semble pas en mesure d'exécuter les ordres goto
 
                                     DeconnecterSocket(i);
@@ -1460 +1495 @@
                                     if (reponse.find("OK") != string::npos)
                                     {
-                                        // On a ici la confirmation que l'antenne 'i' a bien réalisé
-                                        // le goto
+                                        // On a ici la confirmation que l'antenne 'i' a bien réalisé le goto
 
                                         // On prend note
@@ -1488 +1522 @@
                                         }
 
-                                        // Si le nombre d'antennes connectées est >0
+                                        // Si le nombre d'antennes connectées est > 0
                                         // et que toutes les antennes connectées ont
                                         // réalisé le goto alors...
@@ -1495 +1529 @@
                                         {
                                             // C'est bon ! Tout marche bien...
-                                            // On actualise l'AR et la dec dans la boîte de dialogue
+                                            // On actualise l'AD et la Dec dans la boîte de dialogue
 
                                             lastRA  = targetRA;
@@ -1559 +1593 @@
             Suivi = false;
 
-            // On arrête l'enchaînement des actions
-            // pour réaliser un goto
+            // On arrête l'enchaînement des actions nécessaires à la réalisation d'un goto
 
             RealisationGoto = false;
@@ -1617 +1650 @@
             InitAntennes();
 
-            //Pour permettre de refaire un park
+            // Pour permettre de refaire un park
 
             Park = false;
@@ -1629 +1662 @@
         {
             // Délais entre deux actualisations
-
-            double delai = ActualisationTMTransit / 3600.0 / 24.0;   // Actualisation toutes les 15 minutes en mode transit (par défaut)
-
-            if (TrackingMode == 2) delai = ActualisationTMTracking / 3600.0 / 24.0;   //et 5 secs en mode tracking (par défaut)
-
-
-            // On actualise la position si le delai est dépassé
+            
+            // Actualisation toutes les 15 minutes en mode transit (par défaut)
+
+            double delai = ActualisationTMTransit / 3600.0 / 24.0;   
+            
+            // et 5 secs en mode tracking (par défaut)
+
+            if (TrackingMode == BAO_TRACKING) delai = ActualisationTMTracking / 3600.0 / 24.0;   
+
+
+            // On actualise la position si le délai est dépassé
 
             if (GetJJ() - JJAnc > delai)
             {
-                // Cette variable vaudra true lorsque le goto aura été réalisé
+                // Cette variable vaut true lorsque le goto a été réalisé
 
                 UpdatedGoto = false;
@@ -1706 +1743 @@
                     case 0 :
                     {
-                        // On doit intialiser l'acknowledge à false
+                        // On doit initialiser l'acknowledge à false
 
                         Sockets[i].ack_pos    = false;
@@ -1765 +1802 @@
 
                             // Les erreurs graves s'accumulent. Pas de réponse aprÚs plusieurs minutes
-                            // Il faut déconnecter l'antenne
+                            // -> Il faut déconnecter l'antenne
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
                             {
@@ -1772 +1809 @@
                                 OnCoordSetSP.s = IPS_ALERT;
 
-                                //Message à l'attentnio de l'utilisateur
+                                //Message à l'attention de l'utilisateur
+                                
                                 IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : pas d acknowledge recu apres l ordre POSITION. \
 Deconnexion de l antenne.", Sockets[i].IP.c_str());
 
                                 // On déconnecte l'antenne
+                                
                                 DeconnecterSocket(i);
                             }
@@ -1792 +1831 @@
                             // Tout vas bien
                             // On ne consigne aucune anomalie
+                            
                             Sockets[i].AttenteExecution = 0;
                             Sockets[i].AnomaliesExecution = 0;
 
                             //On passe à l'étape suivante
+                            
                             Sockets[i].etape++;
                         }
@@ -1812 +1853 @@
 
                                 // On consigne une erreur grave. L'antenne tarde à répondre
+                                
                                 Sockets[i].AnomaliesExecution++;
                             }
@@ -1817 +1859 @@
                             // Aucune réponse de l'antenne depuis plusieurs minutes
                             // On la déconnecte
+                            
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
                             {
@@ -1824 +1867 @@
 
                                 //Message d'erreur
+                                
                                 IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : la position retournee n est pas valide. \
 Deconnexion de l antenne.", Sockets[i].IP.c_str());
 
                                 //Déconnexion de l'antenne
+                                
                                 DeconnecterSocket(i);
                             }
@@ -1898 +1943 @@
                             if (Sockets[i].AttenteExecution > MAXATTENTE)
                             {
-                                // On prolonge l'attente afin de recevoit un GOTO OK
+                                // On prolonge l'attente afin de recevoir un GOTO OK
 
                                 Sockets[i].etape = 5;
@@ -1905 +1950 @@
                             }
 
-                            // On déconnecte l'antenne s'il n'y a pas de coonfirmation du goto au bout de 2 minutes
+                            // On déconnecte l'antenne s'il n'y a pas de confirmation du goto au bout de 2 minutes
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIESGOTO)
                             {
@@ -1927 +1972 @@
 
         ///////////////////////////////////////
-        // Traitement de l'étape 3 de la réalisation d'un goto
+        // Réalisation d'un goto - traitement de l'étape 3 
         // On place cette partie du traitement en dehors du switch et de la boucle
-        // pour pouvoir envoyer les ordres gotos à toutes les antennes lorsque l'on a la confirmation
-        // qu'elles sont toutes prêtes à executer cet ordre (être à l'étape 3 pour un socket)
+        // pour pouvoir envoyer les gotos à toutes les antennes lorsque l'on a la confirmation
+        // qu'elles sont toutes prêtes à exécuter cet ordre (être à l'étape 3 pour un socket)
         // -> meilleure synchronisation
 
@@ -2004 +2049 @@
 /**************************************************************************************
 ** Mode transit ou tracking
+**
 ***************************************************************************************/
 
@@ -2011 +2057 @@
     {
         // Transit
+        
     case BAO_TRANSIT:
 
-        //Eteindre les voyants dans la boîte de dialogue Indi
+        // Éteindre les voyants dans la boîte de dialogue Indi
         EquatorialCoordsWNP.s = IPS_BUSY;
         AbortSlewSP.s = IPS_IDLE;
@@ -2026 +2073 @@
         InitAntennes();
 
-        // On garde la trace du début du Goto pour enchainer les actualisations
+        // On garde la trace du début du Goto pour enchaîner les actualisations
 
         JJAnc = GetJJ();
@@ -2036 +2083 @@
         // Mode transit activé
 
-        TrackingMode = 1;
+        TrackingMode = BAO_TRANSIT;
 
         // On suit un objet
@@ -2053 +2100 @@
 
         // Tracking
+        
     case BAO_TRACKING:
 
-        //Eteindre les voyants dans la boîte de dialogue Indi
+        // Éteindre les voyants dans la boîte de dialogue Indi
+        
         EquatorialCoordsWNP.s = IPS_BUSY;
         AbortSlewSP.s = IPS_IDLE;
@@ -2070 +2119 @@
         ADDEC2Motor(targetRA, targetDEC);
 
-        TrackingMode = 2;
+        TrackingMode = BAO_TRACKING;
 
         Suivi = true;
@@ -2088 +2137 @@
 /**************************************************************************************
 ** Connexion / Déconnexion avec le télescope
+**
 ***************************************************************************************/
 
@@ -2270 +2320 @@
 
     // problÚme 1 : si deltaAz > à un demi-tours - soit 2000 pas codeur alors
-    // on fait le trajet dans le sens inverse pour aller plus vite
+    // on fait le trajet en sens inverse pour aller plus vite
 
     // problÚme 2 : Passage au méridien
@@ -2278 +2328 @@
 
     // ne pas faire des tours complets en Az pour rien...
+    
     while (deltaAz > NBREPASCODEURSAZ) deltaAz -= NBREPASCODEURSAZ;
 
     // Doit résoudre tous les problÚmes concernant l'azimut...
+    
     if (deltaAz > NBREPASCODEURSAZ / 2 )
     {
@@ -2313 +2365 @@
 {
     //Il ne faut exécuter la fonction qu'une seule fois
+    
     static int isInit = 0;
 

BAORadio/libindi/libindi/drivers/telescope/BAO.h

@@ -57 +57 @@
 
     int sendalertes;                        // une requête 'send' a généré une erreur sur le réseau
-    int AttenteExecution;                   // L'antenne parvient-elle à executer un cycle de commandes ?
+    int AttenteExecution;                   // L'antenne parvient-elle à exécuter un cycle de commandes ?
     int AnomaliesExecution;                 // Erreur critique. L'antenne ne répond plus !
-    int etape;                              // étape dans le cycle de commandes/réponses entre PC et microcontroleurs
+    int etape;                              // étape dans le cycle de commandes/réponses entre PC et micro-contrÎleurs
 
     bool Connected;                         // le micro-contrÎleur est-il connecté ?
     bool PosValides;                        // le micro-contrÎleur a-t-il donné une position des moteurs valide ?
     bool ack_status;                        // Etat des acknowledges ?
-    bool ack_pos;                           // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre POSITION ?
-    bool ack_park;                          // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre PARK ?
-    bool ack_abort;                         // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre ABORT ?
-    bool ack_goto;                          // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre GOTO ?
+    bool ack_pos;                           // le PC a-t-il reçu une confirmation du micro-contrÎleurs aprÚs un ordre POSITION ?
+    bool ack_park;                          // le PC a-t-il reçu une confirmation du micro-contrÎleurs aprÚs un ordre PARK ?
+    bool ack_abort;                         // le PC a-t-il reçu une confirmation du micro-contrÎleurs aprÚs un ordre ABORT ?
+    bool ack_goto;                          // le PC a-t-il reçu une confirmation du micro-contrÎleurs aprÚs un ordre GOTO ?
     bool GotoOk;                            // Est-ce que le dernier goto est OK ?
 
     Position TargetPosition;                // Position à atteindre
-    Position Pos;                           // derniÚre position retournée par le microcontrÎleur
+    Position Pos;                           // derniÚre position retournée par le micro-contrÎleur 
     
     Alignement *AlignementAntenne;          // Contient les paramÚtres d'alignement de l'antenne  
@@ -79 +79 @@
 // Le PC et les antennes communiquent par le biais du port 8000 sur le réseau Ethernet
 
-ServerSocket server( 8000 );         
+ServerSocket server( BAO_PORT );         
 
 class BAO : public Astro
@@ -206 +206 @@
     double lastDEC;                      // ...et la déclinaison
     double JJAnc;                        // Sauvegarde du jour julien lors de la derniÚre actualisation de la position (fct Goto)
-    double ActualisationTMTransit;       // Délai entre deux actualisations dans les modes transit
-    double ActualisationTMTracking;      //  "                 "                     "     tracking
+    double ActualisationTMTransit;       // Délai entre deux actualisations dans les modes transit (en sec)
+    double ActualisationTMTracking;      //  "                 "                     "     tracking (en sec)
     double Longitude;                    // Longitude et latitude du lieu d'observation
     double Latitude;
@@ -221 +221 @@
 
     int    currentSet;                   // mode de suivi actuel - tracking ou transit
-    int    lastSet;                      // Variable interne de l'interface indi - ne pas toucher
-    int    TrackingMode;                 // 1 : Transit           2: Tracking
+    int    MethodeAlignement;            // Méthode d'alignement
+    BAO_STATUS  TrackingMode;            // Mode de suivi actuellement activé
 };
 

BAORadio/libindi/libindi/result_recherche_bao

@@ -1 @@
-
-
-Results from query to  NASA/IPAC Extragalactic Database (NED),
-which is operated by the Jet Propulsion Laboratory, California Institute of
-Technology, under contract with the National Aeronautics and Space Administration.
-This work was (partially) supported by the US National Virtual Observatory
-development project, which is funded by the National Science Foundation
-under cooperative agreement AST0122449 with The Johns Hopkins University.
-
-
-
-queryDateTime:2012-02-24T03:26:46PST
-
-
-
-Main Information Table for MESSIER 092
-
-
-
-Equinox:J2000.0
-
-
-
-CoordSystem:Equatorial
-
-No.|Object Name|RA(deg)|DEC(deg)|Type|Velocity|Redshift|Redshift Flag|Magnitude and Filter|Distance (arcmin)|References|Notes|Photometry Points|Positions|Redshift Points|Diameter Points|Associations
-1|MESSIER 092|259.28029 |  43.13652 |*Cl||||     ||27|1|0|0|0|2|2