Changeset 619 for BAORadio

Timestamp:

Dec 4, 2011, 7:51:30 PM (13 years ago)

Author:

frichard

Message:

 

Location:

BAORadio/libindi/libindi

Files:

• BAOControl/Makefile (modified) (2 diffs)
• BAOControl/baocontrol.cpp (modified) (24 diffs)
• BAOControl/baocontrol.h (modified) (8 diffs)
• BAOControl/filetools.cpp (modified) (15 diffs)
• BAOControl/result (modified) (2 diffs)
• CMakeLists.txt (modified) (1 diff)
• drivers/telescope/BAO.cpp (modified) (42 diffs)
• drivers/telescope/BAO.h (modified) (6 diffs)

BAORadio/libindi/libindi/BAOControl/Makefile

@@ -2 +2 @@
 #
 
-CC = g++ 
-#CFLAGS = -g 
-#CXXFLAGS = -g
+CC = g++
+#debug
+CFLAGS = -g 
+CXXFLAGS = -g 
 
-BAOcontrol_objects =  main.o baocontrol.o ClientSocket.o Socket.o filetools.o exception.o ../drivers/telescope/astro.o
+BAOcontrol_objects =  main.o baocontrol.o ClientSocket.o Socket.o filetools.o exception.o
 
 
@@ -13 +14 @@
 
 BAOcontrol: $(BAOcontrol_objects)
-        g++  -o BAOcontrol $(BAOcontrol_objects) -lpthread -lX11
+        g++ $(CXXFLAGS) -c -o ../BAOControl/astro.o ../drivers/telescope/astro.cpp
+        g++ $(CXXFLAGS) -o BAOcontrol $(BAOcontrol_objects) astro.o -lpthread -lX11
 
 Socket:  Socket.cpp
 ClientSocket: ClientSocket.cpp
-Astro: ../drivers/telescope/astro.cpp
 baocontrol: baocontrol.cpp
+filetools: filetools.cpp
+exception: exception.c
 main: main.cpp
 

BAORadio/libindi/libindi/BAOControl/baocontrol.cpp

@@ -4 +4 @@
 /* Franck RICHARD             */
 /* franckrichard033@gmail.com */
-/* Juin 2011                  */
+/* Décembre 2011              */
 /******************************/
 
 
 #include "baocontrol.h"
+#include <termios.h>
+#include <unistd.h>
 
 
@@ -31 +33 @@
  * Laboratoire de l'Accélérateur Linéaire *\n \
  *                                        *\n \
- *             v0.2  20/06/2011           *\n \
+ *             v0.4  02/12/2011           *\n \
  *        franckrichard033@gmail.com      *\n \
  ******************************************\n\n\n", true);
@@ -41 +43 @@
     delaitracking = 0;
     lognum        = 0;
-    numAntenne    = 0;
+    numAntennes   = 0;
     numobjets     = 0;
     runnum        = 1;
@@ -72 +74 @@
         Antennes[i].ok=0;
         Antennes[i].ip=0;
+        Antennes[i].delta_az=0;
+        Antennes[i].delta_ha=0;
     }
 
