Changeset 504 for BAORadio

BAORadio/libindi/libindi/BAOControl/.directory

r502	r504
1	1	[Dolphin]
2		Timestamp=2010,11,5,22,3,10
	2	Timestamp=2010,11,8,3,1,35
	3
	4	[Settings]
	5	ShowDotFiles=false

BAORadio/libindi/libindi/BAOControl/Makefile

-                      r502
+                      r504
+#
+CC=g++
+CC = g++
+#CFLAGS = -g
+#CXXFLAGS = -g
 BAOControl_objects =  baocontrol.o ClientSocket.o Socket.o filetools.o exception.o astro.o
+BAOcontrol_objects =  main.o baocontrol.o ClientSocket.o Socket.o filetools.o exception.o ../drivers/telescope/astro.o
 all : BAOControl
+all : BAOcontrol
 BAOControl: $(BAOControl_objects)
         g++ -o BAOControl $(BAOControl_objects) -lpthread -lX11
+BAOcontrol: $(BAOcontrol_objects)
+        g++  -o BAOcontrol $(BAOcontrol_objects) -lpthread -lX11
 Socket: Socket.cpp
+Socket:  Socket.cpp
 ClientSocket: ClientSocket.cpp
 Astro: astro.cpp
+Astro: ../drivers/telescope/astro.cpp
 baocontrol: baocontrol.cpp
+main: main.cpp
 clean:
+        rm -f *.o *.cpp~ *.c~ *.h~ BAOControl
+        rm -f *.o *.cpp~ *.c~ *.h~ BAOcontrol
+install:
+        cp BAOcontrol /usr/bin

BAORadio/libindi/libindi/BAOControl/Socket.cpp

-                      r502
+                      r504
    //  TIME_WAIT - argh
     int on = 1;
+    if ( setsockopt ( m_sock, SOL_SOCKET, SO_REUSEADDR, ( const char* ) &on, sizeof ( on ) ) == -1 ) return false;
+    if (setsockopt(m_sock, SOL_TCP, TCP_NODELAY, (const char*) &on, sizeof(on)) <0) return false;
+    if ( setsockopt( m_sock, SOL_SOCKET, SO_REUSEADDR, ( const char* ) &on, sizeof ( on ) ) == -1 ) return false;
+    if ( setsockopt(m_sock, SOL_TCP, TCP_NODELAY, (const char*) &on, sizeof(on)) <0) return false;
     return true;
+}
 …
     if ( bind_return == -1 ) return false;
     return true;
+}

BAORadio/libindi/libindi/BAOControl/Socket.h

-                      r502
+                      r504
 #include <arpa/inet.h>
 #include <iostream>
+#include "stdio.h"
 const int MAXHOSTNAME = 200;
+const int MAXHOSTNAME = 1000;
 const int MAXCONNECTIONS = 5;
 const int MAXRECV = 5000;

BAORadio/libindi/libindi/BAOControl/baocontrol.cpp

-                      r502
+                      r504
+/********************/
+/* BAOCONTROL       */
+/*                  */
+/********************/
+/******************************/
+/* BAOCONTROL                 */
+/*                            */
+/* Franck RICHARD             */
+/* franckrichard033@gmail.com */
+/* Juin 2011                  */
+/******************************/
 …
+/* Affiche Ã  l'Ã©cran (si AfficheEcran==true) et sauvegarde dans le fichier
+   BAOControl.log le message contenu dans la variable chaine */
+void Affiche(std::string chaine, bool AfficheEcran)
+/**************************************************************************************
+**Constructeur
+***************************************************************************************/
+BAOcontrol::BAOcontrol()
+{
+    float a1, a2, a3;
+    // Le choix de la couleur des caractÃšres est adaptÃ© pour une fenÃªtre de terminal
+    // ayant un fond blanc. pour un fond noir, mettre couleurs=2 dans le fichier params
+    ChoixCouleurs=1;
+    Affiche("\n\n\n\n\n \
+ ******************************************\n \
+ *             BAORadio Control           *\n \
+ * Laboratoire de l'AccÃ©lÃ©rateur LinÃ©aire *\n \
+ *                                        *\n \
+ *             v0.2  20/06/2011           *\n \
+ *        franckrichard033@gmail.com      *\n \
+ ******************************************\n\n\n", true);
+    //Initialisation des variables globales et des pointeurs
+    delaitransit  = 0;
+    delaitracking = 0;
+    lognum        = 0;
+    numAntenne    = 0;
+    numobjets     = 0;
+    runnum        = 1;
+    Pression      = 1013.0;
+    Temperature   = 10.0;
+    NoExit        = true;
+    Transit       = false;
+    run           = false;
+    exitrun       = false;
+    fd            = NULL;
+    client_socket = NULL;
+    // chaines de caractÃšres et tableaux
+    LatitudeChar  = "";
+    LongitudeChar = "";
+    Serveur       = "";
+    Port          = "";
+    Antennes      = new DefAntenne[MAXANTENNES];
+    objets        = new DefObjets[MAXOBJETS];
+    //on initalise aussi les tableaux
+    for (int i=0; i<MAXANTENNES; i++)
+    {
+        Antennes[i].ok=0;
+        Antennes[i].ip=0;
+    }
+    for (int i=0; i<MAXOBJETS; i++)
+    {
+        objets[i].JJ=0;
+        objets[i].exec=false;
+    }
+    // Chargement du fichier contenant les paramÃštres
+    if (!ChargementParametres("params"))
+    {
+        Erreur("Le fichier de configuration 'params' contient des erreurs ou n'existe pas.\n \
+        Merci de vÃ©rifier.\n\n");
+        exit(1);
+    }
+    // Conversion de la latitude et de la longitude en radians
+    Decomposition(LatitudeChar, 0, &a1, &a2, &a3);
+    double Latitude = (a1 + a2 / 60.0 + a3 / 3600.0) * Pidiv180;
+    Decomposition(LongitudeChar, 1, &a1, &a2, &a3);
+    double Longitude = Pi2 - ( a1 + a2 / 60.0 + a3 / 3600.0 ) * Pidiv180;
+    // Transfert de la latitude, longitude, pression, tempÃ©rature Ã  la classe Astro
+    DefinirLongitudeLatitude(Longitude, Latitude);
+    DefinirPressionTemp(Pression, Temperature);
+    // Ouverture du socket avec indi_BAO
+    client_socket = new ClientSocket("localhost", atoi(Port.c_str()) );
+    // On se connecte au pilote indi_BAO
+    Connect(true);
+}
+/**************************************************************************************
+** Destructeur
+***************************************************************************************/
+BAOcontrol::~BAOcontrol()
+{
+    // destruction des tableaux
+    delete [] Antennes;
+    delete [] objets;
+    // destruction de la fenÃªtre graphique, des caractÃšres
+    if (d!=NULL)
+    {
+        XFreeGC(d, noir);
+        XFreeGC(d, vert);
+        XFreeGC(d, rouge);
+        XFreeGC(d, gris);
+        XFreeFont(d, fd);
+        XDestroyWindow(d, w);
+        XCloseDisplay(d);
+    }
+    // destruction du socket
+    delete client_socket;
+}
+/**************************************************************************************
+** Affiche le message Ã  l'Ã©cran (si AfficheEcran==true) et le sauvegarde dans le fichier
+** BAOControl.log
+***************************************************************************************/
+void BAOcontrol::Affiche(string Message, bool AfficheEcran)
+{
     FILE *pFile = NULL;
+    pFile = fopen ("BAOControl.log", "a");
+    if (AfficheEcran) std::cout << chaine;
+    fprintf (pFile, chaine.c_str());
+    os.str("");
+    fclose (pFile);
+}
+/*Affiche les messages d'erreur en rouge */
+void Erreur(std::string chaine)
+{
+    std::cout << red;
+    if ( (pFile = fopen ("BAOcontrol.log", "a")) != NULL)
+    {
+        if (AfficheEcran) cout << Message;
+        fprintf (pFile, Message.c_str());
+        fclose (pFile);
+    }
+}
+void BAOcontrol::Affiche(stringstream *Message, bool AfficheEcran)
+{
+    Affiche(Message->str(), AfficheEcran);
+    // on efface le buffer
+    Message->str("");
+}
+/**************************************************************************************
+** Affiche les messages d'erreur en rouge
+***************************************************************************************/
+void BAOcontrol::Erreur(string chaine)
+{
+    ChoixCouleurs==1 ? cout << red1  : cout << red2;
     Affiche(chaine, true);
+    std::cout << black;
+}
+/*initialise une fenÃªtre graphique */
+void initialiserFenetre()
+    ChoixCouleurs==1 ? cout << grey1 : cout << grey2;
+}
+void BAOcontrol::Erreur(stringstream *Message)
+{
+    Erreur(Message->str());
+    // on efface le buffer
+    Message->str("");
+}
+/**************************************************************************************
+** Initialise la fenÃªtre graphique
+***************************************************************************************/
+void BAOcontrol::initialiserFenetre()
+{
     XGCValues gcv;
+    XFontStruct * fd;
+    /*contacte le serveur*/
+    // contacte le serveur graphique
     if ((d = XOpenDisplay(getenv("DISPLAY"))) == NULL)
+    {
 …
+    }
+    /*crÃ©e une fenÃªtre*/
+    // crÃ©e une fenÃªtre
     w = XCreateSimpleWindow(d, RootWindow(d, DefaultScreen(d)),
 , 0, larg, haut,
+, 0, larg_fenetre, haut_fenetre,
 , BlackPixel(d, DefaultScreen(d)),
                             WhitePixel(d, DefaultScreen(d)));
+    /* Creation du double buffer */
+    db = XCreatePixmap(d, w, larg, haut, DefaultDepth(d, DefaultScreen(d)));
+    /*chargement d'une police de caractÃšres*/
+    if ((fd=XLoadQueryFont(d, "fixed")) == NULL)
+    // CrÃ©ation du double buffer
+    db = XCreatePixmap(d, w, larg_fenetre, haut_fenetre, DefaultDepth(d, DefaultScreen(d)));
+    // Chargement de la police de caractÃšres
+    if ((fd = XLoadQueryFont(d, "fixed")) == NULL)
+    {
         Erreur("Impossible de charger la police fixed\n\n");
 …
+    }
+    /*crÃ©ation d'un contexte graphique*/
+    // CrÃ©ation des couleurs
     gcv.font = fd->fid;
     gcv.foreground = BlackPixel(d, DefaultScreen(d));
 …
     gris = XCreateGC(d, w, GCFont | GCForeground, &gcv);
+    /*affiche la fenÃªtre */
+    // Affichage de fenÃªtre
     XMapWindow(d, w);
+}
+/* Dessine les Ã©lÃ©ments de la fenÃªtre graphique */
+void Dessiner()
+{
+    char chaine[100];
+/**************************************************************************************
+** Dessine les Ã©lÃ©ments dans la fenÃªtre graphique
+***************************************************************************************/
+void BAOcontrol::Dessiner()
+{
+    char *chaine;
     GC color;
+    /* On efface la fenÃªtre */
+    chaine = new char [100];
+    // On efface la fenÃªtre
     XSetForeground(d, noir, WhitePixel(d, DefaultScreen(d)));
     XFillRectangle(d, db, noir, 0, 0, larg, haut);
+    XFillRectangle(d, db, noir, 0, 0, larg_fenetre, haut_fenetre);
     XSetForeground(d, noir, BlackPixel(d, DefaultScreen(d)));
+    /* Affichage de la date et de l'heure */
+    int h=astro->Heu;
+    int m=astro->Min;
+    int s=astro->Sec;
+    int j=astro->Jour;
+    // On rÃ©cupÃšre la date et l'heure contenue dans la classe astro (et le jour julien)
+    double h  = GetHeure();
+    double mi = GetMin();
+    double s  = GetSec();
+    double a  = GetAnnee();
+    double m  = GetMois();
+    double j  = GetJour();
+    double JJ = GetJJ();
+    // on Ã©vite les affichages de l'heure du genre 12:56:60 ou 24:00:00
     if (s==60) {
         s=0;
         m++;
         if (m==60) {
             m=0;
+        s = 0;
+        mi++;
+        if (mi == 60) {
+            mi = 0;
             h++;
             if (h==24) {
                 h=0;
+            if (h == 24) {
+                h = 0;
                 j++;
+            }
+        }
+    }
+    sprintf(chaine, "%02i:%02i:%02i TU    %02i/%02.0f/%04.0f    JJ=%10.5f",
+            h, m, s, j, astro->Mois, astro->Annee, astro->JJ);
+    }
+    //affichage de la date et de l'heure
+    sprintf(chaine, "%02.0f:%02.0f:%02.1f TU    %02.0f/%02.0f/%04.0f    JJ=%10.5f",
+            h, mi, s, j, m, a, JJ);
     XDrawString(d, db, noir, 10, 10, chaine, strlen(chaine));
+    //En cas d'exÃ©cution d'un fichier de mouvements, on affiche la prochaine Ã©tape
     if (run)
+    {
+        sprintf(chaine, "Prochaine etape dans %4.1fs", (objets[runnum].JJ-astro->JJ)*3600.0*24.0);
+        if ((objets[runnum].JJ-astro->JJ)*3600.0*24.0 >= 0.0) XDrawString(d, db, noir, 350, 10, chaine, strlen(chaine));
+    }
+    /*affichage des cercles d'Ã©tat*/
+        sprintf(chaine, "Prochaine etape dans %4.1fs", (objets[runnum].JJ - JJ) * 3600.0 * 24.0);
+        if ((objets[runnum].JJ - JJ) * 3600.0 * 24.0 >= 0.0)
+            XDrawString(d, db, noir, 350, 10, chaine, strlen(chaine));
+    }
+    // affichage des cercles d'Ã©tat
+    // vert = l'antenne fonctionne
+    // rouge = problÃšme dÃ©tectÃ© sur l'antenne
+    // gris = antenne non connectÃ©e
     for (int i=0; i <20; i++)
+    {
+        for (int j=0; j<5; j++)
+        {
+            switch(Antennes[20*j+i].ok)
+            {
+              case 1 : color=vert; break;
+              case 2 : color=rouge; break;
+              default: color=gris; break;
+            }
+        for (int j=0; j<2; j++)
+        {
+            switch (Antennes[20*j+i].ok)
+            {
+            case 1 :
+                color=vert;
+                break;
+            case 2 :
+                color=rouge;
+                break;
+            default:
+                color=gris;
+                break;
+            }
             XFillArc(d, db ,color, 10+i*30, 20+j*30, 15, 15, 0, 360*64);
+            XDrawArc(d, db ,noir, 10+i*30, 20+j*30, 15, 15, 0, 360*64);
+        }
+    }
+    /*Affichage des messages d'erreur*/
+    if (lognum>15)
+    {
+        for (int i=lognum-1; i>lognum-16; i--)
+            XDrawArc(d, db ,noir,  10+i*30, 20+j*30, 15, 15, 0, 360*64);
+        }
+    }
+    // Affichage des messages d'indi_BAO
+    // gÃšre aussi le dÃ©filement
+    if (lognum>10)
+    {
+        for (int i=lognum-1; i>lognum-11; i--)
+        {
             if ((logs[i].find("Err")!=string::npos)
                     || (logs[i].find("ALERTE")!=string::npos)) color=rouge;
             else color=vert;
             XDrawString(d, db, color, 10, 15*12+(i-lognum+15)*12, logs[i].c_str(), strlen(logs[i].c_str()));
+            XDrawString(d, db, color, 10, 9*12+(i-lognum+10)*12, logs[i].c_str(), strlen(logs[i].c_str()));
+        }
+    }
 …
                     || (logs[i].find("ALERTE")!=string::npos)) color=rouge;
             else color=vert;
+            XDrawString(d, db, color, 10, 15*12+i*12, logs[i].c_str(), strlen(logs[i].c_str()));
+        }
+    }
+    XCopyArea(d, db, w, noir, 0, 0, larg, haut, 0, 0);
+    /* on force le rafraichissement de l'Ã©cran */
+            XDrawString(d, db, color, 10, 9*12+i*12, logs[i].c_str(), strlen(logs[i].c_str()));
+        }
+    }
+    // On affiche la copie de l'Ã©cran une fois que tout est dessinÃ©
+    // on Ã©vite ainsi les scientillements de la fenÃªtre
+    XCopyArea(d, db, w, noir, 0, 0, larg_fenetre, haut_fenetre, 0, 0);
+    // On force le rafraichissement de l'Ã©cran
     XFlush(d);
+}
+/* Gestion des messages concernant la fenÃªtre graphique */
+void rouler(char* reponse)
+    delete [] chaine;
+}
+/**************************************************************************************
+** Gestion des Ã©vÃ©nements affectant la fenÃªtre graphique
+***************************************************************************************/
+void BAOcontrol::rouler()
+{
     XEvent e;
 …
+        {
         default:
             //std::cout << "J'ai reÃ§u un Ã©vÃšnement " <<  e.type << std::endl
+            //cout << "J'ai reÃ§u un Ã©vÃ©nement " <<  e.type << endl
             break;
         case Expose :
 …
+/* RÃ©cupÃšre les messages envoyÃ©s par indi_BAO */
+void LireReponse()
+{
+    std::string reponse, decomp;
+    std::stringstream os;
+/**************************************************************************************
+** RÃ©cupÃšre les messages envoyÃ©s par indi_BAO
+***************************************************************************************/
+void BAOcontrol::LireReponse()
+{
+    string reponse, memreponse, decomp;
     bool test=false;
     *client_socket >> reponse;
+    if (reponse.find("message")!=string::npos)
+    {
+        /* on ne garde que la partie intÃ©ressante */
+        reponse=reponse.substr(reponse.find("message")+9);
+        reponse=reponse.substr(0, reponse.find("\""));
+        /*rÃ©cupÃšre l'adresse ip de l'antenne */
+        if (reponse.find(". (Antennes connectees")!=string::npos)
+        {
+            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++)
+   // printf("%s\n", reponse.c_str());
+    do
+    {
+        if (reponse.find("message")!=string::npos)
+        {
+            // On ne garde que la partie intÃ©ressante
+            // La partie suivant "message="...
+            reponse = reponse.substr(reponse.find("message") + 9);
+            memreponse = reponse;
+            // ...jusqu'au "
+            reponse=reponse.substr(0, reponse.find("\""));
+            // On rÃ©cupÃšre l'adresse ip de l'antenne qui nous parle
+            // et on met Ã  jour le tabmeau des Ã©tats des antennes
+            if (reponse.find(". (Antennes connectees")!=string::npos)
+            {
+                if (atoi(decomp.c_str()) == Antennes[i].ip)
+                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++)
+                {
+                    Antennes[i].ok=1;
+                    test=true;
+                    break;
+                    if (atoi(decomp.c_str()) == Antennes[i].ip)
+                    {
+                        Antennes[i].ok=1;
+                        test=true;
+                        break;
+                    }
+                }
+                // ou si c'est une nouvelle antenne, on l'ajoute au tableau
+                if (!test)
+                {
+                    Antennes[numAntenne].ip = atoi(decomp.c_str());
+                    Antennes[numAntenne++].ok = 1;
+                }
+            }
+            /*ou on ajoute son Ã©tat */
+            if (!test)
+            // erreur sur une antenne -> on change son Ã©tat dans la fenÃªtre
+            if  ((reponse.find("ALERTE antenne ")!=string::npos) ||
+                    (reponse.find("Erreur sur l antenne ")!=string::npos))
+            {
+                Antennes[numAntenne].ip=atoi(decomp.c_str());
+                Antennes[numAntenne].ok=1;
+                numAntenne++;
+            }
+        }
+        /*erreur sur une antenne -> on change son Ã©tat dans la fenÃªtre */
+        if  ((reponse.find("ALERTE antenne ")!=string::npos) || (reponse.find("Erreur sur l antenne ")!=string::npos))
+        {
+            decomp=reponse.substr(0, reponse.find(" :"));
+            decomp=decomp.substr(decomp.rfind(".")+1);
+            for (int i=0; i<numAntenne; i++)
+            {
+                if (atoi(decomp.c_str()) == Antennes[i].ip)
+                decomp = reponse.substr(0, reponse.find(" :"));
+                decomp = decomp.substr(decomp.rfind(".") + 1);
+                for (int i=0; i<numAntenne; i++)
+                {
+                    Antennes[i].ok=2;
+                    if (atoi(decomp.c_str()) == Antennes[i].ip)
+                    {
+                        Antennes[i].ok = 2;  // Erreur sur l'antenne i
+                    }
+                }
+            }
+        }
+        /* On sauvegarde le message dans le tableau log */
+        os << lognum << " : " << reponse;
+        Affiche(os.str(), false);
+        Affiche("\n", false);
+        logs[lognum++]=os.str();
+        if (lognum>=MAXLOG-1) lognum=0;
+            // On sauvegarde le message dans le tableau logs
+            stringstream os;
+            os << lognum << " : " << reponse;
+            Affiche(os.str() + "\n", false);
+            if (lognum<MAXLOG-1) logs[lognum++] = os.str();
+            reponse = memreponse;
+        }
+        else reponse="";
+        /*on actualise la fenÃªtre */
+    } while ( reponse !="" );
+     // on actualise la fenÃªtre
         Dessiner();
+    }
+    rouler((char *)reponse.c_str());
+}
+/* Est-ce que la rÃ©ponse du pilote indi_BAO
+est conforme Ã  ce que l'on attendait ? */
+bool VerifReponse(std::string reponseattendue)
+{
+    std::string reponse;
+    usleep(10000); // attendre 10 ms pour laisser le temps au pilote indi_BAO de rÃ©pondre
+    *client_socket >> reponse;
+    if (reponse.find(reponseattendue)==string::npos)
+    {
+        //rÃ©ponse inconnue -> une erreur ?
+        os << "RÃ©ponse du pilote indi_BAO :" << std::endl << reponse
+                  << std::endl << std::endl << std::endl;
+        Erreur(os.str());
+    // on envoie un message pour actualiser la fenÃªtre graphique
+    rouler();
+}
+/**************************************************************************************
+** Est-ce que la rÃ©ponse du pilote indi_BAO est conforme Ã  ce que l'on attendait ?
+***************************************************************************************/
+bool BAOcontrol::VerifReponse(string reponseattendue)
+{
+    string reponse = "";
+    string memreponse = "";
+    int    duree = 0;
+    bool   test = false;
+    // TODO :La rÃ©ponse du driver ne vient pas tout de suite et on peut recevoir
+    // des messages intermÃ©diaires un peu Ã©tranges impliquant la fonction CONNECT, pourquoi ?
+    // LÃ  on lit les messages trois fois de suite pour essayer de voir passer le bon
+    // Essayer de voir si on ne peut pas faire mieux...
+    for (int i=0; i<3 ;i++)
+    {
+        do
+        {
+            usleep(1000); // attendre 1 ms pour laisser le temps au pilote indi_BAO de rÃ©pondre
+            *client_socket >> reponse;
+            duree++;
+        }
+        while (reponse.length() == 0 && duree<10 ); // on attend un message pendant 10 ms max
+        // on ajoute tous les messages reÃ§us dans memmreponse
+        // ->intÃ©ressant pour le debug
+        memreponse += reponse;
+        if (reponse.find(reponseattendue) != string::npos)
+        {
+            test = true;
+            break;
+        }
+    }
+    if (!test)
+    {
+        // rÃ©ponse inconnue -> une erreur ?
+        int pos = memreponse.find("message=");
+        if ( pos != string::npos )
+        {
+            memreponse = memreponse.substr(pos + 9);
+            memreponse = memreponse.substr(0, memreponse.find("\""));
+            Erreur("RÃ©ponse du pilote indi_BAO :" + memreponse + "\n\n");
+        }
+        return false;
+    }
 …
+/*RÃ©cupÃ©ration de la date et de l'heure
+ et calcul du jour julien et du tsl */
+void CalculJourJulien()
+/**************************************************************************************
+** Calcul du jour julien et du temps sidÃ©ral local
+***************************************************************************************/
+void BAOcontrol::Update()
+{
     struct tm date;
 …
     struct timezone tz;
+    // On rÃ©cupÃšre la date et l'heure depuis l'horloge du systÃšme
     time(&t);
     date=*gmtime(&t);
     gettimeofday(&tv, &tz);
+    astro->Annee=(double)(date.tm_year+1900);
+    astro->Mois=(double)(date.tm_mon+1);
+    astro->Jour=(double)date.tm_mday;
+    astro->Heu=(double)date.tm_hour;
+    astro->Min=(double)date.tm_min;
+    astro->Sec=(double)date.tm_sec+tv.tv_usec/1.0E6;
+    astro->UTCP=0.0;//(double)date.tm_isdst;
+    //Calcul du temps sidÃ©ral local et du JJ
+    astro->CalculTSL();
+}
+/* gestion du thread permettant l'actualisation de la fenÃªtre graphique
+ et la rÃ©cupÃ©ration des messages d'indi_BAO */
+void *my_thread_process (void * arg)
+{
+    double Annee = (double)date.tm_year + 1900.0;
+    double Mois  = (double)date.tm_mon + 1.0;
+    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;
+    /*Annee=2011;
+    Mois=6;
+    Jour=17;
+    Heu=15;
+    Min=53.0;
+    Sec=00.0;*/
+    // On actualise la date et l'heure dans la classe Astro
+    DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
+    // On lance le calcul
+    CalculTSL();
+}
+/**************************************************************************************
+** gestion du thread permettant
+** -l'exÃ©cution d'une liste de mouvements programmÃ©s
+** -l'actualisation de la fenÃªtre graphique
+** -la rÃ©cupÃ©ration des messages du pilote indi_BAO
+***************************************************************************************/
+void *BAOcontrol::my_thread_process ()
+{
+    stringstream os;
+    // Tant ue l'utilisateur n'a pas taper la commande 'exit'
     while (NoExit)
+    {
+        CalculJourJulien();
+        //Execution d'un fichier de mouvements
+        //On actualise le jour julien et le temps sidÃ©ral local
+        Update();
+        // On rÃ©cupÃšre le jour julien
+        double JJ = GetJJ();
+        // 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)
+        {
+            /* On lance l'exÃ©cution des mouvements programmÃ©s */
+            if (astro->JJ>=objets[runnum].JJ && !objets[runnum].exec)
+            // On lance le mouvement numÃ©ro runnum si la date correspond au dÃ©but
+            // de son exÃ©cution et que ce mouvement n'a pas Ã©tÃ© encore rÃ©alisÃ©
+            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);
+                os << "Suivi de l'objet nÂ°" << runnum << std::endl;
+                Affiche(os.str(), true);
+                os << "Suivi de l'objet nÂ°" << runnum << endl;
+                Affiche(&os, true);
+                // on indique que le mouvement est en cours d'exÃ©cution
+                //ou qu'il a Ã©tÃ© dÃ©jÃ  exÃ©cutÃ©
                 objets[runnum].exec=true;
+                Goto(objets[runnum].ad, objets[runnum].de, Transit);
+                //on envoie l'ordre goto correspondant
+                Goto(objets[runnum].ad, objets[runnum].de, Transit, J2000);
+            }
+            /*on arrive Ã  la fin du mouvements i */
+            if (astro->JJ>=objets[runnum].JJ+objets[runnum].Duree/3600.0/24.0)
+            // On arrive Ã  la fin de l'exÃ©cution du mouvements runnum
+            if (JJ >= objets[runnum].JJ + objets[runnum].Duree / 3600.0 / 24.0 )
+            {
+                // On interrompt le mouvement
                 Abort();
+                /*fin de la commande run */
+                if (runnum+1>=numobjets)
+                // S'il s'agit du dernier mouvement -> Fin de la commande run
+                if ( runnum + 1 >= numobjets )
+                {
                     Affiche("Fin de l'execution du fichier de mouvements\n\n", true);
+                    std::cout << std::endl << blue << ">";
+                    // on rÃ©affiche le prompt
+                    cout << endl;
+                    ChoixCouleurs==1 ? cout << blue1 : cout << blue2;
+                    cout << ">";
+                    // on rÃ©initiale toutes les variables impliquÃ©es dans la commande run
                     run=false;
                     runnum=1;
                     numobjets=1;
+                    /*on sort du programme dans le cas ./BAOControl -r fileName */
+                    if (exitrun) NoExit=false;
+                    // On sort du programme dans le cas BAOControl -r fileName
+                    NoExit=!exitrun;
+                }
                 else
+                {
+                    // on passe au mouvement suivant
                     runnum++;
+                }
 …
+        }
+        // on lit et affiche la rÃ©ponse des microcontrolleurs
         LireReponse();
         Dessiner();
+        usleep(100000); //100 ms
+    }
+        // pause de 100 ms
+        usleep(100000);
+    }
+    // l'utilisateur a tapÃ© exit... On sort du thread...
     pthread_exit (0);
 …
+/* DÃ©composition et vÃ©rification des dates, heures, AD et dÃ©clinaisons
+ type = 0 -> DÃ©clinaison/latitude
+ type = 1 -> longitude
+ type = 2 -> AD ou heure
+ type = 3 -> date */
+bool Decomposition(std::string chaine, char type, float *a1, float *a2, float *a3)
+{
+    std::string car, s;
+    int pos1, pos2;
+    float a, b, c;
+    if (type==3) car="/"; else car=":";
+    /* Y a-t-il 2 caractÃšres : ou / Ã  la suite ? */
+    int test=0;
+    for (int i=0; i<chaine.length(); i++) if (chaine[i]==car[0]) test++;
+    if (test<2) return false;
+    s=chaine.substr(0, chaine.find(car));
+    a=atoi(s.c_str());
+    s=chaine.substr(chaine.find(car)+1, chaine.rfind(car)-chaine.find(car)-1);
+    b=atoi(s.c_str());
+    s=chaine.substr(chaine.rfind(car)+1);
+    c=atoi(s.c_str());
+    if (type <3)
+    {
+        if ((type==0) && (a>90.0 || a<-90.0)) return false;
+        if ((type==1) && (a>180.0 || a<-180.0)) return false;
+        if ((type==2) && (a>23.0 || a<0.0)) return false;
+        if (b<0.0 || b>59.0) return false;
+        if (c<0.0 || c>=60.0) return false;
+    }
+    else
+    {
+        if (a<0.0 || a>31.0) return false;
+        if (b<0.0 || b>12.0) return false;
+    }
+    if (a1!=NULL) *a1=a;
+    if (a2!=NULL) *a2=b;
+    if (a3!=NULL) *a3=c;
+void* LancementThread(BAOcontrol * appli)
+{
+    appli->my_thread_process();
+    return 0;
+}
+/**************************************************************************************
+** DÃ©crypte les commandes saisies par l'utilisateur
+** Exemples :
+** DecompositionCommande("goto 10:10:10 25:10:10", "goto", &chaine1, &chaine2)
+** retourne chaine1  = "10:10:10"
+**          chaine2  = "25:10:10"
+**
+** DecompositionCommande("goto messier 1","goto", &chaine1, NULL) (avec chaine2=NULLL)
+** retourne chaine1  = "messier 1"
+**          chaine2  = NULL
+***************************************************************************************/
+bool BAOcontrol::DecompositionCommande(string chaine, string commande, string *chaine1, string *chaine2)
+{
+    size_t pos = chaine.find(commande);
+    // si la commande est prÃ©sente dans chaine, on continue
+    if (pos != string::npos)
+    {
+        // on s'intÃ©resse aux caractÃšres qui suivent la commande
+        pos += commande.length();
+        chaine = chaine.substr(pos);
+        // on ignore les espaces superflus
+        while (chaine[0] == ' ') chaine = chaine.substr(1);
+        // si on veut prendre les deux arguments d'un commande
+        if (chaine2 != NULL)
+        {
+            // on prend le premier bloc jusqu'au prochain espace -> c'est la chaine1
+            *chaine1 = chaine.substr(0, chaine.find(" "));
+            // puis on prend le deuxiÃšme bloc -> c'est la chaine2
+            pos = chaine.find(" ");
+            if (pos != string::npos)
+            {
+                chaine = chaine.substr(pos + 1);
+                while (chaine[0] == ' ') chaine = chaine.substr(1);
+                *chaine2 = chaine.substr(0, chaine.find(" "));
+            }
+        }
+        else
+        {
+            // 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
+            // mÃªme chaine
+            *chaine1 = chaine;
+        }
+    }
     return true;
+}
+/* isole les diffÃ©rents Ã©lÃ©ments de la commande saisie par l'utilisateur */
+bool DecompositionCommande(std::string chaine, std::string commande, std::string *chaine1, std::string *chaine2)
+{
+    size_t pos;
+    pos = chaine.find(commande);
+    if (pos!=string::npos)
+    {
+        pos+=commande.length();
+        chaine=chaine.substr(pos);
+        while (chaine[0] == ' ') chaine=chaine.substr(1);
+        *chaine1=chaine.substr(0,chaine.find(" "));
+        if (chaine2!=NULL)
+        {
+            pos = chaine.find(" ");
+            if (pos!=string::npos)
+            {
+                chaine=chaine.substr(pos+1);
+                while (chaine[0] == ' ') chaine=chaine.substr(1);
+                *chaine2=chaine.substr(0, chaine.find(" "));
+            }
+        }
+    }
+    return true;
+}
+/*Envoie la longitude et la latitude du lieu d'observation au pilote indi_BAO */
+bool EncoyerCoordGeographiques()
+{
+/**************************************************************************************
+** Envoie la longitude et la latitude du lieu d'observation au pilote indi_BAO
+***************************************************************************************/
+bool BAOcontrol::EnvoyerCoordGeographiques()
+{
+    // la communication avec le pilote indi_BAO
+    // se fait par l'envoie de petit fichier xml
+    // d'oÃ¹ le cÃŽtÃ© complexe des commandes
     try
+    {
         *client_socket << "<newNumberVector device=\"BAO\" name=\"GEOGRAPHIC_COORD\">";
         *client_socket << "<oneNumber name=\"LAT\">";
         *client_socket << Latitude;
+        *client_socket << LatitudeChar;
         *client_socket << "</oneNumber>";
         *client_socket << "<oneNumber name=\"LONG\">";
         *client_socket << Longitude;
+        *client_socket << LongitudeChar;
         *client_socket << "</oneNumber>";
         *client_socket << "</newNumberVector>";
 …
         if (!VerifReponse("name=\"GEOGRAPHIC_COORD\" state=\"Ok\""))
+        {
             Erreur("ERREUR fct EncoyerCoordGeographiques : pas de rÃ©ponse du pilote indi_BAO.\n\n");
+            Erreur("ERREUR fct EnvoyerCoordGeographiques : pas de rÃ©ponse du pilote indi_BAO.\n\n");
             return false;
 …
+    }
+    // un problÃšme ?
     catch ( SocketException& e )
+    {
+        os << "Exception was caught:" << e.description() << std::endl;
+        Erreur(os.str());
+        Erreur("Exception was caught:" + e.description() + "\n");
         return false;
+    }
     std::cout << "Les coordonnÃ©es gÃ©ographiques ont bien Ã©tÃ© envoyÃ©es au pilote indi_BAO"  << std::endl << std::endl;
+    Affiche("Les coordonnÃ©es gÃ©ographiques ont bien Ã©tÃ© envoyÃ©es au pilote indi_BAO\n\n", true);
     return true;
 …
+/* Place les antennes en position de repos */
+bool Park()
+/**************************************************************************************
+** Place les antennes en position de repos
+***************************************************************************************/
+bool BAOcontrol::Park()
+{
     try
 …
         *client_socket << "</newSwitchVector>";
         if (!VerifReponse("Envoi de la commande Park"))
+        if (!VerifReponse("PARK OK"))
+        {
             Erreur("La commande PARK a Ã©chouÃ©.\n\n");;
 …
     catch ( SocketException& e)
+    {
+        os << e.description() << "\n";
+        Erreur(os.str());
+        Erreur("Exception was caught:" + e.description() + "\n");
         return false;
+    }
 …
+/* Annule le mouvement en cours */
+bool Abort()
+/**************************************************************************************
+** Annule le mouvement en cours
+***************************************************************************************/
+bool BAOcontrol::Abort()
+{
     try
 …
         *client_socket << "</newSwitchVector>";
         if (!VerifReponse("name=\"ABORT_MOTION\" state=\"Ok\""))
+        if (!VerifReponse("ABORT OK"))
+        {
             Erreur("L'annulation a Ã©chouÃ©.\n\n");
 …
     catch ( SocketException& e)
+    {
+        os << e.description() << "\n";
+        Erreur(os.str());
+        Erreur("Exception was caught:" + e.description() + "\n");
         return false;
+    }
 …
+}
+/*aller aux coordonnÃ©es ar et dec dans le mode transit ou tracking */
+bool Goto(std::string ar, std::string dec, bool Transit)
+{
+/**************************************************************************************
+** Diriger l'antenne vers les coordonnÃ©es ar et dec et suivre l'objet
+** en activant le mode transit ou tracking.
+** si J2000 == true, cela signifie que les coordonnÃ©es ar et dec sont donnÃ©es dans le
+** le systÃšme de coordonnÃ©es J2000 (Ã©cliptique et Ã©quinoxe du 1 janvier 2000 Ã  0 h TU)
+** Des calculs supplÃ©mentaires (prÃ©cession, nutation, abÃ©rration) sont alors nÃ©cessaires
+***************************************************************************************/
+bool BAOcontrol::Goto(string ar, string dec, bool Transit, bool J2000)
+{
+    float  ar1, ar2, ar3;
+    float  dec1, dec2, dec3;
+    double arf, decf;
+    double azi, hau;
+     /*
+     //Pour les tests
+     ar="05:39:14.8";
+     dec="23:19:24.1";
+     printf("JJ=%10.10f\n", GetJJ());
+     J2000=true;
+     */
+    // Conversion de l'AD et de la dÃ©clinaison en radians
+    Decomposition(ar, 2, &ar1, &ar2, &ar3);
+    Decomposition(dec, 0, &dec1, &dec2, &dec3);
+    arf  = ( ar1  + ar2 / 60.0  + ar3 / 3600.0 ) * 15.0 * Pidiv180;
+    decf = ( fabs(dec1) + dec2 / 60.0 + dec3 / 3600.0 ) * Pidiv180;
+    if (dec[0]=='-') decf = -decf;
+    // calculs pupplÃ©mentaires pour se ramener
+    // Ã  l'Ã©poque de l'observation
+    if (J2000)
+    {
+        Precession(&arf, &decf);
+        NutationEtoile(&arf, &decf);
+        AberrationAnnuelle(&arf, &decf);
+    }
+    // on rÃ©Ã©crit l'ar et la dec dans le format d'indi_BAO
+    ar  = DHMS(arf * N180divPi, true);
+    dec = DHMS(decf * N180divPi, false);
+    // on en informe l'utilisateur
+    Affiche("CoordonnÃ©es apparentes de l'objet :\n", true);
+    Affiche("AD=" + ar  + "   Dec=" + dec +"\n", true);
+    /*
+    //Tests
+    Azimut(arf, decf, &azi, &hau);
+    hau=RefractionAtmospherique(hau);
+    Affiche("CoordonnÃ©es rectangulaires liÃ©es au lieu d'observation :\n", true);
+    printf("Azimut = %s   Hauteur = %s\n", DHMS(azi*N180divPi,false).c_str(), DHMS(hau*N180divPi, false).c_str());
+    */
+    // On transmet les coordonnÃ©es au pilote BAO
     try
+    {
 …
     catch ( SocketException& e)
+    {
+        os << e.description() << "\n";
+        Erreur(os.str());
+        Erreur("Exception was caught:" + e.description() + "\n");
         return false;
+    }
+    os << "Les nouvelles coordonnÃ©es AD=" << ar << "  DEC=" << dec << " ont Ã©tÃ© envoyÃ©es au pilote indi_BAO.\n\n";
+    Affiche(os.str(), true);
+    Affiche("Les nouvelles coordonnÃ©es AD=" + ar + " Dec=" + dec, true);
+    Affiche(" ont Ã©tÃ© envoyÃ©es au pilote indi_BAO.\n\n", true);
     return true;
+}
+/*se connecter ou se dÃ©connecter au pilote indi_BAO */
+bool Connect(bool connect)
+/**************************************************************************************
+** Se connecte ou se dÃ©connecte au pilote indi_BAO
+***************************************************************************************/
+bool BAOcontrol::Connect(bool connect)
+{
     try
 …
     catch ( SocketException& e )
+    {
+        os << "Exception was caught:" << e.description() << std::endl;
+        Erreur(os.str());
+        Erreur("Exception was caught:" + e.description() + "\n");
         return false;
+    }
 …
         Affiche("La connexion a Ã©tÃ© Ã©tablie avec le pilote indi_BAO.\n\n", true);
         EncoyerCoordGeographiques();
+        EnvoyerCoordGeographiques();
+    }
     else
+    {
         Affiche("Confirmation de la dÃ©connexion avec le pilote indi_BAO.\n\n", true);
+        Affiche("BAOcontrol s'est bien dÃ©connectÃ© du pilote indi_BAO.\n\n", true);
+    }
 …
+/* Lecture des mouvements planifiÃ©s dans le fichier fileName */
+bool LectureFichierMouvements(char * fileName)
+{
+    char * section =(char * )malloc(80);
+    char * key = (char *)malloc(80);
+    char * chaine = (char *)malloc(80);
+    char * value;
+    Astro * AstroJJ;
+/**************************************************************************************
+** Lecture des mouvements planifiÃ©s contenus dans le fichier fileName
+***************************************************************************************/
+bool BAOcontrol::LectureFichierMouvements(string fileName)
+{
+    string section;
+    string key;
+    char * value   = NULL;
+    stringstream os;
     float a1, a2, a3, h;
     numobjets=1;
+    os << "Lecture du fichier " << fileName << std::endl << std::endl;
+    Affiche(os.str(), true);
+    strcpy(section, "objet 1");
+    strcpy(key, "date");
+    while ((readINI(section, key, &value, fileName)) && (numobjets<MAXOBJETS))
+    {
+        os << "object nÂ°" << numobjets << std::endl;
+        Affiche(os.str(), true);
+        strcpy(key, "date");
+        if ((readINI(section, key, &value, fileName)) && (Decomposition(value, 3, &a1, &a2, &a3)))
+        {
+            os << "Date du dÃ©but de l'observation : le " << value;
+            Affiche(os.str(), true);
+            AstroJJ = new Astro();
+            AstroJJ->Jour=a1;
+            AstroJJ->Mois=a2;
+            AstroJJ->Annee=a3;
+            AstroJJ->CalculJJ(0.0);
+            objets[numobjets].JJ=AstroJJ->JJ;
+            delete AstroJJ;
+    Affiche("Lecture du fichier " + fileName +"\n\n", true);
+    //Lecture de la rubrique ParamÃštres
+    section = "parametres";
+    key     = "mode";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        Transit = ( strstr(value, "transit") != NULL);
+        delete [] value;
+        if (Transit) Affiche("Mode transit activÃ©.\n", true);
+        else Affiche("Mode tracking activÃ©.\n", true);
+    }
+    else
+    {
+        Erreur("Le parametre mode est incorrect.\n");
+        return false;
+    }
+    key = "J2000";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        J2000 = ( strstr(value, "on") != NULL);
+        delete [] value;
+        if (J2000) Affiche("Mode J2000 activÃ©.\n\n", true);
+        else Affiche("Mode J2000 dÃ©sactivÃ©.\n\n", true);
+    }
+    else
+    {
+        Erreur("Le parametre J2000 est incorrect.\n");
+        return false;
+    }
+    // Lecture de la liste des observations
+    section = "objet 1";
+    key     = "date";
+    while ((readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+            && (numobjets<MAXOBJETS))
+    {
+        os << "object nÂ°" << numobjets << endl;
+        Affiche(&os, true);
+        delete [] value;
+        value = NULL;
+        // Lecture de la date et de l'heure de l'observation
+        key = "date";
+        if ((readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+                && (Decomposition(value, 3, &a1, &a2, &a3)))
+        {
+            Affiche("Date du dÃ©but de l'observation : le " + (string)value, true);
+            delete [] value;
+            value = NULL;
+            objets[numobjets].JJ = CalculJJ(a3, a2, a1, 0.0);
+        }
         else
+        {
             os << "La date de la rubrique [objet " << numobjets << "] est incorrecte !" << std::endl;
+            Erreur(os.str());
+            os << "La date de la rubrique [objet " << numobjets << "] est incorrecte !" << endl;
+            Erreur(&os);
             return false;
+        }
+        strcpy(key, "heure");
+        if ((readINI(section, key, &value, fileName)) && (Decomposition(value, 2, &a1, &a2, &a3)))
+        {
+            os << " Ã  " <<  value ;
+            Affiche(os.str(), true);
+            objets[numobjets].JJ+=(a1+a2/60.0+a3/3600.0)/24.0;
+            sprintf(chaine, " TU  -> JJ=%10.5f\n", objets[numobjets].JJ);
+            Affiche(chaine, true);
+            for (int i=1; i<numobjets; i++)
+            {
+              if (objets[i].JJ==objets[numobjets].JJ)
+              {
+                os << "Attention, les observations des objets " << i << " et " << numobjets << " sont dÃ©finies Ã  la mÃªme date !\n";
+                Erreur(os.str());
+              }
+              if (objets[i].JJ+objets[i].Duree/3600/24.0>objets[numobjets].JJ)
+              {
+                os << "Attention, les observations des objets " << i << " et " << numobjets << " se chevauchent !\n";
+                Erreur(os.str());
+              }
+            }
+        key = "heure";
+        if ((readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+                && (Decomposition(value, 2, &a1, &a2, &a3)))
+        {
+            Affiche(" Ã  " + (string)value, true) ;
+            delete [] value;
+            value = NULL;
+            objets[numobjets].JJ += ( a1 + a2 / 60.0 + a3 / 3600.0 ) / 24.0;
+            os << " TU  -> JJ=" << fixed << objets[numobjets].JJ << scientific << endl;
+            Affiche(&os, true);
+            for (int i=1; i<numobjets; i++)
+            {
+                if (objets[i].JJ==objets[numobjets].JJ)
+                {
+                    os << "Attention, les observations des objets " << i << " et ";
+                    os << numobjets << " sont dÃ©finies Ã  la mÃªme date !" << endl;
+                    Erreur(&os);
+                }
+                if (objets[i].JJ+objets[i].Duree/3600/24.0>objets[numobjets].JJ)
+                {
+                    os << "Attention, les observations des objets " << i << " et " ;
+                    os << numobjets << " se chevauchent !" << endl;
+                    Erreur(&os);
+                }
+            }
+        }
         else
+        {
             os << "L'heure de la rubrique [objet " << numobjets << "] est incorrecte !" << std::endl;
             Erreur(os.str());
+            os << "L'heure de la rubrique [objet " << numobjets << "] est incorrecte !" << endl;
+            Erreur(&os);
             return false;
+        }
         strcpy(key, "duree");
+        // Lecture de la durÃ©e de l'observation
+        key = "duree";
         objets[numobjets].Duree=0.0;
         if (readINI(section, key, &value, fileName))
+        {
            os << "DurÃ©e de l'observation : " << value << " secondes" << std::endl;
            Affiche(os.str(), true);
            objets[numobjets].Duree=atof(value);
+        if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+        {
+            Affiche("DurÃ©e de l'observation : " + (string)value + " secondes\n", true);
+            objets[numobjets].Duree=atof(value);
+            delete [] value;
+            value = NULL;
+        }
         else
+        {
             os << "La duree d'observation de la rubrique [objet " << numobjets << "] est incorrecte !" << std::endl;
             Erreur(os.str());
+            os << "La duree d'observation de la rubrique [objet " << numobjets << "] est incorrecte !\n";
+            Erreur(&os);
             return false;
+        }
+        strcpy(key, "ad");
+        strcpy(objets[numobjets].ad, "");
+        if ((readINI(section, key, &value, fileName)) && (Decomposition(value, 2, NULL, NULL, NULL)))
+        {
+            os << "Ascension droite de l'objet : " << value << std::endl;
+            Affiche(os.str(), true);
+            strcpy(objets[numobjets].ad, value);
+        // Lecture de l'ascension droite de l'objet
+        key = "ad";
+        objets[numobjets].ad = "";
+        if ((readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+                && (Decomposition(value, 2, NULL, NULL, NULL)))
+        {
+            Affiche("Ascension droite de l'objet : " + (string)value + "\n", true);
+            objets[numobjets].ad = value;
+            delete [] value;
+            value = NULL;
+        }
         else
+        {
+            os << "L'ascension droite de la rubrique [objet " << numobjets << "] est incorrecte !" << std::endl;
+            Erreur(os.str());
+            os << "L'ascension droite de la rubrique [objet " << numobjets << "] est incorrecte !";
+            os << endl;
+            Erreur(&os);
             return false;
+        }
+        strcpy(key, "de");
+        strcpy(objets[numobjets].de, "");
+        if ((readINI(section, key, &value, fileName)) && (Decomposition(value, 0, NULL, NULL, NULL)))
+        {
+            os << "DÃ©clinaison de l'objet : " << value << std::endl << std::endl;
+            Affiche(os.str(), true);
+            strcpy(objets[numobjets].de, value);
+        // Lecture de la dÃ©clinaison de l'objet
+        key = "de";
+        objets[numobjets].de = "";
+        if ((readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+                && (Decomposition(value, 0, NULL, NULL, NULL)))
+        {
+            Affiche("DÃ©clinaison de l'objet : " + (string)value + "\n\n", true);
+            objets[numobjets].de = value;
+            delete [] value;
+            value = NULL;
+        }
         else
+        {
+            os << "La dÃ©clinaison de la rubrique [objet " << numobjets << "] est incorrecte !" << std::endl;
+            Erreur(os.str());
+            os << "La dÃ©clinaison de la rubrique [objet " << numobjets << "] est incorrecte !";
+            os << endl;
+            Erreur(&os);
             return false;
+        }
+        objets[numobjets].exec=false;
+        objets[numobjets].exec = false;
+        // On passe Ã  l'objet suivant
         numobjets++;
+        sprintf(section, "objet %i", numobjets);
+    }
+        os << "objet "<< numobjets;
+        section = os.str();
+        os.str("");
+    }
+    if (value) delete [] value;
     return true;
+}
+/*Execute le fichier de mouvements */
+bool Run(std::string fichier)
+{
+    bool exec=LectureFichierMouvements((char *)fichier.c_str());
+    CalculJourJulien();
+    if (exec && numobjets>1)
+    {
+        if (objets[numobjets-1].JJ+objets[numobjets-1].Duree/3600.0/24.0 < astro->JJ)
+/**************************************************************************************
+** Execute le fichier de mouvements
+***************************************************************************************/
+bool BAOcontrol::Run(string fichier)
+{
+    stringstream os;
+    bool exec = LectureFichierMouvements(fichier);
+    Update();
+    if ( exec && numobjets>1 )
+    {
+        // Si le chargement du fichier s'est bien dÃ©roulÃ© et qu'il y a plus d'un mouvement dedans
+        if (objets[numobjets-1].JJ + objets[numobjets-1].Duree / 3600.0 / 24.0 < GetJJ())
+        {
             Erreur("Le fichier contient des dates qui sont toutes pÃ©rimÃ©es. ExÃ©cution annulÃ©e.\n\n");
             if (exitrun) NoExit=false;
+            NoExit=!exitrun;
             return false;
+        }
         else
+        {
+            os << "Execution du fichier " << fichier << " en attente..." << std::endl << std::endl;
+            Affiche(os.str(), true);
+            Affiche("Execution du fichier " + fichier + " en attente...\n\n", true);
             run=true;
+        }
 …
     else
+    {
+        os << std::endl << "Le fichier " << fichier << " contient des erreurs ou n'existe pas...\n" << std::endl << std::endl;
+        Erreur(os.str());
+        if (exitrun) NoExit=false;
+        Erreur("\nLe fichier " + fichier + " contient des erreurs ou n'existe pas...\n\n\n");
+        NoExit=!exitrun;
         return false;
+    }
 …
+/*identification des commandes entrÃ©es par l'utilisateur */
+void DecodageEntreesUtilisateur(std::string chaine)
+{
+    std::string ar, de, fichier;
+    if (chaine.find("goto")!=string::npos)
+    {
+/**************************************************************************************
+** DÃ©composition et vÃ©rification des dates, heures, AD et dÃ©clinaisons
+**
+** type = 0 -> DÃ©clinaison/latitude
+** type = 1 -> longitude
+** type = 2 -> AD ou heure
+** type = 3 -> date
+**
+** Exemple de Decomposition("15:23:12", 2, a, b, c) retourne a=15, b=23, c=12
+** si la chaine a un format incorrect, la fct retourne false
+***************************************************************************************/
+bool BAOcontrol::Decomposition(string chaine, char type, float *a1, float *a2, float *a3)
+{
+    string car, s;
+    float a, b, c;
+    // pour les heures et les coordonnÃ©es, on attend ":" comme caractÃšre sÃ©parateur, sinon
+    // on attend d'avoir des "/" pour une date
+    (type==3) ? car="/" : car=":";
+    // Y a-t-il 2 caractÃšres ':' ou '/' dans la chaine ?
+    // C'est indispensable dans tous les cas
+    int test=0;
+    for (int i=0; i<chaine.length(); i++) if (chaine[i] == car[0]) test++;
+    if (test<2) return false;
+    // Extraction des trois nombres
+    s = chaine.substr(0, chaine.find(car));
+    a = atoi(s.c_str());
+    s = chaine.substr(chaine.find(car)+1, chaine.rfind(car) - chaine.find(car) - 1);
+    b = atoi(s.c_str());
+    s = chaine.substr(chaine.rfind(car)+1);
+    c = Arrondi(atof(s.c_str())*100.0)/100.0;
+    //vÃ©rification de la cohÃ©rence des infos contenues dans la chaine
+    if (type < 3 )
+    {
+        // pour une dÃ©clinaison
+        if ((type==0) && (a>90.0  || a<-90.0)) return false;
+        // pour une AD
+        if ((type==1) && (a>360.0 || a<0.0  )) return false;
+        // pour une heure
+        if ((type==2) && (a>23.0  || a<0.0  )) return false;
+        // pour les minutes
+        if (b<0.0 || b>59.0 ) return false;
+        //pour les secondes
+        if (c<0.0 || c>=60.0) return false;
+    }
+    else
+    {
+        //pour les jours
+        if (a<0.0 || a>31.0) return false;
+        //pour les mois
+        if (b<0.0 || b>12.0) return false;
+    }
+    if (a1!=NULL) *a1 = a;
+    if (a2!=NULL) *a2 = b;
+    if (a3!=NULL) *a3 = c;
+    return true;
+}
+/**************************************************************************************
+** identification des commandes entrÃ©es par l'utilisateur
+** puis exÃ©cution des commandes
+***************************************************************************************/
+void BAOcontrol::DecodageEntreesUtilisateur(string chaine)
+{
+    string ar, de, objet, fichier;
+    stringstream os;
+    // Permet de savoir si la derniÃšre saisie de l'utilisateur
+    // est une commande valide
+    bool CommandeOK = false;
+    // Commande goto
+    if ( chaine.find("goto") != string::npos )
+    {
+        CommandeOK = true;
+        // L'utilisateur a fait suivre la commande goto de l'indication J2000
+        if (J2000 = (chaine.find("j2000") != string::npos))
+        {
+            Affiche("Prise en compte de la prÃ©cession, de la nutation et de l'aberration...\n", true);
+            // On je garde que la premiÃšre partie de la chaine avant J2000
+            chaine = chaine.substr(0, chaine.find("J2000"));
+        }
         if (DecompositionCommande(chaine, "goto", &ar, &de) && Decomposition(ar, 2, NULL, NULL, NULL) && Decomposition(de, 0, NULL, NULL, NULL))
+        {
+            Goto(ar, de, Transit);
+            // L'utilisateur a indiquÃ© deux coordonnÃ©es valides -> on exÃ©cute le goto
+            Goto(ar, de, Transit, J2000);
+        }
         else
+        {
+            Erreur("Erreur goto : le format de la commande est goto AD DEC\n \
+            // L'utilisateur a indiquÃ© un nom d'objet aprÃšs le goto -> on lance la recherche sur internet
+            // puis on envoie les coordonnÃ©es de l'objet au pilote indi_BAO
+            if ((DecompositionCommande(chaine, "goto", &objet, NULL)) && (chaine.find(":") == string::npos))
+            {
+                Coordonnees reponse;
+                if (objet != "sun")
+                {
+                    reponse = ServeurNED(objet);
+                    if (reponse.ar!="" && reponse.dec!="")  Goto(reponse.ar, reponse.dec, Transit, true);
+                }
+                else
+                {
+                    printf(" lancement\n");
+                    CalculARDecSoleil(&reponse);
+                    printf("%s   %s \n", reponse.ar.c_str(), reponse.dec.c_str());
+                    Goto(reponse.ar, reponse.dec, Transit, false);
+                }
+            }
+            else
+            {
+                Erreur("Erreur goto : le format de la commande est goto AD DEC\n \
                     L AD doit Ãªtre de la forme xx:yy:zz   (ex: 12:00:03 pour 12h 0m 3s)\n \
+                    La dÃ©clinaison doit Ãªtre de la forme +/-xx:yy:zz (ex: -12:50:01 pour -12Â° 50' 01'')\n\n");
+        }
+    }
+    if (chaine.find("abort")!=string::npos)
+    {
+                    La dÃ©clinaison doit Ãªtre de la forme +/-xx:yy:zz (ex: -12:50:01 pour -12Â° 50' 01'')\n\n \
+                    Il est egalement possible de faire suivre la commande d'un nom d'un objet\n \
+                    Exemple goto M 31 ou encore goto ngc145\n \
+                    Ne pas prÃ©ciser dans ce cas J2000.\n\n");
+            }
+        }
+    }
+    // Annulation du suivi en cours
+    if (chaine.find("abort") != string::npos)
+    {
+        CommandeOK = true;
         Abort();
+        if (chaine.find("run")!=string::npos)
+        // Annulation de l'exÃ©cution d'un fichier de mouvements
+        if (chaine.find("run") != string::npos)
+        {
             run=false;
 …
             Affiche("Annulation de l'exÃ©cution du fichier de mouvements.\n\n", true);
+            return;
+        }
+    }
+    if (chaine.find("run")!=string::npos)
+    {
+            return;
+        }
+    }
+    // Lance l'exÃ©cution d'un fichier de mouvements
+    if (chaine.find("run") != string::npos)
+    {
+        CommandeOK = true;
         if (DecompositionCommande(chaine, "run", &fichier, NULL))
+        {
 …
+        }
+    }
+    if (chaine.find("connect")!=string::npos)
+    {
+        Connect(chaine.find("disconnect")==string::npos);
+    }
+    if (chaine.find("transit")!=string::npos)
+    {
+    // se connecte/dÃ©connecte au serveur
+    if (chaine.find("connect") != string::npos)
+    {
+        CommandeOK = true;
+        Connect(chaine.find("disconnect") == string::npos);
+    }
+    // Active le mode de suivi "transit"
+    if (chaine.find("transit") != string::npos)
+    {
+        CommandeOK = true;
         Affiche("Mode transit activÃ©.\n\n", true);
         Transit=true;
+    }
+    if (chaine.find("tracking")!=string::npos)
+    {
+    // Active le mode de suivi "tracking"
+    if (chaine.find("tracking") != string::npos)
+    {
+        CommandeOK = true;
         Affiche("Mode tracking activÃ©.\n\n", true);
         Transit=false;
+    }
+    if (chaine.find("park")!=string::npos)
+    {
+    // Place les antennes en position de repos
+    if (chaine.find("park") != string::npos)
+    {
+        CommandeOK = true;
         Park();
+    }
+    if (chaine.find("help")!=string::npos)
+    {
+        std::cout << std::endl;
+        std::cout << "connect : connecte le pilote INDI" << std::endl;
+        std::cout << "disconnect : ferme la connexion avec le pilote INDI" << std::endl;
+        std::cout << "goto AD Dec : pointe l'objet aux coordonnÃ©es AD Dec" << std::endl;
+        std::cout << "transit : mode de suivi transit" << std::endl;
+        std::cout << "tracking : mode de suivi tracking" << std::endl;
+        std::cout << "run filename : execute le fichier filename" << std::endl;
+        std::cout << "abort run : annule l'exÃ©cution du fichier de mouvements" << std::endl;
+        std::cout << "abort : annule le mouvement en cours" << std::endl;
+        std::cout << "park : place les antennes en position de repos" << std::endl;
+        std::cout << "exit : sortir de BAOControl" << std::endl;
+        std::cout << std::endl;
+    }
+    // interroge un serveur de temps pour mettre l'horloge du PC Ã  jour
+    if (chaine.find("updatetime") != string::npos)
+    {
+        CommandeOK = true;
+        int rc = system("sntp -s fr.pool.ntp.org");
+        if (WEXITSTATUS(rc) ==-1 || WEXITSTATUS(rc) ==127)
+        {
+            Erreur("La commande sntp n'est pas accessible. Merci de vÃ©rifier.\n\n");
+        }
+    }
+    // Affiche tous les paramÃštres du programme
+    if (chaine.find("status") != string::npos)
+    {
+        CommandeOK = true;
+        os << "Latitude = " << (string)LatitudeChar << "\n";
+        os << "Longitude = " << (string)LongitudeChar << "\n\n";
+        os << "Serveur Indi = " << (string)Serveur << "\n";
+        os << "Port du serveur Indi = " << Port << "\n\n";
+        os << "Pression atmosphÃ©rique  = " << Pression << " mBar\n";
+        os << "TempÃ©rature = " << Temperature << " Â°C\n\n";
+        Affiche(&os, true);
+        if (Transit) Affiche("Mode Transit activÃ©.\n\n", true);
+        else Affiche ("Mode Tracking activÃ©.\n\n", true);
+    }
+    // interroge le serveur NED sur internet -> retourne les coordonnÃ©es de l'objet
+    if (chaine.find("search")!=string::npos)
+    {
+        string objet;
+        CommandeOK = true;
+        if (DecompositionCommande(chaine, "search", &objet, NULL))
+        {
+            ServeurNED(objet);
+        }
+    }
+    // Aide du programme
+    if (chaine.find("help") != string::npos)
+    {
+        CommandeOK = true;
+        cout << endl;
+        cout << "connect :           se connecte au pilote indi_BAO." << endl;
+        cout << "disconnect :        se dÃ©connecte du pilote indi_BAO." << endl;
+        cout << "goto AD Dec :       pointe l'objet situÃ© aux coordonnÃ©es apparentes AD Dec." << endl;
+        cout << "                    AD doit Ãªtre au format xx:yy:zz et dec au format +/-xx:yy:zz" << endl;
+        cout << "                    exemple goto 12:10:05 -05:10:11 permettra de pointer l'objet" << endl;
+        cout << "                    situÃ© aux coordonnÃ©es AD=12h10m5s et dec=-5Â°10'11''" << endl;
+        cout << "goto AD Dec J2000 : pointe l'objet situÃ© aux coordonnÃ©es AD Dec dans le repÃšre J2000." << endl;
+        cout << "                    Avant de pointer l'objet, le programme calcule la prÃ©cession, la nutation et l'aberration" << endl;
+        cout << "                    pour ramener les coordonnÃ©es Ã  l'Ã©cliptique et Ã  l'Ã©quinoxe de l'observation." << endl;
+        cout << "goto nom_objet :    interroge la base NED pour trouver les coordonnÃ©es de l'objet puis le pointe." << endl;
+        cout << "                    exemples: goto m 31, goto messier 1, goto ngc 175, goto ic 434 etc..." << endl;
+        cout << "                    Dans ce mode, les coordonnÃ©es sont automatiquement rapportÃ©es" << endl;
+        cout << "                    Ã  l'Ã©cliptique et Ã  l'Ã©quinoxe de l'observation." << endl;
+        cout << "                    Aussi, merci de ne pas faire suivre les coordonnÃ©es de l'indication J2000."<< endl;
+        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 << "transit :           active le mode de suivi transit." << endl;
+        cout << "tracking :          active le mode de suivi tracking." << endl;
+        cout << "status :            liste les paramÃštres du programme." << endl;
+        cout << "run filename :      exÃ©cute le fichier de mouvements filename." << endl;
+        cout << "abort run :         annule l'exÃ©cution du fichier de mouvements." << endl;
+        cout << "abort :             annule le mouvement en cours." << endl;
+        cout << "park :              place les antennes en position de repos." << endl;
+        cout << "updatetime :        synchronise l'horloge du PC avec un serveur de temps." << endl;
+        cout << "exit :              sortir de BAOControl." << endl;
+        cout << endl;
+    }
+    // Bye !
     if (chaine.find("exit")!=string::npos)
+    {
+        Connect (false);
+        NoExit=false;
+    }
+}
+/* chargement des paramÃštres dans le fichier params */
+bool ChargementParametres()
+{
+    char * section =(char * )malloc(80);
+    char * key = (char *)malloc(80);
+        CommandeOK = true;
+        Abort();
+        Connect(false);
+        NoExit = false;
+    }
+    // La commande n'a pas Ã©tÃ© identifiÃ©e !
+    if (!CommandeOK) Erreur("Commande inconnue... Tapez help pour obtenir la liste des commandes disponibles.\n\n");
+}
+/**************************************************************************************
+** Interroge le serveur NED sur internet et retourne les coordonnÃ©es dans le repÃšre J2000
+** Si pas de rÃ©ponse, alors message d'erreur et les coordonnÃ©es sont Ã©gales Ã  AR="" dec=""
+***************************************************************************************/
+Coordonnees BAOcontrol::ServeurNED(string objet)
+{
+    Coordonnees reponse;
+    stringstream send;
+    FILE *pFile = NULL;
+    int rc;
+    //initialsation des variables de retour
+    reponse.ar = "";
+    reponse.dec = "";
+    // le nom de l'objet ne doit pas contenir des espace pour la requÃªte NED
+    // on les remplace par des '+'
+    for (int i=0; i<objet.length(); i++) if (objet[i] == ' ') objet[i]='+';
+    // Effacer le fichier result s'il existe dans le rÃ©pertoire du programme
+    if ((pFile = fopen ("result", "r")) != NULL )
+    {
+        fclose (pFile);
+        rc = system( "rm result");
+    }
+    // On utilise l'utilitaire curl pour passer la requÃªte au serveur NED
+    // On sauvegarde le rÃ©sultat dans le fichier result
+    send << "curl >> result \"http://ned.ipac.caltech.edu/cgi-bin/nph-objsearch?objname=";
+    send << objet;
+    send << "&extend=no&hconst=73&omegam=0.27&omegav=0.73&corr_z=1&out_csys=Equatorial&out_equinox=J2000.0";
+    send << "&obj_sort=RA+or+Longitude&of=ascii_bar&zv_breaker=30000.0&list_limit=5&img_stamp=NO\"";
+    Affiche("Envoi de la requÃªte au serveur NED...\n", true);
+    // on lance la requÃªte
+    rc = system(send.str().c_str() );
+    // traitement du rÃ©sultat
+    if (WEXITSTATUS(rc) ==-1 || WEXITSTATUS(rc) ==127)
+    {
+        Erreur("La commande curl n'est pas accessible. Merci de vÃ©rifier.\n\n");
+    }
+    else
+    {
+        // On a obtenu quelque chose
+        int nbRead = 0;
+        char *pBuf;
+        pBuf = new char [100000];
+        // On laisse un peu de temps au serveur pour rÃ©pondre.
+        // C'est pas vraiment indispensable mais bon...
+        sleep(1);
+        // On ouvre le fichier result
+        pFile = fopen ("result", "r");
+        if (pFile)
+        {
+            nbRead = readline (pFile, pBuf);
+            // Si le fichier n'est pas vide
+            if (nbRead!=-1)
+            {
+                if (strstr(pBuf, "Error") != NULL)
+                {
+                    // Le fichier contient une indication d'erreur -> pas de rÃ©ponse exploitable
+                    Affiche("\nLe serveur NED n'a pas trouvÃ© de rÃ©ponse Ã  votre demande...\n", true);
+                }
+                else
+                {
+                    // on analyse la rÃ©ponse
+                    Affiche("\nRÃ©ponse du serveur :\n", true);
+                    do
+                    {
+                        // on cherche la premiÃšre suggestion de NED
+                        // Il faudra peut-Ãªtre un peu complexifier par la suite
+                        if (pBuf[0] == '1')
+                        {
+                            string chaine = (string)pBuf;
+                            string chaine2;
+                            chaine=chaine.substr(chaine.find('|')+1);
+                            // affiche le nom de l'objet dans le serveur NED
+                            Affiche(chaine.substr(0, chaine.find('|')) + "\n", true);
+                            chaine = chaine.substr(chaine.find('|') + 1);
+                            chaine2 = chaine.substr(0, chaine.find('|'));
+                            double ar = atof(chaine2.c_str());
+                            // affiche l'ascension droite
+                            Affiche("AD (J2000) = " + DHMS(ar, true) + "\n", true);
+                            reponse.ar = DHMS(ar, true);
+                            chaine=chaine.substr(chaine.find('|')+1);
+                            chaine2 = chaine.substr(0, chaine.find('|'));
+                            double dec = atof(chaine2.c_str());
+                            // on affiche la dÃ©clinaison
+                            Affiche("Dec (J2000) = " + DHMS(dec, false)+"\n", true);
+                            reponse.dec = DHMS(dec, false);
+                        }
+                        nbRead = readline (pFile, pBuf);
+                    } while (nbRead!=-1);
+                }
+            }
+            else
+            {
+                Erreur("\nLa connexion semble impossible avec le serveur NED !\n\n");
+            }
+            fclose(pFile);
+        }
+        else
+        {
+            Erreur("\nLa connexion semble impossible avec le serveur NED !\n\n");
+        }
+        delete [] pBuf;
+        Affiche("\n", true);
+    }
+    return reponse;
+}
+/**************************************************************************************
+** Lecteur d'un fichier ligne aprÃšs ligne
+** retourne -1 Ã  la fin
+***************************************************************************************/
+int BAOcontrol::readline (FILE * pfile, char *tab)
+{
+    int nbchar = 0;
+    char c;
+    while ((c = getc (pfile)) != '\n')
+    {
+        if (c == EOF)
+        {
+            break;
+        }
+        tab[nbchar++] = c;
+    }
+    tab[nbchar] = '\0';
+    while (nbchar>0 && tab[nbchar-1]==' ')
+    {
+        tab[--nbchar] = '\0';
+    }
+    while (tab[0]==' ') for (int i=1; i<=nbchar; i++) tab[i-1] = tab[i];
+    if (c == EOF) nbchar=-1;
+    return (nbchar);
+}
+/**************************************************************************************
+** chargement des paramÃštres contenus dans le fichier params
+***************************************************************************************/
+bool BAOcontrol::ChargementParametres(string fileName)
+{
+    string section;
+    string key;
     char * value;
+    char * fileName = (char *)malloc(sizeof(char)*255);
+    stringstream os;
     Affiche("Lecture du fichier de configuration 'params' :\n\n", true);
+    strcpy(fileName,"params");
+    strcpy(section, "connexion indi");
+    strcpy(key, "serveur");
+    strcpy(Serveur, "");
+    if (readINI(section, key, &value, fileName))
+    {
+        strcpy(Serveur, value);
+        os << "serveur=" << Serveur << std::endl;
+        Affiche(os.str(), true);
+    /////////////////////////////////////////
+    // Rubrique CoodonnÃ©es gÃ©ographiques
+    section = "coordonnees geographiques";
+    key = "latitude";
+    if ((readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+            && (Decomposition(value, 0, NULL, NULL, NULL)))
+    {
+        LatitudeChar = (string)value;
+        delete [] value;
+        Affiche("latitude = " + LatitudeChar +"\n", true);
+    }
     else
+    {
+        os << "Nom du serveur invalide !" << std::endl;
+        Erreur("La latitude est incorrecte !\n");
+        return false;
+    }
+    key = "longitude";
+    if ((readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+            && (Decomposition(value, 1, NULL, NULL, NULL)))
+    {
+        LongitudeChar = (string)value;
+        delete [] value;
+        Affiche("longitude = " + LongitudeChar +"\n\n", true);
+    }
+    else
+    {
+        Erreur("La longitude est incorrecte !\n");
+        return false;
+    }
+    /////////////////////////////////////////
+    // rubrique connexion
+    section = "connexion indi";
+    key = "serveur";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        Serveur = (string)value;
+        delete [] value;
+        Affiche("serveur = " + Serveur +"\n", true);
+    }
+    else
+    {
+        Erreur("Nom du serveur invalide !\n");
+        return false;
+    }
+    key = "port";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        Port = (string)value;
+        delete [] value;
+        Affiche("port = " + Port +"\n\n", true);
+    }
+    else
+    {
+        Erreur("NumÃ©ro de port incorrect !\n");
+        return false;
+    }
+    /////////////////////////////////////////
+    // Rubrique paramÃštres de l'atmosphÃšre
+    section = "atmosphere";
+    key = "pression";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        Pression = atof(value);
+        delete [] value;
+        os << "pression = " << Pression << endl;
+        Affiche(&os, true);
+    }
+    else
+    {
+        os << "La pression atmosph&rique est incorrecte !" << endl;
+        Erreur(&os);
+        return false;
+    }
+    key = "temperature";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        Temperature=atof(value);
+        delete [] value;
+        os << "tempÃ©rature = " << Temperature << endl << endl;
+        Affiche(&os, true);
+    }
+    else
+    {
+        Erreur("La tempÃ©rature est incorrecte !\n");
+        return false;
+    }
+    /////////////////////////////////////////
+    // Rubrique suivi
+    section = "suivi";
+    key = "mode";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        Transit = (strstr(value, "transit") != NULL);
+        Affiche("mode suivi = " + (string)value + "\n", true);
+        delete [] value;
+    }
+    else
+    {
+        Erreur("Le paramÃštre mode est incorrect !\n");
+        return false;
+    }
+    key = "delai_transit";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        delaitransit=atoi(value);
+        delete [] value;
+        os << "delai transit = " << delaitransit << " sec" << endl;
+        Affiche(&os, true);
+    }
+    else
+    {
+        Erreur("Le paramÃštre delai_transit est incorrect !\n");
+        return false;
+    }
+    key = "delai_tracking";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        delaitracking=atoi(value);
+        delete [] value;
+        os << "delai tracking = " << delaitracking << " sec" << endl << endl;
+        Affiche(&os, true);
+    }
+    else
+    {
+        Erreur("Le paramÃštre delai_tracking est incorrect !\n");
+        return false;
+    }
+    /////////////////////////////////////////
+    // Rubrique divers
+    section = "divers";
+    key = "couleurs";
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        ChoixCouleurs=atoi(value);
+        delete [] value;
+    }
+    else
+    {
+        /*os << "Le paramÃštre couleurs est incorrect !" << endl;
         Erreur(os.str());
+        return false;
+    }
+    strcpy(key, "port");
+    if (readINI(section, key, &value, fileName))
+    {
+        Port=atoi(value);
+        os << "port=" << Port << std::endl << std::endl;
+        Affiche(os.str(), true);
+    }
+    else
+    {
+        os << "NumÃ©ro de port incorrect !" << std::endl;
+        Erreur(os.str());
+        return false;
+    }
+    strcpy(section, "coordonnees geographiques");
+    strcpy(Latitude, "");
+    strcpy(Longitude, "");
+    strcpy(key, "latitude");
+    if ((readINI(section, key, &value, fileName)) && (Decomposition(value, 0, NULL, NULL, NULL)))
+    {
+        strcpy(Latitude, value);
+        os << "latitude=" << Latitude << std::endl;
+        Affiche(os.str(), true);
+    }
+    else
+    {
+        os << "La latitude est incorrecte !" << std::endl;
+        Erreur(os.str());
+        return false;
+    }
+    strcpy(key, "longitude");
+    if ((readINI(section, key, &value, fileName)) && (Decomposition(value, 1, NULL, NULL, NULL)))
+    {
+        strcpy(Longitude, value);
+        os << "longitude=" << Longitude << std::endl << std::endl;
+        Affiche(os.str(), true);
+    }
+    else
+    {
+        os << "La longitude est incorrecte !" << std::endl;
+        Erreur(os.str());
+        return false;
+    }
+    strcpy(section, "transit");
+    strcpy(key, "delai");
+    if (readINI(section, key, &value, fileName))
+    {
+        delaitransit=atoi(value);
+        os << "delai transit= " << delaitransit << " sec" << std::endl;
+        Affiche(os.str(), true);
+    }
+    else
+    {
+        os << "Le paramÃštre transit est incorrect !" << std::endl;
+        Erreur(os.str());
+        return false;
+    }
+    strcpy(section, "tracking");
+    strcpy(key, "delai");
+    if (readINI(section, key, &value, fileName))
+    {
+        delaitracking=atoi(value);
+        os << "delai tracking= " << delaitracking << " sec" << std::endl << std::endl;
+        Affiche(os.str(), true);
+    }
+    else
+    {
+        os << "Le paramÃštre tracking est incorrect !" << std::endl;
+        Erreur(os.str());
+        return false;
+        return false;*/
+    }
 …
+int main(int argc, char **argv)
+{
+    std::string chaine;
+/**************************************************************************************
+** Routine principale
+***************************************************************************************/
+int BAOcontrol::init(int argc, char **argv)
+{
+    string chaine;
     pthread_t th1;
+    if (argc >1)
+    // gestion au dÃ©marrage des paramÃštres en ligne de commande
+    if ( argc >1 )
+    {
         if (strstr(argv[1], "-h")!=NULL)
+        {
             std::cout << "usage :\n \
+            cout << "usage :\n \
        BAOControl -h ou --help : affiche l'aide\n \
        BAOControl -r FileName : execute les mouvements dÃ©finis dans le fichier FileName\n\n";
+       BAOControl -r FileName : exÃ©cute les mouvements dÃ©finis dans le fichier FileName\n\n";
             return 0;
 …
+    }
+    for (int i=0; i<MAXANTENNES; i++)
+    {
+        Antennes[i].ok=0;
+        Antennes[i].ip=0;
+    }
+    for (int i=0; i<MAXOBJETS; i++)
+    {
+        objets[i].JJ=0;
+        objets[i].exec=false;
+    }
+    Affiche("\n\n\n\n\n\n \
+    ************************\n \
+    *      BAO Control     *\n \
+    *         v0.1         *\n \
+    *      10/11/2010      *\n \
+    ************************\n\n", true);
+    if (!ChargementParametres())
+    {
+        Erreur("Le fichier de configuration 'params' contient des erreurs ou n'existe pas. Merci de vÃ©rifier.\n");
+        exit(1);
+    }
+    client_socket = new ClientSocket("localhost", Port );
+    Connect(true);
+    if (argc == 1)  std::cout << "Tapez help pour obtenir des infos sur les commandes disponibles.\n" << std::endl;
+    if (argc == 1)  cout << "Tapez help pour obtenir la liste des commandes disponibles.\n" << endl << endl;
+    // On lance la fenÃªtre graphique
     initialiserFenetre();
 …
     XSelectInput(d,w, ExposureMask );
+    if (pthread_create(&th1, NULL, my_thread_process, NULL) < 0) {
+    // On lance le thread pour gÃ©rer la fenÃªtre graphique
+    // la communication avec indi_BAO et le suivi des objets
+    if (pthread_create(&th1, NULL, (void*(*)(void*))LancementThread, this) < 0) {
         Erreur("Impossible de crÃ©er le thread\n");
+        exit (1);
+    }
+    astro = new Astro();
+        return -1;
+    }
+    // si on a utilisÃ© l'option -r en ligne de commande
+    // alors on charge et on lance l'exÃ©cution d'un fichier de mouvements
     if (argc == 3)
 …
             Run(argv[2]);
+            // on attend ici la fin de l'exÃ©cution du fichier de mouvements
             do
 …
     else
+    {
+        // Saisie et dÃ©codage des commandes entrÃ©es par l'utilisateur
         do
+        {
+            std::cout << blue << '>';
+            getline(std::cin, chaine);
+            std::cout << black;
+            // Prompt
+            ChoixCouleurs==1 ? cout << blue1 : cout << blue2;
+            cout << '>';
+            // saisie
+            getline(cin, chaine);
+            ChoixCouleurs==1 ? cout << grey1 : cout << grey2;
+            // on met en minuscules
             for (int i=0; i<chaine.size();++i) chaine[i] = tolower(chaine[i]);
+            // on dÃ©code et exÃ©cute les commandes
             DecodageEntreesUtilisateur(chaine);
+        }
         while (NoExit);
+    }
     delete astro;
     delete client_socket;
+        pthread_join(th1 ,NULL);
+        //pthread_detach(th1);
+    }
     return 0;

BAORadio/libindi/libindi/BAOControl/baocontrol.h

-                      r502
+                      r504
+// Definition of the Astro BAOcontrol
+// Franck RICHARD
+// BAORadio
+#ifndef BAOcontrol_class
+#define BAOcontrol_class
 #include <iostream>
 #include <string.h>
 …
 #include "SocketException.h"
 #include <stdio.h>
+#include <stdlib.h>
 #include <pthread.h>
 #include <X11/Xlib.h>
 #include "filetools.h"
 #include "astro.h"
+#include "../drivers/telescope/astro.h"
 #include "math.h"
 #include <time.h>
 …
+#define red "\033[0;31m"
+#define blue "\033[0;34m"
+#define green "\033[0;32m"
+#define black "\033[0;30m"
+// couleurs utilisÃ©es dans le terminal
+#define red1 "\033[0;31m"
+#define blue1 "\033[0;34m"
+#define green1 "\033[0;32m"
+#define black1 "\033[0;30m"
+#define grey1 "\033[1;30m"
+#define red2 "\033[1;31m"
+#define blue2 "\033[1;34m"
+#define green2 "\033[1;32m"
+#define black2 "\033[1;30m"
+#define grey2 "\033[1;37m"
+// limites des tableaux
 #define MAXLOG 1000
 #define MAXOBJETS 100
 #define MAXANTENNES 100
+#define MAXANTENNES 50
+#define larg 600
+#define haut 10+30*12
+//dimensions de la fenÃªtre graphique
+#define haut_fenetre 10+22*10
+#define larg_fenetre 605
 using namespace std;
 …
 struct DefAntenne
+{
     unsigned char ip;
+    unsigned char ip;                   // Adresse ip d'une antenne
     char ok;
+    char ok;                            // actuellement disponible ?
 };
+// objets stockÃ©s dans le fichier de mouvements
 struct DefObjets
+{
     double JJ;
     double Duree;
     char ad[10];
     char de[10];
     bool exec;
+    double JJ;                          // Jour julien oÃ¹ le tÃ©lescope doit aller pointer vers l'objet
+    double Duree;                       // DurÃ©e de l'observation de l'objet en sec
+    string ad;                          // Ascension droite J2000 de l'objet
+    string de;                          // dÃ©clinaison J2000 de l'objet
+    bool exec;                          // En cours d'exÃ©cution ?
 };
-char Latitude[80];
-char Longitude[80];
-char Serveur[80];
+std::string logs[MAXLOG];
+class BAOcontrol : public Astro
+{
+std::stringstream os;
+public:
+    BAOcontrol();
+    ~BAOcontrol();
+int Port=0;
+int delaitransit=0;
+int delaitracking=0;
+int lognum=0;
+int numAntenne=0;
+int numobjets=0;
+int runnum=1;
+struct DefAntenne Antennes[MAXANTENNES];
+struct DefObjets objets[MAXOBJETS];
+bool NoExit=true;
+bool Transit=false;
+bool run=false;
+bool exitrun=false;
+ClientSocket *client_socket;
+Astro *astro;
+Display * d;
+Window w;
+Pixmap db;
+GC noir, vert, rouge, gris;
+    void *my_thread_process ();
+    int init(int argc, char **argv);
+void initialiserFenetre();
+void Dessiner();
+void rouler(char* reponse);
+void LireReponse();
+void *my_thread_process (void * arg);
+bool Decomposition(std::string chaine, char type, float *a1, float *a2, float *a3);
+bool DecompositionCommande(std::string chaine, std::string commande, std::string *chaine1, std::string *chaine2);
+bool EncoyerCoordGeographiques();
+bool Connect(bool connect);
+bool Park();
+bool Abort();
+bool Goto(std::string ar, std::string dec, bool Transit);
+bool LectureFichierMouvements(char * fileName);
+bool Run(std::string fichier);
+void DecodageFonction(std::string chaine);
+bool ChargementParametres();
+private:
+    void Affiche(string chaine, bool AfficheEcran);
+    void Affiche(stringstream *Message, bool AfficheEcran);
+    void Erreur(string chaine);
+    void Erreur(stringstream *Message);
+    void initialiserFenetre();
+    void Dessiner();
+    void rouler();
+    void LireReponse();
+    bool VerifReponse(string reponseattendue);
+    void Update();
+    bool Decomposition(string chaine, char type, float *a1, float *a2, float *a3);
+    bool DecompositionCommande(string chaine, string commande, string *chaine1, string *chaine2);
+    bool EnvoyerCoordGeographiques();
+    bool Park();
+    bool Abort();
+    bool Goto(string ar, string dec, bool Transit, bool J2000);
+    bool Connect(bool connect);
+    bool LectureFichierMouvements(string fileName);
+    void DecodageEntreesUtilisateur(string chaine);
+    bool Run(string fichier);
+    bool ChargementParametres(string fileName);
+    Coordonnees ServeurNED(string objet);
+    int  readline (FILE * pfile, char *tab);
+    // Variables globales
+    XFontStruct * fd;                           // Police de caractÃšres dans la fenÃªtre graphique
+    char ChoixCouleurs;                         // 1-pour un terminal Ã  fond blanc    2-pour un terminal Ã  fond noir
+    string logs[MAXLOG];                        // Sauvegarde de toutes les actions et rÃ©ponses dans un tableau logs
+    int delaitransit;                           // DÃ©lai entre deux actualisations de la position en mode transit
+    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 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
+    bool NoExit;                                // A-t-on tapÃ© exit pour sortir ? Permet de fermer le thread Ã  ce moment-lÃ
+    bool Transit;                               // Si oui, le mode transit est activÃ©, sinon, c'est le mode tracking
+    bool run;                                   // execute actuellement un fichier de mouvements
+    bool exitrun;                               // doit-on sortir du programme Ã  la fin de l'execution de la commande run ?
+    bool J2000;                                 // est-ce que les coordonnÃ©es du fichier de mouvements sont en coordonnÃ©es J2000 ?
+    struct DefAntenne *Antennes;                // Sauvegarde de la situation actuelle de l'antenne i
+    struct DefObjets  *objets;                  // Liste des objets chargÃ©s depuis un fichier de mouvements
+    string LatitudeChar;                        // Latitude du lieu d'observation. ChargÃ©e depuis le fichier de configuration
+    string LongitudeChar;                       // Longitude du lieu d'observation. ChargÃ©e depuis le fichier de configuration
+    string Serveur;                             // Nom ou IP du serveur faisant tourner indi_BAO. Par defaut c'est localhost
+    string Port;                                // Port utilisÃ© pour connecter le serveur indi_BAO
+    ClientSocket *client_socket;                // Socket permettant la connexion avec le pilote indi_BAO
+    Display * d;                                // contexte graphique
+    Window w;                                   // fenÃªtre graphique
+    Pixmap db;                                  // copie de la fenÃªtre pour permettre une actualisation sans scintillement
+    GC noir, vert, rouge, gris;                 // couleurs utilisÃ©es dans la fenÃªtre graphique
+};
+#endif

BAORadio/libindi/libindi/BAOControl/filetools.cpp

-                      r502
+                      r504
 #define MAX_LENGHT 255
 /******************************************************
 …
 readINI (char *sectionName, char *pKeyName, char **ppStr, char *fileName)
+{
+  INI *pIni = NULL;
+  SECTION *pSection = NULL;
+  KEY *pKey = NULL;
+  int trouve = 0;
+  char *pSectionName = NULL;
+  int offset = 0;
+  //pStr = resultValue;
+  TRY
+  {
+    INI *pIni = NULL;
+    SECTION *pSection = NULL;
+    KEY *pKey = NULL;
+    int trouve = 0;
+    char *pSectionName = NULL;
+    int offset = 0;
     trouve = 0;
     pIni = _loadINI (fileName);
+    if (!pIni) return 0;
     /*recherche de la section */
     offset = strlen (sectionName) + 3;
     pSectionName = (char *) m_malloc (sizeof (char) * offset);
+    pSectionName = new char [offset];
     pSectionName[0] = '[';
     strcpy (pSectionName + 1, sectionName);
 …
     pSection = _findSECTION (pIni, pSectionName);
+    delete [] pSectionName;
     if (pSection != NULL)
+      {
+    {
         /*recherche de la cle */
         pKey = _findKEY (pSection, pKeyName);
         if (pKey != NULL)
+        {
+          *ppStr = (char *) m_malloc (sizeof (char) * strlen (pKey->value) + 2);
+          strcpy (*ppStr, pKey->value);
+          (*ppStr)[strlen (pKey->value)] = '\0';
+          trouve = 1;
+        }
+      }
+  }
+  CATCH (ERR_FOPEN)
+  {
+    printf ("impossible d'ouvrir le fichier %s\n", fileName);
+    ppStr = NULL;
+  }
+  CATCH (ERR_MALLOC)
+  {
+    perror ("Probleme d'allocation memoire");
+    exit (EXIT_FAILURE);
+  }
+  ENDTRY;
+  return trouve;
+            *ppStr = new char [strlen (pKey->value) + 2];
+            strcpy (*ppStr, pKey->value);
+            (*ppStr)[strlen (pKey->value)] = '\0';
+            trouve = 1;
+        }
+    }
+    //On efface toutes les clÃ©s et toutes les sections
+    KEY *keyprev=NULL;
+    SECTION * secprev=NULL;
+    pSection=pIni->fils;
+    do
+    {
+        pKey=pSection->fils;
+        do
+        {
+            if (pKey->name) delete [] pKey->name;
+            if (pKey->value) delete [] pKey->value;
+            keyprev=pKey;
+            KEY *prev=pKey;
+            pKey=pKey->next;
+            delete prev;
+        } while (pKey!=keyprev);
+        if (pSection->name) delete []pSection->name;
+        secprev=pSection;
+        SECTION *sprev=pSection;
+        pSection=pSection->next;
+        delete sprev;
+    }  while (pSection!=secprev);
+    delete [] pIni->fileName;
+    delete pIni;
+    pIni=NULL;
+    return trouve;
+}
+int
+readINI (const char *sectionName, const char *pKeyName, char **ppStr, const char *fileName)
+{
+     return readINI((char*)sectionName, (char*)pKeyName, ppStr, (char*)fileName);
+}
 …
  * 1 si reussite de la suppression, 0 sinon           *
  ******************************************************/
+/*
 int
 delINI (char *sectionName, char *pKeyName, char **ppStr, char *fileName)
 …
     pIni = _loadINI (fileName);
     /*recherche de la section */
+    //recherche de la section
     offset = strlen (sectionName) + 3;
     pSectionName = (char *) m_malloc (sizeof (char) * offset);
 …
         if (pKeyName == NULL)
+          {
             /*on supprime toute la section */
+            //on supprime toute la section
             pKey = _lastKEY (pSection);
 …
         else
+          {
             /*recherche de la cle si indiquee */
+            //recherche de la cle si indiquee
             pKey = _findKEY (pSection, pKeyName);
             if (pKey != NULL)
 …
                 if (_delKEY (pKey))
+                  {
                     /*si la cle supprimee etait la derniere de la section */
+                    //si la cle supprimee etait la derniere de la section
                     _delSECTION (pSection);
+                  }
 …
   return del;
+}
+*/
 /******************************************************
  * NOM:                writeINI                       *
 …
  *  et la valeur de la cle est initialisee            *
  *  sinon la cle existante de la section existante est*
  *  mise a jour                                       *
+ *  mise a jour                                       *
  * ARGUMENTS:                                         *
  * ENVIRONNEMENT:                                     *
 …
  *  NULL si echec ou keyValue si reussite             *
  ******************************************************/
+char *
+writeINI (char *sectionName, char *keyName, char *keyValue, char *fileName)
+/*
+char * writeINI (char *sectionName, char *keyName, char *keyValue, char *fileName)
+{
   char *pSectionName = NULL;
 …
     pSectionName[strlen (sectionName) + 1] = ']';
     pSectionName[strlen (sectionName) + 2] = '\0';
     /*chargement */
+    //chargement
     pIni = _loadINI (fileName);
 …
   ENDTRY;
   /*recherche de la section */
+  //recherche de la section
   pSection = _findSECTION (pIni, pSectionName);
   /*recherche de la cle */
+  //recherche de la cle
   if (pSection != NULL)
+    {
 …
       else
+        {
           /*cle pas trouve dans la section, on ajoute la cle a la section */
+          //cle pas trouve dans la section, on ajoute la cle a la section
           pKey = _newKEY (pKeyName, pKeyValue);
           _addKEY (pSection, pKey);
 …
   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);
 …
+  {
     /*sauvegarde */
+    //sauvegarde
     _saveINI (pIni);
 …
   ENDTRY;
   /*nettoyage */
+  //nettoyage
   free (pIni);
 …
   return pKeyValue;
+}
+*/
 /******************************************************
 …
 _delKEY (KEY * pKey)
+{
   int result = 0;
   if (pKey != NULL)
+    {
       /*la cle n'est pas la premiere */
       if (pKey->prev != pKey)
+        {
           if (pKey->next != pKey)
+            {
               /*la cle n'est pas la derniere */
               pKey->prev->next = pKey->next;
+            }
           else
+            {
               result = 1;
               pKey->prev->next = pKey->prev;
+            }
+        }
       else
+        {
           if (pKey->next != pKey)
+            {
               /*la cle n'est pas non plus la derniere */
               pKey->parent->fils = pKey->next;
+            }
           else
+            {
               result = 1;
               pKey->parent->fils = NULL;
+            }
+        }
       _freeKEY (pKey);
       return result;
+    }
   else
+    {
       result = -1;
       return result;
+    int result = 0;
+    if (pKey != NULL)
+    {
+        /*la cle n'est pas la premiere */
+        if (pKey->prev != pKey)
+        {
+            if (pKey->next != pKey)
+            {
+                /*la cle n'est pas la derniere */
+                pKey->prev->next = pKey->next;
+            }
+            else
+            {
+                result = 1;
+                pKey->prev->next = pKey->prev;
+            }
+        }
+        else
+        {
+            if (pKey->next != pKey)
+            {
+                /*la cle n'est pas non plus la derniere */
+                pKey->parent->fils = pKey->next;
+            }
+            else
+            {
+                result = 1;
+                pKey->parent->fils = NULL;
+            }
+        }
+        _freeKEY (pKey);
+        return result;
+    }
+    else
+    {
+        result = -1;
+        return result;
+    }
+}
 …
 _delSECTION (SECTION * pSection)
+{
   if (pSection != NULL)
+    {
       /*la cle n'est pas la premiere */
       if (pSection->prev != pSection)
+        {
           /*la cle n'est pas la derniere */
           if (pSection->next != pSection)
+            {
               pSection->prev->next = pSection->next;
+            }
           else
+            {
               pSection->prev->next = pSection->prev;
+            }
+        }
       else
+        {
           /*la cle n'estpas nonplus la derniere */
           if (pSection->next != pSection)
+            {
               pSection->parent->fils = pSection->next;
               pSection->next->prev = pSection->next;
+            }
           else
+            {
               pSection->parent->fils = NULL;
+            }
+        }
       _freeSECTION (pSection);
       return 1;
+    }
   else
+    {
       return 0;
+    if (pSection != NULL)
+    {
+        /*la cle n'est pas la premiere */
+        if (pSection->prev != pSection)
+        {
+            /*la cle n'est pas la derniere */
+            if (pSection->next != pSection)
+            {
+                pSection->prev->next = pSection->next;
+            }
+            else
+            {
+                pSection->prev->next = pSection->prev;
+            }
+        }
+        else
+        {
+            /*la cle n'estpas nonplus la derniere */
+            if (pSection->next != pSection)
+            {
+                pSection->parent->fils = pSection->next;
+                pSection->next->prev = pSection->next;
+            }
+            else
+            {
+                pSection->parent->fils = NULL;
+            }
+        }
+        _freeSECTION (pSection);
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
 …
 _freeKEY (KEY * pKey)
+{
+  if (pKey != NULL)
+    {
+      pKey->parent = NULL;
+      pKey->next = NULL;
+      pKey->prev = NULL;
+      if (pKey->value != NULL)
+        {
+          free (pKey->value);
+        }
+      if (pKey->name != NULL)
+        {
+          free (pKey->name);
+        }
+      free (pKey);
+    if (pKey != NULL)
+    {
+        pKey->parent = NULL;
+        pKey->next = NULL;
+        pKey->prev = NULL;
+        if (pKey->value != NULL)
+        {
+            delete [] pKey->value;
+        }
+        if (pKey->name != NULL)
+        {
+            delete [] pKey->name;
+        }
+        delete pKey;
+        pKey=NULL;
+    }
+}
 …
 _freeSECTION (SECTION * pSection)
+{
+  if (pSection != NULL)
+    {
+      pSection->parent = NULL;
+      pSection->next = NULL;
+      pSection->prev = NULL;
+      if (pSection->name != NULL)
+        {
+          free (pSection->name);
+        }
+      free (pSection);
+    if (pSection != NULL)
+    {
+        pSection->parent = NULL;
+        pSection->next = NULL;
+        pSection->prev = NULL;
+        if (pSection->name != NULL)
+        {
+            delete [] pSection->name;
+        }
+        delete pSection;
+        pSection=NULL;
+    }
+}
 …
 _newKEY (char *pKeyName, char *pKeyValue)
+{
+  KEY *pKey;
+  TRY
+  {
+    pKey = (KEY *) m_malloc (sizeof (KEY));
+    pKey->name = (char *) m_malloc (sizeof (char) * strlen (pKeyName) + 1);
+    pKey->value = (char *) m_malloc (sizeof (char) * strlen (pKeyValue) + 1);
+  }
+  CATCH (ERR_MALLOC)
+  {
+    perror ("Probleme d'allocation memoire");
+    exit (EXIT_FAILURE);
+  }
+  ENDTRY;
+  strcpy (pKey->name, pKeyName);
+  strcpy (pKey->value, pKeyValue);
+  pKey->parent = NULL;
+  pKey->prev = pKey;
+  pKey->next = pKey;
+  return pKey;
+    KEY *pKey;
+    {
+        pKey = new KEY;
+        pKey->name = new char [strlen (pKeyName) + 1];
+        pKey->value = new char [strlen (pKeyValue) + 1];
+    }
+    strcpy (pKey->name, pKeyName);
+    strcpy (pKey->value, pKeyValue);
+    pKey->parent = NULL;
+    pKey->prev = pKey;
+    pKey->next = pKey;
+    return pKey;
+}
 …
 _newSECTION (char *pSectionName)
+{
+  SECTION *pSection;
+  TRY
+  {
+    pSection = (SECTION *) m_malloc (sizeof (SECTION));
+    pSection->name =
+      (char *) m_malloc (sizeof (char) * strlen (pSectionName) + 1);
+  }
+  CATCH (ERR_MALLOC)
+  {
+    perror ("Probleme d'allocation memoire");
+    exit (EXIT_FAILURE);
+  }
+  ENDTRY;
+  strcpy (pSection->name, pSectionName);
+  pSection->parent = NULL;
+  pSection->fils = NULL;
+  pSection->prev = pSection;
+  pSection->next = pSection;
+  return pSection;
+    SECTION *pSection;
+    {
+        pSection = new SECTION;
+        pSection->name = new char [strlen (pSectionName) + 1];
+    }
+    strcpy (pSection->name, pSectionName);
+    pSection->parent = NULL;
+    pSection->fils = NULL;
+    pSection->prev = pSection;
+    pSection->next = pSection;
+    return pSection;
+}
 …
 _findSECTION (INI * pIni, char *pSectionName)
+{
   SECTION *pSection = NULL;
   pSection = pIni->fils;
   while ((pSection != NULL) && (strcmp (pSection->name, pSectionName) != 0))
+    {
       if (pSection == pSection->next)
+        {
           pSection = NULL;
+        }
       else
+        {
           pSection = pSection->next;
+        }
+    }
   return pSection;
+    SECTION *pSection = NULL;
+    pSection = pIni->fils;
+    while ((pSection != NULL) && (strcmp (pSection->name, pSectionName) != 0))
+    {
+        if (pSection == pSection->next)
+        {
+            pSection = NULL;
+        }
+        else
+        {
+            pSection = pSection->next;
+        }
+    }
+    return pSection;
+}
 …
 _findKEY (SECTION * pSection, char *pKeyName)
+{
   KEY *pKey = NULL;
   pKey = pSection->fils;
   while ((pKey != NULL) && (strcmp (pKey->name, pKeyName) != 0))
+    {
       if (pKey == pKey->next)
+        {
           pKey = NULL;
+        }
       else
+        {
           pKey = pKey->next;
+        }
+    }
   return pKey;
+    KEY *pKey = NULL;
+    pKey = pSection->fils;
+    while ((pKey != NULL) && (strcmp (pKey->name, pKeyName) != 0))
+    {
+        if (pKey == pKey->next)
+        {
+            pKey = NULL;
+        }
+        else
+        {
+            pKey = pKey->next;
+        }
+    }
+    return pKey;
+}
 …
 _lastKEY (SECTION * pSection)
+{
   KEY *pKey_pred = NULL;
   KEY *pKey = NULL;
   pKey = pSection->fils;
   pKey_pred = pKey;
   while (pKey != NULL)
+    {
       pKey_pred = pKey;
       if (pKey == pKey->next)
+        {
           pKey = NULL;
+        }
       else
+        {
           pKey = pKey->next;
+        }
+    }
   return pKey_pred;
+    KEY *pKey_pred = NULL;
+    KEY *pKey = NULL;
+    pKey = pSection->fils;
+    pKey_pred = pKey;
+    while (pKey != NULL)
+    {
+        pKey_pred = pKey;
+        if (pKey == pKey->next)
+        {
+            pKey = NULL;
+        }
+        else
+        {
+            pKey = pKey->next;
+        }
+    }
+    return pKey_pred;
+}
 …
 _lastSECTION (INI * pIni)
+{
   SECTION *pSection_pred = NULL;
   SECTION *pSection = NULL;
   pSection = pIni->fils;
   pSection_pred = pSection;
   while (pSection != NULL)
+    {
       pSection_pred = pSection;
       if (pSection == pSection->next)
+        {
           pSection = NULL;
+        }
       else
+        {
           pSection = pSection->next;
+        }
+    }
   return pSection_pred;
+    SECTION *pSection_pred = NULL;
+    SECTION *pSection = NULL;
+    pSection = pIni->fils;
+    pSection_pred = pSection;
+    while (pSection != NULL)
+    {
+        pSection_pred = pSection;
+        if (pSection == pSection->next)
+        {
+            pSection = NULL;
+        }
+        else
+        {
+            pSection = pSection->next;
+        }
+    }
+    return pSection_pred;
+}
 …
  *  la section ne doit pas appartenir a une INI       *
  * ARGUMENTS:                                         *
  * la structure INI, la structure SECTION             *
+ * la structure INI, la structure SECTION             *
  * ENVIRONNEMENT:                                     *
  * VALEUR RETOURNEE:                                  *
 …
 _addSECTION (INI * pIni, SECTION * pSection)
+{
   SECTION *pSection_last = NULL;
   if (pSection->parent != NULL)
+    {
       return NULL;
+    }
   else
+    {
       pSection_last = _lastSECTION (pIni);
       pSection->parent = pIni;
       if (pSection_last != NULL)
+        {
           pSection_last->next = pSection;
           pSection->prev = pSection_last;
+        }
       else
+        {
           pIni->fils = pSection;
+        }
       return pSection;
+    SECTION *pSection_last = NULL;
+    if (pSection->parent != NULL)
+    {
+        return NULL;
+    }
+    else
+    {
+        pSection_last = _lastSECTION (pIni);
+        pSection->parent = pIni;
+        if (pSection_last != NULL)
+        {
+            pSection_last->next = pSection;
+            pSection->prev = pSection_last;
+        }
+        else
+        {
+            pIni->fils = pSection;
+        }
+        return pSection;
+    }
+}
 …
 _addKEY (SECTION * pSection, KEY * pKey)
+{
   KEY *pKey_last = NULL;
   if (pKey->parent != NULL)
+    {
       return NULL;
+    }
   else
+    {
       pKey_last = _lastKEY (pSection);
       pKey->parent = pSection;
       if (pKey_last != NULL)
+        {
           pKey_last->next = pKey;
           pKey->prev = pKey_last;
+        }
       else
+        {
           pSection->fils = pKey;
+        }
       pKey->next = pKey;
       return pKey;
+    KEY *pKey_last = NULL;
+    if (pKey->parent != NULL)
+    {
+        return NULL;
+    }
+    else
+    {
+        pKey_last = _lastKEY (pSection);
+        pKey->parent = pSection;
+        if (pKey_last != NULL)
+        {
+            pKey_last->next = pKey;
+            pKey->prev = pKey_last;
+        }
+        else
+        {
+            pSection->fils = pKey;
+        }
+        pKey->next = pKey;
+        return pKey;
+    }
+}
 …
 *  -1 si un probleme a eu lieu, 0 sinon              *
 ******************************************************/
+int
+/*
+ * int
 _saveINI (INI * pIni)
+{
 …
       while (pSection != pSection_pred);
+    }
   /*nettoyage */
+  //nettoyage
   fclose (pFile);
+}
+}*/
 /******************************************************
 …
 _loadINI (char *fileName)
+{
+  FILE *pFile = NULL;
+  char *pBuf;
+  int nbRead = 0;
+  SECTION *pSection = NULL;
+  KEY *pKey = NULL;
+  INI *pIni = NULL;
+  pBuf = (char *) m_malloc (sizeof (char) * MAX_LENGHT);
+  pFile = fopen (fileName, "r");
+  if (pFile == NULL)
+    {
+      pFile = fopen (fileName, "a");
+      if (pFile == NULL)
+        THROW (ERR_FOPEN);      /*encore NULL !!? la! il y a vraiment un probleme !! */
+    }
+  pIni = (INI *) m_malloc (sizeof (INI));
+  pIni->fileName = (char *) m_malloc (sizeof (char) * strlen (fileName) + 1);
+  strcpy (pIni->fileName, fileName);
+  pIni->fils = NULL;
+  /* on lit ligne par ligne */
+  nbRead = readline (pFile, pBuf);
+  while (nbRead != -1)
+    {
+      if ((pBuf[0] == '[') && (pBuf[strlen (pBuf) - 1] == ']'))
+        {
+          /* une section */
+          pSection = NULL;
+          pSection = _newSECTION (pBuf);
+          _addSECTION (pIni, pSection);
+        }
+      /* les cles de la section */
+      while (((nbRead = readline (pFile, pBuf)) !=-1) && (pBuf[0] != '['))
+        {
+          int ind = 0;
+          pKey = NULL;
+          if ((ind = _isKey (pBuf)) >= 0)
+            {
+              char *strName = NULL;
+              strName = (char *) m_malloc (sizeof (char) * ind + 1);
+              strncpy (strName, pBuf, ind);
+              strName[ind] = '\0';
+              pKey = _newKEY (strName, pBuf + ind + 1);
+              _addKEY (pSection, pKey);
+            }
+        }
+    }
+  /*nettoyage */
+  free (pBuf);
+  fclose (pFile);
+  return pIni;
+    FILE *pFile = NULL;
+    char *pBuf;
+    int nbRead = 0;
+    SECTION *pSection = NULL;
+    KEY *pKey = NULL;
+    INI *pIni = NULL;
+    pBuf = new char [MAX_LENGHT];
+    pFile = fopen (fileName, "r");
+    if (pFile == NULL)
+    {
+        pFile = fopen (fileName, "a");
+        if (pFile == NULL)
+        return NULL;
+    }
+    pIni = new INI;
+    pIni->fileName = new char [strlen (fileName) + 1];
+    strcpy (pIni->fileName, fileName);
+    pIni->fils = NULL;
+    /* on lit ligne par ligne */
+    nbRead = readline (pFile, pBuf);
+    if (nbRead==-1) { fclose(pFile); delete  [] pIni->fileName; delete pIni; delete [] pBuf; return 0;}
+    while (nbRead != -1)
+    {
+        if ((pBuf[0] == '[') && (pBuf[strlen (pBuf) - 1] == ']'))
+        {
+            /* une section */
+            pSection = NULL;
+            pSection = _newSECTION (pBuf);
+            _addSECTION (pIni, pSection);
+        }
+        /* les cles de la section */
+        while (((nbRead = readline (pFile, pBuf)) !=-1) && (pBuf[0] != '['))
+        {
+            int ind = 0;
+            pKey = NULL;
+            if ((ind = _isKey (pBuf)) >= 0)
+            {
+                char *strName = NULL;
+                strName = new char [ind + 1];
+                strncpy (strName, pBuf, ind);
+                strName[ind] = '\0';
+                pKey = _newKEY (strName, pBuf + ind + 1);
+                _addKEY (pSection, pKey);
+                delete [] strName;
+            }
+        }
+    }
+    /*nettoyage */
+    delete [] pBuf;
+    fclose (pFile);
+    return pIni;
+}
 …
 _isKey (char *str)
+{
   int ind = 0;
   for (ind; (ind < strlen (str)) && (str[ind] != '='); ind++);
   if (str[ind] == '=')
     return ind;
   else
     return -1;
+    int ind = 0;
+    for (ind; (ind < strlen (str)) && (str[ind] != '='); ind++);
+    if (str[ind] == '=')
+        return ind;
+    else
+        return -1;
+}
 …
  * VALEUR RETOURNEE:                                  *
  ******************************************************/
 void
+/*void
 _printINI (INI * pIni)
+{
 …
+    }
   printf ("\n#Fin du fichier INI#\n");
+}
+}*/
 /******************************************************
 …
  * VALEUR RETOURNEE:                                  *
  ******************************************************/
 void
+/*void
 _printSECTION (SECTION * pSection)
+{
 …
       while (pKey != pKey_pred);
+    }
+}
+}*/
 /******************************************************
 …
  * VALEUR RETOURNEE:                                  *
  ******************************************************/
+void
+/*
+ * void
 _printKEY (KEY * pKey)
+{
   printf ("%s=%s\n", pKey->name, pKey->value);
+}
+}*/
 /******************************************************
 …
  * VALEUR RETOURNEE:                                  *
  ******************************************************/
+void
+/*void
 printINI (char *file)
+{
 …
   _printINI (pIni);
   free (pIni);
+}
+}*/
 /******************************************************
 …
 jumpline (int nbline, FILE * pfile)
+{
   int compteur = 0, c;
   while ((compteur < nbline) && ((c = getc (pfile)) != EOF))
+    {
       if (c == '\n')
         compteur++;
+    }
   return (compteur);
+    int compteur = 0, c;
+    while ((compteur < nbline) && ((c = getc (pfile)) != EOF))
+    {
+        if (c == '\n')
+            compteur++;
+    }
+    return (compteur);
+}
 …
 readline (FILE * pfile, char *tab)
+{
+  int nbchar = 0;
+  char c;
+  while ((c = getc (pfile)) != '\n')
+    {
+      if (c == EOF)
+        {
+          break;
+        }
+      tab[nbchar++] = c;
+    }
+  tab[nbchar] = '\0';
+  while (nbchar>0 && tab[nbchar-1]==' ') { tab[--nbchar] = '\0';}
+  while (tab[0]==' ') for (int i=1; i<=nbchar; i++) tab[i-1]=tab[i];
+  if (c == EOF) nbchar=-1;
+  return (nbchar);
+    int nbchar = 0;
+    char c;
+    while ((c = getc (pfile)) != '\n')
+    {
+        if (c == EOF)
+        {
+            break;
+        }
+        tab[nbchar++] = c;
+    }
+    tab[nbchar] = '\0';
+    while (nbchar>0 && tab[nbchar-1]==' ') {
+        tab[--nbchar] = '\0';
+    }
+    while (tab[0]==' ') for (int i=1; i<=nbchar; i++) tab[i-1]=tab[i];
+    if (c == EOF) nbchar=-1;
+    return (nbchar);
+}
 …
  * VALEUR RETOURNEE:                                  *
  ******************************************************/
+void *
+m_malloc (size_t size)
+/*
+void * m_malloc (size_t size)
+{
   void *ptr = malloc (size);
 …
   else
     return ptr;
+}
+}*/

BAORadio/libindi/libindi/BAOControl/filetools.h

r502	r504
57	57
58	58	**********************************************************************************/
59
	59	int readINI (const char sectionName, const char pKeyName, char *ppStr, const char fileName);
60	60
61	61	char writeINI (char section, char key, char pKeyValue, char *fileName);

BAORadio/libindi/libindi/BAOControl/mouvements

-                      r502
+                      r504
+[parametres]
+mode=tracking
+J2000=on
 [objet 1]
 date=07/11/2010
 heure=14:19:00
+date=19/06/2011
+heure=22:52:00
 duree=30
 ad=12:25:00
 …
 [objet 2]
 date=07/11/2010
 heure=14:19:31
+date=19/06/2011
+heure=22:53:00
 duree=30
 ad=00:25:00
 de=89:00:00
+[objet 3]
+date=19/06/2011
+heure=22:54:00
+duree=30
+ad=00:25:00
+de=87:00:00

BAORadio/libindi/libindi/BAOControl/params

-                      r502
+                      r504
 [coordonnees geographiques]
 latitude=48:41:56
 longitude=2:10:13
+latitude=48:51:00
+longitude=2:19:59
+[transit]
+delai=100
+[atmosphere]
+pression=1013
+temperature=10
+[tracking]
+delai=5
+[suivi]
+mode=tracking
+delai_transit=100
+delai_tracking=5
+[divers]
+couleurs=1

BAORadio/libindi/libindi/BAOTest/BAOtest_main.cpp

r498	r504
69	69	result.y=0;
70	70
71		if (str.length()>2)
	71	if (str.length() > 2)
72	72	{
73	73	result.x=atoi(str.substr(2, 4).c_str());
…	…
203	203	if (Aleat)
204	204	{
205		sprintf(chaine, "POSITION/%0~~4i/%04~~i/\n", Pos.x, Pos.y);
	205	sprintf(chaine, "POSITION/%05i/%05i/\n", Pos.x, Pos.y);
206	206	}
207	207	else

BAORadio/libindi/libindi/CMakeLists.txt

-                      r501
+                      r504
 cmake_minimum_required(VERSION 2.4.7)
- if(COMMAND cmake_policy)
-      cmake_policy(SET CMP0003 NEW)
-    endif(COMMAND cmake_policy)
 ##################  INDI version  ################################
 set(INDI_SOVERSION "0")
 set(CMAKE_INDI_VERSION_MAJOR 0)
 set(CMAKE_INDI_VERSION_MINOR 7)
+set(CMAKE_INDI_VERSION_MINOR 8)
 set(CMAKE_INDI_VERSION_RELEASE 0)
 set(CMAKE_INDI_VERSION_STRING "${CMAKE_INDI_VERSION_MAJOR}.${CMAKE_INDI_VERSION_MINOR}.${CMAKE_INDI_VERSION_RELEASE}")
 …
 find_package(ZLIB REQUIRED)
+FIND_PACKAGE(Boost)
+IF (BOOST_FOUND)
+    INCLUDE_DIRECTORIES(${BOOST_INCLUDE_DIR})
+ENDIF()
 macro_optional_find_package(USB)
 macro_log_feature(LIBUSB_FOUND "libusb" "User level access to USB devices" "http://indi.sf.net" FALSE "" "Provides support for USB based drivers in INDI.")
+macro_log_feature(LIBUSB_FOUND "libusb" "User level access to USB devices" "http://www.libusb.org" FALSE "" "Provides support for USB based drivers in INDI.")
 macro_optional_find_package(CFITSIO)
 if (NOT CFITSIO_FOUND OR CFITSIO_VERSION_MAJOR LESS 3)
   message(FATAL_ERROR "CFITSIO version too old, Please install cfitsio 3.x and try again. http://indi.sf.net")
+  message(FATAL_ERROR "CFITSIO version too old, Please install cfitsio 3.x and try again. http://heasarc.gsfc.nasa.gov/fitsio/fitsio.html")
 endif (NOT CFITSIO_FOUND OR CFITSIO_VERSION_MAJOR LESS 3)
 …
 macro_log_feature(CFITSIO_FOUND "libcfitsio" "A library for reading and writing data files in FITS (Flexible Image Transport System) data format" "http://indi.sf.net" FALSE "3.03" "Provides INDI with FITS I/O support.")
-macro_optional_find_package(FLI)
-macro_log_feature(FLI_FOUND "libfli" "Finger Lakes Instrument Library" "http://indi.sourceforge.net/" FALSE "1.71" "Provides INDI with support for controlling FLI CCDS & Filter Wheels.")
 macro_optional_find_package(Nova)
 …
 check_include_files(termios.h TERMIOS_FOUND)
 macro_bool_to_01(TERMIOS_FOUND HAVE_TERMIOS_H)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config.h )
+if(COMMAND cmake_policy)
+ cmake_policy(SET CMP0003 NEW)
+endif(COMMAND cmake_policy)
 include_directories( ${CMAKE_CURRENT_BINARY_DIR})
 …
     include_directories(${NOVA_INCLUDE_DIR})
 endif (NOVA_FOUND)
-if (FLI_FOUND)
-    include_directories(${FLI_INCLUDE_DIR})
-endif (FLI_FOUND)
 set(liblilxml_SRCS  ${CMAKE_SOURCE_DIR}/libs/lilxml.c )
 …
+    )
 set (indibase_SRCS
+set (indiclient_SRCS
         ${CMAKE_SOURCE_DIR}/libs/indibase/basedriver.cpp
         ${CMAKE_SOURCE_DIR}/libs/indibase/baseclient.cpp
+    )
 set (indidefaultdevice_SRCS
+set (indidriver_SRCS
         ${CMAKE_SOURCE_DIR}/libs/indibase/basedriver.cpp
         ${CMAKE_SOURCE_DIR}/libs/indibase/defaultdriver.cpp
+        ${CMAKE_SOURCE_DIR}/libs/indibase/indiccd.cpp
+        ${CMAKE_SOURCE_DIR}/libs/indibase/inditelescope.cpp
+        ${CMAKE_SOURCE_DIR}/libs/indibase/indifilterwheel.cpp
+        ${CMAKE_SOURCE_DIR}/libs/indibase/indifocuser.cpp
+        ${CMAKE_SOURCE_DIR}/libs/indibase/indiusbdevice.cpp
+    )
 …
 install(TARGETS indiserver RUNTIME DESTINATION bin )
+######################################
+######## INDI Shared Library #########
+######################################
+#################################################
+############# INDI Shared Library ###############
+# To offer lilxml and communination routines    #
+# Mostly used by generic clients                #
+#################################################
 add_library(indi SHARED ${libindicom_SRCS} ${liblilxml_SRCS})
 target_link_libraries(indi m z)
 …
 target_link_libraries(indi ${CFITSIO_LIBRARIES})
 endif(CFITSIO_FOUND)
-if (FLI_FOUND)
-target_link_libraries(indi ${FLI_LIBRARIES})
-endif(FLI_FOUND)
 install(TARGETS indi LIBRARY DESTINATION lib${LIB_POSTFIX})
 set_target_properties(indi PROPERTIES VERSION ${CMAKE_INDI_VERSION_STRING} SOVERSION ${INDI_SOVERSION})
+######################################
+######## INDI Static Library #########
+######################################
+add_library(indidriver STATIC ${indimain_SRCS})
+##################################################
+############ INDI Main Static Library ############
+# To link with main() for 3rd party drivers      #
+##################################################
+add_library(indimain STATIC ${indimain_SRCS})
+install(TARGETS indimain ARCHIVE DESTINATION lib${LIB_POSTFIX})
+##################################################
+###### INDI Default Driver Static Library ########
+# To link with main() and indibase classes       #
+##################################################
+add_library(indidriver STATIC ${indimain_SRCS} ${indidriver_SRCS})
 install(TARGETS indidriver ARCHIVE DESTINATION lib${LIB_POSTFIX})
+##############################################
+######## INDI Default Driver Library #########
+##############################################
+add_library(indidefaultdriver STATIC ${indimain_SRCS} ${indidefaultdevice_SRCS})
+install(TARGETS indidefaultdriver ARCHIVE DESTINATION lib${LIB_POSTFIX})
+##############################################
+######## INDI Client Library #########
+##############################################
+add_library(indiclient STATIC ${indibase_SRCS})
+target_link_libraries(indiclient indi)
+##################################################
+########### INDI Client Static Library ###########
+##################################################
+add_library(indiclient STATIC ${indiclient_SRCS})
+target_link_libraries(indiclient indi pthread)
 install(TARGETS indiclient ARCHIVE DESTINATION lib${LIB_POSTFIX})
 …
 install(TARGETS indi_BAO RUNTIME DESTINATION bin )
+########### Syncscan ###############
+set(synscan_SRCS
+   ${indimain_SRCS}
+   ${CMAKE_SOURCE_DIR}/drivers/telescope/synscanmount.cpp )
+add_executable(indi_synscan ${synscan_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_synscan indidriver m z)
+if (NOVA_FOUND)
+  target_link_libraries(indi_synscan ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_synscan RUNTIME DESTINATION bin )
+########### Telescope Simulator ##############
+set(telescopesimulator_SRCS
+        ${indimain_SRCS}
+        ${CMAKE_SOURCE_DIR}/drivers/telescope/telescope_simulator.cpp
+   )
+add_executable(indi_simulator_telescope ${telescopesimulator_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_simulator_telescope indidriver ${CFITSIO_LIBRARIES} m z pthread)
+if (NOVA_FOUND)
+  target_link_libraries(indi_simulator_telescope ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_simulator_telescope RUNTIME DESTINATION bin )
 #####################################
 ########## FOCUSER GROUP ############
 #####################################
+###### FLI Precision Digital Focuser ######
+if (FLI_FOUND)
+set(flipdf_SRCS
+        ${indimain_SRCS}
+        ${CMAKE_SOURCE_DIR}/drivers/focuser/fli_pdf.c
+)
+add_executable(indi_fli_pdf ${flipdf_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_fli_pdf m ${FLI_LIBRARIES})
+if (NOVA_FOUND)
+  target_link_libraries(indi_fli_pdf ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_fli_pdf RUNTIME DESTINATION bin )
+endif(FLI_FOUND)
+########### CCD Simulator ##############
+if (CFITSIO_FOUND)
+set(ccdsimulator_SRCS
+        ${indimain_SRCS}
+        ${CMAKE_SOURCE_DIR}/drivers/ccd/ccd_simulator.cpp
+   )
+add_executable(indi_simulator_ccd ${ccdsimulator_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_simulator_ccd indidriver ${CFITSIO_LIBRARIES} m z pthread)
+if (NOVA_FOUND)
+  target_link_libraries(indi_simulator_ccd ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_simulator_ccd RUNTIME DESTINATION bin )
+endif (CFITSIO_FOUND)
+#####################################
+########## FOCUSER GROUP ############
+#####################################
 #################################################################################
 …
+   )
+add_executable(indi_robofocus ${robofocus_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_robofocus m)
+if (NOVA_FOUND)
+  target_link_libraries(indi_robofocus ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_robofocus RUNTIME DESTINATION bin )
+add_executable(indi_robo_focus ${robofocus_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_robo_focus m)
+if (NOVA_FOUND)
+  target_link_libraries(indi_robo_focus ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_robo_focus RUNTIME DESTINATION bin )
+################ Optec TCF-S ################
+set(tcfs_SRCS
+        ${indimain_SRCS}
+        ${CMAKE_SOURCE_DIR}/drivers/focuser/tcfs.cpp
+   )
+add_executable(indi_tcfs_focus ${tcfs_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_tcfs_focus indidriver m z)
+if (NOVA_FOUND)
+  target_link_libraries(indi_tcfs_focus ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_tcfs_focus RUNTIME DESTINATION bin )
+file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/make_tcfs_symlink.cmake
+"exec_program(${CMAKE_COMMAND} ARGS -E create_symlink ${BIN_INSTALL_DIR}/indi_tcfs_focus ${BUILD_ROOT}${BIN_INSTALL_DIR}/indi_tcfs3_focus)\n")
+set_target_properties(indi_tcfs_focus PROPERTIES POST_INSTALL_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/make_tcfs_symlink.cmake)
 #################################################################################
 …
 install(TARGETS indi_trutech_wheel RUNTIME DESTINATION bin )
+#################################################################################
+########## FLI Filter Wheel ############
+if (FLI_FOUND)
+set(fliwheel_SRCS
+        ${indimain_SRCS}
+        ${CMAKE_SOURCE_DIR}/drivers/filter_wheel/fli_wheel.c
+   )
+add_executable(indi_fli_wheel ${fliwheel_SRCS}  ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_fli_wheel ${FLI_LIBRARIES} m)
+if (NOVA_FOUND)
+  target_link_libraries(indi_fli_wheel ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_fli_wheel RUNTIME DESTINATION bin )
+endif (FLI_FOUND)
+#################################################################################
+#######################################
+############# CCD GROUP ###############
+#######################################
+############# FLI CCD ###############
+if (CFITSIO_FOUND AND FLI_FOUND)
+set(fliccd_SRCS
+        ${indimain_SRCS}
+        ${CMAKE_SOURCE_DIR}/drivers/ccd/fli_ccd.c
+)
+add_executable(indi_fli_ccd ${fliccd_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_fli_ccd ${FLI_LIBRARIES} ${CFITSIO_LIBRARIES} m z)
+if (NOVA_FOUND)
+  target_link_libraries(indi_fli_ccd ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_fli_ccd RUNTIME DESTINATION bin )
+endif (CFITSIO_FOUND AND FLI_FOUND)
+########### Filter Simulator ##############
+set(filtersimulator_SRCS
+        ${indimain_SRCS}
+        ${CMAKE_SOURCE_DIR}/drivers/filter_wheel/filter_simulator.cpp
+   )
+add_executable(indi_simulator_wheel ${filtersimulator_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(indi_simulator_wheel indidriver ${CFITSIO_LIBRARIES} m z pthread)
+if (NOVA_FOUND)
+  target_link_libraries(indi_simulator_wheel ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+install(TARGETS indi_simulator_wheel RUNTIME DESTINATION bin )
 #################################################################################
 …
 ### Meade Lunar Planetary Imager ########
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 if (CFITSIO_FOUND)
 …
 endif (CFITSIO_FOUND)
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 #################################################################################
 ########### V4L Philips ##############
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 if (CFITSIO_FOUND)
 …
 endif (CFITSIO_FOUND)
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 #################################################################################
 ########### Generic V4L Driver ###############
+if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 if (CFITSIO_FOUND)
 …
 endif (CFITSIO_FOUND)
+endif (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 #################################################################################
 …
 ########### Tutorial four ##############
+if (CFITSIO_FOUND)
 set(tutorialfour_SRCS
         ${indimain_SRCS}
 …
 add_executable(tutorial_four ${tutorialfour_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
 target_link_libraries(tutorial_four indidefaultdriver indiclient m z pthread)
+target_link_libraries(tutorial_four indidriver ${CFITSIO_LIBRARIES} m z pthread)
 if (NOVA_FOUND)
 …
 endif (NOVA_FOUND)
+endif (CFITSIO_FOUND)
 ########### Tutorial dome ##############
 …
 endif (NOVA_FOUND)
+#################################################################################
+install( FILES drivers.xml DESTINATION ${DATA_INSTALL_DIR})
+########### Client Tutorial ##############
+set(tutorialclient_SRCS
+        ${CMAKE_SOURCE_DIR}/examples/tutorial_client.cpp
+   )
+add_executable(tutorial_client ${tutorialclient_SRCS} ${liblilxml_SRCS} ${libindicom_SRCS})
+target_link_libraries(tutorial_client indiclient m)
+if (NOVA_FOUND)
+  target_link_libraries(tutorial_client ${NOVA_LIBRARIES})
+endif (NOVA_FOUND)
+#################################################################################
+install( FILES drivers.xml ${CMAKE_SOURCE_DIR}/drivers/focuser/indi_tcfs_sk.xml DESTINATION ${DATA_INSTALL_DIR})
 install( FILES indiapi.h indidevapi.h base64.h eventloop.h indidriver.h ${CMAKE_SOURCE_DIR}/libs/lilxml.h ${CMAKE_SOURCE_DIR}/libs/indibase/indibase.h
 ${CMAKE_SOURCE_DIR}/libs/indibase/basedriver.h  ${CMAKE_SOURCE_DIR}/libs/indibase/defaultdriver.h
+${CMAKE_SOURCE_DIR}/libs/indibase/indiccd.h  ${CMAKE_SOURCE_DIR}/libs/indibase/indifilterwheel.h
+${CMAKE_SOURCE_DIR}/libs/indibase/indifocuser.h  ${CMAKE_SOURCE_DIR}/libs/indibase/inditelescope.h
 ${CMAKE_SOURCE_DIR}/libs/indibase/baseclient.h ${CMAKE_SOURCE_DIR}/libs/indicom.h
+${CMAKE_SOURCE_DIR}/libs/indibase/indiusbdevice.h
  DESTINATION ${INCLUDE_INSTALL_DIR}/libindi COMPONENT Devel)
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libindi.pc.cmake ${CMAKE_CURRENT_BINARY_DIR}/libindi.pc @ONLY)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libindi.pc DESTINATION ${PKGCONFIG_INSTALL_PREFIX})

BAORadio/libindi/libindi/ChangeLog

-                      r501
+                      r504
+From 0.7.2 to 0.8
+      # TCF-S Focuser driver.
+      # Synscan Telescope driver.
+From 0.7.0 to 0.7.1
+      # Fixed change filter bug in true technology filter wheel. (JM)
+      # setINDI updated and improved. (ED)
+      # Improved INDI::Mediator functionality. (JM)
+      # Fixed buffer reading in INDI::BaseClient. (JM)
+      # Add new tutorial for INDI::BaseClient. (JM).
 From 0.6.2 to 0.7.0

BAORadio/libindi/libindi/INSTALL

-                      r501
+                      r504
 INDI Library Setup 0.7.0
+INDI Library Setup 0.8.0
 ========================
 …
 + cfitsio >= 3.0
-You can download packages for the dependencies above from SUSE BuildService:
-http://software.opensuse.org/search
-The packages are available for all major distributions.

BAORadio/libindi/libindi/README

-                      r501
+                      r504
 libindi v0.6.2
 ==============
+libindi v0.8
+============
 The code here demonstrates the use of INDI, an Instrument-Neutral Device
 …
         more stuff
+! For RCS Only -- Do Not Edit
+! @(#) $RCSfile$ $Date: 2004-02-03 09:34:32 +0300 (Tue, 03 Feb 2004) $ $Revision: 284704 $ $Name:  $

BAORadio/libindi/libindi/README.drivers

-                      r490
+                      r504
 You can find more up to date information on INDI drivers from the following sources:
 . INDI Device Profiles: http://indi.sf.net/devices.html
 . INDI Wiki: http://wiki.kde.org/tiki-index.php?page=indi
+. INDI Device Profiles: http://www.indilib.org
+. INDI Wiki: http://www.indilib.org

BAORadio/libindi/libindi/cmake_modules/FindFLI.cmake

r490	r504
45	45	else (FLI_FOUND)
46	46	if (FLI_FIND_REQUIRED)
47		message(FATAL_ERROR "FLI not found. Please install libfli~~1-devel. http://indi.sf.net~~")
	47	message(FATAL_ERROR "FLI not found. Please install libfli-dev. http://www.indilib.org")
48	48	endif (FLI_FIND_REQUIRED)
49	49	endif (FLI_FOUND)

BAORadio/libindi/libindi/cmake_modules/FindINDI.cmake

-                      r501
+                      r504
 #  INDI_INCLUDE_DIR - the INDI include directory
 #  INDI_LIBRARIES - Link these to use INDI
+#  INDI_DEVICE_LIBRARY - The indi default device library
+#  INDI_MAIN_LIBRARIES - Link to these to build INDI drivers with main()
+#  INDI_DRIVER_LIBRARIES - Link to these to build INDI drivers with indibase support
+#  INDI_CLIENT_LIBRARIES - Link to these to build INDI clients
 #  INDI_DATA_DIR - INDI shared data dir.
 # Copyright (c) 2010, Jasem Mutlaq <mutlaqja@ikarustech.com>
+# Copyright (c) 2011, Jasem Mutlaq <mutlaqja@ikarustech.com>
 # Based on FindLibfacile by Carsten Niehaus, <cniehaus@gmx.de>
+#
 …
 # For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 if (INDI_INCLUDE_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES)
+if (INDI_INCLUDE_DIR AND INDI_DATA_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES AND INDI_MAIN_LIBRARIES)
   # in cache already
 …
 else (INDI_INCLUDE_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES)
+else (INDI_INCLUDE_DIR AND INDI_DATA_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES AND INDI_MAIN_LIBRARIES)
   find_path(INDI_INCLUDE_DIR indidevapi.h
 …
  find_path(INDI_DATA_DIR drivers.xml
+    PATHS /usr/share /usr/local/share /opt ${GNUWIN32_DIR}/share
     PATH_SUFFIXES indi
+    /usr
+    /usr/local
+    /opt
+    ${GNUWIN32_DIR}/share
+  )
+  find_library(INDI_LIBRARIES NAMES indi
+    PATHS
+    ${_obLinkDir}
+    ${GNUWIN32_DIR}/lib
+  )
 …
+  )
   find_library(INDI_DEVICE_LIBRARIES NAMES indidefaultdevice
+  find_library(INDI_MAIN_LIBRARIES NAMES indimain
     PATHS
     ${_obLinkDir}
 …
+  )
+  find_library(INDI_LIBRARIES NAMES indi
+  find_library(INDI_CLIENT_LIBRARIES NAMES indiclient
     PATHS
     ${_obLinkDir}
 …
+  )
   if(INDI_INCLUDE_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES)
+  if(INDI_INCLUDE_DIR AND INDI_DATA_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES AND INDI_MAIN_LIBRARIES)
     set(INDI_FOUND TRUE)
   else (INDI_INCLUDE_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES)
+  else (INDI_INCLUDE_DIR AND INDI_DATA_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES AND INDI_MAIN_LIBRARIES)
     set(INDI_FOUND FALSE)
   endif(INDI_INCLUDE_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES)
+  endif(INDI_INCLUDE_DIR AND INDI_DATA_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES AND INDI_MAIN_LIBRARIES)
   if (INDI_FOUND)
     if (NOT INDI_FIND_QUIETLY)
+      message(STATUS "Found INDI: ${INDI_LIBRARIES}, ${INDI_DRIVER_LIBRARIES}")
+      message(STATUS "Found INDI: ${INDI_LIBRARIES}, ${INDI_MAIN_LIBRARIES}")
+      message(STATUS "INDI Include: ${INDI_INCLUDE_DIR}, INDI Data: ${INDI_DATA_DIR}")
     endif (NOT INDI_FIND_QUIETLY)
   else (INDI_FOUND)
     if (INDI_FIND_REQUIRED)
       message(FATAL_ERROR "indi-devel not found. Cannot compile INDI drivers. Please install indi-devel and try again. http://www.indilib.org")
+      message(FATAL_ERROR "indi-dev not found. Cannot compile INDI drivers. Please install indi-dev and try again. http://www.indilib.org")
     endif (INDI_FIND_REQUIRED)
   endif (INDI_FOUND)
   mark_as_advanced(INDI_INCLUDE_DIR INDI_LIBRARIES INDI_DRIVER_LIBRARIES INDI_DEVICE_LIBRARIES INDI_DATA_DIR)
+  mark_as_advanced(INDI_INCLUDE_DIR INDI_DATA_DIR INDI_LIBRARIES INDI_DRIVER_LIBRARIES INDI_MAIN_LIBRARIES INDI_CLIENT_LIBRARIES)
 endif (INDI_INCLUDE_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES)
+endif (INDI_INCLUDE_DIR AND INDI_DATA_DIR AND INDI_LIBRARIES AND INDI_DRIVER_LIBRARIES AND INDI_MAIN_LIBRARIES)

BAORadio/libindi/libindi/config.h.cmake

r490	r504
13	13	/* Define if you have libnova.h */
14	14	#cmakedefine HAVE_NOVA_H 1
	15

BAORadio/libindi/libindi/drivers.xml

-                      r490
+                      r504
 <devGroup group="Telescopes">
+        <device label="BAO" focal_length="" aperture="">
+                <driver name="BAO">indi_BAO</driver>
+                <version>1.0</version>
+        </device>
         <device label="LX200 Basic" focal_length="" aperture="">
                 <driver name="LX200 Basic">indi_lx200basic</driver>
-                <version>1.0</version>
-        </device>
-        <device label="BAO" focal_length="" aperture="">
-                <driver name="BAO">indi_BAO</driver>
                 <version>1.0</version>
         </device>
 …
                 <version>0.2</version>
         </device>
+        <device label="SynScan" focal_length="" aperture="">
+                <driver name="SynScan">indi_synscan</driver>
+                <version>1.0</version>
+        </device>
+        <device label="EQ6" focal_length="" aperture="">
+                <driver name="SynScan">indi_synscan</driver>
+                <version>1.0</version>
+        </device>
+        <device label="HEQ5" focal_length="" aperture="">
+                <driver name="SynScan">indi_synscan</driver>
+                <version>1.0</version>
+        </device>
+        <device label="NEQ3" focal_length="" aperture="">
+                <driver name="SynScan">indi_synscan</driver>
+                <version>1.0</version>
+        </device>
+        <device label="Telescope Simulator" focal_length="" aperture="">
+                <driver name="Telescope Simulator">indi_simulator_telescope</driver>
+                <version>1.0</version>
+        </device>
+</devGroup>
+<devGroup group="Focusers">
+        <device label="Robo Focus">
+                <driver name="Robofocus">indi_robo_focus</driver>
+                <version>0.1</version>
+        </device>
+        <device label="Optec TCF-S">
+                <driver name="Optec TCF-S">indi_tcfs_focus</driver>
+                <version>0.1</version>
+        </device>
+        <device label="Optec TCF-S3">
+                <driver name="Optec TCF-S">indi_tcfs3_focus</driver>
+                <version>0.1</version>
+        </device>
 </devGroup>
 <devGroup group="CCDs">
+        <device label="FLI CCD">
+                <driver name="FLI CCD">indi_fli_ccd</driver>
+                <version>1.0</version>
+        </device>
+</devGroup>
+<devGroup group="Focusers">
+        <device label="FLI PDF">
+                <driver name="FLI PDF">indi_fli_pdf</driver>
+                <version>0.1</version>
+        </device>
+        <device label="Robo Focus">
+                <driver name="Robofocus">indi_robofocus</driver>
+                <version>0.1</version>
+        </device>
+        <device label="CCD Simulator">
+                <driver name="CCD Simulator">indi_simulator_ccd</driver>
+                <version>0.1</version>
+        </device>
 </devGroup>
 <devGroup group="Filter Wheels">
 …
                 <version>0.1</version>
         </device>
+        <device label="Filter Simulator">
+                <driver name="Filter Simulator">indi_simulator_wheel</driver>
+                <version>0.1</version>
+        </device>
 </devGroup>
 <devGroup group="Video">

BAORadio/libindi/libindi/drivers/filter_wheel/trutech_wheel.c

-                      r501
+                      r504
                 unsigned char type = 0x03;
                 unsigned char chksum = COMM_INIT + type + COMM_FILL;
-                /*char filter_command[5] = { COMM_PRE, COMM_INIT, type, COMM_FILL, chksum };*/
                 unsigned char filter_command[CMD_SIZE];
+                snprintf(filter_command, CMD_SIZE,  "%c%c%c%c%c", COMM_PRE, COMM_INIT, type, COMM_FILL, chksum);
+                //snprintf(filter_command, CMD_SIZE,  "%c%c%c%c%c", COMM_PRE, COMM_INIT, type, COMM_FILL, chksum);
+                snprintf(filter_command, CMD_SIZE,  "%c%c%c%c", COMM_INIT, type, COMM_FILL, chksum);
                 if (checkPowerS(&HomeSP))
 …
                 if (DEBUG_ON)
+                {
                     IDLog("Home Search Command (int): #%d#%d#%d#%d#%d#\n",COMM_PRE, COMM_INIT, type, COMM_FILL, chksum);
                     IDLog("Home Search Command (char): #%c#%c#%c#%c#%c#\n",COMM_PRE, COMM_INIT, type, COMM_FILL, chksum);
+                    IDLog("Home Search Command (int): #%d#%d#%d#%d#\n",COMM_INIT, type, COMM_FILL, chksum);
+                    IDLog("Home Search Command (char): #%c#%c#%c#%c#\n",COMM_INIT, type, COMM_FILL, chksum);
+                }
 …
                         IUUpdateNumber(&FilterPositionNP, values, names, n);
+                        snprintf(filter_command, CMD_SIZE,  "%c%c%c%c%c", COMM_PRE, COMM_INIT, type, targetFilter, chksum);
+                        //snprintf(filter_command, CMD_SIZE,  "%c%c%c%c%c", COMM_PRE, COMM_INIT, type, targetFilter, chksum);
+                        snprintf(filter_command, CMD_SIZE,  "%c%c%c%c", COMM_INIT, type, targetFilter, chksum);
                         if (DEBUG_ON)
+                        {
                             IDLog("Filter Position Command (int): #%d#%d#%d#%d#%d#\n",COMM_PRE, COMM_INIT, type, targetFilter, chksum);
                             IDLog("Filter Position Command (char): #%c#%c#%c#%c#%c#\n",COMM_PRE, COMM_INIT, type, targetFilter, chksum);
+                            IDLog("Filter Position Command (int): #%d#%d#%d#%d#\n", COMM_INIT, type, targetFilter, chksum);
+                            IDLog("Filter Position Command (char): #%c#%c#%c#%c#\n", COMM_INIT, type, targetFilter, chksum);
+                        }

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

-                      r501
+                      r504
+#if 0
+/*
 #############################
 ##
 ## BAORadio Indi driver
 ## Franck RICHARD
+## Mai 2010
+## franckrichard033@gmail.com
+## Juin 2011
 ##
 #############################
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <math.h>
+#include <unistd.h>
+#include <time.h>
+#include <memory>
+#include <pthread.h>
+#include <iostream>
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <config.h>
+#include "indicom.h"
+#include "Socket.h"
+*/
 #include "BAO.h"
-using namespace std;
 auto_ptr<BAO> telescope(0);
 const int POLLMS = 1;                           // Period of update, 1 ms.
 const char *mydev = "BAO";                      // Name of our device.
+const int POLLMS = 1;                                   // Period of update, 1 ms.
+const char *mydev = "BAO";                              // Name of our device.
 const char *BASIC_GROUP    = "Main Control";            // Main Group
 …
 static void ISPoll(void *);
+static void retry_connection(void *);
+/**************************************************************************************
+**
+***************************************************************************************/
+void *pThreadSocket (void * arg)
+{
+    try
+    {
+        int pos = SocketsNumber;
+        // Trouver Ã©ventuellement un emplacement disponible dans l'intervalle [1..SocketsNumber]
+        /*
+        for (int i=1; i<SocketsNumber; i++)
+        {
+        if (!Sockets[i].Connected)
+        {
+        pos = i;
+        break;
+        }
+        }*/
+        server.accept ( Sockets[pos].new_sock );
+        Sockets[pos].IP=server.recupip(Sockets[pos].new_sock);
+        Sockets[pos].Connected=true;
+        if (pos == SocketsNumber ) SocketsNumber++;
+        InitThreadOK=true;
+    }
+    catch ( SocketException& e )
+    {
+        //A activer pour vÃ©rif
+        /*std::string oss;
+        oss="pThreadSocket exception : " + e.description() + "\n";
+        size_t size = oss.size() + 1;
+        char* buffer = new char[size];
+        strncpy(buffer, oss.c_str(), size);
+        IDLog(buffer);
+        delete [] buffer;*/
+    }
+    return NULL;
+}
+/**************************************************************************************
+** Utilisation d'un thread pour Ã©viter de bloquer l'execution du pilote
+** avec la commande accept
+***************************************************************************************/
+void BAO::InitThread()
+{
+    if (pthread_create (&th1, NULL, pThreadSocket, NULL) < 0)
+    {
+        IDLog("pthread_create error for threadSocket\n");
+    }
+    pthread_join (th1, NULL);
+}
+/**************************************************************************************
+** Initialisation du pilote BAO
+***************************************************************************************/
+void ISInit()
+{
+    static int isInit=0;
+    if (isInit) return;
+    if (telescope.get() == 0) telescope.reset(new BAO());
+    isInit = 1;
+    IEAddTimer (POLLMS, ISPoll, NULL);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void ISGetProperties (const char *dev)
+{
+    ISInit();
+    telescope->ISGetProperties(dev);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
+{
+    ISInit();
+    telescope->ISNewSwitch(dev, name, states, names, n);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n)
+{
+    ISInit();
+    telescope->ISNewText(dev, name, texts, names, n);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n)
+{
+    ISInit();
+    telescope->ISNewNumber(dev, name, values, names, n);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void ISPoll (void *p)
+{
+    INDI_UNUSED(p);
+    telescope->ISPoll();
+    IEAddTimer (POLLMS, ISPoll, NULL);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void ISNewBLOB (const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[], char *formats[], char *names[], int n)
+{
+    INDI_UNUSED(dev);
+    INDI_UNUSED(name);
+    INDI_UNUSED(sizes);
+    INDI_UNUSED(blobsizes);
+    INDI_UNUSED(blobs);
+    INDI_UNUSED(formats);
+    INDI_UNUSED(names);
+    INDI_UNUSED(n);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void ISSnoopDevice (XMLEle *root)
+{
+    INDI_UNUSED(root);
+}
+void* LancementThread(BAO * appli);
 /**************************************************************************************
 ** Initialisation de la classe BAO
 ***************************************************************************************/
 BAO::BAO()
+{
     init_properties();
+    ConnectSP.s = IPS_IDLE;
+    // tÃ©lescope en Ã©tat IDLE
+    ConnectSP.s    = IPS_IDLE;
+    // derniÃšre actualisation
+    lastRA         = 0.0;
+    lastDEC        = 0.0;
+    JJAnc          = 0.0;
+    currentSet     =  0;
     lastSet        = -1;
+    fd             = -1;
+    simulation     = false;
+    lastRA         = 0;
+    lastDEC        = 0;
+    currentSet     = 0;
+    JJAnc          = 0.0;
+    SocketsNumber  = 1;
+    ActualisationTM1 = 15.0*60.0;
+    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;
+    InitThreadOK=false;
+    LecturePosition=false;
+    Abort=false;
+    Park=false;
+    Goto=false;
+    LastGotoOK=true;
+    TrackingMode=1;
+    UpdateGoto      = true;
+    InitThreadOK    = false;
+    ActualisationPosition = false;
+    Abort           = false;
+    Park            = false;
+    Suivi            = false;
+    Exit            = false;
+    // initialisation des sockets (Antennes)
     for (int i=0; i<MAXHOSTNAME; i++)
+    {
 …
+    }
+    // initialisations supplÃ©mentaires
     InitAntennes();
+    // NumÃ©ro de version
     IDLog("Initilizing from BAO device...\n");
+    IDLog("Driver Version: 2010-11-10\n");
+    //enableSimulation(true);
+}
+/**************************************************************************************
+**
+    IDLog("Driver Version: 2011-06-27\n");
+    //connect_telescope();
+}
+/**************************************************************************************
+** Destructeur
+** Lorsque l'on lance indi_BAO depuis indiserver dans un terminal
+** Le destructeur ne semble jamais Ãªtre atteint lorsque l'on sort...
 ***************************************************************************************/
 BAO::~BAO()
+{
+}
+    Exit=true;
+    sleep(1);
+    pthread_join (th1, NULL);
+}
 /**************************************************************************************
 ** Initialisation des boutons et des zones d'affichage dans la boÃ®te de dialogue INDI
 ***************************************************************************************/
 void BAO::init_properties()
+{
 …
     IUFillTextVector(&ObjectTP, ObjectT, NARRAY(ObjectT), mydev, "OBJECT_INFO", "Object", BASIC_GROUP, IP_RW, 0, IPS_IDLE);
     // Equatorial Coords - SET
     IUFillNumber(&EquatorialCoordsWN[0], "RA", "RA  H:M:S", "%10.6m",  0., 24., 0., 0.);
 …
     IUFillNumberVector(&EquatorialCoordsWNP, EquatorialCoordsWN, NARRAY(EquatorialCoordsWN), mydev, "EQUATORIAL_EOD_COORD_REQUEST" , "Equatorial JNow", BASIC_GROUP, IP_WO, 0, IPS_IDLE);
-    // Equatorial Coords - READ
-    //    IUFillNumber(&EquatorialCoordsRN[0], "RA", "RA  H:M:S", "%10.6m",  0., 24., 0., 0.);
-    //    IUFillNumber(&EquatorialCoordsRN[1], "DEC", "Dec D:M:S", "%10.6m", -90., 90., 0., 0.);
-    //    IUFillNumberVector(&EquatorialCoordsRNP, EquatorialCoordsRN, NARRAY(EquatorialCoordsRN), mydev, "EQUATORIAL_EOD_COORD" , "Equatorial JNow", BASIC_GROUP, IP_RO, 0, IPS_IDLE);
     // Geographic coord - SET
     IUFillNumber(&GeographicCoordsWN[0], "LAT", "Lat  D", "%10.6m",  -90., 90., 0., 0.);
 …
     IUFillNumber(&ActualisationN2[0], "DELAY", "Tracking mode delay (Sec)", "%10.6m",  0., 3600., 0., 0.);
     IUFillNumberVector(&ActualisationNP2, ActualisationN2, NARRAY(ActualisationN2), mydev, "DELAY2" , "", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
+    // Transit threshold
+    //IUFillNumber(&SlewAccuracyN[0], "TransitRA",  "RA (arcmin)", "%10.6m",  0., 60., 1., 3.0);
+    //IUFillNumber(&SlewAccuracyN[1], "TransitDEC", "Dec (arcmin)", "%10.6m", 0., 60., 1., 3.0);
+    //IUFillNumberVector(&SlewAccuracyNP, SlewAccuracyN, NARRAY(SlewAccuracyN), mydev, "Transit Accuracy", "", OPTIONS_GROUP, IP_RW, 0, IPS_IDLE);
+    // Tracking threshold
+    //IUFillNumber(&TrackAccuracyN[0], "TrackingRA", "RA (arcmin)", "%10.6m",  0., 60., 1., 3.0);
+    //IUFillNumber(&TrackAccuracyN[1], "TrackingDEC", "Dec (arcmin)", "%10.6m", 0., 60., 1., 3.0);
+    //IUFillNumberVector(&TrackAccuracyNP, TrackAccuracyN, NARRAY(TrackAccuracyN), mydev, "Tracking Accuracy", "", OPTIONS_GROUP, IP_RW, 0, IPS_IDLE);
+}
+}
 /**************************************************************************************
 ** Initialisation de la boÃ®te de dialogue INDI (suite)
 ***************************************************************************************/
 void BAO::ISGetProperties(const char *dev)
+{
 …
     IDDefText(&ObjectTP, NULL);
     IDDefNumber(&EquatorialCoordsWNP, NULL);
-    //IDDefNumber(&EquatorialCoordsRNP, NULL);
     IDDefNumber(&GeographicCoordsWNP, NULL);
     IDDefSwitch(&OnCoordSetSP, NULL);
 …
     // Options
-    //IDDefNumber(&SlewAccuracyNP, NULL);
-    //IDDefNumber(&TrackAccuracyNP, NULL);
     IDDefNumber(&ActualisationNP1, NULL);
     IDDefNumber(&ActualisationNP2, NULL);
 …
+}
+/**************************************************************************************
+** En cas de changement de texte dans la boÃ®te de dialogue
+***************************************************************************************/
+/**************************************************************************************
+** 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
+***************************************************************************************/
 void BAO::ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n)
+{
 …
+}
 /**************************************************************************************
 ** En cas de changement d'une valeur numÃ©rique dans la boÃ®te de dialogue Indi
+***************************************************************************************/
+** Exemple : longitude, latitude, ar, dec etc...
+**
+***************************************************************************************/
 void BAO::ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n)
+{
 …
                 nset += Latitude >= -90.0 && Latitude <= 90.0;
                 Latitude*=Pidiv180;
+                Latitude *= Pidiv180;
+            }
             else if (eqp == &GeographicCoordsWN[1])
 …
                 nset += Longitude >= 0.0 && Longitude <= 360.0;
                 Longitude*=-Pidiv180;
+                Longitude *= -Pidiv180;
+            }
+        }
+        // Si la longitude et la latitude sont correctes
         if (nset == 2)
+        {
 …
             Longitude=0.0;
+        }
+        DefinirLongitudeLatitude(Longitude, Latitude);
         return;
 …
+        }
+        targetRA  = newRA;
+        targetDEC = newDEC;
+        // si les coordonnÃ©es de l'objet sont correctes
         if (nset == 2)
+        {
             char RAStr[32], DecStr[32];
             double targetAZ, targetAlt;
+            targetRA  = newRA;
+            targetDEC = newDEC;
             fs_sexa(RAStr, newRA, 2, 3600);
 …
                 if (newAct1 >= 0.0 && newAct1 <= 3600.0)
+                {
                     ActualisationTM1=newAct1;
+                    ActualisationTM1 = newAct1;
                     ActualisationNP1.s = IPS_OK;
 …
                 if (newAct2 >= 0.0 && newAct2 <= 3600.0)
+                {
                     ActualisationTM2=newAct2;
+                    ActualisationTM2 = newAct2;
                     ActualisationNP2.s = IPS_OK;
 …
+            }
+        }
+    } /* end EquatorialCoordsWNP */
+}
+    }
+}
 /**************************************************************************************
 ** L'utilisateur clique sur l'un des boutons de la boÃ®te Indi
 ***************************************************************************************/
 void BAO::ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
+{
 …
         connect_telescope();
         return;
+    }
 …
         IUResetSwitch(&AbortSlewSP);
+        /*
+        if (EquatorialCoordsWNP.s == IPS_BUSY)
+        {
+        AbortSlewSP.s = IPS_OK;
+        EquatorialCoordsWNP.s       = IPS_IDLE;
+        EquatorialCoordsRNP.s       = IPS_IDLE;
+        HorizontalCoordsWNP.s       = IPS_IDLE;
+        IDSetSwitch(&AbortSlewSP, "Slew aborted.");
+        IDSetNumber(&EquatorialCoordsWNP, NULL);
+        IDSetNumber(&EquatorialCoordsRNP, NULL);
+        IDSetNumber(&HorizontalCoordsWNP, NULL);
+        }
+        */
+        if (EquatorialCoordsWNP.s == IPS_OK)
+        {
+            AbortSlewSP.s = IPS_OK;
+            EquatorialCoordsWNP.s       = IPS_IDLE;
+            ObjectTP.s = IPS_IDLE;
+            IDSetSwitch(&ConnectSP, "Envoi de la commande Abort\n");
+            IDSetNumber(&EquatorialCoordsWNP, NULL);
+            IDSetText(&ObjectTP, NULL);
+        }
         return;
+    }
 …
         IUResetSwitch(&ParkSP);
+        /*
+        if (EquatorialCoordsWNP.s == IPS_BUSY)
+        {
+        AbortSlewSP.s = IPS_OK;
+        EquatorialCoordsWNP.s       = IPS_IDLE;
+        EquatorialCoordsRNP.s       = IPS_IDLE;
+        HorizontalCoordsWNP.s       = IPS_IDLE;
+        IDSetSwitch(&AbortSlewSP, "Slew aborted.");
+        IDSetNumber(&EquatorialCoordsWNP, NULL);
+        IDSetNumber(&EquatorialCoordsRNP, NULL);
+        IDSetNumber(&HorizontalCoordsWNP, NULL);
+        }
+        */
+        if (EquatorialCoordsWNP.s == IPS_OK)
+        {
+            AbortSlewSP.s = IPS_OK;
+            EquatorialCoordsWNP.s       = IPS_IDLE;
+            ObjectTP.s = IPS_IDLE;
+            IDSetSwitch(&ConnectSP, "Envoi de la commande Park\n");
+            IDSetNumber(&EquatorialCoordsWNP, NULL);
+            IDSetText(&ObjectTP, NULL);
+        }
         return;
+    }
+}
-/**************************************************************************************
-** fct peut-Ãªtre inutile
-***************************************************************************************/
-void BAO::handle_error(INumberVectorProperty *nvp, int err, const char *msg)
+{
-    nvp->s = IPS_ALERT;
-    /* If the error is a time out, then the device doesn't support this property */
-    if (err == -2)
+    {
-        nvp->s = IPS_ALERT;
-        IDSetNumber(nvp, "Device timed out. Current device may be busy or does not support %s. Will retry again.", msg);
+    }
-    else
-        /* Changing property failed, user should retry. */
-        IDSetNumber( nvp , "%s failed.", msg);
-    fault = true;
+}
 /**************************************************************************************
 ** Initialisation des vecteurs INDI
 ***************************************************************************************/
 void BAO::reset_all_properties()
+{
+    char chaine[10];
     ConnectSP.s                 = IPS_IDLE;
     OnCoordSetSP.s              = IPS_IDLE;
 …
     ObjectTP.s                  = IPS_IDLE;
     EquatorialCoordsWNP.s       = IPS_IDLE;
-    //EquatorialCoordsRNP.s     = IPS_IDLE;
     GeographicCoordsWNP.s       = IPS_IDLE;
-    //SlewAccuracyNP.s          = IPS_IDLE;
-    //TrackAccuracyNP.s         = IPS_IDLE;
     ActualisationNP1.s          = IPS_IDLE;
     ActualisationNP2.s          = IPS_IDLE;
 …
     IDSetText(&ObjectTP, NULL);
     IDSetNumber(&EquatorialCoordsWNP, NULL);
-    //IDSetNumber(&EquatorialCoordsRNP, NULL);
     IDSetNumber(&GeographicCoordsWNP, NULL);
-    //IDSetNumber(&SlewAccuracyNP, NULL);
-    //IDSetNumber(&TrackAccuracyNP, NULL);
     IDSetNumber(&ActualisationNP1, NULL);
     IDSetNumber(&ActualisationNP2, NULL);
+}
+/**************************************************************************************
+}
+/**************************************************************************************
+** Gestion du thread
+** permet de suivre la connexion/dÃ©connexion des antennes
 **
+***************************************************************************************/
+void BAO::correct_fault()
+{
+    fault = false;
+    IDMessage(mydev, "Telescope is online.");
+}
+/**************************************************************************************
+** l'utilisation d'un thread permet d'Ã©viter de bloquer l'exÃ©cution du pilote
+** avec la fonction accept qui est bloquante
+***************************************************************************************/
+void *BAO::pThreadSocket ()
+{
+    do
+    {
+        try
+        {
+            server.accept( Sockets[SocketsNumber].new_sock );
+            Sockets[SocketsNumber].IP = server.recupip(Sockets[SocketsNumber].new_sock);
+            Sockets[SocketsNumber++].Connected = true;
+            InitThreadOK = true;
+            usleep(100);
+        }
+        catch ( SocketException& e )
+        {
+            /*IDLog("Indi_BAO, pThreadSocket exception : ");
+            IDLog(e.description().c_str());
+            IDLog("\n");*/
+        }
+    }
+    while (!Exit);
+    pthread_exit (0);
+}
+/**************************************************************************************
+** Astuce pour lancer le thread depuis la classe BAO
 **
 ***************************************************************************************/
+bool BAO::is_connected()
+{
+    if (simulation) return true;
+    // return (ConnectSP.sp[0].s == ISS_ON);
+    return (ConnectSP.s == IPS_OK);
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+static void retry_connection(void * p)
+{
+}
+/**************************************************************************************
+** Extraction de la position de l'antenne
+** dans le retour de la commande POS
+** POS/Valeur az/Valeur alt
+***************************************************************************************/
+Position BAO::ExtractPosition(std::string str)
+{
+    Position result;
+    std::string str2;
+    result.x = -1;
+    result.y = -1;
+void* LancementThread(BAO * appli)
+{
+    appli->pThreadSocket();
+    return 0;
+}
+/**************************************************************************************
+** Extraction de la position de l'antenne aprÃšs l'envoie de la commande P
+** Le retour de la commande P est POSITION/valeur_az/valeur_alt/
+** ExtractPosition retourne donc Valeur_az et Valeur_alt
+***************************************************************************************/
+bool BAO::ExtractPosition(string str, Position *result)
+{
+    string str2;
     int pos = str.find("/");
 …
     if (pos != string::npos)
+    {
         str2 = str.substr(pos+1);
+        str2 = str.substr(pos + 1);
         pos = str2.find("/");
 …
         if (pos != string::npos)
+        {
+            result.x = atoi(str2.substr(0, pos).c_str());
+            result.y = atoi(str2.substr(pos+1).c_str());
+        }
+    }
+    return result;
+            result->x = atol(str2.substr(0, pos).c_str());
+            result->y = atol(str2.substr(pos + 1).c_str());
+            return true;
+        }
+    }
+    IDLog((str +" fail\n").c_str());
+    return false;
+}
 …
 /************************************************************************************
 * cette procÃ©dure convertit les coordonnÃ©es equatoriales de l'objet visÃ©
+* 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)
 ************************************************************************************/
 void BAO::ADDEC2Motor(double newRA, double newDEC)
+{
 …
     char AltStr[32];
     // Calcule la hauteur et l'azimut de la zone du ciel pointÃ©e (en fonction de la date et du lieu)
+    Azimut(tsl, Latitude, newRA * 15.0 * Pidiv180, newDEC * Pidiv180, &targetAz, &targetAlt);
+    Azimut( newRA * 15.0 * Pidiv180, newDEC * Pidiv180, &targetAz, &targetAlt);
+    // Refraction atmosphÃ©rique
+    targetAlt = RefractionAtmospherique(targetAlt);
+    // Petit calcul pour faire en sorte que le sud soit Ã  Â° d'azimut
+    targetAz = VerifAngle( targetAz + Pi );
     // En degrÃ©s
     targetAlt *= N180divPi;
+    targetAz *= N180divPi;
+    targetAz *=  N180divPi;
     // Affichage dans les logs
 …
     fs_sexa(AltStr, targetAlt, 2, 3600);
+    IDLog("Horizontal coords : az %s - Alt %s\n", AzStr, AltStr);
+    // Le calcul est ici trÃšs sommaire et arbitraire :
+    // Je considÃšre qu'il y a 100 positions possibles sur les deux axes
+    // De plus, je considÃšre qu'il n'est pas possible de viser un objet Ã
+    // moins de 30Â° de hauteur au-dessus de l'horizon
+    TargetPosition.x=(int)(targetAz*100.0/360.0);
+    targetAlt=((90.0-targetAlt)/60.0);
+    if (targetAlt>=1.0)
+    {
+        targetAlt=1.0; //on ne peut pas viser un objet situÃ© Ã  moins de 30Â°
+        //au-dessus de l'horizon
+    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.");
         Goto=false;
         LecturePosition=false;
+        Suivi = false;
+        ActualisationPosition = false;
         InitAntennes();
+    }
+    TargetPosition.y=(int)(100.0*targetAlt);
+    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
+        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);
+    }
+}
 …
 /************************************************************************************
 * Retourne simplement le nombre d'antennes connectÃ©es
-* et capables de communiquer
 ************************************************************************************/
 int BAO::AntennesConnectees()
+{
     int num=0;
+    int num = 0;
     for (int i=1; i<SocketsNumber; i++) if (Sockets[i].Connected) num++;
 …
 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;
+    }
+    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;
+    }
+}
+/**************************************************************************************
+** En cas de problÃšme
+** DÃ©connecter l'antenne utilisant le socket num
+***************************************************************************************/
+void BAO::DeconnecterSocket(int num)
+{
+    IDLog("Deconnexion de l antenne : %s\n", Sockets[num].IP.c_str());
+    Sockets[num].new_sock.shutdown();
+    Sockets[num].Connected = false;
+    Sockets[num].IP = "";
+}
 …
 /**************************************************************************************
 ** ProcÃ©dure principale
+** Elle est appelÃ©e toutes les POLLMS ms (ici 1 ms)
+***************************************************************************************/
+** Elle est appelÃ©e toutes les ms
+***************************************************************************************/
 void BAO::ISPoll()
+{
+    static bool ISPOLLRunning=false;
+    static int memSocketsNumber=-1;
+    static unsigned int compt=100;
+    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;
 …
     struct timezone tz;
+    //si pas de connexion avec le seveur d'indi -> on sort
     if (is_connected() == false) return;
+    if (ISPOLLRunning) return;
+    ISPOLLRunning=true;
+    compt++;
+    //toutes les 100 millisec
+    if ( compt%100 == 0)
+    // toutes les 100 millisec, on actualise le jour julien
+    // le temps sidÃ©ral local etc...
+    if ( compt%100 == 0 )
+    {
         //RÃ©cupÃ©ration de la date et de l'heure
 …
         gettimeofday(&tv, &tz);
+        Annee=(double)(date.tm_year+1900);
+        Mois=(double)(date.tm_mon+1);
+        Jour=(double)date.tm_mday;
+        Heu=(double)date.tm_hour;
+        Min=(double)date.tm_min;
+        Sec=(double)date.tm_sec+tv.tv_usec/1.0E6;
+        UTCP=0.0;//(double)date.tm_isdst;
+        //Calcul du temps sidÃ©ral local
+        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
+        DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
+        //Puis on calule le temps sidÃ©ral local, le JJ etc...
         CalculTSL();
+        //Y a-t-il de nouvelles tentatives de connexion sur le serveur ?
+        InitThread();
+    }
+    if (InitThreadOK)  // Il faut qu'il y ait eu au moins une connexion dÃ©tectÃ©e par le thread pour continuer
+    }
+    // Il faut que le thread soit actif
+    if (InitThreadOK)
+    {
         // Nouvelle connexion sur le socket !
         if (SocketsNumber>memSocketsNumber)
+        {
             memSocketsNumber=SocketsNumber;
+        if (SocketsNumber > memSocketsNumber)
+        {
+            memSocketsNumber = SocketsNumber;
             IDSetSwitch(&ConnectSP, "Connexion de l antenne %s. (Antennes connectees : %i)",
 …
+        /////////////////////////////////////////////////
         // DÃ©but des Ã©changes avec les microcontrÃŽleurs
         // Analyse des rÃ©ponses des microcontrÃŽleurs
         for (int i=1; i<SocketsNumber; i++) /*if (Sockets[i].Connected)*/
+        {
             try
+        for (int i=1; i<SocketsNumber; i++)
+        {
+            if (Sockets[i].Connected)
+            {
+                std::string reponse, memreponse;
+                // on rÃ©cupÃšre la rÃ©ponse du microcontrÃŽleur
+                Sockets[i].new_sock >> reponse;
+                //IDSetSwitch(&OnCoordSetSP, "RÃ©ponse ISPOLL : %s\n", reponse.c_str());        // pour vÃ©rif
+                //Dans le cas oÃ¹ plusieurs trames seraient arrivÃ©es entre deux appels de POLLMS
+                //les traiter successivement
+                pos=reponse.find("\n");   // d'oÃ¹ l'intÃ©rÃªt de mettre un '\n' Ã  la fin des trames
+                //pour diffÃ©rencier une trame de la prÃ©cÃ©dente
+                while ((pos!=string::npos) && (reponse.length()>1))
+                try
+                {
+                    memreponse=reponse.substr(pos+1);
+                    reponse=reponse.substr(0, pos);
+                    // On traite ici les acknowledges
+                    if ((reponse.find("ACK")!=string::npos) && (reponse.find("NACK")==string::npos))
+                    string reponse, buffereponse;
+                    // on rÃ©cupÃšre la rÃ©ponse du microcontrÃŽleur
+                    Sockets[i].new_sock >> reponse;
+                    // Dans le cas oÃ¹ plusieurs trames seraient arrivÃ©es entre deux appels de POLLMS
+                    // les traiter successivement
+                    // d'oÃ¹ l'intÃ©rÃªt de mettre un '\n' Ã  la fin des trames
+                    // pour diffÃ©rencier une trame de la prÃ©cÃ©dente
+                    pos = reponse.find("\n");
+                    // S'il y a une rÃ©ponse
+                    while ((pos != string::npos) && (reponse.length() > 1))
+                    {
+                        if (reponse.find("POSITION")!=string::npos)
+                        // on garde en stock la seconde partie trame pour un
+                        // traitement ultÃ©rieure
+                        buffereponse = reponse.substr(pos + 1);
+                        // Partie traitÃ©e
+                        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
+                        if ((reponse.find("ACK") != string::npos) && (reponse.find("NACK") == string::npos))
+                        {
+                            Sockets[i].ack_pos=true;
+                            if (reponse.find("POSITION")  != string::npos)
+                            {
+                                Sockets[i].ack_pos=true;
+                            }
+                            else if (reponse.find("GOTO") != string::npos)
+                            {
+                                Sockets[i].ack_goto=true;
+                            }
+                            else if (reponse.find("PARK") != string::npos)
+                            {
+                                Sockets[i].ack_park=true;
+                            }
+                            else if (reponse.find("ABORT")!= string::npos)
+                            {
+                                Sockets[i].ack_abort=true;
+                            }
+                        }
                         else if (reponse.find("GOTO")!=string::npos)
+                        else
+                        {
+                            Sockets[i].ack_goto=true;
+                        }
+                        else if (reponse.find("PARK")!=string::npos)
+                        {
+                            Sockets[i].ack_park=true;
+                        }
+                        else if (reponse.find("ABORT")!=string::npos)
+                        {
+                            Sockets[i].ack_abort=true;
+                        }
+                    }
+                    else
+                    {
+                        //rÃ©ponse Ã  la requÃªte POSITION
+                        if (reponse.find("POSITION")!=string::npos)
+                        {
+                            if (reponse.find("NACK")!=string::npos)
+                            //rÃ©ponse Ã  la requÃªte POSITION
+                            if (reponse.find("POSITION") != string::npos)
+                            {
+                                OnCoordSetSP.s = IPS_ALERT;
+                                IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : position de l antenne inconnue !\n",
+                                            Sockets[i].IP.c_str());
+                                Sockets[i].PosValides=false;
+                                // Si la position de l'antenne est inconnue, on dÃ©connecte l'antenne
+                                Sockets[i].Connected=false;
+                                if (reponse.find("NACK") != string::npos)
+                                {
+                                    //problÃšme concernant la rÃ©ponse Ã  la commande P
+                                    OnCoordSetSP.s = IPS_ALERT;
+                                    IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : position de l antenne inconnue !\n",
+                                                Sockets[i].IP.c_str());
+                                    Sockets[i].PosValides = false;
+                                    // Si la position de l'antenne est inconnue, 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());
+                                    }
+                                }
+                            }
+                            else if (Sockets[i].ack_pos)
+                            //rÃ©ponse Ã  la requÃªte PARK
+                            if (reponse.find("PARK") != string::npos)
+                            {
+                                OnCoordSetSP.s = IPS_OK;
+                                Sockets[i].Pos = ExtractPosition(reponse);
+                                Sockets[i].PosValides = true;
+                                IDSetSwitch(&ParkSP, "Antenne %s : POSITION OK  (x=%i, y=%i)\n",
+                                            Sockets[i].IP.c_str(), Sockets[i].Pos.x, Sockets[i].Pos.y);
+                                if (reponse.find("NACK") != string::npos)
+                                {
+                                    ParkSP.s = IPS_ALERT;
+                                    IDSetSwitch(&ParkSP, "ALERTE antenne %s : erreur PARK !\n", Sockets[i].IP.c_str());
+                                }
+                                else if (Sockets[i].ack_park && reponse.find("OK")!=string::npos)
+                                {
+                                    ParkSP.s = IPS_OK;
+                                    IDSetSwitch(&ParkSP, "Antenne %s : PARK OK\n",  Sockets[i].IP.c_str());
+                                }
+                            }
+                        }//rÃ©ponse Ã  la requÃªte PARK
+                        else if (reponse.find("PARK")!=string::npos)
+                        {
+                            if (reponse.find("NACK")!=string::npos)
+                            //rÃ©ponse Ã  la requÃªte ABORT
+                            if (reponse.find("ABORT") != string::npos)
+                            {
+                                ParkSP.s = IPS_ALERT;
+                                IDSetSwitch(&ParkSP, "ALERTE antenne %s : erreur PARK !\n", Sockets[i].IP.c_str());
+                                if (reponse.find("NACK") != string::npos)
+                                {
+                                    AbortSlewSP.s = IPS_ALERT;
+                                    IDSetSwitch(&AbortSlewSP, "ALERTE antenne %s : erreur ABORT !\n",  Sockets[i].IP.c_str());
+                                }
+                                else if (Sockets[i].ack_abort && reponse.find("OK")!=string::npos)
+                                {
+                                    AbortSlewSP.s = IPS_OK;
+                                    IDSetSwitch(&AbortSlewSP, "Antenne %s : ABORT OK\n",  Sockets[i].IP.c_str());
+                                }
+                            }
+                            else if (reponse.find("OK")!=string::npos)
+                            //rÃ©ponse Ã  la requÃªte GOTO
+                            if (reponse.find("GOTO") != string::npos)
+                            {
+                                ParkSP.s = IPS_OK;
+                                IDSetSwitch(&ParkSP, "Antenne %s : PARK OK\n",  Sockets[i].IP.c_str());
+                            }
+                        }//rÃ©ponse Ã  la requÃªte ABORT
+                        else if (reponse.find("ABORT")!=string::npos)
+                        {
+                            if (reponse.find("NACK")!=string::npos)
+                            {
+                                AbortSlewSP.s = IPS_ALERT;
+                                IDSetSwitch(&AbortSlewSP, "ALERTE antenne %s : erreur ABORT !\n",  Sockets[i].IP.c_str());
+                            }
+                            if (reponse.find("OK")!=string::npos)
+                            {
+                                AbortSlewSP.s = IPS_OK;
+                                IDSetSwitch(&AbortSlewSP, "Antenne %s : ABORT OK\n",  Sockets[i].IP.c_str());
+                            }
+                        } //rÃ©ponse Ã  la requÃªte GOTO
+                        else if (reponse.find("GOTO")!=string::npos)
+                        {
+                            if (reponse.find("NACK")!=string::npos)
+                            {
+                                OnCoordSetSP.s = IPS_ALERT;
+                                IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : Erreur GOTO !\n",  Sockets[i].IP.c_str());
+                                Sockets[i].Connected=false;
+                            }
+                            else if (Sockets[i].ack_goto)
+                            {
+                                if (reponse.find("OK")!=string::npos)
+                                if (reponse.find("NACK") != string::npos)
+                                {
+                                    OnCoordSetSP.s = IPS_OK;
+                                    Sockets[i].GotoOk=true;
+                                    IDSetSwitch(&ParkSP, "Antenne %s : GOTO OK.\n",  Sockets[i].IP.c_str());
+                                    lastRA  = targetRA;
+                                    lastDEC = targetDEC;
+                                    //IDLog("We received JNow RA %s - DEC %s\n", RAStr, DecStr);*/
+                                    EquatorialCoordsWNP.s = IPS_OK;
+                                    IDSetNumber (&EquatorialCoordsWNP, NULL);
+                                    // Fin du Goto pour toutes les antennes ?
+                                    int num=0;
+                                    for (int j=1; j<SocketsNumber; j++) if (Sockets[j].Connected)
+                                    OnCoordSetSP.s = IPS_ALERT;
+                                    IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : Erreur GOTO !\n",  Sockets[i].IP.c_str());
+                                    DeconnecterSocket(i);
+                                }
+                                else if (Sockets[i].ack_goto)
+                                {
+                                    if (reponse.find("OK") != string::npos)
+                                    {
+                                        // On a la confirmation que l'antenne 'i' a bien rÃ©alisÃ©
+                                        // le goto
+                                        // On prend note
+                                        Sockets[i].GotoOk = true;
+                                        // 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;
+                                        for (int j=1; j<SocketsNumber; j++)
+                                        {
+                                          if (Sockets[j].Connected)
+                                            {
+                                                if (Sockets[j].GotoOk) num++;
+                                            }
+                                        }
+                                        if ((num == AntennesConnectees()) && (num>0))
+                                        {
+                                            if (Sockets[j].GotoOk) num++;
+                                        }
+                                    if ((num == AntennesConnectees()) && (num>0))
+                                    {
+                                        LecturePosition=false;
+                                        InitAntennes();
+                                        LastGotoOK=true;
+                                        IDSetSwitch(&OnCoordSetSP, "GOTO OK !");
+                                            // C'est bon ! Tout marche bien...
+                                            // On actualise l'AR et la dec dans la boÃ®te de dialogue
+                                            lastRA  = targetRA;
+                                            lastDEC = targetDEC;
+                                            // On change en vert les voyants dans la boÃ®te de dialogue
+                                            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
+                                            OnCoordSetSP.s = IPS_OK;
+                                            IDSetSwitch(&OnCoordSetSP, "GOTO OK !");
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        // On passe Ã  la trame suivante si memreponse n'est pas vide
+                        reponse=buffereponse;
+                        pos=reponse.find("\n");
+                    }
+                    // On passe Ã©ventuellement Ã  la trame suivante
+                    reponse=memreponse;
+                    pos=reponse.find("\n");
+                }
+                catch (SocketException& e) //AÃ¯e
+                {
+                    DeconnecterSocket(i);
+                    IDLog("Indi_BAO, SocketException IsPoll : ");
+                    IDLog(e.description().c_str());
+                    IDLog("\n");
+                }
+            }
+            catch (SocketException& e) //AÃ¯e
+        }
+        ///////////////////////////////////////
+        // L'utilisateur a demandÃ© l'annulation du mouvement
+        // en cours
+        if (Abort)
+        {
+            // On arrÃªte le suivi d'un objet
+            Suivi = false;
+            // On arrÃªte l'enchaÃ®nement des actions
+            // pour rÃ©aliser un goto
+            ActualisationPosition = false;
+            // On envoie l'ordre ABORT Ã  toutes les antennes
+            for (int i=1; i<SocketsNumber; i++)
+            {
-                Sockets[i].new_sock.shutdown();
-                Sockets[i].new_sock.create();
-                Sockets[i].Connected = Sockets[i].new_sock.connect((std::string)Sockets[i].IP);
                 if (Sockets[i].Connected)
+                {
-                    Sockets[i].AttenteExecution=0;
-                    Sockets[i].AnomaliesExecution=0;
+                }
-                std::string oss;
-                oss="SocketException IsPoll : " + e.description() + "\n";
-                size_t size = oss.size() + 1;
-                char* buffer = new char[size];
-                strncpy(buffer, oss.c_str(), size);
-                IDLog(buffer);
-                delete [] buffer;
+            }
+        }
-        if (Abort)
+        {
-            IDSetSwitch(&ConnectSP, "Envoi de la commande Abort\n");
-            Goto=false;
-            for (int i=1; i<SocketsNumber; i++) if (Sockets[i].Connected)
+                {
                     if (!ABORT(i)) Sockets[i].sendalertes++;
+                }
+            LecturePosition=false;
+            }
+            IDSetSwitch(&OnCoordSetSP, "ABORT OK !");
+            // RÃ©inititialisation des paramÃštres des antennes
             InitAntennes();
+            //Pour permettre de refaire un abort
             Abort=false;
+        }
+        ///////////////////////////////////////
+        // L'utilisateur a demandÃ© de mettre les antennes au repos
         if (Park)
+        {
+            IDSetSwitch(&ConnectSP, "Envoi de la commande Park\n");
+            Goto=false;
+            for (int i=1; i<SocketsNumber; i++) if (Sockets[i].Connected)
+            // On arrÃªte le suivi d'un objet
+            Suivi = false;
+            // On arrÃªte l'enchaÃ®nement des actions
+            // pour rÃ©aliser un goto
+            ActualisationPosition = false;
+            // On envoie l'ordre PARK Ã  toutes les antennes
+            for (int i=1; i<SocketsNumber; i++)
+            {
+                if (Sockets[i].Connected)
+                {
                     if (!PARK(i)) Sockets[i].sendalertes++;
+                }
+            LecturePosition=false;
+            }
+            IDSetSwitch(&OnCoordSetSP, "PARK OK !");
+            // RÃ©inititialisation des paramÃštres des antennes
             InitAntennes();
+            //Pour permettre de refaire un park
             Park=false;
+        }
+        ///////////////////////////////////////
         // Gestion du suivi
         if ((Goto) && (LastGotoOK))
+        if ((Suivi) && (UpdateGoto))
+        {
             // DurÃ©e 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
             // On actualise la position
             if (JJ-JJAnc > delai)
+            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
+            // On actualise la position si le delai est dÃ©passÃ©
+            if (GetJJ() - JJAnc > delai)
+            {
+                LastGotoOK=false;
+                LecturePosition=true;
+                UpdateGoto = false;
+                // Conversion des coordonnÃ©es en pas moteur
                 ADDEC2Motor(targetRA, targetDEC);
+                // On rÃ©initialise les antennes en vue du goto
                 InitAntennes();
+                JJAnc=JJ;
+                ActualisationPosition = true;
+                // On sauvegarde la date
+                JJAnc = GetJJ();
+            }
             //Plus d'antenne !
+            //Plus d'antenne ! On arrÃªte le suivi
             if (AntennesConnectees() == 0)
+            {
+                // LecturePosition=false;
+                // Goto=false;
+                // InitAntennes();
+                if ( compt % 1000 == 0)  IDSetSwitch(&OnCoordSetSP, "Erreur ! Plus d antennes connectees !");
+                if ( compt % 1000 == 0)
+                {
+                    IDSetSwitch(&OnCoordSetSP, "Erreur ! Plus d antennes connectees !");
+                    if (Suivi) IDLog("ArrÃªt du suivi !");
+                    ActualisationPosition=false;
+                    Suivi=false;
+                    InitAntennes();
+                }
+            }
+        }
 …
         // puis envoi d'une commande Goto
         if (LecturePosition)
+        {
             for (int i=1; i<SocketsNumber; i++) /*if (Sockets[i].Connected)*/
+        if (ActualisationPosition)
+        {
+            for (int i=1; i<SocketsNumber; i++)
+            {
                 switch (Sockets[i].etape)
+                if (Sockets[i].Connected)
+                {
+                    //Envoi de la commande POS
+                case 0 :
+                {
+                    Sockets[i].ack_pos=false;
+                    Sockets[i].PosValides=false;
+                    if (!POSITION(i)) Sockets[i].sendalertes++;
+                    Sockets[i].etape++;
+                }
+                break;
+                //ack POS
+                case 1 :
+                {
+                    if (Sockets[i].ack_pos)
+                    switch (Sockets[i].etape)
+                    {
+                        Sockets[i].AttenteExecution=0;
+                        Sockets[i].AnomaliesExecution=0;
+                        //Envoi de la commande POS
+                    case 0 :
+                    {
+                        Sockets[i].ack_pos    = false;
+                        Sockets[i].PosValides = false;
+                        if (!POSITION(i)) Sockets[i].sendalertes++;
                         Sockets[i].etape++;
-                        i--;
+                    }
+                    else
+                    break;
+                    // A-ton bien reÃ§u l'ack POS ?
+                    case 1 :
+                    {
+                        // on rÃ©itÃšre l'ordre prÃ©cÃ©dent si rien ne se passe
+                        Sockets[i].AttenteExecution++;
+                        if (Sockets[i].AttenteExecution>MAXATTENTE)
+                        if (Sockets[i].ack_pos)
+                        {
+                            Sockets[i].etape=0;
+                            Sockets[i].AttenteExecution=0;
+                            Sockets[i].AnomaliesExecution++;
+                            // tout marche bien
+                            Sockets[i].AttenteExecution = 0;
+                            Sockets[i].AnomaliesExecution = 0;
+                            Sockets[i].etape++;
+                            i--; //permet de revenir sur ce mÃªme socket malgrÃ© la boucle
+                            // -> plus rapide
+                        }
+                        if (Sockets[i].AnomaliesExecution>MAXANOMALIES)
+                        else
+                        {
+                            Sockets[i].etape=3;
+                            // if ( compt % 1000 == 0)
+                            // 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
+                                Sockets[i].etape = 0;
+                                Sockets[i].AttenteExecution = 0;
+                                Sockets[i].AnomaliesExecution++;
+                            }
+                            // Toujours rien -> plus sÃ©rieux : il faut dÃ©connecter l'antenne
+                            if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
+                            {
+                                OnCoordSetSP.s = IPS_ALERT;
                                 IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : pas d acknowledge recu apres l ordre POSITION. \
                                 Deconnexion de l antenne.", Sockets[i].IP.c_str());
                                 Sockets[i].Connected=false;
+    Deconnexion de l antenne.", Sockets[i].IP.c_str());
+                                DeconnecterSocket(i);
+                            }
+                        }
+                    }
+                }
+                break;
+                //Valeurs pos valides ?
+                case 2 :
+                {
+                    if (Sockets[i].PosValides)
+                    break;
+                    //Les valeurs retournÃ©es pas la commande POSITION sont-elles valides ?
+                    case 2 :
+                    {
+                        Sockets[i].AttenteExecution=0;
+                        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)
+                        if (Sockets[i].PosValides)
+                        {
                             Sockets[i].etape=2;
                             Sockets[i].AttenteExecution=0;
                             Sockets[i].AnomaliesExecution++;
+                            Sockets[i].AttenteExecution = 0;
+                            Sockets[i].AnomaliesExecution = 0;
+                            Sockets[i].etape++; // on passe Ã  l'Ã©tape suivante
+                        }
+                        if (Sockets[i].AnomaliesExecution>MAXANOMALIES)
+                        else
+                        {
+                            Sockets[i].etape=3;
+                            // if ( compt % 1000 == 0)
+                            // on rÃ©itÃšre l'ordre prÃ©cÃ©dent si rien ne se passe
+                            Sockets[i].AttenteExecution++;
+                            if (Sockets[i].AttenteExecution > MAXATTENTE)
+                            {
+                                // on attend davantage la rÃ©ponse posvalides
+                                Sockets[i].etape = 2;
+                                Sockets[i].AttenteExecution = 0;
+                                Sockets[i].AnomaliesExecution++;
+                            }
+                            if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
+                            {
+                                OnCoordSetSP.s = IPS_ALERT;
                                 IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : la position retournee n est pas valide. \
                                 Deconnexion de l antenne.", Sockets[i].IP.c_str());
                                 Sockets[i].Connected=false;
+    Deconnexion de l antenne.", Sockets[i].IP.c_str());
+                                DeconnecterSocket(i);
+                            }
+                        }
+                    }
+                }
+                break;
+                //ack goto  ?
+                case 4 :
+                {
+                    if (Sockets[i].ack_goto)
+                    break;
+                    // A-ton reÃ§u l'acknowledge de la commande goto ?
+                    case 4 :
+                    {
+                        Sockets[i].AttenteExecution=0;
+                        Sockets[i].AnomaliesExecution=0;
+                        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)
+                        if (Sockets[i].ack_goto)
+                        {
                             Sockets[i].etape=4;
                             Sockets[i].AttenteExecution=0;
                             Sockets[i].AnomaliesExecution++;
+                            Sockets[i].AttenteExecution = 0;
+                            Sockets[i].AnomaliesExecution = 0;
+                            Sockets[i].etape++; // on passe Ã  l'Ã©tape suivante
+                        }
+                        if (Sockets[i].AnomaliesExecution>MAXANOMALIES)
+                        else
+                        {
+                            Sockets[i].etape=6;
+                            // if ( compt % 1000 == 0)
+                            // on rÃ©itÃšre l'ordre prÃ©cÃ©dent si rien ne se passe
+                            Sockets[i].AttenteExecution++;
+                            if (Sockets[i].AttenteExecution > MAXATTENTE)
+                            {
+                                // On prolonge l'attente
+                                Sockets[i].etape = 4;
+                                Sockets[i].AttenteExecution = 0;
+                                Sockets[i].AnomaliesExecution++;
+                            }
+                            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());
                                 Sockets[i].Connected=false;
+    Deconnexion de l antenne.", Sockets[i].IP.c_str());
+                                DeconnecterSocket(i);
+                            }
+                        }
+                    }
+                }
+                break;
+                //goto ok  ?
+                case 5 :
+                {
+                    if (Sockets[i].GotoOk)
+                    break;
+                    //  Confirmation goto ok ?
+                    case 5 :
+                    {
+                        Sockets[i].AttenteExecution=0;
+                        Sockets[i].AnomaliesExecution=0;
+                        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)
+                        if (Sockets[i].GotoOk)
+                        {
                             Sockets[i].etape=5;
                             Sockets[i].AttenteExecution=0;
                             Sockets[i].AnomaliesExecution++;
+                            Sockets[i].AttenteExecution = 0;
+                            Sockets[i].AnomaliesExecution = 0;
+                            Sockets[i].etape++;
+                        }
+                        if (Sockets[i].AnomaliesExecution>MAXANOMALIESGOTO)
+                        else
+                        {
+                            Sockets[i].etape=6;
+                            // if ( compt % 1000 == 0)
+                            // on rÃ©itÃšre l'ordre prÃ©cÃ©dent si rien ne se passe
+                            Sockets[i].AttenteExecution++;
+                            if (Sockets[i].AttenteExecution > MAXATTENTE)
+                            {
+                                // On prolonge l'attente
+                                Sockets[i].etape = 5;
+                                Sockets[i].AttenteExecution = 0;
+                                Sockets[i].AnomaliesExecution++;
+                            }
+                            // 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());
+                                Sockets[i].Connected=false;
+    Deconnexion de l antenne.", Sockets[i].IP.c_str());
+                                DeconnecterSocket(i);
+                            }
+                        }
+                    }
+                }
+                break;
+                    break;
+                    }
+                }
+            }
 …
+        // DÃ©tection d'anomalies concernant l'envoi de trames sur la socket. dÃ©connexion du micro-cont ?
+        for (int i=1; i<SocketsNumber; i++) if (Sockets[i].Connected)
+        ///////////////////////////////////////
+        //On attend que toutes les antennes soient prÃªtes pour lancer l'ordre Goto -> meilleure synchronisation
+        int num=0;
+        for (int i=1; i<SocketsNumber; i++)
+        {
+            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 ((num == AntennesConnectees()) && (num>0))
+        {
+            for (int i=1; i<SocketsNumber; i++ )
+            {
+                if (Sockets[i].Connected)
+                {
+                    Sockets[i].ack_goto = false;
+                    Sockets[i].AttenteExecution = 0;
+                    Sockets[i].AnomaliesExecution = 0;
+                    if (!GOTO(i, TargetPosition.x - Sockets[i].Pos.x , TargetPosition.y - Sockets[i].Pos.y )) Sockets[i].sendalertes++;
+                    Sockets[i].etape++;
+                }
+            }
+        }
+        ///////////////////////////////////////
+        // DÃ©tection d'anomalies sur la socket. DÃ©connexion du micro-cont ?
+        for (int i=1; i<SocketsNumber; i++)
+        {
+            if (Sockets[i].Connected)
+            {
                 if (Sockets[i].sendalertes > 0)
+                {
+                    Sockets[i].etape=5;
+                    //  if ( compt % 1000 == 0)
+                    {
+                        IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : deconnexion de l antenne.", Sockets[i].IP.c_str());
+                        Sockets[i].Connected=false;
+                    }
+                    OnCoordSetSP.s = IPS_ALERT;
+                    IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : deconnexion de l antenne.", Sockets[i].IP.c_str());
+                    DeconnecterSocket(i);
+                }
+            }
+        //On attend que toutes les antennes soient prÃªtes pour lancer l'ordre Goto -> meilleure synchronisation
+        int num=0;
+        for (int i=1; i<SocketsNumber; i++) if (Sockets[i].Connected)
+            {
+                if (Sockets[i].etape == 3) num++; //fin de la procÃ©dure LecturePosition. Les antennes sont prÃªtes
+                //Ã  recevoir l'ordre GOto
+            }
+        if ((num == AntennesConnectees()) && (num>0))
+        {
+            for (int i=1; i<SocketsNumber; i++ ) if (Sockets[i].Connected)
+                {
+                    Sockets[i].ack_goto=false;
+                    Sockets[i].AttenteExecution=0;
+                    Sockets[i].AnomaliesExecution=0;
+                    if (!GOTO(i, Sockets[i].Pos.x - TargetPosition.x, Sockets[i].Pos.y - TargetPosition.y )) Sockets[i].sendalertes++;
+                    Sockets[i].etape++;
+                }
+        }
+    }
+    ISPOLLRunning=false;
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+        }
+    }
+    compt++;
+}
+/**************************************************************************************
+** Mode transit ou tracking
+***************************************************************************************/
 bool BAO::process_coords()
+{
 …
     case BAO_TRANSIT:
+        //Eteindre les voyants dans la boÃ®te de dialogue Indi
         EquatorialCoordsWNP.s = IPS_BUSY;
+        AbortSlewSP.s = IPS_IDLE;
+        ParkSP.s = IPS_IDLE;
         IDSetNumber (&EquatorialCoordsWNP, NULL);
+        IDSetSwitch (&AbortSlewSP, NULL);
+        IDSetSwitch (&ParkSP, NULL);
+        // On prÃ©pare les antennes pour le prochain goto
         InitAntennes();
+        JJAnc=JJ;
+        JJAnc = GetJJ();
+        ADDEC2Motor(targetRA, targetDEC);
         TrackingMode = 1;
+        Goto=true;
+        LastGotoOK=false;
+        LecturePosition=true;
+        ADDEC2Motor(targetRA, targetDEC);
+        Suivi = true;
+        UpdateGoto = false;
+        ActualisationPosition = true;
         break;
 …
     case BAO_TRACKING:
+        //Eteindre les voyants dans la boÃ®te de dialogue Indi
         EquatorialCoordsWNP.s = IPS_BUSY;
+        AbortSlewSP.s = IPS_IDLE;
+        ParkSP.s = IPS_IDLE;
         IDSetNumber (&EquatorialCoordsWNP, NULL);
+        IDSetSwitch (&AbortSlewSP, NULL);
+        IDSetSwitch (&ParkSP, NULL);
         InitAntennes();
+        JJAnc=JJ;
+        JJAnc=GetJJ();
+        ADDEC2Motor(targetRA, targetDEC);
         TrackingMode = 2;
+        Goto=true;
+        LastGotoOK=false;
+        LecturePosition=true;
+        ADDEC2Motor(targetRA, targetDEC);
+        Suivi = true;
+        UpdateGoto = false;
+        ActualisationPosition = true;
         break;
 …
+}
+/**************************************************************************************
+** Connexion / DÃ©connexion avec le tÃ©lescope
+***************************************************************************************/
+void BAO::connect_telescope()
+{
+    switch (ConnectSP.sp[0].s)
+    {
+    case ISS_ON:
+        // Etats des voyants
+        ConnectS[0].s = ISS_ON;
+        ConnectS[1].s = ISS_OFF;
+        ConnectSP.s = IPS_OK;
+        IDSetSwitch (&ConnectSP, "BAORadio is online. Retrieving basic data...");
+        // Petit message
+        IDLog("\nHello BAORadio !\n");
+        // On lance le thread !
+        Exit=false;
+        if (pthread_create (&th1, NULL, (void*(*)(void*))LancementThread, this) < 0)
+        {
+            IDLog("pthread_create error for threadSocket\n");
+        }
+        break;
+    case ISS_OFF:
+        // On sort du thread
+        Exit = true;
+        sleep(1);
+        pthread_join (th1, NULL);
+        InitThreadOK = false;
+        // Etat des voyants
+        ConnectS[0].s = ISS_OFF;
+        ConnectS[1].s = ISS_ON;
+        ConnectSP.s = IPS_IDLE;
+        IDSetSwitch (&ConnectSP, "BAORadio is offline.");
+        IDLog("Telescope is offline.");
+        // On dÃ©connecte tous les sockets
+        for (int i=0; i<MAXHOSTNAME; i++)
+        {
+            DeconnecterSocket(i);
+        }
+        // init
+        InitAntennes();
+        SocketsNumber = 1;
+        break;
+    }
+}
+/**************************************************************************************
+**  Envoie une commande sur le socket numsocket
+***************************************************************************************/
+bool BAO::COMMANDE(int numsocket, char* Commande, char* Params)
+{
+    char chaine[MAXCARACTERES];
+    try
+    {
+        sprintf(chaine, "%s%s\n", Commande, Params);
+        Sockets[numsocket].new_sock << chaine;
+        IDLog("Commande envoyÃ©e Ã  %s: %s", Sockets[numsocket].IP.c_str(), chaine);
+    }
+    catch (SocketException& e)
+    {
+        DeconnecterSocket(numsocket);
+        IDLog("Indi_BAO, COMMANDE exception : ");
+        IDLog(e.description().c_str());
+        IDLog("\n");
+        return false;
+    }
+    return true;
+}
+/**************************************************************************************
+** Commande POSITION
+***************************************************************************************/
+bool BAO::POSITION(int numsocket)
+{
+    return COMMANDE(numsocket, (char*)"P", (char*)"");
+}
+/**************************************************************************************
+** Commande PARK
+***************************************************************************************/
+bool BAO::PARK(int numsocket)
+{
+    return COMMANDE(numsocket, (char*)"Z", (char*)"");
+}
+/**************************************************************************************
+** Commande ABORT
+***************************************************************************************/
+bool BAO::ABORT(int numsocket)
+{
+    return COMMANDE(numsocket, (char*)"A", (char*)"");
+}
+/**************************************************************************************
+** Commande GOTO
+***************************************************************************************/
+bool BAO::GOTO(int numsocket, int deltaAz, int deltaAlt)
+{
+    char Params[MAXCARACTERES];
+    char sensAz;
+    char sensAlt;
+    sensAlt = 1;
+    sensAz  = 1;
+    if ( deltaAz < 0 )
+    {
+        deltaAz = -deltaAz;
+        sensAz  = 0;
+    }
+    if ( deltaAlt < 0 )
+    {
+        deltaAlt = -deltaAlt;
+        sensAlt  = 0;
+    }
+    // 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
+    // on fait le trajet dans le sens inverse pour aller plus vite
+    // problÃšme 2 : Passage au mÃ©ridien
+    // on se situe Ã  quelques secondes de degrÃ©s avant le sud par exemple (nb de pas 3995 par exemple)
+    // et on franchit le mÃ©ridien (nb de pas codeur = 5 par exemple)
+    // 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...
+    while (deltaAz > NBREPASCODEURSAZ) deltaAz -= NBREPASCODEURSAZ;
+    // Doit rÃ©soudre tous les problÃšmes...
+    if (deltaAz > NBREPASCODEURSAZ / 2 )
+    {
+        deltaAz = NBREPASCODEURSAZ - deltaAz;
+        sensAz = 1 - sensAz;
+    }
+    //on envoie les coordonnÃ©es au driver
+    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);
+    return COMMANDE(numsocket, (char*)"G", Params);
+}
+/**************************************************************************************
+** Les fonctions qui suivent sont nÃ©cessaires pour construire un pilote Indi
+** Elles sont appelÃ©es par le noyau d'Indi
+***************************************************************************************/
+/**************************************************************************************
+** Initialisation du pilote BAO
+***************************************************************************************/
+void ISInit()
+{
+    //Il ne faut exÃ©cuter la fonction qu'une seule fois
+    static int isInit = 0;
+    if (isInit) return;
+    if (telescope.get() == 0) telescope.reset(new BAO());
+    isInit = 1;
+    //initialisation du timer
+    IEAddTimer (POLLMS, ISPoll, NULL);
+}
+void ISGetProperties (const char *dev)
+{
+    ISInit();
+    telescope->ISGetProperties(dev);
+}
+void ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n)
+{
+    ISInit();
+    telescope->ISNewSwitch(dev, name, states, names, n);
+}
+void ISNewText (const char *dev, const char *name, char *texts[], char *names[], int n)
+{
+    ISInit();
+    telescope->ISNewText(dev, name, texts, names, n);
+}
+void ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n)
+{
+    ISInit();
+    telescope->ISNewNumber(dev, name, values, names, n);
+}
+void ISNewBLOB (const char *dev, const char *name, int sizes[], int blobsizes[], char *blobs[], char *formats[], char *names[], int n)
+{
+    INDI_UNUSED(dev);
+    INDI_UNUSED(name);
+    INDI_UNUSED(sizes);
+    INDI_UNUSED(blobsizes);
+    INDI_UNUSED(blobs);
+    INDI_UNUSED(formats);
+    INDI_UNUSED(names);
+    INDI_UNUSED(n);
+}
+void ISSnoopDevice (XMLEle *root)
+{
+    INDI_UNUSED(root);
+}
+void ISPoll (void *p)
+{
+    INDI_UNUSED(p);
+    telescope->ISPoll();
+    IEAddTimer (POLLMS, ISPoll, NULL);
+}
 /**************************************************************************************
 **
 ***************************************************************************************/
 int BAO::get_switch_index(ISwitchVectorProperty *sp)
+{
 …
+}
-/**************************************************************************************
-** Activation de l'interface
-***************************************************************************************/
-void BAO::connect_telescope()
+{
-    switch (ConnectSP.sp[0].s)
+    {
-    case ISS_ON:
-        ConnectS[0].s = ISS_ON;
-        ConnectS[1].s = ISS_OFF;
-        IDLog("\nHello BAORadio !\n");
-        ConnectSP.s = IPS_OK;
-        IDSetSwitch (&ConnectSP, "BAORadio is online. Retrieving basic data...");
-        break;
-    case ISS_OFF:
-        ConnectS[0].s = ISS_OFF;
-        ConnectS[1].s = ISS_ON;
-        ConnectSP.s = IPS_IDLE;
-        SocketsNumber=1;
-        InitThreadOK=false;
-        for (int i=0; i<MAXHOSTNAME; i++)
+        {
-            Sockets[i].Connected=false;
-            Sockets[i].IP="";
-            Sockets[i].new_sock.shutdown();
+        }
-        InitAntennes();
-        IDSetSwitch (&ConnectSP, "BAORadio is offline.");
-        IDLog("Telescope is offline.");
-        break;
+    }
+}
 /**************************************************************************************
 …
+{
     //  IDSetNumber (&EquatorialCoordsRNP, NULL);
+}
 …
 **
 ***************************************************************************************/
+void BAO::enable_simulation(bool enable)
+{
+    simulation = enable;
+    if (simulation)
+        IDLog("Warning: Simulation is activated.\n");
+    else
+        IDLog("Simulation is disabled.\n");
+bool BAO::is_connected()
+{
+    // return (ConnectSP.sp[0].s == ISS_ON);
+    return (ConnectSP.s == IPS_OK);
+}
 …
     ConnectSP.s = IPS_IDLE;
     IDSetSwitch(&ConnectSP, "The connection to the telescope is lost.");
+    IDLog("arret");
     return;
+}
 …
 /**************************************************************************************
+**  Envoi d'une commande sur le socket puis attente de l'acknowledge
+***************************************************************************************/
+bool BAO::COMMANDE(int numsocket, char* Commande, char* Params)
+{
+    char chaine[MAXCARACTERES];
+    try
+    {
+        sprintf(chaine, "%s%s\n", Commande, Params);
+        Sockets[numsocket].new_sock << chaine;
+    }
+    catch (SocketException& e)
+    {
+        Sockets[numsocket].new_sock.shutdown();
+        Sockets[numsocket].new_sock.create();
+        Sockets[numsocket].Connected = Sockets[numsocket].new_sock.connect((std::string)Sockets[numsocket].IP);
+        if (Sockets[numsocket].Connected)
+        {
+            Sockets[numsocket].AttenteExecution=0;
+            Sockets[numsocket].AnomaliesExecution=0;
+        }
+        //  if (AntennesConnectees() == 0) { InitAntennes(); InitThreadOK=false;}
+        std::string oss;
+        oss="COMMANDE exception : " + e.description() + "\n";
+        size_t size = oss.size() + 1;
+        char* buffer = new char[size];
+        strncpy(buffer, oss.c_str(), size);
+        IDLog(buffer);
+        delete [] buffer;
+        return false;
+    }
+    return true;
+}
+/**************************************************************************************
+** Commande POSITION
+***************************************************************************************/
+bool BAO::POSITION(int numsocket)
+{
+    return COMMANDE(numsocket, (char*)"P", (char*)"");
+}
+/**************************************************************************************
+** Commande PARK
+***************************************************************************************/
+bool BAO::PARK(int numsocket)
+{
+    return COMMANDE(numsocket, (char*)"Z", (char*)"");
+}
+/**************************************************************************************
+** Commande ABORT
+***************************************************************************************/
+bool BAO::ABORT(int numsocket)
+{
+    return COMMANDE(numsocket, (char*)"A", (char*)"");
+}
+/**************************************************************************************
+** Commande GOTO
+***************************************************************************************/
+bool BAO::GOTO(int numsocket, int deltaAz, int deltaAlt)
+{
+    char Params[MAXCARACTERES];
+    char sensAz;
+    char sensAlt;
+    sensAlt='b';
+    sensAz='b';
+    if (deltaAz<0)
+    {
+        deltaAz=-deltaAz;
+        sensAz='f';
+    }
+    if (deltaAlt<0)
+    {
+        deltaAlt=-deltaAlt;
+        sensAlt='f';
+    }
+    sprintf(Params, "%c%04i%c%04i", sensAz, deltaAz, sensAlt, deltaAlt);
+    return COMMANDE(numsocket, (char*)"G", Params);
+}
+** GÃšre les erreurs de communication avec la boÃ®te Indi
+***************************************************************************************/
+/*
+void BAO::handle_error(INumberVectorProperty *nvp, int err, const char *msg)
+{
+    nvp->s = IPS_ALERT;
+    // If the error is a time out, then the device doesn't support this property
+    if (err == -2)
+    {
+        nvp->s = IPS_ALERT;
+        IDSetNumber(nvp, "Device timed out. Current device may be busy or does not support %s. Will retry again.", msg);
+    }
+    else
+        // Changing property failed, user should retry.
+        IDSetNumber( nvp , "%s failed.", msg);
+    fault = true;
+}*/
+/**************************************************************************************
+**
+***************************************************************************************/
+/*
+void BAO::correct_fault()
+{
+    fault = false;
+    IDMessage(mydev, "Telescope is online.");
+}*/

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

-                      r498
+                      r504
 /*
+    LX200 Basic Driver
+    Copyright (C) 2005 Jasem Mutlaq (mutlaqja@ikarustech.com)
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Pilote Indi BAORadio
+ franckrichard033@gmail.com
+ Juin 2011
 */
 …
 #define BAO_H
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <math.h>
+#include <unistd.h>
+#include <time.h>
+#include <memory>
+#include <pthread.h>
+#include <iostream>
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <config.h>
+#include "indicom.h"
+#include "Socket.h"
 #include "indidevapi.h"
 #include "indicom.h"
 …
 #include "astro.h"
 #define MAXCARACTERES 1024
 #define MAXATTENTE 80                //Si une commande ne recoit pas d'acknowledge. Alors refaire 80 tentatives en renvoyant la commande
 #define MAXANOMALIES 2               //Si pas de rÃ©ponse au bout de 80 tentatives -> erreur critique -> socket perdu ?
+#define MAXATTENTE 80                // Si une commande ne recoit pas d'acknowledge. Alors refaire 80 tentatives en renvoyant la commande
+#define MAXANOMALIES 2               // Si pas de rÃ©ponse au bout de 80 tentatives -> erreur critique -> socket perdu ?
 #define MAXANOMALIESGOTO 1500
+#define NBREPASCODEURSAZ  4000
+using namespace std;
 struct Position
+{
     int x;
     int y;
+    long int x;
+    long int y;
 };
 struct DefSocket
+{
     ServerSocket new_sock;
     std::string IP;              //IP de l'antenne
     bool Connected;              //le micro-contrÃŽleur est-il connectÃ© ?
     bool PosValides;             //le micro-contrÃŽleur a-t-il donnÃ© une position valide ?
     char status;                 //status='B' pour busy  'R' pour READY
     int sendalertes;             //une requÃªte "send" a gÃ©nÃ©rÃ© une erreur sur le rÃ©seau
     int AttenteExecution;        //L'antenne parvient-elle Ã  executer un cycle de commandes ?
     int AnomaliesExecution;      //Erreur critique. L'antenne ne rÃ©pond plus !
     Position Pos;                //derniÃšre position retournÃ©e par le microcontrÃŽleur
     int etape;
     bool ack_status;             //Etat des acknowledges ?
     bool ack_pos;
     bool ack_park;
     bool ack_abort;
     bool ack_goto;
     bool GotoOk;                 //Est-ce que le dernier goto est OK ?
+    ServerSocket new_sock;           // socket permettant de gÃ©rer la connexion avec une antennes
+    string IP;                       // IP de l'antenne
+    bool Connected;                  // le micro-contrÃŽleur est-il connectÃ© ?
+    bool PosValides;                 // le micro-contrÃŽleur a-t-il donnÃ© une position des moteurs valide ?
+    char status;                     // status='B' pour busy  'R' pour READY
+    int sendalertes;                 // une requÃªte 'send' a gÃ©nÃ©rÃ© une erreur sur le rÃ©seau
+    int AttenteExecution;            // L'antenne parvient-elle Ã  executer un cycle de commandes ?
+    int AnomaliesExecution;          // Erreur critique. L'antenne ne rÃ©pond plus !
+    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
+    bool ack_status;                 // Etat des acknowledges ?
+    bool ack_pos;                    // le PC a reÃ§u une confirmation du microcont aprÃšs un ordre POSITION
+    bool ack_park;                   // le PC a reÃ§u une confirmation du microcont aprÃšs un ordre PARK
+    bool ack_abort;                  // le PC a reÃ§u une confirmation du microcont aprÃšs un ordre ABORT
+    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 ?
 };
+ServerSocket server( 8000 );
+int SocketsNumber;
+bool InitThreadOK;
+DefSocket Sockets[MAXHOSTNAME + 1];
+pthread_t th1;
+ServerSocket server( 8000 );         // Le PC et les antennes communiquent par le biais du port 8000 sur le rÃ©seau tcp
 class BAO : public Astro
 …
     BAO();
     ~BAO();
     void ISGetProperties (const char *dev);
     void ISNewNumber (const char *dev, const char *name, double values[], char *names[], int n);
 …
     void ISNewSwitch (const char *dev, const char *name, ISState *states, char *names[], int n);
     void ISPoll ();
+    void InitThread();
+    void *pThreadSocket ();
+    void *pThreadExit ();
     bool COMMANDE(int numsocket, char* Commande, char* Params);
     Position ExtractPosition(std::string str);
+    bool ExtractPosition(string str, Position *result);
     void connection_lost();
     void connection_resumed();
     bool STATUS(int numsocket);
     bool POSITION(int numsocket);
 …
     void ADDEC2Motor(double newRA, double newDEC);
     int  AntennesConnectees();
+    void DeconnecterSocket(int num);
     void InitAntennes();
+    /*******************************************************/
+    /* Connection Routines
+    ********************************************************/
+    void init_properties();
+    void get_initial_data();
+    void connect_telescope();
+    bool is_connected(void);
+    /*******************************************************/
+    /* Misc routines
+    ********************************************************/
+    bool process_coords();
+    int get_switch_index(ISwitchVectorProperty *sp);
+    /*******************************************************/
+    /* Simulation Routines
+    ********************************************************/
+    void enable_simulation(bool enable);
+    /*******************************************************/
+    /* Error handling routines
+    ********************************************************/
+    void slew_error(int slewCode);
+    void reset_all_properties();
+    void handle_error(INumberVectorProperty *nvp, int err, const char *msg);
+    void correct_fault();
 private:
 …
     INumber ActualisationN1[1];
     INumber ActualisationN2[1];
     //INumber SlewAccuracyN[2];
     //INumber TrackAccuracyN[2];
 …
     INumberVectorProperty ActualisationNP1;
     INumberVectorProperty ActualisationNP2;
     /* Text Vectors */
 …
     ITextVectorProperty ObjectTP;
+    /*******************************************************/
+    /* Connection Routines
+    ********************************************************/
+    void init_properties();
+    void get_initial_data();
+    void connect_telescope();
+    bool is_connected(void);
+    /*******************************************************/
+    /* Misc routines
+    ********************************************************/
+    bool process_coords();
+    int get_switch_index(ISwitchVectorProperty *sp);
+    /*******************************************************/
+    /* Simulation Routines
+    ********************************************************/
+    void enable_simulation(bool enable);
+    /*******************************************************/
+    /* Error handling routines
+    ********************************************************/
+    void slew_error(int slewCode);
+    void reset_all_properties();
+    void handle_error(INumberVectorProperty *nvp, int err, const char *msg);
+    void correct_fault();
 protected:
+    double JD;                          /* Julian Date */
+    double lastRA;
+    int SocketsNumber;                   // nbre de sockets utilisÃ©s pour connecter les antennes
+    bool InitThreadOK;                   // Le thread est bien actif
+    DefSocket Sockets[MAXHOSTNAME + 1];  // Etat de chaque socket. Un socket permet la communication avec une antenne
+    pthread_t th1;                       // le pointeur du thread
+    double JD;                           // Jour julien
+    double lastRA;                       // Sauvegarde de la derniÃšre position avant actualisation
     double lastDEC;
     double JJAnc;                       // Sauvegarde du jour julien de la derniÃšre actualisation de la position (fct Goto)
     double ActualisationTM1;
+    double JJAnc;                        // Sauvegarde du jour julien lors de la derniÃšre actualisation de la position (fct Goto)
+    double ActualisationTM1;             // DÃ©lais entre deux actualisations dans les modes transit et tracking
     double ActualisationTM2;
+    bool   simulation;
+    bool   fault;
+    bool   LecturePosition;             // Ã©tape dans le processus d'actualisation de la position
+    bool   Abort;
+    bool   Park;
+    bool   Goto;
+    bool   BAOConnected;
+    bool   LastGotoOK;
+    int    fd;                          /* Telescope tty file descriptor */
+    int    currentSet;
+    int    lastSet;
+    int    TrackingMode;                //1 : Transit           2: Tracking
+    Position TargetPosition;            //Position Ã  atteindre en coordonnÃ©es Ã©quatoriales
+    double Longitude;                    // Longitude et latitude du lieu d'observation
+    double Latitude;
+    bool   ActualisationPosition;        // Permet de faire les Ã©tapes nÃ©cessaires pour rÃ©aliser un mouvement
+    bool   Abort;                        // Annulation du mouvement en cours
+    bool   Park;                         // On place les antennes dans une position de repos
+    bool   Suivi;                        // Suivi d'un objet en cours...
+    bool   UpdateGoto;                   // On peut exÃ©cuter un Goto
+    bool   Exit;                         // On ferme le driver
+    int    currentSet;                   // Variable interne de l'interface indi
+    int    lastSet;                      // Variable interne de l'interface indi
+    int    TrackingMode;                 //1 : Transit           2: Tracking
+    Position TargetPosition;             //Position Ã  atteindre en coordonnÃ©es Ã©quatoriales
 };

BAORadio/libindi/libindi/drivers/telescope/astro.cpp

-                      r490
+                      r504
+////////////////////////////////
+// Classe Astro               //
+// Franck RICHARD             //
+// franckrichard033@gmail.com //
+// BAORadio                   //
+// juin 2011                  //
+////////////////////////////////
 #include "astro.h"
+////////////////////
+// Routines Astro //
+////////////////////
+/**************************************************************************************
+** Constructeur de la classe Astro
+***************************************************************************************/
 Astro::Astro()
+{
+    Longitude=0.0;
+    Latitude=0.0;
+    Lst=0.0;
+    JJ=0.0;
+    CorP=0.0;
+    CorEP=0.0;
+    Annee=0.0;
+    Mois=0.0;
+    Jour=0.0;
+    Heu=0.0;
+    Min=0.0;
+    Sec=0.0;
+    ep=0.0;
+    hs=0.0;
+    UTCP=0.0;
+    tsl=0.0;
+    //Initialisation des variables
+    Longitude = 0.0;                     // CordonnÃ©es du lieu d'observation
+    Latitude  = 0.0;
+    Annee     = 0.0;                     // Date et heure de l'observation
+    Mois      = 0.0;
+    Jour      = 0.0;
+    Heure     = 0.0;
+    Min       = 0.0;
+    Sec       = 0.0;
+    UTCP      = 0.0;                     // permet de gÃ©rer le fuseau horaire
+                                         // mais semble inutile sous Linux
+    hs        = 0.0;                     // fraction du jour en cours hs=(heure+min/60+secs/3600)/24.
+    ep        = 0.0;                     // obliquitÃ© de l'Ã©cliptique
+    tsl       = 0.0;                     // temps sidÃ©ral local
+    JJ        = 0.0;                     // Jour Julien
+    CorP      = 0.0;                     // Nutation en longitude
+    CorEP     = 0.0;                     // Nutation en inclinaison
+    LongitudeSoleil = 0.0;
+}
 …
+//0<=Angle<=2*PI
+/**************************************************************************************
+** Initialisation des variables globales de la classe Astro
+***************************************************************************************/
+void Astro::DefinirDateHeure(double A, double M, double J, double H, double Mi, double S)
+{
+    Annee = A;
+    Mois = M;
+    Jour = J;
+    Heure = H;
+    Min = Mi;
+    Sec = S;
+}
+void Astro::DefinirPressionTemp(double P, double T)
+{
+    Pression = P;
+    Temp = T;
+}
+void Astro::DefinirLongitudeLatitude(double log, double lat)
+{
+    Longitude = log;
+    Latitude = lat;
+}
+/**************************************************************************************
+** ParamÃštre : angle en radians
+** retourne angle dans un intervalle 0 <= Angle <= 2*PI
+***************************************************************************************/
 double Astro::VerifAngle(double Angle)
+{
 …
+//////////////////////////////////////////////////////////////////////
+//Nutation
+/**************************************************************************************
+** retourne l'arrondi du nombre donnÃ© en paramÃštre
+** Exemples: Arrondi(5.7) =  6
+**           Arrondi(-5.7)= -6
+***************************************************************************************/
+double Astro::Arrondi(double a)
+{
+    double b;
+    if (a>=0.0)
+    {
+        b=a-floor(a);
+        if (b>=0.5) return ceil(a);
+        else return floor(a);
+    }
+    else
+    {
+        b=ceil(a)-a;
+        if (b>=0.5) return floor(a);
+        else return ceil(a);
+    }
+}
+/**************************************************************************************
+** converti un angle (exprimÃ© en degrÃ©s) dans le format hh:mm:ss ou deg:mm:ss
+** selon la valeur de HMS
+***************************************************************************************/
+string Astro::DHMS(double mema, bool HMS)
+{
+    double d, m, s, a;
+    a=mema;
+    if (HMS) a=a / 15.0;
+    a=fabs(a * 3600.0);
+    s=Arrondi(fmod(a, 60.0) * 10.0) / 10.0;
+    a=floor(a / 60.0);
+    m=fmod(a, 60.0);
+    d=floor(a / 60.0);
+    if (s == 60.0)
+    {
+        s=0.0;
+        m+=1.0;
+        if (m==60.0)
+        {
+            m=0.0;
+            d+=1.0;
+            if (HMS && d>23.0) d=0.0;
+        }
+    }
+    stringstream strsTemp;
+    if (mema < 0) strsTemp << '-';
+    strsTemp << setfill('0') << setw(2) << d << ":" << m << ":" << s;
+    return (strsTemp.str());
+}
+/**************************************************************************************
+** Calcul de la longitude du Soleil
+** La quantitÃ© PS n'est pas indispensable. Elle permet d'amÃ©liorer la prÃ©cision
+***************************************************************************************/
+double Astro::CalculLongitudeSoleil()
+{
+    double T = (JJ - 2415020.0) / 36525.0;
+    double A = 153.23 + 22518.7541 * T;
+    double B = 216.57 + 44037.5082 * T;
+    double C = 312.69 + 32964.3577 * T;
+    double D = 350.74 + ( 445267.1142 - 0.00144 * T ) * T;
+    double E = 231.19 + 20.2 * T;
+    double L = 279.69668 + ( 36000.76892 + 0.0003025 * T ) * T;
+    double M = 358.47583 + (((( -0.0000033 * T) -0.00015 )  * T ) + 35999.04975 ) * T;
+    double CC =   (1.919460 + ((-0.000014 * T) - 0.004789 ) * T ) * sin(M * Pidiv180)
+                  + (0.020094 - 0.0001 * T) * sin(2.0 * M * Pidiv180)
+                  + 0.000293 * sin(3.0 * M * Pidiv180);
+    double PS =  0.00134 * cos(A * Pidiv180)
+                +0.00154 * cos(B * Pidiv180)
+                +0.00200 * cos(C * Pidiv180)
+                +0.00179 * sin(D * Pidiv180)
+                +0.00178 * sin(E * Pidiv180);
+    double LS = VerifAngle( (L + CC + PS) * Pidiv180);
+    return LS;
+}
+/**************************************************************************************
+** Calcul de l'AD et la dÃ©clinaison du Soleil
+** indispensable pour exÃ©cuter la commande "goto sun"
+***************************************************************************************/
+void Astro::CalculARDecSoleil(Coordonnees *Soleil)
+{
+    double ar;
+    double de;
+    ar = atan( cos(ep) * sin(LongitudeSoleil) / cos(LongitudeSoleil));
+    if ( cos(LongitudeSoleil) < 0.0) ar += Pi;
+    de = asin( sin(ep) * sin(LongitudeSoleil));
+    Soleil->ar = DHMS( VerifAngle(ar) * N180divPi, true );
+    Soleil->dec = DHMS( de * N180divPi, false );
+}
+/**************************************************************************************
+** Calcul de la nutation en longitude et en inclinaison
+** NÃ©cessaire pour calculer la position apparente d'un objet (Ã©toile, galaxie etc...)
+***************************************************************************************/
 void Astro::Nutation()
+{
+    double T,L,LP,M,MP,O,L2,LP2,O2;
+    T=(JJ-2415020.0)/36525.0;
+    L=(279.6967+(36000.7689+0.000303*T)*T)*Pidiv180;
+    LP=(270.4342+(481267.8831-0.001133*T)*T)*Pidiv180;
+    M=(358.4758+(35999.0498-0.000150*T)*T)*Pidiv180;
+    MP=(296.1046+(477198.8491+0.009192*T)*T)*Pidiv180;
+    O=(259.1833+(-1934.1420+0.002078*T)*T)*Pidiv180;
+    L2=2.0*L;
+    LP2=2.0*LP;
+    O2=2.0*O;
+    CorP=-(17.2327+0.01737*T)*sin(O)
+         -(1.2729+0.00013*T)*sin(L2)
+         +0.2088*sin(O2)
+         -0.2037*sin(LP2)
+         +(0.1261-0.00031*T)*sin(M)
+         +0.0675*sin(MP)
+         -(0.0497-0.00012*T)*sin(L2+M)
+         -0.0342*sin(LP2-O)
+         -0.0261*sin(LP2+MP)
+         +0.0214*sin(L2-M)
+         -0.0149*sin(L2-LP2+MP)
+         +0.0124*sin(L2-O)
+         +0.0114*sin(LP2-MP);
+    CorEP=(9.2100+0.00091*T)*cos(O)
+          +(0.5522-0.00029*T)*cos(L2)
+          -0.0904*cos(O2)
+          +0.0884*cos(LP2)
+          +0.0216*cos(L2+M)
+          +0.0183*cos(LP2-O)
+          +0.0113*cos(LP2+MP)
+          -0.0093*cos(L2-M)
+          -0.0066*cos(L2-O);
+    CorP=CorP/3600.0*Pidiv180;
+    CorEP=CorEP/3600.0*Pidiv180;
+}
+//////////////////////////////////////////////////////////////////////
+// calcul Jour julien
+    double T = (JJ-2415020.0) / 36525.0;
+    double L  = (279.6967 + (36000.7689 + 0.000303 * T ) * T ) * Pidiv180;
+    double LP = (270.4342 + (481267.8831 - 0.001133 * T ) * T ) * Pidiv180;
+    double M  = (358.4758 + (35999.0498 - 0.000150 * T ) * T ) * Pidiv180;
+    double MP = (296.1046 + (477198.8491 + 0.009192 * T ) * T ) * Pidiv180;
+    double O  = (259.1833 + (-1934.1420 + 0.002078 * T ) * T ) * Pidiv180;
+    double L2  = 2.0 * L;
+    double LP2 = 2.0 * LP;
+    double O2  = 2.0 * O;
+    // Nutation en longitude
+    CorP = -(17.2327 + 0.01737 * T) * sin(O)
+           -(1.2729+0.00013 * T) * sin(L2)
+           +0.2088 * sin(O2)
+           -0.2037 * sin(LP2)
+           +(0.1261 - 0.00031 * T) * sin(M)
+           +0.0675 * sin(MP)
+           -(0.0497 - 0.00012 * T) * sin(L2 + M)
+           -0.0342 * sin(LP2 - O)
+           -0.0261 * sin(LP2 + MP)
+           +0.0214 * sin(L2 - M)
+           -0.0149 * sin(L2 - LP2 + MP)
+           +0.0124 * sin(L2 - O)
+           +0.0114 * sin(LP2 - MP);
+    //Nutation en inclinaison
+    CorEP = (9.2100 + 0.00091 * T) * cos(O)
+            +(0.5522 - 0.00029 * T) * cos(L2)
+            -0.0904 * cos(O2)
+            +0.0884 * cos(LP2)
+            +0.0216 * cos(L2+M)
+            +0.0183 * cos(LP2-O)
+            +0.0113 * cos(LP2+MP)
+            -0.0093 * cos(L2-M)
+            -0.0066 * cos(L2-O);
+    CorP  = CorP / 3600.0 * Pidiv180;
+    CorEP = CorEP / 3600.0 * Pidiv180;
+}
+/**************************************************************************************
+** Nutation des Ã©toiles - on utilise les quantitÃ©s calculÃ©es prÃ©cÃ©demment
+** ar et de sont exprimÃ©s en radians
+***************************************************************************************/
+void Astro::NutationEtoile(double *ar, double *de)
+{
+    double a = (cos(ep) + sin(ep) * sin(*ar) * tan(*de)) * CorP - (cos(*ar) * tan(*de)) * CorEP;
+    double b = (sin(ep) * cos(*ar)) * CorP + sin(*ar) * CorEP;
+    *ar = VerifAngle(*ar+a);
+    *de += b;
+}
+/**************************************************************************************
+** PrÃ©cession des Ã©quinoxes
+** ar et de sont exprimÃ©s en radians
+***************************************************************************************/
+void Astro::Precession(double *ar, double *de)
+{
+    double t = (JJ - 2451544.5) / 36524.2199;
+    double ze = ((((0.018 * t) + 0.302) * t + 2304.948) * t) / 3600.0 * Pidiv180;
+    double z = ((((0.019 * t) + 1.093) * t + 2304.948) * t) / 3600.0 * Pidiv180;
+    double delta = ((((-0.042 * t) - 0.426) * t + 2004.255) * t) / 3600.0 * Pidiv180;
+    double A = cos(*de) * sin(*ar + ze);
+    double B = cos(delta) * cos(*de) * cos (*ar + ze) - sin(delta) * sin(*de);
+    double C = sin(delta) * cos(*de) * cos (*ar + ze) + cos(delta) * sin(*de);
+    double AMZ = atan(A / B);
+    if (B<0.0) AMZ += Pi;
+    *ar=VerifAngle(AMZ + z);
+    *de=asin(C);
+}
+/**************************************************************************************
+** ObliquitÃ©
+** calcul de l'inclinaison de l'axe terrestre par rapport Ã  au plan de l'Ã©cliptique
+** QuantitÃ© indispensable pour calculer le temps sidÃ©ral local et les coordonnÃ©es
+** horaires du soleil
+***************************************************************************************/
+void Astro::Obliquite(double JJ)
+{
+    double T;
+    T = (JJ - 2415020.0) / 36525.0;
+    ep = (23.452294+ (((0.000000503 * T ) - 0.00000164 ) * T - 0.0130125 ) * T ) * Pidiv180;
+}
+/**************************************************************************************
+** Aberration annuelle des Ã©toiles
+** ar et de sont exprimÃ©s en radians
+***************************************************************************************/
+void Astro::AberrationAnnuelle(double *ar, double *de)
+{
+    double c = -20.49 / 3600.0 * Pidiv180;
+    double a = c * ( cos(*ar) * cos(LongitudeSoleil) * cos(ep)
+                     + sin(*ar) * sin(LongitudeSoleil)
+                   ) / cos(*de);
+    double b = c * ( cos(LongitudeSoleil) * cos(ep) * (tan(ep) * cos(*de) - sin(*ar) * sin(*de))
+                     + cos(*ar) * sin(*de) * sin(LongitudeSoleil));
+    *ar = VerifAngle(*ar + a);
+    *de += b;
+}
+/**************************************************************************************
+** calcul Jour julien
+***************************************************************************************/
 void Astro::CalculJJ(double Heure)
+{
+    JJ = CalculJJ(Annee, Mois, Jour, Heure);
+}
+double Astro::CalculJJ(double A, double M, double J, double Heure)
+{
     long y, a, b, c, e, m;
+    long year = (long)Annee;
+    int month = (int)Mois;
+    double day = Jour + Heure;
+    long year = (long)A;
+    int month = (int)M;
+    double day = J + Heure;
     y = year + 4800;
 …
 gregor:
         b = (a/4) - a;
+        b = (a / 4) - a;
+    }
+    c = (36525L * y)/100;
+    JJ = b + c + e + day - 32167.5;
+}
+///////////////////////////////////////////////////////////////////////
+//ObliquitÃ©
+void Astro::Obliquite(double JJ)
+{
+    double T;
+    T = (JJ-2415020.0) / 36525.0;
+    ep = (23.452294+ (((0.000000503 * T ) - 0.00000164 ) * T - 0.0130125 ) * T ) * Pidiv180;
+}
+///////////////////////////////////////////////////////////////////////
+//Temps sidÃ©ral local
+    c = (36525L * y) / 100;
+    return b + c + e + day - 32167.5;
+}
+/**************************************************************************************
+** Temps sidÃ©ral local
+***************************************************************************************/
 double Astro::TSL(double JJ, double HeureSiderale, double Longitude)
+{
+    double rd,T;
+    T = (JJ - 2415020.0 ) / 36525.0;
+    rd = 0.276919398 + ( 100.0021359 + 0.000001075 * T ) * T;
+    double T = (JJ - 2415020.0 ) / 36525.0;
+    double rd = 0.276919398 + ( 100.0021359 + 0.000001075 * T ) * T;
     rd += HeureSiderale;
     rd *= Pi2;
+    // temps sidÃ©ral apparent
     rd += CorP * cos(ep);
     rd -= Longitude;
 …
+/**************************************************************************************
+** routine principale des calculs
+***************************************************************************************/
 void Astro::CalculTSL()
+{
     hs=(Heu+Min/60.0+Sec/3600.0)/24.0;
     hs-=UTCP/24.0;
+    hs = (Heure + Min / 60.0 + Sec / 3600.0) / 24.0;
+    hs -= UTCP / 24.0;
     CalculJJ(hs);
 …
     Nutation();
+    tsl=TSL(JJ, hs, Longitude);
+}
+///////////////////////////////////////////////////////////////////////
+//Azimut et hauteur Ã  partir de AR et Dec
+void Astro::Azimut(double ts, double Latitude, double Ar, double De, double *azi, double *hau)
+{
+    double ah, ht, a1, az, zc, ac;
+    ah=ts-Ar;
+    zc=sin(Latitude)*sin(De)+cos(Latitude)*cos(De)*cos(ah);
+    ht=atan(zc/sqrt((-zc*zc)+1.0));
+    a1=cos(De)*sin(ah)/cos(ht);
+    ac=(-cos(Latitude)*sin(De)+sin(Latitude)*cos(De)*cos(ah))/cos(ht);
+    az=atan(a1/sqrt((-a1*a1)+1.0));
+    tsl = TSL(JJ, hs, Longitude);
+    LongitudeSoleil = CalculLongitudeSoleil();
+}
+/**************************************************************************************
+** Calcule la hauteur et l'azimut des Ã©toiles en fct du lieu d'observation
+***************************************************************************************/
+void Astro::Azimut(double Ar, double De, double *azi, double *hau)
+{
+    double ah = tsl - Ar;
+    double zc = sin(Latitude) * sin(De) + cos(Latitude) * cos(De) * cos(ah);
+    double ht = atan(zc / sqrt((-zc * zc) + 1.0));
+    double a1 = cos(De) * sin(ah) / cos(ht);
+    double ac = (-cos(Latitude) * sin(De) + sin(Latitude) * cos(De) * cos(ah)) / cos(ht);
+    double az = atan(a1 / sqrt((-a1*a1)+1.0));
     if (ac<0.0) az=Pi-az;
+    az=VerifAngle(Pi+az);
+    *azi=az;
+    *azi=VerifAngle(Pi+az);
     *hau=ht;
+}
+/**************************************************************************************
+** rÃ©fraction atmosphÃ©rique : formule simple de Jean Meeus
+** la hauteur ht est exprimÃ©e en radians
+***************************************************************************************/
+double Astro::RefractionAtmospherique(double ht)
+{
+    double gamma, R0, a, b, PressionTempCalc, tanHT;
+    if (Pression!=0.0)
+    {
+        PressionTempCalc = (Pression / 1013.25) * 273.0 / (273.0 + Temp);
+        if (ht <= 15.0 * Pidiv180)
+        {
+            gamma = 2.6;
+            a = 7.5262;
+            b = -2.2204;
+            if (ht >= 4.0 * Pidiv180)
+            {
+                gamma=-1.1;
+                a=4.4010;
+                b=-0.9603;
+            }
+            R0 = (pow((a+b*log(ht*N180divPi+gamma)), 2.0)) / 60.0 * Pidiv180;
+            ht += R0 * PressionTempCalc;
+        }
+        else
+        {
+            tanHT = fabs(tan(Pidiv2 - ht));
+            R0 = (0.0161877777777777777777-0.000022888888888888888 * tanHT * tanHT)
+                 * tanHT * Pidiv180;
+            ht += R0 * PressionTempCalc;
+        }
+    }
+    return ht;
+}
+double Astro::slaDrange(double angle )
+{
+    return fmod(angle, Pi);
+}
+float  Astro::slaRange(float angle )
+{
+    return fmodf(angle, Pi);
+}
+void Astro::slaRefro ( double zobs, double hm, double tdk, double pmb,
+                       double rh, double wl, double phi, double tlr,
+                       double eps, double *ref )
+/*
+**  - - - - - - - - -
+**   s l a R e f r o
+**  - - - - - - - - -
+**
+**  Atmospheric refraction for radio and optical wavelengths.
+**
+**  Given:
+**    zobs    double  observed zenith distance of the source (radian)
+**    hm      double  height of the observer above sea level (metre)
+**    tdk     double  ambient temperature at the observer (deg K)
+**    pmb     double  pressure at the observer (millibar)
+**    rh      double  relative humidity at the observer (range 0-1)
+**    wl      double  effective wavelength of the source (micrometre)
+**    phi     double  latitude of the observer (radian, astronomical)
+**    tlr     double  temperature lapse rate in the troposphere (degK/met
+**    eps     double  precision required to terminate iteration (radian)
+**
+**  Returned:
+**    ref     double  refraction: in vacuo ZD minus observed ZD (radian)
+**
+**  Notes:
+**
+**  1  A suggested value for the tlr argument is 0.0065D0.  The
+**     refraction is significantly affected by tlr, and if studies
+**     of the local atmosphere have been carried out a better tlr
+**     value may be available.
+**
+**  2  A suggested value for the eps argument is 1e-8.  The result is
+**     usually at least two orders of magnitude more computationally
+**     precise than the supplied eps value.
+**
+**  3  The routine computes the refraction for zenith distances up
+**     to and a little beyond 90 deg using the method of Hohenkerk
+**     and Sinclair (NAO Technical Notes 59 and 63, subsequently adopted
+**     in the Explanatory Supplement, 1992 edition - see section 3.281).
+**
+**  4  The C code is an adaptation of the Fortran optical refraction
+**     subroutine AREF of C.Hohenkerk (HMNAO, September 1984), with
+**     extensions to support the radio case.  The following modifications
+**     to the original HMNAO optical refraction algorithm have been made:
+**
+**     .  The angle arguments have been changed to radians.
+**
+**     .  Any value of zobs is allowed (see note 6, below).
+**
+**     .  Other argument values have been limited to safe values.
+**
+**     .  Murray's values for the gas constants have been used
+**        (Vectorial Astrometry, Adam Hilger, 1983).
+**
+**     .  The numerical integration phase has been rearranged for
+**        extra clarity.
+**
+**     .  A better model for Ps(T) has been adopted (taken from
+**        Gill, Atmosphere-Ocean Dynamics, Academic Press, 1982).
+**
+**     .  More accurate expressions for Pwo have been adopted
+**        (again from Gill 1982).
+**
+**     .  Provision for radio wavelengths has been added using
+**        expressions devised by A.T.Sinclair, RGO (private
+**        communication 1989), based on the Essen & Froome
+**        refractivity formula adopted in Resolution 1 of the
+**        13th International Geodesy Association General Assembly
+**        (Bulletin Geodesique 1963 p390).
+**
+**     .  Various small changes have been made to gain speed.
+**
+**     None of the changes significantly affects the optical results
+**     with respect to the algorithm given in the 1992 Explanatory
+**     Supplement.  For example, at 70 deg zenith distance the present
+**     routine agrees with the ES algorithm to better than 0.05 arcsec
+**     for any reasonable combination of parameters.  However, the
+**     improved water-vapour expressions do make a significant difference
+**     in the radio band, at 70 deg zenith distance reaching almost
+**     4 arcsec for a hot, humid, low-altitude site during a period of
+**     low pressure.
+**
+**  5  The radio refraction is chosen by specifying wl > 100 micrometres.
+**     Because the algorithm takes no account of the ionosphere, the
+**     accuracy deteriorates at low frequencies, below about 30 MHz.
+**
+**  6  Before use, the value of zobs is expressed in the range +/- pi.
+**     If this ranged zobs is -ve, the result ref is computed from its
+**     absolute value before being made -ve to match.  In addition, if
+**     it has an absolute value greater than 93 deg, a fixed ref value
+**     equal to the result for zobs = 93 deg is returned, appropriately
+**     signed.
+**
+**  7  As in the original Hohenkerk and Sinclair algorithm, fixed values
+**     of the water vapour polytrope exponent, the height of the
+**     tropopause, and the height at which refraction is negligible are
+**     used.
+**
+**  8  The radio refraction has been tested against work done by
+**     Iain Coulson, JACH, (private communication 1995) for the
+**     James Clerk Maxwell Telescope, Mauna Kea.  For typical conditions,
+**     agreement at the 0.1 arcsec level is achieved for moderate ZD,
+**     worsening to perhaps 0.5-1.0 arcsec at ZD 80 deg.  At hot and
+**     humid sea-level sites the accuracy will not be as good.
+**
+**  9  It should be noted that the relative humidity rh is formally
+**     defined in terms of "mixing ratio" rather than pressures or
+**     densities as is often stated.  It is the mass of water per unit
+**     mass of dry air divided by that for saturated air at the same
+**     temperature and pressure (see Gill 1982).
+**
+**  Called:  slaDrange, atmt, atms
+**
+**  Defined in slamac.h:  TRUE, FALSE
+**
+**  Last revision:   30 January 1997
+**
+**  Copyright P.T.Wallace.  All rights reserved.
+*/
+{
+    /* Fixed parameters */
+    static double d93 = 1.623156204; /* 93 degrees in radians        */
+    static double gcr = 8314.32;     /* Universal gas constant       */
+    static double dmd = 28.9644;     /* Molecular weight of dry air  */
+    static double dmw = 18.0152;     /* Molecular weight of water
+                                                             vapour */
+    static double s = 6378120.0;     /* Mean Earth radius (metre)    */
+    static double delta = 18.36;     /* Exponent of temperature
+                                         dependence of water vapour
+                                                           pressure */
+    static double ht = 11000.0;      /* Height of tropopause (metre) */
+    static double hs = 80000.0;      /* Upper limit for refractive
+                                                    effects (metre) */
+    /* Variables used when calling the internal routine atmt */
+    double robs;   /* height of observer from centre of Earth (metre) */
+    double tdkok;  /* temperature at the observer (deg K) */
+    double alpha;  /* alpha          |        */
+    double gamm2;  /* gamma minus 2  | see ES */
+    double delm2;  /* delta minus 2  |        */
+    double c1,c2,c3,c4,c5,c6;  /* various */
+    /* Variables used when calling the internal routine atms */
+    double rt;     /* height of tropopause from centre of Earth (metre) */
+    double tt;     /* temperature at the tropopause (deg k) */
+    double dnt;    /* refractive index at the tropopause */
+    double gamal;  /* constant of the atmospheric model = g*md/r */
+    int is, k, n, i, j, optic;
+    double zobs1, zobs2, hmok, pmbok, rhok, wlok, tol, wlsq, gb,
+    a, gamma, tdc, psat, pwo, w, tempo, dn0, rdndr0, sk0,
+    f0, rdndrt, zt, ft, dnts, rdndrp, zts, fts, rs,
+    dns, rdndrs, zs, fs, refold, z0, zrange, fb, ff, fo,
+    fe, h, r, sz, rg, dr, tg, dn, rdndr, t, f, refp, reft;
+    /* The refraction integrand */
+#define refi(R,DN,RDNDR) ((RDNDR)/(DN+RDNDR));
+    /* Transform zobs into the normal range */
+    zobs1 = slaDrange ( zobs );
+    zobs2 = fabs ( zobs1 );
+    zobs2 = gmin ( zobs2, d93 );
+    /* Keep other arguments within safe bounds */
+    hmok = gmax ( hm, -1000.0 );
+    hmok = gmin ( hmok, 10000.0 );
+    tdkok = gmax ( tdk, 100.0 );
+    tdkok = gmin ( tdkok, 500.0 );
+    pmbok = gmax ( pmb, 0.0 );
+    pmbok = gmin ( pmbok, 10000.0 );
+    rhok  = gmax ( rh, 0.0 );
+    rhok  = gmin ( rhok, 1.0 );
+    wlok  = gmax ( wl, 0.1 );
+    alpha = fabs ( tlr );
+    alpha = gmax ( alpha, 0.001 );
+    alpha = gmin ( alpha, 0.01 );
+    /* Tolerance for iteration */
+    w = fabs ( eps );
+    tol = gmin ( w, 0.1 ) / 2.0;
+    /* Decide whether optical or radio case - switch at 100 micron */
+    optic = ( wlok <= 100.0 );
+    /* Set up model atmosphere parameters defined at the observer */
+    wlsq = wlok * wlok;
+    gb = 9.784 * ( 1.0 - 0.0026 * cos ( 2.0 * phi ) - 2.8e-7 * hmok );
+    a = ( optic ) ?
+        ( ( 287.604 + 1.6288 / wlsq + 0.0136 / ( wlsq * wlsq ) )
+          * 273.15 / 1013.25 ) * 1e-6
+        :
+.624e-6;
+    gamal = gb * dmd / gcr;
+    gamma = gamal / alpha;
+    gamm2 = gamma - 2.0;
+    delm2 = delta - 2.0;
+    tdc = tdkok - 273.15;
+    psat = pow ( 10.0, ( 0.7859 + 0.03477 * tdc ) /
+                 ( 1.0 + 0.00412 * tdc ) ) *
+           ( 1.0 + pmbok * ( 4.5e-6 + 6e-10 * tdc * tdc ) );
+    pwo = ( pmbok > 0.0 ) ?
+          rhok * psat / ( 1.0 - ( 1.0 - rhok ) * psat / pmbok ) :
+.0;
+    w = pwo * ( 1.0 - dmw / dmd ) * gamma / ( delta - gamma );
+    c1 = a * ( pmbok + w ) / tdkok;
+    c2 = ( a * w + ( optic ? 11.2684e-6 : 12.92e-6 ) * pwo ) / tdkok;
+    c3 = ( gamma - 1.0 ) * alpha * c1 / tdkok;
+    c4 = ( delta - 1.0 ) * alpha * c2 / tdkok;
+    c5 = optic ? 0.0 : 371897e-6 * pwo / tdkok;
+    c6 = c5 * delm2 * alpha / ( tdkok * tdkok );
+    /* Conditions at the observer */
+    robs = s + hmok;
+    atmt ( robs, tdkok, alpha, gamm2, delm2, c1, c2, c3, c4, c5, c6, robs,
+           &tempo, &dn0, &rdndr0 );
+    sk0 = dn0 * robs * sin ( zobs2 );
+    f0 = refi ( robs, dn0, rdndr0 );
+    /* Conditions at the tropopause in the troposphere */
+    rt = s + ht;
+    atmt ( robs, tdkok, alpha, gamm2, delm2, c1, c2, c3, c4, c5, c6, rt,
+           &tt, &dnt, &rdndrt );
+    zt = asin ( sk0 / ( rt * dnt ) );
+    ft = refi ( rt, dnt, rdndrt );
+    /* Conditions at the tropopause in the stratosphere */
+    atms ( rt, tt, dnt, gamal, rt, &dnts, &rdndrp );
+    zts = asin ( sk0 / ( rt * dnts ) );
+    fts = refi ( rt, dnts, rdndrp );
+    /* At the stratosphere limit */
+    rs = s + hs;
+    atms ( rt, tt, dnt, gamal, rs, &dns, &rdndrs );
+    zs = asin ( sk0 / ( rs * dns ) );
+    fs = refi ( rs, dns, rdndrs );
+    /*
+    ** Integrate the refraction integral in two parts;  first in the
+    ** troposphere (k=1), then in the stratosphere (k=2).
+    */
+    /* Initialize previous refraction to ensure at least two iterations */
+    refold = 1e6;
+    /*
+    ** Start off with 8 strips for the troposphere integration, and then
+    ** use the final troposphere value for the stratosphere integration,
+    ** which tends to need more strips.
+    */
+    is = 8;
+    /* Troposphere then stratosphere */
+    for ( k = 1; k <= 2; k++ ) {
+        /* Start z, z range, and start and end values */
+        if ( k == 1 ) {
+            z0 = zobs2;
+            zrange = zt - z0;
+            fb = f0;
+            ff = ft;
+        } else {
+            z0 = zts;
+            zrange = zs - z0;
+            fb = fts;
+            ff = fs;
+        }
+        /* Sums of odd and even values */
+        fo = 0.0;
+        fe = 0.0;
+        /* First time through loop we have to do every point */
+        n = 1;
+        /* Start of iteration loop (terminates at specified precision) */
+        for ( ; ; ) {
+            /* Strip width */
+            h = zrange / (double) is;
+            /* Initialize distance from Earth centre for quadrature pass */
+            r = ( k == 1 ) ? robs : rt;
+            /* One pass (no need to compute evens after first time) */
+            for ( i = 1; i < is; i += n ) {
+                /* Sine of observed zenith distance */
+                sz = sin ( z0 + h * (double) i );
+                /* Find r (to nearest metre, maximum four iterations) */
+                if ( sz > 1e-20 ) {
+                    w = sk0 / sz;
+                    rg = r;
+                    j = 0;
+                    do {
+                        if ( k == 1 ) {
+                            atmt ( robs, tdkok, alpha, gamm2, delm2,
+                                   c1, c2, c3, c4, c5, c6, rg,
+                                   &tg, &dn, &rdndr );
+                        } else {
+                            atms ( rt, tt, dnt, gamal, rg, &dn, &rdndr );
+                        }
+                        dr = ( rg * dn - w ) / ( dn + rdndr );
+                        rg -= dr;
+                    } while ( fabs ( dr ) > 1.0 && j++ <= 4 );
+                    r = rg;
+                }
+                /* Find refractive index and integrand at r */
+                if ( k == 1 ) {
+                    atmt ( robs, tdkok, alpha, gamm2, delm2,
+                           c1, c2, c3, c4, c5, c6, r,
+                           &t, &dn, &rdndr );
+                } else {
+                    atms ( rt, tt, dnt, gamal, r, &dn, &rdndr );
+                }
+                f = refi ( r, dn, rdndr );
+                /* Accumulate odd and (first time only) even values */
+                if ( n == 1 && i % 2 == 0 ) {
+                    fe += f;
+                } else {
+                    fo += f;
+                }
+            }
+            /* Evaluate the integrand using Simpson's Rule */
+            refp = h * ( fb + 4.0 * fo + 2.0 * fe + ff ) / 3.0;
+            /* Has the required precision been reached? */
+            if ( fabs ( refp - refold ) > tol ) {
+                /* No: prepare for next iteration */
+                refold = refp;   /* Save current value for convergence test */
+                is += is;        /* Double the number of strips */
+                fe += fo;        /* Sum of all = sum of evens next time */
+                fo = 0.0;        /* Reset odds accumulator */
+                n = 2;           /* Skip even values next time */
+            } else {
+                /* Yes: save troposphere component and terminate loop */
+                if ( k == 1 ) reft = refp;
+                break;
+            }
+        }
+    }
+    /* Result */
+    *ref = reft + refp;
+    if ( zobs1 < 0.0 ) *ref = - ( *ref );
+    *ref+=Pidiv2-zobs1;
+}
+/*--------------------------------------------------------------------------*/
+void Astro::atmt ( double robs, double tdkok, double alpha, double gamm2,
+                   double delm2, double c1, double c2, double c3,
+                   double c4, double c5, double c6, double r,
+                   double *t, double *dn, double *rdndr )
+/*
+**  - - - - -
+**   a t m t
+**  - - - - -
+**
+**  Internal routine used by slaRefro:
+**
+**    refractive index and derivative with respect to height for the
+**    troposphere.
+**
+**  Given:
+**    robs    double   height of observer from centre of the Earth (metre)
+**    tdkok   double   temperature at the observer (deg K)
+**    alpha   double   alpha          )
+**    gamm2   double   gamma minus 2  ) see ES
+**    delm2   double   delta minus 2  )
+**    c1      double   useful term  )
+**    c2      double   useful term  )
+**    c3      double   useful term  ) see source of
+**    c4      double   useful term  ) slaRefro main routine
+**    c5      double   useful term  )
+**    c6      double   useful term  )
+**    r       double   current distance from the centre of the Earth (metre)
+**
+**  Returned:
+**    *t      double   temperature at r (deg K)
+**    *dn     double   refractive index at r
+**    *rdndr  double   r * rate the refractive index is changing at r
+**
+**  This routine is derived from the ATMOSTRO routine (C.Hohenkerk,
+**  HMNAO), with enhancements specified by A.T.Sinclair (RGO) to
+**  handle the radio case.
+**
+**  Note that in the optical case c5 and c6 are zero.
+*/
+{
+    double w, tt0, tt0gm2, tt0dm2;
+    w = tdkok - alpha * ( r - robs );
+    w = gmin ( w, 320.0 );
+    w = gmax ( w, 200.0 );
+    tt0 = w / tdkok;
+    tt0gm2 = pow ( tt0, gamm2 );
+    tt0dm2 = pow ( tt0, delm2 );
+    *t = w;
+    *dn = 1.0 + ( c1 * tt0gm2 - ( c2 - c5 / w ) * tt0dm2 ) * tt0;
+    *rdndr = r * ( - c3 * tt0gm2 + ( c4 - c6 / tt0 ) * tt0dm2 );
+}
+/*--------------------------------------------------------------------------*/
+void Astro::atms ( double rt, double tt, double dnt, double gamal, double r,
+                   double *dn, double *rdndr )
+/*
+**  - - - - -
+**   a t m s
+**  - - - - -
+**
+**  Internal routine used by slaRefro:
+**
+**   refractive index and derivative with respect to height for the
+**   stratosphere.
+**
+**  Given:
+**    rt      double   height of tropopause from centre of the Earth (metre)
+**    tt      double   temperature at the tropopause (deg k)
+**    dnt     double   refractive index at the tropopause
+**    gamal   double   constant of the atmospheric model = g*md/r
+**    r       double   current distance from the centre of the Earth (metre)
+**
+**  Returned:
+**    *dn     double   refractive index at r
+**    *rdndr  double   r * rate the refractive index is changing at r
+**
+**  This routine is derived from the ATMOSSTR routine (C.Hohenkerk, HMNAO).
+*/
+{
+    double b, w;
+    b = gamal / tt;
+    w = ( dnt - 1.0 ) * exp ( - b * ( r - rt ) );
+    *dn = 1.0 + w;
+    *rdndr = - r * b * w;
+}

BAORadio/libindi/libindi/drivers/telescope/astro.h

-                      r490
+                      r504
+// Definition of the Astro class
+// Franck RICHARD
+// BAORadio
+////////////////////////////////
+// Classe Astro               //
+// Franck RICHARD             //
+// BAORadio                   //
+// franckrichard033@gmail.com //
+// juin 2011                  //
+////////////////////////////////
 #ifndef Astro_class
 …
 #include "math.h"
+#include "stdio.h"
+#include <iostream>
+#include <string.h>
+#include <sstream>
+#include <iomanip>
+using namespace std;
 //////////////////////////////
 …
 #define Pidiv2          1.57079632679489661923132169163
+#define gmax(A,B) ((A)>(B)?(A):(B))
+class Astro
+#define gmin(A,B) ((A)<(B)?(A):(B))
+struct Coordonnees
+{
+    string ar;                          // CoordonnÃ©es horaires d'un objet
+    string dec;
+};
+class Astro
+{
 public:
 …
     ~Astro();
+    void   DefinirDateHeure(double Annee, double Mois, double Jour, double Heu, double Min, double Sec);
+    void   DefinirPressionTemp(double P, double T);
+    void   DefinirLongitudeLatitude(double log, double lat);
     double VerifAngle(double Angle);
+    void  Azimut(double ts, double Latitude, double Ar, double De, double *azi, double *hau);
+    void  CalculJJ(double Heure);
+    double Arrondi(double a);
+    string DHMS(double mema, bool HMS);
+    void   Azimut(double Ar, double De, double *azi, double *hau);
+    void   Precession(double *ar, double *de);
+    void   NutationEtoile(double *ar, double *de);
+    void   AberrationAnnuelle(double *ar, double *de);
+    void   CalculJJ(double Heure);
+    double CalculJJ(double A, double M, double J, double Heure);
+    void   CalculTSL();
+    double RefractionAtmospherique(double ht);
+    double CalculLongitudeSoleil();
     double TSL(double JJ,double HeureSiderale,double Longitude);
+    void Nutation();
+    void Obliquite(double JJ);
+    void CalculTSL();
+    void   Nutation();
+    void   Obliquite(double JJ);
+    void   atms ( double rt, double tt, double dnt, double gamal, double r,
+                   double *dn, double *rdndr );
+    void   atmt ( double robs, double tdkok, double alpha, double gamm2,
+                   double delm2, double c1, double c2, double c3,
+                   double c4, double c5, double c6, double r,
+                   double *t, double *dn, double *rdndr );
+    void   slaRefro ( double zobs, double hm, double tdk, double pmb,
+                double rh, double wl, double phi, double tlr,
+                double eps, double *ref );
+    float  slaRange(float angle );
+    double slaDrange(double angle );
+    void   CalculARDecSoleil(Coordonnees *Soleil);
+    double GetAnnee() { return Annee; }
+    double GetMois()  { return Mois;  }
+    double GetJour()  { return Jour;  }
+    double GetHeure() { return Heure; }
+    double GetMin()   { return Min;   }
+    double GetSec()   { return Sec;   }
+    double GetJJ()    { return JJ;    }
+private:
     double Longitude;
     double Latitude;
-    double Lst;
     double JJ;
     double CorP;
 …
     double Mois;
     double Jour;
     double Heu;
+    double Heure;
     double Min;
     double Sec;
 …
     double UTCP;
     double tsl;
+    double LongitudeSoleil;
+    double Pression;
+    double Temp;
 };

BAORadio/libindi/libindi/drivers/telescope/lx200generic.cpp

-                      r501
+                      r504
  Property: Movement (Arrow keys on handset). West/East
 *********************************************/
 static ISwitch MovementWES[]       = {{"MOTION_WEST", "West", ISS_OFF, 0, 0}, {"MOTION_EAST", "East", ISS_OFF, 0, 0}};
 ISwitchVectorProperty MovementWESP      = { mydev, "TELESCOPE_MOTION_WE", "West/East", MOTION_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE, MovementWES, NARRAY(MovementWES), "", 0};
 …
   strcpy(TimeTP.device , newName );
   strcpy(UTCOffsetNP.device , newName );
   strcpy(SDTimeNP.device , newName );

BAORadio/libindi/libindi/examples/README

-                      r490
+                      r504
 tutorial_one: We construct a most basic (and useless) device driver to illustate basic INDI structures.
 tutorial_two:  We create a simple simulator. We will use a few handy utility functions provided by INDI like timers, string <---> number conversion, and more.
 tutorial_three:  We create a simple device, and establish a data channel with the client to transmit a FITS file.
+tutorial_three:  We create a simple CCD simulator, and establish a data channel with the client to transmit a FITS file.
 tutorial_dome and tutorial_rain are part of the inter-driver communication tutorial.
+tutorial_client: We create a simple client to set the temperature of a CCD simulator (tutorial_three).
 Usage
 …
 where num is the tutorial number (tutorial_one, tutorial_two, or tutorial_three).
+------------------------------------------------------------------------------------------
 For the inter-driver communications tutorial, type instead:
 $ indiserver -v -p 8000 ./tutorial_dome ./tutorial_rain
+------------------------------------------------------------------------------------------
+For tutorial_client. Run tutorial_three first:
+$ indiserver -v ./tutorial_three
+Then open another console tab, and run the client:
+$ ./tutorial_client
+You can connect to tutorial_three via a GUI client (e.g. KStars) before running tutorial_client. This will enable you to watch
+changes in the driver as they occur from tutorial_client. Make sure to set the port to 7624 in KStars.
 ------------------------------------------------------------------------------------------

BAORadio/libindi/libindi/examples/tutorial_four.cpp

-                      r501
+                      r504
     IDLog("Initilizing from My Scope device...\n");
     init_properties();
+    //init_properties();
+ }
 …
 /**************************************************************************************
 ** Initialize all properties & set default values.
+***************************************************************************************/
+void MyScope::init_properties()
+{
+**************************************************************************************/
+bool MyScope::initProperties()
+{
+    DefaultDriver::initProperties();
     // This is the default driver skeleton file location
     // Convention is: drivername_sk_xml
 …
     addAuxControls();
+    return true;
+}
 …
             return false;
         // Are we update CONNECTION?
+        /* Are we update CONNECTION?
         if (!strcmp(svp->name, "CONNECTION"))
+        {
 …
             connect_telescope();
             return true;
+        }
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+void MyScope::connect_telescope()
+{
+    ISwitchVectorProperty *svp = getSwitch("CONNECTION");
+    ISwitch *sp = IUFindOnSwitch(svp);
+    if (!sp)
+        return;
+    // Are we connecting?
+    if (!strcmp(sp->name, "CONNECT"))
+    {
+        // Make sure to call setConnected(true) before informing client about successful connection
+        setConnected(true);
+        IDSetSwitch(svp, "Connecting.... telescope is online.");
+        IDLog("Connecting.... telescope is online.\n");
+    }
+    // Are we disconnecting?
+    else
+    {
+        setConnected(false);
+        IDSetSwitch(svp, "Disconnecting... telescope is offline.");
+        IDLog("Disconnecting... telescope is offline.\n");
+    }
+}
+        }*/
+}
+/**************************************************************************************
+**
+***************************************************************************************/
+bool MyScope::Connect()
+{
+    return true;
+}
+bool MyScope::Disconnect()
+{
+    return true;
+}
+const char * MyScope::getDefaultName()
+{
+    return "My Scope";
+}

BAORadio/libindi/libindi/examples/tutorial_four.h

-                      r501
+                      r504
 private:
+ void init_properties();
+ void connect_telescope();
+ const char *getDefaultName();
+ virtual bool initProperties();
+ virtual bool Connect();
+ virtual bool Disconnect();
 };

BAORadio/libindi/libindi/examples/tutorial_three.c

-                      r490
+                      r504
 /* BLOB for sending image */
+static IBLOB imageB = {"CCD1", "Feed", "", 0, 0, 0, 0, 0, 0, 0};
+static IBLOBVectorProperty imageBP = {mydev, "Video", "Video", COMM_GROUP,
+  IP_RO, 0, IPS_IDLE, &imageB, 1, "", 0};
+static IBLOB imagePrimaryB = {"CCD1", "Primary", "", 0, 0, 0, 0, 0, 0, 0};
+static IBLOBVectorProperty imagePrimaryBP = {mydev, "CCD1", "", COMM_GROUP,
+  IP_RO, 0, IPS_IDLE, &imagePrimaryB, 1, "", 0};
+static IBLOB imageGuideB = {"CCD2", "Guide", "", 0, 0, 0, 0, 0, 0, 0};
+static IBLOBVectorProperty imageGuideBP = {mydev, "CCD2", "", COMM_GROUP,
+  IP_RO, 0, IPS_IDLE, &imageGuideB, 1, "", 0};
 void ISGetProperties (const char *dev)
 …
   IDDefNumber(&ExposeTimeNP, NULL);
   IDDefNumber(&TemperatureNP, NULL);
+  IDDefBLOB(&imageBP, NULL);
+  IDDefBLOB(&imagePrimaryBP, NULL);
+  IDDefBLOB(&imageGuideBP, NULL);
   IEAddTimer(1000, ISPoll, NULL);
 …
    /* #6 Send it */
+   imageB.blob = compressedData;
+   imageB.bloblen = compressedBytes;
+   imageB.size = totalBytes;
+   strcpy(imageB.format, ".fits.z");
+   if (!strcmp(filename, "ngc1316o.fits"))
+   {
+   imagePrimaryB.blob = compressedData;
+   imagePrimaryB.bloblen = compressedBytes;
+   imagePrimaryB.size = totalBytes;
+   strcpy(imagePrimaryB.format, ".fits.z");
    /* #7 Set BLOB state to Ok */
+   imageBP.s = IPS_OK;
+   IDSetBLOB (&imageBP, NULL);
+   imagePrimaryBP.s = IPS_OK;
+   IDSetBLOB (&imagePrimaryBP, NULL);
+   }
+   else
+   {
+       imageGuideB.blob = compressedData;
+       imageGuideB.bloblen = compressedBytes;
+       imageGuideB.size = totalBytes;
+       strcpy(imageGuideB.format, ".fits.z");
+       /* #7 Set BLOB state to Ok */
+       imageGuideBP.s = IPS_OK;
+       IDSetBLOB (&imageGuideBP, NULL);
+   }
    /* #8 Set Exposure status to Ok */
 …
         /* Are we done yet? */
         if (ExposeTimeN[0].value == 0)
+        if (ExposeTimeN[0].value <= 0)
+        {
+          ExposeTimeN[0].value = 0;
           /* Let's set the state of OK and report that to the client */
           ExposeTimeNP.s = IPS_OK;
 …
           /* Upload a sample FITS file */
           uploadFile("ngc1316o.fits");
+          uploadFile("x0cj010ct_d0h.fit");
           IDSetNumber(&ExposeTimeNP, NULL);

BAORadio/libindi/libindi/examples/tutorial_two.c

-                      r501
+                      r504
 static INumber eqNR[] = {{"RA" ,"RA  H:M:S" , "%10.6m" ,0. , 24., 0., 0., 0, 0, 0},
                          {"DEC", "Dec D:M:S", "%10.6m", -90., 90., 0., 0., 0, 0, 0}};
 static INumberVectorProperty eqNPR = {  mydev, "EQUATORIAL_EOD_COORD_REQUEST", "Equatorial Request",  MAIN_GROUP , IP_RW, 0, IPS_IDLE,  eqNR, NARRAY(eqNR), "", 0};
+static INumberVectorProperty eqNPR = {  mydev, "EQUATORIAL_EOD_COORD_REQUEST", "Equatorial Request",  MAIN_GROUP , IP_WO, 0, IPS_IDLE,  eqNR, NARRAY(eqNR), "", 0};
 /* Property naming convention. All property names are lower case with a postfix to indicate their type. connectS is a switch,
 …
 ISwitchVectorProperty MovementWESP      = { mydev, "TELESCOPE_MOTION_WE", "West/East", MAIN_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE, MovementWES, NARRAY(MovementWES), "", 0};
+static ISwitch OnCoordSetS[] = {{"TRACK", "Track", ISS_ON, 0, 0}};
+static ISwitchVectorProperty OnCoordSetSP = {mydev, "ON_COORD_SET", "On Set", MAIN_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_OK, OnCoordSetS, NARRAY(OnCoordSetS), "", 0};
 /* Initlization routine */
 static void mountInit()
 …
         IDDefSwitch (&MovementNSSP, NULL);
         IDDefSwitch (&MovementWESP, NULL);
+        IDDefSwitch(&OnCoordSetSP, NULL);
+}
 …
+                }
+        }
+        else if (! strcmp(name, OnCoordSetSP.name))
+        {
+            OnCoordSetSP.s = IPS_OK;
+            IDSetSwitch(&OnCoordSetSP, NULL);
+        }

BAORadio/libindi/libindi/indiapi.h

r501	r504
75	75
76	76	/* INDI Library version */
77		#define INDI_LIBV 0.7
	77	#define INDI_LIBV 0.8
78	78
79	79	/*******************************************************************************

BAORadio/libindi/libindi/indidriver.c

-                      r501
+                      r504
 void IUFillBLOB(IBLOB *bp, const char *name, const char * label, const char *format)
+{
+    memset(bp, 0, sizeof(IBLOB));
     strncpy(bp->name, name, MAXINDINAME);
     strncpy(bp->label, label, MAXINDILABEL);
 …
   strncpy(svp->label, label, MAXINDILABEL);
   strncpy(svp->group, group, MAXINDIGROUP);
-  strcpy(svp->timestamp, "");
   svp->p        = p;
 …
 void IUFillBLOBVector(IBLOBVectorProperty *bvp, IBLOB *bp, int nbp, const char * dev, const char *name, const char *label, const char* group, IPerm p, double timeout, IPState s)
+{
+    memset(bvp, 0, sizeof(IBLOBVectorProperty));
     strncpy(bvp->device, dev, MAXINDIDEVICE);
     strncpy(bvp->name, name, MAXINDINAME);
 …
     strcpy(bvp->timestamp, "");
+  bvp->p        = p;
+  bvp->timeout  = timeout;
+  bvp->s        = s;
+  bvp->bp       = bp;
+  bvp->nbp      = nbp;
+    bvp->p      = p;
+    bvp->timeout        = timeout;
+    bvp->s      = s;
+    bvp->bp     = bp;
+    bvp->nbp    = nbp;
+}

BAORadio/libindi/libindi/indiserver.c

-                      r501
+                      r504
     char dev[MAXINDIDEVICE];
     char name[MAXINDINAME];
+    BLOBHandling blob;                  /* when to snoop BLOBs */
 } Property;
+/* record of each snooped property */
+/* record of each snooped property
 typedef struct {
     Property prop;
+    BLOBHandling blob;                  /* when to snoop BLOBs */
+} Snoopee;
+    BLOBHandling blob;
+} Property;
+*/
 struct
 …
     char dev[MAXINDIDEVICE];            /* device served by this driver */
     int active;                         /* 1 when this record is in use */
     Snoopee *sprops;                    /* malloced array of props we snoop */
+    Property *sprops;                   /* malloced array of props we snoop */
     int nsprops;                        /* n entries in sprops[] */
     int pid;                            /* process id or REMOTEDVR if remote */
 …
     Msg *mp, XMLEle *root);
 static void addSDevice (DvrInfo *dp, const char *dev, const char *name);
 static Snoopee *findSDevice (DvrInfo *dp, const char *dev, const char *name);
 static void addClDevice (ClInfo *cp, const char *dev, const char *name);
+static Property *findSDevice (DvrInfo *dp, const char *dev, const char *name);
+static void addClDevice (ClInfo *cp, const char *dev, const char *name, int isblob);
 static int findClDevice (ClInfo *cp, const char *dev, const char *name);
 static int readFromDriver (DvrInfo *dp);
 …
 static int sendClientMsg (ClInfo *cp);
 static int sendDriverMsg (DvrInfo *cp);
+static void crackBLOB (char *enableBLOB, BLOBHandling *bp);
+static void crackBLOB (const char *enableBLOB, BLOBHandling *bp);
+static void crackBLOBHandling(const char *dev, const char *name, const char *enableBLOB, ClInfo *cp);
 static void traceMsg (XMLEle *root);
 static char *indi_tstamp (char *s);
 …
         dp->lp = newLilXML();
         dp->msgq = newFQ(1);
         dp->sprops = (Snoopee*) malloc (1);     /* seed for realloc */
+        dp->sprops = (Property*) malloc (1);    /* seed for realloc */
         dp->nsprops = 0;
         dp->nsent = 0;
 …
         dp->lp = newLilXML();
         dp->msgq = newFQ(1);
         dp->sprops = (Snoopee*) malloc (1);     /* seed for realloc */
+        dp->sprops = (Property*) malloc (1);    /* seed for realloc */
         dp->nsprops = 0;
         dp->nsent = 0;
 …
     static char *envDev=NULL, *envConfig=NULL;
     const char *delm = " ";
     char *token, *cp;
+    char *token, *cp, *tp;
     DvrInfo *dp = NULL;
     int startCmd=0;
 …
     while ( fgets (line, MAXRBUF, fifo.fs) != NULL)
+    {
+        //fprintf(stderr, "FIFO: %s\n", line);
+        fprintf(stderr, "FIFO: %s\n", line);
         tDev[0] = '\0', tDriver[0] = '\0', tConfig[0] = '\0', envDev[0] = '\0', envConfig[0] = '\0';
         cp = strdup(line);
 …
         if (!strcmp(token, "start") || !strcmp(token, "stop"))
+        {
+            //fprintf(stderr, "TOKEN: %s\n", token);
                 if (!strcmp(token, "start"))
                     startCmd = 1;
 …
                strncpy(tDriver, token, MAXRBUF);
+               if (tp = strchr(tDriver, '\n'))
+                   *tp = '\0';
                if (verbose)
 …
                      strcat(tDev, " ");
                      strncat(tDev, token, MAXRBUF);
                      if (strstr(token, "\"") || strstr(token, "'"))
+                     if ( (tp=strchr(tDev, '\"')) || (tp=strchr(tDev, '\'')))
+                     {
+                         tDev[strlen(tDev)-1] = '\0';
+                         //tDev[strlen(tDev)-1] = '\0';
+                         *tp='\0';
                          break;
+                     }
 …
+                 }
                  else
+                {
                      strncpy(tDev, token, MAXRBUF);
+                     if (tp = strchr(tDev, '\n'))
+                         *tp = '\0';
+                 }
                   /* Find config, if there is any */
 …
                           strncat(tConfig, token, MAXRBUF);
                           if (strstr(token, "\"") || strstr(token, "'"))
+                          if ( (tp=strchr(tConfig, '\"')) || (tp=strchr(tConfig, '\'')))
+                          {
+                                 tConfig[strlen(tConfig)-1] = '\0';
+                                 break;
+                                 //tConfig[strlen(tConfig)-1] = '\0';
+                              *tp = '\0';
+                              break;
+                          }
+                       }
+                      }
                        else
+                      {
                            strncpy(tConfig, token, MAXRBUF);
+                           if (tp = strchr(tConfig, '\n'))
+                               *tp = '\0';
+                       }
+                  }
+              }
 …
+               {
                  snprintf(envDev, MAXRBUF, "INDIDEV=%s", tDev);
+                 //fprintf(stderr, "With name: %s\n", envDev);
+                 if (verbose)
+                    fprintf(stderr, "With name: %s\n", envDev);
                  putenv(envDev);
 …
+               {
                    snprintf(envConfig, MAXRBUF, "INDICONFIG=%s", tConfig);
+                   //fprintf(stderr, "With config: %s\n", envConfig);
+                   if (verbose)
+                    fprintf(stderr, "With config: %s\n", envConfig);
                    putenv(envConfig);
+               }
 …
                  */
                 if (dev[0])
                     addClDevice (cp, dev, name);
+                    addClDevice (cp, dev, name, isblob);
                 else if (!strcmp (roottag, "getProperties") && !cp->nprops)
                     cp->allprops = 1;
 …
                 /* snag enableBLOB -- send to remote drivers too */
                 if (!strcmp (roottag, "enableBLOB"))
+                    crackBLOB (pcdataXMLEle(root), &cp->blob);
+                   // crackBLOB (pcdataXMLEle(root), &cp->blob);
+                     crackBLOBHandling (dev, name, pcdataXMLEle(root), cp);
                 /* build a new message -- set content iff anyone cares */
 …
                 /* that's all if driver is just registering a BLOB mode */
                 if (!strcmp (roottag, "enableBLOB")) {
                     Snoopee *sp = findSDevice (dp, dev, name);
+                    Property *sp = findSDevice (dp, dev, name);
                     if (sp)
                         crackBLOB (pcdataXMLEle (root), &sp->blob);
 …
                 /* send to interested clients */
                 if (q2Clients (NULL, isblob, dev, name, mp, root) < 0)
+                if (q2Clients (NULL, isblob, dev, name, mp, root) < 0)
                     shutany++;
 …
         for (dp = dvrinfo; dp < &dvrinfo[ndvrinfo]; dp++) {
             int isremote = (dp->pid == REMOTEDVR);
+            if (dp->active == 0)
+                continue;
             if (dev[0] && dp->dev[0] && strcmp (dev, dp->dev))
                 continue;       /* driver known to not support this dev */
 …
         for (dp = dvrinfo; dp < &dvrinfo[ndvrinfo]; dp++) {
             Snoopee *sp = findSDevice (dp, dev, name);
+            Property *sp = findSDevice (dp, dev, name);
             /* nothing for dp if not snooping for dev/name or wrong BLOB mode */
 …
 addSDevice (DvrInfo *dp, const char *dev, const char *name)
+{
         Snoopee *sp;
+        Property *sp;
         char *ip;
 …
         /* add dev to sdevs list */
         dp->sprops = (Snoopee*) realloc (dp->sprops,
                                             (dp->nsprops+1)*sizeof(Snoopee));
+        dp->sprops = (Property*) realloc (dp->sprops,
+                                            (dp->nsprops+1)*sizeof(Property));
         sp = &dp->sprops[dp->nsprops++];
         ip = sp->prop.dev;
+        ip = sp->dev;
         strncpy (ip, dev, MAXINDIDEVICE-1);
         ip[MAXINDIDEVICE-1] = '\0';
         ip = sp->prop.name;
+        ip = sp->name;
         strncpy (ip, name, MAXINDINAME-1);
         ip[MAXINDINAME-1] = '\0';
 …
+}
 /* return Snoopee if dp is snooping dev/name, else NULL.
  */
 static Snoopee *
+/* return Property if dp is snooping dev/name, else NULL.
+ */
+static Property *
 findSDevice (DvrInfo *dp, const char *dev, const char *name)
+{
 …
         for (i = 0; i < dp->nsprops; i++) {
+            Snoopee *sp = &dp->sprops[i];
+            Property *pp = &sp->prop;
+            if (!strcmp (pp->dev, dev) &&
+                    (!pp->name[0] || !strcmp(pp->name, name)))
+            Property *sp = &dp->sprops[i];
+            if (!strcmp (sp->dev, dev) &&
+                    (!sp->name[0] || !strcmp(sp->name, name)))
                 return (sp);
+        }
 …
         return (NULL);
+}
 /* put Msg mp on queue of each client interested in dev/name, except notme.
 …
         int shutany = 0;
         ClInfo *cp;
         int ql;
+        int ql,i=0;
         /* queue message to each interested client */
 …
             if (!cp->active || cp == notme)
                 continue;
             if (findClDevice (cp, dev, name) < 0)
+            if (findClDevice (cp, dev, name) < 0)
                 continue;
+            if ((isblob && cp->blob==B_NEVER) || (!isblob && cp->blob==B_ONLY))
+                continue;
+            //if ((isblob && cp->blob==B_NEVER) || (!isblob && cp->blob==B_ONLY))
+            if (!isblob && cp->blob==B_ONLY)
+                continue;
+            if (isblob)
+            {
+                if (cp->nprops > 0)
+                {
+                Property *pp = NULL;
+                int blob_found=0;
+                for (i = 0; i < cp->nprops; i++)
+                {
+                    pp = &cp->props[i];
+                    if (!strcmp (pp->dev, dev) && (!strcmp(pp->name, name)))
+                    {
+                        blob_found = 1;
+                        break;
+                    }
+                }
+                if ( (blob_found && pp->blob == B_NEVER) || (blob_found==0 && cp->blob == B_NEVER) )
+                    continue;
+               }
+               else if (cp->blob == B_NEVER)
+                   continue;
+           }
             /* shut down this client if its q is already too large */
 …
         int i;
         if (cp->allprops || !dev[0])
+        if (cp->allprops || !dev[0])
             return (0);
+        for (i = 0; i < cp->nprops; i++) {
+            Property *pp = &cp->props[i];
+            if (!strcmp (pp->dev, dev) &&
                                     (!pp->name[0] || !strcmp(pp->name, name)))
+        for (i = 0; i < cp->nprops; i++)
+        {
+            Property *pp = &cp->props[i];
+            if (!strcmp (pp->dev, dev) && (!pp->name[0] || !strcmp(pp->name, name)))
                 return (0);
+        }
 …
  */
 static void
 addClDevice (ClInfo *cp, const char *dev, const char *name)
+addClDevice (ClInfo *cp, const char *dev, const char *name, int isblob)
+{
         Property *pp;
         char *ip;
+        int i=0;
+        if (isblob)
+        {
+            for (i = 0; i < cp->nprops; i++)
+            {
+                Property *pp = &cp->props[i];
+                if (!strcmp (pp->dev, dev) && (!pp->name[0] || !strcmp(pp->name, name)))
+                    return;
+            }
+        }
         /* no dups */
         if (!findClDevice (cp, dev, name))
+        else if (!findClDevice (cp, dev, name))
             return;
         /* add */
         cp->props = (Property *) realloc (cp->props,
                                             (cp->nprops+1)*sizeof(Property));
+                                            (cp->nprops+1)*sizeof(Property));
         pp = &cp->props[cp->nprops++];
         ip = pp->dev;
+        /*ip = pp->dev;
         strncpy (ip, dev, MAXINDIDEVICE-1);
         ip[MAXINDIDEVICE-1] = '\0';
 …
         ip = pp->name;
         strncpy (ip, name, MAXINDINAME-1);
+        ip[MAXINDINAME-1] = '\0';
+        ip[MAXINDINAME-1] = '\0';*/
+        strncpy (pp->dev, dev, MAXINDIDEVICE);
+        strncpy (pp->name, name, MAXINDINAME);
+        pp->blob = B_NEVER;
+}
 …
  */
 static void
 crackBLOB (char *enableBLOB, BLOBHandling *bp)
+crackBLOB (const char *enableBLOB, BLOBHandling *bp)
+{
         if (!strcmp (enableBLOB, "Also"))
 …
         else if (!strcmp (enableBLOB, "Never"))
             *bp = B_NEVER;
+}
+/* Update the client property BLOB handling policy */
+static void crackBLOBHandling(const char *dev, const char *name, const char *enableBLOB, ClInfo *cp)
+{
+    int i=0;
+    /* If we have EnableBLOB with property name, we add it to Client device list */
+    if (name[0])
+        addClDevice (cp, dev, name, 1);
+    else
+    /* Otherwise, we set the whole client blob handling to what's passed (enableBLOB) */
+        crackBLOB(enableBLOB, &cp->blob);
+    /* If whole client blob handling policy was updated, we need to pass that also to all children
+       and if the request was for a specific property, then we apply the policy to it */
+    for (i = 0; i < cp->nprops; i++)
+    {
+        Property *pp = &cp->props[i];
+        if (!name[0])
+            crackBLOB(enableBLOB, &pp->blob);
+        else if (!strcmp (pp->dev, dev) && (!strcmp(pp->name, name)))
+        {
+            crackBLOB(enableBLOB, &pp->blob);
+            return;
+        }
+    }
+}

BAORadio/libindi/libindi/libs/indibase/baseclient.cpp

-                      r502
+                      r504
     cServer = "localhost";
     cPort   = 7624;
+    svrwfp = NULL;
+    sConnected = false;
+}
 …
 INDI::BaseClient::~BaseClient()
+{
+    disconnect();
+    close(sockfd);
+}
 …
+}
 bool INDI::BaseClient::connect()
+bool INDI::BaseClient::connectServer()
+{
     struct sockaddr_in serv_addr;
 …
     /* prepare for line-oriented i/o with client */
     svrwfp = fdopen (sockfd, "w");
-    svrrfp = fdopen (sockfd, "r");
     int result = pthread_create( &listen_thread, NULL, &INDI::BaseClient::listenHelper, this);
 …
+    }
+    serverConnected();
+    sConnected = true;
     return true;
+}
+void INDI::BaseClient::disconnect()
+{
+    char errmsg[MAXRBUF];
+    removeDevice(NULL, errmsg);
+    if (lillp)
+        delLilXML(lillp);
+    lillp = NULL;
+    pthread_cancel(listen_thread);
+    close(sockfd);
+    if (svrwfp)
+bool INDI::BaseClient::disconnectServer()
+{
+    if (sConnected == false)
+        return true;
+    if (svrwfp != NULL)
         fclose(svrwfp);
+    svrwfp = NULL;
+    if (svrrfp)
+        fclose(svrrfp);
+    svrrfp = NULL;
+}
+INDI::BaseDriver * INDI::BaseClient::getDevice(const char * deviceName)
+{
+    vector<INDI::BaseDriver *>::const_iterator devi;
+   svrwfp = NULL;
+   close(sockfd);
+    serverDisconnected();
+    sConnected = false;
+    return true;
+}
+void INDI::BaseClient::setDriverConnection(bool status, const char *deviceName)
+{
+    INDI::BaseDriver *drv = getDriver(deviceName);
+    ISwitchVectorProperty *drv_connection = NULL;
+    if (drv == NULL)
+    {
+        IDLog("INDI::BaseClient: Error. Unable to find driver %s\n", deviceName);
+        return;
+    }
+    drv_connection = drv->getSwitch("CONNECTION");
+    if (drv_connection == NULL)
+        return;
+    // If we need to connect
+    if (status)
+    {
+        // If there is no need to do anything, i.e. already connected.
+        if (drv_connection->sp[0].s == ISS_ON)
+            return;
+        IUResetSwitch(drv_connection);
+        drv_connection->s = IPS_BUSY;
+        drv_connection->sp[0].s = ISS_ON;
+        drv_connection->sp[1].s = ISS_OFF;
+        sendNewSwitch(drv_connection, &(drv_connection->sp[0]));
+    }
+    else
+    {
+        // If there is no need to do anything, i.e. already disconnected.
+        if (drv_connection->sp[1].s == ISS_ON)
+            return;
+        IUResetSwitch(drv_connection);
+        drv_connection->s = IPS_BUSY;
+        drv_connection->sp[0].s = ISS_OFF;
+        drv_connection->sp[1].s = ISS_ON;
+        sendNewSwitch(drv_connection, &(drv_connection->sp[1]));
+    }
+}
+INDI::BaseDriver * INDI::BaseClient::getDriver(const char * deviceName)
+{
+    vector<devicePtr>::const_iterator devi;
     for ( devi = cDevices.begin(); devi != cDevices.end(); devi++)
         if (!strcmp(deviceName, (*devi)->deviceName()))
             return (*devi);
+            return (*devi).get();
     return NULL;
 …
     /* read from server, exit if find all requested properties */
     while (1)
+    {
         n = fread(buffer, 1, MAXINDIBUF, svrrfp);
+    while (sConnected)
+    {
+        n = read(sockfd, buffer, MAXINDIBUF);
         if (n ==0)
+        {
+            if (ferror(svrrfp))
+                perror ("read");
+            else
+                fprintf (stderr,"INDI server %s/%d disconnected\n", cServer.c_str(), cPort);
+            perror ("read");
+            fprintf (stderr,"INDI server %s/%d disconnected\n", cServer.c_str(), cPort);
             serverDisconnected();
             return;
 …
+        }
+    }
+}
 …
 int INDI::BaseClient::removeDevice( const char * devName, char * errmsg )
+{
     std::vector<INDI::BaseDriver *>::iterator devicei = cDevices.begin();
+    std::vector<devicePtr>::iterator devicei = cDevices.begin();
     while (devicei != cDevices.end())
+    {
       if (devName == NULL || !strcmp(devName, (*devicei)->deviceName()))
+      if (strcmp(devName, (*devicei)->deviceName()))
+      {
           cDevices.erase(devicei);
           delete (*devicei);
+          //delete (*devicei);
           return 0;
+      }
 …
+{
     std::vector<INDI::BaseDriver *>::const_iterator devicei;
+    std::vector<devicePtr>::const_iterator devicei;
     for (devicei = cDevices.begin(); devicei != cDevices.end(); devicei++)
+    {
         if (!strcmp(devName, (*devicei)->deviceName()))
          return (*devicei);
+         return (*devicei).get();
+    }
 …
 INDI::BaseDriver * INDI::BaseClient::addDevice (XMLEle *dep, char * errmsg)
+{
     INDI::BaseDriver *dp;
+    devicePtr dp(new INDI::BaseDriver());
     XMLAtt *ap;
     char * device_name;
 …
     device_name = valuXMLAtt(ap);
-    dp = new INDI::BaseDriver();
     dp->setMediator(this);
     dp->setDeviceName(device_name);
 …
     cDevices.push_back(dp);
     newDevice();
+    newDevice(device_name);
     /* ok */
     return dp;
+    return dp.get();
+}
 …
 void INDI::BaseClient::setBLOBMode(BLOBHandling blobH, const char *dev, const char *prop)
+{
+    char blobOpenTag[64];
+    if (dev)
+    {
+        if (prop)
+            snprintf(blobOpenTag, 64, "<enableBLOB device='%s' name='%s'>", dev, prop);
+        else
+            snprintf(blobOpenTag, 64, "<enableBLOB device='%s'>", dev);
+    }
+    else
+        snprintf(blobOpenTag, 64, "<enableBLOB>", dev, prop);
+    char blobOpenTag[MAXRBUF];
+    if (!dev[0])
+        return;
+   if (prop != NULL)
+           snprintf(blobOpenTag, MAXRBUF, "<enableBLOB device='%s' name='%s'>", dev, prop);
+   else
+          snprintf(blobOpenTag, MAXRBUF, "<enableBLOB device='%s'>", dev);
     switch (blobH)

BAORadio/libindi/libindi/libs/indibase/baseclient.h

-                      r502
+                      r504
 #include <vector>
 #include <map>
+#include <boost/shared_ptr.hpp>
 #include <string>
 …
 public:
     enum { INDI_DEVICE_NOT_FOUND=-1, INDI_PROPERTY_INVALID=-2, INDI_PROPERTY_DUPLICATED = -3, INDI_DISPATCH_ERROR=-4 };
+    typedef boost::shared_ptr<INDI::BaseDriver> devicePtr;
     BaseClient();
     virtual ~BaseClient();
+    ~BaseClient();
     /** \brief Set the server host name and port
 …
         \note This function blocks until connection is either successull or unsuccessful.
     */
     bool connect();
+    bool connectServer();
     /** \brief Disconnect from INDI server.
         Disconnects from INDI servers. Any devices previously created will be deleted and memory cleared.
+        \return True if disconnection is successful, false otherwise.
     */
     void disconnect();
+    bool disconnectServer();
+    /** \brief Connect/Disconnect to INDI driver
+        \param status If true, the client will attempt to turn on CONNECTION property within the driver (i.e. turn on the device).
+         Otherwise, CONNECTION will be turned off.
+        \param deviceName Name of the device to connect to.
+    */
+    void setDriverConnection(bool status, const char *deviceName);
     /** \param deviceName Name of device to search for in the list of devices owned by INDI server,
          \returns If \e deviceName exists, it returns an instance of the device. Otherwise, it returns NULL.
     */
     INDI::BaseDriver * getDevice(const char * deviceName);
+    INDI::BaseDriver * getDriver(const char * deviceName);
     /** \returns Returns a vector of all devices created in the client.
     */
     const vector<INDI::BaseDriver *> & getDevices() const { return cDevices; }
+    const vector<devicePtr> & getDrivers() const { return cDevices; }
     /** \brief Set Binary Large Object policy mode
 …
       If \e dev and \e prop are supplied, then the BLOB handling policy is set for this particular device and property.
       if \e prop is NULL, then the BLOB policy applies to the whole device.
+      if \e dev is NULL, then the BLOB policy applies to all devices owned by INDI server.
       \param blobH BLOB handling policy
       \param dev name of device
       \param prop name of property
+      \param dev name of device, required.
+      \param prop name of property, optional.
     */
     void setBLOBMode(BLOBHandling blobH, const char *dev = NULL, const char *prop = NULL);
+    void setBLOBMode(BLOBHandling blobH, const char *dev, const char *prop = NULL);
     // Update
 …
     pthread_t listen_thread;
     vector<INDI::BaseDriver *> cDevices;
+    vector<devicePtr> cDevices;
     vector<string> cDeviceNames;
     string cServer;
     unsigned int cPort;
+    bool sConnected;
     // Parse & FILE buffers for IO
 …
     LilXML *lillp;                      /* XML parser context */
     FILE *svrwfp;                       /* FILE * to talk to server */
-    FILE *svrrfp;                       /* FILE * to read from server */
 };

BAORadio/libindi/libindi/libs/indibase/basedriver.cpp

-                      r502
+                      r504
     mediator = NULL;
     lp = newLilXML();
+    if (getenv("INDIDEV") != NULL)
+    {
+        strncpy(deviceID, getenv("INDIDEV"), MAXINDINAME);
+        putenv("INDIDEV=");
+    }
+}
 …
 INDI::BaseDriver::~BaseDriver()
+{
-    std::vector<INumberVectorProperty *>::const_iterator numi;
-    std::vector<ISwitchVectorProperty *>::const_iterator switchi;
-    std::vector<ITextVectorProperty *>::const_iterator texti;
-    std::vector<ILightVectorProperty *>::const_iterator lighti;
-    std::vector<IBLOBVectorProperty *>::const_iterator blobi;
     delLilXML (lp);
-    pAll.clear();
-    for ( numi = pNumbers.begin(); numi != pNumbers.end(); numi++)
-        delete (*numi);
-   for ( switchi = pSwitches.begin(); switchi != pSwitches.end(); switchi++)
-        delete (*switchi);
-   for ( texti = pTexts.begin(); texti != pTexts.end(); texti++)
-        delete (*texti);
-   for ( lighti = pLights.begin(); lighti != pLights.end(); lighti++)
-        delete (*lighti);
-   for ( blobi = pBlobs.begin(); blobi != pBlobs.end(); blobi++)
-        delete (*blobi);
+}
 INumberVectorProperty * INDI::BaseDriver::getNumber(const char *name)
+{
+    std::vector<INumberVectorProperty *>::const_iterator numi;
+    for ( numi = pNumbers.begin(); numi != pNumbers.end(); numi++)
+        if (!strcmp(name, (*numi)->name))
+            return *numi;
+    return NULL;
+    INumberVectorProperty * nvp = NULL;
+    nvp = static_cast<INumberVectorProperty *> (getProperty(name, INDI_NUMBER));
+    return nvp;
+}
 ITextVectorProperty * INDI::BaseDriver::getText(const char *name)
+{
+    std::vector<ITextVectorProperty *>::const_iterator texti;
+    for ( texti = pTexts.begin(); texti != pTexts.end(); texti++)
+        if (!strcmp(name, (*texti)->name))
+            return *texti;
+    return NULL;
+    ITextVectorProperty * tvp = NULL;
+    tvp = static_cast<ITextVectorProperty *> (getProperty(name, INDI_TEXT));
+    return tvp;
+}
 ISwitchVectorProperty * INDI::BaseDriver::getSwitch(const char *name)
+{
+    std::vector<ISwitchVectorProperty *>::const_iterator switchi;
+    for ( switchi = pSwitches.begin(); switchi != pSwitches.end(); switchi++)
+        if (!strcmp(name, (*switchi)->name))
+            return *switchi;
+    return NULL;
+    ISwitchVectorProperty * svp = NULL;
+    svp = static_cast<ISwitchVectorProperty *> (getProperty(name, INDI_SWITCH));
+    return svp;
+}
 ILightVectorProperty * INDI::BaseDriver::getLight(const char *name)
+{
+    std::vector<ILightVectorProperty *>::const_iterator lighti;
+    for ( lighti = pLights.begin(); lighti != pLights.end(); lighti++)
+        if (!strcmp(name, (*lighti)->name))
+            return *lighti;
+    return NULL;
+    ILightVectorProperty * lvp = NULL;
+    lvp = static_cast<ILightVectorProperty *> (getProperty(name, INDI_LIGHT));
+    return lvp;
+}
 IBLOBVectorProperty * INDI::BaseDriver::getBLOB(const char *name)
+{
+    std::vector<IBLOBVectorProperty *>::const_iterator blobi;
+    for ( blobi = pBlobs.begin(); blobi != pBlobs.end(); blobi++)
+        if (!strcmp(name, (*blobi)->name))
+            return *blobi;
+    return NULL;
+}
+void * INDI::BaseDriver::getProperty(const char *name, INDI_TYPE & type)
+{
+    std::vector<pOrder>::const_iterator orderi;
+{
+  IBLOBVectorProperty * bvp = NULL;
+  bvp = static_cast<IBLOBVectorProperty *> (getProperty(name, INDI_BLOB));
+  return bvp;
+}
+void * INDI::BaseDriver::getProperty(const char *name, INDI_TYPE type)
+{
+    std::map< boost::shared_ptr<void>, INDI_TYPE>::iterator orderi;
     INumberVectorProperty *nvp;
 …
     ILightVectorProperty *lvp;
     IBLOBVectorProperty *bvp;
+    int i=0;
+    for (i=0, orderi = pAll.begin(); orderi != pAll.end(); orderi++, i++)
+    {
+        switch ( (*orderi).type)
+    for (orderi = pAll.begin(); orderi != pAll.end(); orderi++)
+    {
+        if (type != INDI_UNKNOWN &&  orderi->second != type)
+            continue;
+        switch (orderi->second)
+        {
         case INDI_NUMBER:
             nvp = static_cast<INumberVectorProperty *>((*orderi).p);
+            nvp = static_cast<INumberVectorProperty *>((orderi->first).get());
             if (!strcmp(name, nvp->name))
+            {
+                type = INDI_NUMBER;
+                return (*orderi).p;
+            }
+                return (orderi->first).get();
              break;
         case INDI_TEXT:
              tvp = static_cast<ITextVectorProperty *>((*orderi).p);
+             tvp = static_cast<ITextVectorProperty *>((orderi->first).get());
              if (!strcmp(name, tvp->name))
+             {
+                 type = INDI_TEXT;
+                 return (*orderi).p;
+             }
+                return (orderi->first).get();
              break;
         case INDI_SWITCH:
              svp = static_cast<ISwitchVectorProperty *>((*orderi).p);
+             svp = static_cast<ISwitchVectorProperty *>((orderi->first).get());
              if (!strcmp(name, svp->name))
+             {
+                 type = INDI_SWITCH;
+                 return (*orderi).p;
+             }
+                 return (orderi->first).get();
              break;
         case INDI_LIGHT:
              lvp = static_cast<ILightVectorProperty *>((*orderi).p);
+             lvp = static_cast<ILightVectorProperty *>((orderi->first).get());
              if (!strcmp(name, lvp->name))
+             {
+                 type = INDI_LIGHT;
+                 return (*orderi).p;
+             }
+                 return (orderi->first).get();
              break;
         case INDI_BLOB:
              bvp = static_cast<IBLOBVectorProperty *>((*orderi).p);
+             bvp = static_cast<IBLOBVectorProperty *>((orderi->first).get());
              if (!strcmp(name, bvp->name))
+             {
+                 type = INDI_BLOB;
+                 return (*orderi).p;
+             }
+                 return (orderi->first).get();
              break;
+        }
+    }
 …
 int INDI::BaseDriver::removeProperty(const char *name)
+{
     std::vector<pOrder>::iterator orderi;
+    std::map< boost::shared_ptr<void>, INDI_TYPE>::iterator orderi;
     INumberVectorProperty *nvp;
 …
     for (orderi = pAll.begin(); orderi != pAll.end(); orderi++)
+    {
         switch ( (*orderi).type)
+        switch (orderi->second)
+        {
         case INDI_NUMBER:
             nvp = static_cast<INumberVectorProperty *>((*orderi).p);
+            nvp = static_cast<INumberVectorProperty *>((orderi->first).get());
             if (!strcmp(name, nvp->name))
+            {
                  pAll.erase(orderi);
-                 delete (nvp);
                  return 0;
+             }
              break;
         case INDI_TEXT:
              tvp = static_cast<ITextVectorProperty *>((*orderi).p);
+             tvp = static_cast<ITextVectorProperty *>((orderi->first).get());
              if (!strcmp(name, tvp->name))
+             {
                   pAll.erase(orderi);
-                  delete (tvp);
                   return 0;
+              }
              break;
         case INDI_SWITCH:
              svp = static_cast<ISwitchVectorProperty *>((*orderi).p);
+             svp = static_cast<ISwitchVectorProperty *>((orderi->first).get());
              if (!strcmp(name, svp->name))
+             {
                   pAll.erase(orderi);
-                  delete (svp);
                   return 0;
+              }
              break;
         case INDI_LIGHT:
              lvp = static_cast<ILightVectorProperty *>((*orderi).p);
+             lvp = static_cast<ILightVectorProperty *>((orderi->first).get());
              if (!strcmp(name, lvp->name))
+             {
                   pAll.erase(orderi);
-                  delete (lvp);
                   return 0;
+              }
              break;
         case INDI_BLOB:
              bvp = static_cast<IBLOBVectorProperty *>((*orderi).p);
+             bvp = static_cast<IBLOBVectorProperty *>((orderi->first).get());
              if (!strcmp(name, bvp->name))
+             {
                   pAll.erase(orderi);
-                  delete (bvp);
                   return 0;
+              }
 …
             buildProp(root, errmsg);
     /**************************************************************************/
+}
 …
     XMLEle *ep = NULL;
     char *rtag, *rname, *rdev;
     INDI_TYPE type;
+    //INDI_TYPE type;
     double timeout=0;
 …
         return -1;
     if (!deviceID[0])
+   /* if (!deviceID[0])
+    {
         if (getenv("INDIDEV"))
 …
         else
             strncpy(deviceID, rdev, MAXINDINAME);
+    }
+    if (getProperty(rname, type) != NULL)
+    }*/
+    if (!deviceID[0])
+        strncpy(deviceID, rdev, MAXINDINAME);
+    //if (getProperty(rname, type) != NULL)
+    if (getProperty(rname) != NULL)
         return INDI::BaseClient::INDI_PROPERTY_DUPLICATED;
     if (crackIPerm(findXMLAttValu(root, "perm"), &perm) < 0)
+    {
         IDLog("Error extracting %s permission (%s)", rname, findXMLAttValu(root, "perm"));
+    if (strcmp (rtag, "defLightVector") && crackIPerm(findXMLAttValu(root, "perm"), &perm) < 0)
+    {
+        IDLog("Error extracting %s permission (%s)\n", rname, findXMLAttValu(root, "perm"));
         return -1;
+    }
 …
     if (crackIPState (findXMLAttValu(root, "state"), &state) < 0)
+    {
         IDLog("Error extracting %s state (%s)", rname, findXMLAttValu(root, "state"));
+        IDLog("Error extracting %s state (%s)\n", rname, findXMLAttValu(root, "state"));
         return -1;
+    }
 …
+    {
+        INumberVectorProperty *nvp = new INumberVectorProperty;
+        numberPtr nvp(new INumberVectorProperty);
+        //INumberVectorProperty *nvp = new INumberVectorProperty;
+        //INumberVectorProperty *nvp = (INumberVectorProperty *) malloc(sizeof(INumberVectorProperty));
         INumber *np = NULL;
         int n=0;
 …
             np = (INumber *) realloc(np, (n+1) * sizeof(INumber));
             np[n].nvp = nvp;
+            np[n].nvp = nvp.get();
             XMLAtt *na = findXMLAtt (ep, "name");
 …
         nvp->nnp = n;
         nvp->np  = np;
+        pNumbers.push_back(nvp);
+        pOrder o = { INDI_NUMBER, nvp };
+        pAll.push_back(o);
+        IDLog("Adding number property %s to list.\n", nvp->name);
+        //orderPtr o(new pOrder);
+        //o->p = &nvp;
+        //o->type = INDI_NUMBER;
+        //pAll.push_back(o);
+        pAll[nvp] = INDI_NUMBER;
+        //IDLog("Adding number property %s to list.\n", nvp->name);
+        if (mediator)
+            mediator->newProperty(nvp->device, nvp->name);
+    }
     else
 …
   else if (!strcmp (rtag, "defSwitchVector"))
+        {
+            ISwitchVectorProperty *svp = new ISwitchVectorProperty;
+            switchPtr svp(new ISwitchVectorProperty);
+            //ISwitchVectorProperty *svp = new ISwitchVectorProperty;
+            //ISwitchVectorProperty *svp = (ISwitchVectorProperty *) malloc(sizeof(ISwitchVectorProperty));
             ISwitch *sp = NULL;
             int n=0;
 …
                 sp = (ISwitch *) realloc(sp, (n+1) * sizeof(ISwitch));
                 sp[n].svp = svp;
+                sp[n].svp = svp.get();
                 XMLAtt *na = findXMLAtt (ep, "name");
 …
             svp->nsp = n;
             svp->sp  = sp;
+            pSwitches.push_back(svp);
+            pOrder o = { INDI_SWITCH, svp };
+            pAll.push_back(o);
+            IDLog("Adding Switch property %s to list.\n", svp->name);
+            //orderPtr o(new pOrder);
+            //o->p = &svp;
+            //o->type = INDI_SWITCH;
+            //pAll.push_back(o);
+            pAll[svp] = INDI_SWITCH;
+            //IDLog("Adding Switch property %s to list.\n", svp->name);
+            if (mediator)
+                mediator->newProperty(svp->device, svp->name);
+        }
         else
 …
+    {
+        ITextVectorProperty *tvp = new ITextVectorProperty;
+        //ITextVectorProperty *tvp = new ITextVectorProperty;
+        //ITextVectorProperty *tvp = (ITextVectorProperty *) malloc(sizeof(ITextVectorProperty));
+        textPtr tvp(new ITextVectorProperty);
         IText *tp = NULL;
         int n=0;
 …
             tp = (IText *) realloc(tp, (n+1) * sizeof(IText));
             tp[n].tvp = tvp;
+            tp[n].tvp = tvp.get();
             XMLAtt *na = findXMLAtt (ep, "name");
 …
         tvp->ntp = n;
         tvp->tp  = tp;
+        pTexts.push_back(tvp);
+        pOrder o = { INDI_TEXT, tvp };
+        pAll.push_back(o);
+        IDLog("Adding Text property %s to list.\n", tvp->name);
+        //orderPtr o(new pOrder);
+        //o->p = &tvp;
+        //o->type = INDI_TEXT;
+        //pAll.push_back(o);
+        pAll[tvp] = INDI_TEXT;
+        //IDLog("Adding Text property %s to list.\n", tvp->name);
+        if (mediator)
+            mediator->newProperty(tvp->device, tvp->name);
+    }
     else
 …
+    {
+        ILightVectorProperty *lvp = new ILightVectorProperty;
+        //ILightVectorProperty *lvp = new ILightVectorProperty;
+        //ILightVectorProperty *lvp = (ILightVectorProperty *) malloc(sizeof(ILightVectorProperty));
+        lightPtr lvp(new ILightVectorProperty);
         ILight *lp = NULL;
         int n=0;
 …
             lp = (ILight *) realloc(lp, (n+1) * sizeof(ILight));
             lp[n].lvp = lvp;
+            lp[n].lvp = lvp.get();
             XMLAtt *na = findXMLAtt (ep, "name");
 …
         lvp->nlp = n;
         lvp->lp  = lp;
+        pLights.push_back(lvp);
+        pOrder o = { INDI_LIGHT, lvp };
+        pAll.push_back(o);
+        IDLog("Adding Light property %s to list.\n", lvp->name);
+        //orderPtr o(new pOrder);
+        //o->p = &lvp;
+        //o->type = INDI_LIGHT;
+        //pAll.push_back(o);
+        pAll[lvp] = INDI_LIGHT;
+        //IDLog("Adding Light property %s to list.\n", lvp->name);
+        if (mediator)
+            mediator->newProperty(lvp->device, lvp->name);
+    }
     else
 …
+    {
+        IBLOBVectorProperty *bvp = new IBLOBVectorProperty;
+        //IBLOBVectorProperty *bvp = new IBLOBVectorProperty;
+        //IBLOBVectorProperty *bvp = (IBLOBVectorProperty *) malloc(sizeof(IBLOBVectorProperty));
+        blobPtr bvp(new IBLOBVectorProperty);
         IBLOB *bp = NULL;
         int n=0;
 …
             bp = (IBLOB *) realloc(bp, (n+1) * sizeof(IBLOB));
             bp[n].bvp = bvp;
+            bp[n].bvp = bvp.get();
             XMLAtt *na = findXMLAtt (ep, "name");
 …
         bvp->nbp = n;
         bvp->bp  = bp;
+        pBlobs.push_back(bvp);
+        pOrder o = { INDI_BLOB, bvp };
+        pAll.push_back(o);
+        IDLog("Adding BLOB property %s to list.\n", bvp->name);
+        //orderPtr o(new pOrder);
+        //o->p = &bvp;
+        //o->type = INDI_BLOB;
+        //pAll.push_back(o);
+        pAll[bvp] = INDI_BLOB;
+        //IDLog("Adding BLOB property %s to list.\n", bvp->name);
+        if (mediator)
+            mediator->newProperty(bvp->device, bvp->name);
+    }
     else
 …
         return false;
+}
-void INDI::BaseDriver::setConnected(bool status)
+{
-    ISwitch *sp = NULL;
-    ISwitchVectorProperty *svp = getSwitch("CONNECTION");
-    if (!svp)
-        return;
-    IUResetSwitch(svp);
-    // Connect
-    if (status)
+    {
-        sp = IUFindSwitch(svp, "CONNECT");
-        if (!sp)
-            return;
-        sp->s = ISS_ON;
+    }
-    // Disconnect
-    else
+    {
-        sp = IUFindSwitch(svp, "DISCONNECT");
-        if (!sp)
-            return;
-        sp->s = ISS_ON;
+    }
-    svp->s = IPS_OK;
+}
 …
+}
+void INDI::BaseDriver::registerProperty(void *p, INDI_TYPE type)
+{
+    if (type == INDI_NUMBER)
+    {
+        INumberVectorProperty *nvp = static_cast<INumberVectorProperty *> (p);
+        if (getProperty(nvp->name, INDI_NUMBER) != NULL)
+            return;
+        numberPtr ovp(nvp);
+        pAll[ovp] = INDI_NUMBER;
+    }
+    else if (type == INDI_TEXT)
+    {
+       ITextVectorProperty *tvp = static_cast<ITextVectorProperty *> (p);
+       if (getProperty(tvp->name, INDI_TEXT) != NULL)
+           return;
+       textPtr ovp(tvp);
+       //o->p = &ovp;
+       pAll[ovp] = INDI_TEXT;
+   }
+    else if (type == INDI_SWITCH)
+    {
+       ISwitchVectorProperty *svp = static_cast<ISwitchVectorProperty *> (p);
+       if (getProperty(svp->name, INDI_SWITCH) != NULL)
+           return;
+       switchPtr ovp(svp);
+       //o->p = &ovp;
+       IDLog("Registering switch %s\n", svp->name);
+       pAll[ovp] = INDI_SWITCH;
+    }
+    else if (type == INDI_LIGHT)
+    {
+       ILightVectorProperty *lvp = static_cast<ILightVectorProperty *> (p);
+       if (getProperty(lvp->name, INDI_LIGHT) != NULL)
+           return;
+       lightPtr ovp(lvp);
+       //o->p = &ovp;
+       pAll[ovp] = INDI_LIGHT;
+   }
+    else if (type == INDI_BLOB)
+    {
+       IBLOBVectorProperty *bvp = static_cast<IBLOBVectorProperty *> (p);
+       if (getProperty(bvp->name, INDI_BLOB) != NULL)
+           return;
+       blobPtr ovp(bvp);
+       //o->p = &ovp;
+       pAll[ovp] = INDI_BLOB;
+    }
+}

BAORadio/libindi/libindi/libs/indibase/basedriver.h

-                      r502
+                      r504
 #define INDIBASEDRIVER_H
 #include <vector>
+#include <boost/shared_ptr.hpp>
 #include <map>
 #include <string>
 …
 public:
     BaseDriver();
     virtual ~BaseDriver();
+    ~BaseDriver();
     /*! INDI error codes. */
 …
     /*! INDI property type */
     enum INDI_TYPE
+    typedef enum
+    {
         INDI_NUMBER, /*!< INumberVectorProperty. */
 …
         INDI_TEXT,   /*!< ITextVectorProperty. */
         INDI_LIGHT,  /*!< ILightVectorProperty. */
+        INDI_BLOB    /*!< IBLOBVectorProperty. */
+    };
+        INDI_BLOB,    /*!< IBLOBVectorProperty. */
+        INDI_UNKNOWN
+    } INDI_TYPE;
     /** \return Return vector number property given its name */
 …
     /** \return Return vector BLOB property given its name */
     IBLOBVectorProperty * getBLOB(const char *name);
+    void registerProperty(void *p, INDI_TYPE type);
     /** \brief Remove a property
 …
     */
     void * getProperty(const char *name, INDI_TYPE & type);
+    void * getProperty(const char *name, INDI_TYPE type = INDI_UNKNOWN);
     /** \brief Build driver properties from a skeleton file.
 …
     /** \return True if the device is connected (CONNECT=ON), False otherwise */
     bool isConnected();
+    /** \brief Connect or Disconnect a device.
+      \param status If true, the driver will attempt to connect to the device (CONNECT=ON). If false, it will attempt
+to disconnect the device.
+    */
+    virtual void setConnected(bool status);
     /** \brief Set the device name
 …
       */
     void setDeviceName(const char *dev);
     /** \return Returns the device name */
     const char *deviceName();
 …
     */
     void addMessage(const char *msg);
+    //** \returns Returns the contents of the driver's message queue. *;
+    /** \return Returns the contents of the driver's message queue. */
     const char *message() { return messageQueue.c_str(); }
     /** \brief Set the driver's mediator to receive notification of news devices and updated property values. */
     void setMediator(INDI::BaseMediator *med) { mediator = med; }
     /** \returns Get the meditator assigned to this driver */
     INDI::BaseMediator * getMediator() { return mediator; }
 protected:
 …
       \param root XML element to parse and build.
       \param errmsg buffer to store error message in parsing fails.
       \return 0 if parsing is successful, -1 otherwise and errmsg is set */
     int buildProp(XMLEle *root, char *errmsg);
 …
     char deviceID[MAXINDINAME];
+    typedef boost::shared_ptr<INumberVectorProperty> numberPtr;
+    typedef boost::shared_ptr<ITextVectorProperty> textPtr;
+    typedef boost::shared_ptr<ISwitchVectorProperty> switchPtr;
+    typedef boost::shared_ptr<ILightVectorProperty> lightPtr;
+    typedef boost::shared_ptr<IBLOBVectorProperty> blobPtr;
 private:
+    typedef struct
+    {
+        INDI_TYPE type;
+        void *p;
+    } pOrder;
+    std::vector<INumberVectorProperty *> pNumbers;
+    std::vector<ITextVectorProperty *> pTexts;
+    std::vector<ISwitchVectorProperty *> pSwitches;
+    std::vector<ILightVectorProperty *> pLights;
+    std::vector<IBLOBVectorProperty *> pBlobs;
+    std::map< boost::shared_ptr<void>, INDI_TYPE> pAll;
     LilXML *lp;
-    std::vector<pOrder> pAll;
     std::string messageQueue;

BAORadio/libindi/libindi/libs/indibase/defaultdriver.cpp

-                      r502
+                      r504
 #include "base64.h"
+void timerfunc(void *t)
+{
+    //fprintf(stderr,"Got a timer hit with %x\n",t);
+    INDI::DefaultDriver *devPtr = static_cast<INDI::DefaultDriver *> (t);
+    if (devPtr != NULL)
+    {
+        //  this was for my device
+        //  but we dont have a way of telling
+        //  WHICH timer was hit :(
+        devPtr->TimerHit();
+    }
+    return;
+}
 INDI::DefaultDriver::DefaultDriver()
 …
     pDebug = false;
     pSimulation = false;
+    //switchPtr conSw(new ISwitchVectorProperty);
+    ConnectionSP = new ISwitchVectorProperty;
+    IUFillSwitch(&ConnectionS[0],"CONNECT","Connect",ISS_OFF);
+    IUFillSwitch(&ConnectionS[1],"DISCONNECT","Disconnect",ISS_ON);
+    IUFillSwitchVector(ConnectionSP,ConnectionS,2,deviceName(),"CONNECTION","Connection","Main Control",IP_RW,ISR_1OFMANY,60,IPS_IDLE);
+    registerProperty(ConnectionSP, INDI_SWITCH);
+}
 …
 bool INDI::DefaultDriver::saveConfig()
+{
+    std::vector<pOrder>::const_iterator orderi;
+    //std::vector<orderPtr>::iterator orderi;
+    std::map< boost::shared_ptr<void>, INDI_TYPE>::iterator orderi;
     ISwitchVectorProperty *svp=NULL;
+    INumberVectorProperty *nvp=NULL;
+    ITextVectorProperty   *tvp=NULL;
+    IBLOBVectorProperty   *bvp=NULL;
     char errmsg[MAXRBUF];
     FILE *fp = NULL;
 …
     for (orderi = pAll.begin(); orderi != pAll.end(); orderi++)
+    {
+        switch ( (*orderi).type)
+        switch (orderi->second)
+        {
         case INDI_NUMBER:
+             IUSaveConfigNumber(fp, static_cast<INumberVectorProperty *> ((*orderi).p));
+             nvp = static_cast<INumberVectorProperty *>((orderi->first).get());
+             IDLog("Trying to save config for number %s\n", nvp->name);
+             IUSaveConfigNumber(fp, nvp);
              break;
         case INDI_TEXT:
+             IUSaveConfigText(fp, static_cast<ITextVectorProperty *> ((*orderi).p));
+             tvp = static_cast<ITextVectorProperty *>((orderi->first).get());
+             IUSaveConfigText(fp, tvp);
              break;
         case INDI_SWITCH:
              svp = static_cast<ISwitchVectorProperty *> ((*orderi).p);
+             svp = static_cast<ISwitchVectorProperty *>((orderi->first).get());
              /* Never save CONNECTION property. Don't save switches with no switches on if the rule is one of many */
              if (!strcmp(svp->name, "CONNECTION") || (svp->r == ISR_1OFMANY && !IUFindOnSwitch(svp)))
 …
              break;
         case INDI_BLOB:
+             IUSaveConfigBLOB(fp, static_cast<IBLOBVectorProperty *> ((*orderi).p));
+             bvp = static_cast<IBLOBVectorProperty *>((orderi->first).get());
+             IUSaveConfigBLOB(fp, bvp);
              break;
+        }
 …
     if (!svp)
         return false;
+     if(!strcmp(svp->name,ConnectionSP->name))
+     {
+        bool rc;
+      for (int i=0; i < n; i++)
+      {
+        if ( !strcmp(names[i], "CONNECT") && (states[i] == ISS_ON))
+        {
+            // If not connected, attempt to connect
+            if (isConnected() == false)
+            {
+                rc = Connect();
+                // If connection is successful, set it thus
+                if (rc)
+                  setConnected(true);
+                else
+                  setConnected(false, IPS_ALERT);
+                updateProperties();
+            }
+            else
+                // Just tell client we're connected yes
+                setConnected(true);
+        }
+        else if ( !strcmp(names[i], "DISCONNECT") && (states[i] == ISS_ON))
+        {
+            // If connected, then true to disconnect.
+            if (isConnected() == true)
+                rc = Disconnect();
+            else
+                rc = true;
+            if (rc)
+                setConnected(false, IPS_IDLE);
+            else
+                setConnected(true, IPS_ALERT);
+            updateProperties();
+        }
+    }
+        return true;
+    }
     if (!strcmp(svp->name, "DEBUG"))
 …
+}
 void INDI::DefaultDriver::addAuxControls()
+void INDI::DefaultDriver::addDebugControl()
+{
     /**************************************************************************/
 …
     if (!DebugSP)
+    {
+        DebugSP = new ISwitchVectorProperty;
+        switchPtr debSw(new ISwitchVectorProperty);
+        DebugSP = debSw.get();
         IUFillSwitch(&DebugS[0], "ENABLE", "Enable", ISS_OFF);
         IUFillSwitch(&DebugS[1], "DISABLE", "Disable", ISS_ON);
         IUFillSwitchVector(DebugSP, DebugS, NARRAY(DebugS), deviceID, "DEBUG", "Debug", "Options", IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
+        pSwitches.push_back(DebugSP);
+        pOrder debo = {INDI_SWITCH, DebugSP};
+        pAll.push_back(debo);
+        pAll[debSw] = INDI_SWITCH;
+    }
     else
 …
     /**************************************************************************/
+}
+void INDI::DefaultDriver::addSimulationControl()
+{
     /**************************************************************************/
     SimulationSP = getSwitch("SIMULATION");
     if (!SimulationSP)
+    {
+        SimulationSP = new ISwitchVectorProperty;
+        switchPtr simSw(new ISwitchVectorProperty);
+        SimulationSP = simSw.get();
         IUFillSwitch(&SimulationS[0], "ENABLE", "Enable", ISS_OFF);
         IUFillSwitch(&SimulationS[1], "DISABLE", "Disable", ISS_ON);
         IUFillSwitchVector(SimulationSP, SimulationS, NARRAY(SimulationS), deviceID, "SIMULATION", "Simulation", "Options", IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
+        pSwitches.push_back(SimulationSP);
+        pOrder simo = {INDI_SWITCH, SimulationSP};
+        pAll.push_back(simo);
+        pAll[simSw] = INDI_SWITCH;
+    }
     else
 …
                 pSimulation = true;
+    }
+}
+void INDI::DefaultDriver::addConfigurationControl()
+{
     /**************************************************************************/
     ConfigProcessSP = getSwitch("CONFIG_PROCESS");
     if (!ConfigProcessSP)
+    {
+        ConfigProcessSP = new ISwitchVectorProperty;
+        switchPtr configSw(new ISwitchVectorProperty);
+        ConfigProcessSP = configSw.get();
         IUFillSwitch(&ConfigProcessS[0], "CONFIG_LOAD", "Load", ISS_OFF);
         IUFillSwitch(&ConfigProcessS[1], "CONFIG_SAVE", "Save", ISS_OFF);
         IUFillSwitch(&ConfigProcessS[2], "CONFIG_DEFAULT", "Default", ISS_OFF);
         IUFillSwitchVector(ConfigProcessSP, ConfigProcessS, NARRAY(ConfigProcessS), deviceID, "CONFIG_PROCESS", "Configuration", "Options", IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
+        pSwitches.push_back(ConfigProcessSP);
+        pOrder cpono = {INDI_SWITCH, ConfigProcessSP};
+        pAll.push_back(cpono);
+        pAll[configSw] = INDI_SWITCH;
+    }
     /**************************************************************************/
 …
+}
+void INDI::DefaultDriver::addAuxControls()
+{
+   addDebugControl();
+   addSimulationControl();
+   addConfigurationControl();
+}
 void INDI::DefaultDriver::setDebug(bool enable)
+{
+    if (!DebugSP)
+        return;
     if (pDebug == enable)
+    {
 …
         return;
+    }
-    if (!DebugSP)
-        return;
     IUResetSwitch(DebugSP);
 …
 void INDI::DefaultDriver::setSimulation(bool enable)
+{
+    if (!SimulationSP)
+        return;
    if (pSimulation == enable)
+   {
 …
        return;
+   }
-   if (!SimulationSP)
-       return;
    IUResetSwitch(SimulationSP);
 …
 void INDI::DefaultDriver::ISGetProperties (const char *dev)
+{
+    std::vector<pOrder>::const_iterator orderi;
+    std::map< boost::shared_ptr<void>, INDI_TYPE>::iterator orderi;
+    static int isInit = 0;
+    //fprintf(stderr,"Enter ISGetProperties '%s'\n",dev);
+    if(isInit == 0)
+    {
+        if(dev != NULL)
+             setDeviceName(dev);
+        else
+        {
+            char *envDev = getenv("INDIDEV");
+            if (envDev != NULL)
+                setDeviceName(envDev);
+            else
+               setDeviceName(getDefaultName());
+        }
+        strncpy(ConnectionSP->device, deviceName(), MAXINDIDEVICE);
+        initProperties();
+        addConfigurationControl();
+        isInit = 1;
+    }
     for (orderi = pAll.begin(); orderi != pAll.end(); orderi++)
+    {
         switch ( (*orderi).type)
+        switch (orderi->second)
+        {
         case INDI_NUMBER:
              IDDefNumber(static_cast<INumberVectorProperty *>((*orderi).p) , NULL);
+             IDDefNumber(static_cast<INumberVectorProperty *>((orderi->first).get()) , NULL);
              break;
         case INDI_TEXT:
              IDDefText(static_cast<ITextVectorProperty *>((*orderi).p) , NULL);
+             IDDefText(static_cast<ITextVectorProperty *>((orderi->first).get()) , NULL);
              break;
         case INDI_SWITCH:
              IDDefSwitch(static_cast<ISwitchVectorProperty *>((*orderi).p) , NULL);
+             IDDefSwitch(static_cast<ISwitchVectorProperty *>((orderi->first).get()) , NULL);
              break;
         case INDI_LIGHT:
              IDDefLight(static_cast<ILightVectorProperty *>((*orderi).p) , NULL);
+             IDDefLight(static_cast<ILightVectorProperty *>((orderi->first).get()) , NULL);
              break;
         case INDI_BLOB:
              IDDefBLOB(static_cast<IBLOBVectorProperty *>((*orderi).p) , NULL);
+             IDDefBLOB(static_cast<IBLOBVectorProperty *>((orderi->first).get()) , NULL);
              break;
+        }
+    }
+}
 void INDI::DefaultDriver::resetProperties()
+{
     std::vector<INumberVectorProperty *>::const_iterator numi;
     std::vector<ISwitchVectorProperty *>::const_iterator switchi;
     std::vector<ITextVectorProperty *>::const_iterator texti;
     std::vector<ILightVectorProperty *>::const_iterator lighti;
     std::vector<IBLOBVectorProperty *>::const_iterator blobi;
+    /*std::vector<numberPtr>::const_iterator numi;
+    std::vector<switchPtr>::const_iterator switchi;
+    std::vector<textPtr>::const_iterator texti;
+    std::vector<lightPtr>::const_iterator lighti;
+    std::vector<blobPtr>::const_iterator blobi;
     for ( numi = pNumbers.begin(); numi != pNumbers.end(); numi++)
+    {
         (*numi)->s = IPS_IDLE;
         IDSetNumber( (*numi), NULL);
+        IDSetNumber( (*numi).get(), NULL);
+    }
 …
+   {
        (*switchi)->s = IPS_IDLE;
        IDSetSwitch( (*switchi), NULL);
+       IDSetSwitch( (*switchi).get(), NULL);
+   }
 …
+   {
       (*texti)->s = IPS_IDLE;
       IDSetText( (*texti), NULL);
+      IDSetText( (*texti).get(), NULL);
+   }
 …
+   {
        (*lighti)->s = IPS_IDLE;
        IDSetLight( (*lighti), NULL);
+       IDSetLight( (*lighti).get(), NULL);
+   }
 …
+   {
        (*blobi)->s = IPS_IDLE;
+       IDSetBLOB( (*blobi), NULL);
+   }
+}
+       IDSetBLOB( (*blobi).get(), NULL);
+   }*/
+}
+void INDI::DefaultDriver::setConnected(bool status, IPState state, const char *msg)
+{
+    ISwitch *sp = NULL;
+    ISwitchVectorProperty *svp = getSwitch("CONNECTION");
+    if (!svp)
+        return;
+    IUResetSwitch(svp);
+    // Connect
+    if (status)
+    {
+        sp = IUFindSwitch(svp, "CONNECT");
+        if (!sp)
+            return;
+        sp->s = ISS_ON;
+    }
+    // Disconnect
+    else
+    {
+        sp = IUFindSwitch(svp, "DISCONNECT");
+        if (!sp)
+            return;
+        sp->s = ISS_ON;
+    }
+    svp->s = state;
+    IDSetSwitch(svp, msg, NULL);
+}
+//  This is a helper function
+//  that just encapsulates the Indi way into our clean c++ way of doing things
+int INDI::DefaultDriver::SetTimer(int t)
+{
+    return IEAddTimer(t,timerfunc,this);
+}
+//  Just another helper to help encapsulate indi into a clean class
+void INDI::DefaultDriver::RemoveTimer(int t)
+{
+    IERmTimer(t);
+    return;
+}
+//  This is just a placeholder
+//  This function should be overriden by child classes if they use timers
+//  So we should never get here
+void INDI::DefaultDriver::TimerHit()
+{
+    return;
+}
+bool INDI::DefaultDriver::updateProperties()
+{
+    //  The base device has no properties to update
+    return true;
+}
+bool INDI::DefaultDriver::initProperties()
+{
+   return true;
+}
+bool INDI::DefaultDriver::deleteProperty(const char *propertyName)
+{
+    removeProperty(propertyName);
+    IDDelete(deviceName(), propertyName ,NULL);
+    return true;
+}
+void INDI::DefaultDriver::defineNumber(INumberVectorProperty *nvp)
+{
+    registerProperty(nvp, INDI_NUMBER);
+    IDDefNumber(nvp, NULL);
+}
+void INDI::DefaultDriver::defineText(ITextVectorProperty *tvp)
+{
+    registerProperty(tvp, INDI_TEXT);
+    IDDefText(tvp, NULL);
+}
+void INDI::DefaultDriver::defineSwitch(ISwitchVectorProperty *svp)
+{
+    registerProperty(svp, INDI_SWITCH);
+    IDDefSwitch(svp, NULL);
+}
+void INDI::DefaultDriver::defineLight(ILightVectorProperty *lvp)
+{
+    registerProperty(lvp, INDI_LIGHT);
+    IDDefLight(lvp, NULL);
+}
+void INDI::DefaultDriver::defineBLOB(IBLOBVectorProperty *bvp)
+{
+    registerProperty(bvp, INDI_BLOB);
+    IDDefBLOB(bvp, NULL);
+}

BAORadio/libindi/libindi/libs/indibase/defaultdriver.h

-                      r502
+                      r504
     void addAuxControls();
+    /** \brief Add Debug control to the driver */
+    void addDebugControl();
+    /** \brief Add Simulation control to the driver */
+    void addSimulationControl();
+    /** \brief Add Configuration control to the driver */
+    void addConfigurationControl();
     /** \brief Set all properties to IDLE state */
     void resetProperties();
+    /** \brief Define number vector to client & register it. Alternatively, IDDefNumber can be used but the property will not
+               get registered and the driver will not be able to save configuration files.
+         \param nvp The number vector property to be defined
+    */
+    void defineNumber(INumberVectorProperty *nvp);
+    /** \brief Define text vector to client & register it. Alternatively, IDDefText can be used but the property will not
+               get registered and the driver will not be able to save configuration files.
+         \param tvp The text vector property to be defined
+    */
+    void defineText(ITextVectorProperty *tvp);
+    /** \brief Define switch vector to client & register it. Alternatively, IDDefswitch can be used but the property will not
+               get registered and the driver will not be able to save configuration files.
+         \param svp The switch vector property to be defined
+    */
+    void defineSwitch(ISwitchVectorProperty *svp);
+    /** \brief Define light vector to client & register it. Alternatively, IDDeflight can be used but the property will not
+               get registered and the driver will not be able to save configuration files.
+         \param lvp The light vector property to be defined
+    */
+    void defineLight(ILightVectorProperty *lvp);
+    /** \brief Define BLOB vector to client & register it. Alternatively, IDDefBLOB can be used but the property will not
+               get registered and the driver will not be able to save configuration files.
+         \param bvp The BLOB vector property to be defined
+    */
+    void defineBLOB(IBLOBVectorProperty *bvp);
+    /** \brief Delete a property and unregister it. It will also be deleted from all clients.
+        \param propertyName name of property to be deleted.
+    */
+    virtual bool deleteProperty(const char *propertyName);
+    /** \brief Connect or Disconnect a device.
+      \param status If true, the driver will attempt to connect to the device (CONNECT=ON). If false, it will attempt
+to disconnect the device.
+      \param msg A message to be sent along with connect/disconnect command.
+    */
+    virtual void setConnected(bool status, IPState state=IPS_OK, const char *msg = NULL);
+    int SetTimer(int);
+    void RemoveTimer(int);
+    virtual void TimerHit();
 protected:
 …
     /** \return True if Simulation is on, False otherwise. */
     bool isSimulation();
+    //  These are the properties we define, that are generic to pretty much all devices
+    //  They are public to make them available to all dervied classes and thier children
+    ISwitchVectorProperty *ConnectionSP;
+    ISwitch ConnectionS[2];
+    /** \brief Initilize properties initial state and value. The child class must implement this function.
+        \return True if initilization is successful, false otherwise.
+    */
+    virtual bool initProperties();
+    /** \brief updateProperties is called whenever there is a change in the CONNECTION status of the driver.
+        This will enable the driver to react to changes of switching ON/OFF a device. For example, a driver
+        may only define a set of properties after a device is connected, but not before.
+        \return True if update is successful, false otherwise.
+    */
+    virtual bool updateProperties();
+    /** \brief Connect to a device. Child classes must implement this function and perform the connection
+        routine in the function.
+        \return True if connection to device is successful, false otherwise.
+    */
+    virtual bool Connect()=0;
+    /** \brief Disconnect from a device. Child classes must implement this function and perform the disconnection
+        routine in the function.
+        \return True if disconnection from a device is successful, false otherwise.
+    */
+    virtual bool Disconnect()=0;
+    /** \return Default name of the device. */
+    virtual const char *getDefaultName()=0;
 private:

BAORadio/libindi/libindi/libs/indibase/indibase.h

-                      r502
+                      r504
     class BaseDriver;
     class DefaultDriver;
+    class CCD;
+    class Telescope;
+    class FilterWheel;
+    class Focuser;
+    class USBDevice;
+}
 …
 /**
  * \class INDI::BaseMediator
    \brief Meditates event notification as generated by devices and passed to clients.
+   \brief Meditates event notification as generated by driver and passed to clients.
 */
 class INDI::BaseMediator
 …
     /** \brief Emmited when a new device is created from INDI server.
+        \param device_name Name of the new device
     */
+    virtual void newDevice()  =0;
+    virtual void newDevice(const char *device_name)  =0;
+    /** \brief Emmited when a new property is created for an INDI driver.
+        \param device_name Name of the device
+        \param property_name Name of the new property
+    */
+    virtual void newProperty(const char *device_name, const char *property_name)  =0;
     /** \brief Emmited when a new BLOB value arrives from INDI server.
 …
     virtual void newLight(ILightVectorProperty *lvp) =0;
+    /** \brief Emmited when the server is connected.
+    */
+    virtual void serverConnected() =0;
     /** \brief Emmited when the server gets disconnected.
     */

BAORadio/libindi/libindi/libs/indicom.c

-                      r501
+                      r504
 #include <sys/param.h>
 //#include <config.h>
+#include <config.h>
 #ifdef HAVE_NOVA_H
 …
 int tty_timeout(int fd, int timeout)
+{
+ if (fd == -1)
+        return TTY_ERRNO;
   struct timeval tv;
   fd_set readout;
 …
 int tty_write(int fd, const char * buf, int nbytes, int *nbytes_written)
+{
+    if (fd == -1)
+           return TTY_ERRNO;
   int bytes_w = 0;
   *nbytes_written = 0;
 …
 int tty_write_string(int fd, const char * buf, int *nbytes_written)
+{
+    if (fd == -1)
+           return TTY_ERRNO;
   unsigned int nbytes;
   int bytes_w = 0;
 …
 int tty_read(int fd, char *buf, int nbytes, int timeout, int *nbytes_read)
+{
+    if (fd == -1)
+           return TTY_ERRNO;
  int bytesRead = 0;
 …
 int tty_read_section(int fd, char *buf, char stop_char, int timeout, int *nbytes_read)
+{
+    if (fd == -1)
+           return TTY_ERRNO;
  int bytesRead = 0;
 …
                         break;
                 default:
                         if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid bit rate.", bit_rate)  0)
+                        if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid bit rate.", bit_rate) < 0)
                                 perror(NULL);
                         else
 …
                         fprintf( stderr, "Default\n") ;
                         if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid data bit count.", word_size)  0)
+                        if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid data bit count.", word_size) < 0)
                                 perror(NULL);
                         else
 …
                         fprintf( stderr, "Default1\n") ;
                         if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid parity selection value.", parity)  0)
+                        if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid parity selection value.", parity) < 0)
                                 perror(NULL);
                         else
 …
                 default:
                         fprintf( stderr, "Default2\n") ;
                         if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid stop bit count.", stop_bits)  0)
+                        if (snprintf(msg, sizeof(msg), "tty_connect: %d is not a valid stop bit count.", stop_bits) < 0)
                                 perror(NULL);
                         else
 …
+    {
         close(t_fd);
+        *fd = -1;
+    }
 …
 #else
  int t_fd=0;
+ int t_fd=-1;
  char msg[80];
  int bps;
 …
  if ( (t_fd = open(device, O_RDWR | O_NOCTTY )) == -1)
+ {
+     *fd = -1;
     return TTY_PORT_FAILURE;
+ }
     /* Control Modes
 …
 int tty_disconnect(int fd)
+{
+    if (fd == -1)
+           return TTY_ERRNO;
 #ifdef _WIN32
         return TTY_ERRNO;

BAORadio/libindi/libindi/tools/setINDIproperty.c

-                      r490
+                      r504
 static int readServerChar (FILE *fp);
 static void findSet (XMLEle *root, FILE *fp);
+static void scanEV (SetSpec *sp, char e[], char v[]);
+static void scanEV (SetSpec *specp, char ev[]);
+static void scanEEVV (SetSpec *specp, char *ep, char ev[]);
+static void scanEVEV (SetSpec *specp, char ev[]);
 static void sendNew (FILE *fp, INDIDef *dp, SetSpec *sp);
 static void sendSpecs(FILE *wfp);
 …
+{
         fprintf(stderr, "Purpose: set one or more writable INDI properties\n");
+        fprintf(stderr, "%s\n", "$Revision: 1.4 $");
+        fprintf(stderr, "Usage: %s [options] {[type] device.property.e1[;e2...]=v1[;v2...]} ...\n",
+                                                                            me);
+        fprintf(stderr, "%s\n", "$Revision: 1.6 $");
+        fprintf(stderr, "Usage: %s [options] {[type] spec} ...\n", me);
         fprintf(stderr, "Options:\n");
         fprintf(stderr, "  -d f  : use file descriptor f already open to server\n");
 …
         fprintf(stderr, "  -p p  : alternate port, default is %d\n", INDIPORT);
         fprintf(stderr, "  -t t  : max time to wait, default is %d secs\n",TIMEOUT);
         fprintf(stderr, "  -v    : verbose (cumulative)\n");
         fprintf(stderr, "Each property optionally preceded by its type is sent without first confirming\n");
+        fprintf(stderr, "  -v    : verbose (more are cumulative)\n");
+        fprintf(stderr, "Each spec optionally preceded by its type is sent without first confirming\n");
         fprintf(stderr, "its structure. This is much more efficient but there is no error checking.\n");
         fprintf(stderr, "Types are indicated with the following flags:\n");
 …
         fprintf(stderr, "  -n    : Number\n");
         fprintf(stderr, "  -s    : Switch\n");
+        fprintf(stderr, "Spec may be either:\n");
+        fprintf(stderr, "    device.property.e1[;e2...]=v1[;v2...]\n");
+        fprintf(stderr, "  or\n");
+        fprintf(stderr, "    device.property.e1=v1[;e2=v2...]\n");
         fprintf(stderr, "Exit status:\n");
         fprintf(stderr, "  0: all settings successful\n");
 …
 crackSpec (int *acp, char **avp[])
+{
         char d[1024], p[1024], e[2048], v[2048];
+        char d[128], p[128], ev[2048];
         char *spec = *avp[0];
         INDIDef *dp = NULL;
 …
         /* then scan arg for property spec */
         if (sscanf (spec, "%[^.].%[^.].%[^.=]=%s", d, p, e, v) != 4) {
             fprintf (stderr, "Bad property format: %s\n", spec);
+        if (sscanf (spec, "%[^.].%[^.].%s", d, p, ev) != 3) {
+            fprintf (stderr, "Malformed property spec: %s\n", spec);
             usage();
+        }
 …
         sets[nsets].ev = (SetEV *) malloc (1);          /* seed realloc */
         sets[nsets].nev = 0;
         scanEV (&sets[nsets++], e, v);
+        scanEV (&sets[nsets++], ev);
         /* update caller's pointers */
 …
+}
+/* scan e1[;e2...] v1[;v2,...] from e[] and v[] and add to spec sp.
+/* scan ev for element definitions in either of two forms and add to sp:
+ *    e1[;e2...]=v1[;v2...]
+ *  or
+ *    e1=v1[;e2=v2...]
+ * exit if nothing sensible found.
+ */
+static void
+scanEV (SetSpec *specp, char ev[])
+{
+        char *ep, *sp;          /* pointers to = and ; */
+        if (verbose > 1)
+            fprintf (stderr, "Scanning assignments %s\n", ev);
+        ep = strchr (ev, '=');
+        sp = strchr (ev, ';');
+        if (!ep) {
+            fprintf (stderr, "Malformed assignment: %s\n", ev);
+            usage();
+        }
+        if (sp < ep)
+            scanEEVV (specp, ep, ev);   /* including just one E=V */
+        else
+            scanEVEV (specp, ev);
+}
+/* add specs of the form e1[;e2...]=v1[;v2...] to sp.
+ * v is pointer to equal sign.
  * exit if trouble.
+ */
+static void
+scanEV (SetSpec *sp, char e[], char v[])
+ * N.B. e[] and v[] are modified in place.
+ */
+static void
+scanEEVV (SetSpec *sp, char *v, char *e)
+{
         static char sep[] = ";";
+        char *ep, *vp;
+        if (verbose > 1)
+            fprintf (stderr, "Scanning %s = %s\n", e, v);
+        char *ec, *vc;
+        *v++ = '\0';
         while (1) {
             char *e0 = strtok_r (e, sep, &ep);
             char *v0 = strtok_r (v, sep, &vp);
+            char *e0 = strtok_r (e, sep, &ec);
+            char *v0 = strtok_r (v, sep, &vc);
             if (!e0 && !v0)
                 break;
             if (!e0) {
+                fprintf (stderr, "More values than elements for %s.%s\n",
+                                                                sp->d, sp->p);
+                fprintf (stderr, "More values than elements for %s.%s\n", sp->d, sp->p);
                 exit(2);
+            }
             if (!v0) {
+                fprintf (stderr, "More elements than values for %s.%s\n",
+                                                                sp->d, sp->p);
+                fprintf (stderr, "More elements than values for %s.%s\n", sp->d, sp->p);
                 exit(2);
+            }
 …
             sp->ev[sp->nev].e = strcpy (malloc(strlen(e0)+1), e0);
             sp->ev[sp->nev].v = strcpy (malloc(strlen(v0)+1), v0);
+            if (verbose > 1)
+                fprintf (stderr, "Found assignment %s=%s\n", sp->ev[sp->nev].e, sp->ev[sp->nev].v);
             sp->nev++;
 …
             v = NULL;
+        }
+}
+/* add specs of the form e1=v1[;e2=v2...] to sp.
+ * exit if trouble.
+ * N.B. ev[] is modified in place.
+ */
+static void
+scanEVEV (SetSpec *sp, char ev[])
+{
+        char *s, *e;
+        int last = 0;
+        do {
+            s = strchr (ev, ';');
+            if (s)
+                *s++ = '\0';
+            else {
+                s = ev + strlen (ev);
+                last = 1;
+            }
+            e = strchr (ev, '=');
+            if (e)
+                *e++ = '\0';
+            else {
+                fprintf (stderr, "Malformed assignment: %s\n", ev);
+                usage();
+            }
+            sp->ev = (SetEV *) realloc (sp->ev, (sp->nev+1)*sizeof(SetEV));
+            sp->ev[sp->nev].e = strcpy (malloc(strlen(ev)+1), ev);
+            sp->ev[sp->nev].v = strcpy (malloc(strlen(e)+1), e);
+            if (verbose > 1)
+                fprintf (stderr, "Found assignment %s=%s\n", sp->ev[sp->nev].e, sp->ev[sp->nev].v);
+            sp->nev++;
+            ev = s;
+        } while (!last);
+}
 …
 /* For RCS Only -- Do Not Edit */
 static char *rcsid[2] = {(char *)rcsid, "@(#) $RCSfile: setINDI.c,v $ $Date: 2007/10/11 20:12:11 $ $Revision: 1.4 $ $Name:  $"};
+static char *rcsid[2] = {(char *)rcsid, "@(#) $RCSfile: setINDI.c,v $ $Date: 2010/11/07 07:13:59 $ $Revision: 1.6 $ $Name:  $"};

Context Navigation

Legend:

Download in other formats: