Index: /BAORadio/libindi/libindi/BAOControl/baocontrol.cpp
===================================================================
--- /BAORadio/libindi/libindi/BAOControl/baocontrol.cpp	(revision 647)
+++ /BAORadio/libindi/libindi/BAOControl/baocontrol.cpp	(revision 648)
@@ -27,5 +27,5 @@
     ChoixCouleurs=1;
 
-    //Affichage de la version du porgramme
+    // Affichage de la version du programme
 
     AfficherLog("\n\n\n\n\n \
@@ -66,5 +66,5 @@
     client_socket          = NULL;
 
-    // chaines de caractÃšres et tableaux
+    // chaÃ®nes de caractÃšres et tableaux
 
     LatitudeChar           = "";
@@ -78,5 +78,5 @@
 
 
-    //on initalise aussi les structures
+    // on initialise aussi les structures
 
     for (int i=0; i<MAXANTENNES; i++)
@@ -147,5 +147,4 @@
     }
 
-
     // Ouverture du socket avec indi_BAO
 
@@ -218,5 +217,5 @@
 
 
-    // crÃ©e une fenÃªtre
+    // crÃ©ation d'une fenÃªtre
 
     w = XCreateSimpleWindow(d, RootWindow(d, DefaultScreen(d)),
@@ -226,5 +225,6 @@
 
 
-    // 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,4 +265,5 @@
 /**************************************************************************************
 ** Dessine les Ã©lÃ©ments dans la fenÃªtre graphique
+**
 ***************************************************************************************/
 
@@ -295,5 +296,5 @@
     // 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,7 +351,7 @@
             }
 
-            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,10 +375,10 @@
 
     // 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,5 +440,5 @@
             reponse = reponse.substr(reponse.find("message") + 9);
 
-            //(on en garde une trace)
+            // (on en garde une trace)
 
             memreponse = reponse;
@@ -481,6 +482,6 @@
 
             // 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,5 +532,5 @@
 /**************************************************************************************
 ** Est-ce que la rÃ©ponse du pilote indi_BAO est conforme Ã  ce que l'on attendait ?
-** Retourne true si c'est bonne
+**
 **
 ***************************************************************************************/
@@ -557,5 +558,5 @@
             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,4 +645,5 @@
 
     // Tant que l'utilisateur n'a pas tapÃ© la commande 'exit'
+
     while (NoExit)
     {
@@ -655,5 +657,5 @@
 
 
-        // Faut-il executer un fichier de mouvements ?
+        // Faut-il exÃ©cuter un fichier de mouvements ?
 
         if (run && numobjets > 1 && runnum < numobjets)
@@ -664,5 +666,5 @@
             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,5 +705,5 @@
                     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,5 +711,5 @@
                     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,5 +724,5 @@
         }
 
-        // on lit et affiche la rÃ©ponse des microcontrolleurs
+        // on lit et affiche la rÃ©ponse des micro-contrÃŽleurs
 
         LireReponse();
@@ -734,11 +736,22 @@
             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,5 +794,5 @@
     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,5 +833,5 @@
             // 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,4 +846,6 @@
 /**************************************************************************************
 ** 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,5 +854,5 @@
 {
     // 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,7 +995,6 @@
 
 /**************************************************************************************
-** 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,5 +1014,5 @@
         *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,11 +1112,11 @@
 
 /**************************************************************************************
-** 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,9 +1138,10 @@
 
     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,11 +1172,9 @@
         *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,4 +1220,5 @@
 /**************************************************************************************
 ** Se connecte ou se dÃ©connecte au pilote indi_BAO
+**
 ***************************************************************************************/
 
@@ -1215,6 +1229,5 @@
         *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,4 +1266,8 @@
         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,7 +1290,8 @@
 
 /**************************************************************************************
-** 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,8 +1326,9 @@
 ** 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,5 +1367,5 @@
     {
         // 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,5 +1373,12 @@
         // 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,10 +1388,12 @@
         // 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,6 +1426,7 @@
                     ModificationAlignement=true;
                     AfficherLog("delta_az - 1\n", true);
-		    
+
                     break;
+                    //abort
                 case 'a' :
                     Abort();
@@ -1406,12 +1435,30 @@
                     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,5 +1475,6 @@
             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,9 +1490,8 @@
             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,5 +1501,5 @@
                                            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,5 +1520,5 @@
                 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,6 +1548,6 @@
                     // 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,4 +1615,5 @@
                             break;
 
+                            //abort
                         case 'a' :
                             Abort();
@@ -1574,4 +1622,5 @@
                             break;
 
+                            // vitesse 1x ou 10x
                         case 's' :
                             (Vitesse == 1 ) ? Vitesse = 10 : Vitesse = 1;
@@ -1581,4 +1630,5 @@
                             break;
 
+                            // reprise du goto
                         case 'g' :
                             AfficherLog("Reprise du GOTO.\n\n", true);
@@ -1596,5 +1646,6 @@
                 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,9 +1657,9 @@
         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,5 +1676,5 @@
 
 /**************************************************************************************
-** Lance l'executution d'un fichier de mouvements
+** Lance l'exÃ©cution d'un fichier de mouvements
 **
 ***************************************************************************************/