@@ -123 +127 @@
 {
     // destruction des tableaux
-
+    
     delete [] Antennes;
     delete [] objets;
 
-    // destruction de la fenêtre graphique, des caractÚres
+    // destruction de la fenêtre graphique,des caractÚres
 
     if (d!=NULL)
@@ -417 +421 @@
         {
             // On ne garde que la partie intéressante
-            // La partie suivant "message="...
+            // La partie "message="...
             reponse = reponse.substr(reponse.find("message") + 9);
 
@@ -426 +430 @@
 
             // On récupÚre l'adresse ip de l'antenne qui nous parle
-            // et on met à jour le tabmeau des états des antennes
+            // et on met à jour le tableau des états des antennes
 
             if (reponse.find(". (Antennes connectees")!=string::npos)
             {
-                decomp=reponse.substr(0, reponse.find(". (Antennes connectees"));
-                decomp=decomp.substr(decomp.rfind(".")+1);
+                decomp = reponse.substr(0, reponse.find(". (Antennes connectees"));
+                decomp = decomp.substr(decomp.rfind(".")+1);
 
                 // si cette antenne est déjà connectée, on change son état
-
-                for (int i=0; i<numAntenne; i++)
+                
+                if (atoi(decomp.c_str())!=0) for (int i=0; i<numAntennes; i++)
                 {
                     if (atoi(decomp.c_str()) == Antennes[i].ip)
@@ -449 +453 @@
                 if (!test)
                 {
-                    Antennes[numAntenne].ip = atoi(decomp.c_str());
-                    Antennes[numAntenne++].ok = 1;
+                    Antennes[numAntennes].ip = atoi(decomp.c_str());
+                    Antennes[numAntennes++].ok = 1;
                 }
             }
@@ -462 +466 @@
                 decomp = decomp.substr(decomp.rfind(".") + 1);
 
-                for (int i=0; i<numAntenne; i++)
+                for (int i=0; i<numAntennes; i++)
                 {
                     if (atoi(decomp.c_str()) == Antennes[i].ip)
@@ -498 +502 @@
 
 
+
 /**************************************************************************************
 ** Est-ce que la réponse du pilote indi_BAO est conforme à ce que l'on attendait ?
@@ -596 +601 @@
     DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
 
-
-    // On lance le calcul
+    // On lance les calculs
 
     CalculTSL();
@@ -627 +631 @@
 
         // Faut-il executer un fichier de mouvements ?
-        // il faut qu'il y ait plus d'un mouvement
-        // et exxecuter les commande dans ce test jusqu'au dernier mouvement
 
         if (run && numobjets>1 && runnum<numobjets)
@@ -637 +639 @@
             if (JJ >= objets[runnum].JJ && !objets[runnum].exec)
             {
-                // petits messages pour l'utilisateur
-
-                if (runnum==1) Affiche("Début de l'exécution du fichier de mouvements\n\n", true);
+                // petit message pour l'utilisateur
+
+                if ( runnum == 1 ) Affiche("Début de l'exécution du fichier de mouvements\n\n", true);
 
                 os << "Suivi de l'objet n°" << runnum << endl;
@@ -677 +679 @@
                     // on réinitiale toutes les variables impliquées dans la commande run
 
-                    run=false;
-                    runnum=1;
-                    numobjets=1;
+                    run         = false;
+                    runnum      = 1;
+                    numobjets   = 1;
 
                     // On sort du programme dans le cas BAOControl -r fileName
@@ -718 +720 @@
     return 0;
 }
-
 
 
@@ -752 +753 @@
         while (chaine[0] == ' ') chaine = chaine.substr(1);
 
-        // si on veut prendre les deux arguments d'un commande
+        // si on veut prendre les deux arguments d'une commande
 
         if (chaine2 != NULL)
@@ -775 +776 @@
         {
             // on prend tout d'un bloc aprÚs la commande -> chaine 1
-            // utile pour une commande ty type goto m 42 qui doit retourner "m 42" dans une
+            // utile pour une commande du type "goto m 42" qui doit retourner "m 42" dans une
             // même chaine
 
@@ -794 +795 @@
 {
     // la communication avec le pilote indi_BAO
-    // se fait par l'envoie de petit fichier xml
+    // se fait par l'envoie de fichiers xml
     // d'où le cÎté complexe des commandes
 
@@ -936 +937 @@
     // à l'époque de l'observation
 
-    if (J2000)
+    if ( J2000 )
     {
         Precession(&arf, &decf);
@@ -1071 +1072 @@
     {
         Affiche("BAOcontrol s'est bien déconnecté du pilote indi_BAO.\n\n", true);
+    }
+
+    return true;
+}
+
+
+/**************************************************************************************
+** Gestion du clavier en mode raw pour la procédure d'alignement
+***************************************************************************************/
+
+void mode_raw(int activer)
+{
+    static struct termios cooked;
+    static int raw_actif = 0;
+    
+    if (raw_actif == activer)
+        return;
+    
+    if (activer)
+    {
+        struct termios raw;
+        
+        tcgetattr(STDIN_FILENO, &cooked);
+        
+        raw = cooked;
+        cfmakeraw(&raw);
+        tcsetattr(STDIN_FILENO, TCSANOW, &raw);
+    }
+    else
+        tcsetattr(STDIN_FILENO, TCSANOW, &cooked);
+    
+    raw_actif = activer;
+}
+
+
+/**************************************************************************************
+** Alignement de l'antenne située à l'adresse ip
+***************************************************************************************/
+
+bool BAOcontrol::Alignement(string ip)
+{
+   bool test=false;
+   
+   int i;
+   
+   if (ip.rfind(".") != string::npos) ip=ip.substr(ip.rfind(".")+1);
+   
+   for (i=0; i<numAntennes; i++)
+   {
+      if (atoi(ip.c_str()) == Antennes[i].ip) { test=true; break; }
+   }
+  
+   if ((test) && (atoi(ip.c_str())!=0))
+   {
+         Affiche("Début de l'alignement de l'antenne.\n \
+         Appuyez sur les touches Z,Q,D,X pour centrer l'objet dans le viseur.\n \
+         (ESC pour arrêter et valider).\n\n", true);
+         
+         int c = 0;
+         
+         while (c!=27)
+         {
+           mode_raw(1);
+           
+           c = getchar();
+           
+           mode_raw(0);
+           
+           switch(c)
+           {
+             case 122 : Antennes[i].delta_ha++; Affiche("delta_ha + 1\n", true); break;
+             case 100 : Antennes[i].delta_az++; Affiche("delta_az + 1\n", true); break;
+             case 113 : Antennes[i].delta_az--; Affiche("delta_az - 1\n", true); break;
+             case 120 : Antennes[i].delta_ha--; Affiche("delta_ha - 1\n", true); break;
+           }  
+           
+           // Enregistrement des paramÚtres d'alignement des antennes
+    
+           EnregistrementParametresAlignement("/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg");
+         }          
+   }  
+   else
+   {
+         Erreur("L'antenne située à l'adresse ip indiquée n'existe pas\n\n");
+         
+         return false;
+   }
+    
+   return true;
+}
+
+
+/**************************************************************************************
+** Sauvegarde des paramÚtres d'alignement des antennes
+***************************************************************************************/
+
+bool BAOcontrol::EnregistrementParametresAlignement(string fileName)
+{
+    string section;
+    string key;
+    string value;
+    char ip[100];
+
+    stringstream os;
+
+    //Affiche("Enregistrement de l'alignement des antennes dans le fichier " + fileName + "\n", true);
+
+    //Enregistrement des corrections des l'antennes
+
+    for (int i=0; i< numAntennes; i++)
+    {
+        sprintf(ip, "%i", Antennes[i].ip);
+        os << "Alignement antenne ip x.x.x." << (string)ip;
+        section = os.str();
+        os.str("");
+        key     = "delta_az";
+        os << Antennes[i].delta_az;
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        key     = "delta_ha";
+        os << Antennes[i].delta_ha;
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
     }
 
@@ -1603 +1732 @@
         }
     }
+    
+    // correction de l'alignement d'une antenne par rapport à l'objet visé
+
+    if (chaine.find("align")!=string::npos)
+    {
+        string antenne;
+
+        CommandeOK = true;
+
+        if (DecompositionCommande(chaine, "align", &antenne, NULL))
+        {
+            Alignement(antenne);
+        }
+        else
+        {
+            Erreur("Erreur align : la commande align doit être suivie par l'ip de l'antenne qui faut aligner.\n\n");
+        }
+    }
 
     // Aide du programme
@@ -1628 +1775 @@
         cout << "                    Goto sun permet de suivre le soleil." << endl;
         cout << "search nom_objet :  interroge le serveur NED sur internet et retourne les coordonnées de l'objet." << endl;
+        cout << "align ip :          lance la procédure d'alignement de l'antenne d'adresse ip." << endl;
         cout << "transit :           active le mode de suivi transit." << endl;
         cout << "tracking :          active le mode de suivi tracking." << endl;
@@ -1818 +1966 @@
 
 /**************************************************************************************
-** Lecteur d'un fichier ligne aprÚs ligne
+** Lecture d'un fichier ligne aprÚs ligne
 ** retourne -1 Ã  la fin
 ***************************************************************************************/
@@ -2135 +2283 @@
 
             // on décode et exécute les commandes
-            DecodageEntreesUtilisateur(chaine);
+            DecodageEntreesUtilisateur(chaine);    
+            
         }
         while (NoExit);

BAORadio/libindi/libindi/BAOControl/baocontrol.h

@@ -23 +23 @@
 #include <sys/time.h>
 
-
 // couleurs utilisées dans le terminal
 
@@ -38 +37 @@
 
 
-// limites des tableaux
+// dimensions des tableaux
 
 #define MAXLOG 1000
@@ -45 +44 @@
 
 
-//dimensions de la fenêtre graphique
+// dimensions de la fenêtre graphique
 
 #define haut_fenetre 10+22*10
@@ -58 +57 @@
 
     char ok;                            // actuellement disponible ?
+    
+    long delta_az;
+    
+    long delta_ha;
 };
 
@@ -64 +67 @@
 struct DefObjets
 {
-    double JJ;                          // Jour julien où le télescope doit aller pointer vers l'objet
+    double JJ;                          // Date julienne où le télescope doit aller pointer l'objet
     double Duree;                       // Durée de l'observation de l'objet en sec
     string ad;                          // Ascension droite J2000 de l'objet
@@ -103 +106 @@
     bool Connect(bool connect);
     bool LectureFichierMouvements(string fileName);
+    bool EnregistrementParametresAlignement(string fileName);
     void DecodageEntreesUtilisateur(string chaine);
     bool Run(string fichier);
@@ -108 +112 @@
     Coordonnees ServeurNED(string objet);
     int  readline (FILE * pfile, char *tab);
+    bool Alignement(string ip);
 
 
@@ -122 +127 @@
     int delaitracking;                          // Délai entre deux actualisations de la position en mode tracking
     int lognum;                                 // Nbre d'enregistrements dans le tableau logs
-    int numAntenne;                             // Nbre d'antennes connectées
+    int numAntennes;                            // Nbre d'antennes connectées
     int numobjets;                              // Nbre d'objets dans le dernier fichier de mouvements chargé
     int runnum;                                 // Numéro de l'objet actuellement visé dans le fichier de mouvement
 
     double Pression;                            // Pression atmosphérique en mBar
-    double Temperature;                         // température de l'atmosphÚre
+    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à 

BAORadio/libindi/libindi/BAOControl/filetools.cpp

@@ -84 +84 @@
             delete prev;
 
-
         } while (pKey!=keyprev);
  
-        if (pSection->name) delete []pSection->name;
+        if (pSection->name) delete [] pSection->name;
 
         secprev=pSection;
@@ -222 +221 @@
  ******************************************************/
 
-/*
+
 
 char * writeINI (char *sectionName, char *keyName, char *keyValue, char *fileName)
@@ -229 +228 @@
   char *pKeyName = NULL;
   char *pKeyValue = NULL;
-  INI *pIni = NULL;
+  INI  *pIni = NULL;
   SECTION *pSection = NULL;
   KEY *pKey = NULL;
   TRY
   {
-    pKeyName = (char *) m_malloc (sizeof (char) * strlen (keyName) + 1);
-    pSectionName =
-      (char *) m_malloc (sizeof (char) * strlen (sectionName) + 3);
+    pKeyName = new char [sizeof (char) * strlen (keyName) + 1];
+    pSectionName = new char [sizeof (char) * strlen (sectionName) + 3];
     if (keyValue != NULL)
       {
-        pKeyValue = (char *) m_malloc (sizeof (char) * strlen (keyValue) + 1);
+        pKeyValue = new char [sizeof (char) * strlen (keyValue) + 1];
         strcpy (pKeyValue, keyValue);
         pKeyValue[strlen (keyValue)] = '\0';
@@ -245 +243 @@
     else
       {
-        pKeyValue = (char *) m_malloc (sizeof (char));
+        pKeyValue = new char [sizeof (char)];
         pKeyValue[0] = '\0';
       }
@@ -255 +253 @@
     //chargement
     pIni = _loadINI (fileName);
-
   }
   CATCH (ERR_FOPEN)
@@ -277 +274 @@
       if (pKey != NULL)
         {
-          pKey->value =
-            (char *) realloc (pKey->value,
-                              sizeof (char) * strlen (pKeyName) + 1);
+          if (pKey->value != NULL) { delete [] pKey->value; pKey->value = NULL; pKey->value = new char [sizeof (char) * strlen (pKeyValue) + 1]; }
+          
           if (pKey->value == NULL)
             {
@@ -296 +292 @@
   else
     {
-      //section pas trouve, on la cree avec sa cle
+       //section pas trouve, on la cree avec sa cle
       pSection = _newSECTION (pSectionName);
       _addSECTION (pIni, pSection);
@@ -305 +301 @@
   TRY
   {
-
     //sauvegarde
     _saveINI (pIni);
@@ -312 +307 @@
   CATCH (ERR_FOPEN)
   {
-    printf ("erruer sur le fichier %s", pIni->fileName);
+    printf ("erreur sur le fichier %s", pIni->fileName);
   }
   ENDTRY;
 
   //nettoyage
-
-  free (pIni);
-  free (pSection);
-  free (pKey);
-  free (pKeyName);
-  free (pSectionName);
+  if (pKey->value != NULL) delete [] pKey->value; 
+  if (pKey != NULL) delete [] pKey;
+  if (pKeyName != NULL) delete [] pKeyName;
+  if (pSectionName != NULL) delete [] pSectionName;
+  if (pIni != NULL) delete [] pIni;
+  if (pSection != NULL) delete [] pSection;
   pIni = NULL;
   pKeyName = NULL;
@@ -328 +323 @@
   return pKeyValue;
 }
-*/
+
 
 /******************************************************
@@ -756 +751 @@
 ******************************************************/
 
-/*
- * int
+
+ int
 _saveINI (INI * pIni)
 {
@@ -787 +782 @@
               TRY
               {
-                str = (char *) m_malloc (sizeof (char) * offset);
+                str = new char [sizeof (char) * offset];
               }
               CATCH (ERR_MALLOC)
@@ -805 +800 @@
               pKey_pred = pKey;
               pKey = pKey->next;
-              free (str);
+              delete [] str;
             }
           while (pKey != pKey_pred);
@@ -816 +811 @@
   //nettoyage
   fclose (pFile);
-}*/
+}
 
 /******************************************************
@@ -859 +854 @@
     /* on lit ligne par ligne */
     nbRead = readline (pFile, pBuf);
-    if (nbRead==-1) { fclose(pFile); delete  [] pIni->fileName; delete pIni; delete [] pBuf; return 0;}
+  //  if (nbRead==-1) { fclose(pFile); delete  [] pIni->fileName; delete pIni; delete [] pBuf; return 0;}
     while (nbRead != -1)
     {

BAORadio/libindi/libindi/BAOControl/result

@@ -10 +10 @@
 
 
-queryDateTime:2011-06-26T14:47:53PDT
+queryDateTime:2011-12-04T07:23:36PST
 
 
 
-Main Information Table for MESSIER 082
+Main Information Table for MESSIER 031
 
 
@@ -25 +25 @@
 
 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 082|148.96969 |  69.67938 |G|   203| 0.000677 |    | 9.30||1671|32|239|9|14|9|0
+1|MESSIER 031| 10.68479 |  41.26906 |G|  -300|-0.001001 |    | 4.36||3357|17|132|8|26|7|0

BAORadio/libindi/libindi/CMakeLists.txt

@@ -314 +314 @@
 ${CMAKE_SOURCE_DIR}/drivers/telescope/ServerSocket.cpp
 ${CMAKE_SOURCE_DIR}/drivers/telescope/astro.cpp
-   ${CMAKE_SOURCE_DIR}/drivers/telescope/BAO.cpp )
+${CMAKE_SOURCE_DIR}/drivers/telescope/BAO.cpp
+${CMAKE_SOURCE_DIR}/drivers/telescope/exception.c
+${CMAKE_SOURCE_DIR}/drivers/telescope/filetools.cpp
+ )
    
 add_executable(indi_BAO ${BAO_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})

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

