Index: /BAORadio/libindi/libindi/BAOTest/BAOtest_main.cpp
===================================================================
--- /BAORadio/libindi/libindi/BAOTest/BAOtest_main.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/BAOTest/BAOtest_main.cpp	(revision 677)
@@ -12,5 +12,5 @@
 #include <stdio.h>
 #include <stdlib.h>
-#include <net/if.h>
+#include <net/if.h> 
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -114,5 +114,5 @@
         return atoi(str2.c_str());
     }
-
+  
     return -1;
 }
Index: ORadio/libindi/libindi/Indi_Stellarium/src/ClientSocket.cpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/ClientSocket.cpp	(revision 676)
+++ 	(revision )
@@ -1,64 +1,0 @@
-// Implementation of the ClientSocket class
-
-#include "ClientSocket.h"
-#include "SocketException.h"
-
-
-#include <iostream>
-#include <string>
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-
-ClientSocket::ClientSocket ( std::string host, int port )
-{
-  if ( ! socketdef::create() )
-    {
-      throw SocketException ( "Could not create client socket." );
-    }
-
-  if ( ! socketdef::connect ( host, port ) )
-    {
-      throw SocketException ( "Could not bind to port." );
-    }
-}
-
-
-const ClientSocket& ClientSocket::operator << ( const std::string& s ) const
-{
-  if ( ! socketdef::send ( s ) )
-    {
-     // throw SocketException ( "Could not write to socket." );
-    }
-
-  return *this;
-
-}
-
-
-const ClientSocket& ClientSocket::operator >> ( std::string& s ) const
-{
-  if ( ! socketdef::recv ( s ) )
-    {
-    //   throw SocketException ( "Could not read from socket." );
-    }
-
-  return *this;
-}
-
-
-void ClientSocket::recv( std::string& s ) 
-{
-  if ( ! socketdef::recv ( s ) )
-    {
-      sleep(1);
-
-      if (! socketdef::shutdown() ) std::cout << "shutdown impossible.\n";
-
-      if (! socketdef::create() ) std::cout << "create impossible.\n";
-
-      if (! socketdef::connect((std::string)"192.168.0.1", 8000)) { std::cout << "connect impossible.\n"; socketdef::shutdown(); } else {   std::cout << "Reconnexion reussie.\n"; }
-    }
-}
-
Index: ORadio/libindi/libindi/Indi_Stellarium/src/ClientSocket.h
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/ClientSocket.h	(revision 676)
+++ 	(revision )
@@ -1,28 +1,0 @@
-// Definition of the ClientSocket class
-
-#ifndef ClientSocket_class
-#define ClientSocket_class
-
-#include "socket.h"
-
-struct Position
-{
-   int x;
-   int y;
-};
-
-class ClientSocket : private socketdef
-{
- public:
-
-  ClientSocket ( std::string host, int port );
-  virtual ~ClientSocket(){};
-
-  const ClientSocket& operator << ( const std::string& ) const;
-  const ClientSocket& operator >> ( std::string& ) const;
-
-void recv( std::string& s ); 
-};
-
-
-#endif
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.cpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.cpp	(revision 677)
@@ -88,5 +88,5 @@
 #endif
 