@@ -1637,5 +1688,5 @@
     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,4 +1695,5 @@
         {
             ErreurLog("Le fichier contient des dates qui sont toutes pÃ©rimÃ©es. ExÃ©cution annulÃ©e.\n\n");
+
             NoExit = !exitrun;
 
@@ -1650,5 +1702,5 @@
         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,4 +1709,5 @@
     {
         ErreurLog("\nLe fichier " + fichier + " contient des erreurs ou n'existe pas...\n\n\n");
+
         NoExit=!exitrun;
 
@@ -1670,11 +1723,11 @@
 ** 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,5 +1744,5 @@
     (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,5 +1769,5 @@
     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,4 +1805,5 @@
 ** 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,9 +1896,11 @@
             {
                 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,4 +2103,6 @@
 
                 Antennes[num].AlignementAntenne->InitAlignement();
+		
+		Antennes[num].AlignementAntenne->MethodeAlignement = MethodeAlignement;
 
                 ModificationAlignement = true;
@@ -2280,5 +2338,5 @@
     int rc;
 
-    //initialsation des variables de retour
+    //initialisation des variables de retour
 
     reponse.ar = "";
@@ -2426,4 +2484,5 @@
 ** Lecture d'un fichier ligne aprÃšs ligne
 ** retourne -1 Ã  la fin
+**
 ***************************************************************************************/
 
@@ -2480,5 +2539,5 @@
 
     /////////////////////////////////////////
-    // Rubrique CoodonnÃ©es gÃ©ographiques
+    // Rubrique CoordonnÃ©es gÃ©ographiques
 
     section = "coordonnees geographiques";
@@ -2538,4 +2597,6 @@
     }
 
+    /////////////////////////////////////////
+    // Port de connexion du serveur Indi
 
     key = "port";
@@ -2593,4 +2654,42 @@
     }
 
+    /////////////////////////////////////////
+    // 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,5 +2708,5 @@
     else
     {
-        ErreurLog("Le paramÃštre mode est incorrect !\n");
+        ErreurLog("Le paramÃštre mode suivi est incorrect !\n");
 
         return false;
@@ -2969,5 +3068,5 @@
             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,7 +3083,7 @@
                 && (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,5 +3104,5 @@
         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,6 +3118,6 @@
         // 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,5 +3192,5 @@
 
     // 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,9 +3257,15 @@
 
     // 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);
 }
Index: /BAORadio/libindi/libindi/BAOControl/baocontrol.h
===================================================================
--- /BAORadio/libindi/libindi/BAOControl/baocontrol.h	(revision 647)
+++ /BAORadio/libindi/libindi/BAOControl/baocontrol.h	(revision 648)
@@ -41,6 +41,5 @@
     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,5 +90,5 @@
     void *my_thread_process ();
     
-    // intialise la clase
+    // initialise la classe
     
     int init(int argc, char **argv);
@@ -106,5 +105,5 @@
 
 
-    //communications entre les antennes et le microcontrÃŽleur
+    //communications entre les antennes et le micro-contrÃŽleur
 
     void LireReponse();
@@ -135,5 +134,5 @@
     
 
-    //Gestion serveur NED
+    // Gestion du serveur NED
     
     CoordonneesHoraires ServeurNED(string objet);
@@ -166,11 +165,11 @@
     
 
-    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 
Index: /BAORadio/libindi/libindi/BAOControl/baocontrol_params
===================================================================
--- /BAORadio/libindi/libindi/BAOControl/baocontrol_params	(revision 647)
+++ /BAORadio/libindi/libindi/BAOControl/baocontrol_params	(revision 648)
@@ -11,4 +11,7 @@
 temperature=10
 
+[alignement]
+methode_alignement=SIMPLE
+
 [suivi]
 mode=tracking
Index: /BAORadio/libindi/libindi/communs/alignement.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 647)
+++ /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 648)
@@ -19,5 +19,5 @@
 {
     //Initialisation des paramÃštres des antennes
-    
+
     InitAlignement();
 }
@@ -88,7 +88,7 @@
 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,10 +118,10 @@
 
 /**************************************************************************************
-**  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,5 +397,5 @@
 
     // 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,8 +509,8 @@
         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,8 +602,8 @@
     int best2 = 0;
     int best3 = 0;
-    
-    
+
+
     // On calcule le temps sidÃ©ral local, etc...
-    
+
     CalculTSL();
 
@@ -738,15 +738,33 @@
         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,9 +815,9 @@
     os << MATRICE[1][3] << "   \t" << MATRICE[2][3] << "    \t" << MATRICE[3][3] << "\n";
 
-    
-    
-    
-
-    
+
+
+
+
+
     //VÃ©rifications supp
     /*
@@ -811,5 +829,5 @@
     os << GetHeure() << ":" << GetMin() << ":" << GetSec() << "\n";
     os << DHMS(GetTSL()*N180divPi, true) << "\n\n";
-    
+
       Azimut(c3.x, c3.y, &mm1.x, &mm1.y);
 
@@ -848,6 +866,6 @@
     */
 
-    
-    
+
+
     //Afficher les messages de cette fonction
 
@@ -1018,4 +1036,8 @@
     os2.str("");
 
+    /*  char chaine[100];
+    sprintf(chaine, "************** %s\n",alignment_method_data);
+      cout << chaine;*/
+
     if (alignment_method_data)
     {
@@ -1038,5 +1060,5 @@
     {
         // Si la procÃ©dure d'alignement se termine, il faut calculer la matrice de correction
-        
+
         if (AlignementEnCours != atoi(align_data))
         {
@@ -1103,5 +1125,5 @@
     stringstream os;
 
-    
+
     //AfficherLog("Enregistrement de l'alignement des antennes dans le fichier " + fileName + "\n", true);
 
@@ -1111,5 +1133,5 @@
     section = os.str();
     os.str("");
-    
+
     os << "delta_az_polar";
     key     = os.str();
@@ -1137,5 +1159,10 @@
     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;*/
 
 
Index: /BAORadio/libindi/libindi/communs/const.h
===================================================================
--- /BAORadio/libindi/libindi/communs/const.h	(revision 647)
+++ /BAORadio/libindi/libindi/communs/const.h	(revision 648)
@@ -119,4 +119,12 @@
 /////////////////////////////////////////////
 
+// 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
 
Index: /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp
===================================================================
--- /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp	(revision 647)
+++ /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp	(revision 648)
@@ -43,5 +43,5 @@
     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,10 +52,12 @@
     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,10 +67,15 @@
     // 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,19 +93,21 @@
     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,5 +150,5 @@
 BAO::~BAO()
 {
-    //On informe le thread que nous allons sortir
+    // On informe le thread que nous allons sortir
 
     Exit = true;
@@ -161,5 +170,5 @@
 
     // 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,6 +266,6 @@
 
 /**************************************************************************************
-** 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,7 +280,5 @@
     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,10 +289,12 @@
     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,7 +342,8 @@
 ** 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,4 +382,12 @@
 ** 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,10 +418,10 @@
     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,7 +430,6 @@
         // 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,6 +442,6 @@
             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,13 +476,13 @@
         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,5 +495,5 @@
         {
             // 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,5 +513,5 @@
 
         // 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,5 +550,5 @@
             else if (eqp == &EquatorialCoordsWN[1])
             {
-                //mÃªme chose pour la dÃ©clinaison
+                // mÃªme chose pour la dÃ©clinaison
                 newDEC = values[i];
 
@@ -553,5 +570,5 @@
             targetDEC = newDEC;
 
-            // on les affiches dans les logs
+            // on les affiche dans les logs
 
             fs_sexa(RAStr, newRA, 2, 3600);
@@ -602,5 +619,5 @@
             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,9 +666,9 @@
     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,5 +734,6 @@
 /**************************************************************************************
 ** 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,11 +785,16 @@
             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,4 +869,6 @@
 ** 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,6 +883,8 @@
 
             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,6 +921,8 @@
 /**************************************************************************************
 ** 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,7 +958,6 @@
 
 /************************************************************************************
-** 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,5 +982,5 @@
         if (Sockets[i].Connected)
         {
-            newRA = newRA2;
+            newRA  = newRA2;
 	    newDEC = newDEC2;
 	  
@@ -960,17 +988,17 @@
             // 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,5 +1027,5 @@
                     // 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,7 +1051,5 @@
 		}
             }
-                   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,10 +1068,9 @@
 
                 // 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,5 +1092,5 @@
                     targetAz = atan( result.y / result.x );
 		    
-	            if (result.x < 0) targetAz+=Pi;
+	            if (result.x < 0) targetAz += Pi;
                 }
                 else targetAz = Pidiv2;
@@ -1107,5 +1132,5 @@
 
 
-            //Conversion des deux angles en pas codeurs
+            // Conversion des deux angles en pas codeurs
 
             if ( targetAlt < HAUTMIN )
@@ -1140,9 +1165,9 @@
                 //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,6 +1178,6 @@
 
 /************************************************************************************
-* Retourne le nombre d'antennes actuellement connectÃ©es
-*
+** Retourne le nombre d'antennes actuellement connectÃ©es
+**
 ************************************************************************************/
 
@@ -1187,4 +1212,5 @@
 ** ProcÃ©dure principale
 ** Elle est appelÃ©e toutes les ms
+**
 ***************************************************************************************/
 
@@ -1199,5 +1225,5 @@
     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,5 +1253,5 @@
         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,5 +1269,14 @@
                     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,7 +1303,7 @@
 
         /////////////////////////////////////////////////
-        // 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,5 +1315,5 @@
                     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,5 +1371,5 @@
                             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,5 +1399,5 @@
                                     {
                                         // 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,5 +1428,5 @@
                                 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,5 +1453,5 @@
                                 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,5 +1478,5 @@
                                 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,5 +1487,5 @@
                                     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,6 +1495,5 @@
                                     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,5 +1522,5 @@
                                         }
 
-                                        // 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,5 +1529,5 @@
                                         {
                                             // 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,6 +1593,5 @@
             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,5 +1650,5 @@
             InitAntennes();
 
-            //Pour permettre de refaire un park
+            // Pour permettre de refaire un park
 
             Park = false;
@@ -1629,15 +1662,19 @@
         {
             // 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,5 +1743,5 @@
                     case 0 :
                     {
-                        // On doit intialiser l'acknowledge Ã  false
+                        // On doit initialiser l'acknowledge Ã  false
 
                         Sockets[i].ack_pos    = false;
@@ -1765,5 +1802,5 @@
 
                             // 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,9 +1809,11 @@
                                 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,8 +1831,10 @@
                             // 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,4 +1853,5 @@
 
                                 // On consigne une erreur grave. L'antenne tarde Ã  rÃ©pondre
+				
                                 Sockets[i].AnomaliesExecution++;
                             }
@@ -1817,4 +1859,5 @@
                             // Aucune rÃ©ponse de l'antenne depuis plusieurs minutes
                             // On la dÃ©connecte
+                            
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
                             {
@@ -1824,8 +1867,10 @@
 
                                 //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,5 +1943,5 @@
                             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,5 +1950,5 @@
                             }
 
-                            // 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,8 +1972,8 @@
 
         ///////////////////////////////////////
-        // 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,4 +2049,5 @@
 /**************************************************************************************
 ** Mode transit ou tracking
+**
 ***************************************************************************************/
 
@@ -2011,7 +2057,8 @@
     {
         // 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,5 +2073,5 @@
         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,5 +2083,5 @@
         // Mode transit activÃ©
 
-        TrackingMode = 1;
+        TrackingMode = BAO_TRANSIT;
 
         // On suit un objet
@@ -2053,7 +2100,9 @@
 
         // 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,5 +2119,5 @@
         ADDEC2Motor(targetRA, targetDEC);
 
-        TrackingMode = 2;
+        TrackingMode = BAO_TRACKING;
 
         Suivi = true;
@@ -2088,4 +2137,5 @@
 /**************************************************************************************
 ** Connexion / DÃ©connexion avec le tÃ©lescope
+**
 ***************************************************************************************/
 
@@ -2270,5 +2320,5 @@
 
     // 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,7 +2328,9 @@
 
     // 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,4 +2365,5 @@
 {
     //Il ne faut exÃ©cuter la fonction qu'une seule fois
+    
     static int isInit = 0;
 
Index: /BAORadio/libindi/libindi/drivers/telescope/BAO.h
===================================================================
--- /BAORadio/libindi/libindi/drivers/telescope/BAO.h	(revision 647)
+++ /BAORadio/libindi/libindi/drivers/telescope/BAO.h	(revision 648)
@@ -57,19 +57,19 @@
 
     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,5 +79,5 @@
 // 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,6 +206,6 @@
     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,6 +221,6 @@
 
     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Ã©
 };
 
Index: /BAORadio/libindi/libindi/result_recherche_bao
===================================================================
--- /BAORadio/libindi/libindi/result_recherche_bao	(revision 647)
+++ /BAORadio/libindi/libindi/result_recherche_bao	(revision 648)
@@ -1,27 +1,0 @@
-
-
-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
