Changeset 677 for BAORadio/libindi

Timestamp:

May 21, 2012, 3:25:43 PM (13 years ago)

Author:

frichard

Message:

Sauvegarde de sécurité (problème de DD). Interfae graphique de BAOcontrol en QT

Location:

BAORadio/libindi/libindi

Files:

• BAOTest/BAOtest_main.cpp (modified) (2 diffs)
• Indi_Stellarium/src/ClientSocket.cpp (deleted)
• Indi_Stellarium/src/ClientSocket.h (deleted)
• Indi_Stellarium/src/Connection.cpp (modified) (1 diff)
• Indi_Stellarium/src/Connection.hpp (modified) (1 diff)
• Indi_Stellarium/src/Listener.hpp (modified) (2 diffs)
• Indi_Stellarium/src/Makefile (modified) (2 diffs)
• Indi_Stellarium/src/Server.cpp (modified) (4 diffs)
• Indi_Stellarium/src/Server.hpp (modified) (4 diffs)
• Indi_Stellarium/src/ServerBAO.cpp (modified) (43 diffs)
• Indi_Stellarium/src/ServerBAO.hpp (modified) (5 diffs)
• Indi_Stellarium/src/Socket.cpp (deleted)
• Indi_Stellarium/src/Socket2.hpp (moved) (moved from BAORadio/libindi/libindi/Indi_Stellarium/src/Socket.hpp ) (3 diffs)
• Indi_Stellarium/src/SocketException.h (deleted)
• Indi_Stellarium/src/exception.c (deleted)
• Indi_Stellarium/src/exception.h (deleted)
• Indi_Stellarium/src/filetools.cpp (deleted)
• Indi_Stellarium/src/filetools.h (deleted)
• Indi_Stellarium/src/socket.cpp (deleted)
• Indi_Stellarium/src/socket.h (deleted)
• bao.sh (modified) (3 diffs)
• communs/ClientSocket.cpp (modified) (1 diff)
• communs/alignement.cpp (modified) (39 diffs)
• communs/alignement.h (modified) (5 diffs)
• communs/astro.cpp (modified) (15 diffs)
• communs/astro.h (modified) (5 diffs)
• communs/const.h (modified) (4 diffs)
• drivers/telescope/BAO.cpp (modified) (30 diffs)
• drivers/telescope/BAO.h (modified) (7 diffs)
• result_recherche_bao (modified) (1 diff)

BAORadio/libindi/libindi/BAOTest/BAOtest_main.cpp

@@ -12 +12 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <net/if.h>
+#include <net/if.h> 
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -114 +114 @@
         return atoi(str2.c_str());
     }
-
+  
     return -1;
 }

BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.cpp

@@ -88 +88 @@
 #endif
 
