Changeset 642 for BAORadio/libindi/libindi/drivers/telescope/BAO.cpp

Timestamp:

Feb 24, 2012, 12:37:36 PM (12 years ago)

Author:

frichard

Message:

-Alignement des antennes
-Version 0.0.9 de libindi

File:

• BAORadio/libindi/libindi/drivers/telescope/BAO.cpp (modified) (91 diffs)

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

@@ -11 +11 @@
 
 #include "BAO.h"
+#include "../communs/alt2motor.h"
 
 
@@ -22 +23 @@
 const char *OPTIONS_GROUP  = "Options";                 // Options Group
 
-/* Handy Macros */
-//#define currentRA     EquatorialCoordsRN[0].value
-//#define currentDEC    EquatorialCoordsRN[1].value
-#define targetRA        EquatorialCoordsWN[0].value
-#define targetDEC       EquatorialCoordsWN[1].value
+
+#define targetRA    EquatorialCoordsWN[0].value
+#define targetDEC   EquatorialCoordsWN[1].value
 
 
@@ -34 +33 @@
 
 
+
 /**************************************************************************************
 ** Initialisation de la classe BAO
+**
 ***************************************************************************************/
 
@@ -42 +43 @@
     init_properties();
 
-    // télescope en état IDLE
-    ConnectSP.s    = IPS_IDLE;
+    // Le bouton connect de la boîte de dialogue d'indi8BAO
+    // est dans l'état IDLE au démarrage
+
+    ConnectSP.s           = IPS_IDLE;
 
     // derniÚre actualisation
-    lastRA         = 0.0;
-    lastDEC        = 0.0;
-    JJAnc          = 0.0;
-
-    currentSet     =  0;
-    lastSet        = -1;
-    SocketsNumber  =  1;
-    TrackingMode   =  1;
-
-    // délais en sec entre deux actualisations de la
-    // position dans les modes transit et tracking
-
-    ActualisationTM1 = 15.0 * 60.0;
-    ActualisationTM2 = 5.0;
-
-    UpdateGoto      = true;
-    InitThreadOK    = false;
-    ActualisationPosition = false;
-    Abort           = false;
-    Park            = false;
-    Suivi           = false;
-    Exit            = false;
+
+    lastRA                = 0.0;
+    lastDEC               = 0.0;
+    JJAnc                 = 0.0;
+
+    // Variables d'état
+
+    currentSet            =  0;         // Variables internes d'Indi, ne pas toucher
+    lastSet               = -1;         // Variable interne d'Indi, ne pas toucher
+
+    // Nombre d'antennes connectées
+
+    SocketsNumber         =  1;
+
+    // Le mode tracking est activé par défaut
+
+    TrackingMode          =  1;
+
+    // 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
+    ActualisationTMTracking = 5.0;            //                "                 "        tracking
+
+    // cette variable vaut "true" lorsque le thread de l'aplication a été initialisé
+
+    InitThreadOK          = false;
+
+    // UpdatedGoto = true lorsque le dernier goto a bien été réalisé jusqu'au bout
+
+    UpdatedGoto           = true;
+
+    // RealisationGoto = true lorsque les étapes nécessaires à la réalisation d'un goto
+    // sont en cours d'execution
+
+    RealisationGoto       = false;
+
+    // vaut 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
+
+    Park                  = false;
+
+    // vaut true 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
+
+    Exit                  = false;
+    
+    Pression              = 1013.0;
+    
+    Temp                  = 10.0;
 
 
     // initialisation des sockets (Antennes)
-    
+
     for (int i=0; i<MAXHOSTNAME; i++)
     {
-        Sockets[i].Connected = false;
-        Sockets[i].IP = "";
-                
-        Sockets[i].Delta.x = 0.0;
-        Sockets[i].Delta.y = 0.0;
+        Sockets[i].Connected         = false;
+        Sockets[i].IP                = "";
+        Sockets[i].TargetPosition.x  = 0.0;
+        Sockets[i].TargetPosition.y  = 0.0;
+        Sockets[i].AlignementAntenne = new Alignement();
+
+        if (Sockets[i].AlignementAntenne) Sockets[i].AlignementAntenne->InitAlignement();
     }
 
     // initialisations supplémentaires
-    
+
     InitAntennes();
 
     // Numéro de version
-    
-    IDLog("Initilizing from BAO device...\n");
-    IDLog("Driver Version: 2011-12-02\n");
+
+    IDLog("Indi server BAORadio...\n");
+    IDLog("Driver Version: 23-02-2012\n");
 
     //connect_telescope();
@@ -94 +133 @@
 
 
+
 /**************************************************************************************
 ** Destructeur
-** Lorsque l'on lance indi_BAO depuis indiserver dans un terminal
-** Le destructeur ne semble jamais être atteint lorsque l'on sort... A vérifier
-***************************************************************************************/
+**
+***************************************************************************************/
+
 BAO::~BAO()
 {
+    //On informe le thread que nous allons sortir
+
     Exit = true;
+
+    // On lui laisse une seconde pour qu'il se termine
+
     sleep(1);
-    pthread_join (th1, NULL);
-}
+
+    // destruction du thread
+
+    pthread_join(th1, NULL);
+
+    // destruction des objets AlignementAntennes
+
+    for (int i=0; i<MAXHOSTNAME; i++)
+    {
+        delete Sockets[i].AlignementAntenne;
+    }
+
+    // Petit message à l'attention de l'utilisateur
+    // permet de savoir si le destructeur est bien atteint
+
+    IDLog("Sortie de indi_BAO\n");
+}
+
 
 
 /************************************************************************************
-* Initialisation des paramÚtres des antennes
-*
+** Initialisation des paramÚtres des antennes
+**
 ************************************************************************************/
+
 void BAO::InitAntennes()
 {
@@ -121 +183 @@
         Sockets[i].etape              = 0;
 
-        Sockets[i].ack_status = false;
-        Sockets[i].ack_pos    = false;
-        Sockets[i].ack_park   = false;
-        Sockets[i].ack_abort  = false;
-        Sockets[i].ack_goto   = false;
-
-        Sockets[i].PosValides = false;
-        Sockets[i].GotoOk     = false;
-    }
-}
+        Sockets[i].ack_status         = false;
+        Sockets[i].ack_pos            = false;
+        Sockets[i].ack_park           = false;
+        Sockets[i].ack_abort          = false;
+        Sockets[i].ack_goto           = false;
+
+        Sockets[i].PosValides         = false;
+        Sockets[i].GotoOk             = false;
+    }
+}
+
 
 
 /**************************************************************************************
 ** Initialisation des boutons et des zones d'affichage dans la boîte de dialogue INDI
+** se référer à la documentation d'INDI
+**
 ***************************************************************************************/
 