@@ -5 +5 @@
 ## Franck RICHARD
 ## franckrichard033@gmail.com
-## Juin 2011
+## Décembre 2011
 ##
 #############################
@@ -15 +15 @@
 auto_ptr<BAO> telescope(0);
 
-const int POLLMS = 1;                                   // Period of update, 1 ms.
+const int  POLLMS = 1;                                  // Period of update, 1 ms.
 
 const char *mydev = "BAO";                              // Name of our device.
@@ -66 +66 @@
     Abort           = false;
     Park            = false;
-    Suivi            = false;
+    Suivi           = false;
     Exit            = false;
 
 
     // initialisation des sockets (Antennes)
+    
     for (int i=0; i<MAXHOSTNAME; i++)
     {
-        Sockets[i].Connected=false;
-        Sockets[i].IP="";
+        Sockets[i].Connected = false;
+        Sockets[i].IP = "";
+                
+        Sockets[i].Delta.x = 0.0;
+        Sockets[i].Delta.y = 0.0;
     }
 
     // initialisations supplémentaires
+    
     InitAntennes();
 
     // Numéro de version
+    
     IDLog("Initilizing from BAO device...\n");
-    IDLog("Driver Version: 2011-06-27\n");
+    IDLog("Driver Version: 2011-12-02\n");
 
     //connect_telescope();