-Connection::Connection(Server &server, SOCKET fd) : Socket(server, fd)
+Connection::Connection(Server2 &server, SOCKET fd) : Socket2(server, fd)
 {
 	read_buff_end = read_buff;
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.hpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.hpp	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/Connection.hpp	(revision 677)
@@ -26,11 +26,11 @@
 #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
 	{
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/Listener.hpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Listener.hpp	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/Listener.hpp	(revision 677)
@@ -26,5 +26,5 @@
 #define _LISTENER_HPP_
 
-#include "Socket.hpp"
+#include "Socket2.hpp"
 
 //! Listens for connection attempts and adds new connections to the server.
@@ -34,9 +34,9 @@
 //! 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) {}
 	
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/Makefile
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Makefile	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/Makefile	(revision 677)
@@ -12,6 +12,6 @@
 
 
-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,5 +44,12 @@
 
 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 $@
 
 
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/Server.cpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Server.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/Server.cpp	(revision 677)
@@ -24,8 +24,8 @@
 
 #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,14 +33,14 @@
 		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,5 +52,5 @@
 }
 
-void Server::step(long long int timeout_micros)
+void Server2::step(long long int timeout_micros)
 {
 	fd_set read_fds, write_fds;
@@ -93,5 +93,5 @@
 }
 
-void Server::closeAcceptedConnections(void)
+void Server2::closeAcceptedConnections(void)
 {
 	for (SocketList::iterator it(socket_list.begin());
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/Server.hpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Server.hpp	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/Server.hpp	(revision 677)
@@ -29,5 +29,5 @@
 using namespace std;
 
-class Socket;
+class Socket2;
 
 //! Base class for telescope server classes. A true telescope server class
@@ -43,10 +43,10 @@
 //! 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,5 +58,5 @@
 	//! 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,5 +71,5 @@
 	friend class Connection;
 	
-	class SocketList : public list<Socket*>
+	class SocketList : public list<Socket2*>
 	{
 		public:
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.cpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.cpp	(revision 677)
@@ -24,10 +24,10 @@
 
 #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,99 +37,142 @@
 
 
-        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,5 +218,5 @@
 
 	
-	Server::step(timeout_micros);
+	Server2::step(timeout_micros);
 }
 
@@ -449,62 +492,77 @@
 {
     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,5 +572,5 @@
             }
 
-            // 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,18 +578,18 @@
             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,5 +603,5 @@
 ***************************************************************************************/
 
-bool ServerDummy::VerifReponse(string reponseattendue)
+bool ServerDummy::VerifReponse(string reponseattendue, string *retourreponse)
 {
     string reponse = "";
@@ -552,10 +610,13 @@
     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,5 +628,5 @@
             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,20 +642,35 @@
     }
 
+
     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,8 +723,9 @@
 
 
-
-
 /**************************************************************************************
 ** 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,6 +733,5 @@
 {
     // 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,7 +746,7 @@
         *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,9 +758,10 @@
     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,7 +769,198 @@
 
 
+/**************************************************************************************
+** 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,7 +975,7 @@
         *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,9 +984,10 @@
     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,4 +998,5 @@
 /**************************************************************************************
 ** Annule le mouvement en cours
+**
 ***************************************************************************************/
 
@@ -741,7 +1011,7 @@
         *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,9 +1020,10 @@
     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,43 +1031,323 @@
 
 
-
-/**************************************************************************************
-** 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,19 +1364,8 @@
     // 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,17 +1375,15 @@
         *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,7 +1399,7 @@
         *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,17 +1408,18 @@
     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,6 +1430,5 @@
         *client_socket << "<newSwitchVector device=\"BAO\" name=\"CONNECTION\">";
 
-        if (connect) *client_socket << "<oneSwitch name=\"CONNECT\">";
-        else *client_socket << "<oneSwitch name=\"DISCONNECT\">";
+        (connect) ? *client_socket << "<oneSwitch name=\"CONNECT\">" : *client_socket << "<oneSwitch name=\"DISCONNECT\">";
 
         *client_socket << "On";
@@ -900,7 +1438,7 @@
         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,7 +1447,7 @@
         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,5 +1458,6 @@
     catch ( SocketException& e )
     {
-        Erreur("Exception was caught:" + e.description() + "\n");
+        ErreurLog("Exception was caught:" + e.description() + "\n");
+
         return false;
     }
@@ -926,18 +1465,27 @@
     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,5 +1609,5 @@
 bool ServerDummy::ChargementParametres(string fileName)
 {
-    string section;
+     string section;
     string key;
     char * value;
@@ -1067,10 +1615,14 @@
 
 
-
-    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,10 +1634,11 @@
     {
         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,10 +1651,11 @@
     {
         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,13 +1672,16 @@
     {
         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,10 +1690,11 @@
     {
         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,12 +1711,13 @@
     {
         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,14 +1727,53 @@
     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,10 +1788,11 @@
     {
         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,12 +1804,13 @@
     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,12 +1821,13 @@
     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,10 +1844,10 @@
     {
         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,2 +1857,29 @@
 
 
+
+/**************************************************************************************
+** 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);
+}
+
+
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.hpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.hpp	(revision 676)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/ServerBAO.hpp	(revision 677)
@@ -30,12 +30,14 @@
 #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,49 +46,49 @@
 
 
-// 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,5 +96,5 @@
 //! 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,14 +110,28 @@
         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,42 +142,47 @@
 	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
 };
 
Index: ORadio/libindi/libindi/Indi_Stellarium/src/Socket.cpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Socket.cpp	(revision 676)
+++ 	(revision )
@@ -1,58 +1,0 @@
-/*
-The stellarium telescope library helps building
-telescope server programs, that can communicate with stellarium
-by means of the stellarium TCP telescope protocol.
-It also contains smaple server classes (dummy, Meade LX200).
-
-Author and Copyright of this file and of the stellarium telescope library:
-Johannes Gajdosik, 2006
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Lesser General Public
-License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-#include "Socket.hpp"
-
-#ifdef WIN32
-  #include <windows.h> // GetSystemTimeAsFileTime
-#else
-  #include <sys/time.h>
-#endif
-
-long long int GetNow(void)
-{
-#ifdef WIN32
-	union
-	{
-		FILETIME file_time;
-		__int64 t;
-	} tmp;
-	GetSystemTimeAsFileTime(&tmp.file_time);
-	return (tmp.t/10) - 86400000000LL*(369*365+89);
-#else
-	struct timeval tv;
-	gettimeofday(&tv, 0);
-	return tv.tv_sec * 1000000LL + tv.tv_usec;
-#endif
-}
-
-void Socket::hangup(void)
-{
-	if (!IS_INVALID_SOCKET(fd))
-	{
-		close(fd);
-		fd = INVALID_SOCKET;
-	}
-}
-
Index: ORadio/libindi/libindi/Indi_Stellarium/src/Socket.hpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Socket.hpp	(revision 676)
+++ 	(revision )
@@ -1,121 +1,0 @@
-/*
-The stellarium telescope library helps building
-telescope server programs, that can communicate with stellarium
-by means of the stellarium TCP telescope protocol.
-It also contains smaple server classes (dummy, Meade LX200).
-
-Author and Copyright of this file and of the stellarium telescope library:
-Johannes Gajdosik, 2006
-
-This library is free software; you can redistribute it and/or
-modify it under the terms of the GNU Lesser General Public
-License as published by the Free Software Foundation; either
-version 2.1 of the License, or (at your option) any later version.
-
-This library is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public
-License along with this library; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
-*/
-
-#ifndef _SOCKET_HPP_
-#define _SOCKET_HPP_
-
-#ifdef WIN32
-
-#include <winsock2.h>
-#include <fcntl.h>
-
-#define ERRNO WSAGetLastError()
-#undef EAGAIN
-#define EAGAIN WSAEWOULDBLOCK
-#undef EINTR
-#define EINTR WSAEINTR
-#undef ECONNRESET
-#define ECONNRESET WSAECONNRESET
-static inline int SetNonblocking(int s)
-{
-	u_long arg = 1;
-	return ioctlsocket(s, FIONBIO, &arg);
-}
-#define SETNONBLOCK(s) SetNonblocking(s)
-#define SOCKLEN_T int
-#define close closesocket
-#define IS_INVALID_SOCKET(fd) (fd==INVALID_SOCKET)
-#define STRERROR(x) x
-//  #define DEBUG5
-
-#else
-
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/socket.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <errno.h>
-#include <string.h> // strerror
-#define ERRNO errno
-#define SETNONBLOCK(s) fcntl(s,F_SETFL,O_NONBLOCK)
-#define SOCKLEN_T socklen_t
-#define SOCKET int
-#define IS_INVALID_SOCKET(fd) (fd<0)
-#define INVALID_SOCKET (-1)
-#define STRERROR(x) strerror(x)
-
-#endif //WIN32
-
-long long int GetNow(void);
-
-class Server;
-
-class Socket
-{
-public:
-	virtual ~Socket(void) { hangup(); }
-	void hangup(void);
-	virtual void prepareSelectFds(fd_set &read_fds, fd_set &write_fds, int &fd_max) = 0;
-	virtual void handleSelectFds(const fd_set &read_fds, const fd_set &write_fds) = 0;
-	virtual bool isClosed(void) const
-	{
-		return IS_INVALID_SOCKET(fd);
-	}
-	virtual bool isTcpConnection(void) const { return false; }
-	virtual void sendPosition(unsigned int ra_int, int dec_int, int status) {}
-	
-protected:
-	Socket(Server &server, SOCKET fd) : server(server), fd(fd) {}
-	Server & server;
-	
-#ifdef WIN32
-	virtual int readNonblocking(char *buf, int count)
-	{
-		return recv(fd, buf, count, 0);
-	}
-	virtual int writeNonblocking(const char *buf, int count)
-	{
-		return send(fd, buf, count, 0);
-	}
-#else
-	int readNonblocking(void *buf, int count)
-	{
-		return read(fd, buf, count);
-	}
-	int writeNonblocking(const void *buf, int count) {
-		return write(fd, buf, count);
-	}
-#endif
-
-protected:
-	SOCKET fd;
-	
-private:
-	// no copying
-	Socket(const Socket&);
-	const Socket &operator=(const Socket&);
-};
-
-#endif
Index: /BAORadio/libindi/libindi/Indi_Stellarium/src/Socket2.hpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/Socket2.hpp	(revision 677)
+++ /BAORadio/libindi/libindi/Indi_Stellarium/src/Socket2.hpp	(revision 677)
@@ -0,0 +1,121 @@
+/*
+The stellarium telescope library helps building
+telescope server programs, that can communicate with stellarium
+by means of the stellarium TCP telescope protocol.
+It also contains smaple server classes (dummy, Meade LX200).
+
+Author and Copyright of this file and of the stellarium telescope library:
+Johannes Gajdosik, 2006
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef _SOCKET_HPP_
+#define _SOCKET_HPP_
+
+#ifdef WIN32
+
+#include <winsock2.h>
+#include <fcntl.h>
+
+#define ERRNO WSAGetLastError()
+#undef EAGAIN
+#define EAGAIN WSAEWOULDBLOCK
+#undef EINTR
+#define EINTR WSAEINTR
+#undef ECONNRESET
+#define ECONNRESET WSAECONNRESET
+static inline int SetNonblocking(int s)
+{
+	u_long arg = 1;
+	return ioctlsocket(s, FIONBIO, &arg);
+}
+#define SETNONBLOCK(s) SetNonblocking(s)
+#define SOCKLEN_T int
+#define close closesocket
+#define IS_INVALID_SOCKET(fd) (fd==INVALID_SOCKET)
+#define STRERROR(x) x
+//  #define DEBUG5
+
+#else
+
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h> // strerror
+#define ERRNO errno
+#define SETNONBLOCK(s) fcntl(s,F_SETFL,O_NONBLOCK)
+#define SOCKLEN_T socklen_t
+#define SOCKET int
+#define IS_INVALID_SOCKET(fd) (fd<0)
+#define INVALID_SOCKET (-1)
+#define STRERROR(x) strerror(x)
+
+#endif //WIN32
+
+long long int GetNow(void);
+
+class Server2;
+
+class Socket2
+{
+public:
+	virtual ~Socket2(void) { hangup(); }
+	void hangup(void);
+	virtual void prepareSelectFds(fd_set &read_fds, fd_set &write_fds, int &fd_max) = 0;
+	virtual void handleSelectFds(const fd_set &read_fds, const fd_set &write_fds) = 0;
+	virtual bool isClosed(void) const
+	{
+		return IS_INVALID_SOCKET(fd);
+	}
+	virtual bool isTcpConnection(void) const { return false; }
+	virtual void sendPosition(unsigned int ra_int, int dec_int, int status) {}
+	
+protected:
+	Socket2(Server2 &server, SOCKET fd) : server(server), fd(fd) {}
+	Server2 & server;
+	
+#ifdef WIN32
+	virtual int readNonblocking(char *buf, int count)
+	{
+		return recv(fd, buf, count, 0);
+	}
+	virtual int writeNonblocking(const char *buf, int count)
+	{
+		return send(fd, buf, count, 0);
+	}
+#else
+	int readNonblocking(void *buf, int count)
+	{
+		return read(fd, buf, count);
+	}
+	int writeNonblocking(const void *buf, int count) {
+		return write(fd, buf, count);
+	}
+#endif
+
+protected:
+	SOCKET fd;
+	
+private:
+	// no copying
+	Socket2(const Socket2&);
+	const Socket2 &operator=(const Socket2&);
+};
+
+#endif
Index: ORadio/libindi/libindi/Indi_Stellarium/src/SocketException.h
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/SocketException.h	(revision 676)
+++ 	(revision )
@@ -1,23 +1,0 @@
-// SocketException class
-
-
-#ifndef SocketException_class
-#define SocketException_class
-
-#include <string>
-
-class SocketException
-{
- public:
-  SocketException ( std::string s ) : m_s ( s ) {};
-  ~SocketException (){};
-
-  std::string description() { return m_s; }
-
- private:
-
-  std::string m_s;
-
-};
-
-#endif
Index: ORadio/libindi/libindi/Indi_Stellarium/src/exception.c
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/exception.c	(revision 676)
+++ 	(revision )
@@ -1,36 +1,0 @@
-/* exception.c */
-/* fonctions de manipulation de la pile */
-
-#include "exception.h"
-
-except *_exceptions = NULL;
-
-/* empile */
-
-void push_exc(){
-  except* layer;
-  layer = (except*) malloc(sizeof(except));
-  if(layer == NULL){
-    fprintf(stderr,"[push_exc()]Erreur d'allocation memoire pour la pile");
-  }
-  layer->super = _exceptions;
-  _exceptions = layer;
-}
-
-/* depile */
-
-void pop_exc(int ex){
-  except* super;
-  super = _exceptions->super;
-  free(_exceptions);
-  _exceptions = super;
-  if(ex){
-    if(_exceptions){
-      longjmp(_exceptions->ctx, ex);
-    }
-    else{
-      fprintf(stderr, "Exception non geree : %d\n", ex);
-      exit(-1);
-    }
-  }
-}
Index: ORadio/libindi/libindi/Indi_Stellarium/src/exception.h
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/exception.h	(revision 676)
+++ 	(revision )
@@ -1,54 +1,0 @@
-/* exception.h */
-#include <stdio.h>
-#include <stdlib.h>
-#include <setjmp.h>
-
-#ifndef __EXCEPTION__
-#define __EXCEPTION__  1
-
-/* exceptions de base */
-
-#define ERR_MALLOC     10
-#define NULL_POINTEUR  11
-#define ERR_FOPEN      12
-
-/*prototypes*/
-
-/* definition des structures de donnees de gestion de la pile des contextes 
-   et des macros TRY, CATCH, et ENDTRY */
-
-
-/* liste chainee des contextes */
-typedef struct except_ctx 
-{
-  jmp_buf ctx;
-  struct except_ctx* super;
-} except;
-extern except* _exceptions;
-
-/* les macros */
-#define TRY { \
-  int exc; \
-  push_exc(); \
-  exc = setjmp(_exceptions->ctx); \
-  switch(exc){ \
-  case 0:
-
-#define CATCH(X) \
-  break; \
-  case(X): \
-  exc = 0;
-
-#define ENDTRY \
-  break; \
-  default: \
-  pop_exc(exc); }\
-  }
-
-#define THROW(X) longjmp(_exceptions->ctx, X)
-
-
-void push_exc();
-void pop_exc(int);
-
-#endif
Index: ORadio/libindi/libindi/Indi_Stellarium/src/filetools.cpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/filetools.cpp	(revision 676)
+++ 	(revision )
@@ -1,1115 +1,0 @@
-/*filetools.c*/
-
-#include "filetools.h"
-
-#define MAX_LENGHT 255
-
-
-
-/******************************************************
- * NOM:              readINI                          *
- * SPECIFICATION:                                     *
- *   retourne la valeur de la cle du                  *
- *               fichier dont la structure est celle  *
- *               d'un fichier .ini windows            *
- * ARGUMENTS:                                         *
- * >section: le nom de la section sans les crochets   *
- * >key: nom de la cle de la section                  *
- * >pStr: pointeur pour mettre le resultat            *
- *       allocation memoire effectuee                 *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:0 si echec 1 si oui               *
- ******************************************************/
-int
-readINI (char *sectionName, char *pKeyName, char **ppStr, char *fileName)
-{
-    INI *pIni = NULL;
-    SECTION *pSection = NULL;
-    KEY *pKey = NULL;
-    int trouve = 0;
-    char *pSectionName = NULL;
-    int offset = 0;
- 
-
-    trouve = 0;
-    pIni = _loadINI (fileName);
-    if (!pIni) return 0;
-
-    /*recherche de la section */
-    offset = strlen (sectionName) + 3;
-    pSectionName = new char [offset];
-    pSectionName[0] = '[';
-    strcpy (pSectionName + 1, sectionName);
-    pSectionName[strlen (sectionName) + 1] = ']';
-    pSectionName[offset - 1]='\0';
-
-    pSection = _findSECTION (pIni, pSectionName);
-
-    delete [] pSectionName;
-
-    if (pSection != NULL)
-    {
-        /*recherche de la cle */
-        pKey = _findKEY (pSection, pKeyName);
-        if (pKey != NULL)
-        {
-            *ppStr = new char [strlen (pKey->value) + 2];
-            strcpy (*ppStr, pKey->value);
-            (*ppStr)[strlen (pKey->value)] = '\0';
-            trouve = 1;
-
-        }
-    }
-
-    //On efface toutes les clÃ©s et toutes les sections
-
-    KEY *keyprev=NULL;
-    SECTION * secprev=NULL;
-    pSection=pIni->fils;
-
-    do
-    {
-        pKey=pSection->fils;
-
-        do
-        {
-            if (pKey->name) delete [] pKey->name;
-            if (pKey->value) delete [] pKey->value;
-
-            keyprev=pKey;
-
-            KEY *prev=pKey;
-            pKey=pKey->next;
-
-            delete prev;
-
-
-        } while (pKey!=keyprev);
- 
-        if (pSection->name) delete []pSection->name;
-
-        secprev=pSection;
-
-        SECTION *sprev=pSection;
-        pSection=pSection->next;
-
-        delete sprev;
-
-    }  while (pSection!=secprev);
-
-
-
-    delete [] pIni->fileName;
-    delete pIni;
-    pIni=NULL;
-
-    return trouve;
-}
-
-int
-readINI (const char *sectionName, const char *pKeyName, char **ppStr, const char *fileName)
-{
-     return readINI((char*)sectionName, (char*)pKeyName, ppStr, (char*)fileName);
-}
-
-/******************************************************
- * NOM:                delINI                         *
- * SPECIFICATION:                                     *
- *  seule la cle de la section est supprimee          *
- *  si la section est vide, elle est supprimee        *
- * ARGUMENTS:                                         *
- * >section: le nom de la section sans les crochets   *
- * >key: nom de la cle de la section                  *
- * >pStr: pointeur pour mettre la valeur de la cle    *
- *       avant sa suppression                         *
- *       allocation memoire effectuee                 *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * 1 si reussite de la suppression, 0 sinon           *
- ******************************************************/
-/*
-int
-delINI (char *sectionName, char *pKeyName, char **ppStr, char *fileName)
-{
-  INI *pIni = NULL;
-  SECTION *pSection = NULL;
-  KEY *pKey = NULL;
-  int del = 0;
-  char *pSectionName = NULL;
-  int offset = 0;
-  //pStr = resultValue;
-  TRY
-  {
-
-    pIni = _loadINI (fileName);
-    //recherche de la section
-    offset = strlen (sectionName) + 3;
-    pSectionName = (char *) m_malloc (sizeof (char) * offset);
-    pSectionName[0] = '[';
-    strcpy (pSectionName + 1, sectionName);
-    pSectionName[strlen (sectionName) + 1] = ']';
-    pSectionName[offset - 1];
-
-    pSection = _findSECTION (pIni, pSectionName);
-
-    if (pSection != NULL)
-      {
-	if (pKeyName == NULL)
-	  {
-	    //on supprime toute la section
-
-	    pKey = _lastKEY (pSection);
-	    while (pKey != NULL)
-	      {
-		_delKEY (pKey);
-		pKey = _lastKEY (pSection);
-	      }
-	    _delSECTION (pSection);
-	    del = 1;
-	  }
-	else
-	  {
-	    //recherche de la cle si indiquee
-	    pKey = _findKEY (pSection, pKeyName);
-	    if (pKey != NULL)
-	      {
-		(*ppStr) =
-		  (char *) m_malloc (sizeof (char) * strlen (pKey->value) +
-				     2);
-		strcpy (*ppStr, pKey->value);
-		(*ppStr)[strlen (pKey->value)] = '\0';
-		if (_delKEY (pKey))
-		  {
-		    //si la cle supprimee etait la derniere de la section
-		    _delSECTION (pSection);
-		  }
-		del = 1;
-	      }
-	  }
-      }
-    if (del)
-      {
-	_saveINI (pIni);
-      }
-  }
-  CATCH (ERR_FOPEN)
-  {
-    printf ("impossible d'ouvrir le fichier %s\n", fileName);
-    (*ppStr) = NULL;
-  }
-  CATCH (ERR_MALLOC)
-  {
-    perror ("Probleme d'allocation memoire");
-    exit (EXIT_FAILURE);
-  }
-  ENDTRY;
-
-  return del;
-}
-*/
-/******************************************************
- * NOM:                writeINI                       *
- * SPECIFICATION:                                     *
- *  si la section n'existe pas elle est cree          *
- *  si la cle n'existe pas elle est cree              *
- *  et la valeur de la cle est initialisee            *
- *  sinon la cle existante de la section existante est*
- *  mise a jour                                       *
- * ARGUMENTS:                                         *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- *  NULL si echec ou keyValue si reussite             *
- ******************************************************/
-
-/*
-
-char * writeINI (char *sectionName, char *keyName, char *keyValue, char *fileName)
-{
-  char *pSectionName = NULL;
-  char *pKeyName = NULL;
-  char *pKeyValue = NULL;
-  INI *pIni = NULL;
-  SECTION *pSection = NULL;
-  KEY *pKey = NULL;
-  TRY
-  {
-    pKeyName = (char *) m_malloc (sizeof (char) * strlen (keyName) + 1);
-    pSectionName =
-      (char *) m_malloc (sizeof (char) * strlen (sectionName) + 3);
-    if (keyValue != NULL)
-      {
-	pKeyValue = (char *) m_malloc (sizeof (char) * strlen (keyValue) + 1);
-	strcpy (pKeyValue, keyValue);
-	pKeyValue[strlen (keyValue)] = '\0';
-      }
-    else
-      {
-	pKeyValue = (char *) m_malloc (sizeof (char));
-	pKeyValue[0] = '\0';
-      }
-    strcpy (pKeyName, keyName);
-    pSectionName[0] = '[';
-    strcpy (pSectionName + 1, sectionName);
-    pSectionName[strlen (sectionName) + 1] = ']';
-    pSectionName[strlen (sectionName) + 2] = '\0';
-    //chargement
-    pIni = _loadINI (fileName);
-
-  }
-  CATCH (ERR_FOPEN)
-  {
-    printf ("Erreur en ouvrant le fichier .ini:%s\n", fileName);
-    exit (EXIT_FAILURE);
-  }
-  CATCH (ERR_MALLOC)
-  {
-    perror ("Probleme d'allocation memoire");
-    exit (EXIT_FAILURE);
-  }
-  ENDTRY;
-
-  //recherche de la section
-  pSection = _findSECTION (pIni, pSectionName);
-  //recherche de la cle
-  if (pSection != NULL)
-    {
-      pKey = _findKEY (pSection, pKeyName);
-      if (pKey != NULL)
-	{
-	  pKey->value =
-	    (char *) realloc (pKey->value,
-			      sizeof (char) * strlen (pKeyName) + 1);
-	  if (pKey->value == NULL)
-	    {
-	      perror ("probleme de reallocation memoire");
-	      exit (EXIT_FAILURE);
-	    }
-	  strcpy (pKey->value, pKeyValue);
-	}
-      else
-	{
-	  //cle pas trouve dans la section, on ajoute la cle a la section
-	  pKey = _newKEY (pKeyName, pKeyValue);
-	  _addKEY (pSection, pKey);
-	}
-    }
-  else
-    {
-      //section pas trouve, on la cree avec sa cle
-      pSection = _newSECTION (pSectionName);
-      _addSECTION (pIni, pSection);
-      pKey = _newKEY (pKeyName, pKeyValue);
-      _addKEY (pSection, pKey);
-
-    }
-  TRY
-  {
-
-    //sauvegarde
-    _saveINI (pIni);
-
-  }
-  CATCH (ERR_FOPEN)
-  {
-    printf ("erruer sur le fichier %s", pIni->fileName);
-  }
-  ENDTRY;
-
-  //nettoyage
-
-  free (pIni);
-  free (pSection);
-  free (pKey);
-  free (pKeyName);
-  free (pSectionName);
-  pIni = NULL;
-  pKeyName = NULL;
-  pSectionName = NULL;
-  return pKeyValue;
-}
-*/
-
-/******************************************************
- * NOM:                                               *
- *                 _delKEY                            *
- * SPECIFICATION:                                     *
- * ARGUMENTS:                                         *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- *  1 si derniere cellule, 0 sinon, -1 si probleme    *
- ******************************************************/
-int
-_delKEY (KEY * pKey)
-{
-    int result = 0;
-    if (pKey != NULL)
-    {
-        /*la cle n'est pas la premiere */
-        if (pKey->prev != pKey)
-        {
-            if (pKey->next != pKey)
-            {
-                /*la cle n'est pas la derniere */
-                pKey->prev->next = pKey->next;
-            }
-            else
-            {
-                result = 1;
-                pKey->prev->next = pKey->prev;
-            }
-        }
-        else
-        {
-            if (pKey->next != pKey)
-            {
-                /*la cle n'est pas non plus la derniere */
-                pKey->parent->fils = pKey->next;
-            }
-            else
-            {
-                result = 1;
-                pKey->parent->fils = NULL;
-            }
-        }
-        _freeKEY (pKey);
-        return result;
-    }
-    else
-    {
-        result = -1;
-        return result;
-    }
-}
-
-
-/******************************************************
- * NOM:                                               *
- *                 _delSECTION                        *
- * SPECIFICATION:                                     *
- * ARGUMENTS:                                         *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- *  pointeur sur la section                           *
- ******************************************************/
-int
-_delSECTION (SECTION * pSection)
-{
-    if (pSection != NULL)
-    {
-        /*la cle n'est pas la premiere */
-        if (pSection->prev != pSection)
-        {
-            /*la cle n'est pas la derniere */
-            if (pSection->next != pSection)
-            {
-                pSection->prev->next = pSection->next;
-            }
-            else
-            {
-                pSection->prev->next = pSection->prev;
-            }
-        }
-        else
-        {
-            /*la cle n'estpas nonplus la derniere */
-            if (pSection->next != pSection)
-            {
-                pSection->parent->fils = pSection->next;
-                pSection->next->prev = pSection->next;
-            }
-            else
-            {
-                pSection->parent->fils = NULL;
-            }
-        }
-        _freeSECTION (pSection);
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-/************************
- * liberation memoire   *
- ************************/
-void
-_freeKEY (KEY * pKey)
-{
-    if (pKey != NULL)
-    {
-        pKey->parent = NULL;
-        pKey->next = NULL;
-        pKey->prev = NULL;
-        if (pKey->value != NULL)
-        {
-            delete [] pKey->value;
-        }
-        if (pKey->name != NULL)
-        {
-            delete [] pKey->name;
-        }
-        delete pKey;
-
-        pKey=NULL;
-    }
-}
-void
-_freeSECTION (SECTION * pSection)
-{
-    if (pSection != NULL)
-    {
-        pSection->parent = NULL;
-        pSection->next = NULL;
-        pSection->prev = NULL;
-        if (pSection->name != NULL)
-        {
-            delete [] pSection->name;
-        }
-        delete pSection;
-
-        pSection=NULL;
-    }
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _newKEY                            *
- * SPECIFICATION:                                     *
- *  allocation d'une nouvelle cle                     *
- * ARGUMENTS:                                         *
- * le nom et la valeur de la cle                      *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la cle, NULL sinon                    *
- ******************************************************/
-KEY *
-_newKEY (char *pKeyName, char *pKeyValue)
-{
-    KEY *pKey;
-
-    {
-        pKey = new KEY;
-
-        pKey->name = new char [strlen (pKeyName) + 1];
-        pKey->value = new char [strlen (pKeyValue) + 1];
-    }
-
-
-    strcpy (pKey->name, pKeyName);
-    strcpy (pKey->value, pKeyValue);
-    pKey->parent = NULL;
-    pKey->prev = pKey;
-    pKey->next = pKey;
-
-    return pKey;
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _newSECTION                        *
- * SPECIFICATION:                                     *
- *  allocation d'une nouvelle section                 *
- * ARGUMENTS:                                         *
- * le nom de la section                               *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la section, NULL sinon                *
- ******************************************************/
-SECTION *
-_newSECTION (char *pSectionName)
-{
-    SECTION *pSection;
-
-    {
-        pSection = new SECTION;
-
-        pSection->name = new char [strlen (pSectionName) + 1];
-    }
-
-
-    strcpy (pSection->name, pSectionName);
-    pSection->parent = NULL;
-    pSection->fils = NULL;
-    pSection->prev = pSection;
-    pSection->next = pSection;
-
-    return pSection;
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _findSECTION                       *
- * SPECIFICATION:                                     *
- *  trouver la section dans une struture INI          *
- * ARGUMENTS:                                         *
- * la structure INI, le nom de la section avec ses [ ]*
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la section, NULL sinon                *
- ******************************************************/
-SECTION *
-_findSECTION (INI * pIni, char *pSectionName)
-{
-    SECTION *pSection = NULL;
-    pSection = pIni->fils;
-    while ((pSection != NULL) && (strcmp (pSection->name, pSectionName) != 0))
-    {
-        if (pSection == pSection->next)
-        {
-            pSection = NULL;
-        }
-        else
-        {
-            pSection = pSection->next;
-        }
-    }
-    return pSection;
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _findKEY                           *
- * SPECIFICATION:                                     *
- *  trouver la cle dans une struture SECTION          *
- * ARGUMENTS:                                         *
- * la structure SECTION, le nom de la cle             *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la cle, NULL sinon                    *
- ******************************************************/
-KEY *
-_findKEY (SECTION * pSection, char *pKeyName)
-{
-    KEY *pKey = NULL;
-    pKey = pSection->fils;
-    while ((pKey != NULL) && (strcmp (pKey->name, pKeyName) != 0))
-    {
-        if (pKey == pKey->next)
-        {
-            pKey = NULL;
-        }
-        else
-        {
-            pKey = pKey->next;
-        }
-    }
-    return pKey;
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _lastKEY                           *
- * SPECIFICATION:                                     *
- *  trouver la derniere cle dans une struture SECTION *
- * ARGUMENTS:                                         *
- * la structure SECTION                               *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la cle, NULL sinon                    *
- ******************************************************/
-KEY *
-_lastKEY (SECTION * pSection)
-{
-    KEY *pKey_pred = NULL;
-    KEY *pKey = NULL;
-    pKey = pSection->fils;
-    pKey_pred = pKey;
-    while (pKey != NULL)
-    {
-        pKey_pred = pKey;
-        if (pKey == pKey->next)
-        {
-            pKey = NULL;
-        }
-        else
-        {
-            pKey = pKey->next;
-        }
-    }
-    return pKey_pred;
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _lastSECTION                       *
- * SPECIFICATION:                                     *
- *  trouver la derniere section dans une INI          *
- * ARGUMENTS:                                         *
- * la structure INI                                   *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la section, NULL sinon                *
- ******************************************************/
-SECTION *
-_lastSECTION (INI * pIni)
-{
-    SECTION *pSection_pred = NULL;
-    SECTION *pSection = NULL;
-    pSection = pIni->fils;
-    pSection_pred = pSection;
-    while (pSection != NULL)
-    {
-        pSection_pred = pSection;
-        if (pSection == pSection->next)
-        {
-            pSection = NULL;
-        }
-        else
-        {
-            pSection = pSection->next;
-        }
-    }
-    return pSection_pred;
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _addSECTION                        *
- * SPECIFICATION:                                     *
- *  ajoute une section en derniere place dans une INI *
- *  la section ne doit pas appartenir a une INI       *
- * ARGUMENTS:                                         *
- * la structure INI, la structure SECTION             *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la section, NULL sinon                *
- ******************************************************/
-SECTION *
-_addSECTION (INI * pIni, SECTION * pSection)
-{
-    SECTION *pSection_last = NULL;
-
-    if (pSection->parent != NULL)
-    {
-        return NULL;
-    }
-    else
-    {
-        pSection_last = _lastSECTION (pIni);
-        pSection->parent = pIni;
-        if (pSection_last != NULL)
-        {
-            pSection_last->next = pSection;
-            pSection->prev = pSection_last;
-        }
-        else
-        {
-            pIni->fils = pSection;
-        }
-        return pSection;
-    }
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _addKEY                            *
- * SPECIFICATION:                                     *
- *  ajoute une cle en derniere place dans une SECTION *
- *  la section ne doit pas appartenir a une SECTION   *
- * ARGUMENTS:                                         *
- * la structure KEY, la structure SECTION             *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * pointeur sur la cle, NULL sinon                *
- ******************************************************/
-KEY *
-_addKEY (SECTION * pSection, KEY * pKey)
-{
-    KEY *pKey_last = NULL;
-
-    if (pKey->parent != NULL)
-    {
-        return NULL;
-    }
-    else
-    {
-
-        pKey_last = _lastKEY (pSection);
-        pKey->parent = pSection;
-        if (pKey_last != NULL)
-        {
-            pKey_last->next = pKey;
-            pKey->prev = pKey_last;
-        }
-        else
-        {
-            pSection->fils = pKey;
-        }
-        pKey->next = pKey;
-        return pKey;
-    }
-}
-
-/******************************************************
- * NOM:                                               *
- *                 saveINI                            *
- * SPECIFICATION:                                     *
- *  sauvegarde de la structure INI dans son fichier   *
- *  Attention, ecrase l'ancien fichier                *
-* ARGUMENTS:                                         *
-*  pointeur sur la structure INI a sauvegarder       *
-* ENVIRONNEMENT:                                     *
-* VALEUR RETOURNEE:                                  *
-*  -1 si un probleme a eu lieu, 0 sinon              *
-******************************************************/
-
-/*
- * int
-_saveINI (INI * pIni)
-{
-  FILE *pFile = NULL;
-  char *str = NULL;
-  SECTION *pSection_pred = NULL, *pSection = NULL;
-  KEY *pKey_pred = NULL, *pKey = NULL;
-  int offset = 0;
-
-  pFile = fopen (pIni->fileName, "w");
-  if (pFile == NULL)
-    THROW (ERR_FOPEN);
-  //printf("#SAUVEGARDE Fichier INI#\n");
-  //printf("# %s #\n\n",pIni->fileName);
-  if (pIni->fils != NULL)
-    {
-      pSection = pIni->fils;
-      do
-	{
-
-	  fprintf (pFile, pSection->name);
-	  fprintf (pFile, "\n");
-	  pKey = pSection->fils;
-	  do
-	    {
-
-	      offset = strlen (pKey->name) + strlen (pKey->value) + 2;
-
-	      TRY
-	      {
-		str = (char *) m_malloc (sizeof (char) * offset);
-	      }
-	      CATCH (ERR_MALLOC)
-	      {
-		perror ("probleme d'allocation memoire");
-		exit (EXIT_FAILURE);
-	      }
-	      ENDTRY;
-	      memset (str, 0, offset);
-	      strcpy (str, pKey->name);
-	      offset = strlen (pKey->name);
-	      strcpy (str + offset, "=");
-	      offset = strlen (pKey->name) + 1;
-	      strcpy (str + offset, pKey->value);
-	      fprintf (pFile, str);
-	      fprintf (pFile, "\n");
-	      pKey_pred = pKey;
-	      pKey = pKey->next;
-	      free (str);
-	    }
-	  while (pKey != pKey_pred);
-
-	  pSection_pred = pSection;
-	  pSection = pSection->next;
-	}
-      while (pSection != pSection_pred);
-    }
-  //nettoyage
-  fclose (pFile);
-}*/
-
-/******************************************************
- * NOM:                                               *
- *                  loadINI                           *
- * SPECIFICATION:                                     *
- *  Charge le contenu d'un fichier .ini en memoire    *
- * ARGUMENTS:                                         *
- *  nom du fichier                                    *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- *  pointeur sur la structure INI contenant le fichier*
- *  .ini avec les structures decrites dans le .h      *
- * EXCEPTION:                                         *
- * ERR_FOPEN, ERR_MALLOC
- ******************************************************/
-INI *
-_loadINI (char *fileName)
-{
-    FILE *pFile = NULL;
-    char *pBuf;
-    int nbRead = 0;
-    SECTION *pSection = NULL;
-    KEY *pKey = NULL;
-
-    INI *pIni = NULL;
-    pBuf = new char [MAX_LENGHT];
-
-    pFile = fopen (fileName, "r");
-    if (pFile == NULL)
-    {
-        pFile = fopen (fileName, "a");
-        if (pFile == NULL)
-            
-        return NULL;
-    }
-
-    pIni = new INI;
-    pIni->fileName = new char [strlen (fileName) + 1];
-    strcpy (pIni->fileName, fileName);
-    pIni->fils = NULL;
-    /* on lit ligne par ligne */
-    nbRead = readline (pFile, pBuf);
-    if (nbRead==-1) { fclose(pFile); delete  [] pIni->fileName; delete pIni; delete [] pBuf; return 0;}
-    while (nbRead != -1)
-    {
-
-        if ((pBuf[0] == '[') && (pBuf[strlen (pBuf) - 1] == ']'))
-        {
-            /* une section */
-            pSection = NULL;
-
-            pSection = _newSECTION (pBuf);
-            _addSECTION (pIni, pSection);
-        }
-
-        /* les cles de la section */
-        while (((nbRead = readline (pFile, pBuf)) !=-1) && (pBuf[0] != '['))
-        {
-            int ind = 0;
-            pKey = NULL;
-            if ((ind = _isKey (pBuf)) >= 0)
-            {
-
-                char *strName = NULL;
-                strName = new char [ind + 1];
-                strncpy (strName, pBuf, ind);
-                strName[ind] = '\0';
-                pKey = _newKEY (strName, pBuf + ind + 1);
-                _addKEY (pSection, pKey);
-                delete [] strName;
-            }
-        }
-    }
-
-    /*nettoyage */
-    delete [] pBuf;
-    fclose (pFile);
-    return pIni;
-}
-
-/******************************************************
- * NOM:                                               *
- *                 _isKey                             *
- * SPECIFICATION:                                     *
- *  determine si une chaine est une cle valide        *
- * ARGUMENTS:                                         *
- *  pointeur sur la chaine                            *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- *  indice du signe '=' si oui, -1 sinon              *
- ******************************************************/
-int
-_isKey (char *str)
-{
-    int ind = 0;
-    for (ind=0; ind < (int)strlen (str); ind++)
-    {
-    if (str[ind] == '=')
-        return ind;
-    }
-    return -1;
-}
-
-
-/******************************************************
- * NOM:                                               *
- *                  _printINI                         *
- * SPECIFICATION:                                     *
- * affiche a l'ecran le contenu de structure INI      *
- * ARGUMENTS:                                         *
- *  pointeur sur la structure INI                     *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- ******************************************************/
-/*void
-_printINI (INI * pIni)
-{
-  SECTION *pSection_pred = NULL;
-  SECTION *pSection = NULL;
-  printf ("#Fichier INI#\n");
-  printf ("# %s #\n\n", pIni->fileName);
-  pSection = pIni->fils;
-  if (pSection != NULL)
-    {
-      do
-	{
-	  _printSECTION (pSection);
-	  pSection_pred = pSection;
-	  pSection = pSection->next;
-	}
-      while (pSection != pSection_pred);
-    }
-  printf ("\n#Fin du fichier INI#\n");
-}*/
-
-/******************************************************
- * NOM:                                               *
- *                  _printSECTION                     *
- * SPECIFICATION:                                     *
- * affiche a l'ecran le contenu de structure SECTION  *
- * ARGUMENTS:                                         *
- *  pointeur sur la structure SECTION                 *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- ******************************************************/
-/*void
-_printSECTION (SECTION * pSection)
-{
-  KEY *pKey = NULL;
-  KEY *pKey_pred = NULL;
-  printf ("%s\n", pSection->name);
-  pKey = pSection->fils;
-  if (pKey != NULL)
-    {
-      do
-	{
-	  _printKEY (pKey);
-	  pKey_pred = pKey;
-	  pKey = pKey->next;
-	}
-      while (pKey != pKey_pred);
-    }
-}*/
-
-/******************************************************
- * NOM:                                               *
- *                  _printKEY                         *
- * SPECIFICATION:                                     *
- * affiche a l'ecran le contenu de structure SECTION  *
- * ARGUMENTS:                                         *
- *  pointeur sur la structure SECTION                 *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- ******************************************************/
-/*
- * void
-_printKEY (KEY * pKey)
-{
-  printf ("%s=%s\n", pKey->name, pKey->value);
-}*/
-
-/******************************************************
- * NOM:                                               *
- *                  printINI                          *
- * SPECIFICATION:                                     *
- * affiche a l'ecran le contenu du fichier .ini       *
- * ARGUMENTS:                                         *
- *  nom du fichier                                    *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- ******************************************************/
-
-/*void
-printINI (char *file)
-{
-  INI *pIni = NULL;
-  TRY
-  {
-    pIni = _loadINI (file);
-  }
-  CATCH (ERR_MALLOC)
-  {
-    printf ("Erreur d'allocation memoire en chargeant le fichier .ini:%s\n",
-	    file);
-    exit (EXIT_FAILURE);
-  }
-  CATCH (ERR_FOPEN)
-  {
-    printf ("Erreur en ouvrant le fichier .ini:%s\n", file);
-    exit (EXIT_FAILURE);
-  }
-  ENDTRY;
-  _printINI (pIni);
-  free (pIni);
-}*/
-
-/******************************************************
- * NOM:                 jumpline                      *
- * SPECIFICATION:                                     *
- * fonction permettant de sauter des lignes dans le   *
- * fichier a partir de la position courante dans le   *
- * fichier                                            *
- * ARGUMENTS:                                         *
- * nombre de lignes a saute, pointeur sur le fichier  *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE: nombre de lignes sautees         *
- ******************************************************/
-
-int
-jumpline (int nbline, FILE * pfile)
-{
-    int compteur = 0, c;
-
-    while ((compteur < nbline) && ((c = getc (pfile)) != EOF))
-    {
-        if (c == '\n')
-            compteur++;
-    }
-    return (compteur);
-}
-
-/******************************************************
- * NOM:                readline                       *
- * SPECIFICATION:                                     *
- * recupere la ligne courante du fichier et renvoie le*
- * nombre de caracteres lus                           *
- * ARGUMENTS:                                         *
- * pointeur sur le fichier a lire                     *
- * pointeur sur le tableau recevant la ligne          *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- * nombre de caracteres lus                           *
- ******************************************************/
-int
-readline (FILE * pfile, char *tab)
-{
-    int nbchar = 0;
-    char c;
-    while ((c = getc (pfile)) != '\n')
-    {
-        if (c == EOF)
-        {
-            break;
-        }
-        tab[nbchar++] = c;
-    }
-    tab[nbchar] = '\0';
-
-    while (nbchar>0 && tab[nbchar-1]==' ') {
-        tab[--nbchar] = '\0';
-    }
-
-    while (tab[0]==' ') for (int i=1; i<=nbchar; i++) tab[i-1]=tab[i];
-
-    if (c == EOF) nbchar=-1;
-
-    return (nbchar);
-}
-
-/******************************************************
- * NOM:                m_malloc                       *
- * SPECIFICATION:                                     *
- *  clone de malloc renvoyant une exception           *
- * ARGUMENTS:                                         *
- * ENVIRONNEMENT:                                     *
- * VALEUR RETOURNEE:                                  *
- ******************************************************/
-
-/*
-void * m_malloc (size_t size)
-{
-  void *ptr = malloc (size);
-  if (ptr == NULL)
-    THROW (ERR_MALLOC);
-  else
-    return ptr;
-}*/
Index: ORadio/libindi/libindi/Indi_Stellarium/src/filetools.h
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/filetools.h	(revision 676)
+++ 	(revision )
@@ -1,109 +1,0 @@
-/*******************************************************
-                          filetools.h
-                          -----------
-    begin                : Wed Dec 13 2000
-    copyright            : (C) 2000 by Sylvain Le Petit 
-    email                : sylvainlepetit@wanadoo.fr
- *******************************************************/
-#include <stdio.h>
-#include <string.h>
-#include "exception.h"
-/* Structures de donnees */
-
-
-typedef struct section
-{
-  char *name;
-  struct key *fils;
-  struct ini *parent;
-  struct section *prev;
-  struct section *next;
-
-}
-SECTION;
-
-typedef struct key
-{
-  char *name;
-  char *value;
-  SECTION *parent;
-  struct key *prev;
-  struct key *next;
-}
-KEY;
-
-typedef struct ini
-{
-  char *fileName;
-  SECTION *fils;
-}
-INI;
-
-/* declaration des prototypes*/
- /*PUBLIC*/ int jumpline (int nbline, FILE * pfile);
-int readline (FILE * pfile, char *tab);
-/*************************************************************************
-gestion des fichier .ini
-**************************************************************************/
-
-int readINI (char *section, char *key, char **ppStr, char *fileName);
-/*******************************************************************************
- lire une valeur
-
-section: nom de la section
-key : nom de la cle
-ppStr: adresse du pointeur sur la valeur de la cle retour, NULL si pas trouve, memoire allouee dans la fonction
-fileName : nom du fichier contenant les cles, pas forcement xxx.ini c'est pas obligatoire
-
-**********************************************************************************/
-int readINI (const char *sectionName, const char *pKeyName, char **ppStr, const char *fileName);
-
-char *writeINI (char *section, char *key, char *pKeyValue, char *fileName);
-/*******************************************************************************
-  ecrire une cle avec sa valeur, que se soit une nouvelle cle ou un mise a jour
-c'est pareil
-
-section: nom de la section
-key : nom de la cle
-pKeyValue: valeur de la cle, evitez de mettre NULL pas encore tester ce cas limite
-fileName : nom du fichier contenant les cles, pas forcement xxx.ini c'est pas obligatoire
-
- *******************************************************************************/
-
-int delINI (char *sectionName, char *pKeyName, char **ppStr, char *fileName);
-/*************************************************************************/
-/* permet de supprimer une cle ou une section complete                   */
-/* >suppression d'une cle, donner le nomde la section et le nom de la cle*/
-/*  si la section est vide elle est supprimee                            */
-/* >suppression d'une section complete, mettre NULL comme nom de cle     */
-/*************************************************************************/
-
-void printINI (char *fileName);
-/*****************************************************************/
-/*  permet d'afficher le contenu du fichier .ini, seulement les: */
-/*  [section]                                                    */
-/*  cle=valeur                                                   */
-/*****************************************************************/
-
-
-
-/*PRIVATE: ne pas utiliser directement*/
-int _saveINI (INI * ini);
-INI *_loadINI (char *fileName);
-void _printINI (INI * pIni);
-void _printSECTION (SECTION * pSection);
-void _printKEY (KEY * pKey);
-KEY *_newKEY (char *pKeyName, char *pKeyValue);
-SECTION *_newSECTION (char *pSectionName);
-SECTION *_findSECTION (INI * pIni, char *pSectionName);
-KEY *_findKEY (SECTION * pSection, char *pKeyName);
-KEY *_lastKEY (SECTION * pSection);
-SECTION *_lastSECTION (INI * pIni);
-SECTION *_addSECTION (INI * pIni, SECTION * pSection);
-KEY *_addKEY (SECTION * pSection, KEY * pKey);
-int _isKey (char *str);
-void *m_malloc (size_t size);	/*renvoi l'exception ERR_MALLOC */
-void _freeKEY (KEY * pKey);
-void _freeSECTION (SECTION * pSection);
-int _delKEY (KEY * pKey);
-int _delSECTION (SECTION * pSection);
Index: ORadio/libindi/libindi/Indi_Stellarium/src/socket.cpp
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/socket.cpp	(revision 676)
+++ 	(revision )
@@ -1,229 +1,0 @@
-// Implementation of the Socket class.
-
-
-#include "socket.h"
-#include "string.h"
-#include <string.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <iostream>
-#include <netinet/tcp.h>
-
-
-
-
-
-socketdef::socketdef() :
-        m_sock ( -1 )
-{
-
-    memset ( &m_addr,
-             0,
-             sizeof ( m_addr ) );
-
-}
-
-socketdef::~socketdef()
-{
-    if ( is_valid() )
-        ::close ( m_sock );
-}
-
-bool socketdef::create()
-{
-    m_sock = socket ( AF_INET,
-                      SOCK_STREAM,
-                      0); //IPPROTO_TCP
-
-    if ( ! is_valid() )
-        return false;
-
-
-   //  TIME_WAIT - argh
-    int on = 1;
- 
-    if ( setsockopt( m_sock, SOL_SOCKET, SO_REUSEADDR, ( const char* ) &on, sizeof ( on ) ) == -1 ) return false;
- 
-    if ( setsockopt(m_sock, SOL_TCP, TCP_NODELAY, (const char*) &on, sizeof(on)) <0) return false;
-    
-    
-    return true;
-}
-
-
-bool socketdef::shutdown()
-{
-  int ret = 0;
-
-  if ( is_valid() )
-      ret =  ::shutdown ( m_sock, 2 );
-  
-  m_sock=-1;
-
-  if ( ret == 0 ) return true;
-
-  return false;
-}
-
-
-bool socketdef::bind ( const int port )
-{
-    if ( ! is_valid() ) return false;
-    
-    m_addr.sin_family = AF_INET;
-    m_addr.sin_addr.s_addr = INADDR_ANY;
-    m_addr.sin_port =  htons ( port );
-
-    int bind_return = ::bind ( m_sock,
-                               ( struct sockaddr * ) &m_addr,
-                               sizeof ( m_addr ) );
-
-
-    if ( bind_return == -1 ) return false;
-  
-    return true;
-}
-
-
-bool socketdef::listen() const
-{
-    if ( ! is_valid() ) return false;
-    
-    int listen_return = ::listen ( m_sock, MAXCONNECTIONS );
-
-    if ( listen_return == -1 ) return false;
-    
-    return true;
-}
-
-
-bool socketdef::accept ( socketdef& new_socket ) const
-{
-    int addr_length = sizeof ( m_addr );
-    
-    new_socket.m_sock = ::accept ( m_sock, ( sockaddr * ) &m_addr, ( socklen_t * ) &addr_length );
-
-    if ( new_socket.m_sock <= 0 ) return false;
-        
-    return true;
-}
-
-
-bool socketdef::send ( const std::string s ) const
-{
-    int status = ::send ( m_sock, s.c_str(), s.size(), MSG_NOSIGNAL);
-    
-    if ( status == -1 ) return false;
-        
-    return true;    
-}
-
-
-int socketdef::recv ( std::string& s ) const
-{
-    int sel;
-    fd_set r;
-    struct timeval timeout;
-
-    if ( ! is_valid() ) return false;
-    
-    s="";
-
-    timeout.tv_sec = 0; // initialise le timeout, ici  les secondes
-    timeout.tv_usec = 1; // les microsecondes
-
-    FD_ZERO(&r); // initialise la liste de fd
-    FD_SET(m_sock, &r); // ajoute la socket dans la liste des fd
-    sel = select(m_sock + 1, &r, NULL, NULL, &timeout);
-    if (sel < 0) // select a rencontrÃ© un problÃšme
-    {
-        return -1;
-    }
-    else if (sel == 0) // timeout
-    {
-	return 1;
-    }
-    else // quelque chose est Ã  lire sur un file descriptor
-    {
-        if (FD_ISSET(m_sock, &r)) // si la socket est prÃªte Ã  Ãªtre lue
-        {
-            char buf [ MAXRECV + 1 ];
-
-            s = "";
-
-            memset ( buf, 0, MAXRECV + 1 );
-
-            int status = ::recv ( m_sock, buf, MAXRECV, 0 );
-
-            if ( status == -1 )
-            {
-	         // lÃ , nous ne sommes pas en prÃ©sence d'une vraie erreur
-		 // car le mode non-bloquant est activÃ© ici
-		 // (consulter la doc de la fct recv...)
-                 if (errno == EAGAIN )
-		 {
-	           return 0;
-		 }
-		 
-		 return -1;
-            }
-            else if ( status == 0 )
-            {
-                return 0;
-            }
-            else
-            {
-                s = buf;
-                return status;
-            }
-        }
-    }
-
-    return -1;
-}
-
-
-
-bool socketdef::connect ( const std::string host, const int port )
-{
-    if ( ! is_valid() ) return false;
-
-    memset ( &m_addr,
-             0,
-             sizeof ( m_addr ) );
-
-    m_addr.sin_family = AF_INET;
-    m_addr.sin_port = htons ( port );
-
-    int status = inet_pton ( AF_INET, host.c_str(), &m_addr.sin_addr );
-
-    if ( errno == EAFNOSUPPORT ) return false;
-
-
-    status = ::connect ( m_sock, ( sockaddr * ) &m_addr, sizeof ( m_addr ) );
-
-    if ( status == 0 ) return true;
-    
-    return false;
-}
-
-void socketdef::set_non_blocking ( const bool b )
-{
-    int opts;
-
-    opts = fcntl ( m_sock,F_GETFL );
-
-    if ( opts < 0 )
-    {
-        return;
-    }
-
-    if ( b )
-        opts = ( opts | O_NONBLOCK );
-    else
-        opts = ( opts & ~O_NONBLOCK );
-
-    fcntl ( m_sock,
-            F_SETFL,opts );
-
-}
Index: ORadio/libindi/libindi/Indi_Stellarium/src/socket.h
===================================================================
--- /BAORadio/libindi/libindi/Indi_Stellarium/src/socket.h	(revision 676)
+++ 	(revision )
@@ -1,62 +1,0 @@
-// Definition of the Socket class
-
-#ifndef socket_class
-#define socket_class
-
-
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <netinet/in.h>
-#include <netdb.h>
-#include <unistd.h>
-#include <string>
-#include <arpa/inet.h>
-#include <iostream>
-#include "stdio.h"
-
-
-const int MAXHOSTNAME = 1000;
-const int MAXCONNECTIONS = 5;
-const int MAXRECV = 5000;
-
-
-
-class socketdef
-{
- public:
-  socketdef();
-  virtual ~socketdef();
-
-
-  // Server initialization
-  bool create();
-  bool bind ( const int port );
-  bool listen() const;
-  bool accept ( socketdef& ) const;
-
-  // Client initialization
-  bool connect ( const std::string host, const int port );
-
-  // Data Transimission
-  bool send ( const std::string ) const;
-  int recv ( std::string& ) const;
-
-
-  void set_non_blocking ( const bool );
-
-  bool is_valid() const { return m_sock != -1; }
-
-  bool shutdown();
-
- private:
-
-  int m_sock;
-  sockaddr_in m_addr;
-
-
-
-
-};
-
-
-#endif
Index: /BAORadio/libindi/libindi/bao.sh
===================================================================
--- /BAORadio/libindi/libindi/bao.sh	(revision 676)
+++ /BAORadio/libindi/libindi/bao.sh	(revision 677)
@@ -19,6 +19,7 @@
 cd libindi_build
 make clean
-cd ../BAOControl
+cd ../BAOcontrol
 make clean
+rm -f *.o *.cpp~ *.h~  BAOtest
 cd ../BAOTest
 make clean
@@ -51,7 +52,9 @@
 echo ;
 
-cd ../BAOControl
+cd ../BAOcontrol
+qmake -project
+qmake
 make
-make install
+cp BAOcontrol /usr/bin
 echo ;
 echo ;
@@ -70,7 +73,7 @@
 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
Index: /BAORadio/libindi/libindi/communs/ClientSocket.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/ClientSocket.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/communs/ClientSocket.cpp	(revision 677)
@@ -64,7 +64,12 @@
 
         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";
         }
Index: /BAORadio/libindi/libindi/communs/alignement.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 677)
@@ -45,9 +45,10 @@
     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,4 +61,10 @@
 
     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,5 +168,5 @@
     double temp[4][4];
     double UnitVect[4][4];
-
+    
     temp[1][1] = p2.x - p1.x;
     temp[2][1] = p3.x - p1.x;
@@ -176,7 +183,8 @@
     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,5 +200,5 @@
 ***************************************************************************************/
 
-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,14 +206,24 @@
     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,5 +284,5 @@
     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,7 +296,7 @@
     // 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,5 +325,5 @@
 ***************************************************************************************/
 
-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,13 +332,46 @@
     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,11 +400,20 @@
     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,5 +591,25 @@
 
 
-
+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,6 +621,14 @@
 {
     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,7 +659,7 @@
     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,7 +679,7 @@
 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,7 +687,7 @@
     stringstream os;
 
-    int best1 = 0;
-    int best2 = 0;
-    int best3 = 0;
+    int best1 = -1;
+    int best2 = -1;
+    int best3 = -1;
 
 
@@ -612,7 +700,7 @@
     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,11 +717,11 @@
         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,34 +730,32 @@
         }
 
-        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,28 +764,28 @@
                     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,5 +807,5 @@
 
 
-    if ( best1 == 0 && best2 == 0 && best3 == 0 )
+    if ( best1 == -1 && best2 == -1 && best3 == -1 )
     {
         if (MethodeAlignement == AFFINE || MethodeAlignement == TAKI)
@@ -738,5 +824,5 @@
         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,38 +838,29 @@
             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,9 +876,9 @@
     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,9 +891,13 @@
     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,5 +966,5 @@
 
     // 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,5 +989,7 @@
     stringstream os, os2;
 
-    char *delta_az_polar_data = NULL;
+    char *delta_az = NULL;
+
+    char *delta_ha = NULL;
 
     char *ad_data = NULL;
@@ -924,5 +1007,4 @@
     char *tsl_data = NULL;
 
-
     if (!is_readable(fileName)) return false;
 
@@ -933,14 +1015,10 @@
     // 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,24 +1059,27 @@
             // -> 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,15 +1095,15 @@
     }
 
-    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,4 +1111,20 @@
     }
 
+    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,8 +1132,4 @@
 
     os2.str("");
-
-    /*  char chaine[100];
-    sprintf(chaine, "************** %s\n",alignment_method_data);
-      cout << chaine;*/
 
     if (alignment_method_data)
@@ -1102,5 +1195,7 @@
     }
 
-    SAFEDELETE_TAB(delta_az_polar_data);
+    SAFEDELETE_TAB(delta_az);
+
+    SAFEDELETE_TAB(delta_ha);
 
     SAFEDELETE_TAB(alignment_method_data);
@@ -1130,16 +1225,8 @@
     //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,13 +1246,26 @@
     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,5 +1290,5 @@
         key     = os.str();
         os.str("");
-        os << 0;
+        os << 0.0;
         value = os.str();
         os.str("");
@@ -1199,5 +1299,5 @@
         key     = os.str();
         os.str("");
-        os << 0;
+        os << 0.0;
         value = os.str();
         os.str("");
@@ -1215,6 +1315,5 @@
     }
 
-
-    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;
Index: /BAORadio/libindi/libindi/communs/alignement.h
===================================================================
--- /BAORadio/libindi/libindi/communs/alignement.h	(revision 676)
+++ /BAORadio/libindi/libindi/communs/alignement.h	(revision 677)
@@ -11,5 +11,4 @@
 #ifndef Alignement_class
 #define Alignement_class
-
 
 #include <stdio.h>
@@ -34,5 +33,4 @@
 
 using namespace std;
-
 
 struct Coord
@@ -93,5 +91,8 @@
 
     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,4 +110,9 @@
     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,7 +122,7 @@
     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
Index: /BAORadio/libindi/libindi/communs/astro.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/astro.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/communs/astro.cpp	(revision 677)
@@ -19,8 +19,8 @@
 {
     //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,17 +30,17 @@
     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,8 +106,8 @@
 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,10 +115,10 @@
 /**************************************************************************************
 ** 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,5 +161,5 @@
     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,4 +190,82 @@
 }
 
+/**************************************************************************************
+** 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,12 +293,12 @@
 
     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,20 +311,20 @@
 ***************************************************************************************/
 
-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,5 +348,5 @@
     double LP2 = 2.0 * LP;
     double O2  = 2.0 * O;
-    
+
     // Nutation en longitude
 
@@ -286,5 +364,5 @@
            +0.0124 * sin(L2 - O)
            +0.0114 * sin(LP2 - MP);
-	   
+
     //Nutation en inclinaison
 
@@ -393,5 +471,5 @@
 void Astro::CalculJJ(double Heure)
 {
-    JJ = CalculJJ(Annee, Mois, Jour, Heure);    
+    JJ = CalculJJ(Annee, Mois, Jour, Heure);
 }
 
@@ -438,5 +516,5 @@
 
     c = (36525L * y) / 100;
-    
+
     return b + c + e + day - 32167.5;
 }
@@ -450,5 +528,5 @@
 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,9 +578,94 @@
     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,8 +875,8 @@
     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 */
Index: /BAORadio/libindi/libindi/communs/astro.h
===================================================================
--- /BAORadio/libindi/libindi/communs/astro.h	(revision 676)
+++ /BAORadio/libindi/libindi/communs/astro.h	(revision 677)
@@ -13,8 +13,10 @@
 #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,4 +29,10 @@
     string ar;				// CoordonnÃ©es horaires d'un objet
     string dec;
+};
+
+struct CoordonneesHorairesDouble
+{
+    double ar;				// CoordonnÃ©es horaires d'un objet
+    double dec;
 };
 
@@ -45,4 +53,6 @@
     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,4 +64,5 @@
     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,5 +78,5 @@
     float  slaRange(float angle );
     double slaDrange(double angle );
-    void   CalculARDecSoleil(CoordonneesHoraires *Soleil);
+    void   CalculARDecSoleil(CoordonneesHorairesDouble *Soleil);
     
     double GetLatitude()    { return Latitude;  }
Index: /BAORadio/libindi/libindi/communs/const.h
===================================================================
--- /BAORadio/libindi/libindi/communs/const.h	(revision 676)
+++ /BAORadio/libindi/libindi/communs/const.h	(revision 677)
@@ -27,4 +27,10 @@
 
 #define NBREPASCODEURSAZ  4000
+
+// DÃ©finition des limites autorisÃ©es pour l'azimut (en pas codeur)
+
+#define MAXAZCODEURS 3800
+#define MINAZCODEURS -1680
+
 
 
@@ -71,6 +77,9 @@
 // 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,5 +134,5 @@
 // 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,5 +146,13 @@
 // 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 )
 
 
Index: /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp
===================================================================
--- /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp	(revision 676)
+++ /BAORadio/libindi/libindi/drivers/telescope/BAO.cpp	(revision 677)
@@ -22,8 +22,10 @@
 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,7 +78,7 @@
     // 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,4 +116,11 @@
 
     Temp                  = 10.0;
+
+    // raquette
+
+    delta_az 		  = 0;
+    delta_ha              = 0;
+    VitesseRaquette       = 10;
+    targetAlignmentIP     = -1;
 
 
@@ -136,5 +145,5 @@
 
     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,30 +302,66 @@
     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,13 +371,13 @@
 
     // 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,7 +402,18 @@
     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,4 +436,11 @@
     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,4 +455,10 @@
     IUResetSwitch(&OnCoordSetSP);
     IUResetSwitch(&AlignmentSP);
+    IUResetSwitch(&AlignementAltpP);
+    IUResetSwitch(&AlignementAzP);
+    IUResetSwitch(&AlignementAltnP);
+    IUResetSwitch(&AlignementOkP);
+    IUResetSwitch(&AlignementResetP);
+    IUResetSwitch(&RaquetteNP);
     IUResetSwitch(&AbortSlewSP);
     IUResetSwitch(&ParkSP);
@@ -397,4 +466,8 @@
     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,8 +476,15 @@
     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,4 +534,53 @@
 
     // ===================================
+    // 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,7 +603,9 @@
             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,4 +615,142 @@
                         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,4 +968,28 @@
             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,4 +1166,21 @@
         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,9 +1226,6 @@
         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,4 +1250,275 @@
 
     // ===================================
+    // 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,5 +1667,4 @@
 
 
-
 /************************************************************************************
 ** Cette procÃ©dure, aprÃšs avoir appliquÃ© la matrice de rotation aux coordonnÃ©es de l'objet
@@ -1128,46 +1705,47 @@
                 // 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,9 +1755,12 @@
                     // 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,9 +1774,10 @@
             // 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,34 +1788,53 @@
                 // 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,5 +1843,5 @@
             // 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,19 +1868,19 @@
             // 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,9 +1897,27 @@
                 // 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,26 +2014,19 @@
         // 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,4 +2046,16 @@
             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,4 +2841,10 @@
         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,4 +2890,10 @@
         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();
Index: /BAORadio/libindi/libindi/drivers/telescope/BAO.h
===================================================================
--- /BAORadio/libindi/libindi/drivers/telescope/BAO.h	(revision 676)
+++ /BAORadio/libindi/libindi/drivers/telescope/BAO.h	(revision 677)
@@ -152,4 +152,8 @@
     
     void AfficherLog(const char* Message,...);
+    
+    
+  
+    
 
 
@@ -164,4 +168,10 @@
     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,4 +181,5 @@
     IText ObjectT[1];
     IText CommandT[1];
+    IText AlignementIP[1];
 
     /* Numbers */
@@ -178,4 +189,5 @@
     INumber ActualisationN1[1];
     INumber ActualisationN2[1];
+    
 
     /* Switch Vectors */
@@ -183,4 +195,10 @@
     ISwitchVectorProperty OnCoordSetSP;
     ISwitchVectorProperty AlignmentSP;
+    ISwitchVectorProperty AlignementAltpP;
+    ISwitchVectorProperty AlignementAzP;
+    ISwitchVectorProperty AlignementAltnP; 
+    ISwitchVectorProperty AlignementOkP;
+    ISwitchVectorProperty AlignementResetP;
+    ISwitchVectorProperty RaquetteNP;
     ISwitchVectorProperty AbortSlewSP;
     ISwitchVectorProperty ParkSP;
@@ -192,10 +210,10 @@
     INumberVectorProperty ActualisationNP1;
     INumberVectorProperty ActualisationNP2;
-
-
+    
     /* Text Vectors */
     ITextVectorProperty PortTP;
     ITextVectorProperty ObjectTP;
     ITextVectorProperty CommandTP;
+    ITextVectorProperty AlignementIPP;
 
 
@@ -229,4 +247,15 @@
     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;
+    
+    
 };
 
Index: /BAORadio/libindi/libindi/result_recherche_bao
===================================================================
--- /BAORadio/libindi/libindi/result_recherche_bao	(revision 676)
+++ /BAORadio/libindi/libindi/result_recherche_bao	(revision 677)
@@ -1,27 +1,68 @@
-
-
-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>