@@ -149 +214 @@
     IUFillSwitchVector(&OnCoordSetSP, OnCoordSetS, NARRAY(OnCoordSetS), mydev, "ON_COORD_SET", "On Set", BASIC_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
 
+    // Alignment Set
+    IUFillSwitch(&AlignmentS[0], "SIMPLE", "Simple", ISS_ON);
+    IUFillSwitch(&AlignmentS[1], "AFFINE", "Affine", ISS_OFF);
+    IUFillSwitch(&AlignmentS[2], "TAKI", "Taki", ISS_OFF);
+    IUFillSwitchVector(&AlignmentSP, AlignmentS, NARRAY(AlignmentS), mydev, "ALIGNMENT_SET", "Alignment", BASIC_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
+
     // Abort
     IUFillSwitch(&AbortSlewS[0], "ABORT", "Abort", ISS_OFF);
@@ -171 +242 @@
     IUFillNumberVector(&GeographicCoordsWNP, GeographicCoordsWN, NARRAY(GeographicCoordsWN), mydev, "GEOGRAPHIC_COORD" , "Geographic coords", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
 
+     // Pression température - SET
+    IUFillNumber(&PressionTempWN[0], "Pression", "Pression mb", "%10.6m",  0., 1500., 0., 0.);
+    IUFillNumber(&PressionTempWN[1], "Temperature", "Temperature °c", "%10.6m", -50., +50., 0., 0.);
+    IUFillNumberVector(&PressionTempWNP, PressionTempWN, NARRAY(PressionTempWN), mydev, "PRESSION_DATA" , "Pression, Temperature", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
+
     // Actualisation - SET
-    IUFillNumber(&ActualisationN1[0], "DELAY", "Transit mode delay (Sec)", "%10.6m",  0., 3600., 0., 0.);
+    IUFillNumber(&ActualisationN1[0], "DELAY", "Transit delay (s)", "%10.6m",  0., 3600., 0., 0.);
     IUFillNumberVector(&ActualisationNP1, ActualisationN1, NARRAY(ActualisationN1), mydev, "DELAY1" , "", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
 
-    IUFillNumber(&ActualisationN2[0], "DELAY", "Tracking mode delay (Sec)", "%10.6m",  0., 3600., 0., 0.);
+    IUFillNumber(&ActualisationN2[0], "DELAY", "Tracking delay (s)", "%10.6m",  0., 3600., 0., 0.);
     IUFillNumberVector(&ActualisationNP2, ActualisationN2, NARRAY(ActualisationN2), mydev, "DELAY2" , "", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
 }
@@ -182 +258 @@
 /**************************************************************************************
 ** Initialisation de la boîte de dialogue INDI (suite)
+** Vider tous les vecteurs
+**
 ***************************************************************************************/
 
@@ -195 +273 @@
     IDDefNumber(&EquatorialCoordsWNP, NULL);
     IDDefNumber(&GeographicCoordsWNP, NULL);
+    IDDefNumber(&PressionTempWNP, NULL);
     IDDefSwitch(&OnCoordSetSP, NULL);
+    IDDefSwitch(&AlignmentSP, NULL);
     IDDefSwitch(&AbortSlewSP, NULL);
     IDDefSwitch(&ParkSP, NULL);
@@ -207 +287 @@
 /**************************************************************************************
 ** Initialisation des vecteurs INDI
+** ParamÚtres par défaut
+**
 ***************************************************************************************/
 
@@ -213 +295 @@
     ConnectSP.s                 = IPS_IDLE;
     OnCoordSetSP.s              = IPS_IDLE;
+    AlignmentSP.s               = IPS_IDLE;
     AbortSlewSP.s               = IPS_IDLE;
     ParkSP.s                    = IPS_IDLE;
     ObjectTP.s                  = IPS_IDLE;
     EquatorialCoordsWNP.s       = IPS_IDLE;
+    PressionTempWNP.s           = IPS_IDLE;
     GeographicCoordsWNP.s       = IPS_IDLE;
     ActualisationNP1.s          = IPS_IDLE;
@@ -222 +306 @@
 
     IUResetSwitch(&OnCoordSetSP);
+    IUResetSwitch(&AlignmentSP);
     IUResetSwitch(&AbortSlewSP);
     IUResetSwitch(&ParkSP);
 
     OnCoordSetS[0].s = ISS_ON;
+    AlignmentS[0].s = ISS_ON;
     ConnectS[0].s = ISS_OFF;
     ConnectS[1].s = ISS_ON;
@@ -231 +317 @@
     IDSetSwitch(&ConnectSP, NULL);
     IDSetSwitch(&OnCoordSetSP, NULL);
+    IDSetSwitch(&AlignmentSP, NULL);
     IDSetSwitch(&AbortSlewSP, NULL);
     IDSetSwitch(&ParkSP, NULL);
     IDSetText(&ObjectTP, NULL);
     IDSetNumber(&EquatorialCoordsWNP, NULL);
+    IDSetNumber(&PressionTempWNP, NULL);
     IDSetNumber(&GeographicCoordsWNP, NULL);
     IDSetNumber(&ActualisationNP1, NULL);
@@ -241 +329 @@
 
 
+
 /**************************************************************************************
 ** En cas de changement de texte dans la boîte de dialogue (par exemple : changement du
-** nom de l'objet) alors suivre l'objet... 
+** 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
+**
 ***************************************************************************************/
 
@@ -275 +367 @@
 
 
+
 /**************************************************************************************
 ** En cas de changement d'une valeur numérique dans la boîte de dialogue Indi
@@ -285 +378 @@
 
     // Ignore if not ours
+
     if (strcmp (dev, mydev))
         return;
 
+    // Si pas de connexion -> on sort
+
     if (is_connected() == false)
     {
         IDMessage(mydev, "Error ! BAO is offline. Please connect before issuing any commands.");
+
         reset_all_properties();
+
         return;
     }
@@ -299 +397 @@
     // Geographic  Coords
     // ===================================
+
     if (!strcmp (name, GeographicCoordsWNP.name))
     {
-        int i=0, nset=0, error_code=0;
-
-        Latitude=0.0;
-        Longitude=0.0;
-
-        for (nset = i = 0; i < n; i++)
-        {
+        // l'utilisateur a modifié un les 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
+
+        Latitude  = 0.0;
+        Longitude = 0.0;
+
+        // 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
+
+        for (i = 0; i < n; i++)
+        {
+            // pour chacun d'entre eux, on regarde si le nom passé en argument de la fonction (*name)
+            // correspond bien à l'un des éléments du vecteur GeographicCoordsWNP
+
             INumber *eqp = IUFindNumber (&GeographicCoordsWNP, names[i]);
+
             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
+                // C'est la valeur saisie par l'utilisateur
+
                 Latitude = values[i];
+
+                // On doit vérifier que la latitude est dans un intervalle correct
+
                 nset += Latitude >= -90.0 && Latitude <= 90.0;
+
+                // on convertit en radians
 
                 Latitude *= Pidiv180;
@@ -318 +441 @@
             else if (eqp == &GeographicCoordsWN[1])
             {
+                // ici on a identifié une modification dans la rubrique longitude
+
                 Longitude = values[i];
+
+                // dans l'intervalle ?
+
                 nset += Longitude >= 0.0 && Longitude <= 360.0;
+
+                // en radians
 
                 Longitude *= -Pidiv180;
@@ -332 +462 @@
             //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
+            // 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
+
             GeographicCoordsWNP.s = IPS_OK;
+
+            // pas de message d'erreur dans la boîte
+
             IDSetNumber(&GeographicCoordsWNP, NULL);
         }
         else
         {
+            // quelque chose cloche
+            // peut-être l'une des veleurs saisies par l'utilisateur n'est-elle pas dans
+            // le bon intervalle ? ex : lat = 150°
+
+            // on change la couleur de la diode
+
             GeographicCoordsWNP.s = IPS_ALERT;
+
+            // on affiche un message d'erreur
+
             IDSetNumber(&GeographicCoordsWNP, "Latitude or Longitude missing or invalid");
 
-            Latitude=0.0;
-            Longitude=0.0;
-        }
+            // on fixe arbitrairement les valeurs à 0
+
+            Latitude  = 0.0;
+            Longitude = 0.0;
+        }
+
+        // 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...
 
         DefinirLongitudeLatitude(Longitude, Latitude);
@@ -355 +509 @@
     if (!strcmp (name, EquatorialCoordsWNP.name))
     {
-        int i=0, nset=0, error_code=0;
-        double newRA =0, newDEC =0;
-
-        for (nset = i = 0; i < n; i++)
+        int i = 0, nset = 0;
+
+        double newRA =0.0, newDEC =0.0;
+
+        // nous avons le même principe de fonctionnement que pour les coordonnées géographiques
+
+        for (i = 0; i < n; i++)
         {
             INumber *eqp = IUFindNumber (&EquatorialCoordsWNP, names[i]);
+
             if (eqp == &EquatorialCoordsWN[0])
             {
+                // on a compris que l'utilisateur avait changé l'ascension droite de l'objet
+
+                // on affecte la nouvelle valeur à newRA
+
                 newRA = values[i];
+
+                // Est-ce que cette valeur est dans le bon intervalle ?
+
                 nset += newRA >= 0 && newRA <= 24.0;
             }
             else if (eqp == &EquatorialCoordsWN[1])
             {
+                //même chose pour la déclinaison
                 newDEC = values[i];
+
                 nset += newDEC >= -90.0 && newDEC <= 90.0;
             }
@@ -375 +542 @@
 
         // si les coordonnées de l'objet sont correctes
+
         if (nset == 2)
         {
@@ -380 +548 @@
             double targetAZ, targetAlt;
 
+            // On garde une trace des nouvelles coordonnées saisies par l'utilisateur
+
             targetRA  = newRA;
             targetDEC = newDEC;
 
+            // on les affiches dans les logs
+
             fs_sexa(RAStr, newRA, 2, 3600);
             fs_sexa(DecStr, newDEC, 2, 3600);
@@ -392 +564 @@
 
             ADDEC2Motor(newRA, newDEC);
+
+            // on déclenche le goto
 
             if (process_coords() == false)
             {
                 EquatorialCoordsWNP.s = IPS_ALERT;
+
                 IDSetNumber(&EquatorialCoordsWNP, NULL);
             }
@@ -402 +577 @@
         {
             EquatorialCoordsWNP.s = IPS_ALERT;
+
             IDSetNumber(&EquatorialCoordsWNP, "Error ! RA or Dec missing or invalid");
         }
@@ -407 +583 @@
         return;
     }
+    
+    
+    // ===================================
+    // Pression, Temperature
+    // ===================================
+    if (!strcmp (name, PressionTempWNP.name))
+    {
+        int i = 0, nset = 0;
+
+        double newPression =0.0, newTemperature =0.0;
+
+        // nous avons le même principe de fonctionnement que pour les coordonnées géographiques
+
+        for (i = 0; i < n; i++)
+        {
+            INumber *eqp = IUFindNumber (&PressionTempWNP, names[i]);
+
+            if (eqp == &PressionTempWN[0])
+            {
+                // on a compris que l'utilisateur avait changé l'ascension droite de l'objet
+
+                // on affecte la nouvelle valeur à newRA
+
+                newPression = values[i];
+
+                // Est-ce que cette valeur est dans le bon intervalle ?
+
+                nset += newPression >= 0.0 && newPression <= 1500.0;
+            }
+            else if (eqp == &PressionTempWN[1])
+            {
+                //même chose pour la déclinaison
+                newTemperature = values[i];
+
+                nset += newTemperature >= -50.0 && newTemperature <= 50.0;
+            }
+        }
+
+
+        // si les coordonnées de l'objet sont correctes
+
+        if (nset == 2)
+        {  
+            PressionTempWNP.s = IPS_OK;
+
+            IDSetNumber(&PressionTempWNP, NULL);
+                    
+            Pression = newPression;
+            Temp = newTemperature;
+        }
+        else
+        {
+            PressionTempWNP.s = IPS_ALERT;
+
+            IDSetNumber(&PressionTempWNP, "Error ! Bad values for pression or temperature");
+        }
+
+        return;
+    }
+
 
     // ===================================
@@ -413 +649 @@
     if (!strcmp (name, ActualisationNP1.name))
     {
-        int i=0, nset=0, error_code=0;
-        double newAct1 =0;
-
-        for (nset = i = 0; i < n; i++)
+        // on a ici exactement le même fonctionnement que précédement
+        // on régle ici les valeurs des delais 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
+
+        double newAct1 = 1.0;
+
+        for (int i = 0; i < n; i++)
         {
             INumber *eqp = IUFindNumber (&ActualisationNP1, names[i]);
+
             if (eqp == &ActualisationN1[0])
             {
                 newAct1 = values[i];
 
-                if (newAct1 >= 0.0 && newAct1 <= 3600.0)
+                if ( newAct1 >= 0.0 && newAct1 <= 3600.0 )
                 {
-                    ActualisationTM1 = newAct1;
+                    ActualisationTMTransit = newAct1;
 
                     ActualisationNP1.s = IPS_OK;
+
                     IDSetNumber(&ActualisationNP1, NULL);
                 }
@@ -433 +676 @@
                 {
                     ActualisationNP1.s = IPS_ALERT;
+
                     IDSetNumber(&ActualisationNP1, "Error ! Delay invalid");
                 }
@@ -441 +685 @@
     if (!strcmp (name, ActualisationNP2.name))
     {
-        int i=0, nset=0, error_code=0;
-        double newAct2 =0;
-
-        for (nset = i = 0; i < n; i++)
+        double newAct2 = 1.0;
+
+        for (int i = 0; i < n; i++)
         {
             INumber *eqp = IUFindNumber (&ActualisationNP2, names[i]);
+
             if (eqp == &ActualisationN2[0])
             {
                 newAct2 = values[i];
 
-                if (newAct2 >= 0.0 && newAct2 <= 3600.0)
+                if ( newAct2 >= 0.0 && newAct2 <= 3600.0 )
                 {
-                    ActualisationTM2 = newAct2;
+                    ActualisationTMTracking = newAct2;
 
                     ActualisationNP2.s = IPS_OK;
+
                     IDSetNumber(&ActualisationNP2, NULL);
                 }
@@ -469 +714 @@
 
 
+
 /**************************************************************************************
 ** L'utilisateur clique sur l'un des boutons de la boîte Indi
+**
 ***************************************************************************************/
 
@@ -513 +760 @@
 
     // ===================================
+    // Alignment Set
+    // ===================================
+    if (!strcmp(name, AlignmentSP.name))
+    {
+        if (IUUpdateSwitch(&AlignmentSP, states, names, n) < 0)
+            return;
+
+        currentSet = get_switch_index(&AlignmentSP);
+        AlignmentSP.s = IPS_OK;
+        IDSetSwitch(&AlignmentSP, NULL);
+
+        for (int i=0; i<MAXALIGNEMENTANTENNE; i++)
+        {
+            switch (currentSet)
+            {
+            case 1 :
+                Sockets[i].AlignementAntenne->MethodeAlignement = SIMPLE;
+                break;
+            case 2 :
+                Sockets[i].AlignementAntenne->MethodeAlignement = AFFINE;
+                break;
+            case 3 :
+                Sockets[i].AlignementAntenne->MethodeAlignement = TAKI;
+                break;
+            }
+        }
+
+        return;
+    }
+
+    // ===================================
     // Abort slew
     // ===================================
     if (!strcmp (name, AbortSlewSP.name))
     {
-        Abort=true;
+        Abort = true;
 
         IUResetSwitch(&AbortSlewSP);
@@ -568 +846 @@
 ** l'utilisation d'un thread permet de contourner le problÚme de la fonction accept
 ** qui est bloquante.
+**
 ***************************************************************************************/
 
@@ -590 +869 @@
             IDLog("\n");*/
         }
-        
-        sleep(1); // faire une pause pour éviter de consommer trop de temps CPU -> à vérifier 
+
+        sleep(1); // faire une pause pour éviter de consommer trop de temps CPU -> à vérifier
     }
     while (!Exit);
@@ -617 +896 @@
 ** Le retour de la commande P est POSITION/valeur_az/valeur_alt/
 ** ExtractPosition retourne donc Valeur_az et Valeur_alt
+**
 ***************************************************************************************/
 
@@ -633 +913 @@
         if (pos != string::npos)
         {
-            result->x = atol(str2.substr(0, pos).c_str());
-
-            result->y = atol(str2.substr(pos + 1).c_str());
-            
-            return true;
-        }        
-    } 
+            result->x = atol( str2.substr(0, pos).c_str() );
+
+            result->y = atol( str2.substr(pos + 1).c_str() );
+
+            return true;
+        }
+    }
 
     IDLog((str +" failed !\n").c_str());
@@ -649 +929 @@
 
 /************************************************************************************
-* cette procédure convertit les coordonnées équatoriales de l'objet visé
-* en unités de codeurs des paraboles (nb de tours des deux axes moteurs depuis la position PARK)
+** 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
+** (cà d en nb de tours des deux axes moteurs depuis la position PARK)
+**
 ************************************************************************************/
 
@@ -657 +940 @@
     double targetAz;
     double targetAlt;
+    double newRA2  = newRA * 15.0 * Pidiv180;
+    double newDEC2 = newDEC * Pidiv180;
     char AzStr[32];
     char AltStr[32];
-
-
-    // Calcule la hauteur et l'azimut de la zone du ciel pointée (en fonction de la date et du lieu d'observation)
-
-    Azimut( newRA * 15.0 * Pidiv180, newDEC * Pidiv180, &targetAz, &targetAlt);
-    
-    // Correction de la réfraction atmosphérique
-    
-    targetAlt = RefractionAtmospherique(targetAlt);
-
-    // Petit calcul pour faire en sorte que le sud soit à 0° d'azimut
-
-    targetAz = VerifAngle( targetAz + Pi );
-
-    // On convertit les angles précédents en degrés
-
-    targetAlt *= N180divPi;
-    targetAz  *= N180divPi;
-
-    // Affichage dans les logs
-
-    fs_sexa(AzStr, targetAz, 2, 3600);
-    fs_sexa(AltStr, targetAlt, 2, 3600);
-
-    IDLog("Horizontal coords : Az = %s     Alt = %s\n", AzStr, AltStr);
-
-
-    //Conversion des deux angles en pas codeurs
-
-    if ( targetAlt < 30.0 )
-    {
-        // L'objet est trop bas (<30°). On annule le suivi...
-
-        IDSetSwitch(&OnCoordSetSP, "Erreur ! L objet suivi est situe a moins de 30° au-dessus de l horizon. Goto annule.");
-
-        Suivi = false;
-
-        ActualisationPosition = false;
-
-        InitAntennes();
-    }
-    else
-    {
-        // Si la hauteur est supérieure à 90°, on doit ajouter 180° à l'azimut et corriger
-        // la hauteur en appliquant hauteur=180°-hauteur
-
-        if (targetAlt > 90.0)
-        {
-            targetAlt = 180.0 - targetAlt;
-            targetAz += 180.0;
-        }
-
-        // On applique la formule de Marc pour convertir la hauteur en nombre de pas codeur alt
-
-        double I0 = 81.0;
-        double I2 = 128279.4 - 129723.4 * sin( (targetAlt - 20.2345) * Pidiv180 );
-
-        double Codalt = (sqrt(I2) - I0) / 0.078947;
-
-
-        TargetPosition.y = (int) Arrondi(Codalt);
-
-        //4000 pas pour 360° sur l'axe az
-
-        TargetPosition.x = (int) Arrondi( targetAz * 4000.0 / 360.0);
-
-        IDLog("Nbre de pas codeurs Az = %i        Alt = %i\n", TargetPosition.x, TargetPosition.y);
-    }
-}
-
-
-/**************************************************************************************
-** Le fichier file existe-t-il et n'est-il pas vide ?
-**************************************************************************************/
-
-bool BAO::is_readable( const std::string & file ) 
-{ 
-    std::ifstream fichier( file.c_str() ); 
-    if (fichier.fail()) return false;
-    
-    // sauvegarder la position courante
-    long pos = fichier.tellg();
-    // se placer en fin de fichier
-    fichier.seekg( 0 , std::ios_base::end );
-    // récupérer la nouvelle position = la taille du fichier
-    long size = fichier.tellg() ;
-    // restaurer la position initiale du fichier
-    fichier.seekg( pos,  std::ios_base::beg ) ;
-    return size ;
-}
-
-
-/**************************************************************************************
-** Chargement des paramÚtres d'alignement des antennes
-**************************************************************************************/
-
-bool BAO::ChargementParametresAlignement(string fileName)
-{
-    string value;
-    
-    stringstream os;
-    
-    char *delta_az = NULL;
-    
-    char *delta_ha = NULL;
-        
-    if (!is_readable(fileName)) return false;
-     
-    //IDLog("Chargement du fichier d alignement des antennes %s\n", fileName.c_str());
-     
-    //Chargement des corrections des antennes
-    
+    Coord result, vect;
+
+    // Pour toutes les antennes connectées
+
     for (int i=0; i<SocketsNumber; i++)
     {
+        // On vérifie qu'elles sont encore connectées
+
         if (Sockets[i].Connected)
         {
-            os << "Alignement antenne ip x.x.x." << Sockets[i].IP.substr(Sockets[i].IP.rfind(".")+1);
-
-            value="delta_az";
-
-            if (readINI((char*)os.str().c_str(), (char*)value.c_str(), &delta_az,  (char*)fileName.c_str()))
-
-            value="delta_ha";
-
-            if (readINI((char*)os.str().c_str(), (char*)value.c_str(), &delta_ha,  (char*)fileName.c_str()))
-
-            if (delta_az && delta_ha)
+            newRA = newRA2;
+            newDEC = newDEC2;
+          
+            // Dans les modes d'alignement AFFINE et TAKI, on applique la matrice de correction
+            // sur les coordonnées horaires de l'objet visé
+
+            // il faut vérifier auparavent que la matrice de rotation est disponible
+            // pour l'antenne i
+
+            if  (Sockets[i].AlignementAntenne->Matrice_ok)
             {
-               // Si les corrections de l'antenne i ont été modifiées depuis le démarrage du programme
-               // -> on les applique...
-               if (Sockets[i].Delta.x != atol(delta_az) || Sockets[i].Delta.y != atol(delta_ha))
-               {
-                  Sockets[i].Delta.x = atol(delta_az);
-
-                  Sockets[i].Delta.y = atol(delta_ha);
-
-                  IDLog("Correction antenne ip %s  deltaAz=%i   deltaHa=%i\n", Sockets[i].IP.c_str(), Sockets[i].Delta.x, Sockets[i].Delta.y);
-               }
+                // On est bien dans le cas de l'allignement AFFINE ou Taki
+
+                if (Sockets[i].AlignementAntenne->MethodeAlignement ==  AFFINE ||
+                        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
+                    // z = 1.0
+                    // Voir la documentation pour plus d'explications sur le calcul affine/taki
+
+                    vect.x = VerifAngle( newRA2 - GetTSL() );
+                    vect.y = newDEC2;
+                    vect.z = 1.0;
+
+                    // Message pour l'utilisateur et les logs
+
+                    IDLog("Application de la matrice AFFINE/TAKI\nCoordonnees initiales: AD = %s  Dec = %s\n", DHMS(newRA2*N180divPi, true ).c_str(),
+                          DHMS(newDEC2*N180divPi, false ).c_str());
+
+                    // On applique la matrice de transformation
+
+                    switch (Sockets[i].AlignementAntenne->MethodeAlignement)
+                    {
+                    case AFFINE :
+                        Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionAffine(&result, vect);
+                        break;
+                    case TAKI   :
+                        Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionTaki( &result, vect);
+                        break;
+                    }
+
+                    // On récupÚre les nouvelles coordonnées. z ne nous intéresse pas
+
+                    newRA  = VerifAngle(result.x+GetTSL());
+                    newDEC = result.y;
+
+                    IDLog("Coordonnees finales: AD = %s  Dec = %s\n", DHMS(newRA*N180divPi, true ).c_str(),
+                          DHMS(newDEC*N180divPi, false ).c_str());
+                }               
             }
-
-            if (delta_az) {
-                delete [] delta_az;
-                delta_az=NULL;
+            else
+            {
+                if (Sockets[i].AlignementAntenne->AlignementEnCours)
+                {
+                    // Si la matrice n'est pas prête, c'est que la procédure d'alignement de l'antenne i n'est pas encore achevée.
+                    // On se contente ici d'appliquer des deltas en ascension droite et en déclinaison. Ces deltas sont envoyés de BAOcontrol
+                    // au driver indi_BAO par l'intermédiaire du fichier AlignementAntennes.cfg
+                    // Consultez la documentation pour comprendre le principe de fonctionnement de l'alignement et de la communication
+                    // entre les deux programmes
+
+                    newRA  = VerifAngle(newRA2  + Sockets[i].AlignementAntenne->delta_ad[Sockets[i].AlignementAntenne->nbrcorrections] * PasDeltaAD);
+                    newDEC = newDEC2 + Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections] * PasDeltaDe;
+
+                    IDLog("Alignement en cours.\nDelta RA=%i  delta Dec=%i\n", Sockets[i].AlignementAntenne->delta_ad[Sockets[i].AlignementAntenne->nbrcorrections], Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections]);
+                    IDLog("Nouvelles Coordonnées AD =%s  Dec = %s\n", DHMS(newRA*N180divPi, true).c_str(), DHMS(newDEC*N180divPi, false).c_str());               
+                }
             }
-
-            if (delta_ha) {
-                delete [] delta_ha;
-                delta_ha=NULL;
+                   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)
+
+            Azimut( newRA, newDEC, &targetAz, &targetAlt);
+
+            // Si la méthode d'alignement est la méthode SIMPLE, alors on doit cette fois-ci appliquer la matrice
+            // de correction au coordonnées horizontales et non aux coordonnées horaires comme ce que nous
+            // avons vu plus haut
+
+            if  (Sockets[i].AlignementAntenne->Matrice_ok && Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE)
+            {
+                // AprÚs s'être assurer que nous utilisons la méthode SIMPLE et que la matrice de rotation est ok
+
+                IDLog("Application de la matrice SIMPLE\nCoordonnees initiales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
+                      DHMS(targetAlt*N180divPi, false ).c_str());
+
+                // 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
+                // sphériques aux coordonnées rectangulaires
+                
+                
+
+                vect.x = cos(targetAz) * cos(targetAlt);
+                vect.y = sin(targetAz) * cos(targetAlt);
+                vect.z = sin(targetAlt);
+
+
+                // Application de la matrice SIMPLE
+                
+                Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionSimple(&result, vect);
+
+
+                // Là on doit repasser des coordonnées rectangulaires
+                // aux coordonnées sphériques
+
+                if (result.x != 0.0)
+                {
+                    targetAz = atan( result.y / result.x );
+                    
+                    if (result.x < 0) targetAz+=Pi;
+                }
+                else targetAz = Pidiv2;
+
+                targetAz  = VerifAngle(targetAz);
+
+                targetAlt = asin(result.z);
+
+
+                IDLog("Coordonnees finales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
+                      DHMS(targetAlt*N180divPi, false ).c_str());
             }
 
-            os.str("");
-        }
-    }
-    
-    return true;
-}
+            // Application du delta en azimut (préalablement réglé sur la polaire)
+            // Correspond à la variable AlignementAntenne->delta_az_polar
+            // Ne s'applique que pour les alignements AFFINE et TAKI
+
+            if (Sockets[i].AlignementAntenne->MethodeAlignement != SIMPLE) targetAz += Sockets[i].AlignementAntenne->delta_az_polar * PasDeltaAD;
+
+            // Correction de la réfraction atmosphérique
+
+            targetAlt = RefractionAtmospherique(targetAlt);
+
+            // On ajoute Pi pour que le sud soit à 0° d'azimut
+
+            targetAz = VerifAngle( targetAz + Pi );
+
+            // On convertit les angles précédents en degrés
+
+            targetAlt *= N180divPi;
+            targetAz  *= N180divPi;
+
+            // Affichage dans les logs
+
+            fs_sexa(AzStr, targetAz, 2, 3600);
+            fs_sexa(AltStr, targetAlt, 2, 3600);
+
+            IDLog("Coordonnees horizontales finales: Azi = %s  Haut= %s\n", AzStr, AltStr);
+
+
+            //Conversion des deux angles en pas codeurs
+
+            if ( targetAlt < HAUTMIN )
+            {
+                // L'objet est trop bas ( < 30°). On annule le suivi...
+
+                IDSetSwitch(&OnCoordSetSP, "Erreur ! L objet suivi est situe a moins de 30 deg au-dessus de l horizon. Goto annule.");
+
+                Suivi = false;
+
+                RealisationGoto = false;
+
+                InitAntennes();
+
+                return;
+            }
+            else
+            {
+                // Si la hauteur est supérieure à 90°, on doit ajouter 180° à l'azimut et corriger
+                // la hauteur en appliquant hauteur=180°-hauteur
+
+                if (targetAlt > 90.0)
+                {
+                    targetAlt = 180.0 - targetAlt;
+                    targetAz += 180.0;
+                }
+
+                // On applique la formule de Marc pour convertir la hauteur en nombre de pas codeur alt
+
+                Sockets[i].TargetPosition.y = (int) Arrondi( Alt2Motor( targetAlt ) );
+
+                //4000 pas pour 360° sur l'axe az
+
+                Sockets[i].TargetPosition.x = (int) Arrondi( targetAz * 4000.0 / 360.0);
+                
+                // Message de debug
+
+                IDLog("Nbre de pas codeurs Az = %i        Alt = %i\n", Sockets[i].TargetPosition.x, Sockets[i].TargetPosition.y);
+            }
+        }
+    }
+}
+
 
 
 /************************************************************************************
-* Retourne le nombre d'antennes connectées
-* 
+* Retourne le nombre d'antennes actuellement connectées
+*
 ************************************************************************************/
 