@@ -91 +97 @@
 ** Destructeur
 ** Lorsque l'on lance indi_BAO depuis indiserver dans un terminal
-** Le destructeur ne semble jamais être atteint lorsque l'on sort...
+** Le destructeur ne semble jamais être atteint lorsque l'on sort... A vérifier
 ***************************************************************************************/
 BAO::~BAO()
 {
-    Exit=true;
+    Exit = true;
     sleep(1);
     pthread_join (th1, NULL);
 }
 
+
+/************************************************************************************
+* Initialisation des paramÚtres des antennes
+*
+************************************************************************************/
+void BAO::InitAntennes()
+{
+    for (int i=0; i<MAXHOSTNAME; i++)
+    {
+        Sockets[i].status             = 0;
+        Sockets[i].sendalertes        = 0;
+        Sockets[i].AttenteExecution   = 0;
+        Sockets[i].AnomaliesExecution = 0;
+        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;
+    }
+}
 
 
@@ -171 +202 @@
     IDDefNumber(&ActualisationNP1, NULL);
     IDDefNumber(&ActualisationNP2, NULL);
-
-}
-
-
-
-/**************************************************************************************
-** En cas de changement de texte dans la boîte de dialogue. Exemple : changement du
-** nom de l'objet. Cette fonction n'est pas encore utilisée
+}
+
+
+/**************************************************************************************
+** Initialisation des vecteurs INDI
+***************************************************************************************/
+
+void BAO::reset_all_properties()
+{
+    ConnectSP.s                 = IPS_IDLE;
+    OnCoordSetSP.s              = IPS_IDLE;
+    AbortSlewSP.s               = IPS_IDLE;
+    ParkSP.s                    = IPS_IDLE;
+    ObjectTP.s                  = IPS_IDLE;
+    EquatorialCoordsWNP.s       = IPS_IDLE;
+    GeographicCoordsWNP.s       = IPS_IDLE;
+    ActualisationNP1.s          = IPS_IDLE;
+    ActualisationNP2.s          = IPS_IDLE;
+
+    IUResetSwitch(&OnCoordSetSP);
+    IUResetSwitch(&AbortSlewSP);
+    IUResetSwitch(&ParkSP);
+
+    OnCoordSetS[0].s = ISS_ON;
+    ConnectS[0].s = ISS_OFF;
+    ConnectS[1].s = ISS_ON;
+
+    IDSetSwitch(&ConnectSP, NULL);
+    IDSetSwitch(&OnCoordSetSP, NULL);
+    IDSetSwitch(&AbortSlewSP, NULL);
+    IDSetSwitch(&ParkSP, NULL);
+    IDSetText(&ObjectTP, NULL);
+    IDSetNumber(&EquatorialCoordsWNP, NULL);
+    IDSetNumber(&GeographicCoordsWNP, NULL);
+    IDSetNumber(&ActualisationNP1, NULL);
+    IDSetNumber(&ActualisationNP2, NULL);
+}
+
+
+/**************************************************************************************
+** 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
 ***************************************************************************************/
 
@@ -211 +277 @@
 /**************************************************************************************
 ** En cas de changement d'une valeur numérique dans la boîte de dialogue Indi
-** Exemple : longitude, latitude, ar, dec etc...
+** Exemple : longitude, latitude, ar, dec etc...) -> prendre en compte les modifications
 **
 ***************************************************************************************/
@@ -260 +326 @@
 
         // Si la longitude et la latitude sont correctes
