Index: /BAORadio/libindi/libindi/communs/ClientSocket.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/ClientSocket.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/ClientSocket.cpp	(revision 644)
@@ -0,0 +1,73 @@
+// 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 ( ! Socket::create() )
+    {
+        throw SocketException ( "Could not create client socket." );
+    }
+
+    if ( ! Socket::connect ( host, port ) )
+    {
+        throw SocketException ( "Could not bind to port." );
+    }
+}
+
+
+const ClientSocket& ClientSocket::operator << ( const std::string& s ) const
+{
+    if ( ! Socket::send ( s ) )
+    {
+        // throw SocketException ( "Could not write to socket." );
+    }
+
+    return *this;
+
+}
+
+
+const ClientSocket& ClientSocket::operator >> ( std::string& s ) const
+{
+    if ( ! Socket::recv ( s ) )
+    {
+        //   throw SocketException ( "Could not read from socket." );
+    }
+
+    return *this;
+}
+
+
+void ClientSocket::recv( std::string& s )
+{
+    if ( ! Socket::recv ( s ) )
+    {
+        sleep(1);
+	
+	if (! Socket::shutdown() ) std::cout << "shutdown impossible.\n";
+
+	sleep(1);
+	
+        if (! Socket::create() ) std::cout << "create impossible.\n";
+
+        sleep(2);
+
+        if (! Socket::connect((std::string)"192.168.0.1", 8000)) {
+            std::cout << "connect impossible.\n";
+            Socket::shutdown();
+        } else {
+            std::cout << "Reconnexion reussie.\n";
+        }
+    }
+}
+
Index: /BAORadio/libindi/libindi/communs/ServerSocket.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/ServerSocket.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/ServerSocket.cpp	(revision 644)
@@ -0,0 +1,94 @@
+// Implementation of the ServerSocket class
+// Franck RICHARD
+// BAORadio
+
+#include "ServerSocket.h"
+#include "SocketException.h"
+#include <net/if.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <netinet/in.h>
+
+
+ServerSocket::ServerSocket ( int port )
+{
+    if ( ! Socket::create() )
+    {
+        throw SocketException ( "Could not create server socket." );
+    }
+
+    if ( ! Socket::bind ( port ) )
+    {
+        throw SocketException ( "Could not bind to port." );
+    }
+
+    if ( ! Socket::listen() )
+    {
+        throw SocketException ( "Could not listen to socket." );
+    }
+
+    Socket::set_non_blocking(true);
+}
+
+ServerSocket::~ServerSocket()
+{
+}
+
+
+const ServerSocket& ServerSocket::operator << ( const std::string& s ) const
+{
+    if ( ! Socket::send ( s ) )
+    {
+        throw SocketException ( "Could not write to socket." );
+    }
+
+    return *this;
+
+}
+
+
+const ServerSocket& ServerSocket::operator >> ( std::string& s ) const
+{
+    if ( ! Socket::recv ( s ) )
+    {
+        throw SocketException ( "Could not read from socket." );
+    }
+
+    return *this;
+}
+
+
+void ServerSocket::accept ( ServerSocket& sock )
+{
+    if ( ! Socket::accept ( sock ) )
+    {
+        throw SocketException ( "Could not accept socket." );
+    }
+}
+
+void ServerSocket::shutdown ( )
+{
+    if ( ! Socket::shutdown (  ) )
+    {
+        throw SocketException ( "Could not shutdown socket." );
+    }
+}
+
+void ServerSocket::create ( )
+{
+    if ( ! Socket::create (  ) )
+    {
+        throw SocketException ( "Could not create socket." );
+    }
+}
+
+bool ServerSocket::connect(std::string IP ) 
+{
+   return Socket::connect (IP, 8000);  
+}
+
+std::string ServerSocket::recupip( ServerSocket& sock)
+{ 
+   return ( Socket::recupip() ); 
+}
Index: /BAORadio/libindi/libindi/communs/ServerSocket.h
===================================================================
--- /BAORadio/libindi/libindi/communs/ServerSocket.h	(revision 644)
+++ /BAORadio/libindi/libindi/communs/ServerSocket.h	(revision 644)
@@ -0,0 +1,34 @@
+// Definition of the ServerSocket class
+
+#ifndef ServerSocket_class
+#define ServerSocket_class
+
+#include "Socket.h"
+
+
+
+
+class ServerSocket : private Socket
+{
+ public:
+
+  ServerSocket ( int port );
+  ServerSocket (){};
+  virtual ~ServerSocket();
+
+  const ServerSocket& operator << ( const std::string& ) const;
+  const ServerSocket& operator >> ( std::string& ) const;
+  
+  void accept ( ServerSocket& );
+
+  void shutdown ( );
+  
+  void create();
+  
+  bool connect(std::string IP );
+  
+  std::string recupip( ServerSocket& );
+};
+
+
+#endif
Index: /BAORadio/libindi/libindi/communs/Socket.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/Socket.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/Socket.cpp	(revision 644)
@@ -0,0 +1,235 @@
+// 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>
+
+
+
+Socket::Socket() :
+        m_sock ( -1 )
+{
+
+    memset ( &m_addr,
+             0,
+             sizeof ( m_addr ) );
+}
+
+Socket::~Socket()
+{
+    if ( is_valid() )
+        ::close ( m_sock );
+}
+
+bool Socket::create()
+{
+    m_sock = socket ( AF_INET,
+                      SOCK_STREAM,
+                      0); //IPPROTO_TCP
+
+    if ( ! is_valid() )
+        return false;
+
+
+    int on = 1;
+
+    if ( setsockopt ( m_sock, SOL_SOCKET, SO_REUSEADDR, ( const char* ) &on, sizeof ( on ) ) == -1 ) return false;
+
+    // RÃ©duire les dÃ©lais lors des transmissions TCP/IP
+    // Voir article Ã  l'adresse
+    // http://www.redhat.com/docs/en-US/Red_Hat_Enterprise_MRG/1.0/html/Realtime_Tuning_Guide/sect-Realtime_Tuning_Guide-Application_Tuning_and_Deployment-TCP_NODELAY_and_Small_Buffer_Writes.html
+    
+    if ( setsockopt(m_sock, SOL_TCP, TCP_NODELAY, (const char*) &on, sizeof(on)) < 0 ) return false;
+
+    return true;
+}
+
+
+
+bool Socket::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 Socket::listen() const
+{
+    if ( ! is_valid() ) return false;
+    
+    int listen_return = ::listen ( m_sock, MAXCONNECTIONS );
+
+    if ( listen_return == -1 ) return false;
+    
+    return true;
+}
+
+
+bool Socket::accept ( Socket& 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 Socket::shutdown()
+{
+  int ret = 0;
+
+  if ( is_valid() )
+      ret =  ::shutdown ( m_sock, 2 );
+  
+  m_sock=-1;
+
+  if ( ret == 0 ) return true;
+
+  return false;
+}
+
+
+bool Socket::send ( const std::string s ) const
+{
+    if ( ! is_valid() ) return false;
+    
+    int status = ::send ( m_sock, s.c_str(), s.size(), MSG_NOSIGNAL);
+    
+    if ( status == -1 ) return false;
+        
+    return true;    
+}
+
+
+int Socket::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;
+            }
+        }
+    }
+}
+
+
+
+bool Socket::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 Socket::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 );
+
+}
+
+
+std::string Socket::recupip() const
+{
+    return inet_ntoa(m_addr.sin_addr);
+}
Index: /BAORadio/libindi/libindi/communs/SocketException.h
===================================================================
--- /BAORadio/libindi/libindi/communs/SocketException.h	(revision 644)
+++ /BAORadio/libindi/libindi/communs/SocketException.h	(revision 644)
@@ -0,0 +1,23 @@
+// 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: /BAORadio/libindi/libindi/communs/alignement.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/alignement.cpp	(revision 644)
@@ -0,0 +1,1251 @@
+////////////////////////////////
+// Classe Alignement          //
+// Franck RICHARD             //
+// franckrichard033@gmail.com //
+// BAORadio                   //
+// fÃ©vrier 2011               //
+////////////////////////////////
+
+
+#include "alignement.h"
+
+
+/**************************************************************************************
+** Constructeur de la classe Alignement
+**
+***************************************************************************************/
+
+Alignement::Alignement()
+{
+    //Initialisation des paramÃštres des antennes
+    
+    InitAlignement();
+}
+
+
+/**************************************************************************************
+** Destructeur de la classe Alignement
+**
+***************************************************************************************/
+
+Alignement::~Alignement()
+{
+}
+
+
+/**************************************************************************************
+** Initialisations des vecteurs et des paramÃštres d'alignement
+**
+***************************************************************************************/
+
+void Alignement::InitAlignement()
+{
+    // On initialise les points de correction
+
+    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;
+    }
+
+    // initialisation de la matrice de rotation (Ã  la matrice identitÃ©)
+
+    Identity();
+
+
+    // initialisation de la direction en azimut de l'Ã©toile polaire
+
+    delta_az_polar    = 0;
+
+    // Nbre de points (de mesures) actuellement disponibles pour
+    // bÃ¢tir les matrices de correction
+
+    nbrcorrections    = 0;
+
+    // Est-ce que l'antenne est en cours d'alignement ?
+
+    AlignementEnCours = 0;
+
+    // La matrice de correction a-t-elle Ã©tÃ© calculÃ©e ?
+
+    Matrice_ok        = false;
+
+    // MÃ©thode d'alignement par dÃ©faut
+
+    MethodeAlignement = SIMPLE;
+}
+
+
+
+/**************************************************************************************
+**  Initialisation des paramÃštres de la classe astro
+**
+***************************************************************************************/
+
+void Alignement::TransmettreParametresClasseAstro(double Annee, double Mois, double Jour, double Heu, double Min, double Sec, double Longitude, double Latitude, double Pression, double Temp)
+{
+    DefinirLongitudeLatitude(Longitude, Latitude); 
+    DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
+    DefinirPressionTemp(Pression, Temp);   
+}
+
+
+/**************************************************************************************
+**  1 0 0
+**  0 1 0
+**  0 0 1
+***************************************************************************************/
+
+void Alignement::Identity()
+{
+    MATRICE[1][1] = 1.0;
+    MATRICE[2][1] = 0.0;
+    MATRICE[3][1] = 0.0;
+
+    MATRICE[1][2] = 0.0;
+    MATRICE[2][2] = 1.0;
+    MATRICE[3][2] = 0.0;
+
+    MATRICE[1][3] = 0.0;
+    MATRICE[2][3] = 0.0;
+    MATRICE[3][3] = 1.0;
+}
+
+
+
+/**************************************************************************************
+**  Calcule la matrice de rotation d'un angle alpha autour d'un axe dÃ©fini 
+**  par les paramÃštres t et r dans un systÃšme de coordonnÃ©es spÄ¥Ã©riques
+**  Le signe - devant le cos permet seulement de rendre le repÃšre compatible avec WinStars
+** que j'utilise pour faire des vÃ©rifications...
+** Fonction utile pour de dÃ©bogage de la fct d'alignement
+**  
+***************************************************************************************/
+
+void Alignement::RotationAutourDunAxe(double t, double r, double alpha)
+{
+    double x = -cos(t) * cos(r);
+    double y = sin(t) * cos(r);
+    double z = sin(r);
+
+    double c = cos(alpha);
+    double s = sin(alpha);
+
+
+    MATRICE[1][1] = x * x + (1.0 - x * x) * c;
+    MATRICE[1][2] = x * y * (1.0 - c) - z * s;
+    MATRICE[1][3] = x * z * (1.0 - c) + y * s;
+
+    MATRICE[2][1] = x * y * (1.0 - c) + z * s;
+    MATRICE[2][2] = y * y + (1.0 - y * y) * c;
+    MATRICE[2][3] = y * z * (1.0 - c) - x * s;
+
+    MATRICE[3][1] = x * z * (1.0 - c) - y * s;
+    MATRICE[3][2] = y * z * (1.0 - c) + x * s;
+    MATRICE[3][3] = z * z + (1.0 - z * z) * c;
+}
+
+
+/**************************************************************************************
+** Matrice intermÃ©diaire nÃ©cessaire au calcul de la matrice de correction
+** dans le mode d'alignement TAKI
+** Consultez la documentation pour comprendre le principe de la correction AFFINE/TAKI
+**
+***************************************************************************************/
+
+void Alignement::Calculer_Matrice_LMN(Coord p1, Coord p2, Coord p3)
+{
+    double temp[4][4];
+    double UnitVect[4][4];
+
+    temp[1][1] = p2.x - p1.x;
+    temp[2][1] = p3.x - p1.x;
+
+    temp[1][2] = p2.y - p1.y;
+    temp[2][2] = p3.y - p1.y;
+
+    temp[1][3] = p2.z - p1.z;
+    temp[2][3] = p3.z - p1.z;
+
+    UnitVect[1][1] = (temp[1][2] * temp[2][3]) - (temp[1][3] * temp[2][2]);
+    UnitVect[1][2] = (temp[1][3] * temp[2][1]) - (temp[1][1] * temp[2][3]);
+    UnitVect[1][3] = (temp[1][1] * temp[2][2]) - (temp[1][2] * temp[2][1]);
+    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]);
+    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];
+
+    GETLMN[3][1] = UnitVect[2][3] * UnitVect[1][1];
+    GETLMN[3][2] = UnitVect[2][3] * UnitVect[1][2];
+    GETLMN[3][3] = UnitVect[2][3] * UnitVect[1][3];
+}
+
+
+
+/**************************************************************************************
+** Calcul de la matrice de correction dans le mode d'alignement TAKI
+**
+***************************************************************************************/
+
+int Alignement::Calculer_Matrice_Taki(double x, double y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
+{
+    double Det;
+    double EQLMN1[4][4];
+    double EQLMN2[4][4];
+    double EQMI_T[4][4];
+
+    //construit les matrices EQLMN1 & 2
+
+    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];
+
+    // Calcule le dÃ©terminant de EQLMN1
+
+    Det = EQLMN1[1][1] * ((EQLMN1[2][2] * EQLMN1[3][3]) - (EQLMN1[3][2] * EQLMN1[2][ 3]));
+    Det = Det - (EQLMN1[1][2] * ((EQLMN1[2][1] * EQLMN1[3][3]) - (EQLMN1[3][1] * EQLMN1[2][3])));
+    Det = Det + (EQLMN1[1][3] * ((EQLMN1[2][1] * EQLMN1[3][2]) - (EQLMN1[3][1] * EQLMN1[2][2])));
+
+
+    // Calcule la matrice inverse EQMI_T de EQLMN1
+
+    if (Det == 0.0)
+    {
+        ErreurLog("Erreur Matrice_Taki. Impossible de calculer l'inverse de la matrice avec un determinant = 0 \n");
+        return 0;
+    }
+    else
+    {
+        EQMI_T[1][1] = ((EQLMN1[2][2] * EQLMN1[3][3]) - (EQLMN1[3][2] * EQLMN1[2][3])) / Det;
+        EQMI_T[1][2] = ((EQLMN1[1][3] * EQLMN1[3][2]) - (EQLMN1[1][2] * EQLMN1[3][3])) / Det;
+        EQMI_T[1][3] = ((EQLMN1[1][2] * EQLMN1[2][3]) - (EQLMN1[2][2] * EQLMN1[1][3])) / Det;
+        EQMI_T[2][1] = ((EQLMN1[2][3] * EQLMN1[3][1]) - (EQLMN1[3][3] * EQLMN1[2][1])) / Det;
+        EQMI_T[2][2] = ((EQLMN1[1][1] * EQLMN1[3][3]) - (EQLMN1[3][1] * EQLMN1[1][3])) / Det;
+        EQMI_T[2][3] = ((EQLMN1[1][3] * EQLMN1[2][1]) - (EQLMN1[2][3] * EQLMN1[1][1])) / Det;
+        EQMI_T[3][1] = ((EQLMN1[2][1] * EQLMN1[3][2]) - (EQLMN1[3][1] * EQLMN1[2][2])) / Det;
+        EQMI_T[3][2] = ((EQLMN1[1][2] * EQLMN1[3][1]) - (EQLMN1[3][2] * EQLMN1[1][1])) / Det;
+        EQMI_T[3][3] = ((EQLMN1[1][1] * EQLMN1[2][2]) - (EQLMN1[2][1] * EQLMN1[1][2])) / Det;
+    }
+
+
+    // Effectue le produit des matrices EQMI_T et EQLMN2
+
+    MATRICE[1][1] = (EQMI_T[1][1] * EQLMN2[1][1]) + (EQMI_T[1][2] * EQLMN2[2][1]) + (EQMI_T[1][3] * EQLMN2[3][1]);
+    MATRICE[1][2] = (EQMI_T[1][1] * EQLMN2[1][2]) + (EQMI_T[1][2] * EQLMN2[2][2]) + (EQMI_T[1][3] * EQLMN2[3][2]);
+    MATRICE[1][3] = (EQMI_T[1][1] * EQLMN2[1][3]) + (EQMI_T[1][2] * EQLMN2[2][3]) + (EQMI_T[1][3] * EQLMN2[3][3]);
+
+    MATRICE[2][1] = (EQMI_T[2][1] * EQLMN2[1][1]) + (EQMI_T[2][2] * EQLMN2[2][1]) + (EQMI_T[2][3] * EQLMN2[3][1]);
+    MATRICE[2][2] = (EQMI_T[2][1] * EQLMN2[1][2]) + (EQMI_T[2][2] * EQLMN2[2][2]) + (EQMI_T[2][3] * EQLMN2[3][2]);
+    MATRICE[2][3] = (EQMI_T[2][1] * EQLMN2[1][3]) + (EQMI_T[2][2] * EQLMN2[2][3]) + (EQMI_T[2][3] * EQLMN2[3][3]);
+
+    MATRICE[3][1] = (EQMI_T[3][1] * EQLMN2[1][1]) + (EQMI_T[3][2] * EQLMN2[2][1]) + (EQMI_T[3][3] * EQLMN2[3][1]);
+    MATRICE[3][2] = (EQMI_T[3][1] * EQLMN2[1][2]) + (EQMI_T[3][2] * EQLMN2[2][2]) + (EQMI_T[3][3] * EQLMN2[3][2]);
+    MATRICE[3][3] = (EQMI_T[3][1] * EQLMN2[1][3]) + (EQMI_T[3][2] * EQLMN2[2][3]) + (EQMI_T[3][3] * EQLMN2[3][3]);
+
+
+    // Calcule l'offset sur le ciel
+
+    VECT_OFFSET.x = m1.x - ((a1.x * MATRICE[1][1]) + (a1.y * MATRICE[2][1]) + (a1.z * MATRICE[3][1]));
+    VECT_OFFSET.y = m1.y - ((a1.x * MATRICE[1][2]) + (a1.y * MATRICE[2][2]) + (a1.z * MATRICE[3][2]));
+    VECT_OFFSET.z = m1.z - ((a1.x * MATRICE[1][3]) + (a1.y * MATRICE[2][3]) + (a1.z * MATRICE[3][3]));
+
+
+
+    if (x + y == 0 )
+    {
+        return 0;
+    }
+    else
+    {
+        return  PointSitueDansSurfaceTriangle(x, y, a1.x, a1.y, a2.x, a2.y, a3.x, a3.y);
+    }
+}
+
+
+void Alignement::AppliquerMatriceCorrectionTaki(Coord * result, Coord vect)
+{
+    // Applique la correction sur le vecteur orientation vect avec
+    // vect.x = ascension droite
+    // vect.y = dÃ©clinaison
+    // 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]));
+}
+
+
+
+
+/**************************************************************************************
+** Matrice intermÃ©diaire nÃ©cessaire au calcul de la matrice de correction
+** dans le mode d'alignement AFFINE
+**
+***************************************************************************************/
+
+void Alignement::Calculer_Matrice_GETPQ(Coord p1, Coord p2, Coord p3)
+{
+    GETPQ[1][1] = p2.x - p1.x;
+    GETPQ[2][1] = p3.x - p1.x;
+    GETPQ[1][2] = p2.y - p1.y;
+    GETPQ[2][2] = p3.y - p1.y;
+}
+
+
+
+/**************************************************************************************
+** Calcul de la matrice de correction dans le mode d'alignement AFFINE
+**
+***************************************************************************************/
+
+int Alignement::Calculer_Matrice_Affine( double x, double y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
+{
+    double Det;
+    double EQMI[4][4];
+    double EQMP[4][4];
+    double EQMQ[4][4];
+
+    //Construit les matrices EQMP et EQMQ
+
+    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];
+
+    // Calcule l'inverse de EQMP
+
+    Det = (EQMP[1][1] * EQMP[2][2]) - (EQMP[1][2] * EQMP[2][1]);
+
+    if (Det == 0)
+    {
+        ErreurLog("Erreur Matrice_Affine. Impossible de calculer l'inverse de la matrice avec un determinant = 0 \n");
+        return 0;
+    }
+    else
+    {
+        // Si le dÃ©terminant n'est pas nul
+        EQMI[1][1] =  EQMP[2][2] / Det;
+        EQMI[1][2] = -EQMP[1][2] / Det;
+        EQMI[2][1] = -EQMP[2][1] / Det;
+        EQMI[2][2] =  EQMP[1][1] / Det;
+    }
+
+
+    // MATRICE = EQMI * EQMQ
+
+    MATRICE[1][1] = (EQMI[1][1] * EQMQ[1][1]) + (EQMI[1][2] * EQMQ[2][1]);
+    MATRICE[1][2] = (EQMI[1][1] * EQMQ[1][2]) + (EQMI[1][2] * EQMQ[2][2]);
+    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;
+}
+
+
+
+/**************************************************************************************
+** Calcule la quantitÃ© CoordObjets * MATRICECorrection + VECT_offset
+**
+***************************************************************************************/
+
+void Alignement::AppliquerMatriceCorrectionAffine( Coord * result, Coord ob)
+{
+    result->x = VECT_OFFSET.x + ((ob.x * MATRICE[1][1]) + (ob.y * MATRICE[2][1]));
+    result->y = VECT_OFFSET.y + ((ob.x * MATRICE[1][2]) + (ob.y * MATRICE[2][2]));
+}
+
+
+
+/**************************************************************************************
+** Calcule la matrice de correction issue de la procÃ©dure d'alignement des antennes
+**
+** Cette mÃ©thode qui utilise trois points de correction seulement est particuliÃšrement
+** simple mais repose sur la qualitÃ© des pointages effectuÃ©s lors de l'alignement sur
+** les trois Ã©toiles et ne prend en compte de la torsion de la monture etc...
+**
+** Les variables a1, a2, a3 contiennent les coordonnÃ©es horaires calculÃ©es (AD & Dec) des trois
+** Ã©toiles visÃ©es...
+** Les variables m1, m2, m3 contiennent les coordonnÃ©es horaires effectivement mesurÃ©es
+** de ces trois mÃªmes objets
+**
+***************************************************************************************/
+
+int Alignement::Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3)
+{
+    double x, y, z;
+
+    Coord aa1, aa2, aa3;
+    Coord mm1, mm2, mm3;
+
+    stringstream os;
+
+    // Pour chaque variable coordonnÃ©es, on calcule d'abord l'azimut et la hauteur de l'objet correspondant
+    
+    Azimut(a1.x, a1.y, &aa1.x, &aa1.y);
+
+    // puis on transforme les coordonnÃ©es sphÃ©riques (azi, haut) en coordonnÃ©es cartÃ©siennes x, y, z
+    x=cos(aa1.x) * cos(aa1.y);
+    y=sin(aa1.x) * cos(aa1.y);
+    z=sin(aa1.y);
+    aa1.x=x;
+    aa1.y=y;
+    aa1.z=z;
+
+    Azimut(a2.x, a2.y, &aa2.x, &aa2.y);
+    os << "a2.y " << a2.y << "\n";
+    x=cos(aa2.x) * cos(aa2.y);
+    y=sin(aa2.x) * cos(aa2.y);
+    z=sin(aa2.y);
+    aa2.x=x;
+    aa2.y=y;
+    aa2.z=z;
+
+    Azimut(a3.x, a3.y, &aa3.x, &aa3.y);
+    os << "a3.y " << a3.y << "\n";
+    x=cos(aa3.x) * cos(aa3.y);
+    y=sin(aa3.x) * cos(aa3.y);
+    z=sin(aa3.y);
+    aa3.x=x;
+    aa3.y=y;
+    aa3.z=z;
+
+    Azimut(m1.x, m1.y, &mm1.x, &mm1.y);
+    os << "m1.y " << m1.y << "\n";
+    x=cos(mm1.x) * cos(mm1.y);
+    y=sin(mm1.x) * cos(mm1.y);
+    z=sin(mm1.y);
+    mm1.x=x;
+    mm1.y=y;
+    mm1.z=z;
+
+    Azimut(m2.x, m2.y, &mm2.x, &mm2.y);
+    os << "m2.y " << m2.y << "\n";
+    x=cos(mm2.x) * cos(mm2.y);
+    y=sin(mm2.x) * cos(mm2.y);
+    z=sin(mm2.y);
+    mm2.x=x;
+    mm2.y=y;
+    mm2.z=z;
+
+    Azimut(m3.x, m3.y, &mm3.x, &mm3.y);
+    os << "m3.y " << m3.y << "\n";
+    x=cos(mm3.x) * cos(mm3.y);
+    y=sin(mm3.x) * cos(mm3.y);
+    z=sin(mm3.y);
+    mm3.x=x;
+    mm3.y=y;
+    mm3.z=z;
+
+    // On se retouvre Ã  devoir rÃ©soudre les equations:
+
+    // mm1 = aa1 * MATRICE_Correction
+    // mm2 = aa2 * MATRICE_Correction
+    // mm3 = aa3 * MATRICE_Correction
+
+    // et donc Ã  trouver les Ã©lÃ©ments de la matrice MATRICE_Correction en fonction des paramÃštres x, y, z des vecteurs
+    // aa1, aa2, aa3, mm1, mm2, mm3
+
+    // Les Ã©lÃ©ments de la matrice se trouvent aisÃ©ment
+
+    double div= aa1.z*aa2.y*aa3.x - aa1.y*aa2.z*aa3.x - aa1.z*aa2.x*aa3.y +
+                aa1.x*aa2.z*aa3.y + aa1.y*aa2.x*aa3.z - aa1.x*aa2.y*aa3.z;
+
+    if ( div !=0.0 )
+    {
+
+        double mm11 = -(((-aa2.z)*aa3.y*mm1.x + aa2.y*aa3.z*mm1.x + aa1.z*aa3.y*mm2.x - aa1.y*aa3.z*mm2.x -
+                         aa1.z*aa2.y*mm3.x + aa1.y*aa2.z*mm3.x)/div);
+
+        double mm12 = -((aa2.z*aa3.x*mm1.x - aa2.x*aa3.z*mm1.x - aa1.z*aa3.x*mm2.x + aa1.x*aa3.z*mm2.x + aa1.z*aa2.x*mm3.x - aa1.x*aa2.z*mm3.x)/div);
+
+        double mm13 = -(((-aa2.y)*aa3.x*mm1.x + aa2.x*aa3.y*mm1.x + aa1.y*aa3.x*mm2.x - aa1.x*aa3.y*mm2.x - aa1.y*aa2.x*mm3.x + aa1.x*aa2.y*mm3.x)/div);
+
+        double mm21 = -(((-aa2.z)*aa3.y*mm1.y + aa2.y*aa3.z*mm1.y + aa1.z*aa3.y*mm2.y - aa1.y*aa3.z*mm2.y -
+                         aa1.z*aa2.y*mm3.y + aa1.y*aa2.z*mm3.y)/div);
+
+        double mm22 = -((aa2.z*aa3.x*mm1.y - aa2.x*aa3.z*mm1.y - aa1.z*aa3.x*mm2.y + aa1.x*aa3.z*mm2.y + aa1.z*aa2.x*mm3.y -
+                         aa1.x*aa2.z*mm3.y)/div);
+
+        double mm23 = -(((-aa2.y)*aa3.x*mm1.y + aa2.x*aa3.y*mm1.y + aa1.y*aa3.x*mm2.y - aa1.x*aa3.y*mm2.y -
+                         aa1.y*aa2.x*mm3.y + aa1.x*aa2.y*mm3.y)/div);
+
+        double mm31 = -(((-aa2.z)*aa3.y*mm1.z + aa2.y*aa3.z*mm1.z + aa1.z*aa3.y*mm2.z - aa1.y*aa3.z*mm2.z -
+                         aa1.z*aa2.y*mm3.z + aa1.y*aa2.z*mm3.z)/div);
+
+        double mm32 = -((aa2.z*aa3.x*mm1.z - aa2.x*aa3.z*mm1.z - aa1.z*aa3.x*mm2.z + aa1.x*aa3.z*mm2.z + aa1.z*aa2.x*mm3.z -
+                         aa1.x*aa2.z*mm3.z)/div);
+
+        double mm33 = -(((-aa2.y)*aa3.x*mm1.z + aa2.x*aa3.y*mm1.z + aa1.y*aa3.x*mm2.z - aa1.x*aa3.y*mm2.z -
+                         aa1.y*aa2.x*mm3.z + aa1.x*aa2.y*mm3.z)/div);
+
+
+
+        MATRICE[1][1] = mm11;
+        MATRICE[2][1] = mm12;
+        MATRICE[3][1] = mm13;
+
+        MATRICE[1][2] = mm21;
+        MATRICE[2][2] = mm22;
+        MATRICE[3][2] = mm23;
+
+        MATRICE[1][3] = mm31;
+        MATRICE[2][3] = mm32;
+        MATRICE[3][3] = mm33;
+
+	//Pour vÃ©rifs
+        //RotationAutourDunAxe(0.3,Pi/2.0-0.1, 0.2);
+       
+	return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+void Alignement::AppliquerMatriceCorrectionSimple(Coord * result, Coord vect)
+{
+    // Applique la correction sur le vecteur orientation vect avec
+
+    result->x = vect.x * MATRICE[1][1] + vect.y * MATRICE[2][1] + vect.z * MATRICE[3][1];
+    result->y = vect.x * MATRICE[1][2] + vect.y * MATRICE[2][2] + vect.z * MATRICE[3][2];
+    result->z = vect.x * MATRICE[1][3] + vect.y * MATRICE[2][3] + vect.z * MATRICE[3][3];
+}
+
+
+
+
+/**************************************************************************************
+** Calcule la surface d'un triangle de coordonnÃ©es (px1,py1) (px2, py2) (px3, py3)
+**
+***************************************************************************************/
+
+double Alignement::Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3)
+{
+    double ta;
+
+    ta = (((px2 * py1) - (px1 * py2)) ) + (((px3 * py2) - (px2 * py3))  ) + (((px1 * py3) - (px3 * py1))  );
+
+    return  fabs(ta) / 2.0;
+}
+
+
+/**************************************************************************************
+** Est-ce que le point de coordonnÃ©es (px, py) se trouve dans la surface du triangle
+** de coordonnÃ©es (px1,py1) (px2, py2) (px3, py3) ?
+**
+***************************************************************************************/
+
+bool Alignement::PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3)
+{
+    double ta;
+    double t1;
+    double t2;
+    double t3;
+
+    ta = Surface_Triangle(px1, py1, px2, py2, px3, py3);
+    t1 = Surface_Triangle(px,  py,  px2, py2, px3, py3);
+    t2 = Surface_Triangle(px1, py1, px,  py,  px3, py3);
+    t3 = Surface_Triangle(px1, py1, px2, py2, px,  py);
+
+    stringstream os;
+
+    os << fabs(ta - t1 - t2 - t3)<< "\n";
+    AfficherLog(os.str().c_str(), true);
+
+    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;
+
+    return ( fabs(ta - t1 - t2 - t3) < 1e-10 );
+}
+
+
+/**************************************************************************************
+** Calcule la matrice de correction issue de la procÃ©dure d'alignement des antennes
+**
+** Routine principale. On construit ici trois vecteurs c1, c2 et c3 qui contiennent
+** les coordonnÃ©es (issues du catalogue) de trois objets visÃ©s pendant la procÃ©dure
+** d'alignement. Les vecteurs m1, m2 et m3 contiennent les coordonnÃ©es mesurÃ©es
+** de ces mÃªmes objets dans le viseur de l'instrument.
+**
+***************************************************************************************/
+
+void Alignement::CalculerMatriceCorrection(double ar, double dec)
+{
+    Coord c1, c2, c3, c4, m1, m2, m3, m4;
+
+    double a1, b1, a2, b2;
+
+    int map[MAXALIGNEMENTANTENNE];
+
+    stringstream os;
+
+    int best1 = 0;
+    int best2 = 0;
+    int best3 = 0;
+    
+    
+    // On calcule le temps sidÃ©ral local, etc...
+    
+    CalculTSL();
+
+    switch ( MethodeAlignement )
+    {
+    case SIMPLE :
+    {
+        best1 = 1;
+        best2 = 2;
+        best3 = 3;
+
+        for (int i=0; i<MAXALIGNEMENTANTENNE; i++) map[i] = i;
+    }
+    break;
+
+
+    case AFFINE:
+    case TAKI  :
+    {
+
+        double *distances;
+
+        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++)
+        {
+            Azimut(VerifAngle(ad[i]-tsl[i]),de[i], &a1, &b1);
+
+            distances[i] = DistanceAngulaireEntre2Points(a1, b1, a2, b2);
+
+            map[i]=i;
+        }
+
+        for (int i=1; i<=nbrcorrections; i++)
+        {
+            for (int j=i+1; j<=nbrcorrections; j++)
+            {
+                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;
+                }
+            }
+        }
+
+        for (int i=1; i<=nbrcorrections; i++)
+        {
+            os << "Point " << map[i] << "  d=" << distances[i] << "\n";
+        }
+
+        for (int i=1; i<=nbrcorrections; i++)
+        {
+            for (int j=i+1; j<=nbrcorrections; j++)
+            {
+                for (int k=j+1; k<=nbrcorrections; k++)
+                {
+                    double a,b;
+
+                    os << "Triangle : " << map[i] << " " << map[j] << " " << map[k]  << "\n";
+
+                    os << "Objet ";
+
+                    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";
+
+                    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]]))
+                    {
+                        best1=i;
+                        best2=j;
+                        best3=k;
+                        k=1000;
+                        j=1000;
+                        i=1000;
+                    }
+                }
+            }
+        }
+
+        delete [] distances;
+    }
+    break;
+    }
+
+
+
+    if ( best1 == 0 && best2 == 0 && best3 == 0 )
+    {
+        if (MethodeAlignement == AFFINE || MethodeAlignement == TAKI)
+        {
+            ErreurLog("Erreur ! Pas de triangle disponible pour la correction !\nLe positionnement de l antenne sera approximatif !\n");
+        }
+
+        Identity();
+
+        Matrice_ok = false;
+
+        return;
+    }
+    else
+    {
+        os << "\nUtilisation du triangle : " << map[best1] << " " << map[best2] << " " << map[best3]  << "\n" ;
+
+        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]] + GetTSL());
+        c2.y = de[map[best2]];
+        c2.z = 1.0;
+
+        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.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.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.z = 1.0;
+    }
+
+    // Calcul de la matrice de correction en fonction de la mÃ©thode d'alignement
+
+    switch (MethodeAlignement)
+    {
+    case SIMPLE:
+        os << "Methode d alignement SIMPLE\n";
+        Matrice_ok = Calculer_Matrice_Simple(c1, c2, c3 ,m1, m2, m3);
+        break;
+    case AFFINE:
+        os << "Methode d alignement AFFINE\n";
+        Matrice_ok = Calculer_Matrice_Affine( VerifAngle( ar - GetTSL() ), dec, 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);
+        break;
+    }
+
+
+    // Affiche de la matrice pour vÃ©rif
+
+    os << "\nCalcul de la matrice de correction:\n";
+    os << MATRICE[1][1] << "   \t" << MATRICE[2][1] << "    \t" << MATRICE[3][1] << "\n";
+    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";
+
+    
+    
+    
+
+    
+    //VÃ©rifications supp
+    /*
+    Coord result, mm1;
+    double targetAz, targetAlt;
+
+    os << "\n\n\n" << GetLatitude()*N180divPi << "      " << GetLongitude()*N180divPi << "\n";
+    os << GetPression() << "      " << GetTemperature() << "\n";
+    os << GetHeure() << ":" << GetMin() << ":" << GetSec() << "\n";
+    os << DHMS(GetTSL()*N180divPi, true) << "\n\n";
+    
+      Azimut(c3.x, c3.y, &mm1.x, &mm1.y);
+
+    os << mm1.x*N180divPi << "   "  <<  mm1.y*N180divPi << "\n";
+
+
+    Azimut(m3.x, m3.y, &mm1.x, &mm1.y);
+
+    os << mm1.x*N180divPi << "   "  <<  mm1.y*N180divPi << "\n";
+
+
+    Azimut(c3.x, c3.y, &mm1.x, &mm1.y);
+
+    double x=cos(mm1.x) * cos(mm1.y);
+    double y=sin(mm1.x) * cos(mm1.y);
+    double z=sin(mm1.y);
+    mm1.x=x;
+    mm1.y=y;
+    mm1.z=z;
+
+    AppliquerMatriceCorrectionSimple(&result, mm1);
+
+    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);
+
+    os << targetAz*N180divPi << "   "  <<  targetAlt*N180divPi << "\n";
+    */
+
+    
+    
+    //Afficher les messages de cette fonction
+
+    AfficherLog(os.str(), true);
+}
+
+
+
+/**************************************************************************************
+** Le fichier file existe-t-il et n'est-il pas vide ?
+**************************************************************************************/
+
+bool Alignement::is_readable( const std::string & file )
+{
+    std::ifstream fichier( file.c_str() );
+    if (fichier.fail()) return false;
+
+    // sauvegarder la position courante
+    long pos = fichier.tellg();
+    // se placer en fin de fichier
+    fichier.seekg( 0 , std::ios_base::end );
+    // rÃ©cupÃ©rer la nouvelle position = la taille du fichier
+    long size = fichier.tellg();
+    return (size > 0);
+}
+
+
+/**************************************************************************************
+** Chargement des paramÃštres d'alignement des antennes
+**************************************************************************************/
+
+bool Alignement::ChargementParametresAlignement(string IP, string fileName, double a, double b)
+{
+    static double mema = a;
+
+    static double memb = b;
+
+    string value;
+
+    stringstream os, os2;
+
+    char *delta_az_polar_data = NULL;
+
+    char *ad_data = NULL;
+
+    char *de_data = NULL;
+
+    char *delta_ad_data = NULL;
+
+    char *delta_de_data = NULL;
+
+    char *align_data = NULL;
+
+    char *alignment_method_data = NULL;
+
+    char *tsl_data = NULL;
+
+
+    if (!is_readable(fileName)) return false;
+
+    // Chargement des corrections des antennes
+
+    bool modificationAlignement = false;
+
+    // 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++)
+    {
+        os2 << "ad " << j;
+
+        readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &ad_data,  (char*)fileName.c_str());
+
+        os2.str("");
+
+        os2 << "de " << j;
+
+        readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &de_data,  (char*)fileName.c_str());
+
+        os2.str("");
+
+        os2 << "delta_ad " << j;
+
+        readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_ad_data,  (char*)fileName.c_str());
+
+        os2.str("");
+
+        os2 << "delta_de " << j;
+
+        readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_de_data,  (char*)fileName.c_str());
+
+        os2.str("");
+
+        os2 << "tsl " << j;
+
+        readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &tsl_data,  (char*)fileName.c_str());
+
+        os2.str("");
+
+
+        if ( ad_data && de_data && delta_ad_data && delta_de_data
+                && tsl_data && atof(tsl_data)!=0.0 && atof(ad_data)!=0.0 && atof(de_data)!=0.0)
+        {
+            // Si les corrections de l'antenne i ont Ã©tÃ© modifiÃ©es depuis le dÃ©marrage du programme
+            // -> on les applique...
+
+            nbrcorrections = j;
+
+            if (delta_ad[j] != atol(delta_ad_data) || delta_de[j] != atol(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";
+
+                AfficherLog(&os2, true);
+
+                modificationAlignement = true;
+            }
+        }
+
+        SAFEDELETE_TAB(ad_data);
+
+        SAFEDELETE_TAB(de_data);
+
+        SAFEDELETE_TAB(delta_ad_data);
+
+        SAFEDELETE_TAB(delta_de_data);
+
+        SAFEDELETE_TAB(tsl_data);
+    }
+
+    os2 << "delta_az_polar";
+
+    readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &delta_az_polar_data,  (char*)fileName.c_str());
+
+    os2.str("");
+
+    if (delta_az_polar_data)
+    {
+        if ( delta_az_polar != atol(delta_az_polar_data) )
+        {
+            delta_az_polar = atol(delta_az_polar_data);
+
+            modificationAlignement = true;
+        }
+    }
+
+    os2 << "alignment_method";
+
+    readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &alignment_method_data,  (char*)fileName.c_str());
+
+    os2.str("");
+
+    if (alignment_method_data)
+    {
+        if ( MethodeAlignement != atoi(alignment_method_data) )
+        {
+            MethodeAlignement = atoi(alignment_method_data);
+
+            modificationAlignement = true;
+        }
+    }
+
+    os2 << "align";
+
+    readINI((char*)os.str().c_str(), (char*)os2.str().c_str(), &align_data,  (char*)fileName.c_str());
+
+    os2.str("");
+
+
+    if (align_data)
+    {
+        // Si la procÃ©dure d'alignement se termine, il faut calculer la matrice de correction
+        
+        if (AlignementEnCours != atoi(align_data))
+        {
+            AlignementEnCours = atoi(align_data);
+
+            modificationAlignement = true;
+        }
+    }
+
+    if (mema!=a || memb!=b)
+    {
+        mema = a;
+
+        memb = b;
+
+        modificationAlignement = true;
+    }
+
+    // si nbrcorrections=0 (suite Ã  l'utilisation de la commande reset dans BAOcontrol par ex) il faut
+    // rÃ©initialiser la matrice
+
+    if (nbrcorrections == 0 ) modificationAlignement = true;
+
+
+    // Si un des paramÃštres d'une antenne change pendant la procÃ©dure d'alignement ou que l'on a
+    // plus de deux points d'alignement sur une antenne, alors on calcule la matrice de correction
+
+    if (modificationAlignement)
+    {
+        if  (nbrcorrections >=3 && AlignementEnCours == 0)
+        {
+            // IDLog("Calcul matrice\n", true);
+            CalculerMatriceCorrection(a, b);
+        }
+        else
+        {
+            Identity();
+
+            Matrice_ok = false;
+        }
+    }
+
+    SAFEDELETE_TAB(delta_az_polar_data);
+
+    SAFEDELETE_TAB(alignment_method_data);
+
+    SAFEDELETE_TAB(align_data);
+
+    return true;
+}
+
+
+
+/**************************************************************************************
+** Sauvegarde des paramÃštres d'alignement des antennes
+***************************************************************************************/
+
+bool Alignement::EnregistrementParametresAlignement(string IP, string fileName)
+{
+    string section;
+    string key;
+    string value;
+
+    stringstream os;
+
+    
+    //AfficherLog("Enregistrement de l'alignement des antennes dans le fichier " + fileName + "\n", true);
+
+    //Enregistrement des corrections des l'antennes
+
+    os << "Alignement antenne ip x.x.x." << 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";
+    key     = os.str();
+    os.str("");
+    (AlignementEnCours == true) ? os << "1" : os << "0";
+    value = os.str();
+    os.str("");
+
+    writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+    os << "alignment_method";
+    key     = os.str();
+    os.str("");
+    os << MethodeAlignement;
+    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 = 1; j <= MAXALIGNEMENTANTENNE; j++)
+    {
+        os << "ad " << j;
+        key     = os.str();
+        os.str("");
+        os << 0.0;
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "de " << j;
+        key     = os.str();
+        os.str("");
+        os << 0.0;
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "delta_ad " << j;
+        key     = os.str();
+        os.str("");
+        os << 0;
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "delta_de " << j;
+        key     = os.str();
+        os.str("");
+        os << 0;
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "tsl " << j;
+        key     = os.str();
+        os.str("");
+        os << 0.0;
+        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 = 1; j <= nbrcorrections; j++)
+    {
+        os << "ad " << j;
+        key     = os.str();
+        os.str("");
+        os << ad[j];
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "de " << j;
+        key     = os.str();
+        os.str("");
+        os << de[j];
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "delta_ad " << j;
+        key     = os.str();
+        os.str("");
+        os << delta_ad[j];
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "delta_de " << j;
+        key     = os.str();
+        os.str("");
+        os << delta_de[j];
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+
+        os << "tsl " << j;
+        key     = os.str();
+        os.str("");
+        os << tsl[j];
+        value = os.str();
+        os.str("");
+
+        writeINI((char*)section.c_str(), (char*)key.c_str(), (char*)value.c_str(), (char*)fileName.c_str());
+    }
+
+
+    return true;
+}
+
+
+bool Alignement::EnregistrementParametresAlignement(int IP, string fileName)
+{
+    stringstream os;
+
+    os << IP;
+
+    return EnregistrementParametresAlignement(os.str(), fileName);
+}
Index: /BAORadio/libindi/libindi/communs/alignement.h
===================================================================
--- /BAORadio/libindi/libindi/communs/alignement.h	(revision 644)
+++ /BAORadio/libindi/libindi/communs/alignement.h	(revision 644)
@@ -0,0 +1,131 @@
+////////////////////////////////
+// Classe Alignement          //
+// Franck RICHARD             //
+// BAORadio                   //
+// franckrichard033@gmail.com //
+// fÃ©vrier 2012               //
+////////////////////////////////
+
+
+
+#ifndef Alignement_class
+#define Alignement_class
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include <math.h>
+#include <unistd.h>
+#include <time.h>
+#include <memory>
+#include <pthread.h>
+#include <iostream>
+#include <time.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <fstream>
+#include "../communs/const.h"
+#include "../communs/filetools.h"
+#include "../communs/astro.h"
+#include "../communs/logs.h"
+
+
+using namespace std;
+
+
+struct Coord
+{
+    double x;
+    double y;
+    double z;
+};
+
+class Alignement : public Astro, public Logs
+{
+public:
+    Alignement();
+    ~Alignement();
+
+    void InitAlignement();
+    void TransmettreParametresClasseAstro(double Annee, double Mois, double Jour, double Heu, double Min, double Sec, double Longitude, double Latitude, double Pression, double Temp);
+
+
+    /*******************************************************/
+    /* Gestion des fichiers de paramÃštres
+    ********************************************************/
+    bool is_readable( const std::string & file );
+    bool ChargementParametresAlignement(string IP, string fileName, double ad, double de);
+
+    // bool ChargementParametresAlignement(string fileName, int ip, int num);
+    bool EnregistrementParametresAlignement(string IP, string fileName);
+    bool EnregistrementParametresAlignement(int IP, string fileName);
+
+
+
+    /*******************************************************/
+    /* Calcul des matrices
+    ********************************************************/
+
+    //RÃ©initialisation MATRICE = Matrice identitÃ©
+    void Identity();
+    void RotationAutourDunAxe(double t, double r, double alpha);
+    
+    // MÃ©thode de correction "simple
+    int  Calculer_Matrice_Simple( Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3);
+    void AppliquerMatriceCorrectionSimple( Coord * result, Coord vect);
+
+
+    // MÃ©thode de correction "affine"
+    void Calculer_Matrice_GETPQ(Coord p1, Coord p2, Coord p3);
+    int  Calculer_Matrice_Affine(double x, double y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3);
+    void AppliquerMatriceCorrectionAffine( Coord* result, Coord ob);
+
+    // MÃ©thode correction "Taki"
+    void Calculer_Matrice_LMN(Coord p1, Coord p2, Coord p3);
+    int  Calculer_Matrice_Taki(double x, double Y, Coord a1, Coord a2, Coord a3, Coord m1, Coord m2, Coord m3);
+    void AppliquerMatriceCorrectionTaki(Coord * result, Coord vect);
+
+
+    void CalculerMatriceCorrection(double ad, double de);
+
+
+    double Surface_Triangle(double px1, double py1, double px2, double py2, double px3, double py3);
+    bool PointSitueDansSurfaceTriangle(double px, double py, double px1, double py1, double px2, double py2, double px3, double py3);
+
+
+
+
+
+    int MethodeAlignement;                      // MÃ©thode d'alignement utilisÃ©e
+
+    int nbrcorrections;                         // Nombre de points utilisÃ©s pour bÃ¢tir la ou les matrices de correction
+
+    int AlignementEnCours;
+
+    bool Matrice_ok;				// Il existe une matrice de correction applicable Ã  la direction de l'observation
+
+    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
+
+    double ad[MAXALIGNEMENTANTENNE];            // CoordonnÃ©es horaires d'un point de correction
+
+    double de[MAXALIGNEMENTANTENNE];
+
+    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Ã©
+
+    long delta_de[MAXALIGNEMENTANTENNE];
+
+    double MATRICE[4][4];                       // La matrices de correction calculÃ©e dans les trois modes d'alignement
+
+    Coord  VECT_OFFSET;                      // Vecteur offset que l'on applique dans les modes affine/taki
+
+    double GETLMN[4][4];                        // Matrices intermÃ©diaires nÃ©cessaires pour le calcul des matrices de correction
+    // dans les modes d'alignement AFFINE/TAKI
+    double GETPQ[4][4];
+};
+
+#endif
Index: /BAORadio/libindi/libindi/communs/alt2motor.h
===================================================================
--- /BAORadio/libindi/libindi/communs/alt2motor.h	(revision 644)
+++ /BAORadio/libindi/libindi/communs/alt2motor.h	(revision 644)
@@ -0,0 +1,18 @@
+#ifndef __motor__
+#define __motor__
+
+
+#include "const.h"
+ 
+double Alt2Motor(double targetAlt)
+{
+    double I0 = 81.0;
+    
+    double I2 = 128279.4 - 129723.4 * sin( (targetAlt - 20.2345) * Pidiv180 );
+
+    double Codalt = (sqrt(I2) - I0) / 0.078947;
+
+    return Codalt;  
+}
+
+#endif
Index: /BAORadio/libindi/libindi/communs/astro.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/astro.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/astro.cpp	(revision 644)
@@ -0,0 +1,1013 @@
+////////////////////////////////
+// Classe Astro               //
+// Franck RICHARD             //
+// franckrichard033@gmail.com //
+// BAORadio                   //
+// juin 2011                  //
+////////////////////////////////
+
+
+#include "astro.h"
+
+
+/**************************************************************************************
+** Constructeur de la classe Astro
+**
+***************************************************************************************/
+
+Astro::Astro()
+{
+    //Initialisation des variables
+    
+    Longitude = 0.0;                     // CordonnÃ©es du lieu d'observation
+    Latitude  = 0.0;
+    
+    Annee     = 0.0;                     // Date et heure de l'observation
+    Mois      = 0.0;
+    Jour      = 0.0;
+    Heure     = 0.0;
+    Min       = 0.0;
+    Sec       = 0.0;
+    UTCP      = 0.0;			 // permet de gÃ©rer le fuseau horaire
+                                         // mais semble inutile sous Linux
+    
+    hs        = 0.0;                     // fraction du jour en cours 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 
+    CorEP     = 0.0; 			 // Nutation en inclinaison
+    
+    Pression  = 1013.0;
+    Temp      = 0.0;
+     
+    LongitudeSoleil = 0.0;
+}
+
+
+/**************************************************************************************
+** Constructeur de la classe Astro
+**
+***************************************************************************************/
+
+Astro::~Astro()
+{
+}
+
+
+/**************************************************************************************
+** Initialisation des variables globales de la classe Astro
+**
+***************************************************************************************/
+
+void Astro::DefinirDateHeure(double A, double M, double J, double H, double Mi, double S)
+{
+    Annee = A;
+    Mois  = M;
+    Jour  = J;
+    Heure = H;
+    Min   = Mi;
+    Sec   = S;
+}
+
+void Astro::DefinirPressionTemp(double P, double T)
+{
+    Pression = P;
+    Temp     = T;
+}
+
+void Astro::DefinirLongitudeLatitude(double log, double lat)
+{
+    Longitude = log;
+    Latitude  = lat;
+}
+
+
+
+/**************************************************************************************
+** ParamÃštre : angle en radians
+** retourne angle dans un intervalle 0 <= Angle <= 2*PI
+***************************************************************************************/
+
+double Astro::VerifAngle(double Angle)
+{
+    Angle=fmod(Angle, Pi2);
+    if (Angle<0.0) Angle+=Pi2;
+
+    return(Angle);
+}
+
+/**************************************************************************************
+** ParamÃštre : angle en radians
+** retourne angle dans un intervalle 0 <= Angle <= PI
+***************************************************************************************/
+
+double Astro::VerifDistance(double Angle)
+{
+	Angle=VerifAngle(Angle);
+	if (Angle>Pi) Angle=Pi2-Angle;
+
+	return(Angle);
+}
+
+
+/**************************************************************************************
+** 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)); 
+}
+
+
+/**************************************************************************************
+** retourne l'arrondi du nombre donnÃ© en paramÃštre
+** Exemples: Arrondi(5.7) =  6
+**           Arrondi(-5.7)= -6
+***************************************************************************************/
+
+double Astro::Arrondi(double a)
+{
+    double b;
+
+    if (a>=0.0)
+    {
+        b=a-floor(a);
+        if (b>=0.5) return ceil(a);
+        else return floor(a);
+    }
+    else
+    {
+        b=ceil(a)-a;
+        if (b>=0.5) return floor(a);
+        else return ceil(a);
+    }
+}
+
+
+
+/**************************************************************************************
+** converti un angle (exprimÃ© en degrÃ©s) dans le format hh:mm:ss ou deg:mm:ss
+** selon la valeur de HMS
+***************************************************************************************/
+
+string Astro::DHMS(double mema, bool HMS)
+{
+    double d, m, s, a;
+
+    a=mema;
+
+    if (HMS) a=a / 15.0;
+    a=fabs(a * 3600.0);
+    s=Arrondi(fmod(a, 60.0) * 10.0) / 10.0;
+    a=floor(a / 60.0);
+    m=fmod(a, 60.0);
+    d=floor(a / 60.0);
+
+    if (s == 60.0)
+    {
+        s=0.0;
+        m+=1.0;
+        if (m==60.0)
+        {
+            m=0.0;
+            d+=1.0;
+
+            if (HMS && d>23.0) d=0.0;
+        }
+    }
+
+    stringstream strsTemp;
+
+    if (mema < 0) strsTemp << '-';
+
+    strsTemp << setfill('0') << setw(2) << d << ":" << setfill('0') << setw(2) << m << ":" << setfill('0') << setw(2) << s;
+
+    return (strsTemp.str());
+}
+
+
+/**************************************************************************************
+** Calcul de la longitude du Soleil
+** La quantitÃ© PS n'est pas indispensable. Elle permet d'amÃ©liorer la prÃ©cision
+***************************************************************************************/
+
+double Astro::CalculLongitudeSoleil()
+{
+    double T = (JJ - 2415020.0) / 36525.0;
+
+    double A = 153.23 + 22518.7541 * T;
+    double B = 216.57 + 44037.5082 * T;
+    double C = 312.69 + 32964.3577 * T;
+    double D = 350.74 + ( 445267.1142 - 0.00144 * T ) * T;
+    double E = 231.19 + 20.2 * T;
+
+
+    double L = 279.69668 + ( 36000.76892 + 0.0003025 * T ) * T;
+    double M = 358.47583 + (((( -0.0000033 * T) -0.00015 )  * T ) + 35999.04975 ) * T;
+
+    double CC =   (1.919460 + ((-0.000014 * T) - 0.004789 ) * T ) * sin(M * Pidiv180)
+                  + (0.020094 - 0.0001 * T) * sin(2.0 * M * Pidiv180)
+                  + 0.000293 * sin(3.0 * M * Pidiv180);
+
+    double PS =  0.00134 * cos(A * Pidiv180)
+                +0.00154 * cos(B * Pidiv180)
+                +0.00200 * cos(C * Pidiv180)
+                +0.00179 * sin(D * Pidiv180)
+                +0.00178 * sin(E * Pidiv180);
+
+
+    double LS = VerifAngle( (L + CC + PS) * Pidiv180);
+    
+    return LS;
+}
+
+
+
+/**************************************************************************************
+** Calcul de l'AD et la dÃ©clinaison du Soleil
+** indispensable pour exÃ©cuter la commande "goto sun"
+***************************************************************************************/
+
+void Astro::CalculARDecSoleil(CoordonneesHoraires *Soleil)
+{
+    double ar;
+    double de;
+    
+    ar = atan( cos(ep) * sin(LongitudeSoleil) / cos(LongitudeSoleil));
+    
+    if ( cos(LongitudeSoleil) < 0.0) ar += Pi;
+    
+    de = asin( sin(ep) * sin(LongitudeSoleil));
+
+    Soleil->ar = DHMS( VerifAngle(ar) * N180divPi, true );
+    
+    Soleil->dec = DHMS( de * N180divPi, false );
+}
+    
+
+
+
+/**************************************************************************************
+** Calcul de la nutation en longitude et en inclinaison
+** NÃ©cessaire pour calculer la position apparente d'un objet (Ã©toile, galaxie etc...)
+***************************************************************************************/
+
+void Astro::Nutation()
+{
+    double T = (JJ-2415020.0) / 36525.0;
+
+    double L  = (279.6967 + (36000.7689 + 0.000303 * T ) * T ) * Pidiv180;
+    double LP = (270.4342 + (481267.8831 - 0.001133 * T ) * T ) * Pidiv180;
+    double M  = (358.4758 + (35999.0498 - 0.000150 * T ) * T ) * Pidiv180;
+    double MP = (296.1046 + (477198.8491 + 0.009192 * T ) * T ) * Pidiv180;
+    double O  = (259.1833 + (-1934.1420 + 0.002078 * T ) * T ) * Pidiv180;
+
+    double L2  = 2.0 * L;
+    double LP2 = 2.0 * LP;
+    double O2  = 2.0 * O;
+    
+    // Nutation en longitude
+
+    CorP = -(17.2327 + 0.01737 * T) * sin(O)
+           -(1.2729+0.00013 * T) * sin(L2)
+           +0.2088 * sin(O2)
+           -0.2037 * sin(LP2)
+           +(0.1261 - 0.00031 * T) * sin(M)
+           +0.0675 * sin(MP)
+           -(0.0497 - 0.00012 * T) * sin(L2 + M)
+           -0.0342 * sin(LP2 - O)
+           -0.0261 * sin(LP2 + MP)
+           +0.0214 * sin(L2 - M)
+           -0.0149 * sin(L2 - LP2 + MP)
+           +0.0124 * sin(L2 - O)
+           +0.0114 * sin(LP2 - MP);
+	   
+    //Nutation en inclinaison
+
+    CorEP = (9.2100 + 0.00091 * T) * cos(O)
+            +(0.5522 - 0.00029 * T) * cos(L2)
+            -0.0904 * cos(O2)
+            +0.0884 * cos(LP2)
+            +0.0216 * cos(L2+M)
+            +0.0183 * cos(LP2-O)
+            +0.0113 * cos(LP2+MP)
+            -0.0093 * cos(L2-M)
+            -0.0066 * cos(L2-O);
+
+    CorP  = CorP / 3600.0 * Pidiv180;
+    CorEP = CorEP / 3600.0 * Pidiv180;
+}
+
+
+
+/**************************************************************************************
+** Nutation des Ã©toiles - on utilise les quantitÃ©s calculÃ©es prÃ©cÃ©demment
+** ar et de sont exprimÃ©s en radians
+***************************************************************************************/
+
+void Astro::NutationEtoile(double *ar, double *de)
+{
+    double a = (cos(ep) + sin(ep) * sin(*ar) * tan(*de)) * CorP - (cos(*ar) * tan(*de)) * CorEP;
+    double b = (sin(ep) * cos(*ar)) * CorP + sin(*ar) * CorEP;
+
+    *ar = VerifAngle(*ar+a);
+    *de += b;
+}
+
+
+/**************************************************************************************
+** PrÃ©cession des Ã©quinoxes
+** ar et de sont exprimÃ©s en radians
+***************************************************************************************/
+
+void Astro::Precession(double *ar, double *de)
+{
+    double t = (JJ - 2451544.5) / 36524.2199;
+
+    double ze = ((((0.018 * t) + 0.302) * t + 2304.948) * t) / 3600.0 * Pidiv180;
+    double z = ((((0.019 * t) + 1.093) * t + 2304.948) * t) / 3600.0 * Pidiv180;
+    double delta = ((((-0.042 * t) - 0.426) * t + 2004.255) * t) / 3600.0 * Pidiv180;
+
+
+    double A = cos(*de) * sin(*ar + ze);
+    double B = cos(delta) * cos(*de) * cos (*ar + ze) - sin(delta) * sin(*de);
+    double C = sin(delta) * cos(*de) * cos (*ar + ze) + cos(delta) * sin(*de);
+
+    double AMZ = atan(A / B);
+
+    if (B<0.0) AMZ += Pi;
+
+    *ar=VerifAngle(AMZ + z);
+    *de=asin(C);
+}
+
+
+
+/**************************************************************************************
+** ObliquitÃ©
+** calcul de l'inclinaison de l'axe terrestre par rapport Ã  au plan de l'Ã©cliptique
+** QuantitÃ© indispensable pour calculer le temps sidÃ©ral local et les coordonnÃ©es
+** horaires du soleil
+***************************************************************************************/
+
+void Astro::Obliquite(double JJ)
+{
+    double T;
+
+    T = (JJ - 2415020.0) / 36525.0;
+
+    ep = (23.452294+ (((0.000000503 * T ) - 0.00000164 ) * T - 0.0130125 ) * T ) * Pidiv180;
+}
+
+
+
+
+/**************************************************************************************
+** Aberration annuelle des Ã©toiles
+** ar et de sont exprimÃ©s en radians
+***************************************************************************************/
+
+void Astro::AberrationAnnuelle(double *ar, double *de)
+{
+    double c = -20.49 / 3600.0 * Pidiv180;
+    double a = c * ( cos(*ar) * cos(LongitudeSoleil) * cos(ep)
+                     + sin(*ar) * sin(LongitudeSoleil)
+                   ) / cos(*de);
+
+    double b = c * ( cos(LongitudeSoleil) * cos(ep) * (tan(ep) * cos(*de) - sin(*ar) * sin(*de))
+                     + cos(*ar) * sin(*de) * sin(LongitudeSoleil));
+
+    *ar = VerifAngle(*ar + a);
+    *de += b;
+}
+
+
+/**************************************************************************************
+** calcul Jour julien
+***************************************************************************************/
+
+void Astro::CalculJJ(double Heure)
+{
+    JJ = CalculJJ(Annee, Mois, Jour, Heure);    
+}
+
+double Astro::CalculJJ(double A, double M, double J, double Heure)
+{
+    long y, a, b, c, e, m;
+
+    long year = (long)A;
+    int month = (int)M;
+    double day = J + Heure;
+
+    y = year + 4800;
+
+    m = month;
+    if ( m <= 2 )
+    {
+        m += 12;
+        y -= 1;
+    }
+    e = (306 * (m+1))/10;
+
+    a = y/100;
+    if ( year <= 1582L )
+    {
+        if ( year == 1582L )
+        {
+            if ( month < 10 )
+                goto julius;
+            if ( month > 10)
+                goto gregor;
+            if ( day >= 15 )
+                goto gregor;
+        }
+julius:
+
+        b = -38;
+    }
+    else
+    {
+
+gregor:
+        b = (a / 4) - a;
+    }
+
+    c = (36525L * y) / 100;
+    
+    return b + c + e + day - 32167.5;
+}
+
+
+
+/**************************************************************************************
+** Temps sidÃ©ral local
+***************************************************************************************/
+
+double Astro::TSL(double JJ, double HeureSiderale, double Longitude)
+{
+    double T = (JJ - 2415020.0 ) / 36525.0;
+    double rd = 0.276919398 + ( 100.0021359 + 0.000001075 * T ) * T;
+    rd += HeureSiderale;
+    rd *= Pi2;
+    // temps sidÃ©ral apparent
+    rd += CorP * cos(ep);
+    rd -= Longitude;
+
+    return VerifAngle(rd);
+}
+
+
+/**************************************************************************************
+** routine principale des calculs
+***************************************************************************************/
+
+void Astro::CalculTSL()
+{
+    hs = (Heure + Min / 60.0 + Sec / 3600.0) / 24.0;
+
+    hs -= UTCP / 24.0;
+
+    CalculJJ(hs);
+
+    Obliquite(JJ);
+
+    Nutation();
+
+    tsl = TSL(JJ, hs, Longitude);
+
+    LongitudeSoleil = CalculLongitudeSoleil();
+}
+
+
+
+/**************************************************************************************
+** Calcule la hauteur et l'azimut des Ã©toiles en fct du lieu d'observation
+***************************************************************************************/
+
+void Astro::Azimut(double Ar, double De, double *azi, double *hau)
+{
+    double ah = tsl - Ar;
+
+    double zc = sin(Latitude) * sin(De) + cos(Latitude) * cos(De) * cos(ah);
+    double ht = atan(zc / sqrt((-zc * zc) + 1.0));
+
+    double a1 = cos(De) * sin(ah) / cos(ht);
+    double ac = (-cos(Latitude) * sin(De) + sin(Latitude) * cos(De) * cos(ah)) / cos(ht);
+    double az = atan(a1 / sqrt((-a1*a1)+1.0));
+
+    if (ac<0.0) az=Pi-az;
+
+    *azi=VerifAngle(Pi+az);
+    *hau=ht;
+}
+
+
+/**************************************************************************************
+** rÃ©fraction atmosphÃ©rique : formule simple de Jean Meeus
+** la hauteur ht est exprimÃ©e en radians
+***************************************************************************************/
+
+double Astro::RefractionAtmospherique(double ht)
+{
+    double gamma, R0, a, b, PressionTempCalc, tanHT;
+
+    if (Pression != 0.0)
+    {
+        PressionTempCalc = (Pression / 1013.25) * 273.0 / (273.0 + Temp);
+
+        if (ht <= 15.0 * Pidiv180)
+        {
+            gamma = 2.6;
+            a = 7.5262;
+            b = -2.2204;
+
+            if (ht >= 4.0 * Pidiv180)
+            {
+                gamma=-1.1;
+                a=4.4010;
+                b=-0.9603;
+            }
+
+            R0 = (pow((a+b*log(ht*N180divPi+gamma)), 2.0)) / 60.0 * Pidiv180;
+            ht += R0 * PressionTempCalc;
+        }
+        else
+        {
+            tanHT = fabs(tan(Pidiv2 - ht));
+            R0 = (0.0161877777777777777777-0.000022888888888888888 * tanHT * tanHT)
+                 * tanHT * Pidiv180;
+            ht += R0 * PressionTempCalc;
+        }
+    }
+
+    return ht;
+}
+
+
+
+
+double Astro::slaDrange(double angle )
+{
+    return fmod(angle, Pi);
+}
+
+float  Astro::slaRange(float angle )
+{
+    return fmodf(angle, Pi);
+}
+
+void Astro::slaRefro ( double zobs, double hm, double tdk, double pmb,
+                       double rh, double wl, double phi, double tlr,
+                       double eps, double *ref )
+/*
+**  - - - - - - - - -
+**   s l a R e f r o
+**  - - - - - - - - -
+**
+**  Atmospheric refraction for radio and optical wavelengths.
+**
+**  Given:
+**    zobs    double  observed zenith distance of the source (radian)
+**    hm      double  height of the observer above sea level (metre)
+**    tdk     double  ambient temperature at the observer (deg K)
+**    pmb     double  pressure at the observer (millibar)
+**    rh      double  relative humidity at the observer (range 0-1)
+**    wl      double  effective wavelength of the source (micrometre)
+**    phi     double  latitude of the observer (radian, astronomical)
+**    tlr     double  temperature lapse rate in the troposphere (degK/met
+**    eps     double  precision required to terminate iteration (radian)
+**
+**  Returned:
+**    ref     double  refraction: in vacuo ZD minus observed ZD (radian)
+**
+**  Notes:
+**
+**  1  A suggested value for the tlr argument is 0.0065D0.  The
+**     refraction is significantly affected by tlr, and if studies
+**     of the local atmosphere have been carried out a better tlr
+**     value may be available.
+**
+**  2  A suggested value for the eps argument is 1e-8.  The result is
+**     usually at least two orders of magnitude more computationally
+**     precise than the supplied eps value.
+**
+**  3  The routine computes the refraction for zenith distances up
+**     to and a little beyond 90 deg using the method of Hohenkerk
+**     and Sinclair (NAO Technical Notes 59 and 63, subsequently adopted
+**     in the Explanatory Supplement, 1992 edition - see section 3.281).
+**
+**  4  The C code is an adaptation of the Fortran optical refraction
+**     subroutine AREF of C.Hohenkerk (HMNAO, September 1984), with
+**     extensions to support the radio case.  The following modifications
+**     to the original HMNAO optical refraction algorithm have been made:
+**
+**     .  The angle arguments have been changed to radians.
+**
+**     .  Any value of zobs is allowed (see note 6, below).
+**
+**     .  Other argument values have been limited to safe values.
+**
+**     .  Murray's values for the gas constants have been used
+**        (Vectorial Astrometry, Adam Hilger, 1983).
+**
+**     .  The numerical integration phase has been rearranged for
+**        extra clarity.
+**
+**     .  A better model for Ps(T) has been adopted (taken from
+**        Gill, Atmosphere-Ocean Dynamics, Academic Press, 1982).
+**
+**     .  More accurate expressions for Pwo have been adopted
+**        (again from Gill 1982).
+**
+**     .  Provision for radio wavelengths has been added using
+**        expressions devised by A.T.Sinclair, RGO (private
+**        communication 1989), based on the Essen & Froome
+**        refractivity formula adopted in Resolution 1 of the
+**        13th International Geodesy Association General Assembly
+**        (Bulletin Geodesique 1963 p390).
+**
+**     .  Various small changes have been made to gain speed.
+**
+**     None of the changes significantly affects the optical results
+**     with respect to the algorithm given in the 1992 Explanatory
+**     Supplement.  For example, at 70 deg zenith distance the present
+**     routine agrees with the ES algorithm to better than 0.05 arcsec
+**     for any reasonable combination of parameters.  However, the
+**     improved water-vapour expressions do make a significant difference
+**     in the radio band, at 70 deg zenith distance reaching almost
+**     4 arcsec for a hot, humid, low-altitude site during a period of
+**     low pressure.
+**
+**  5  The radio refraction is chosen by specifying wl > 100 micrometres.
+**     Because the algorithm takes no account of the ionosphere, the
+**     accuracy deteriorates at low frequencies, below about 30 MHz.
+**
+**  6  Before use, the value of zobs is expressed in the range +/- pi.
+**     If this ranged zobs is -ve, the result ref is computed from its
+**     absolute value before being made -ve to match.  In addition, if
+**     it has an absolute value greater than 93 deg, a fixed ref value
+**     equal to the result for zobs = 93 deg is returned, appropriately
+**     signed.
+**
+**  7  As in the original Hohenkerk and Sinclair algorithm, fixed values
+**     of the water vapour polytrope exponent, the height of the
+**     tropopause, and the height at which refraction is negligible are
+**     used.
+**
+**  8  The radio refraction has been tested against work done by
+**     Iain Coulson, JACH, (private communication 1995) for the
+**     James Clerk Maxwell Telescope, Mauna Kea.  For typical conditions,
+**     agreement at the 0.1 arcsec level is achieved for moderate ZD,
+**     worsening to perhaps 0.5-1.0 arcsec at ZD 80 deg.  At hot and
+**     humid sea-level sites the accuracy will not be as good.
+**
+**  9  It should be noted that the relative humidity rh is formally
+**     defined in terms of "mixing ratio" rather than pressures or
+**     densities as is often stated.  It is the mass of water per unit
+**     mass of dry air divided by that for saturated air at the same
+**     temperature and pressure (see Gill 1982).
+**
+**  Called:  slaDrange, atmt, atms
+**
+**  Defined in slamac.h:  TRUE, FALSE
+**
+**  Last revision:   30 January 1997
+**
+**  Copyright P.T.Wallace.  All rights reserved.
+*/
+{
+    /* Fixed parameters */
+
+    static double d93 = 1.623156204; /* 93 degrees in radians        */
+    static double gcr = 8314.32;     /* Universal gas constant       */
+    static double dmd = 28.9644;     /* Molecular weight of dry air  */
+    static double dmw = 18.0152;     /* Molecular weight of water
+                                                             vapour */
+    static double s = 6378120.0;     /* Mean Earth radius (metre)    */
+    static double delta = 18.36;     /* Exponent of temperature
+                                         dependence of water vapour
+                                                           pressure */
+    static double ht = 11000.0;      /* Height of tropopause (metre) */
+    static double hs = 80000.0;      /* Upper limit for refractive
+                                                    effects (metre) */
+
+    /* Variables used when calling the internal routine atmt */
+    double robs;   /* height of observer from centre of Earth (metre) */
+    double tdkok;  /* temperature at the observer (deg K) */
+    double alpha;  /* alpha          |        */
+    double gamm2;  /* gamma minus 2  | see ES */
+    double delm2;  /* delta minus 2  |        */
+    double c1,c2,c3,c4,c5,c6;  /* various */
+
+    /* Variables used when calling the internal routine atms */
+    double rt;     /* height of tropopause from centre of Earth (metre) */
+    double tt;     /* temperature at the tropopause (deg k) */
+    double dnt;    /* refractive index at the tropopause */
+    double gamal;  /* constant of the atmospheric model = g*md/r */
+
+    int is, k, n, i, j, optic;
+    double zobs1, zobs2, hmok, pmbok, rhok, wlok, tol, wlsq, gb,
+    a, gamma, tdc, psat, pwo, w, tempo, dn0, rdndr0, sk0,
+    f0, rdndrt, zt, ft, dnts, rdndrp, zts, fts, rs,
+    dns, rdndrs, zs, fs, refold, z0, zrange, fb, ff, fo,
+    fe, h, r, sz, rg, dr, tg, dn, rdndr, t, f, refp, reft;
+
+    /* The refraction integrand */
+#define refi(R,DN,RDNDR) ((RDNDR)/(DN+RDNDR));
+
+
+
+    /* Transform zobs into the normal range */
+    zobs1 = slaDrange ( zobs );
+    zobs2 = fabs ( zobs1 );
+    zobs2 = gmin ( zobs2, d93 );
+
+    /* Keep other arguments within safe bounds */
+    hmok = gmax ( hm, -1000.0 );
+    hmok = gmin ( hmok, 10000.0 );
+    tdkok = gmax ( tdk, 100.0 );
+    tdkok = gmin ( tdkok, 500.0 );
+    pmbok = gmax ( pmb, 0.0 );
+    pmbok = gmin ( pmbok, 10000.0 );
+    rhok  = gmax ( rh, 0.0 );
+    rhok  = gmin ( rhok, 1.0 );
+    wlok  = gmax ( wl, 0.1 );
+    alpha = fabs ( tlr );
+    alpha = gmax ( alpha, 0.001 );
+    alpha = gmin ( alpha, 0.01 );
+
+    /* Tolerance for iteration */
+    w = fabs ( eps );
+    tol = gmin ( w, 0.1 ) / 2.0;
+
+    /* Decide whether optical or radio case - switch at 100 micron */
+    optic = ( wlok <= 100.0 );
+
+    /* Set up model atmosphere parameters defined at the observer */
+    wlsq = wlok * wlok;
+    gb = 9.784 * ( 1.0 - 0.0026 * cos ( 2.0 * phi ) - 2.8e-7 * hmok );
+    a = ( optic ) ?
+        ( ( 287.604 + 1.6288 / wlsq + 0.0136 / ( wlsq * wlsq ) )
+          * 273.15 / 1013.25 ) * 1e-6
+        :
+        77.624e-6;
+    gamal = gb * dmd / gcr;
+    gamma = gamal / alpha;
+    gamm2 = gamma - 2.0;
+    delm2 = delta - 2.0;
+    tdc = tdkok - 273.15;
+    psat = pow ( 10.0, ( 0.7859 + 0.03477 * tdc ) /
+                 ( 1.0 + 0.00412 * tdc ) ) *
+           ( 1.0 + pmbok * ( 4.5e-6 + 6e-10 * tdc * tdc ) );
+    pwo = ( pmbok > 0.0 ) ?
+          rhok * psat / ( 1.0 - ( 1.0 - rhok ) * psat / pmbok ) :
+          0.0;
+    w = pwo * ( 1.0 - dmw / dmd ) * gamma / ( delta - gamma );
+    c1 = a * ( pmbok + w ) / tdkok;
+    c2 = ( a * w + ( optic ? 11.2684e-6 : 12.92e-6 ) * pwo ) / tdkok;
+    c3 = ( gamma - 1.0 ) * alpha * c1 / tdkok;
+    c4 = ( delta - 1.0 ) * alpha * c2 / tdkok;
+    c5 = optic ? 0.0 : 371897e-6 * pwo / tdkok;
+    c6 = c5 * delm2 * alpha / ( tdkok * tdkok );
+
+    /* Conditions at the observer */
+    robs = s + hmok;
+    atmt ( robs, tdkok, alpha, gamm2, delm2, c1, c2, c3, c4, c5, c6, robs,
+           &tempo, &dn0, &rdndr0 );
+    sk0 = dn0 * robs * sin ( zobs2 );
+    f0 = refi ( robs, dn0, rdndr0 );
+
+    /* Conditions at the tropopause in the troposphere */
+    rt = s + ht;
+    atmt ( robs, tdkok, alpha, gamm2, delm2, c1, c2, c3, c4, c5, c6, rt,
+           &tt, &dnt, &rdndrt );
+    zt = asin ( sk0 / ( rt * dnt ) );
+    ft = refi ( rt, dnt, rdndrt );
+
+    /* Conditions at the tropopause in the stratosphere */
+    atms ( rt, tt, dnt, gamal, rt, &dnts, &rdndrp );
+    zts = asin ( sk0 / ( rt * dnts ) );
+    fts = refi ( rt, dnts, rdndrp );
+
+    /* At the stratosphere limit */
+    rs = s + hs;
+    atms ( rt, tt, dnt, gamal, rs, &dns, &rdndrs );
+    zs = asin ( sk0 / ( rs * dns ) );
+    fs = refi ( rs, dns, rdndrs );
+
+    /*
+    ** Integrate the refraction integral in two parts;  first in the
+    ** troposphere (k=1), then in the stratosphere (k=2).
+    */
+
+    /* Initialize previous refraction to ensure at least two iterations */
+    refold = 1e6;
+
+    /*
+    ** Start off with 8 strips for the troposphere integration, and then
+    ** use the final troposphere value for the stratosphere integration,
+    ** which tends to need more strips.
+    */
+    is = 8;
+
+    /* Troposphere then stratosphere */
+    for ( k = 1; k <= 2; k++ ) {
+
+        /* Start z, z range, and start and end values */
+        if ( k == 1 ) {
+            z0 = zobs2;
+            zrange = zt - z0;
+            fb = f0;
+            ff = ft;
+        } else {
+            z0 = zts;
+            zrange = zs - z0;
+            fb = fts;
+            ff = fs;
+        }
+
+        /* Sums of odd and even values */
+        fo = 0.0;
+        fe = 0.0;
+
+        /* First time through loop we have to do every point */
+        n = 1;
+
+        /* Start of iteration loop (terminates at specified precision) */
+        for ( ; ; ) {
+
+            /* Strip width */
+            h = zrange / (double) is;
+
+            /* Initialize distance from Earth centre for quadrature pass */
+            r = ( k == 1 ) ? robs : rt;
+
+            /* One pass (no need to compute evens after first time) */
+            for ( i = 1; i < is; i += n ) {
+
+                /* Sine of observed zenith distance */
+                sz = sin ( z0 + h * (double) i );
+
+                /* Find r (to nearest metre, maximum four iterations) */
+                if ( sz > 1e-20 ) {
+                    w = sk0 / sz;
+                    rg = r;
+                    j = 0;
+                    do {
+                        if ( k == 1 ) {
+                            atmt ( robs, tdkok, alpha, gamm2, delm2,
+                                   c1, c2, c3, c4, c5, c6, rg,
+                                   &tg, &dn, &rdndr );
+                        } else {
+                            atms ( rt, tt, dnt, gamal, rg, &dn, &rdndr );
+                        }
+                        dr = ( rg * dn - w ) / ( dn + rdndr );
+                        rg -= dr;
+                    } while ( fabs ( dr ) > 1.0 && j++ <= 4 );
+                    r = rg;
+                }
+
+                /* Find refractive index and integrand at r */
+                if ( k == 1 ) {
+                    atmt ( robs, tdkok, alpha, gamm2, delm2,
+                           c1, c2, c3, c4, c5, c6, r,
+                           &t, &dn, &rdndr );
+                } else {
+                    atms ( rt, tt, dnt, gamal, r, &dn, &rdndr );
+                }
+                f = refi ( r, dn, rdndr );
+
+                /* Accumulate odd and (first time only) even values */
+                if ( n == 1 && i % 2 == 0 ) {
+                    fe += f;
+                } else {
+                    fo += f;
+                }
+            }
+
+            /* Evaluate the integrand using Simpson's Rule */
+            refp = h * ( fb + 4.0 * fo + 2.0 * fe + ff ) / 3.0;
+
+            /* Has the required precision been reached? */
+            if ( fabs ( refp - refold ) > tol ) {
+
+                /* No: prepare for next iteration */
+                refold = refp;   /* Save current value for convergence test */
+                is += is;        /* Double the number of strips */
+                fe += fo;        /* Sum of all = sum of evens next time */
+                fo = 0.0;        /* Reset odds accumulator */
+                n = 2;           /* Skip even values next time */
+
+            } else {
+
+                /* Yes: save troposphere component and terminate loop */
+                if ( k == 1 ) reft = refp;
+                break;
+            }
+        }
+    }
+
+    /* Result */
+    *ref = reft + refp;
+    if ( zobs1 < 0.0 ) *ref = - ( *ref );
+
+    *ref+=Pidiv2-zobs1;
+}
+
+/*--------------------------------------------------------------------------*/
+
+void Astro::atmt ( double robs, double tdkok, double alpha, double gamm2,
+                   double delm2, double c1, double c2, double c3,
+                   double c4, double c5, double c6, double r,
+                   double *t, double *dn, double *rdndr )
+/*
+**  - - - - -
+**   a t m t
+**  - - - - -
+**
+**  Internal routine used by slaRefro:
+**
+**    refractive index and derivative with respect to height for the
+**    troposphere.
+**
+**  Given:
+**    robs    double   height of observer from centre of the Earth (metre)
+**    tdkok   double   temperature at the observer (deg K)
+**    alpha   double   alpha          )
+**    gamm2   double   gamma minus 2  ) see ES
+**    delm2   double   delta minus 2  )
+**    c1      double   useful term  )
+**    c2      double   useful term  )
+**    c3      double   useful term  ) see source of
+**    c4      double   useful term  ) slaRefro main routine
+**    c5      double   useful term  )
+**    c6      double   useful term  )
+**    r       double   current distance from the centre of the Earth (metre)
+**
+**  Returned:
+**    *t      double   temperature at r (deg K)
+**    *dn     double   refractive index at r
+**    *rdndr  double   r * rate the refractive index is changing at r
+**
+**  This routine is derived from the ATMOSTRO routine (C.Hohenkerk,
+**  HMNAO), with enhancements specified by A.T.Sinclair (RGO) to
+**  handle the radio case.
+**
+**  Note that in the optical case c5 and c6 are zero.
+*/
+{
+    double w, tt0, tt0gm2, tt0dm2;
+
+    w = tdkok - alpha * ( r - robs );
+    w = gmin ( w, 320.0 );
+    w = gmax ( w, 200.0 );
+    tt0 = w / tdkok;
+    tt0gm2 = pow ( tt0, gamm2 );
+    tt0dm2 = pow ( tt0, delm2 );
+    *t = w;
+    *dn = 1.0 + ( c1 * tt0gm2 - ( c2 - c5 / w ) * tt0dm2 ) * tt0;
+    *rdndr = r * ( - c3 * tt0gm2 + ( c4 - c6 / tt0 ) * tt0dm2 );
+}
+
+/*--------------------------------------------------------------------------*/
+
+void Astro::atms ( double rt, double tt, double dnt, double gamal, double r,
+                   double *dn, double *rdndr )
+/*
+**  - - - - -
+**   a t m s
+**  - - - - -
+**
+**  Internal routine used by slaRefro:
+**
+**   refractive index and derivative with respect to height for the
+**   stratosphere.
+**
+**  Given:
+**    rt      double   height of tropopause from centre of the Earth (metre)
+**    tt      double   temperature at the tropopause (deg k)
+**    dnt     double   refractive index at the tropopause
+**    gamal   double   constant of the atmospheric model = g*md/r
+**    r       double   current distance from the centre of the Earth (metre)
+**
+**  Returned:
+**    *dn     double   refractive index at r
+**    *rdndr  double   r * rate the refractive index is changing at r
+**
+**  This routine is derived from the ATMOSSTR routine (C.Hohenkerk, HMNAO).
+*/
+{
+    double b, w;
+
+    b = gamal / tt;
+    w = ( dnt - 1.0 ) * exp ( - b * ( r - rt ) );
+    *dn = 1.0 + w;
+    *rdndr = - r * b * w;
+}
+
+
+
Index: /BAORadio/libindi/libindi/communs/exception.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/exception.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/exception.cpp	(revision 644)
@@ -0,0 +1,36 @@
+/* exception.c */
+/* fonctions de manipulation de la pile */
+
+#include "exception.h"
+
+except *_exceptions = NULL;
+
+/* empile */
+
+void push_exc(){
+  except* layer;
+  layer = new 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;
+  delete _exceptions;
+  _exceptions = super;
+  if(ex){
+    if(_exceptions){
+      longjmp(_exceptions->ctx, ex);
+    }
+    else{
+      fprintf(stderr, "Exception non geree : %d\n", ex);
+      exit(-1);
+    }
+  }
+}
Index: /BAORadio/libindi/libindi/communs/exception.h
===================================================================
--- /BAORadio/libindi/libindi/communs/exception.h	(revision 644)
+++ /BAORadio/libindi/libindi/communs/exception.h	(revision 644)
@@ -0,0 +1,55 @@
+/* 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); }\
+ pop_exc(exc); \
+  }
+
+#define THROW(X) longjmp(_exceptions->ctx, X)
+
+
+void push_exc();
+void pop_exc(int);
+
+#endif
Index: /BAORadio/libindi/libindi/communs/filetools.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/filetools.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/filetools.cpp	(revision 644)
@@ -0,0 +1,1156 @@
+/*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, true);
+    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;
+
+            if (prev) { delete prev; prev =NULL; }
+
+        } while (pKey!=keyprev);
+ 
+        if (pSection->name) delete [] pSection->name;
+
+        secprev=pSection;
+
+        SECTION *sprev=pSection;
+        pSection=pSection->next;
+
+        if (sprev) { delete sprev; sprev =NULL; }
+
+    }  while (pSection!=secprev);
+
+
+
+    if (pIni->fileName != NULL) 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             *
+ ******************************************************/
+
+
+
+void 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 = new char [sizeof (char) * strlen (keyName) + 1];
+    pSectionName = new char [sizeof (char) * strlen (sectionName) + 3];
+    if (keyValue != NULL)
+      {
+	pKeyValue = new char [sizeof (char) * strlen (keyValue) + 1];
+	strcpy (pKeyValue, keyValue);
+	pKeyValue[strlen (keyValue)] = '\0';
+      }
+    else
+      {
+	pKeyValue = new char [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, false);
+  }
+  CATCH (ERR_FOPEN)
+  {
+    printf ("Erreur en ouvrant le fichier .ini:%s\n", fileName);
+    exit (EXIT_FAILURE);
+  }
+  CATCH (ERR_MALLOC)
+  {
+    perror ("Probleme d'allocation memoire\n");
+    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)
+	{
+	  if (pKey->value != NULL) { delete [] pKey->value; pKey->value = NULL; pKey->value = new char [sizeof (char) * strlen (pKeyValue) + 1]; }
+	  
+	  if (pKey->value == NULL)
+	    {
+	      perror ("probleme de reallocation memoire\n");
+	      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 ("Erreur sur le fichier %s\n", pIni->fileName);
+  }
+  ENDTRY;
+
+  //nettoyage
+  
+  
+   //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;
+
+            if (prev) { delete prev; prev =NULL; }
+
+        } while (pKey!=keyprev);
+	
+	if (pSection->name) delete [] pSection->name;
+
+        secprev=pSection;
+
+        SECTION *sprev=pSection;
+        pSection=pSection->next;
+
+        if (sprev) { delete sprev; sprev =NULL; }
+        
+        
+
+    }  while (pSection!=secprev);
+
+    
+
+
+  if (pKeyValue != NULL) delete [] pKeyValue;
+  if (pKeyName != NULL) delete [] pKeyName;
+  if (pSectionName != NULL) delete [] pSectionName;
+  if (pIni->fileName != NULL) delete [] pIni->fileName;
+  if (pIni != NULL) delete pIni;
+//  if (pSection != NULL) delete  pSection;
+  //if (pKey != NULL) delete  pKey;
+  
+ 
+  pIni = NULL;
+  pKeyName = NULL;
+  pSectionName = NULL;
+}
+
+
+/******************************************************
+ * 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 = new char [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;
+	      delete [] 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, bool SortirSiVide)
+{
+    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) && (SortirSiVide)) { fclose(pFile); delete  [] pIni->fileName; delete pIni; delete [] pBuf; return NULL;}
+    while (nbRead != -1)
+    {
+
+        if ((pBuf[0] == '[') && (pBuf[strlen (pBuf) - 1] == ']'))
+        {
+            /* une section */
+            pSection = NULL;
+
+            pSection = _newSECTION (pBuf);
+            _addSECTION (pIni, pSection);
+	   // if (pSection != NULL ) { delete pSection; pSection = NULL;}
+	    
+        }
+
+        /* 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;
+	//	if (pKey != NULL ) {delete pKey; pKey = NULL;}
+            }
+        }
+    }
+
+    /*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; (ind < strlen (str)) && (str[ind] != '='); ind++);
+    if (str[ind] == '=')
+        return ind;
+    else
+        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: /BAORadio/libindi/libindi/communs/filetools.h
===================================================================
--- /BAORadio/libindi/libindi/communs/filetools.h	(revision 644)
+++ /BAORadio/libindi/libindi/communs/filetools.h	(revision 644)
@@ -0,0 +1,109 @@
+/*******************************************************
+                          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);
+
+void 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, bool );
+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: /BAORadio/libindi/libindi/communs/logs.cpp
===================================================================
--- /BAORadio/libindi/libindi/communs/logs.cpp	(revision 644)
+++ /BAORadio/libindi/libindi/communs/logs.cpp	(revision 644)
@@ -0,0 +1,132 @@
+////////////////////////////////
+// Classe Logs               //
+// Franck RICHARD             //
+// BAORadio                   //
+// franckrichard033@gmail.com //
+// fÃ©vrier 2012               //
+////////////////////////////////
+
+#include "logs.h"
+
+
+Logs::Logs()
+{
+    ChoixCouleurs = 1;
+}
+
+Logs::~Logs()
+{
+}
+
+
+/**************************************************************************************
+** Reprise de la fonction IDLog prÃ©sente dans le code d'Indi
+**
+***************************************************************************************/
+
+void Logs::IDLog (const char *fmt, ...)
+{
+    va_list ap;
+    va_start (ap, fmt);
+    vfprintf (stderr, fmt, ap);
+    va_end (ap);
+}
+
+
+/**************************************************************************************
+** Retourne la longueur du fichier file
+**
+***************************************************************************************/
+
+long int Logs::Taille( const std::string & file )
+{
+    std::ifstream fichier( file.c_str() );
+
+    if (fichier.fail()) return 0;
+
+    return  fichier.tellg();
+}
+
+
+/**************************************************************************************
+** Affiche le message Ã  l'Ã©cran (si AfficheEcran==true) et le sauvegarde dans le fichier
+** BAOControl.log
+***************************************************************************************/
+
+void Logs::AfficherLog(string Message, bool AfficheEcran)
+{
+    static bool avertissement = false;
+
+    FILE *pFile = NULL;
+
+    string fichier;
+
+    // On affiche Ã©ventuellement le message Ã  l'Ã©cran
+
+    if (AfficheEcran) IDLog(Message.c_str());
+
+    fichier = "/home/" + (string)getenv("USER") + "/BAOcontrol.log";
+
+    //Si le fichier log a une taille > 3M -> on efface le fichier
+
+    if ( Taille(fichier) > TAILLEMAXLOGS ) remove(fichier.c_str());
+
+    if ( (pFile = fopen(fichier.c_str(), "a")) != NULL)
+    {
+        // On le sauvegarde dans le fichier log
+
+        fprintf(pFile, Message.c_str());
+
+        fclose(pFile);
+    }
+    else
+    {
+        if (!avertissement)
+        {
+            ChoixCouleurs==1 ? IDLog(red1) : IDLog(red2);
+
+            string chaine = "Impossible d'Ã©crire dans le fichier " + fichier +"\nMerci de vÃ©rifier les permissions\n";
+	    chaine += "ou exÃ©cutez le programme en mode superutilisateur.\n\n";
+
+            IDLog(chaine.c_str());
+
+            ChoixCouleurs==1 ? IDLog(grey1) : IDLog(grey2);
+
+            avertissement = true;
+        }
+    }
+}
+
+
+void Logs::AfficherLog(stringstream *Message, bool AfficheEcran)
+{
+    AfficherLog(Message->str(), AfficheEcran);
+
+    // on efface le buffer
+
+    Message->str("");
+}
+
+
+/**************************************************************************************
+** Affiche les messages d'erreur en rouge
+***************************************************************************************/
+
+void Logs::ErreurLog(string chaine)
+{
+    ChoixCouleurs==1 ? IDLog(red1) : IDLog(red2);
+
+    AfficherLog(chaine, true);
+
+    ChoixCouleurs==1 ? IDLog(grey1) : IDLog(grey2);
+}
+
+void Logs::ErreurLog(stringstream *Message)
+{
+    ErreurLog(Message->str());
+
+    // on efface le buffer
+
+    Message->str("");
+}
+
Index: /BAORadio/libindi/libindi/communs/logs.h
===================================================================
--- /BAORadio/libindi/libindi/communs/logs.h	(revision 644)
+++ /BAORadio/libindi/libindi/communs/logs.h	(revision 644)
@@ -0,0 +1,50 @@
+////////////////////////////////
+// Classe Logs               //
+// Franck RICHARD             //
+// BAORadio                   //
+// franckrichard033@gmail.com //
+// fÃ©vrier 2012               //
+////////////////////////////////
+
+#ifndef Logs_h
+#define Logs_h
+
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include "const.h"
+
+
+using namespace std;
+
+
+class Logs
+{
+public :
+
+    Logs();
+    
+    ~Logs();
+
+    void IDLog (const char *fmt, ...);    
+
+    void AfficherLog(string Message, bool AfficheEcran);
+
+    void AfficherLog(stringstream *Message, bool AfficheEcran);
+
+    void ErreurLog(string chaine);
+
+    void ErreurLog(stringstream *Message);
+
+
+    char ChoixCouleurs;                         // vaut 1 pour un terminal Ã  fond blanc et 2 pour un terminal Ã  fond noir
+    
+private:
+  
+    long int Taille( const std::string & file );
+};
+
+#endif