@@ -830 +1165 @@
     return num;
 }
+
 
 
@@ -839 +1175 @@
 void BAO::DeconnecterSocket(int num)
 {
-    IDLog("Deconnexion de l antenne : %s\n", Sockets[num].IP.c_str());
+    if (Sockets[num].Connected) IDLog("Deconnexion de l antenne : %s\n", Sockets[num].IP.c_str());
     Sockets[num].new_sock.shutdown();
     Sockets[num].Connected = false;
     Sockets[num].IP = "";
 }
+
+
 
 
@@ -877 +1215 @@
         gettimeofday(&tv, &tz);
 
-        double Annee=(double)(date.tm_year+1900);
-        double Mois=(double)(date.tm_mon+1);
-        double Jour=(double)date.tm_mday;
-        double Heu=(double)date.tm_hour;
-        double Min=(double)date.tm_min;
-        double Sec=(double)date.tm_sec+tv.tv_usec/1.0E6;
-        double UTCP=0.0;//(double)date.tm_isdst;
+        double Annee = (double)(date.tm_year + 1900);
+        double Mois  = (double)(date.tm_mon + 1);
+        double Jour  = (double)date.tm_mday;
+        double Heu   = (double)date.tm_hour;
+        double Min   = (double)date.tm_min;
+        double Sec   = (double)date.tm_sec+tv.tv_usec/1.0E6;
+        double UTCP  = 0.0;//(double)date.tm_isdst;
 
         // On transmet la date et l'heure à la classe Astro