+        // on envoie les coordonnées à la classe Astro
         if (nset == 2)
         {
@@ -457 +524 @@
         {
             AbortSlewSP.s = IPS_OK;
-            EquatorialCoordsWNP.s       = IPS_IDLE;
+            EquatorialCoordsWNP.s = IPS_IDLE;
             ObjectTP.s = IPS_IDLE;
 
@@ -481 +548 @@
         {
             AbortSlewSP.s = IPS_OK;
-            EquatorialCoordsWNP.s       = IPS_IDLE;
+            EquatorialCoordsWNP.s = IPS_IDLE;
             ObjectTP.s = IPS_IDLE;
 
@@ -494 +561 @@
 
 
-/**************************************************************************************
-** Initialisation des vecteurs INDI
-***************************************************************************************/
-
-void BAO::reset_all_properties()
-{
-    char chaine[10];
-
-    ConnectSP.s                 = IPS_IDLE;
-    OnCoordSetSP.s              = IPS_IDLE;
-    AbortSlewSP.s               = IPS_IDLE;
-    ParkSP.s                    = IPS_IDLE;
-    ObjectTP.s                  = IPS_IDLE;
-    EquatorialCoordsWNP.s       = IPS_IDLE;
-    GeographicCoordsWNP.s       = IPS_IDLE;
-    ActualisationNP1.s          = IPS_IDLE;
-    ActualisationNP2.s          = IPS_IDLE;
-
-    IUResetSwitch(&OnCoordSetSP);
-    IUResetSwitch(&AbortSlewSP);
-    IUResetSwitch(&ParkSP);
-
-    OnCoordSetS[0].s = ISS_ON;
-    ConnectS[0].s = ISS_OFF;
-    ConnectS[1].s = ISS_ON;
-
-    IDSetSwitch(&ConnectSP, NULL);
-    IDSetSwitch(&OnCoordSetSP, NULL);
-    IDSetSwitch(&AbortSlewSP, NULL);
-    IDSetSwitch(&ParkSP, NULL);
-    IDSetText(&ObjectTP, NULL);
-    IDSetNumber(&EquatorialCoordsWNP, NULL);
-    IDSetNumber(&GeographicCoordsWNP, NULL);
-    IDSetNumber(&ActualisationNP1, NULL);
-    IDSetNumber(&ActualisationNP2, NULL);
-}
-
-
-
-
 
 /**************************************************************************************
 ** Gestion du thread
-** permet de suivre la connexion/déconnexion des antennes
+** permet de suivre la connexion/déconnexion des antennes toutes les secondes
 **
-** l'utilisation d'un thread permet d'éviter de bloquer l'exécution du pilote
-** avec la fonction accept qui est bloquante
+** l'utilisation d'un thread permet de contourner le problÚme de la fonction accept
+** qui est bloquante.
 ***************************************************************************************/
 
@@ -556 +583 @@
 
             InitThreadOK = true;
-
-            usleep(100);
         }
         catch ( SocketException& e )
@@ -565 +590 @@
             IDLog("\n");*/
         }
+        
+        sleep(1); // faire une pause pour éviter de consommer trop de temps CPU -> à vérifier 
     }
     while (!Exit);
@@ -570 +597 @@
     pthread_exit (0);
 }
-
 
 
@@ -583 +609 @@
     appli->pThreadSocket();
 
-
     return 0;
 }
@@ -589 +614 @@
 
 /**************************************************************************************
-** Extraction de la position de l'antenne aprÚs l'envoie de la commande P
+** 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
@@ -616 +641 @@
     } 
 
-    IDLog((str +" fail\n").c_str());
+    IDLog((str +" failed !\n").c_str());
 
     return false;
@@ -636 +661 @@
 
 
-    // Calcule la hauteur et l'azimut de la zone du ciel pointée (en fonction de la date et du lieu)
+    // 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);
     
-    // Refraction atmosphérique
+    // Correction de la réfraction atmosphérique
     
     targetAlt = RefractionAtmospherique(targetAlt);
 
-    // Petit calcul pour faire en sorte que le sud soit à ° d'azimut
+    // Petit calcul pour faire en sorte que le sud soit à 0° d'azimut
 
     targetAz = VerifAngle( targetAz + Pi );
 
-    // En degrés
+    // On convertit les angles précédents en degrés
 
     targetAlt *= N180divPi;
-    targetAz *=  N180divPi;
-
+    targetAz  *= N180divPi;
 
     // Affichage dans les logs
@@ -659 +683 @@
     fs_sexa(AltStr, targetAlt, 2, 3600);
 
-    IDLog("Horizontal coords : az = %s     Alt = %s\n", AzStr, AltStr);
+    IDLog("Horizontal coords : Az = %s     Alt = %s\n", AzStr, AltStr);
 
 
     //Conversion des deux angles en pas codeurs
 
-    if (targetAlt < 30.0 )
+    if ( targetAlt < 30.0 )
     {
         // L'objet est trop bas (<30°). On annule le suivi...
@@ -678 +702 @@
     else
     {
-        // Si la hauteur est supérieure à 90°, on doit faire une rotation de l'azimut de 180° et corriger
-        // la hauteur en appliquant hauteur= 180° - hauteur
+        // 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)
@@ -690 +714 @@
 
         double I0 = 81.0;
-        double I2 = 128279.4 - 129723.4 * sin( (targetAlt - 20.2345) * Pidiv180 ) ;
+        double I2 = 128279.4 - 129723.4 * sin( (targetAlt - 20.2345) * Pidiv180 );
 
         double Codalt = (sqrt(I2) - I0) / 0.078947;
@@ -701 +725 @@
         TargetPosition.x = (int) Arrondi( targetAz * 4000.0 / 360.0);
 
-        IDLog("Nbre de pas codeurs az = %i        Alt = %i\n", TargetPosition.x, TargetPosition.y);
-    }
+        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
+    
+    for (int i=0; i<SocketsNumber; i++)
+    {
+        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)
+            {
+               // 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);
+               }
+            }
+
+            if (delta_az) {
+                delete [] delta_az;
+                delta_az=NULL;
+            }
+
+            if (delta_ha) {
+                delete [] delta_ha;
+                delta_ha=NULL;
+            }
+
+            os.str("");
+        }
+    }
+    
+    return true;
 }
 
 
 /************************************************************************************
-* Retourne simplement le nombre d'antennes connectées
+* Retourne le nombre d'antennes connectées
+* 
 ************************************************************************************/
 