-Connection::Connection(Server &server, SOCKET fd) : Socket(server, fd)
+Connection::Connection(Server2 &server, SOCKET fd) : Socket2(server, fd)
 {
         read_buff_end = read_buff;

BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.hpp

@@ -26 +26 @@
 #define _CONNECTION_HPP_
 
-#include "Socket.hpp"
+#include "Socket2.hpp"
 
 //! TCP/IP connection to a client.
-class Connection : public Socket
+class Connection : public Socket2
 {
 public:
-        Connection(Server &server, SOCKET fd);
+        Connection(Server2 &server, SOCKET fd);
         long long int getServerMinusClientTime(void) const
         {

BAORadio/libindi/libindi/Indi_Stellarium/src/Listener.hpp

@@ -26 +26 @@
 #define _LISTENER_HPP_
 
-#include "Socket.hpp"
+#include "Socket2.hpp"
 
 //! Listens for connection attempts and adds new connections to the server.
@@ -34 +34 @@
 //! attempts. If a TCP/IP connection is established, the listener adds it
 //! to the list of connections maintained by the server.
-class Listener : public Socket
+class Listener : public Socket2
 {
 public:
         //! @param port TCP/IP port number
-        Listener(Server &server, int port) : Socket(server, INVALID_SOCKET),
+        Listener(Server2 &server, int port) : Socket2(server, INVALID_SOCKET),
                                              port(port) {}
         

BAORadio/libindi/libindi/Indi_Stellarium/src/Makefile

@@ -12 +12 @@
 
 
-TelescopeServerBAO_CPP = Connection.cpp Listener.cpp Socket.cpp socket.cpp filetools.cpp exception.c astro.cpp ClientSocket.cpp \
-  Server.cpp ServerBAO.cpp LogFile.cpp MainBAO.cpp
+TelescopeServerBAO_CPP = Connection.cpp Listener.cpp Socket2.cpp Server.cpp  \
+  ServerBAO.cpp LogFile.cpp MainBAO.cpp
 
 TelescopeServerBAO_O = $(TelescopeServerBAO_CPP:.cpp=.o)
@@ -44 +44 @@
 
 TelescopeServerBAO: $(TelescopeServerBAO_O)
-        g++ $(LDFLAGS) $(TelescopeServerBAO_O) -o $@
+        g++ $(LDFLAGS) -c -o ../src/astro.o ../../communs/astro.cpp
+        g++ $(LDFLAGS) -c -o ../src/exception.o ../../communs/exception.cpp
+        g++ $(LDFLAGS) -c -o ../src/filetools.o ../../communs/filetools.cpp
+        g++ $(LDFLAGS) -c -o ../src/Socket.o ../../communs/Socket.cpp
+        g++ $(LDFLAGS) -c -o ../src/ClientSocket.o ../../communs/ClientSocket.cpp
+        g++ $(LDFLAGS) -c -o ../src/logs.o ../../communs/logs.cpp
+        g++ $(LDFLAGS) -c -o ../src/alignement.o ../../communs/alignement.cpp
+        g++ $(LDFLAGS) $(TelescopeServerBAO_O) astro.o exception.o filetools.o Socket.o ClientSocket.o logs.o alignement.o -o $@
 
 

BAORadio/libindi/libindi/Indi_Stellarium/src/Server.cpp

@@ -24 +24 @@
 
 #include "Server.hpp"
-#include "Socket.hpp"
+#include "Socket2.hpp"
 #include "Listener.hpp"
 
-void Server::SocketList::clear(void)
+void Server2::SocketList::clear(void)
 {
         for (const_iterator it(begin()); it != end(); it++)
@@ -33 +33 @@
                 delete (*it);
         }
-        list<Socket*>::clear();
+        list<Socket2*>::clear();
 }
 
-Server::Server(int port)
+Server2::Server2(int port)
 {
-        Socket *listener = new Listener(*this, port);
+        Socket2 *listener = new Listener(*this, port);
         socket_list.push_back(listener);
 }
 
-void Server::sendPosition(unsigned int ra_int, int dec_int, int status)
+void Server2::sendPosition(unsigned int ra_int, int dec_int, int status)
 {
         for (SocketList::const_iterator it(socket_list.begin());
@@ -52 +52 @@
 }
 
-void Server::step(long long int timeout_micros)
+void Server2::step(long long int timeout_micros)
 {
         fd_set read_fds, write_fds;
@@ -93 +93 @@
 }
 
-void Server::closeAcceptedConnections(void)
+void Server2::closeAcceptedConnections(void)
 {
         for (SocketList::iterator it(socket_list.begin());

BAORadio/libindi/libindi/Indi_Stellarium/src/Server.hpp

@@ -29 +29 @@
 using namespace std;
 
-class Socket;
+class Socket2;
 
 //! Base class for telescope server classes. A true telescope server class
@@ -43 +43 @@
 //! Socket::prepareSelectFds() and Socket::handleSelectFds() for each connection
 //! in the list. These methods are reimplemented for each class.
-class Server
+class Server2
 {
 public:
-        Server(void) {}
-        Server(int port);
-        virtual ~Server(void) {}
+        Server2(void) {}
+        Server2(int port);
+        virtual ~Server2(void) {}
         virtual void step(long long int timeout_micros);
         
@@ -58 +58 @@
         //! Connection or any custom class that implements a serial port
         //! connection (such as Lx200Connection and NexStarConnection).
-        void addConnection(Socket *s)
+        void addConnection(Socket2 *s)
         {
                 if (s)
@@ -71 +71 @@
         friend class Connection;
         
-        class SocketList : public list<Socket*>
+        class SocketList : public list<Socket2*>
         {
                 public:

BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.cpp

@@ -24 +24 @@
 
 #include "ServerBAO.hpp"
-#include "Socket.hpp" // GetNow
+#include "Socket2.hpp" // GetNow
 
 #include <math.h>
 
 ServerDummy::ServerDummy(int port)
-            :Server(port)
+            :Server2(port)
 {
         last_pos[0] = current_pos[0] = desired_pos[0] = 1.0;
@@ -37 +37 @@
 
 
-        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 \
-     *           Serveur Stellarium           *\n \
-     * Laboratoire de l'Accélérateur Linéaire *\n \
-     *                                        *\n \
-     *             v0.1  20/08/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);
-
+       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;
+
+    // Affichage de la version du programme
+
+    AfficherLog("\n\n\n\n\n \
+ ******************************************\n \
+ *             BAORadio Control           *\n \
+ * Laboratoire de l'Accélérateur Linéaire *\n \
+ *                                        *\n \
+ *             v0.52 19/04/2012           *\n \
+ *        franckrichard033@gmail.com      *\n \
+ ******************************************\n\n\n", true);
+
+
+    // Initialisation des variables globales et des pointeurs
+    // pour la signification des variables, voir baocontrol.h
+
+
+    delaitransit           = 0;
+    delaitracking          = 0;
+    lognum                 = 0;
+    numAntennes            = 0;
+    numobjets              = 0;
+    numEtoiles             = 0;
+    runnum                 = 1;
+
+    MethodeAlignement      = SIMPLE;
+
+    Pression               = 1013.0;
+    Temperature            = 10.0;
+
+    NoExit                 = true;
+    Transit                = false;
+    run                    = false;
+    exitrun                = false;
+    ModificationAlignement = false;
+
+    fd                     = NULL;
+    client_socket          = NULL;
+
+    // chaînes de caractÚres et tableaux
+
+    LatitudeChar           = "";
+    LongitudeChar          = "";
+    Serveur                = "";
+    Port                   = "";
+
+    Antennes               = new DefAntenne[ MAXANTENNES ];
+    objets                 = new DefObjets [ MAXOBJETS ];
+    Etoiles                = new DefEtoiles[ MAXETOILES] ;
+
+
+    // on initialise aussi les structures
+
+    for (int i=0; i<MAXANTENNES; i++)
+    {
+        Antennes[i].ok = 0;
+        Antennes[i].ip = 0;
+
+        Antennes[i].AlignementAntenne = new Alignement();
+    }
+
+    for (int i=0; i<MAXOBJETS; i++)
+    {
+        objets[i].JJ   = 0.0;
+        objets[i].exec = false;
+    }
+
+    for (int i=0; i<MAXETOILES; i++)
+    {
+        Etoiles[i].nom          = "";
+        Etoiles[i].ad           = 0.0;
+        Etoiles[i].de           = 0.0;
+        Etoiles[i].az           = 0.0;
+        Etoiles[i].ha           = 0.0;
+        Etoiles[i].mag          = 0.0;
+        Etoiles[i].selectionnee = false;
+    }
+
+
+    // Chargement du fichier contenant les paramÚtres de l'application BAOcontrol
+    // La variable permet de récupérer le nom de l'utilisateur ayant ouvert la session sous linux
+    // c'est dans le répertoire /home/USER/ que BAOcontrol cherche le fichier de paramÚtre baocontrol_params
+
+    if (!ChargementParametres("/home/" + (string)getenv("USER") + "/baocontrol_params"))
+    {
+        ErreurLog("Le fichier de configuration 'params' contient des erreurs ou n'existe pas.\n");
+        ErreurLog("Il devrait se trouver dans le répertoire /home/" + (string)getenv("USER") +"\n");
+        ErreurLog("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);
+    // On lance les calculs (Temps sidéral local etc...)
+
+    CalculTSL();
+
+
+    //Chargement du catalogue d'étoiles que l'on utilise pour l'alignement des antennes
+
+  /* if ( !ChargementCatalogueEtoiles("/home/" + (string)getenv("USER") + "/bao_catalogue.dat") )
+    {
+        ErreurLog("Le catalogue d'étoiles 'bao_catalogue' est introuvable.\n");
+        ErreurLog("Il devrait se trouver dans le répertoire /home/" + (string)getenv("USER") +"\n");
+        ErreurLog("Merci de vérifier...\n\n");
+        exit(1);
+    }
+*/
+
+
+    // Ouverture du socket avec indi_BAO
+
+    client_socket = new ClientSocket("localhost", atoi(Port.c_str()) );
+
+    // On se connecte au pilote indi_BAO
+
+   Connect(true);
         // On lance la fenêtre graphique
 
@@ -175 +218 @@
 
         
-        Server::step(timeout_micros);
+        Server2::step(timeout_micros);
 }
 
@@ -449 +492 @@
 {
     string reponse, memreponse, decomp;
-    bool test=false;
+
+    bool test = false;
+
+    // on récupÚre les messages provenant d'indi_BAO
 
     *client_socket >> reponse;
 
-   // printf("%s\n", reponse.c_str());
-
     do
     {
-        if (reponse.find("message")!=string::npos)
+        // s'il contient le mot message (et vient donc d'indi_BAO)
+
+        if (reponse.find("message") != string::npos)
         {
             // On ne garde que la partie intéressante
-            // La partie suivant "message="...
+            // La partie qui suit "message="...
+
             reponse = reponse.substr(reponse.find("message") + 9);
 
+            // (on en garde une trace)
+
             memreponse = reponse;
 
-            // ...jusqu'au "
-            reponse=reponse.substr(0, reponse.find("\""));
+            // ...on extrait le message jusqu'au caractÚre "
+
+            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)
+            // et on met à jour le tableau des états de l'antenne correspondante
+            // Dans les messages d'indi_BAO, l'adresse ip précÚde les mots "Antennes connectées"
+
+            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++)
-                {
-                    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 si nécessaire
+
+                if ( atoi(decomp.c_str()) != 0 ) for (int i=0; i<numAntennes; i++)
                     {
-                        Antennes[i].ok=1;
-                        test=true;
-                        break;
+                        // on a trouvé l'antenne correspondante
+
+                        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
+
+                // ou si c'est une nouvelle antenne, on l'ajoute au tableau Antennes
 
                 if (!test)
                 {
-                    Antennes[numAntenne].ip = atoi(decomp.c_str());
-                    Antennes[numAntenne++].ok = 1;
+                    Antennes[numAntennes].ip = atoi(decomp.c_str());
+
+                    Antennes[numAntennes++].ok = 1;
                 }
             }
 
             // 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))
+            // on trouve les erreurs dans les messages d'indi_BAO formulée
+            // de la façon suivante: "ALERTE antenne" ou bien "Erreur sur l antenne"
+
+            if  ((reponse.find("ALERTE antenne ") != string::npos) ||
+                    (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++)
+                for (int i=0; i<numAntennes; i++)
                 {
+                    // On identifie l'antenne dans le tableau Antennes et on change son état
+
                     if (atoi(decomp.c_str()) == Antennes[i].ip)
                     {
@@ -514 +572 @@
             }
 
-            // On sauvegarde le message dans le tableau logs
+            // On sauvegarde le message dans le fichier logs mais on ne l'affiche pas
 
             stringstream os;
@@ -520 +578 @@
             os << lognum << " : " << reponse;
 
-            Affiche(os.str() + "\n", false);
-
-            if (lognum<MAXLOG-1) logs[lognum++] = os.str();
+            AfficherLog(os.str() + "\n", false);
+
+            if ( lognum < MAXLOG - 1 ) logs[ lognum++ ] = os.str();
 
             reponse = memreponse;
         }
-        else reponse="";
-
-
-    } while ( reponse !="" );
-
-     // on actualise la fenêtre
-
-        Dessiner();
+        else reponse = "";
+
+
+    } while ( reponse != "" );
+
+    // on actualise la fenêtre
+
+    Dessiner();
 
     // on envoie un message pour actualiser la fenêtre graphique
@@ -545 +603 @@
 ***************************************************************************************/
 
-bool ServerDummy::VerifReponse(string reponseattendue)
+bool ServerDummy::VerifReponse(string reponseattendue, string *retourreponse)
 {
     string reponse = "";
@@ -552 +610 @@
     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
+    // LÃ  on lit les messages cinq 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++)
+    if (retourreponse) *retourreponse = "";
+
+    for (int i=0; i<5 ; i++)
     {
         do
@@ -567 +628 @@
             duree++;
         }
-        while (reponse.length() == 0 && duree<10 ); // on attend un message pendant 10 ms max
+        while (reponse.length() == 0 && duree < MAX_DELAI_REPONSE ); // on attend un message pendant 10 ms max
 
         // on ajoute tous les messages reçus dans memmreponse
@@ -581 +642 @@
     }
 
+
     if (!test)
     {
         // réponse inconnue -> une erreur ?
 
-        int pos = memreponse.find("message=");
-
-        if ( pos != (int)string::npos )
+       long  unsigned 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;
+        }
+
+        if (memreponse != "")  ErreurLog("Réponse du pilote indi_BAO :" + memreponse + "\n\n");
+
+        return false;
+    }
+
+    if (retourreponse)
+    {
+        long unsigned int pos = memreponse.find(reponseattendue);
+
+        if ( pos != string::npos )
+        {
+            memreponse = memreponse.substr(pos);
+
+            memreponse = memreponse.substr(0, memreponse.find("\""));
+        }
+
+        *retourreponse = memreponse;
     }
 
@@ -647 +723 @@
 
 
-
-
 /**************************************************************************************
 ** Envoie la longitude et la latitude du lieu d'observation au pilote indi_BAO
+** sous la forme de vecteurs xml
+** (voir les particularités des drivers développés sous Indi)
+**
 ***************************************************************************************/
 
@@ -656 +733 @@
 {
     // la communication avec le pilote indi_BAO
-    // se fait par l'envoie de petit fichier xml
-    // d'où le cÎté complexe des commandes
+    // se fait par l'envoi de trames au format xml
 
     try
@@ -670 +746 @@
         *client_socket << "</newNumberVector>";
 
-        if (!VerifReponse("name=\"GEOGRAPHIC_COORD\" state=\"Ok\""))
-        {
-            Erreur("ERREUR fct EnvoyerCoordGeographiques : pas de réponse du pilote indi_BAO.\n\n");
+        if (!VerifReponse("name=\"GEOGRAPHIC_COORD\" state=\"Ok\"", NULL))
+        {
+            ErreurLog("ERREUR fct EnvoyerCoordGeographiques : pas de réponse du pilote indi_BAO.\n\n");
 
             return false;
@@ -682 +758 @@
     catch ( SocketException& e )
     {
-        Erreur("Exception was caught:" + e.description() + "\n");
-        return false;
-    }
-
-    Affiche("Les coordonnées géographiques ont bien été envoyées au pilote indi_BAO\n\n", true);
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("Les coordonnées géographiques ont bien été envoyées au pilote indi_BAO\n\n", true);
 
     return true;
@@ -692 +769 @@
 
 
+/**************************************************************************************
+** Transmet la pression et la température au pilote indi_BAO
+**
+***************************************************************************************/
+
+bool ServerDummy::EnvoyerPressionTemperature()
+{
+    stringstream os;
+
+    try
+    {
+        *client_socket << "<newNumberVector device=\"BAO\" name=\"PRESSION_DATA\">";
+        *client_socket << "<oneNumber name=\"Pression\">";
+        os << Pression;
+        *client_socket << os.str();
+        os.str("");
+        *client_socket << "</oneNumber>";
+        *client_socket << "<oneNumber name=\"Temperature\">";
+        os << Temperature;
+        *client_socket << os.str();
+        os.str("");
+        *client_socket << "</oneNumber>";
+        *client_socket << "</newNumberVector>";
+
+        if (!VerifReponse("name=\"PRESSION_DATA\" state=\"Ok\"", NULL))
+        {
+            ErreurLog("ERREUR fct EnvoyerPressionTemperature : pas de réponse du pilote indi_BAO.\n\n");
+
+            return false;
+        }
+    }
+
+    // un problÚme ?
+
+    catch ( SocketException& e )
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("La pression et la température ont bien été envoyées au pilote indi_BAO\n\n", true);
+
+    return true;
+}
+
+/**************************************************************************************
+** Envoie les paramÚtres delaitransit et delaitracking au pilote indi_BAO
+** Ces paramÚtres définissent la durée (en sec) entre deux actualisations
+** dans les modes tracking et transit
+**
+***************************************************************************************/
+
+bool ServerDummy::EnvoyerDelaisModesTransitEtTracking()
+{
+    stringstream os;
+
+    try
+    {
+        os << delaitransit;
+        *client_socket << "<newNumberVector device=\"BAO\" name=\"DELAY1\">";
+        *client_socket << "<oneNumber name=\"DELAY\">";
+        *client_socket << os.str();
+        *client_socket << "</oneNumber>";
+        *client_socket << "</newNumberVector>";
+        os.str("");
+
+        if (!VerifReponse("name=\"DELAY1\" state=\"Ok\"", NULL))
+        {
+            ErreurLog("ERREUR fct EnvoyerDelaisModesTransitEtTracking : pas de réponse du pilote indi_BAO.\n\n");
+
+            return false;
+        }
+
+        os << delaitracking;
+        *client_socket << "<newNumberVector device=\"BAO\" name=\"DELAY2\">";
+        *client_socket << "<oneNumber name=\"DELAY\">";
+        *client_socket << os.str();
+        *client_socket << "</oneNumber>";
+        *client_socket << "</newNumberVector>";
+        os.str("");
+
+        if (!VerifReponse("name=\"DELAY2\" state=\"Ok\"", NULL))
+        {
+            ErreurLog("ERREUR fct EnvoyerDelaisModesTransitEtTracking : pas de réponse du pilote indi_BAO.\n\n");
+
+            return false;
+        }
+    }
+
+    // un problÚme ?
+
+    catch ( SocketException& e )
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    return true;
+}
+
+
+
+/**************************************************************************************
+** Envoie la méthode d'alignement au pilote indi_bao
+** Ce paramÚtre peut être SIMPLE, AFFINE ou TAKI
+**
+***************************************************************************************/
+
+bool ServerDummy::EnvoyerMethodeAlignement()
+{
+    stringstream os;
+
+    try
+    {
+        *client_socket << "<newSwitchVector device=\"BAO\" name=\"ALIGNMENT_SET\">";
+        *client_socket << "<oneSwitch name=\"SIMPLE\">";
+        (MethodeAlignement == SIMPLE) ? *client_socket << "On" : *client_socket << "Off";
+        *client_socket << "</oneSwitch>";
+        *client_socket << "<oneSwitch name=\"AFFINE\">";
+        (MethodeAlignement == AFFINE) ? *client_socket << "On" : *client_socket << "Off";
+        *client_socket << "</oneSwitch>";
+        *client_socket << "<oneSwitch name=\"TAKI\">";
+        (MethodeAlignement == TAKI)   ? *client_socket << "On" : *client_socket << "Off";
+        *client_socket << "</oneSwitch>";
+        *client_socket << "</newSwitchVector>";
+
+        if (!VerifReponse("name=\"ALIGNMENT_SET\" state=\"Ok\"", NULL))
+        {
+            ErreurLog("ERREUR fct EnvoyerMethodeAlignement : pas de réponse du pilote indi_BAO.\n\n");
+
+            return false;
+        }
+    }
+
+    // un problÚme ?
+
+    catch ( SocketException& e )
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    return true;
+}
+
+
+/**************************************************************************************
+** Envoie une commande aux antennes
+** exemples : P, Z, A, Gf1000f0100
+**
+***************************************************************************************/
+
+bool ServerDummy::EnvoyerCommande(string commande)
+{
+    stringstream os;
+
+    try
+    {
+        *client_socket << "<newTextVector device=\"BAO\" name=\"COMMAND_SET\">";
+        *client_socket << "<oneText name=\"COMMAND\">";
+        *client_socket << commande;
+        *client_socket << "</oneText>";
+        *client_socket << "</newTextVector>";
+
+        if (!VerifReponse("name=\"COMMAND_SET\" state=\"Ok\"", NULL))
+        {
+            ErreurLog("ERREUR fct EnvoyerCommande : pas de réponse du pilote indi_BAO.\n\n");
+
+            return false;
+        }
+
+    }
+
+
+    // un problÚme ?
+
+    catch ( SocketException& e )
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    return true;
+}
+
+
 
 /**************************************************************************************
 ** Place les antennes en position de repos
+**
 ***************************************************************************************/
 
@@ -707 +975 @@
         *client_socket << "</newSwitchVector>";
 
-        if (!VerifReponse("PARK OK"))
-        {
-            Erreur("La commande PARK a échoué.\n\n");;
+        if (!VerifReponse("PARK OK", NULL))
+        {
+            ErreurLog("La commande PARK a échoué.\n\n");;
 
             return false;
@@ -716 +984 @@
     catch ( SocketException& e)
     {
-        Erreur("Exception was caught:" + e.description() + "\n");
-        return false;
-    }
-
-    Affiche("Le pilote indi_BAO a bien reçu la commande PARK.\n\n", true);
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("Le pilote indi_BAO a bien reçu la commande PARK.\n\n", true);
 
     return true;
@@ -729 +998 @@
 /**************************************************************************************
 ** Annule le mouvement en cours
+**
 ***************************************************************************************/
 
@@ -741 +1011 @@
         *client_socket << "</newSwitchVector>";
 
-        if (!VerifReponse("ABORT OK"))
-        {
-            Erreur("L'annulation a échoué.\n\n");
+        if (!VerifReponse("ABORT OK", NULL))
+        {
+            ErreurLog("L'annulation a échoué.\n\n");
 
             return false;
@@ -750 +1020 @@
     catch ( SocketException& e)
     {
-        Erreur("Exception was caught:" + e.description() + "\n");
-        return false;
-    }
-
-    Affiche("Le pilote indi_BAO a bien reçu la commande ABORT.\n\n", true);
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("Le pilote indi_BAO a bien reçu la commande ABORT.\n\n", true);
 
     return true;
@@ -760 +1031 @@
 
 
-
-/**************************************************************************************
-** Diriger l'antenne vers les coordonnées ar et dec et suivre l'objet
-** en activant le mode transit ou tracking.
+/**************************************************************************************
+** Alignement de l'antenne ip
+**
+***************************************************************************************/
+
+bool ServerDummy::AlignementIP(string ip)
+{
+    try
+    {
+        *client_socket << "<newTextVector device=\"BAO\" name=\"ALIGNEMENT_IP\">";
+        *client_socket << "<oneText name=\"IP\">";
+        *client_socket << ip;
+        *client_socket << "</oneText>";
+        *client_socket << "</newTextVector>";
+
+
+        if (!VerifReponse("est maintenant prete pour l alignement", NULL))
+        {
+            ErreurLog("La sélection de l'antenne située à l'adresse ip a échoué.\n\n");
+
+            return false;
+        }
+    }
+    catch ( SocketException& e)
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("Le pilote indi_BAO a bien sélectionné l'antenne situé à l'adresse ip pour l'alignement.\n\n", true);
+
+    return true;
+}
+
+
+/**************************************************************************************
+** Augmenter ou diminuer le delta en ascension droite ou en déclinaison
+**
+***************************************************************************************/
+
+bool ServerDummy::AlignementDelta(string delta, bool azimut)
+{
+    string Message = "";
+
+    try
+    {
+        if (azimut)
+        {
+            if (delta == "-1")
+            {   *client_socket << "<newSwitchVector device=\"BAO\" name=\"AZ\" >";
+                *client_socket << "<oneSwitch name=\"AZM\">";
+                *client_socket << "On";
+                *client_socket << "</oneSwitch>";
+                *client_socket << "</newSwitchVector>";
+            }
+            else
+            {
+                *client_socket << "<newSwitchVector device=\"BAO\" name=\"AZ\" >";
+                *client_socket << "<oneSwitch name=\"AZP\">";
+                *client_socket << "On";
+                *client_socket << "</oneSwitch>";
+                *client_socket << "</newSwitchVector>";
+            }
+
+            if (!VerifReponse("Delta", &Message))
+            {
+                ErreurLog("BAOcontrol:AlignementDelta a échoué.\n\n");
+
+                return false;
+            }
+        }
+        else
+        {
+            if (delta == "-1")
+            {
+                *client_socket << "<newSwitchVector device=\"BAO\" name=\"ALT_N\" >";
+                *client_socket << "<oneSwitch name=\"ALTN\">";
+                *client_socket << "On";
+                *client_socket << "</oneSwitch>";
+                *client_socket << "</newSwitchVector>";
+
+                if (!VerifReponse("Delta", &Message))
+                {
+                    ErreurLog("BAOcontrol:AlignementDelta a échoué.\n\n");
+
+                    return false;
+                }
+            }
+            else
+            {
+                *client_socket << "<newSwitchVector device=\"BAO\" name=\"ALT_P\" >";
+                *client_socket << "<oneSwitch name=\"ALTP\">";
+                *client_socket << "On";
+                *client_socket << "</oneSwitch>";
+                *client_socket << "</newSwitchVector>";
+
+                if (!VerifReponse("Delta", &Message))
+                {
+                    ErreurLog("BAOcontrol:AlignementDelta a échoué.\n\n");
+
+                    return false;
+                }
+            }
+        }
+
+        if (Message != "") AfficherLog(Message + "\n\n", true);
+    }
+    catch ( SocketException& e)
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+//   AfficherLog("Le pilote indi_BAO a bien sélectionné l'antenne situé à l'adresse ip pour l'alignement.\n\n", true);
+
+    return true;
+}
+
+
+/**************************************************************************************
+** Validation de l'alignement sur l'étoile visée actuellement
+**
+***************************************************************************************/
+
+bool ServerDummy::ValidationAlignement()
+{
+    try
+    {
+        *client_socket << "<newSwitchVector device=\"BAO\" name=\"ALIGNMENT_OK\" >";
+        *client_socket << "<oneSwitch name=\"OK\">";
+        *client_socket << "On";
+        *client_socket << "</oneSwitch>";
+        *client_socket << "</newSwitchVector>";
+
+        if (!VerifReponse("alignement ont ete valides", NULL))
+        {
+            ErreurLog("L'alignement sur l'étoile n'a pu être validé.\n\n");
+
+            return false;
+        }
+    }
+    catch ( SocketException& e)
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("L'alignement sur l'étoile a bien été validé.\n\n", true);
+
+    return true;
+}
+
+
+/**************************************************************************************
+** Sauvegarde de l'alignement
+**
+***************************************************************************************/
+
+bool ServerDummy::SauvegardeAlignement()
+{
+    try
+    {
+        *client_socket << "<newSwitchVector device=\"BAO\" name=\"ALIGNMENT_OK\" >";
+        *client_socket << "<oneSwitch name=\"SAUV\">";
+        *client_socket << "On";
+        *client_socket << "</oneSwitch>";
+        *client_socket << "</newSwitchVector>";
+
+        if (!VerifReponse("Les parametres de l alignement ont ete sauvegardes", NULL))
+        {
+            ErreurLog("La sauvegarde des paramÚtres de l'alignement a échoué.\n\n");
+
+            return false;
+        }
+    }
+    catch ( SocketException& e)
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("Les paramÚtres de l'alignemeent ont bien été sauvegardés.\n\n", true);
+
+    return true;
+}
+
+
+
+/**************************************************************************************
+** Sauvegarde de l'alignement
+**
+***************************************************************************************/
+
+bool ServerDummy::ResetAlignement()
+{
+    try
+    {
+        *client_socket << "<newSwitchVector device=\"BAO\" name=\"ALIGNMENT_RESET\" >";
+        *client_socket << "<oneSwitch name=\"RESET\">";
+        *client_socket << "On";
+        *client_socket << "</oneSwitch>";
+        *client_socket << "</newSwitchVector>";
+
+        if (!VerifReponse("reinitialises", NULL))
+        {
+            ErreurLog("Impossible de réinitialiser les paramÚtres d'alignement de l'antenne.\n\n");
+
+            return false;
+        }
+    }
+    catch ( SocketException& e)
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("Les paramÚtres d'alignement de l'antenne ont été réinitialisés.\n\n", true);
+
+    return true;
+}
+
+
+/**************************************************************************************
+** Sélection vitesse alignement
+**
+***************************************************************************************/
+
+bool ServerDummy::VitesseAlignement(int vit)
+{
+    string Message = "";
+
+    try
+    {
+        if (vit == 1)
+        {
+            *client_socket << "<newSwitchVector device=\"BAO\" name=\"RAQ\" >";
+            *client_socket << "<oneSwitch name=\"RAQ1\">";
+            *client_socket << "On";
+            *client_socket << "</oneSwitch>";
+            *client_socket << "</newSwitchVector>";
+
+            if (!VerifReponse("La vitesse de la raquette est fixee a 1x", &Message))
+            {
+                ErreurLog("Impossible de modifier la vitesse de la raquette.\n\n");
+
+                return false;
+            }
+        }
+        else
+        {
+            *client_socket << "<newSwitchVector device=\"BAO\" name=\"RAQ\" >";
+            *client_socket << "<oneSwitch name=\"RAQ10\">";
+            *client_socket << "On";
+            *client_socket << "</oneSwitch>";
+            *client_socket << "</newSwitchVector>";
+
+            if (!VerifReponse("La vitesse de la raquette est fixee a 10x", &Message))
+            {
+                ErreurLog("Impossible de modifier la vitesse de la raquette.\n\n");
+
+                return false;
+            }
+        }
+
+
+
+    }
+    catch ( SocketException& e)
+    {
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    if (Message != "") AfficherLog(Message +"\n\n", true);
+
+    return true;
+}
+
+/**************************************************************************************
+** Dirige l'antenne vers les coordonnées ar et dec et suit l'objet  en activant le mode
+** transit ou tracking.
+**
 ** si J2000 == true, cela signifie que les coordonnées ar et dec sont données dans le
 ** le systÚme de coordonnées J2000 (écliptique et équinoxe du 1 janvier 2000 à 0 h TU)
-** Des calculs supplémentaires (précession, nutation, abérration) sont alors nécessaires
+** Des calculs supplémentaires (précession, nutation, aberration) sont alors réalisés
+** pour ramener les coordonnées horaires à l'écliptique et l'équinoxe de la date de
+** l'observation.
+**
 ***************************************************************************************/
 
 bool ServerDummy::Goto(string ar, string dec, bool Transit, bool J2000)
 {
+    double arf, decf;
     float  ar1, ar2, ar3;
     float  dec1, dec2, dec3;
-    double arf, decf;
-
-
-
-     /*
-     //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
+    if (dec[0] == '-') decf = -decf;
+
+    // Calculs supplémentaires pour ramener les coordonnées horaires
     // à l'époque de l'observation
 
-    if (J2000)
+    if ( J2000 )
     {
         Precession(&arf, &decf);
@@ -813 +1364 @@
     // 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());
-    */
+    AfficherLog("Coordonnées apparentes de l'objet :\n", true);
+
+    AfficherLog("AD=" + ar  + "   Dec=" + dec +"\n", true);
+
 
     // On transmet les coordonnées au pilote BAO
@@ -835 +1375 @@
         *client_socket << "<newSwitchVector device=\"BAO\" name=\"ON_COORD_SET\">";
         *client_socket << "<oneSwitch name=\"TRANSIT\">";
-        if (Transit) *client_socket << "On";
-        else *client_socket << "Off";
+        (Transit) ? *client_socket << "On" : *client_socket << "Off";
         *client_socket << "</oneSwitch>";
 
         *client_socket << "<oneSwitch name=\"TRACKING\">";
-        if (Transit)  *client_socket << "Off";
-        else *client_socket << "On";
+        (Transit) ? *client_socket << "Off" : *client_socket << "On";
         *client_socket << "</oneSwitch>";
         *client_socket << "</newSwitchVector>";
 
-        if (!VerifReponse("name=\"ON_COORD_SET\""))
-        {
-            Erreur("Le changement de mode TRANSIT/TRACKING a échoué.\n\n");
+        if (!VerifReponse("name=\"ON_COORD_SET\"", NULL))
+        {
+            ErreurLog("Le changement de mode TRANSIT/TRACKING a échoué.\n\n");
 
             return false;
@@ -861 +1399 @@
         *client_socket << "</newNumberVector>";
 
-        if (!VerifReponse("name=\"EQUATORIAL_EOD_COORD_REQUEST\""))
-        {
-            Erreur("Le transfert des coordonnées de l'objet a échoué.\n\n");
+        if (!VerifReponse("name=\"EQUATORIAL_EOD_COORD_REQUEST\"", NULL))
+        {
+            ErreurLog("Le transfert des coordonnées de l'objet a échoué.\n\n");
 
             return false;
@@ -870 +1408 @@
     catch ( SocketException& e)
     {
-        Erreur("Exception was caught:" + e.description() + "\n");
-        return false;
-    }
-
-    Affiche("Les nouvelles coordonnées AD=" + ar + " Dec=" + dec, true);
-    Affiche(" ont été envoyées au pilote indi_BAO.\n\n", true);
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
+        return false;
+    }
+
+    AfficherLog("Les nouvelles coordonnées AD=" + ar + " Dec=" + dec, true);
+    AfficherLog(" ont été envoyées au pilote indi_BAO.\n\n", true);
+
     return true;
 }
 
-
-
 /**************************************************************************************
 ** Se connecte ou se déconnecte au pilote indi_BAO
+**
 ***************************************************************************************/
 
@@ -891 +1430 @@
         *client_socket << "<newSwitchVector device=\"BAO\" name=\"CONNECTION\">";
 
-        if (connect) *client_socket << "<oneSwitch name=\"CONNECT\">";
-        else *client_socket << "<oneSwitch name=\"DISCONNECT\">";
+        (connect) ? *client_socket << "<oneSwitch name=\"CONNECT\">" : *client_socket << "<oneSwitch name=\"DISCONNECT\">";
 
         *client_socket << "On";
@@ -900 +1438 @@
         if (connect)
         {
-            if (!VerifReponse("BAORadio is online"))
+            if (!VerifReponse("BAORadio is online", NULL))
             {
-                Erreur("La connexion a échoué.\n\n");
+                ErreurLog("La connexion a échoué.\n\n");
 
                 return false;
@@ -909 +1447 @@
         else
         {
-            if (!VerifReponse("BAORadio is offline"))
+            if (!VerifReponse("BAORadio is offline", NULL))
             {
-                Erreur("La déconnexion a échoué.\n\n");
+                ErreurLog("La déconnexion a échoué.\n\n");
 
                 return false;
@@ -920 +1458 @@
     catch ( SocketException& e )
     {
-        Erreur("Exception was caught:" + e.description() + "\n");
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
         return false;
     }
@@ -926 +1465 @@
     if (connect)
     {
-        Affiche("La connexion a été établie avec le pilote indi_BAO.\n\n", true);
+        AfficherLog("La connexion a été établie avec le pilote indi_BAO.\n\n", true);
+
+        // Au moment de la connexion avec le driver indi_BAO
+        // On transmet les paramÚtres du lieu de l'observation, le mode de suivi
+        // ainsi que la méthode d'alignement utilisée
+
+        usleep(500000);
 
         EnvoyerCoordGeographiques();
+
+        EnvoyerPressionTemperature();
+
+        EnvoyerDelaisModesTransitEtTracking();
+
+        EnvoyerMethodeAlignement();
     }
     else
     {
-        Affiche("BAOcontrol s'est bien déconnecté du pilote indi_BAO.\n\n", true);
+        AfficherLog("BAOcontrol s'est bien déconnecté du pilote indi_BAO.\n\n", true);
     }
 
     return true;
 }
-
-
-
 
 
@@ -1061 +1609 @@
 bool ServerDummy::ChargementParametres(string fileName)
 {
-    string section;
+     string section;
     string key;
     char * value;
@@ -1067 +1615 @@
 
 
-
-    Affiche("Lecture du fichier de configuration 'params' :\n\n", true);
+    // Si le fichier n'existe pas -> on sort
+
+    if (!is_readable(fileName)) return false;
+
+
+    AfficherLog("Lecture du fichier de configuration 'params' :\n\n", true);
 
 
     /////////////////////////////////////////
-    // Rubrique Coodonnées géographiques
+    // Rubrique Coordonnées géographiques
 
     section = "coordonnees geographiques";
@@ -1082 +1634 @@
     {
         LatitudeChar = (string)value;
-        delete [] value;
-        Affiche("latitude = " + LatitudeChar +"\n", true);
+        SAFEDELETE_TAB(value);
+        AfficherLog("latitude = " + LatitudeChar +"\n", true);
     }
     else
     {
-        Erreur("La latitude est incorrecte !\n");
+        ErreurLog("La latitude est incorrecte !\n");
+
         return false;
     }
@@ -1098 +1651 @@
     {
         LongitudeChar = (string)value;
-        delete [] value;
-        Affiche("longitude = " + LongitudeChar +"\n\n", true);
+        SAFEDELETE_TAB(value);
+        AfficherLog("longitude = " + LongitudeChar +"\n\n", true);
     }
     else
     {
-        Erreur("La longitude est incorrecte !\n");
+        ErreurLog("La longitude est incorrecte !\n");
+
         return false;
     }
@@ -1118 +1672 @@
     {
         Serveur = (string)value;
-        delete [] value;
-        Affiche("serveur = " + Serveur +"\n", true);
+        SAFEDELETE_TAB(value);
+        AfficherLog("serveur = " + Serveur +"\n", true);
     }
     else
     {
-        Erreur("Nom du serveur invalide !\n");
-        return false;
-    }
-
+        ErreurLog("Nom du serveur invalide !\n");
+
+        return false;
+    }
+
+    /////////////////////////////////////////
+    // Port de connexion du serveur Indi
 
     key = "port";
@@ -1133 +1690 @@
     {
         Port = (string)value;
-        delete [] value;
-        Affiche("port = " + Port +"\n\n", true);
+        SAFEDELETE_TAB(value);
+        AfficherLog("port = " + Port +"\n\n", true);
     }
     else
     {
-        Erreur("Numéro de port incorrect !\n");
+        ErreurLog("Numéro de port incorrect !\n");
+
         return false;
     }
@@ -1153 +1711 @@
     {
         Pression = atof(value);
-        delete [] value;
+        SAFEDELETE_TAB(value);
         os << "pression = " << Pression << endl;
-        Affiche(&os, true);
+        AfficherLog(&os, true);
     }
     else
     {
-        os << "La pression atmosph&rique est incorrecte !" << endl;
-        Erreur(&os);
+        os << "La pression atmosphérique est incorrecte !" << endl;
+        ErreurLog(&os);
+
         return false;
     }
@@ -1168 +1727 @@
     if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
     {
-        Temperature=atof(value);
-        delete [] value;
+        Temperature = atof(value);
+        SAFEDELETE_TAB(value);
         os << "température = " << Temperature << endl << endl;
-        Affiche(&os, true);
+        AfficherLog(&os, true);
     }
     else
     {
-        Erreur("La température est incorrecte !\n");
-        return false;
-    }
+        ErreurLog("La température est incorrecte !\n");
+
+        return false;
+    }
+
+    /////////////////////////////////////////
+    // Rubrique alignement
+
+    section = "alignement";
+
+    key = "methode_alignement";
+
+    if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
+    {
+        AfficherLog("methode d'alignement = " + (string)value + "\n", true);
+        switch (value[0])
+        {
+        case 's' :
+        case 'S' :
+            MethodeAlignement = SIMPLE;
+            break;
+
+        case 'a' :
+        case 'A' :
+            MethodeAlignement = AFFINE;
+            break;
+
+        case 't' :
+        case 'T' :
+            MethodeAlignement = TAKI;
+            break;
+        }
+
+        SAFEDELETE_TAB(value);
+    }
+    else
+    {
+        ErreurLog("Le paramÚtre methode_alignement est incorrect !\n");
+
+        return false;
+    }
+
 
 
@@ -1190 +1788 @@
     {
         Transit = (strstr(value, "transit") != NULL);
-        Affiche("mode suivi = " + (string)value + "\n", true);
-        delete [] value;
+        AfficherLog("mode suivi = " + (string)value + "\n", true);
+        SAFEDELETE_TAB(value);
     }
     else
     {
-        Erreur("Le paramÚtre mode est incorrect !\n");
+        ErreurLog("Le paramÚtre mode suivi est incorrect !\n");
+
         return false;
     }
@@ -1205 +1804 @@
     if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
     {
-        delaitransit=atoi(value);
-        delete [] value;
+        delaitransit = atoi(value);
+        SAFEDELETE_TAB(value);
         os << "delai transit = " << delaitransit << " sec" << endl;
-        Affiche(&os, true);
+        AfficherLog(&os, true);
     }
     else
     {
-        Erreur("Le paramÚtre delai_transit est incorrect !\n");
+        ErreurLog("Le paramÚtre delai_transit est incorrect !\n");
+
         return false;
     }
@@ -1221 +1821 @@
     if (readINI(section.c_str(), key.c_str(), &value, fileName.c_str()))
     {
-        delaitracking=atoi(value);
-        delete [] value;
+        delaitracking = atoi(value);
+        SAFEDELETE_TAB(value);
         os << "delai tracking = " << delaitracking << " sec" << endl << endl;
-        Affiche(&os, true);
+        AfficherLog(&os, true);
     }
     else
     {
-        Erreur("Le paramÚtre delai_tracking est incorrect !\n");
+        ErreurLog("Le paramÚtre delai_tracking est incorrect !\n");
+
         return false;
     }
@@ -1243 +1844 @@
     {
         ChoixCouleurs=atoi(value);
-        delete [] value;
+        SAFEDELETE_TAB(value);
     }
     else
     {
         /*os << "Le paramÚtre couleurs est incorrect !" << endl;
-        Erreur(os.str());
+        ErreurLog(os.str());
         return false;*/
     }
@@ -1256 +1857 @@
 
 
+
+/**************************************************************************************
+** Le fichier file existe-t-il et n'est-il pas vide ?
+**
+**************************************************************************************/
+
+bool ServerDummy::is_readable( const string & file )
+{
+    ifstream fichier( file.c_str() );
+    if (fichier.fail()) return false;
+
+    // sauvegarder la position courante
+
+ //   long pos = fichier.tellg();
+
+    // se placer en fin de fichier
+
+    fichier.seekg( 0 , ios_base::end );
+
+    // récupérer la nouvelle position = la taille du fichier
+
+    long size = fichier.tellg();
+
+    return (size > 0);
+}
+
+

BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.hpp

@@ -30 +30 @@
 #include <string.h>
 #include <sstream>
-#include "ClientSocket.h"
-#include "SocketException.h"
+#include "../../communs/ClientSocket.h"
+#include "../../communs/SocketException.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <X11/Xlib.h>
-#include "filetools.h"
-#include "astro.h"
+#include "../../communs/const.h"
+#include "../../communs/astro.h"
+#include "../../communs/logs.h"
+#include "../../communs/alignement.h"
 #include "math.h"
 #include <time.h>
@@ -44 +46 @@
 
 
-// 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 50
-
-
-//dimensions de la fenêtre graphique
-
-#define haut_fenetre 10+22*10
-#define larg_fenetre 605
-
 using namespace std;
 
 
+// ParamÚtres des étoiles utilisées pour l'alignement des antennes
+
+struct DefEtoiles
+{
+    string nom;                         // Nom de l'objet
+    string cons;                        // Nom de la constellation
+    double ad;                          // Ascension droite J2000 de l'objet (en rad)
+    double de;                          // déclinaison J2000 de l'objet (en rad)
+    double az;                          // Azimut (en rad)
+    double ha;                          // hauteur au-dessus de l'horizon (en rad)
+    double mag;                         // magnitude
+    bool   selectionnee;                // l'objet a-t-il été sélectionné pour calibrer l'antenne ?
+};
+
+
+
+// structure définissant les paramÚtres des antennes
+
 struct DefAntenne
 {
-    unsigned char ip;                   // Adresse ip d'une antenne
+    unsigned char ip;                   // Adresse ip d'une antenne. Seul le dernier nombre nous intéresse
 
-    char ok;                            // actuellement disponible ?
+    char ok;                            // actuellement disponible ? 
+                                        // 0 = antenne non connectée
+                                        // 1 = antenne connectée fonctionnant normalement
+                                        // 2 = antenne connectée mais présentant un défaut
+
+    Alignement *AlignementAntenne;      // Contient les paramÚtres d'alignement de l'antenne définie par cette structure  
 };
 
-// objets stockés dans le fichier de mouvements
+
+
+// objets ou zone du ciel stockés dans le fichier des mouvements planifiés
+// Se reporter à la notice de la commande run pour savoir comment utiliser ces fichiers de mouvement
 
 struct DefObjets
 {
-    double JJ;                          // Jour julien où le télescope doit aller pointer vers l'objet
+    double JJ;                          // Date julienne du début de l'observation de l'objet i défini dans le fichier de mouvements
     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 ?
+    string ad;                          // Ascension droite de l'objet dans le repÚre J2000
+    string de;                          // Déclinaison de l'objet dans le repÚre J2000
+    bool exec;                          // L'objet est-il actuellement observé ?
 };
 
@@ -94 +96 @@
 //! Telescope server class for a virtual telescope that requires no physical device.
 //! Useful for remote connection testing.
-class ServerDummy : public Server, public Astro
+class ServerDummy : public Server2, public Astro, public Logs
 {
 public:
@@ -108 +110 @@
         void rouler();
         void LireReponse();
-        bool VerifReponse(string reponseattendue);
+        bool VerifReponse(string reponseattendue, string *Message);
         void Update();
-        bool EnvoyerCoordGeographiques();
-        bool Park();
-        bool Abort();
-        bool Goto(string ar, string dec, bool Transit, bool J2000);
-        bool Connect(bool connect);
+     bool Connect(bool connect);
+    bool EnvoyerCoordGeographiques();
+    bool EnvoyerPressionTemperature();
+    bool EnvoyerDelaisModesTransitEtTracking();
+    bool EnvoyerMethodeAlignement();
+    bool EnvoyerCommande(string commande);
+    bool Park();
+    bool Abort();
+    bool Goto(string ar, string dec, bool Transit, bool J2000);
+    bool AlignementAntenneIP(string ip);
+   
+    bool AlignementIP(string ip);
+    bool AlignementDelta(string delta, bool azimut);
+    bool ValidationAlignement();
+    bool SauvegardeAlignement();
+    bool ResetAlignement();
+    bool VitesseAlignement(int vit);
         bool Decomposition(string chaine, char type, float *a1, float *a2, float *a3);
         int  readline (FILE * pfile, char *tab);
         bool ChargementParametres(string fileName);
+        
+        bool is_readable( const string & file );
         
 private:
@@ -126 +142 @@
         long long int next_pos_time;
 
-        // Variables globales
+       // Variables globales
 
-           XFontStruct * fd;                           // Police de caractÚres dans la fenêtre graphique
+    XFontStruct * fd;                           // Police de caractÚres utilisée 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
 
-           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 numAntennes;                            // Nbre d'antennes connectées
+    int numobjets;                              // Nbre d'objets dans le dernier fichier de mouvements chargé
+    int runnum;                                 // Numéro de l'objet actuellement visé dans le fichier de mouvement
+    int numEtoiles;                             // Nbre d'étoiles utilisées pour la procédure d'alignement des antennes
+    int MethodeAlignement;                      // Méthode d'alignement utilisée
 
-           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
+    double Pression;                            // Pression atmosphérique en mbar
+    double Temperature;                         // température de l'atmosphÚre en °C
 
-           bool NoExit;                         // A-t-on tapé exit pour sortir ? Permet de fermer le thread à ce moment-là 
-           bool Transit;                                // Si oui, le mode transit est activé, sinon, c'est le mode tracking
-           bool run;                                    // execute actuellement un fichier de mouvements
-           bool exitrun;                                // doit-on sortir du programme à la fin de l'execution de la commande run ?
-           bool J2000;                                  // est-ce que les coordonnées du fichier de mouvements sont en coordonnées J2000 ?
+    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;                                   // exécute actuellement un fichier de mouvements
+    bool exitrun;                               // doit-on sortir du programme à la fin de l'exécution de la commande run ?
+    bool J2000;                                 // est-ce que les coordonnées du fichier de mouvements sont en coordonnées J2000 ?
+    bool ModificationAlignement;                // Est-ce que l'une des antennes est en cours d'alignement et est-ce qu'un paramÚtre 
+                                                // d'alignement à changé ?
 
-           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
+    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
+    struct DefEtoiles *Etoiles;                 // Liste des étoiles servant à la procédure d'alignement des antennes
 
-           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
+    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 contient 'localhost'
+    string Port;                                // Port utilisé pour connecter le serveur indi_BAO
 
-           ClientSocket *client_socket;         // Socket permettant la connexion avec le pilote 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
+    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
 };
 

BAORadio/libindi/libindi/Indi_Stellarium/src/Socket2.hpp

@@ -71 +71 @@
 long long int GetNow(void);
 
-class Server;
+class Server2;
 
-class Socket
+class Socket2
 {
 public:
-        virtual ~Socket(void) { hangup(); }
+        virtual ~Socket2(void) { hangup(); }
         void hangup(void);
         virtual void prepareSelectFds(fd_set &read_fds, fd_set &write_fds, int &fd_max) = 0;
@@ -88 +88 @@
         
 protected:
-        Socket(Server &server, SOCKET fd) : server(server), fd(fd) {}
-        Server & server;
+        Socket2(Server2 &server, SOCKET fd) : server(server), fd(fd) {}
+        Server2 & server;
         
 #ifdef WIN32
@@ -115 +115 @@
 private:
         // no copying
-        Socket(const Socket&);
-        const Socket &operator=(const Socket&);
+        Socket2(const Socket2&);
+        const Socket2 &operator=(const Socket2&);
 };
 

BAORadio/libindi/libindi/bao.sh

@@ -19 +19 @@
 cd libindi_build
 make clean
-cd ../BAOControl
+cd ../BAOcontrol
 make clean
+rm -f *.o *.cpp~ *.h~  BAOtest
 cd ../BAOTest
 make clean
@@ -51 +52 @@
 echo ;
 
-cd ../BAOControl
+cd ../BAOcontrol
+qmake -project
+qmake
 make
-make install
+cp BAOcontrol /usr/bin
 echo ;
 echo ;
@@ -70 +73 @@
 if  [ "$1" == "install" ] && [ "$2" == "config" ]
 then 
-cp BAOControl/baocontrol_params "/home/"$USER
+cp BAOcontrol/baocontrol_params "/home/"$USER
 echo "Le fichier baocontrol_params a été copié dans le répertoire /home/"$USER;
-cp BAOControl/bao_catalogue.dat "/home/"$USER
+cp BAOcontrol/bao_catalogue.dat "/home/"$USER
 echo "Le fichier bao_catalogue.dat a été copié dans le répertoire /home/"$USER;
 fi

BAORadio/libindi/libindi/communs/ClientSocket.cpp

@@ -64 +64 @@
 
         if (! Socket::connect((std::string)"192.168.0.1", 8000)) {
-            std::cout << "connect impossible.\n";
+            std::cout << "connect impossible 192.168.0.1.\n";
+           // Socket::shutdown();
+            if (! Socket::connect((std::string)"127.0.0.1", 8000)) {
+            std::cout << "connect impossible 127.0.0.1.\n";
             Socket::shutdown();
-        } else {
+            } else std::cout << "Reconnexion reussie.\n";
+        }
+         else {
             std::cout << "Reconnexion reussie.\n";
         }

BAORadio/libindi/libindi/communs/alignement.cpp

@@ -45 +45 @@
     for (int i=0; i< MAXALIGNEMENTANTENNE; i++)
     {
-        ad[i]         = 0.0;
-        de[i]         = 0.0;
-        delta_ad[i]   = 0;
-        delta_de[i]   = 0;
-        tsl[i]        = 0.0;
+        ad[i]                           = 0.0;
+        de[i]                           = 0.0;
+        delta_ad[i]                     = 0.0;
+        delta_de[i]                     = 0.0;
+        tsl[i]                          = 0.0;
+        SelectionnePourCalculMatrice[i] = false;
     }
 
@@ -60 +61 @@
 
     delta_az_polar    = 0;
+
+    // Initialisation des deltas sur les axes az et ha
+    // pour gérer la raquette hors procédure d'alignement
+
+    deltaAZ           = 0;
+    deltaHA           = 0;
 
     // Nbre de points (de mesures) actuellement disponibles pour
@@ -161 +168 @@
     double temp[4][4];
     double UnitVect[4][4];
-
+    
     temp[1][1] = p2.x - p1.x;
     temp[2][1] = p3.x - p1.x;
@@ -176 +183 @@
     UnitVect[2][1] = pow(UnitVect[1][1], 2.0) + pow(UnitVect[1][2], 2.0) + pow (UnitVect[1][3], 2.0);
     UnitVect[2][2] = sqrt(UnitVect[2][1]);
+    UnitVect[2][3] = 0.0;
     if (UnitVect[2][2] != 0.0) UnitVect[2][3] = 1.0 / UnitVect[2][2];
 
-    for (char i=1; i<=2; i++) for (char j=1; j<=3; j++) GETLMN[i][j] = temp[i][j];
+    for (int i=1; i<=2; i++) for (int j=1; j<=3; j++) GETLMN[i][j] = temp[i][j];
 
     GETLMN[3][1] = UnitVect[2][3] * UnitVect[1][1];
@@ -192 +200 @@
 ***************************************************************************************/
 
-int Alignement::Calculer_Matrice_Taki(double x, double y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
+int Alignement::Calculer_Matrice_Taki(double x, double y, Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3)
 {
     double Det;
@@ -198 +206 @@
     double EQLMN2[4][4];
     double EQMI_T[4][4];
-
+    
+    Coord a1, a2, a3, m1, m2, m3;
+    
+    AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
+    AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
+    AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
+
+    AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
+    AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
+    AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
+    
     //construit les matrices EQLMN1 & 2
 
+    Calculer_Matrice_LMN(m1, m2, m3);
+
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN1[i][j]=GETLMN[i][j];
+
     Calculer_Matrice_LMN(a1, a2, a3);
 
-    for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQLMN1[i][j]=GETLMN[i][j];
-
-    Calculer_Matrice_LMN(m1, m2, m3);
-
-    for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQLMN2[i][j]=GETLMN[i][j];
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQLMN2[i][j]=GETLMN[i][j];
 
     // Calcule le déterminant de EQLMN1
@@ -266 +284 @@
     else
     {
-        return  PointSitueDansSurfaceTriangle(x, y, a1.x, a1.y, a2.x, a2.y, a3.x, a3.y);
+        return  PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y);
     }
 }
@@ -278 +296 @@
     // vect.z = 1
 
-    result->x = VECT_OFFSET.x + ((vect.x * MATRICE[1][1]) + (vect.y * MATRICE[2][1]) + (vect.z * MATRICE[3][1]));
-    result->y = VECT_OFFSET.y + ((vect.x * MATRICE[1][2]) + (vect.y * MATRICE[2][2]) + (vect.z * MATRICE[3][2]));
-    result->z = VECT_OFFSET.z + ((vect.x * MATRICE[1][3]) + (vect.y * MATRICE[2][3]) + (vect.z * MATRICE[3][3]));
+    result->x = -VECT_OFFSET.x + ((vect.x * MATRICE[1][1]) + (vect.y * MATRICE[2][1]) + (vect.z * MATRICE[3][1]));
+    result->y = -VECT_OFFSET.y + ((vect.x * MATRICE[1][2]) + (vect.y * MATRICE[2][2]) + (vect.z * MATRICE[3][2]));
+    result->z = -VECT_OFFSET.z + ((vect.x * MATRICE[1][3]) + (vect.y * MATRICE[2][3]) + (vect.z * MATRICE[3][3]));
 }
 
@@ -307 +325 @@
 ***************************************************************************************/
 
-int Alignement::Calculer_Matrice_Affine( double x, double y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
+int Alignement::Calculer_Matrice_Affine( double x, double y, Coord aa1, Coord aa2, Coord aa3, Coord mm1, Coord mm2, Coord mm3)
 {
     double Det;
@@ -314 +332 @@
     double EQMQ[4][4];
 
+    Coord a1, a2, a3, m1, m2, m3, c1, c2;
+    
+    AzHa2XY(aa1.x, aa1.y, &a1.x, &a1.y);
+    AzHa2XY(aa2.x, aa2.y, &a2.x, &a2.y);
+    AzHa2XY(aa3.x, aa3.y, &a3.x, &a3.y);
+
+    AzHa2XY(mm1.x, mm1.y, &m1.x, &m1.y);
+    AzHa2XY(mm2.x, mm2.y, &m2.x, &m2.y);
+    AzHa2XY(mm3.x, mm3.y, &m3.x, &m3.y);
+    
+    /*c1.x=(a1.x+a2.x+a3.x)/3.0;
+    c1.y=(a1.y+a2.y+a3.y)/3.0;
+    
+    c2.x=(m1.x+m2.x+m3.x)/3.0;
+    c2.y=(m1.y+m2.y+m3.y)/3.0;
+    
+    a1.x-=c1.x;
+    a1.y-=c1.y;
+    a2.x-=c1.x;
+    a2.y-=c1.y;
+    a3.x-=c1.x;
+    a3.y-=c1.y;
+    
+    m1.x-=c2.x;
+    m1.y-=c2.y;
+    m2.x-=c2.x;
+    m2.y-=c2.y;
+    m3.x-=c2.x;
+    m3.y-=c2.y;*/
+    
+    
+    
+    
     //Construit les matrices EQMP et EQMQ
 
+    Calculer_Matrice_GETPQ(m1, m2, m3);
+
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMP[i][j]=GETPQ[i][j];
+
     Calculer_Matrice_GETPQ(a1, a2, a3);
 
-    for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQMP[i][j]=GETPQ[i][j];
-
-    Calculer_Matrice_GETPQ(m1, m2, m3);
-
-    for (char i=1; i<=3; i++) for (char j=1; j<=3; j++) EQMQ[i][j]=GETPQ[i][j];
+    for (int i=1; i<=3; i++) for (int j=1; j<=3; j++) EQMQ[i][j]=GETPQ[i][j];
 
     // Calcule l'inverse de EQMP
@@ -349 +400 @@
     MATRICE[2][1] = (EQMI[2][1] * EQMQ[1][1]) + (EQMI[2][2] * EQMQ[2][1]);
     MATRICE[2][2] = (EQMI[2][1] * EQMQ[1][2]) + (EQMI[2][2] * EQMQ[2][2]);
-
+    
+    
+    
     // Calcul du vecteur offset sur le ciel
 
-    VECT_OFFSET.x = m1.x - ((a1.x * MATRICE[1][1]) + (a1.y * MATRICE[2][1]));
-    VECT_OFFSET.y = m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]));
-
-    return 1;
+    VECT_OFFSET.x =0.0;//m1.x - ((a1.x * MATRICE[1][1]) + (a1.y * MATRICE[2][1]));
+    VECT_OFFSET.y =0.0;//m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]));
+
+   if (x + y == 0 )
+    {
+        return 0;
+    }
+    else
+    {
+        return  PointSitueDansSurfaceTriangle(x, y, aa1.x, aa1.y, aa2.x, aa2.y, aa3.x, aa3.y);
+    }
 }
 
@@ -531 +591 @@
 
 
-
+double Alignement::Determinant()
+{
+    double Det;
+    
+    Det = MATRICE[1][1] * ((MATRICE[2][2] * MATRICE[3][3]) - (MATRICE[3][2] * MATRICE[2][ 3]));
+    Det = Det - (MATRICE[1][2] * ((MATRICE[2][1] * MATRICE[3][3]) - (MATRICE[3][1] * MATRICE[2][3])));
+    Det = Det + (MATRICE[1][3] * ((MATRICE[2][1] * MATRICE[3][2]) - (MATRICE[3][1] * MATRICE[2][2])));
+
+    return Det;
+}
+
+
+
+void Alignement::AzHa2XY(double az, double ha, double *x, double *y)
+{
+    double r = Pidiv2 - ha;
+
+    *x = r * cos(az);
+
+    *y = r * sin(az);
+}
 
 /**************************************************************************************
@@ -541 +621 @@
 {
     double ta;
-
-    ta = (((px2 * py1) - (px1 * py2)) ) + (((px3 * py2) - (px2 * py3))  ) + (((px1 * py3) - (px3 * py1))  );
+    
+    double pxx1, pyy1, pxx2, pyy2, pxx3, pyy3;
+
+    AzHa2XY(px1, py1, &pxx1, &pyy1);
+
+    AzHa2XY(px2, py2, &pxx2, &pyy2);
+    
+    AzHa2XY(px3, py3, &pxx3, &pyy3);
+    
+    ta = (((pxx2 * pyy1) - (pxx1 * pyy2)) ) + (((pxx3 * pyy2) - (pxx2 * pyy3))  ) + (((pxx1 * pyy3) - (pxx3 * pyy1))  );
 
     return  fabs(ta) / 2.0;
@@ -571 +659 @@
     AfficherLog(os.str().c_str(), true);
 
-    if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false;
+  /* if ( DistanceAngulaireEntre2Points(px, py, px1, py1) > 1.2 ) return false;
     if ( DistanceAngulaireEntre2Points(px, py, px2, py2) > 1.2 ) return false;
-    if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;
+    if ( DistanceAngulaireEntre2Points(px, py, px3, py3) > 1.2 ) return false;*/
 
     return ( fabs(ta - t1 - t2 - t3) < 1e-10 );
@@ -591 +679 @@
 void Alignement::CalculerMatriceCorrection(double ar, double dec)
 {
-    Coord c1, c2, c3, c4, m1, m2, m3, m4;
-
-    double a1, b1, a2, b2;
+    Coord c1, c2, c3, m1, m2, m3;
+
+    double a1, b1, a2, b2, a3, b3, a4, b4, a5, b5;
 
     int map[MAXALIGNEMENTANTENNE];
@@ -599 +687 @@
     stringstream os;
 
-    int best1 = 0;
-    int best2 = 0;
-    int best3 = 0;
+    int best1 = -1;
+    int best2 = -1;
+    int best3 = -1;
 
 
@@ -612 +700 @@
     case SIMPLE :
     {
-        best1 = 1;
-        best2 = 2;
-        best3 = 3;
+        best1 = 0;
+        best2 = 1;
+        best3 = 2;
 
         for (int i=0; i<MAXALIGNEMENTANTENNE; i++) map[i] = i;
@@ -629 +717 @@
         distances = new double [nbrcorrections+1];
 
-        os << "Coordonnées visees : ad=" << DHMS(ar*N180divPi,true) << "  de=" << DHMS(dec*N180divPi,false) << "\n";
-
-        Azimut(VerifAngle(ar-GetTSL()), dec, &a2, &b2);
-
-        for (int i=1; i<=nbrcorrections; i++)
+        os << "Coordonnées visees : ad=" << DHMS(ar * 15.0,true) << "  de=" << DHMS(dec,false) << "\n";
+
+        Azimut(ar * 15.0 * Pidiv180, dec * Pidiv180, &a2, &b2);
+
+        for (int i=0; i<nbrcorrections; i++)
         {
-            Azimut(VerifAngle(ad[i]-tsl[i]),de[i], &a1, &b1);
+            Azimut(VerifAngle(ad[i]- tsl[i] + GetTSL() ),de[i], &a1, &b1);
 
             distances[i] = DistanceAngulaireEntre2Points(a1, b1, a2, b2);
@@ -642 +730 @@
         }
 
-        for (int i=1; i<=nbrcorrections; i++)
+        for (int i=0; i<nbrcorrections; i++)
         {
-            for (int j=i+1; j<=nbrcorrections; j++)
+            for (int j=i+1; j<nbrcorrections; j++)
             {
-                if (distances[j]<distances[i])
+                if ( distances[j] < distances[i] )
                 {
-                    double bout=distances[i];
-                    distances[i]=distances[j];
-                    distances[j]=bout;
-
-                    int bout2=map[i];
-                    map[i]=map[j];
-                    map[j]=bout2;
+                    double bout  = distances[i];
+                    distances[i] = distances[j];
+                    distances[j] = bout;
+
+                    int bout2 = map[i];
+                    map[i]    = map[j];
+                    map[j]    = bout2;
                 }
             }
         }
 
-        for (int i=1; i<=nbrcorrections; i++)
+        for (int i=0; i<nbrcorrections; i++)
         {
-            os << "Point " << map[i] << "  d=" << distances[i] << "\n";
+            os << "Point " << map[i] << "  d=" << distances[i] * N180divPi << "°\n";
         }
-
-        for (int i=1; i<=nbrcorrections; i++)
+        
+        for (int i=0; i<nbrcorrections; i++)
         {
-            for (int j=i+1; j<=nbrcorrections; j++)
+            for (int j=i+1; j<nbrcorrections; j++)
             {
-                for (int k=j+1; k<=nbrcorrections; k++)
+                for (int k=j+1; k<nbrcorrections; k++)
                 {
-                    double a,b;
-
                     os << "Triangle : " << map[i] << " " << map[j] << " " << map[k]  << "\n";
 
@@ -678 +764 @@
                     os << ": az=" << DHMS(a2*N180divPi, false) << "  ha=" <<  DHMS(b2*N180divPi, false) << "\n";
 
-                    os << "Etoile " << i ;
-
-                    Azimut(VerifAngle(ad[map[i]]-tsl[map[i]]), de[map[i]], &a, &b);
-
-                    os << ": az=" << DHMS(a*N180divPi, false) << "  ha=" <<  DHMS(b*N180divPi, false) << "\n";
-
-                    os << "Etoile " << j ;
-
-                    Azimut(VerifAngle(ad[map[j]]-tsl[map[j]]), de[map[j]], &a, &b);
-
-                    os << ": az=" << DHMS(a*N180divPi, false) << "  ha=" <<  DHMS(b*N180divPi, false) << "\n";
-
-                    os << "Etoile " << k ;
-
-                    Azimut(VerifAngle(ad[map[k]]-tsl[map[k]]), de[map[k]], &a, &b);
-
-                    os << ": az=" << DHMS(a*N180divPi, false) << "  ha=" <<  DHMS(b*N180divPi, false) << "\n";
+                    os << "Etoile " << map[i] ;
+
+                    Azimut(VerifAngle(ad[map[i]] - tsl[map[i]] + GetTSL()), de[map[i]], &a3, &b3);
+
+                    os << ": az=" << DHMS(a3*N180divPi, false) << "  ha=" <<  DHMS(b3*N180divPi, false) << "\n";
+
+                    os << "Etoile " << map[j] ;
+
+                    Azimut(VerifAngle(ad[map[j]] - tsl[map[j]] + GetTSL()), de[map[j]], &a4, &b4);
+
+                    os << ": az=" << DHMS(a4*N180divPi, false) << "  ha=" <<  DHMS(b4*N180divPi, false) << "\n";
+
+                    os << "Etoile " << map[k] ;
+
+                    Azimut(VerifAngle(ad[map[k]] - tsl[map[k]] + GetTSL()), de[map[k]], &a5, &b5);
+
+                    os << ": az=" << DHMS(a5*N180divPi, false) << "  ha=" <<  DHMS(b5*N180divPi, false) << "\n";
 
                     AfficherLog(&os, true);
 
-                    if (PointSitueDansSurfaceTriangle(VerifAngle(ar-GetTSL()), dec,
-                                                      VerifAngle(ad[map[i]]-tsl[map[i]]), de[map[i]],
-                                                      VerifAngle(ad[map[j]]-tsl[map[j]]), de[map[j]],
-                                                      VerifAngle(ad[map[k]]-tsl[map[k]]), de[map[k]]))
+                    if (PointSitueDansSurfaceTriangle(a2, b2,
+                                                      a3, b3,
+                                                      a4, b4,
+                                                      a5, b5))
                     {
                         best1=i;
@@ -721 +807 @@
 
 
-    if ( best1 == 0 && best2 == 0 && best3 == 0 )
+    if ( best1 == -1 && best2 == -1 && best3 == -1 )
     {
         if (MethodeAlignement == AFFINE || MethodeAlignement == TAKI)
@@ -738 +824 @@
         os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3]  << "\n" ;
 
-        if (MethodeAlignement == SIMPLE)
+       // if (MethodeAlignement == SIMPLE)
         {
             c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
@@ -752 +838 @@
             c3.z = 1.0;
         }
-        else
+    /*    else
         {
-            c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]]);
+            c1.x = VerifAngle(ad[map[best1]] - tsl[map[best1]] + GetTSL());
             c1.y = de[map[best1]];
             c1.z = 1.0;
 
-            c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]]);
+            c2.x = VerifAngle(ad[map[best2]] - tsl[map[best2]] + GetTSL());
             c2.y = de[map[best2]];
             c2.z = 1.0;
 
-            c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]]);
+            c3.x = VerifAngle(ad[map[best3]] - tsl[map[best3]] + GetTSL());
             c3.y = de[map[best3]];
             c3.z = 1.0;
-        }
-
-
-        os << "Point 1 :  ho=" << DHMS(c1.x * N180divPi, false);
-        os <<  "   de=" << DHMS(c1.y *N180divPi, false) <<"\n";
-        os << "Point 2 :  ho=" << DHMS(c2.x * N180divPi, false);
-        os <<  "   de=" << DHMS(c2.y * N180divPi, false) <<"\n";
-        os << "Point 3 :  ho=" << DHMS(c3.x * N180divPi, false);
-        os <<  "   de=" << DHMS(c3.y * N180divPi, false) <<"\n\n";
-
-
-        m1.x = VerifAngle(c1.x + (double)delta_ad[map[best1]] * PasDeltaAD);
-        m1.y = c1.y + (double)delta_de[map[best1]] * PasDeltaDe;
+        }*/
+      
+        m1.x = VerifAngle(delta_ad[map[best1]] - tsl[map[best1]] + GetTSL());
+        m1.y = delta_de[map[best1]];
         m1.z = 1.0;
 
-        m2.x = VerifAngle(c2.x + (double)delta_ad[map[best2]] * PasDeltaAD);
-        m2.y = c2.y + (double)delta_de[map[best2]] * PasDeltaDe;
+        m2.x = VerifAngle(delta_ad[map[best2]] - tsl[map[best2]] + GetTSL());
+        m2.y = delta_de[map[best2]];
         m2.z = 1.0;
 
-        m3.x = VerifAngle(c3.x + (double)delta_ad[map[best3]] * PasDeltaAD);
-        m3.y = c3.y + (double)delta_de[map[best3]] * PasDeltaDe;
+        m3.x = VerifAngle(delta_ad[map[best3]] - tsl[map[best3]] + GetTSL());
+        m3.y = delta_de[map[best3]];
         m3.z = 1.0;
     }
@@ -799 +876 @@
     case AFFINE:
         os << "Methode d alignement AFFINE\n";
-        Matrice_ok = Calculer_Matrice_Affine( VerifAngle( ar - GetTSL() ), dec, c1, c2, c3 ,m1, m2, m3);
+        Matrice_ok = Calculer_Matrice_Affine( VerifAngle( ar * 15.0 * Pidiv180 ), dec * Pidiv180, c1, c2, c3 ,m1, m2, m3);
         break;
     case TAKI:
         os << "Methode d alignement TAKI\n";
-        Matrice_ok = Calculer_Matrice_Taki  ( VerifAngle( ar - GetTSL() ), dec, c1, c2, c3 ,m1, m2, m3);
+        Matrice_ok = Calculer_Matrice_Taki  ( VerifAngle( ar * 15.0 * Pidiv180 ), dec * Pidiv180, c1, c2, c3 ,m1, m2, m3);
         break;
     }
@@ -814 +891 @@
     os << MATRICE[1][2] << "   \t" << MATRICE[2][2] << "    \t" << MATRICE[3][2] << "\n";
     os << MATRICE[1][3] << "   \t" << MATRICE[2][3] << "    \t" << MATRICE[3][3] << "\n";
-
-
-
-
-
+    os << "\nDeterminant :" << Determinant() << "\n";
+
+
+    for (int i=0; i<nbrcorrections; i++) SelectionnePourCalculMatrice[i] = false;
+    
+    SelectionnePourCalculMatrice[map[best1]] = true;
+    SelectionnePourCalculMatrice[map[best2]] = true;
+    SelectionnePourCalculMatrice[map[best3]] = true;
+    
 
     //Vérifications supp
@@ -885 +966 @@
 
     // sauvegarder la position courante
-    long pos = fichier.tellg();
+   // long pos = fichier.tellg();
     // se placer en fin de fichier
     fichier.seekg( 0 , std::ios_base::end );
@@ -908 +989 @@
     stringstream os, os2;
 
-    char *delta_az_polar_data = NULL;
+    char *delta_az = NULL;
+
+    char *delta_ha = NULL;
 
     char *ad_data = NULL;
@@ -924 +1007 @@
     char *tsl_data = NULL;
 
-
     if (!is_readable(fileName)) return false;
 
@@ -933 +1015 @@
     // On sélectionne la bonne antenne (à partir de son adresse ip).
 
-    if (IP.rfind(".") != string::npos) IP = IP.substr(IP.rfind(".")+1);
-
-
-    os << "Alignement antenne ip x.x.x." << IP;
-
-
-    //nbrcorrections = 0; TODO semble poser un problÚme
-
-
-    for (int j=1; j < MAXALIGNEMENTANTENNE; j++)
+    os << "Alignement antenne ip " << IP;
+
+
+    nbrcorrections = 0;
+    
+    for (int j=0; j < MAXALIGNEMENTANTENNE; j++)
     {
         os2 << "ad " << j;
@@ -981 +1059 @@
             // -> on les applique...
 
-            nbrcorrections = j;
-
-            if (delta_ad[j] != atol(delta_ad_data) || delta_de[j] != atol(delta_de_data))
+            
+
+            if (delta_ad[nbrcorrections] != atof(delta_ad_data) || delta_de[nbrcorrections] != atof(delta_de_data))
             {
-                ad[j] = atof(ad_data);
-
-                de[j] = atof(de_data);
-
-                delta_ad[j] = atol(delta_ad_data);
-
-                delta_de[j] = atol(delta_de_data);
-
-                tsl[j] = atof(tsl_data);
-
-                os2 << "Correction antenne ip=" << IP <<  " ad=" << ad[j] << " de=" << de[j] << " deltaAD=" << delta_ad[j] << " deltaDe=" << delta_de[j] << " tsl=" << tsl[j] << "\n";
+                ad[nbrcorrections] = atof(ad_data);
+
+                de[nbrcorrections] = atof(de_data);
+
+                delta_ad[nbrcorrections] = atof(delta_ad_data);
+
+                delta_de[nbrcorrections] = atof(delta_de_data);
+
+                tsl[nbrcorrections] = atof(tsl_data);
+
+                os2 << "Correction antenne ip=" << IP <<  " ad=" << ad[nbrcorrections] << " de=" << de[nbrcorrections] << " deltaAD=" << 
+                delta_ad[nbrcorrections] << " deltaDe=" << delta_de[nbrcorrections] << " tsl=" << tsl[nbrcorrections] << "\n";
 
                 AfficherLog(&os2, true);
 
                 modificationAlignement = true;
-            }
+                
+                nbrcorrections++;
+            }           
         }
 
@@ -1014 +1095 @@
     }
 
-    os2 << "delta_az_polar";
-
-    readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_az_polar_data,  (char*)fileName.c_str());
+    os2 << "delta_az";
+
+    readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_az,  (char*)fileName.c_str());
 
     os2.str("");
 
-    if (delta_az_polar_data)
-    {
-        if ( delta_az_polar != atol(delta_az_polar_data) )
+    if (delta_az)
+    {
+        if ( deltaAZ != atol(delta_az) )
         {
-            delta_az_polar = atol(delta_az_polar_data);
+            deltaAZ = atol(delta_az);
 
             modificationAlignement = true;
@@ -1030 +1111 @@
     }
 
+    os2 << "delta_ha";
+
+    readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_ha,  (char*)fileName.c_str());
+
+    os2.str("");
+
+    if (delta_ha)
+    {
+        if ( deltaHA != atol(delta_ha) )
+        {
+            deltaHA= atol(delta_ha);
+
+            modificationAlignement = true;
+        }
+    }
+
     os2 << "alignment_method";
 
@@ -1035 +1132 @@
 
     os2.str("");
-
-    /*  char chaine[100];
-    sprintf(chaine, "************** %s\n",alignment_method_data);
-      cout << chaine;*/
 
     if (alignment_method_data)
@@ -1102 +1195 @@
     }
 
-    SAFEDELETE_TAB(delta_az_polar_data);
+    SAFEDELETE_TAB(delta_az);
+
+    SAFEDELETE_TAB(delta_ha);
 
     SAFEDELETE_TAB(alignment_method_data);
@@ -1130 +1225 @@
     //Enregistrement des corrections des l'antennes
 
-    os << "Alignement antenne ip x.x.x." << IP;
+
+    os << "Alignement antenne ip " << IP;
     section = os.str();
     os.str("");
-
-    os << "delta_az_polar";
-    key     = os.str();
-    os.str("");
-    os << delta_az_polar;
-    value = os.str();
-    os.str("");
-
-    writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
 
     os << "align";
@@ -1159 +1246 @@
     os.str("");
 
-
     writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
 
-    /*    char chaine[100];
-    sprintf(chaine, "s************** %i\n",MethodeAlignement);
-       cout << chaine;*/
-
-
-    for (int j = 1; j <= MAXALIGNEMENTANTENNE; j++)
+    os << "delta_az";
+    key     = os.str();
+    os.str("");
+    os << deltaAZ;
+    value = os.str();
+    os.str("");
+
+    writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+    os << "delta_ha";
+    key     = os.str();
+    os.str("");
+    os << deltaHA;
+    value = os.str();
+    os.str("");
+
+    writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+
+    for (int j = 0; j < MAXALIGNEMENTANTENNE; j++)
     {
         os << "ad " << j;
@@ -1190 +1290 @@
         key     = os.str();
         os.str("");
-        os << 0;
+        os << 0.0;
         value = os.str();
         os.str("");
@@ -1199 +1299 @@
         key     = os.str();
         os.str("");
-        os << 0;
+        os << 0.0;
         value = os.str();
         os.str("");
@@ -1215 +1315 @@
     }
 
-
-    for (int j = 1; j <= nbrcorrections; j++)
+    for (int j = 0; j < nbrcorrections; j++) if (ad[j]!=0.0 && de[j]!=0.0)
     {
         os << "ad " << j;

BAORadio/libindi/libindi/communs/alignement.h

@@ -11 +11 @@
 #ifndef Alignement_class
 #define Alignement_class
-
 
 #include <stdio.h>
@@ -34 +33 @@
 
 using namespace std;
-
 
 struct Coord
@@ -93 +91 @@
 
     double Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3);
+    void AzHa2XY(double az, double ha, double *x, double *y);
     bool PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
+    
+    double Determinant();
 
 
@@ -109 +110 @@
     long delta_az_polar;                        // Correction en azimut de l'orientation de l'étoile polaire
     // C'est la premiÚre étape de l'alignement dans les mode AFFINE et TAKI
+    
+    long int deltaAZ;                           // delta en azimut et en hauteur pour une correction à la raquette
+    long int deltaHA;                           // hors procédure d'alignement
+    
+    bool SelectionnePourCalculMatrice[MAXALIGNEMENTANTENNE];
 
     double ad[MAXALIGNEMENTANTENNE];            // Coordonnées horaires d'un point de correction
@@ -116 +122 @@
     double tsl[MAXALIGNEMENTANTENNE];           // Temps sidéral local où les mesures en ar et dec ont été faites
 
-    long delta_ad[MAXALIGNEMENTANTENNE];        // nbre de pas ajoutés en ascension droite et en déclinaison pour centrer l'objet visé
+    double delta_ad[MAXALIGNEMENTANTENNE];        // nbre de pas ajoutés en ascension droite et en déclinaison pour centrer l'objet visé
 
-    long delta_de[MAXALIGNEMENTANTENNE];
+    double delta_de[MAXALIGNEMENTANTENNE];
 
     double MATRICE[4][4];                       // La matrices de correction calculée dans les trois modes d'alignement

BAORadio/libindi/libindi/communs/astro.cpp

@@ -19 +19 @@
 {
     //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;
@@ -30 +30 @@
     Sec       = 0.0;
     UTCP      = 0.0;                     // permet de gérer le fuseau horaire
-                                         // mais semble inutile sous Linux
-    
+    // mais semble inutile sous Linux
+
     hs        = 0.0;                     // fraction du jour en cours avec 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 
+
+    CorP      = 0.0;                     // Nutation en longitude
     CorEP     = 0.0;                     // Nutation en inclinaison
-    
+
     Pression  = 1013.0;
     Temp      = 0.0;
-     
+
     LongitudeSoleil = 0.0;
 }
@@ -106 +106 @@
 double Astro::VerifDistance(double Angle)
 {
-        Angle=VerifAngle(Angle);
-        if (Angle>Pi) Angle=Pi2-Angle;
-
-        return(Angle);
+    Angle=VerifAngle(Angle);
+    if (Angle>Pi) Angle=Pi2-Angle;
+
+    return(Angle);
 }
 
@@ -115 +115 @@
 /**************************************************************************************
 ** Distance entre deux points situés sur une sphÚre
-** 
+**
 ***************************************************************************************/
 
 double Astro::DistanceAngulaireEntre2Points(double az1, double ha1, double az2, double ha2)
 {
-    return acos(sin(ha1) * sin(ha2) + cos(ha1) * cos(ha2) * cos(az2 - az1)); 
+    return acos(sin(ha1) * sin(ha2) + cos(ha1) * cos(ha2) * cos(az2 - az1));
 }
 
@@ -161 +161 @@
     a=mema;
 
-    if (HMS) a=a / 15.0;
+    if (HMS) a = a / 15.0;
     a=fabs(a * 3600.0);
     s=Arrondi(fmod(a, 60.0) * 10.0) / 10.0;
@@ -190 +190 @@
 }
 
+/**************************************************************************************
+** Décomposition et vérification des dates, heures, AD et déclinaisons
+**
+** type = 0 -> chaîne contient une déclinaison ou une latitude
+** type = 1 -> "        "      une longitude
+** type = 2 -> "        "      une AD ou une heure
+** type = 3 -> "        "      une date
+**
+** Exemple de Décomposition("15:23:12", 2, a, b, c) retourne a=15, b=23, c=12
+** si la chaîne a un format incorrect, la fct retourne false
+**
+***************************************************************************************/
+
+bool Astro::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 caractÚres "/" entre chaque éléments pour une date
+
+    (type == 3) ? car="/" : car=":";
+
+    // Y a-t-il 2 caractÚres ':' ou '/' dans la chaîne ?
+    // C'est indispensable dans tous les cas
+
+    int test = 0;
+
+    for (size_t 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);
+
+    // 12.125454414 sec  -> 12.125 sec
+
+    c = Arrondi(atof(s.c_str()) * 100.0) / 100.0;
+
+    //vérification de la cohérence des infos contenues dans la chaîne
+
+    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;
+}
 
 /**************************************************************************************
@@ -215 +293 @@
 
     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);
+                 +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;
 }
@@ -233 +311 @@
 ***************************************************************************************/
 
-void Astro::CalculARDecSoleil(CoordonneesHoraires *Soleil)
+void Astro::CalculARDecSoleil(CoordonneesHorairesDouble *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 );
-}
-    
+    Soleil->ar = VerifAngle(ar);
+
+    Soleil->dec = de;
+}
+
 
 
@@ -270 +348 @@
     double LP2 = 2.0 * LP;
     double O2  = 2.0 * O;
-    
+
     // Nutation en longitude
 
@@ -286 +364 @@
            +0.0124 * sin(L2 - O)
            +0.0114 * sin(LP2 - MP);
-           
+
     //Nutation en inclinaison
 
@@ -393 +471 @@
 void Astro::CalculJJ(double Heure)
 {
-    JJ = CalculJJ(Annee, Mois, Jour, Heure);    
+    JJ = CalculJJ(Annee, Mois, Jour, Heure);
 }
 
@@ -438 +516 @@
 
     c = (36525L * y) / 100;
-    
+
     return b + c + e + day - 32167.5;
 }
@@ -450 +528 @@
 double Astro::TSL(double JJ, double HeureSiderale, double Longitude)
 {
-    double T = (JJ - 2415020.0 ) / 36525.0;
+    double T = (JJ /*- 66.185/3600.0/24.0*/ - 2415020.0 ) / 36525.0;
     double rd = 0.276919398 + ( 100.0021359 + 0.000001075 * T ) * T;
     rd += HeureSiderale;
@@ -500 +578 @@
     double az = atan(a1 / sqrt((-a1*a1)+1.0));
 
-    if (ac<0.0) az=Pi-az;
-
-    *azi=VerifAngle(Pi+az);
-    *hau=ht;
-}
+    if (ac<0.0) az = Pi - az;
+
+    *azi = VerifAngle( Pi + az );
+    *hau = ht;
+}
+
+
+/**************************************************************************************
+** Calcule l'ascension droite et la déclinaison d'un objet situé à l'azimut az
+** et à la déclinaison de
+***************************************************************************************/
+
+void Astro::AzHa2ADDe(double az, double ha, double *AD, double *Dec)
+{
+    double sindel, del, habar, cosha, ha10;
+
+    sindel = sin(ha) * sin(Latitude) + cos(ha) * cos(Latitude) * cos(az);
+
+    del = asin(sindel);
+
+    if ( (sindel == 1.0) || ( sindel == -1.0) )
+    {
+        habar = 0.0;
+    }
+    else
+    {
+        if ( (sin(Latitude) == 1.0) || (sin(Latitude) == -1.0))
+        {
+            habar = az;
+        }
+        else
+        {
+            cosha = ( sin(ha) - sin(Latitude) * sindel ) / ( cos(Latitude) * cos(del) );
+            if (cosha > 1.0  )  cosha =  1.0;
+            if (cosha < -1.0 )  cosha = -1.0;
+
+            habar = acos(cosha);
+        }
+    }
+
+    if (sin(az) < 0.0)
+    {
+        ha10 = habar;
+    }
+    else
+    {
+        ha10 = Pi2 - habar ;
+    }
+
+    *AD = VerifAngle( tsl - ha10 );
+
+    // if (*AD < 0.0) *AD += Pi2;
+
+    *Dec = del;
+}
+
+
+/**************************************************************************************
+** Recherche l'azimut de l'objet suivi au moment où celui-ci passera sous les 30°
+** et deviendra donc hors d'atteinte de l'instrument.
+***************************************************************************************/
+
+void Astro::RechercheAzimutFinSuivi(double AD, double Dec, long int *azmin, long int *azmax)
+{
+    double az, ha;
+    double min =  10000.0;
+    double max = -10000.0;
+
+    CalculTSL();
+
+    for (int i=0; i < 120; i++)
+    {
+        tsl += i * 5.0 / 60.0 / 24.0 ;
+
+        Azimut( AD, Dec, &az, &ha);
+
+        if ( az > max ) max = az;
+
+        if ( az < min ) min = az;
+
+        if ( ha < HAUTMIN * Pidiv180) break;
+    }
+
+    *azmin = (long int) Arrondi( min * (double)NBREPASCODEURSAZ / 360.0) - NBREPASCODEURSAZ;
+
+    *azmax = (long int) Arrondi( max * (double)NBREPASCODEURSAZ / 360.0) + NBREPASCODEURSAZ;
+
+    CalculTSL();
+}
+
 
 
@@ -712 +875 @@
     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;
+           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 */

BAORadio/libindi/libindi/communs/astro.h

@@ -13 +13 @@
 #include "../communs/const.h"
 #include "stdio.h"
+#include "stdlib.h"
 #include <iostream>
 #include <string.h>
 #include <sstream>
 #include <iomanip>
+#include "const.h"
 
 using namespace std;
@@ -27 +29 @@
     string ar;                          // Coordonnées horaires d'un objet
     string dec;
+};
+
+struct CoordonneesHorairesDouble
+{
+    double ar;                          // Coordonnées horaires d'un objet
+    double dec;
 };
 
@@ -45 +53 @@
     string DHMS(double mema, bool HMS);
     void   Azimut(double Ar, double De, double *azi, double *hau);
+    void   AzHa2ADDe(double Az, double Ha, double *AD, double *Dec);
+    void   RechercheAzimutFinSuivi(double AD, double Dec, long int *azmin, long int *azmax);
     void   Precession(double *ar, double *de);
     void   NutationEtoile(double *ar, double *de);
@@ -54 +64 @@
     double CalculLongitudeSoleil();
     double TSL(double JJ,double HeureSiderale,double Longitude);
+    bool    Decomposition(string chaine, char type, float *a1, float *a2, float *a3);
     void   Nutation();
     void   Obliquite(double JJ);
@@ -67 +78 @@
     float  slaRange(float angle );
     double slaDrange(double angle );
-    void   CalculARDecSoleil(CoordonneesHoraires *Soleil);
+    void   CalculARDecSoleil(CoordonneesHorairesDouble *Soleil);
     
     double GetLatitude()    { return Latitude;  }

BAORadio/libindi/libindi/communs/const.h

@@ -27 +27 @@
 
 #define NBREPASCODEURSAZ  4000
+
+// Définition des limites autorisées pour l'azimut (en pas codeur)
+
+#define MAXAZCODEURS 3800
+#define MINAZCODEURS -1680
+
 
 
@@ -71 +77 @@
 // l'utilisateur agit sur les touches fléchées durant la procédure d'alignement des antennes
 
-#define PasDeltaAD 2.0 * MINUTE_ARC
-#define PasDeltaDe 2.0 * MINUTE_ARC
+#define PasDeltaAD ( 2.0 * MINUTE_ARC )
+#define PasDeltaDe ( 2.0 * MINUTE_ARC )
+
+#define PasDeltaHa ( 5.0 * MINUTE_ARC )
+#define PasDeltaAz ( 5.0 * MINUTE_ARC )
 
 #define gmax(A,B) ((A)>(B)?(A):(B))
@@ -125 +134 @@
 // Délai maximum en ms d'attente de la réponse des micro-contrÎleurs
 
-#define MAX_DELAI_REPONSE 40
+#define MAX_DELAI_REPONSE 60
 
 // Si une commande ne recoit pas d'acknowledge. Alors refaire 80 tentatives en renvoyant la commande
@@ -137 +146 @@
 // attendre plus de 2 mn pour considérer qu'une antenne n'est pas en mesure de faire un goto
 
-#define MAXANOMALIESGOTO 1500
+#define MAXANOMALIESGOTO 2000
+
+// Durée (en sec) entre deux actualisations en mode tracking
+
+#define UPDATETRACKINGDELAY 1.0
+
+// Durée (en sec) entre deux actualisations en mode transit
+
+#define UPDATETRANSITDELAY ( 15.0 * 60.0 )
 
 

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

@@ -22 +22 @@
 const char *BASIC_GROUP    = "Main Control";            // Main Group
 const char *OPTIONS_GROUP  = "Options";                 // Options Group
-
+const char *RAQ_GROUP      = "Raquette";                // Options Group
+const char *ALIG_GROUP     = "Alignement";              // Options Group
 
 #define targetRA    EquatorialCoordsWN[0].value
 #define targetDEC   EquatorialCoordsWN[1].value
+
 
 
@@ -76 +78 @@
     // dans les modes transit et tracking
 
-    ActualisationTMTransit  = 15.0 * 60.0;    // Délai entre 2 actualisations dans le mode transit (en sec)
-
-    ActualisationTMTracking = 5.0;            //                "                 "        tracking
+    ActualisationTMTransit  = UPDATETRANSITDELAY;          // Délai entre 2 actualisations dans le mode transit (en sec)
+
+    ActualisationTMTracking = UPDATETRACKINGDELAY;  //                "                 "        tracking
 
     // cette variable vaut "true" lorsque le thread de l'aplication a été initialisé
@@ -114 +116 @@
 
     Temp                  = 10.0;
+
+    // raquette
+
+    delta_az              = 0;
+    delta_ha              = 0;
+    VitesseRaquette       = 10;
+    targetAlignmentIP     = -1;
 
 
@@ -136 +145 @@
 
     AfficherLog("Indi server BAORadio...\n");
-    AfficherLog("Driver Version: 0.51 (02-04-2012)\n");
+    AfficherLog("Driver Version: 0.6 (19-05-2012)\n");
 
     //connect_telescope();
@@ -293 +302 @@
     IUFillSwitchVector(&OnCoordSetSP, OnCoordSetS, NARRAY(OnCoordSetS), mydev, "ON_COORD_SET", "On Set", BASIC_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
 
+    // Abort
+    IUFillSwitch(&AbortSlewS[0], "ABORT", "Abort", ISS_OFF);
+    IUFillSwitchVector(&AbortSlewSP, AbortSlewS, NARRAY(AbortSlewS), mydev, "ABORT_MOTION", "Abort", BASIC_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
+
+    // Park
+    IUFillSwitch(&ParkS[0], "PARK", "Park", ISS_OFF);
+    IUFillSwitchVector(&ParkSP, ParkS, NARRAY(ParkS), mydev, "", "Park", BASIC_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
+
+    // Object Name
+    IUFillText(&ObjectT[0], "OBJECT_NAME", "Name", "--");
+    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.);
+    IUFillNumber(&EquatorialCoordsWN[1], "DEC", "Dec D:M:S", "%10.6m", -90., 90., 0., 0.);
+    IUFillNumberVector(&EquatorialCoordsWNP, EquatorialCoordsWN, NARRAY(EquatorialCoordsWN), mydev, "EQUATORIAL_EOD_COORD_REQUEST" , "Equatorial JNow", BASIC_GROUP, IP_WO, 0, IPS_IDLE);
+
+    //Command
+    IUFillText(&CommandT[0], "COMMAND", "Command", "");
+    IUFillTextVector(&CommandTP, CommandT, NARRAY(CommandT), mydev, "COMMAND_SET", "Command", BASIC_GROUP, IP_WO, 0, IPS_IDLE);
+
+
+    // Alignement- bouton Alt+
+    IUFillSwitch(&AlignementAltp[0], "ALTP", "Alt+", ISS_OFF);
+    IUFillSwitchVector(&AlignementAltpP, AlignementAltp, NARRAY(AlignementAltp), mydev, "ALT_P", "Alt+", RAQ_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
+
+    // Alignement- bouton Az
+    IUFillSwitch(&AlignementAz[0], "AZM", "Az-", ISS_OFF);
+    IUFillSwitch(&AlignementAz[1], "AZP", "Az+", ISS_OFF);
+    IUFillSwitchVector(&AlignementAzP, AlignementAz, NARRAY(AlignementAz), mydev, "AZ", "Azimut", RAQ_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
+
+
+    // Alignement- bouton Alt-
+    IUFillSwitch(&AlignementAltn[0], "ALTN", "Alt-", ISS_OFF);
+    IUFillSwitchVector(&AlignementAltnP, AlignementAltn, NARRAY(AlignementAltn), mydev, "ALT_N", "Alt-", RAQ_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
+
+    // Vitesse Raquette - bouton Az
+    IUFillSwitch(&RaquetteN[0], "RAQ1", "1x", ISS_OFF);
+    IUFillSwitch(&RaquetteN[1], "RAQ10", "10x", ISS_OFF);
+    IUFillSwitchVector(&RaquetteNP, RaquetteN, NARRAY(RaquetteN), mydev, "RAQ", "Vitesse raquette", RAQ_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
+
+
+    // Alignement Coords - SET
+    IUFillText(&AlignementIP[0], "IP", "IP", "");
+    IUFillTextVector(&AlignementIPP, AlignementIP, NARRAY(AlignementIP), mydev, "ALIGNEMENT_IP", "Alignment IP", ALIG_GROUP, IP_WO, 0, IPS_IDLE);
+
+
+    // Alignment validation
+    IUFillSwitch(&AlignementOk[0], "OK", "Valider", ISS_OFF);
+    IUFillSwitch(&AlignementOk[1], "SAUV", "Sauvegarder", ISS_OFF);
+    IUFillSwitchVector(&AlignementOkP, AlignementOk, NARRAY(AlignementOk), mydev, "ALIGNMENT_OK", "Validation", ALIG_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
+
+    // Alignment reset
+    IUFillSwitch(&AlignementReset[0], "RESET", "Reset", ISS_OFF);
+    IUFillSwitchVector(&AlignementResetP, AlignementReset, NARRAY(AlignementReset), mydev, "ALIGNMENT_RESET", "Reset", ALIG_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
+
     // Alignment Set
     IUFillSwitch(&AlignmentS[0], "SIMPLE", "Simple", ISS_ON);
     IUFillSwitch(&AlignmentS[1], "AFFINE", "Affine", ISS_OFF);
     IUFillSwitch(&AlignmentS[2], "TAKI", "Taki", ISS_OFF);
-    IUFillSwitchVector(&AlignmentSP, AlignmentS, NARRAY(AlignmentS), mydev, "ALIGNMENT_SET", "Alignment", BASIC_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
-
-    // Abort
-    IUFillSwitch(&AbortSlewS[0], "ABORT", "Abort", ISS_OFF);
-    IUFillSwitchVector(&AbortSlewSP, AbortSlewS, NARRAY(AbortSlewS), mydev, "ABORT_MOTION", "Abort", BASIC_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
-
-    // Park
-    IUFillSwitch(&ParkS[0], "PARK", "Park", ISS_OFF);
-    IUFillSwitchVector(&ParkSP, ParkS, NARRAY(ParkS), mydev, "", "Park", BASIC_GROUP, IP_RW, ISR_ATMOST1, 0, IPS_IDLE);
-
-    // Object Name
-    IUFillText(&ObjectT[0], "OBJECT_NAME", "Name", "--");
-    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.);
-    IUFillNumber(&EquatorialCoordsWN[1], "DEC", "Dec D:M:S", "%10.6m", -90., 90., 0., 0.);
-    IUFillNumberVector(&EquatorialCoordsWNP, EquatorialCoordsWN, NARRAY(EquatorialCoordsWN), mydev, "EQUATORIAL_EOD_COORD_REQUEST" , "Equatorial JNow", BASIC_GROUP, IP_WO, 0, IPS_IDLE);
-
-    //Command
-    IUFillText(&CommandT[0], "COMMAND", "Command", "");
-    IUFillTextVector(&CommandTP, CommandT, NARRAY(CommandT), mydev, "COMMAND_SET", "Command", BASIC_GROUP, IP_WO, 0, IPS_IDLE);
+    IUFillSwitchVector(&AlignmentSP, AlignmentS, NARRAY(AlignmentS), mydev, "ALIGNMENT_SET", "Alignment method", ALIG_GROUP, IP_RW, ISR_1OFMANY, 0, IPS_IDLE);
+
 
     // Geographic coord - SET
@@ -326 +371 @@
 
     // Pression température - SET
-    IUFillNumber(&PressionTempWN[0], "Pression", "Pression mb", "%10.6m",  0., 1500., 0., 0.);
-    IUFillNumber(&PressionTempWN[1], "Temperature", "Temperature °c", "%10.6m", -50., +50., 0., 0.);
+    IUFillNumber(&PressionTempWN[0], "Pression", "Pression mb", "%4.0f",  0., 1500., 0., 0.);
+    IUFillNumber(&PressionTempWN[1], "Temperature", "Temperature °c", "%3.0f", -50., +50., 0., 0.);
     IUFillNumberVector(&PressionTempWNP, PressionTempWN, NARRAY(PressionTempWN), mydev, "PRESSION_DATA" , "Pression, Temperature", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
 
     // Actualisation - SET
-    IUFillNumber(&ActualisationN1[0], "DELAY", "Transit delay (s)", "%10.6m",  0., 3600., 0., 0.);
+    IUFillNumber(&ActualisationN1[0], "DELAY", "Transit delay (s)", "%3.0f",  0., 3600., 0., 0.);
     IUFillNumberVector(&ActualisationNP1, ActualisationN1, NARRAY(ActualisationN1), mydev, "DELAY1" , "", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
 
-    IUFillNumber(&ActualisationN2[0], "DELAY", "Tracking delay (s)", "%10.6m",  0., 3600., 0., 0.);
+    IUFillNumber(&ActualisationN2[0], "DELAY", "Tracking delay (s)", "%3.0f",  0., 3600., 0., 0.);
     IUFillNumberVector(&ActualisationNP2, ActualisationN2, NARRAY(ActualisationN2), mydev, "DELAY2" , "", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
 }
@@ -357 +402 @@
     IDDefText(&CommandTP, NULL);
     IDDefSwitch(&OnCoordSetSP, NULL);
-    IDDefSwitch(&AlignmentSP, NULL);
     IDDefSwitch(&AbortSlewSP, NULL);
     IDDefSwitch(&ParkSP, NULL);
+
+    // Raquette
+    IDDefSwitch(&AlignementAltpP, NULL);
+    IDDefSwitch(&AlignementAzP, NULL);
+    IDDefSwitch(&AlignementAltnP, NULL);
+
+    //alignement
+    IDDefSwitch(&RaquetteNP, NULL);
+    IDDefText(&AlignementIPP, NULL);
+    IDDefSwitch(&AlignementOkP, NULL);
+    IDDefSwitch(&AlignementResetP, NULL);
+    IDDefSwitch(&AlignmentSP, NULL);
 
     // Options
@@ -380 +436 @@
     OnCoordSetSP.s              = IPS_IDLE;
     AlignmentSP.s               = IPS_IDLE;
+    AlignementAltpP.s           = IPS_IDLE;
+    AlignementAltnP.s           = IPS_IDLE;
+    AlignementAzP.s             = IPS_IDLE;
+    AlignementIPP.s             = IPS_IDLE;
+    AlignementOkP.s             = IPS_IDLE;
+    RaquetteNP.s                = IPS_IDLE;
+    AlignementResetP.s          = IPS_IDLE;
     AbortSlewSP.s               = IPS_IDLE;
     ParkSP.s                    = IPS_IDLE;
@@ -392 +455 @@
     IUResetSwitch(&OnCoordSetSP);
     IUResetSwitch(&AlignmentSP);
+    IUResetSwitch(&AlignementAltpP);
+    IUResetSwitch(&AlignementAzP);
+    IUResetSwitch(&AlignementAltnP);
+    IUResetSwitch(&AlignementOkP);
+    IUResetSwitch(&AlignementResetP);
+    IUResetSwitch(&RaquetteNP);
     IUResetSwitch(&AbortSlewSP);
     IUResetSwitch(&ParkSP);
@@ -397 +466 @@
     OnCoordSetS[0].s = ISS_ON;
     AlignmentS[0].s = ISS_ON;
+    AlignementAltp[0].s = ISS_OFF;
+    AlignementAltn[0].s = ISS_OFF;
+    AlignementAz[0].s = ISS_OFF;
+    AlignementAz[1].s = ISS_OFF;
     ConnectS[0].s = ISS_OFF;
     ConnectS[1].s = ISS_ON;
@@ -403 +476 @@
     IDSetSwitch(&OnCoordSetSP, NULL);
     IDSetSwitch(&AlignmentSP, NULL);
+    IDSetSwitch(&AlignementAltpP, NULL);
+    IDSetSwitch(&AlignementAzP, NULL);
+    IDSetSwitch(&AlignementAltnP, NULL);
+    IDSetSwitch(&AlignementOkP, NULL);
+    IDSetSwitch(&AlignementResetP, NULL);
+    IDSetSwitch(&RaquetteNP, NULL);
     IDSetSwitch(&AbortSlewSP, NULL);
     IDSetSwitch(&ParkSP, NULL);
     IDSetText(&ObjectTP, NULL);
     IDSetText(&CommandTP, NULL);
+    IDSetText(&AlignementIPP, NULL);
     IDSetNumber(&EquatorialCoordsWNP, NULL);
     IDSetNumber(&PressionTempWNP, NULL);
@@ -454 +534 @@
 
     // ===================================
+    // Adresse IP de l'antenne qu'il faut aligner
+    // ===================================
+    if (!strcmp (name, AlignementIPP.name))
+    {
+        if (IUUpdateText(&AlignementIPP, texts, names, n) < 0)
+            return;
+
+        IText *eqp = IUFindText (&AlignementIPP, names[0]);
+
+        int i;
+
+        if (eqp == &AlignementIP[0])
+        {
+            string ip = texts[0];
+
+            bool IPvalide = false;
+
+            // est-ce que l'adresse ip correspond à l'adresse d'une antenne connectée ?
+
+            for ( i=1; i<SocketsNumber; i++) if (Sockets[i].Connected)
+                {
+                    if (Sockets[i].IP == ip) {
+                        IPvalide = true;
+                        break;
+                    }
+                }
+
+            if ( IPvalide )
+            {
+                targetAlignmentIP = i;
+                AlignementIPP.s = IPS_OK ;
+                IDSetText(&AlignementIPP, "L antenne %s est maintenant prete pour l alignement", Sockets[targetAlignmentIP].IP.c_str() );
+
+                Sockets[targetAlignmentIP].AlignementAntenne->AlignementEnCours = 1;
+
+                Sockets[targetAlignmentIP].AlignementAntenne->Matrice_ok = false;
+            }
+            else
+            {
+                targetAlignmentIP = -1;
+                AlignementIPP.s = IPS_ALERT ;
+                IDSetText(&AlignementIPP, "L antenne indiquee n est pas connectee !");
+            }
+        }
+        return;
+    }
+
+
+    // ===================================
     // Commands
     // ===================================
@@ -474 +603 @@
             if (chaine[0] == 'G')
             {
+                //commande goto
+
                 for (int i = 1; i<=strlen(chaine); i++) chaine[i-1]=chaine[i];
-                
-                IDLog(chaine);
+
+                IDLog(chaine);
 
                 for (int i = 1; i<SocketsNumber; i++ )
@@ -484 +615 @@
                         result = COMMANDE(i, (char*)"G", chaine);
                     }
+                }
+            }
+            else if (chaine[0] == 'X')
+            {
+                if (targetAlignmentIP != -1)
+                {
+                    IDSetText(&CommandTP, "Position:/%05d/%05d\n", Sockets[targetAlignmentIP].Pos.x, Sockets[targetAlignmentIP].Pos.y );
+
+                    return;
+                }
+            }
+            else if (chaine[0] == 'D')
+            {
+                if (targetAlignmentIP != -1)
+                {
+                    IDSetText(&CommandTP, "Deltas:/%05d/%05d\n", delta_az, delta_ha );
+
+                    return;
+                }
+            }
+            else if (chaine[0] == 'C')
+            {
+                if (targetAlignmentIP != -1)
+                {
+                    stringstream os;
+
+                    double a, b;
+
+                    os << "Corrections:";
+
+                    Azimut( targetRA * 15.0 * Pidiv180,
+                            targetDEC * Pidiv180, &a, &b);
+                    os << a << ",";
+                    os << b << ",";
+
+                    os << "/";
+
+                    for (int i=0; i<Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections; i++)
+                    {
+                        if (Sockets[targetAlignmentIP].AlignementAntenne->SelectionnePourCalculMatrice[i])
+                        {
+                            os << i << ",";
+                        }
+                    }
+
+                    os << "/";
+
+                    for (int i=0; i<Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections; i++)
+                    {
+                        if (Sockets[targetAlignmentIP].AlignementAntenne->tsl[i] != 0.0)
+                        {
+                            Azimut( Sockets[targetAlignmentIP].AlignementAntenne->ad[i]
+                                    - Sockets[targetAlignmentIP].AlignementAntenne->tsl[i] + GetTSL(),
+                                    Sockets[targetAlignmentIP].AlignementAntenne->de[i], &a, &b);
+                            os << a << ",";
+                            os << b << ",";
+
+                            Azimut( Sockets[targetAlignmentIP].AlignementAntenne->delta_ad[i]
+                                    - Sockets[targetAlignmentIP].AlignementAntenne->tsl[i] + GetTSL(),
+                                    Sockets[targetAlignmentIP].AlignementAntenne->delta_de[i]
+                                    , &a, &b);
+
+                            os << a << ",";
+                            os << b << ",";
+                        }
+                    }
+
+                    os << "/";
+
+                    for (int i=0; i<Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections; i++)
+                    {
+                        if (Sockets[targetAlignmentIP].AlignementAntenne->tsl[i] != 0.0 && Sockets[targetAlignmentIP].AlignementAntenne->Matrice_ok)
+                        {
+                            Azimut( Sockets[targetAlignmentIP].AlignementAntenne->ad[i]
+                                    - Sockets[targetAlignmentIP].AlignementAntenne->tsl[i] + GetTSL(),
+                                    Sockets[targetAlignmentIP].AlignementAntenne->de[i], &a, &b);
+
+                            Coord vect, r;
+
+                            if (Sockets[targetAlignmentIP].AlignementAntenne->MethodeAlignement == SIMPLE)
+                            {
+                                vect.x = cos(a) * cos(b);
+                                vect.y = sin(a) * cos(b);
+                                vect.z = sin(b);
+
+
+                                // Application de la matrice SIMPLE
+
+                                Sockets[targetAlignmentIP].AlignementAntenne->AppliquerMatriceCorrectionSimple(&r, vect);
+
+
+                                // Là on doit repasser des coordonnées rectangulaires
+                                // aux coordonnées sphériques
+
+                                if (r.x != 0.0)
+                                {
+                                    a = atan( r.y / r.x );
+
+                                    if (r.x < 0) a += Pi;
+                                }
+                                else a = Pidiv2;
+
+                                b = asin(r.z);
+                            }
+                            else
+                            {
+                                double c, d;
+
+                                Sockets[targetAlignmentIP].AlignementAntenne->AzHa2XY(a, b, &c, &d);
+                                vect.x = c;
+                                vect.y = d;
+                                vect.z = 1.0;
+
+                                AfficherLog("az=%5.2f ha=%5.2f x=%5.2f y=%5.2f\n", a, b, c, d);
+                                // Application de la matrice SIMPLE
+
+                                Sockets[targetAlignmentIP].AlignementAntenne->AppliquerMatriceCorrectionAffine(&r, vect);
+
+
+                                AfficherLog("r.x=%5.2f r.y=%5.2f d=%5.2f\n", r.x, r.y,sqrt(r.x*r.x+r.y*r.y));
+                                a = atan(r.y/r.x);
+                                if (r.x < 0) a += Pi;
+
+                                b= Pidiv2-(sqrt(r.x*r.x+r.y*r.y));
+                            }
+
+
+                            os << a << ",";
+                            os << b << ",";
+                        }
+                    }
+
+
+
+
+                    IDSetText(&CommandTP, os.str().c_str() );
+
+                    return;
                 }
             }
@@ -699 +968 @@
             targetDEC = newDEC;
 
+            // Réinitialisation des deltas
+
+            delta_az = 0;
+            delta_ha = 0;
+
+            if (targetAlignmentIP != -1 && Sockets[targetAlignmentIP].AlignementAntenne->AlignementEnCours != 0)
+            {
+                Sockets[targetAlignmentIP].AlignementAntenne->delta_ad[Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections] =
+                    targetRA * 15.0 * Pidiv180;
+
+                Sockets[targetAlignmentIP].AlignementAntenne->delta_de[Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections] =
+                    targetDEC * Pidiv180;
+            }
+            
+            for (int i=0; i<SocketsNumber; i++) if (Sockets[i].Connected)
+            {
+              if ( Sockets[i].AlignementAntenne->AlignementEnCours == 0 )
+              {
+                Sockets[i].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
+              }
+            }
+                
+              
+
             // on les affiche dans les logs
 
@@ -873 +1166 @@
         return;
 
+
+
+    double az, ha, ad, de;
+
+    ad = targetRA * 15.0 * Pidiv180;
+
+    de = targetDEC * Pidiv180;
+
+    CalculTSL();
+
+    Azimut(ad, de, &az, &ha);
+
+    ha = RefractionAtmospherique(ha) ;
+
+
+
+
     // ===================================
     // Connect Switch
@@ -916 +1226 @@
         MethodeAlignement = get_switch_index(&AlignmentSP) + 1 ;
 
-        /*char chaine[100];
-        sprintf(chaine, "****************************************** %i\n", MethodeAlignement);
-        AfficherLog(chaine);*/
-
         AlignmentSP.s = IPS_OK;
+        IUResetSwitch(&AlignmentSP);
         IDSetSwitch(&AlignmentSP, NULL);
 
@@ -943 +1250 @@
 
     // ===================================
+    // Alignment Speed
+    // ===================================
+    if (!strcmp(name, RaquetteNP.name))
+    {
+        if (IUUpdateSwitch(&RaquetteNP, states, names, n) < 0)
+            return;
+
+        RaquetteNP.s = IPS_OK;
+
+        switch (get_switch_index(&RaquetteNP))
+        {
+        case 0 :
+            IUResetSwitch(&RaquetteNP);
+            IDSetSwitch(&RaquetteNP, "La vitesse de la raquette est fixee a 1x");
+            VitesseRaquette = 1;
+            break;
+        case 1 :
+            IUResetSwitch(&RaquetteNP);
+            IDSetSwitch(&RaquetteNP, "La vitesse de la raquette est fixee a 10x");
+            VitesseRaquette = 10;
+            break;
+        }
+
+        return;
+    }
+
+    // ===================================
+    // Alignment Reset
+    // ===================================
+    if (!strcmp(name, AlignementResetP.name))
+    {
+        if (IUUpdateSwitch(&AlignementResetP, states, names, n) < 0)
+            return;
+
+        if ( targetAlignmentIP < 0 )
+        {
+            AlignementResetP.s = IPS_ALERT;
+            IDSetSwitch(&AlignementResetP, "Veuillez indiquer l adresse IP de l antenne a calibrer");
+
+            return;
+        }
+
+        AlignementResetP.s = IPS_OK;
+        IDSetSwitch(&AlignementResetP, "Les parametres de l alignement de l antenne ont ete reinitialises");
+
+        Sockets[targetAlignmentIP].AlignementAntenne->InitAlignement();
+
+        sleep(1);
+
+        Sockets[targetAlignmentIP].AlignementAntenne->EnregistrementParametresAlignement(
+            Sockets[targetAlignmentIP].IP,
+            "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg");
+
+
+        IUResetSwitch(&AlignementResetP);
+        AlignementResetP.s = IPS_IDLE;
+        IDSetSwitch(&AlignementResetP, NULL);
+
+        return;
+    }
+
+
+
+    // ===================================
+    // Alignment buttons
+    // ===================================
+    if (!strcmp(name, AlignementAltpP.name))
+    {
+        if (IUUpdateSwitch(&AlignementAltpP, states, names, n) < 0)
+            return;
+
+        delta_ha += VitesseRaquette;
+
+        az  = VerifAngle(az + (double)delta_az * PasDeltaAz);
+
+        ha += (double)delta_ha * PasDeltaHa;
+
+        //   ISPoll();
+
+        AlignementAltpP.s = IPS_IDLE;
+
+        IDSetSwitch(&AlignementAltpP, "Delta en azimut = %s  delta en hauteur = %s  az = %s  ha = %s (Vitesse raquette = %d)\n",
+                    DHMS(delta_az * PasDeltaAz, false).c_str(),
+                    DHMS(delta_ha * PasDeltaHa, false).c_str(),
+                    DHMS(az * N180divPi, false).c_str(),
+                    DHMS(ha * N180divPi, false).c_str(),
+                    VitesseRaquette);
+        IUResetSwitch(&AlignementAltpP);
+
+        return;
+    }
+
+    if (!strcmp(name, AlignementAltnP.name))
+    {
+        if (IUUpdateSwitch(&AlignementAltnP, states, names, n) < 0)
+            return;
+
+        delta_ha -= VitesseRaquette;
+
+        az  = VerifAngle(az + (double)delta_az * PasDeltaAz);
+
+        ha += (double)delta_ha * PasDeltaHa;
+
+        //   ISPoll();
+
+        AlignementAltnP.s = IPS_IDLE;
+
+        IDSetSwitch(&AlignementAltnP, "Delta en azimut = %s  delta en hauteur = %s  az = %s  ha = %s (Vitesse raquette = %d)\n",
+                    DHMS(delta_az * PasDeltaAz, false).c_str(),
+                    DHMS(delta_ha * PasDeltaHa, false).c_str(),
+                    DHMS(az * N180divPi, false).c_str(),
+                    DHMS(ha * N180divPi, false).c_str(),
+                    VitesseRaquette);
+        IUResetSwitch(&AlignementAltnP);
+
+        return;
+    }
+
+    if (!strcmp(name, AlignementAzP.name))
+    {
+        if (IUUpdateSwitch(&AlignementAzP, states, names, n) < 0)
+            return;
+
+        switch (get_switch_index(&AlignementAzP))
+        {
+        case 0 :
+            delta_az -= VitesseRaquette;
+            break;
+        case 1 :
+            delta_az += VitesseRaquette;
+            break;
+        }
+
+        az  = VerifAngle(az + (double)delta_az * PasDeltaAz);
+
+        ha += (double)delta_ha * PasDeltaHa;
+
+        // ISPoll();
+
+        AlignementAzP.s = IPS_IDLE;
+
+        IDSetSwitch(&AlignementAzP, "Delta en azimut = %s  delta en hauteur = %s  az = %s  ha = %s (Vitesse raquette = %d)\n",
+                    DHMS(delta_az * PasDeltaAz, false).c_str(),
+                    DHMS(delta_ha * PasDeltaHa, false).c_str(),
+                    DHMS(az * N180divPi, false).c_str(),
+                    DHMS(ha * N180divPi, false).c_str(),
+                    VitesseRaquette);
+        IUResetSwitch(&AlignementAzP);
+
+        return;
+    }
+
+    if (!strcmp(name, AlignementOkP.name))
+    {
+        if (IUUpdateSwitch(&AlignementOkP, states, names, n) < 0)
+            return;
+
+        if ( targetAlignmentIP < 0 )
+        {
+            AlignementOkP.s = IPS_ALERT;
+            IDSetSwitch(&AlignementOkP, "Veuillez indiquer l adresse IP de l antenne a calibrer");
+
+            return;
+        }
+
+        AlignementOkP.s = IPS_OK;
+        IDSetSwitch(&AlignementOkP, NULL);
+
+        switch (get_switch_index(&AlignementOkP))
+        {
+            // Validation de l'alignement en cours...
+
+        case 0 :
+        {
+            float a, b, c;
+            double az, ha, ad, de, ad2, de2;
+
+            int num;
+
+            num = Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections;
+
+            ad = targetRA * 15.0 * Pidiv180;
+
+            Sockets[targetAlignmentIP].AlignementAntenne->ad[num] = ad;
+
+            de = targetDEC * Pidiv180;
+
+            Sockets[targetAlignmentIP].AlignementAntenne->de[num] = de;
+
+            CalculTSL();
+
+            Sockets[targetAlignmentIP].AlignementAntenne->tsl[num] = GetTSL();
+
+            Azimut(ad, de, &az, &ha);
+
+            //ha = RefractionAtmospherique(ha) ;
+
+            az  = VerifAngle(az + (double)delta_az * PasDeltaAz);
+
+            ha += (double)delta_ha * PasDeltaHa;
+
+            AzHa2ADDe(az, ha, &ad2, &de2);
+
+
+            Sockets[targetAlignmentIP].AlignementAntenne->delta_ad[num] = ad2;
+
+            Sockets[targetAlignmentIP].AlignementAntenne->delta_de[num] = de2;
+
+            stringstream os;
+
+            AfficherLog("Alignement de l antenne %s avec l objet situe en RA %s - DEC %s\n",
+                        Sockets[targetAlignmentIP].IP.c_str(),
+                        DHMS(targetRA * 15.0, true).c_str(),
+                        DHMS(targetDEC, false     ).c_str());
+
+            AfficherLog("ad1=%s de1=%s ad2=%s de2=%s\n",
+                        DHMS(ad  * N180divPi, true ).c_str(),
+                        DHMS(de  * N180divPi, false).c_str(),
+                        DHMS(ad2 * N180divPi, true ).c_str(),
+                        DHMS(de2 * N180divPi, false).c_str());
+
+            AfficherLog("delta_az=%s delta_ha=%s\n",
+                        DHMS(delta_az * PasDeltaAz, false).c_str(),
+                        DHMS(delta_ha * PasDeltaHa, false).c_str());
+
+            Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections++;
+
+            delta_az = 0;
+            delta_ha = 0;
+
+            IDSetSwitch(&AlignementOkP, "Les parametres de l alignement ont ete valides");
+
+        }
+        break;
+
+        // Sauvegarde de l'alignement en cours...
+
+        case 1 :
+        {
+            if  (Sockets[targetAlignmentIP].AlignementAntenne->nbrcorrections >=3 )
+            {
+                // IDLog("Calcul matrice\n", true);
+                Sockets[targetAlignmentIP].AlignementAntenne->AlignementEnCours = 0;
+                Sockets[targetAlignmentIP].AlignementAntenne->CalculerMatriceCorrection(targetRA, targetDEC);
+            }
+            else
+            {
+                Sockets[targetAlignmentIP].AlignementAntenne->Identity();
+
+                Sockets[targetAlignmentIP].AlignementAntenne->Matrice_ok = false;
+            }
+
+            IDSetSwitch(&AlignementOkP, "Les parametres de l alignement ont ete sauvegardes");
+
+            Sockets[targetAlignmentIP].AlignementAntenne->EnregistrementParametresAlignement(
+                Sockets[targetAlignmentIP].IP,
+                "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg");
+        }
+        break;
+        }
+
+
+        AlignementOkP.s = IPS_IDLE;
+        IUResetSwitch(&AlignementOkP);
+        IDSetSwitch(&AlignementOkP, NULL);
+
+        return;
+    }
+
+
+    // ===================================
     // Abort slew
     // ===================================
@@ -1089 +1667 @@
 
 
-
 /************************************************************************************
 ** Cette procédure, aprÚs avoir appliqué la matrice de rotation aux coordonnées de l'objet
@@ -1128 +1705 @@
                 // On est bien dans le cas de l'alignement AFFINE ou Taki
 
-                if (Sockets[i].AlignementAntenne->MethodeAlignement ==  AFFINE ||
-                        Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI)
-                {
-                    // On crée un vecteur avec pour coordonnées
-                    // x = Angle horaire de l'objet visé
-                    // y = déclinaison de l'objet
-                    // z = 1.0
-                    // Voir la documentation pour plus d'explications sur le calcul affine/taki
-
-                    vect.x = VerifAngle( newRA2 - GetTSL() );
-                    vect.y = newDEC2;
-                    vect.z = 1.0;
-
-                    // Message pour l'utilisateur et les logs
-
-                    AfficherLog("Application de la matrice AFFINE/TAKI\nCoordonnees initiales: AD = %s  Dec = %s\n", DHMS(newRA2*N180divPi, true ).c_str(),
-                                DHMS(newDEC2*N180divPi, false ).c_str());
-
-                    // On applique la matrice de transformation
-
-                    switch (Sockets[i].AlignementAntenne->MethodeAlignement)
-                    {
-                    case AFFINE :
-                        Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionAffine(&result, vect);
-                        break;
-                    case TAKI   :
-                        Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionTaki( &result, vect);
-                        break;
-                    }
-
-                    // On récupÚre les nouvelles coordonnées. z ne nous intéresse pas
-
-                    newRA  = VerifAngle(result.x + GetTSL());
-                    newDEC = result.y;
-
-                    AfficherLog("Coordonnees finales: AD = %s  Dec = %s\n", DHMS(newRA*N180divPi, true ).c_str(),
-                                DHMS(newDEC*N180divPi, false ).c_str());
-                }
+                /* if ( Sockets[i].AlignementAntenne->MethodeAlignement ==  AFFINE ||
+                         Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI )
+                 {
+                     // On crée un vecteur avec pour coordonnées
+                     // x = Angle horaire de l'objet visé
+                     // y = déclinaison de l'objet
+                     // z = 1.0
+                     // Voir la documentation pour plus d'explications sur le calcul affine/taki
+
+                     vect.x = VerifAngle( newRA2 + GetTSL() );
+                     vect.y = newDEC2;
+                     vect.z = 1.0;
+
+                     // Message pour l'utilisateur et les logs
+
+                     AfficherLog("Application de la matrice AFFINE/TAKI\n", true);
+                     AfficherLog("Coordonnees initiales: AD = %s  Dec = %s\n", DHMS(newRA2*N180divPi, true ).c_str(),
+                                 DHMS(newDEC2*N180divPi, false ).c_str());
+
+                     // On applique la matrice de transformation
+
+                     switch (Sockets[i].AlignementAntenne->MethodeAlignement)
+                     {
+                     case AFFINE :
+                         Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionAffine(&result, vect);
+                         break;
+                     case TAKI   :
+                         Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionTaki( &result, vect);
+                         break;
+                     }
+
+                     // On récupÚre les nouvelles coordonnées. z ne nous intéresse pas
+
+                     newRA  = VerifAngle(result.x - GetTSL());
+                     newDEC = result.y;
+
+                     AfficherLog("Coordonnees finales: AD = %s  Dec = %s\n", DHMS(newRA*N180divPi, true ).c_str(),
+                                 DHMS(newDEC*N180divPi, false ).c_str());
+                 }*/
             }
             else
             {
-                if (Sockets[i].AlignementAntenne->AlignementEnCours)
+                if (Sockets[i].AlignementAntenne->AlignementEnCours != 0)
                 {
                     // Si la matrice n'est pas prête, c'est que la procédure d'alignement de l'antenne i n'est pas encore achevée.
@@ -1177 +1755 @@
                     // entre les deux programmes
 
-                    newRA  = VerifAngle(newRA2  + Sockets[i].AlignementAntenne->delta_ad[Sockets[i].AlignementAntenne->nbrcorrections] * PasDeltaAD);
-                    newDEC = newDEC2 + Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections] * PasDeltaDe;
-
-                    AfficherLog("Alignement en cours.\nDelta RA=%i  delta Dec=%i\n", Sockets[i].AlignementAntenne->delta_ad[Sockets[i].AlignementAntenne->nbrcorrections], Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections]);
-                    AfficherLog("Nouvelles Coordonnées AD =%s  Dec = %s\n", DHMS(newRA*N180divPi, true).c_str(), DHMS(newDEC*N180divPi, false).c_str());
+                    newRA  = Sockets[i].AlignementAntenne->delta_ad[Sockets[i].AlignementAntenne->nbrcorrections];
+                    newDEC = Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections];
+
+                    AfficherLog("Alignement en cours.\n", true);
+
+                    AfficherLog("Nouvelles Coordonnées AD =%s  Dec = %s    Ncorrections=%i\n",
+                                DHMS(newRA*N180divPi, true).c_str(),
+                                DHMS(newDEC*N180divPi, false).c_str(),Sockets[i].AlignementAntenne->nbrcorrections);
                 }
             }
@@ -1193 +1774 @@
             // avons vu plus haut
 
-            if  (Sockets[i].AlignementAntenne->Matrice_ok && Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE)
+            if  (Sockets[i].AlignementAntenne->Matrice_ok /*&& Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE*/)
             {
                 // AprÚs s'être assurer que nous utilisons la méthode SIMPLE et que la matrice de rotation est ok
 
-                AfficherLog("Application de la matrice SIMPLE\nCoordonnees initiales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
+                AfficherLog("Application de la matrice SIMPLE\n", true);
+                AfficherLog("Coordonnees initiales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
                             DHMS(targetAlt*N180divPi, false ).c_str());
 
@@ -1206 +1788 @@
                 // On reconnaît les formules de passage des coordonnées
                 // sphériques aux coordonnées rectangulaires
-
-
-                vect.x = cos(targetAz) * cos(targetAlt);
-                vect.y = sin(targetAz) * cos(targetAlt);
-                vect.z = sin(targetAlt);
-
-
-                // Application de la matrice SIMPLE
-
-                Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionSimple(&result, vect);
-
-
-                // Là on doit repasser des coordonnées rectangulaires
-                // aux coordonnées sphériques
-
-                if (result.x != 0.0)
+                if (Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE)
                 {
-                    targetAz = atan( result.y / result.x );
-
+                    vect.x = cos(targetAz) * cos(targetAlt);
+                    vect.y = sin(targetAz) * cos(targetAlt);
+                    vect.z = sin(targetAlt);
+
+                    Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionSimple(&result, vect);
+
+
+                    // Là on doit repasser des coordonnées rectangulaires
+                    // aux coordonnées sphériques
+
+                    if (result.x != 0.0)
+                    {
+                        targetAz = atan( result.y / result.x );
+
+                        if (result.x < 0) targetAz += Pi;
+                    }
+                    else targetAz = Pidiv2;
+
+                    targetAz  = VerifAngle(targetAz);
+
+                    targetAlt = asin(result.z);
+
+                }
+                else
+                {
+                    Sockets[i].AlignementAntenne->AzHa2XY(targetAz, targetAlt, &vect.x, &vect.y);
+
+                    vect.z = 1.0;
+      
+
+             
+                    Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionAffine(&result, vect);
+
+                    // Là on doit repasser des coordonnées rectangulaires
+                    // aux coordonnées sphériques
+
+
+
+                    targetAz = atan(result.y/result.x);
                     if (result.x < 0) targetAz += Pi;
+
+                    targetAlt= Pidiv2 - sqrt(result.x*result.x+result.y*result.y);
+
+
+                    AfficherLog("Coordonnees finales: Azi = %s  Haut = %s\n", DHMS(VerifAngle(targetAz)*N180divPi, false ).c_str(),
+                                DHMS(targetAlt*N180divPi, false ).c_str());
                 }
-                else targetAz = Pidiv2;
-
-                targetAz  = VerifAngle(targetAz);
-
-                targetAlt = asin(result.z);
-
-
-                AfficherLog("Coordonnees finales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
-                            DHMS(targetAlt*N180divPi, false ).c_str());
             }
 
@@ -1242 +1843 @@
             // Ne s'applique que pour les alignements AFFINE et TAKI
 
-            if (Sockets[i].AlignementAntenne->MethodeAlignement != SIMPLE) targetAz += Sockets[i].AlignementAntenne->delta_az_polar * PasDeltaAD;
+            //if (Sockets[i].AlignementAntenne->MethodeAlignement != SIMPLE) targetAz += Sockets[i].AlignementAntenne->delta_az_polar * PasDeltaAD;
 
             // Correction de la réfraction atmosphérique
@@ -1267 +1868 @@
             // Conversion des deux angles en pas codeurs
 
-            /*  if ( targetAlt < HAUTMIN )
-              {
-                  // L'objet est trop bas ( < 30°). On annule le suivi...
-
-                  IDSetSwitch(&OnCoordSetSP, "Erreur ! L objet suivi est situe a moins de 30 deg au-dessus de l horizon. Goto annule.");
-
-                  Suivi = false;
-
-                  RealisationGoto = false;
-
-                  InitAntennes();
-
-                  return;
-              }
-              else*/
+            if ( targetAlt < HAUTMIN )
+            {
+                // L'objet est trop bas ( < 30°). On annule le suivi...
+
+                IDSetSwitch(&OnCoordSetSP, "Erreur ! L objet suivi est situe a moins de 30 deg au-dessus de l horizon. Goto annule.");
+
+                Suivi = false;
+
+                RealisationGoto = false;
+
+                InitAntennes();
+
+                return;
+            }
+            else
             {
                 // Si la hauteur est supérieure à 90°, on doit ajouter 180° à l'azimut et corriger
@@ -1296 +1897 @@
                 // On applique la formule de Marc pour convertir la hauteur en nombre de pas codeur alt
 
-                Sockets[i].TargetPosition.y = (int) Arrondi( Alt2Motor( targetAlt ) );
+                Sockets[i].TargetPosition.y = (long int) Arrondi( Alt2Motor( targetAlt ) );
 
                 //4000 pas pour 360° sur l'axe az
 
-                Sockets[i].TargetPosition.x = (int) Arrondi( targetAz * (double)NBREPASCODEURSAZ / 360.0);
+                Sockets[i].TargetPosition.x = (long int) Arrondi( targetAz * (double)NBREPASCODEURSAZ / 360.0);
+
+                // On ajoute les deltas en AZ et en HA pour la raquette hors procédure d'alignement
+
+                Sockets[i].TargetPosition.x += delta_az;
+                Sockets[i].TargetPosition.y += delta_ha;
+
+
+                // est-ce que le transit de l'objet suivi va nous emmener à sortir de l'intervalle [MINAZCODEURS..MAXAZCODEURS] ?
+
+                if ( azmincodeur < MINAZCODEURS ) Sockets[i].TargetPosition.x += NBREPASCODEURSAZ;
+
+                if ( azmincodeur > MAXAZCODEURS ) Sockets[i].TargetPosition.x -= NBREPASCODEURSAZ;
+
+                // Corrections sup pour rester dans l'intervalle [-1693.. 3867]
+
+                if ( Sockets[i].TargetPosition.x > MAXAZCODEURS ) Sockets[i].TargetPosition.x -= NBREPASCODEURSAZ;
+
+                if ( Sockets[i].TargetPosition.x < MINAZCODEURS ) Sockets[i].TargetPosition.x += NBREPASCODEURSAZ;
 
                 // Message de debug
@@ -1395 +2014 @@
         // On charge les paramÚtres de correction des antennes toutes les demi-secondes
 
+        /*
         if ( compt%500 == 0  && tv.tv_usec/1.0E6 > 0.5 )
-        {
-            for (int i=1; i<SocketsNumber; i++)
-            {
-                if (Sockets[i].Connected)
+            {
+                for (int i=1; i<SocketsNumber; i++)
                 {
-                    // Si l'antenne i est connectée, on charge les paramÚtres
-                    Sockets[i].AlignementAntenne->TransmettreParametresClasseAstro(Annee, Mois, Jour, Heu, Min, Sec, Longitude, Latitude, Pression, Temp);
-
-                    if (Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE )
+                    if (Sockets[i].Connected)
                     {
-                        //AfficherLog("chargement simple\n");
-                        Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesSIMPLE.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
-                    }
-                    else
-                    {
+                        // Si l'antenne i est connectée, on charge les paramÚtres
+                        Sockets[i].AlignementAntenne->TransmettreParametresClasseAstro(Annee, Mois, Jour, Heu, Min, Sec, Longitude, Latitude, Pression, Temp);
+
                         // AfficherLog("chargement taki\n");
-                        Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesTAKI.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
+                        //  Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
                     }
                 }
-            }
-        }
+            }*/
     }
 
@@ -1434 +2046 @@
             IDSetSwitch(&ConnectSP, "Connexion de l antenne %s (Antennes connectees : %i)",
                         Sockets[SocketsNumber-1].IP.c_str(), AntennesConnectees());
+
+            Sockets[SocketsNumber-1].AlignementAntenne->TransmettreParametresClasseAstro(GetAnnee(), GetMois(), GetJour(), GetHeure(), GetMin(), GetSec(), GetLongitude(), GetLatitude(), GetPression(), GetTemperature());
+
+
+            // Chargement des paramÚtres d'alignement de l'antenne
+
+            Sockets[SocketsNumber-1].AlignementAntenne->ChargementParametresAlignement(
+                Sockets[SocketsNumber-1].IP,
+                "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg",
+                targetRA * 15 * Pidiv180,
+                targetDEC * Pidiv180);
+
         }
 
@@ -2217 +2841 @@
         IDSetSwitch (&ParkSP, NULL);
 
+        // On cherche l'azimut de l'objet lorsque celui-ci passera en-dessous de 30°
+        // Cette recherche est nécessaire pour optimiser le suivi et éviter
+        // les rotations inutiles
+
+        RechercheAzimutFinSuivi(targetRA, targetDEC, &azmincodeur, &azmaxcodeur);
+
         // On prépare les antennes pour le prochain goto
 
@@ -2260 +2890 @@
         IDSetSwitch (&AbortSlewSP, NULL);
         IDSetSwitch (&ParkSP, NULL);
+
+        // On cherche l'azimut de l'objet lorsque celui-ci passera en-dessous de 30°
+        // Cette recherche est nécessaire pour optimiser le suivi et éviter
+        // les rotations inutiles
+
+        RechercheAzimutFinSuivi(targetRA, targetDEC, &azmincodeur, &azmaxcodeur);
 
         InitAntennes();

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

@@ -152 +152 @@
     
     void AfficherLog(const char* Message,...);
+    
+    
+  
+    
 
 
@@ -164 +168 @@
     ISwitch OnCoordSetS[2];
     ISwitch AlignmentS[3];
+    ISwitch AlignementAltp[1];
+    ISwitch AlignementAz[2];
+    ISwitch AlignementAltn[1]; 
+    ISwitch AlignementOk[2];
+    ISwitch RaquetteN[2];
+    ISwitch AlignementReset[1];
     ISwitch AbortSlewS[1];
     ISwitch ParkS[1];
@@ -171 +181 @@
     IText ObjectT[1];
     IText CommandT[1];
+    IText AlignementIP[1];
 
     /* Numbers */
@@ -178 +189 @@
     INumber ActualisationN1[1];
     INumber ActualisationN2[1];
+    
 
     /* Switch Vectors */
@@ -183 +195 @@
     ISwitchVectorProperty OnCoordSetSP;
     ISwitchVectorProperty AlignmentSP;
+    ISwitchVectorProperty AlignementAltpP;
+    ISwitchVectorProperty AlignementAzP;
+    ISwitchVectorProperty AlignementAltnP; 
+    ISwitchVectorProperty AlignementOkP;
+    ISwitchVectorProperty AlignementResetP;
+    ISwitchVectorProperty RaquetteNP;
     ISwitchVectorProperty AbortSlewSP;
     ISwitchVectorProperty ParkSP;
@@ -192 +210 @@
     INumberVectorProperty ActualisationNP1;
     INumberVectorProperty ActualisationNP2;
-
-
+    
     /* Text Vectors */
     ITextVectorProperty PortTP;
     ITextVectorProperty ObjectTP;
     ITextVectorProperty CommandTP;
+    ITextVectorProperty AlignementIPP;
 
 
@@ -229 +247 @@
     int    MethodeAlignement;            // Méthode d'alignement
     BAO_STATUS  TrackingMode;            // Mode de suivi actuellement activé
+    
+    long int azmincodeur;
+    long int azmaxcodeur;  
+    
+    int    targetAlignmentIP;
+    
+    long int VitesseRaquette;
+    long int delta_az;
+    long int delta_ha;
+    
+    
 };
 

BAORadio/libindi/libindi/result_recherche_bao

@@ -1 @@
-
-
-Results from query to  NASA/IPAC Extragalactic Database (NED),
-which is operated by the Jet Propulsion Laboratory, California Institute of
-Technology, under contract with the National Aeronautics and Space Administration.
-This work was (partially) supported by the US National Virtual Observatory
-development project, which is funded by the National Science Foundation
-under cooperative agreement AST0122449 with The Johns Hopkins University.
-
-
-
-queryDateTime:2012-04-02T02:43:18PDT
-
-
-
-Main Information Table for MESSIER 031
-
-
-
-Equinox:J2000.0
-
-
-
-CoordSystem:Equatorial
-
-No.|Object Name|RA(deg)|DEC(deg)|Type|Velocity|Redshift|Redshift Flag|Magnitude and Filter|Distance (arcmin)|References|Notes|Photometry Points|Positions|Redshift Points|Diameter Points|Associations
-1|MESSIER 031| 10.68479 |  41.26906 |G|  -300|-0.001001 |    | 4.36||3374|18|138|8|26|7|2
+<PARAM name="Error" >
+<VALUE><![CDATA[Messages:
+ 
+    The object name that you submitted is not currently recognized
+    by the NED name interpreter.
+ 
+    In general, naming conventions employ a prefix (usually an
+    acronym for the first author(s) or the survey name) followed
+    by a numerical string based on a tabular sequence or a position
+    on the sky. For more specifics, see the document at
+    http://vizier.u-strasbg.fr/Dic/iau-spec.htx
+ 
+    Based on your input, we have listed below a number of
+    possibilities that NED does recognize that reasonably may
+    include your object/survey and its standardized naming
+    convention in NED.
+ 
+ 
+Use this format                    for this catalogue
+---------------                    ----------------
+   MAFFEI 2:[TH94] NN              Objects from 1994ApJ...421..122T
+or MESSIER 051:[TH94] NN
+or MESSIER 083:[TH94] NN
+or NGC NNNN:[TH94] NN
+   [T95] J0240-343A                Objects from 1995MNRAS.277..609T
+or [T95] 11
+   TOLOLO NNNNN                    Tololo catalogue
+   MS 1358.4+6245:[T98] GN         Objects from 1998AJ....115....1T
+or [YDG81] 1115+080:[T98] Gx
+or [PBW92] B1422+231:[T98] Gx
+   TON NNNN                        Tonantzintla catalogue
+   [T99] GJHHMM-DDMM               Objects from 1999MNRAS.303..565T
+or [T99] QJHHMM-DDMM
+   [TH2001] A                      Objects from 2001ApJ...563..673T
+   [T99a] NN                       Objects from 1999A&A...352L.103T
+   [TH2002] NNN                    Objects from 2002MNRAS.333..423T
+   NGC 0253:[TH85] N               Objects from 1985ApJ...299L..77T
+   NGC 0253:[T2004] A              Objects from 2004AJ....127...10T
+   HDF:[T2003] NNNN                Objects from 2003ApJ...596..748T
+   NGC 6822:[T2006] ANN            Objects from 2006AJ....132.1372T
+ 
+   SN 1995:[T97]                   Object  from 1997A&A...321...81T
+Key:  A = alphabetic character
+   :  a = optional alphabetic character
+   :  B = Besselian 1950 designator
+   :  b = galactic latitude
+   : DD = degrees of Declination or day of month
+   :  d = decimal degrees of Declination
+   :  F = field/plate name
+   :  G = galaxy OR galactic coordinates designator
+   : HH = hours of Right Ascension
+   :  h = decimal hours of Right Ascension
+   :  J = Julian 2000 designator
+   :  L = galactic longitude
+   :  l = galactic longitude
+   : MM = minutes of R.A. or time or arcminutes of Dec. or month
+   :  m = decimal minutes of R.A. or time or arcminutes of Dec.
+   :  N = numeric character
+   : SS = seconds of R.A. or time or arcseconds of Dec.
+   :  s = decimal seconds of R.A. or time or arcseconds of Dec.
+   : YY = year (2-digit years imply 20th Century except Gamma-ray bursters)
+   :  Z = integer part of redshift
+   : zz = decimal portion of redshift
+   :  + = plus OR minus sign
+   :  - = dash OR minus sign
+ 
+]]></VALUE>
+</PARAM>