@@ -892 +1230 @@
 
         CalculTSL();
-    }
-    
-    // On chargement les paramÚtres de corrections des antennes toutes les secondes
-    
-    if ( compt%1000 == 0 ) ChargementParametresAlignement("/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg");
+        
+        
+        // On charge les paramÚtres de correction des antennes toutes les demi-secondes
+
+        if ( compt%500 == 0  && tv.tv_usec/1.0E6 > 0.5 )
+        {
+            for (int i=1; i<SocketsNumber; i++)
+            {
+                if (Sockets[i].Connected)
+                {
+                    // Si l'antenne i est connectée, on charge les paramÚtres
+                    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);
+                }
+            }
+        }
+    }
+
 
 
@@ -946 +1298 @@
                         // on garde en stock la deuxiÚme partie de la trame
                         // pour un traitement ultérieur
+
                         buffereponse = reponse.substr(pos + 1);
 
                         // Partie traitée
+
                         reponse = reponse.substr(0, pos);
-                        
-                        IDLog("Reponse recue de %s : %s\n", Sockets[i].IP.c_str(), reponse.c_str());
+
+                        // on l'affiche dans le log
+
+                        IDLog("Reponse recue de %s : %s\n", Sockets[i].IP.c_str(), reponse.c_str());
 
                         // On vérifie ici les acknowledges