@@ -718 +830 @@
     return num;
 }
-
-
-/************************************************************************************
-* Initialisation des paramÚtres des antennes
-*
-************************************************************************************/
-void BAO::InitAntennes()
-{
-    for (int i=0; i < MAXHOSTNAME; i++)
-    {
-        Sockets[i].status             = 0;
-        Sockets[i].sendalertes        = 0;
-        Sockets[i].AttenteExecution   = 0;
-        Sockets[i].AnomaliesExecution = 0;
-        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;
-    }
-}
-
 
 
@@ -768 +853 @@
 void BAO::ISPoll()
 {
-    static int memSocketsNumber = -1;       // Combien d'antennes étaient-elles connectées à l'appel précédent d'ISPoll ?
-    static unsigned int compt   =  0;      // permet de répondre toutes les 100ms aux demandes de nouvelles connexions
-
-    // utilise pour le travail sur les chaine
-
-    int pos;
+    static int memSocketsNumber = -1;      // Combien y avait-il d'antennes connectées lors de l'appel précédent d'ISPoll ?
+    static unsigned int compt   =  0;      // Compteur de la fonction ISPoll
 
     struct tm date;
@@ -782 +863 @@
     //si pas de connexion avec le seveur d'indi -> on sort
 
-    if (is_connected() == false) return;
+    if (!is_connected()) return;
 
 
@@ -808 +889 @@
         DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
 
-        //Puis on calule le temps sidéral local, le JJ etc...
+        //Puis on calule le temps sidéral local, le JJ etc.
 
         CalculTSL();
     }
+    
+    // On chargement les paramÚtres de corrections des antennes toutes les secondes
+    
+    if ( compt%1000 == 0 ) ChargementParametresAlignement("/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg");
 
 
@@ -819 +904 @@
     {
 
-        // Nouvelle connexion sur le socket !
+        // Nouvelle connexion sur le socket ?
 
         if (SocketsNumber > memSocketsNumber)
@@ -853 +938 @@
                     // pour différencier une trame de la précédente
 
-                    pos = reponse.find("\n");
+                    int pos = reponse.find("\n");
 
                     // S'il y a une réponse
@@ -859 +944 @@
                     while ((pos != string::npos) && (reponse.length() > 1))
                     {
-                        // on garde en stock la seconde partie trame pour un
-                        // traitement ultérieure
+                        // on garde en stock la deuxiÚme partie de la trame
+                        // pour un traitement ultérieur
                         buffereponse = reponse.substr(pos + 1);
 
@@ -866 +951 @@
                         reponse = reponse.substr(0, pos);
                         
-                        IDLog("Réponse reçue de %s : %s\n", Sockets[i].IP.c_str(), reponse.c_str());
-
-                        // On analyse ici les acknowledges
+                        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))
                         {
@@ -896 +981 @@
                                 if (reponse.find("NACK") != string::npos)
                                 {
-                                    //problÚme concernant la réponse à la commande P
+                                    //problÚme concernant la commande P
                                     OnCoordSetSP.s = IPS_ALERT;
                                     IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : position de l antenne inconnue !\n",
@@ -969 +1054 @@
                                     if (reponse.find("OK") != string::npos)
                                     {
-                                        // On a la confirmation que l'antenne 'i' a bien réalisé
+                                        // On a ici la confirmation que l'antenne 'i' a bien réalisé
                                         // le goto
 
@@ -1001 +1086 @@
                                             lastDEC = targetDEC;
 
-                                            // On change en vert les voyants dans la boîte de dialogue
-
+                                            // On a fini le mouvement. On attend le prochain goto...
+
+                                            ActualisationPosition=false;
+
+                                            // Réinitialisation des paramÚtres des antennes en vue d'un prochain goto
+
+                                            InitAntennes();
+
+                                            // On dessine les voyants de la boîte de dialogue en vert
                                             OnCoordSetSP.s = IPS_OK;
                                             EquatorialCoordsWNP.s = IPS_OK;
                                             IDSetNumber (&EquatorialCoordsWNP, NULL);
 
-                                            // On a fini le mouvement. On attend le prochain goto...
-
-                                            ActualisationPosition=false;
-
-                                            // Réinitialisation des antennes en vue d'un prochain goto
-
-                                            InitAntennes();
-
-                                            UpdateGoto=true;
-
                                             // Confirmation dans la boîte de dialogue que toutes
-                                            // les antennes sont OK
-                                            
+                                            // les antennes sont OK         
                                             OnCoordSetSP.s = IPS_OK;
                                             IDSetSwitch(&OnCoordSetSP, "GOTO OK !");
+                                            
+                                            UpdateGoto=true;
                                         }                                        
                                     }
@@ -1047 +1130 @@
 
         ///////////////////////////////////////
-        // L'utilisateur a demandé l'annulation du mouvement
-        // en cours
+        // L'utilisateur a demandé l'annulation du mouvement en cours
 
         if (Abort)
@@ -1123 +1205 @@
         if ((Suivi) && (UpdateGoto))
         {
-            // Durée entre deux actualisations
+            // Délais entre deux actualisations
 
             double delai=ActualisationTM1 / 3600.0 / 24.0;   // Actualisation toutes les 15 minutes en mode transit
@@ -1256 +1338 @@
                             if (Sockets[i].AttenteExecution > MAXATTENTE)
                             {
-                                // on attend davantage la réponse posvalides                                
+                                // on attend encore la réponse posvalides                                
                                 Sockets[i].etape = 2;
                                 Sockets[i].AttenteExecution = 0;
@@ -1333 +1415 @@
                             }
 
-                            // 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)
                             {
@@ -1374 +1456 @@
                     Sockets[i].AnomaliesExecution = 0;
 
-                    if (!GOTO(i, TargetPosition.x - Sockets[i].Pos.x , TargetPosition.y - Sockets[i].Pos.y )) Sockets[i].sendalertes++;
+                    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++;
 
                     Sockets[i].etape++;
@@ -1398 +1480 @@
         }
     }
-
+    
+    //incrémentation du compteur
     compt++;
 }
@@ -1559 +1642 @@
         Sockets[numsocket].new_sock << chaine;
         
-        IDLog("Commande envoyée à %s: %s", Sockets[numsocket].IP.c_str(), chaine);
+        IDLog("Commande envoyee a %s: %s", Sockets[numsocket].IP.c_str(), chaine);
     }
     catch (SocketException& e)
@@ -1640 +1723 @@
     // On risque alors de faire un tour complet en sens inverse pour rattraper l'objet -> à éviter
 
-    // évite de faire des tours complets en Az pour rien...
+    // ne pas faire des tours complets en Az pour rien...
     while (deltaAz > NBREPASCODEURSAZ) deltaAz -= NBREPASCODEURSAZ;
 
-    // Doit résoudre tous les problÚmes...
+    // Doit résoudre tous les problÚmes concernant l'azimut...
     if (deltaAz > NBREPASCODEURSAZ / 2 )
     {
@@ -1652 +1735 @@
     //on envoie les coordonnées au driver
 
-    if (sensAz == 1 )  sensAz='f';
-    else sensAz='b';
-    if (sensAlt == 1 ) sensAlt='f';
-    else sensAlt='b';
+    if (sensAz == 1 )  sensAz='f'; else sensAz='b';
+    
+    if (sensAlt == 1 ) sensAlt='f'; else sensAlt='b';
 
     sprintf(Params, "%c%04i%c%04i", sensAz, deltaAz, sensAlt, deltaAlt);
@@ -1665 +1747 @@
 
 /**************************************************************************************
-** Les fonctions qui suivent sont nécessaires pour construire un pilote Indi
+** Les fonctions qui suivent sont nécessaires pour construire le pilote Indi_BAO
 ** Elles sont appelées par le noyau d'Indi
 ***************************************************************************************/

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

@@ -2 +2 @@
  Pilote Indi BAORadio
  franckrichard033@gmail.com
- Juin 2011
+ Décembre 2011
 */
 
@@ -21 +21 @@
 #include <unistd.h>
 #include <sys/time.h>
+#include <fstream>
 
 #include <config.h>
@@ -32 +33 @@
 #include "SocketException.h"
 #include "astro.h"
-
+#include "filetools.h"
 
 #define MAXCARACTERES 1024
@@ -65 +66 @@
 
     Position Pos;                    // derniÚre position retournée par le microcontrÎleur
-    int etape;                       //étape dans le cycle de commandes/réponses entre PC et microcontroleurs
+    Position Delta;                  // Corrections en Az et Ha
+    int etape;                       // étape dans le cycle de commandes/réponses entre PC et microcontroleurs
 
     bool ack_status;                 // Etat des acknowledges ?
@@ -73 +75 @@
     bool ack_goto;                   // le PC a reçu une confirmation du microcont aprÚs un ordre GOTO
     bool GotoOk;                     // Est-ce que le dernier goto est OK ?
+    
+    
 };
 
@@ -108 +112 @@
     void DeconnecterSocket(int num);
     void InitAntennes();
-
+    bool ChargementParametresAlignement(string fileName);
+    bool is_readable( const std::string & file );
+  
     /*******************************************************/
     /* Connection Routines