+
                         if ((reponse.find("ACK") != string::npos) && (reponse.find("NACK") == string::npos))
                         {
                             if (reponse.find("POSITION")  != string::npos)
                             {
-                                Sockets[i].ack_pos=true;
+                                Sockets[i].ack_pos   = true;
                             }
                             else if (reponse.find("GOTO") != string::npos)
                             {
-                                Sockets[i].ack_goto=true;
+                                Sockets[i].ack_goto  = true;
                             }
                             else if (reponse.find("PARK") != string::npos)
                             {
-                                Sockets[i].ack_park=true;
+                                Sockets[i].ack_park  = true;
                             }
                             else if (reponse.find("ABORT")!= string::npos)
                             {
-                                Sockets[i].ack_abort=true;
+                                Sockets[i].ack_abort = true;
                             }
                         }
                         else
                         {
-                            //réponse à la requête POSITION
+                            // Réponse à la requête POSITION
 
                             if (reponse.find("POSITION") != string::npos)
                             {
+                                // Il y a une erreur signalée par le microcontroleur
+
                                 if (reponse.find("NACK") != string::npos)
                                 {
-                                    //problÚme concernant la commande P
+                                    // ProblÚme concernant la commande P
+                                    // On affiche dans la boîte indi un voyant de couleur rouge
+                                    // et on affiche un message d'erreur
+
                                     OnCoordSetSP.s = IPS_ALERT;
+
                                     IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : position de l antenne inconnue !\n",
                                                 Sockets[i].IP.c_str());
+
+                                    // La position de l'antenne st donc inconnue
+
                                     Sockets[i].PosValides = false;
-                                    // Si la position de l'antenne est inconnue, on déconnecte l'antenne
+
+                                    // On déconnecte l'antenne
+
                                     Sockets[i].Connected  = false;
                                 }
                                 else if (Sockets[i].ack_pos)
-                                {                              
-                                    if ( Sockets[i].PosValides = (ExtractPosition(reponse, &Sockets[i].Pos) == true) )
-                                    {
-                                      OnCoordSetSP.s = IPS_OK;
-                                      IDSetSwitch(&OnCoordSetSP, "Antenne %s : POSITION OK  (x=%i, y=%i)\n",
-                                                Sockets[i].IP.c_str(), Sockets[i].Pos.x, Sockets[i].Pos.y);
-                                    }
-                                    else
-                                    {
-                                      OnCoordSetSP.s = IPS_ALERT;
-                                      IDSetSwitch(&OnCoordSetSP, "Antenne %s : La position n est pas valide !\n",
-                                                Sockets[i].IP.c_str());
-                                    }
-                                      
+                                {
+                                    // La position devrait être valide si on arrive ici...
+
+                                    if ( Sockets[i].PosValides = (ExtractPosition(reponse, &Sockets[i].Pos) == true) )
+                                    {
+                                        // La fonction extractPositon confirme que les positions transmises
+                                        // par le microcontrÃŽleur sont valides
+
+                                        OnCoordSetSP.s = IPS_OK;
+
+                                        // message dans les logs
+
+                                        IDSetSwitch(&OnCoordSetSP, "Antenne %s : POSITION OK  (x=%i, y=%i)\n",
+                                                    Sockets[i].IP.c_str(), Sockets[i].Pos.x, Sockets[i].Pos.y);
+                                    }
+                                    else
+                                    {
+                                        // Erreur repérée par la fonction ExtractPosition
+
+                                        OnCoordSetSP.s = IPS_ALERT;
+
+                                        // On en informe l'utilisateur
+
+                                        IDSetSwitch(&OnCoordSetSP, "Antenne %s : La position n est pas valide !\n",
+                                                    Sockets[i].IP.c_str());
+                                    }
                                 }
                             }
@@ -1013 +1393 @@
                                 if (reponse.find("NACK") != string::npos)
                                 {
+                                    // Une erreur  est retournée par le microcontroleur concernant la commande Park
+                                    // On affiche le voyant Park en rouge dans la boîte indi...
+
                                     ParkSP.s = IPS_ALERT;
+
+                                    // ... et on affiche un message d'erreur
+
                                     IDSetSwitch(&ParkSP, "ALERTE antenne %s : erreur PARK !\n", Sockets[i].IP.c_str());
                                 }
                                 else if (Sockets[i].ack_park && reponse.find("OK")!=string::npos)
                                 {
+                                    // PARK ok !
+
                                     ParkSP.s = IPS_OK;
+
                                     IDSetSwitch(&ParkSP, "Antenne %s : PARK OK\n",  Sockets[i].IP.c_str());
                                 }
@@ -1029 +1418 @@
                                 if (reponse.find("NACK") != string::npos)
                                 {
+                                    // Une erreur  est retournée par le microcontroleur concernant la commande Abort
+                                    // On affiche le voyant Park en rouge dans la boîte indi...
+
                                     AbortSlewSP.s = IPS_ALERT;
+
+                                    // ... et on affiche un message d'erreur
+
                                     IDSetSwitch(&AbortSlewSP, "ALERTE antenne %s : erreur ABORT !\n",  Sockets[i].IP.c_str());
                                 }
                                 else if (Sockets[i].ack_abort && reponse.find("OK")!=string::npos)
                                 {
+                                    // OK !
+
                                     AbortSlewSP.s = IPS_OK;
+
                                     IDSetSwitch(&AbortSlewSP, "Antenne %s : ABORT OK\n",  Sockets[i].IP.c_str());
                                 }
-
                             }
 
@@ -1046 +1443 @@
                                 if (reponse.find("NACK") != string::npos)
                                 {
+                                    // Une erreur  est retournée par le microcontroleur concernant la commande Goto
+                                    // On affiche le voyant Park en rouge dans la boîte indi...
+
                                     OnCoordSetSP.s = IPS_ALERT;
+
+                                    // Message d'erreur
+
                                     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
+
                                     DeconnecterSocket(i);
                                 }
@@ -1061 +1467 @@
                                         Sockets[i].GotoOk = true;
 
+                                        // Voyant en vert dans la boîte Indi
+
+                                        OnCoordSetSP.s = IPS_OK;
+
                                         // Message pour l'utilisateur
-                                        
-                                        OnCoordSetSP.s = IPS_OK;
+
                                         IDSetSwitch(&OnCoordSetSP, "Antenne %s : GOTO OK.\n",  Sockets[i].IP.c_str());
 
                                         // Fin du Goto pour toutes les antennes ?
-
-                                        int num=0;
+                                        // On compte les antennes connectées qui ont réalisé le dernier ordre goto
+
+                                        int num = 0;
 
                                         for (int j=1; j<SocketsNumber; j++)
-                                        {
-                                          if (Sockets[j].Connected)
+                                        {
+                                            if (Sockets[j].Connected)
                                             {
                                                 if (Sockets[j].GotoOk) num++;
                                             }
-                                        }
+                                        }
+
+                                        // Si le nombre d'antennes connectées est >0
+                                        // et que toutes les antennes connectées ont
+                                        // réalisé le goto alors...
 
                                         if ((num == AntennesConnectees()) && (num>0))
                                         {
-                                            // C'est bon ! Tout marche bien...
+                                            // C'est bon ! Tout marche bien...
                                             // On actualise l'AR et la dec dans la boîte de dialogue
 
@@ -1086 +1500 @@
                                             lastDEC = targetDEC;
 
-                                            // On a fini le mouvement. On attend le prochain goto...
-
-                                            ActualisationPosition=false;
+                                            // On a fini le mouvement. Il n'y a donc plus d'étape à faire
+                                            // dans le processus de réalisation d'un goto
+                                            // RealisationGoto vaut donc false
+
+                                            RealisationGoto = false;
 
                                             // Réinitialisation des paramÚtres des antennes en vue d'un prochain goto
@@ -1095 +1511 @@
 
                                             // On dessine les voyants de la boîte de dialogue en vert
+
                                             OnCoordSetSP.s = IPS_OK;
                                             EquatorialCoordsWNP.s = IPS_OK;
@@ -1100 +1517 @@
 
                                             // Confirmation dans la boîte de dialogue que toutes
-                                            // les antennes sont OK         
-                                            OnCoordSetSP.s = IPS_OK;
+                                            // les antennes sont OK
+
                                             IDSetSwitch(&OnCoordSetSP, "GOTO OK !");
-                                            
-                                            UpdateGoto=true;
-                                        }                                        
+
+                                            UpdatedGoto = true;
+                                        }
                                     }
                                 }
@@ -1113 +1530 @@
                         // On passe à la trame suivante si memreponse n'est pas vide
 
-                        reponse=buffereponse;
-                        pos=reponse.find("\n");
+                        reponse = buffereponse;
+                        pos     = reponse.find("\n");
                     }
                 }
                 catch (SocketException& e) //Aïe
                 {
+                    // Une exception concerne le socket i
+
+                    // On déconnecte l'antenne pour plus de sécurité
+
                     DeconnecterSocket(i);
 
@@ -1141 +1562 @@
             // pour réaliser un goto
 
-            ActualisationPosition = false;
+            RealisationGoto = false;
 
             // On envoie l'ordre ABORT Ã  toutes les antennes
@@ -1153 +1574 @@
             }
 
+            // Message à destination de l'utilisateur et des logs
+
             IDSetSwitch(&OnCoordSetSP, "ABORT OK !");
 
@@ -1161 +1584 @@
             //Pour permettre de refaire un abort
 
-            Abort=false;
+            Abort = false;
         }
 
@@ -1176 +1599 @@
             // pour réaliser un goto
 
-            ActualisationPosition = false;
+            RealisationGoto = false;
 
             // On envoie l'ordre PARK Ã  toutes les antennes
@@ -1196 +1619 @@
             //Pour permettre de refaire un park
 
-            Park=false;
+            Park = false;
         }
 
@@ -1203 +1626 @@
         // Gestion du suivi
 
-        if ((Suivi) && (UpdateGoto))
+        if ((Suivi) && (UpdatedGoto))
         {
             // Délais entre deux actualisations
 
-            double delai=ActualisationTM1 / 3600.0 / 24.0;   // Actualisation toutes les 15 minutes en mode transit
-
-            if (TrackingMode==2) delai=ActualisationTM2 / 3600.0 / 24.0;   //et 5 secs en mode tracking
+            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)
 
 
@@ -1216 +1639 @@
             if (GetJJ() - JJAnc > delai)
             {
-                UpdateGoto = false;
+                // Cette variable vaudra true lorsque le goto aura été réalisé
+
+                UpdatedGoto = false;
 
                 // Conversion des coordonnées en pas moteur
@@ -1226 +1651 @@
                 InitAntennes();
 
-                ActualisationPosition = true;
+                // On lance le processus d'actualisation du goto
+
+                RealisationGoto = true;
 
                 // On sauvegarde la date
@@ -1243 +1670 @@
                     if (Suivi) IDLog("Arrêt du suivi !");
 
-                    ActualisationPosition=false;
+                    RealisationGoto=false;
 
                     Suivi=false;
@@ -1254 +1681 @@
 
 
-        // Exécution de la procédure complÚte de lecture de la position de l'antenne
-        // puis envoi d'une commande Goto
-
-        if (ActualisationPosition)
+        // Exécution de la procédure complÚte d'un goto :
+        // 1Úre étape : envoi de la commande POSITION à toutes les antennes
+        // 2Úme étape : Vérification de l'acknowledge de la commande POSITION pour chaque antenne
+        // 3Úme étape : Les positions retournées par les antennes sont-elles valides ?
+        // 4Úme étape : Si oui, envoie de la commande goto à toutes les antennes
+        // 5Úme étape : est-ce que toutes les antennes ont envoyé l'acknowledge de la commande goto ?
+        // 6Úme étape : les antennes ont toutes répondu GOTO OK !
+
+        if (RealisationGoto)
         {
             for (int i=1; i<SocketsNumber; i++)
             {
+                // On ne parle qu'aux antennes connectées
+
                 if (Sockets[i].Connected)
                 {
+                    // En fonction de l'étage de la réalisation d'un goto par l'antenne i
+
                     switch (Sockets[i].etape)
                     {
 
-                        //Envoi de la commande POS
+                        // Envoi de la commande POS
 
                     case 0 :
                     {
+                        // On doit intialiser l'acknowledge à false
+
                         Sockets[i].ack_pos    = false;
+
+                        // et considérer que la position de l'antenne n'est pas valide
+
                         Sockets[i].PosValides = false;
 
+                        // avant d'envoyer l'ordre POSITION
+
                         if (!POSITION(i)) Sockets[i].sendalertes++;
+
+                        // On passe à l'étage suivante
 
                         Sockets[i].etape++;
@@ -1286 +1731 @@
                         if (Sockets[i].ack_pos)
                         {
-                            // tout marche bien
+                            // tout marche bien. On a bien reçu l'acknowledge de l'antenne i
+
+                            // Il n'y a donc aucune attente supplémentaire pour recevoir la réponse
                             Sockets[i].AttenteExecution = 0;
+
+                            // Pas d'anomalie à consigner
                             Sockets[i].AnomaliesExecution = 0;
+
+                            // On passe à l'étape suivante
                             Sockets[i].etape++;
-                            i--; //permet de revenir sur ce même socket malgré la boucle
-                            // -> plus rapide
+
+                            //permet de rester sur le même socket malgré la boucle -> plus rapide
+                            i--;
                         }
                         else
                         {
-                            // on réitÚre l'ordre précédent si rien ne se passe
+                            // On réitÚre l'ordre précédent si rien ne se passe
 
                             // On garde une trace de l'anomalie
+
                             Sockets[i].AttenteExecution++;
 
                             if (Sockets[i].AttenteExecution > MAXATTENTE)
                             {
-                                // on recommence depuis le début
+                                // on recommence depuis le début.
+                                // Peut-être que l'antenne n'a pas reçu l'ordre ?
                                 Sockets[i].etape = 0;
                                 Sockets[i].AttenteExecution = 0;
+
+                                // Pas de réponse. On consigne une erreur grave
                                 Sockets[i].AnomaliesExecution++;
                             }
 
-                            // Toujours rien -> plus sérieux : il faut déconnecter l'antenne
+                            // Les erreurs graves s'accumulent. Pas de réponse aprÚs plusieurs minutes
+                            // Il faut déconnecter l'antenne
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
                             {
-                                OnCoordSetSP.s = IPS_ALERT;
+                                //Voyant en rouge dans la boîte Indi
+
+                                OnCoordSetSP.s = IPS_ALERT;
+
+                                //Message à l'attentnio 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());
+Deconnexion de l antenne.", Sockets[i].IP.c_str());
+
+                                // On déconnecte l'antenne
                                 DeconnecterSocket(i);
                             }
@@ -1327 +1790 @@
                         if (Sockets[i].PosValides)
                         {
+                            // Tout vas bien
+                            // On ne consigne aucune anomalie
                             Sockets[i].AttenteExecution = 0;
                             Sockets[i].AnomaliesExecution = 0;
-                            Sockets[i].etape++; // on passe à l'étape suivante
+
+                            //On passe à l'étape suivante
+                            Sockets[i].etape++;
                         }
                         else
                         {
                             // on réitÚre l'ordre précédent si rien ne se passe
+
                             Sockets[i].AttenteExecution++;
 
                             if (Sockets[i].AttenteExecution > MAXATTENTE)
                             {
-                                // on attend encore la réponse posvalides                                
+                                // on attend encore la réponse posvalides
+
                                 Sockets[i].etape = 2;
                                 Sockets[i].AttenteExecution = 0;
+
+                                // On consigne une erreur grave. L'antenne tarde à répondre
                                 Sockets[i].AnomaliesExecution++;
                             }
 
+                            // Aucune réponse de l'antenne depuis plusieurs minutes
+                            // On la déconnecte
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
                             {
-                                OnCoordSetSP.s = IPS_ALERT;
+                                // Voyant en rouge
+
+                                OnCoordSetSP.s = IPS_ALERT;
+
+                                //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());
+Deconnexion de l antenne.", Sockets[i].IP.c_str());
+
+                                //Déconnexion de l'antenne
                                 DeconnecterSocket(i);
                             }
@@ -1354 +1833 @@
                     }
                     break;
+
+
+
+                    // On peut remarquer qu'il n'y a pas de case 3 ici...
+                    // L'envoie de la commande goto se fait portant pendant l'étape 3 en dehors du switch
+                    // Voir le code plus loin...
 
 
@@ -1373 +1858 @@
                             if (Sockets[i].AttenteExecution > MAXATTENTE)
                             {
-                                // On prolonge l'attente                                
+                                // On prolonge l'attente pour recevoir l'acknowledge du goto
                                 Sockets[i].etape = 4;
                                 Sockets[i].AttenteExecution = 0;
@@ -1381 +1866 @@
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
                             {
-                                OnCoordSetSP.s = IPS_ALERT;
-                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : pas d acknowledge recu apres l ordre GOTO. \
-    Deconnexion de l antenne.", Sockets[i].IP.c_str());
+                                OnCoordSetSP.s = IPS_ALERT;
+
+                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : pas d acknowledge recu apres l ordre GOTO. Deconnexion de l antenne.", Sockets[i].IP.c_str());
+
                                 DeconnecterSocket(i);
                             }
@@ -1397 +1883 @@
                         if (Sockets[i].GotoOk)
                         {
+                            // On a bien reçu Goto Ok pour l'antenne i !
+
                             Sockets[i].AttenteExecution = 0;
                             Sockets[i].AnomaliesExecution = 0;
+
+                            //On passe à l'étape suivante
                             Sockets[i].etape++;
                         }
@@ -1408 +1898 @@
                             if (Sockets[i].AttenteExecution > MAXATTENTE)
                             {
-                                // On prolonge l'attente
-                                
+                                // On prolonge l'attente afin de recevoit un GOTO OK
+
                                 Sockets[i].etape = 5;
                                 Sockets[i].AttenteExecution = 0;
@@ -1415 +1905 @@
                             }
 
-                            // 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 coonfirmation du goto au bout de 2 minutes
                             if (Sockets[i].AnomaliesExecution > MAXANOMALIESGOTO)
                             {
-                                OnCoordSetSP.s = IPS_ALERT;
-                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : l antenne n a pas renvoye GOTO/OK. \
-    Deconnexion de l antenne.", Sockets[i].IP.c_str());
+                                // Alerte sur une antenne
+                                OnCoordSetSP.s = IPS_ALERT;
+
+                                // Message d'erreur
+                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : l antenne n a pas renvoye GOTO/OK. Deconnexion de l antenne.", Sockets[i].IP.c_str());
+
+                                //Déconnexion de l'antenne
                                 DeconnecterSocket(i);
                             }
@@ -1433 +1927 @@
 
         ///////////////////////////////////////
-        //On attend que toutes les antennes soient prêtes pour lancer l'ordre Goto -> meilleure synchronisation
-
-        int num=0;
+        // Traitement de l'étape 3 de la réalisation d'un goto
+        // 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)
+        // -> meilleure synchronisation
+
+        // On compte les antennes rendues à l'étape 3 et qui attendent
+
+        int num = 0;
 
         for (int i=1; i<SocketsNumber; i++)
         {
+            // Uniquement les antennes connectées
+
             if (Sockets[i].Connected)
             {
-                if (Sockets[i].etape == 3) num++; //fin de la procédure ActualisationPosition.
-                // num antennes sont prêtes à recevoir l'ordre GOTO
+                if (Sockets[i].etape == 3) num++; // num antennes sont prêtes à recevoir l'ordre GOTO
             }
         }
+
+        // Toutes les antennes connectées sont prêtes à recevoir l'ordre goto
 
         if ((num == AntennesConnectees()) && (num>0))
@@ -1452 +1955 @@
                 if (Sockets[i].Connected)
                 {
+                    // On envoie l'ordre
+
                     Sockets[i].ack_goto = false;
                     Sockets[i].AttenteExecution = 0;
                     Sockets[i].AnomaliesExecution = 0;
 
-                    if (!GOTO(i, TargetPosition.x - Sockets[i].Pos.x - Sockets[i].Delta.x, TargetPosition.y - Sockets[i].Pos.y - Sockets[i].Delta.y)) Sockets[i].sendalertes++;
+                    if (!GOTO(i, Sockets[i].TargetPosition.x - Sockets[i].Pos.x, Sockets[i].TargetPosition.y - Sockets[i].Pos.y )) Sockets[i].sendalertes++;
 
                     Sockets[i].etape++;
@@ -1464 +1969 @@
 
         ///////////////////////////////////////
-        // Détection d'anomalies sur la socket. Déconnexion du micro-cont ?
+        // Opération garbage
+        // Détection d'anomalies sur le socket i.
+        // Ce n'est pas normal ici. Il faut déconnecte l'antenne
 
         for (int i=1; i<SocketsNumber; i++)
@@ -1472 +1979 @@
                 if (Sockets[i].sendalertes > 0)
                 {
-                    OnCoordSetSP.s = IPS_ALERT;
+                    // Alarme dans la boîte Indi
+
+                    OnCoordSetSP.s = IPS_ALERT;
+
+                    // Erreur dans les logs
+
                     IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : deconnexion de l antenne.", Sockets[i].IP.c_str());
+
+                    // Déconnexion antenne
 
                     DeconnecterSocket(i);
@@ -1480 +1994 @@
         }
     }
-    
+
     //incrémentation du compteur
+
     compt++;
 }
@@ -1511 +2026 @@
         InitAntennes();
 
+        // On garde la trace du début du Goto pour enchainer les actualisations
+
         JJAnc = GetJJ();
-        
-        ADDEC2Motor(targetRA, targetDEC);
+
+        // Conversion des coordonnées horaires en pas moteur
+
+        ADDEC2Motor(targetRA, targetDEC);
+
+        // Mode transit activé
 
         TrackingMode = 1;
 
+        // On suit un objet
+
         Suivi = true;
 
-        UpdateGoto = false;
-
-        ActualisationPosition = true;
+        // Aucun goto n'a été encore réalisé
+
+        UpdatedGoto = false;
+
+        // Mais on se lance dans la réalisation d'un goto
+
+        RealisationGoto = true;
 
         break;
@@ -1539 +2066 @@
         InitAntennes();
 
-        JJAnc=GetJJ();
-        
-        ADDEC2Motor(targetRA, targetDEC);
+        JJAnc = GetJJ();
+
+        ADDEC2Motor(targetRA, targetDEC);
 
         TrackingMode = 2;
@@ -1547 +2074 @@
         Suivi = true;
 
-        UpdateGoto = false;
-
-        ActualisationPosition = true;       
+        UpdatedGoto = false;
+
+        RealisationGoto = true;
 
         break;
@@ -1581 +2108 @@
 
         // On lance le thread !
-
-        Exit=false;
+        // Exit ne faudra true que lorsque sera venu le moment de sortir !
+
+        Exit = false;
+
+        // Création du thread
 
         if (pthread_create (&th1, NULL, (void*(*)(void*))LancementThread, this) < 0)
@@ -1592 +2122 @@
 
     case ISS_OFF:
-
-        // On sort du thread
-
-        Exit = true;
-        sleep(1);
-        pthread_join (th1, NULL);
-        InitThreadOK = false;
 
         // Etat des voyants
@@ -1621 +2144 @@
         SocketsNumber = 1;
 
+        // On sort du thread
+
+        // On dit au thread de sortir de la boucle
+
+        Exit = true;
+
+        // Désactiver la boucle de traitement des messages des ISPOLL
+
+        InitThreadOK = false;
+
+        // On laisse 1 s au thread pour sortir de la boucle
+
+        sleep(1);
+
+        // On détruit le thread
+
+        pthread_join (th1, NULL);
+
+        // on sort du programme
+
+        exit(EXIT_SUCCESS);
+
         break;
     }
@@ -1630 +2175 @@
 /**************************************************************************************
 **  Envoie une commande sur le socket numsocket
+**
 ***************************************************************************************/
 
@@ -1639 +2185 @@
     {
         sprintf(chaine, "%s%s\n", Commande, Params);
-        
-        Sockets[numsocket].new_sock << chaine;
-        
-        IDLog("Commande envoyee a %s: %s", Sockets[numsocket].IP.c_str(), chaine);
+
+        Sockets[numsocket].new_sock << chaine;
+
+        IDLog("Commande envoyee a %s: %s", Sockets[numsocket].IP.c_str(), chaine);
     }
     catch (SocketException& e)
     {
+        // Consignation d'une anomalie sur le socket
+
         DeconnecterSocket(numsocket);
 
@@ -1661 +2209 @@
 /**************************************************************************************
 ** Commande POSITION
+**
 ***************************************************************************************/
 
@@ -1670 +2219 @@
 /**************************************************************************************
 ** Commande PARK
+**
 ***************************************************************************************/
 
@@ -1679 +2229 @@
 /**************************************************************************************
 ** Commande ABORT
+**
 ***************************************************************************************/
 
@@ -1689 +2240 @@
 /**************************************************************************************
 ** Commande GOTO
+**
 ***************************************************************************************/
 
@@ -1700 +2252 @@
     sensAz  = 1;
 
+    // gestion des signes des deltas
+
     if ( deltaAz < 0 )
     {
@@ -1713 +2267 @@
 
     // Vérification du nombre de pas à faire au niveau de l'axe azimut
-    // Rappel : un tour complet autour de l'axe az fait 4000 pas codeur (#define NBREPASCODEURSAZ dans BAO.h)
-
-    // problÚme 1 : si deltaAz > à un demi-tours - soit 2000 pas alors
+    // Rappel : un tour complet autour de l'axe az fait 4000 pas codeur (voir #define NBREPASCODEURSAZ dans BAO.h)
+
+    // 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
 
@@ -1730 +2284 @@
     {
         deltaAz = NBREPASCODEURSAZ - deltaAz;
+
         sensAz = 1 - sensAz;
     }
@@ -1735 +2290 @@
     //on envoie les coordonnées au driver
 
-    if (sensAz == 1 )  sensAz='f'; else sensAz='b';
-    
-    if (sensAlt == 1 ) sensAlt='f'; else sensAlt='b';
+    (sensAz == 1 ) ? sensAz='f' : sensAz='b';
+
+    (sensAlt == 1 ) ? sensAlt='f': sensAlt='b';
 
     sprintf(Params, "%c%04i%c%04i", sensAz, deltaAz, sensAlt, deltaAlt);
@@ -1838 +2393 @@
 
 
-/**************************************************************************************
-**
-***************************************************************************************/
-void BAO::get_initial_data()
-{
-    //  IDSetNumber (&EquatorialCoordsRNP, NULL);
-}
-
-/**************************************************************************************
-**
-***************************************************************************************/
-void BAO::slew_error(int slewCode)
-{
-    OnCoordSetSP.s = IPS_IDLE;
-
-    if (slewCode == 1)
-        IDSetSwitch (&OnCoordSetSP, "Object below horizon.");
-    else if (slewCode == 2)
-        IDSetSwitch (&OnCoordSetSP, "Object below the minimum elevation limit.");
-    else
-        IDSetSwitch (&OnCoordSetSP, "Slew failed.");
-}
 
 /**************************************************************************************
@@ -1929 +2462 @@
 
 
+