Ignore:
Timestamp:
Apr 2, 2012, 10:56:55 AM (12 years ago)
Author:
frichard
Message:

-Ajout de l'étoile polaris dans le catalogue
-logs plus complets
-correction des déconnexion des antennes
-command send pour envoyer des commandes simples directement aux antennes

File:
1 edited

Legend:

Unmodified
Added
Removed
  • BAORadio/libindi/libindi/drivers/telescope/BAO.cpp

    r648 r650  
    5252    lastRA                = 0.0;
    5353    lastDEC               = 0.0;
    54    
     54
    5555    // Jour julien de la derniÚre actualisation
    56    
     56
    5757    JJAnc                 = 0.0;
    5858
    5959    // Variables d'état
    6060
    61     currentSet            =  0; 
     61    currentSet            =  0;
    6262
    6363    // Nombre d'antennes connectées
     
    6868
    6969    TrackingMode          =  BAO_TRACKING;
    70    
     70
    7171    // Méthode d'alignement par défaut
    72    
     72
    7373    MethodeAlignement     = SIMPLE;
    7474
     
    7777
    7878    ActualisationTMTransit  = 15.0 * 60.0;    // Délai entre 2 actualisations dans le mode transit (en sec)
    79    
     79
    8080    ActualisationTMTracking = 5.0;            //                "                 "        tracking
    8181
     
    108108
    109109    Exit                  = false;
    110    
     110
    111111    // Initialisation des paramÚtres atmosphériques par défaut
    112    
     112
    113113    Pression              = 1013.0;
    114    
     114
    115115    Temp                  = 10.0;
    116116
     
    135135    // Numéro de version
    136136
    137     IDLog("Indi server BAORadio...\n");
    138     IDLog("Driver Version: 23-02-2012\n");
     137    AfficherLog("Indi server BAORadio...\n");
     138    AfficherLog("Driver Version: 0.51 (02-04-2012)\n");
    139139
    140140    //connect_telescope();
     
    172172    // permet de savoir si le destructeur a bien été atteint
    173173
    174     IDLog("Sortie de indi_BAO\n");
     174    AfficherLog("Sortie de indi_BAO\n");
     175}
     176
     177
     178
     179/**************************************************************************************
     180** Affiche le message à l'écran puis sauvegarde le message dans le fichierBAO_indi.log
     181**
     182***************************************************************************************/
     183
     184void BAO::AfficherLog(const char* fmt,...)
     185{
     186    static bool avertissement = false;
     187
     188    va_list ap;
     189
     190    FILE *pFile = NULL;
     191
     192    string fichier;
     193
     194    va_start (ap, fmt);
     195
     196    vfprintf (stderr, fmt, ap);
     197
     198    va_end (ap);
     199
     200    fichier = "/home/" + (string)getenv("USER") + "/BAO_indi.log";
     201
     202    //Si le fichier log a une taille > 3M -> on efface le fichier
     203
     204    //if ( Taille(fichier) > TAILLEMAXLOGS ) remove(fichier.c_str());
     205
     206    if ( (pFile = fopen(fichier.c_str(), "a")) != NULL)
     207    {
     208        time_t rawtime;
     209        struct tm * timeinfo;
     210
     211        char buffer[80];
     212
     213        // On sauvegarde la date et l'heure
     214
     215        time ( &rawtime );
     216        timeinfo = localtime ( &rawtime );
     217        strftime (buffer,80,"%c    ",timeinfo);
     218        fprintf(pFile, buffer);
     219
     220        // On sauvegarde le message dans le fichier log
     221        va_start (ap, fmt);
     222
     223        vfprintf(pFile, fmt, ap);
     224
     225        va_end (ap);
     226
     227        fclose(pFile);
     228    }
     229    else
     230    {
     231        if (!avertissement)
     232        {
     233            string chaine = "Impossible d'écrire dans le fichier " + fichier +"\nMerci de vérifier les permissions\n";
     234            chaine += "ou exécutez le programme en mode superutilisateur.\n\n";
     235
     236            va_start (ap, fmt);
     237
     238            vfprintf (stderr, chaine.c_str(), ap);
     239
     240            va_end (ap);
     241
     242            avertissement = true;
     243        }
     244    }
    175245}
    176246
     
    246316    IUFillNumberVector(&EquatorialCoordsWNP, EquatorialCoordsWN, NARRAY(EquatorialCoordsWN), mydev, "EQUATORIAL_EOD_COORD_REQUEST" , "Equatorial JNow", BASIC_GROUP, IP_WO, 0, IPS_IDLE);
    247317
     318    //Command
     319    IUFillText(&CommandT[0], "COMMAND", "Command", "");
     320    IUFillTextVector(&CommandTP, CommandT, NARRAY(CommandT), mydev, "COMMAND_SET", "Command", BASIC_GROUP, IP_WO, 0, IPS_IDLE);
     321
    248322    // Geographic coord - SET
    249323    IUFillNumber(&GeographicCoordsWN[0], "LAT", "Lat  D", "%10.6m",  -90., 90., 0., 0.);
     
    251325    IUFillNumberVector(&GeographicCoordsWNP, GeographicCoordsWN, NARRAY(GeographicCoordsWN), mydev, "GEOGRAPHIC_COORD" , "Geographic coords", OPTIONS_GROUP, IP_WO, 0, IPS_IDLE);
    252326
    253      // Pression température - SET
     327    // Pression température - SET
    254328    IUFillNumber(&PressionTempWN[0], "Pression", "Pression mb", "%10.6m",  0., 1500., 0., 0.);
    255329    IUFillNumber(&PressionTempWN[1], "Temperature", "Temperature °c", "%10.6m", -50., +50., 0., 0.);
     
    266340
    267341/**************************************************************************************
    268 ** Définition de tous les vecteurs de la boîte de dialogue INDI 
     342** Définition de tous les vecteurs de la boîte de dialogue INDI
    269343** Cette procédure doit être obligatoirement présente dans tous pilotes Indi
    270344**
     
    280354    IDDefSwitch(&ConnectSP, NULL);
    281355    IDDefText(&ObjectTP, NULL);
    282     IDDefNumber(&EquatorialCoordsWNP, NULL);     
     356    IDDefNumber(&EquatorialCoordsWNP, NULL);
     357    IDDefText(&CommandTP, NULL);
    283358    IDDefSwitch(&OnCoordSetSP, NULL);
    284359    IDDefSwitch(&AlignmentSP, NULL);
     
    290365    IDDefNumber(&ActualisationNP2, NULL);
    291366    IDDefNumber(&PressionTempWNP, NULL);
    292     IDDefNumber(&GeographicCoordsWNP, NULL); 
     367    IDDefNumber(&GeographicCoordsWNP, NULL);
    293368}
    294369
     
    309384    ObjectTP.s                  = IPS_IDLE;
    310385    EquatorialCoordsWNP.s       = IPS_IDLE;
     386    CommandTP.s                 = IPS_IDLE;
    311387    PressionTempWNP.s           = IPS_IDLE;
    312388    GeographicCoordsWNP.s       = IPS_IDLE;
     
    330406    IDSetSwitch(&ParkSP, NULL);
    331407    IDSetText(&ObjectTP, NULL);
     408    IDSetText(&CommandTP, NULL);
    332409    IDSetNumber(&EquatorialCoordsWNP, NULL);
    333410    IDSetNumber(&PressionTempWNP, NULL);
     
    374451        return;
    375452    }
     453
     454
     455    // ===================================
     456    // Commands
     457    // ===================================
     458    if (!strcmp (name, CommandTP.name))
     459    {
     460        if (IUUpdateText(&CommandTP, texts, names, n) < 0)
     461            return;
     462
     463        IText *eqp = IUFindText (&CommandTP, names[0]);
     464
     465
     466        if (eqp == &CommandT[0])
     467        {
     468            char chaine[100];
     469
     470            bool result = false;
     471
     472            strcpy(chaine, texts[0]);
     473
     474            if (chaine[0] == 'G')
     475            {
     476                for (int i = 1; i<=strlen(chaine); i++) chaine[i-1]=chaine[i];
     477               
     478                IDLog(chaine);
     479
     480                for (int i = 1; i<SocketsNumber; i++ )
     481                {
     482                    if (Sockets[i].Connected)
     483                    {
     484                        result = COMMANDE(i, (char*)"G", chaine);
     485                    }
     486                }
     487            }
     488            else
     489            {
     490                for (int i = 1; i<SocketsNumber; i++ )
     491                {
     492                    if (Sockets[i].Connected)
     493                    {
     494                        result = COMMANDE(i, chaine, (char*)"");
     495                    }
     496                }
     497            }
     498
     499            (result) ? CommandTP.s = IPS_OK : CommandTP.s = IPS_ALERT;
     500
     501            IDSetText(&CommandTP, NULL);
     502        }
     503        return;
     504    }
    376505}
    377506
     
    383512**
    384513** const char *dev  contient le nom du dispositif recevant le message (ici indi_BAO)
    385 ** const char *name reçoit  le nom de la rubrique modifiée par l'utilisateur 
     514** const char *name reçoit  le nom de la rubrique modifiée par l'utilisateur
    386515** (ex : les coordonnées géographiques, les coordonnées horaires de l'objet etc...)
    387516** double names[] contient la liste de tous les champs modifiables dans chaque rubrique
    388517** (ex : longitude et latitude dans la rubrique coordonnées géographiques
    389 ** char *values[] contient toutes les valeurs (numériques ou non) mais toujours exprimées 
     518** char *values[] contient toutes les valeurs (numériques ou non) mais toujours exprimées
    390519** sous la forme d'une chaîne de caractÚres
    391520**
     
    477606        {
    478607            // Vérification
    479             // IDLog("Geographic : RA %5.2f - DEC %5.2f\n", Latitude, Longitude);
     608            // AfficherLog("Geographic : RA %5.2f - DEC %5.2f\n", Latitude, Longitude);
    480609
    481610            // nset vaut 2, nous sommes donc sûrs qu'il n'y a pas de problÚme dans les valeurs
     
    483612            // voir le code plus haut pour comprendre...
    484613
    485             // On change la couleur de la "diode" de la rubrique coordonnées 
     614            // On change la couleur de la "diode" de la rubrique coordonnées
    486615            // géographiques de la boîte en vert
    487616
     
    575704            fs_sexa(DecStr, newDEC, 2, 3600);
    576705
    577             IDLog("We received JNow RA %s - DEC %s\n", RAStr, DecStr);
     706            AfficherLog("We received JNow RA %s - DEC %s\n", RAStr, DecStr);
    578707
    579708            // on convertit les coordonnées équatoriales de la zone du ciel observée
     
    600729        return;
    601730    }
    602    
    603    
     731
     732
    604733    // ===================================
    605734    // Pression, Temperature
     
    642771
    643772        if (nset == 2)
    644         { 
    645             PressionTempWNP.s = IPS_OK;
     773        {
     774            PressionTempWNP.s = IPS_OK;
    646775
    647776            IDSetNumber(&PressionTempWNP, NULL);
    648                    
     777
    649778            Pression = newPression;
    650             Temp = newTemperature;
     779            Temp = newTemperature;
    651780        }
    652781        else
     
    735864** L'utilisateur clique sur l'un des boutons de la boîte Indi
    736865** Même observation que pour la procédure précédente
    737 ** 
     866**
    738867***************************************************************************************/
    739868
     
    786915
    787916        MethodeAlignement = get_switch_index(&AlignmentSP) + 1 ;
    788        
    789         /*char chaine[100];     
    790         sprintf(chaine, "****************************************** %i\n", MethodeAlignement);
    791         IDLog(chaine);*/
    792        
    793         AlignmentSP.s = IPS_OK;
     917
     918        /*char chaine[100];
     919        sprintf(chaine, "****************************************** %i\n", MethodeAlignement);
     920        AfficherLog(chaine);*/
     921
     922        AlignmentSP.s = IPS_OK;
    794923        IDSetSwitch(&AlignmentSP, NULL);
    795924
     
    827956            EquatorialCoordsWNP.s = IPS_IDLE;
    828957            ObjectTP.s = IPS_IDLE;
     958            CommandTP.s = IPS_IDLE;
    829959
    830960            IDSetSwitch(&ConnectSP, "Envoi de la commande Abort\n");
    831961            IDSetNumber(&EquatorialCoordsWNP, NULL);
    832962            IDSetText(&ObjectTP, NULL);
     963            IDSetText(&CommandTP, NULL);
    833964        }
    834965
     
    851982            EquatorialCoordsWNP.s = IPS_IDLE;
    852983            ObjectTP.s = IPS_IDLE;
     984            CommandTP.s = IPS_IDLE;
    853985
    854986            IDSetSwitch(&ConnectSP, "Envoi de la commande Park\n");
    855987            IDSetNumber(&EquatorialCoordsWNP, NULL);
    856988            IDSetText(&ObjectTP, NULL);
     989            IDSetText(&CommandTP, NULL);
    857990        }
    858991
     
    8831016
    8841017            Sockets[SocketsNumber].IP = server.recupip(Sockets[SocketsNumber].new_sock);
    885            
    886             Sockets[SocketsNumber].AlignementAntenne->MethodeAlignement = MethodeAlignement;
    887 
    888             Sockets[SocketsNumber++].Connected = true;     
     1018
     1019            Sockets[SocketsNumber].AlignementAntenne->MethodeAlignement = MethodeAlignement;
     1020
     1021            Sockets[SocketsNumber++].Connected = true;
    8891022
    8901023            InitThreadOK = true;
     
    8921025        catch ( SocketException& e )
    8931026        {
    894             /*IDLog("Indi_BAO, pThreadSocket exception : ");
    895             IDLog(e.description().c_str());
    896             IDLog("\n");*/
     1027            /*AfficherLog("Indi_BAO, pThreadSocket exception : ");
     1028            AfficherLog(e.description().c_str());
     1029            AfficherLog("\n");*/
    8971030        }
    8981031
     
    9211054/**************************************************************************************
    9221055** Extraction de la position de l'antenne aprÚs l'envoi de la commande P
    923 ** Le retour de la commande P est POSITION/valeur_az/valeur_alt/ 
     1056** Le retour de la commande P est POSITION/valeur_az/valeur_alt/
    9241057** Ce retour est envoyé dans la chaîne str
    9251058** ExtractPosition retourne une structure Position contenant Valeur_az et Valeur_alt
     
    9501083    }
    9511084
    952     IDLog((str +" failed !\n").c_str());
     1085    AfficherLog((str +" failed !\n").c_str());
    9531086
    9541087    return false;
     
    9831116        {
    9841117            newRA  = newRA2;
    985             newDEC = newDEC2;
    986          
    987             // Dans les modes d'alignement AFFINE et TAKI, on applique la matrice de correction
     1118            newDEC = newDEC2;
     1119
     1120            // Dans les modes d'alignement AFFINE et TAKI, on applique la matrice de correction
    9881121            // sur les coordonnées horaires de l'objet visé
    9891122
     
    9961129
    9971130                if (Sockets[i].AlignementAntenne->MethodeAlignement ==  AFFINE ||
    998                     Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI)
     1131                        Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI)
    9991132                {
    10001133                    // On crée un vecteur avec pour coordonnées
     
    10101143                    // Message pour l'utilisateur et les logs
    10111144
    1012                     IDLog("Application de la matrice AFFINE/TAKI\nCoordonnees initiales: AD = %s  Dec = %s\n", DHMS(newRA2*N180divPi, true ).c_str(),
    1013                           DHMS(newDEC2*N180divPi, false ).c_str());
     1145                    AfficherLog("Application de la matrice AFFINE/TAKI\nCoordonnees initiales: AD = %s  Dec = %s\n", DHMS(newRA2*N180divPi, true ).c_str(),
     1146                                DHMS(newDEC2*N180divPi, false ).c_str());
    10141147
    10151148                    // On applique la matrice de transformation
     
    10301163                    newDEC = result.y;
    10311164
    1032                     IDLog("Coordonnees finales: AD = %s  Dec = %s\n", DHMS(newRA*N180divPi, true ).c_str(),
    1033                           DHMS(newDEC*N180divPi, false ).c_str());
    1034                 }               
     1165                    AfficherLog("Coordonnees finales: AD = %s  Dec = %s\n", DHMS(newRA*N180divPi, true ).c_str(),
     1166                                DHMS(newDEC*N180divPi, false ).c_str());
     1167                }
    10351168            }
    10361169            else
     
    10381171                if (Sockets[i].AlignementAntenne->AlignementEnCours)
    10391172                {
    1040                     // Si la matrice n'est pas prête, c'est que la procédure d'alignement de l'antenne i n'est pas encore achevée.
     1173                    // Si la matrice n'est pas prête, c'est que la procédure d'alignement de l'antenne i n'est pas encore achevée.
    10411174                    // On se contente ici d'appliquer des deltas en ascension droite et en déclinaison. Ces deltas sont envoyés de BAOcontrol
    10421175                    // au driver indi_BAO par l'intermédiaire du fichier AlignementAntennes.cfg
     
    10471180                    newDEC = newDEC2 + Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections] * PasDeltaDe;
    10481181
    1049                     IDLog("Alignement en cours.\nDelta RA=%i  delta Dec=%i\n", Sockets[i].AlignementAntenne->delta_ad[Sockets[i].AlignementAntenne->nbrcorrections], Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections]);
    1050                     IDLog("Nouvelles Coordonnées AD =%s  Dec = %s\n", DHMS(newRA*N180divPi, true).c_str(), DHMS(newDEC*N180divPi, false).c_str());               
    1051                 }
     1182                    AfficherLog("Alignement en cours.\nDelta RA=%i  delta Dec=%i\n", Sockets[i].AlignementAntenne->delta_ad[Sockets[i].AlignementAntenne->nbrcorrections], Sockets[i].AlignementAntenne->delta_de[Sockets[i].AlignementAntenne->nbrcorrections]);
     1183                    AfficherLog("Nouvelles Coordonnées AD =%s  Dec = %s\n", DHMS(newRA*N180divPi, true).c_str(), DHMS(newDEC*N180divPi, false).c_str());
     1184                }
    10521185            }
    1053    
     1186
    10541187            // Calcule la hauteur et l'azimut de la zone du ciel pointée (en fonction de la date et du lieu d'observation)
    10551188
     
    10641197                // AprÚs s'être assurer que nous utilisons la méthode SIMPLE et que la matrice de rotation est ok
    10651198
    1066                 IDLog("Application de la matrice SIMPLE\nCoordonnees initiales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
    1067                       DHMS(targetAlt*N180divPi, false ).c_str());
     1199                AfficherLog("Application de la matrice SIMPLE\nCoordonnees initiales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
     1200                            DHMS(targetAlt*N180divPi, false ).c_str());
    10681201
    10691202                // On constitue un vecteur vect
    10701203                // Les coordonnées du vecteur correspondent à la position
    10711204                // d'un point défini par une latitude targetAlt et une longitude targetAz
    1072                 // sur une sphÚre de rayon 1.
     1205                // sur une sphÚre de rayon 1.
    10731206                // On reconnaît les formules de passage des coordonnées
    10741207                // sphériques aux coordonnées rectangulaires
    1075                
     1208
    10761209
    10771210                vect.x = cos(targetAz) * cos(targetAlt);
     
    10811214
    10821215                // Application de la matrice SIMPLE
    1083                
    1084                 Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionSimple(&result, vect);
     1216
     1217                Sockets[i].AlignementAntenne->AppliquerMatriceCorrectionSimple(&result, vect);
    10851218
    10861219
     
    10911224                {
    10921225                    targetAz = atan( result.y / result.x );
    1093                    
    1094                     if (result.x < 0) targetAz += Pi;
     1226
     1227                    if (result.x < 0) targetAz += Pi;
    10951228                }
    10961229                else targetAz = Pidiv2;
     
    11011234
    11021235
    1103                 IDLog("Coordonnees finales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
    1104                       DHMS(targetAlt*N180divPi, false ).c_str());
     1236                AfficherLog("Coordonnees finales: Azi = %s  Haut = %s\n", DHMS(targetAz*N180divPi, false ).c_str(),
     1237                            DHMS(targetAlt*N180divPi, false ).c_str());
    11051238            }
    11061239
     
    11291262            fs_sexa(AltStr, targetAlt, 2, 3600);
    11301263
    1131             IDLog("Coordonnees horizontales finales: Azi = %s  Haut= %s\n", AzStr, AltStr);
     1264            AfficherLog("Coordonnees horizontales finales: Azi = %s  Haut= %s\n", AzStr, AltStr);
    11321265
    11331266
    11341267            // Conversion des deux angles en pas codeurs
    11351268
    1136             if ( targetAlt < HAUTMIN )
    1137             {
    1138                 // L'objet est trop bas ( < 30°). On annule le suivi...
    1139 
    1140                 IDSetSwitch(&OnCoordSetSP, "Erreur ! L objet suivi est situe a moins de 30 deg au-dessus de l horizon. Goto annule.");
    1141 
    1142                 Suivi = false;
    1143 
    1144                 RealisationGoto = false;
    1145 
    1146                 InitAntennes();
    1147 
    1148                 return;
    1149             }
    1150             else
     1269            /*  if ( targetAlt < HAUTMIN )
     1270              {
     1271                  // L'objet est trop bas ( < 30°). On annule le suivi...
     1272
     1273                  IDSetSwitch(&OnCoordSetSP, "Erreur ! L objet suivi est situe a moins de 30 deg au-dessus de l horizon. Goto annule.");
     1274
     1275                  Suivi = false;
     1276
     1277                  RealisationGoto = false;
     1278
     1279                  InitAntennes();
     1280
     1281                  return;
     1282              }
     1283              else*/
    11511284            {
    11521285                // Si la hauteur est supérieure à 90°, on doit ajouter 180° à l'azimut et corriger
     
    11591292                }
    11601293
     1294                if ( targetAlt < HAUTMIN ) targetAlt = HAUTMIN;
     1295
    11611296                // On applique la formule de Marc pour convertir la hauteur en nombre de pas codeur alt
    11621297
     
    11661301
    11671302                Sockets[i].TargetPosition.x = (int) Arrondi( targetAz * (double)NBREPASCODEURSAZ / 360.0);
    1168                
    1169                 // Message de debug
    1170 
    1171                 IDLog("Nbre de pas codeurs Az = %i  Alt = %i\n", Sockets[i].TargetPosition.x, Sockets[i].TargetPosition.y);
     1303
     1304                // Message de debug
     1305
     1306                AfficherLog("Nbre de pas codeurs Az = %i  Alt = %i\n", Sockets[i].TargetPosition.x, Sockets[i].TargetPosition.y);
    11721307            }
    11731308        }
     
    12001335void BAO::DeconnecterSocket(int num)
    12011336{
    1202     if (Sockets[num].Connected) IDLog("Deconnexion de l antenne : %s\n", Sockets[num].IP.c_str());
     1337    if (Sockets[num].Connected) AfficherLog("Deconnexion de l antenne : %s\n", Sockets[num].IP.c_str());
    12031338    Sockets[num].new_sock.shutdown();
    12041339    Sockets[num].Connected = false;
     
    12561391
    12571392        CalculTSL();
    1258        
    1259        
    1260         // On charge les paramÚtres de correction des antennes toutes les demi-secondes
     1393
     1394
     1395        // On charge les paramÚtres de correction des antennes toutes les demi-secondes
    12611396
    12621397        if ( compt%500 == 0  && tv.tv_usec/1.0E6 > 0.5 )
     
    12671402                {
    12681403                    // Si l'antenne i est connectée, on charge les paramÚtres
    1269                     Sockets[i].AlignementAntenne->TransmettreParametresClasseAstro(Annee, Mois, Jour, Heu, Min, Sec, Longitude, Latitude, Pression, Temp);         
    1270                    
    1271                     if (Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE )
    1272                     {
    1273                       //IDLog("chargement simple\n");
    1274                       Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesSIMPLE.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
    1275                     }
    1276                     else
    1277                        {
    1278                         // IDLog("chargement taki\n");
    1279                       Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesTAKI.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
    1280                     }
     1404                    Sockets[i].AlignementAntenne->TransmettreParametresClasseAstro(Annee, Mois, Jour, Heu, Min, Sec, Longitude, Latitude, Pression, Temp);
     1405
     1406                    if (Sockets[i].AlignementAntenne->MethodeAlignement == SIMPLE )
     1407                    {
     1408                        //AfficherLog("chargement simple\n");
     1409                        Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesSIMPLE.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
     1410                    }
     1411                    else
     1412                    {
     1413                        // AfficherLog("chargement taki\n");
     1414                        Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennesTAKI.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
     1415                    }
    12811416                }
    12821417            }
     
    13421477                        // on l'affiche dans le log
    13431478
    1344                         IDLog("Reponse recue de %s : %s\n", Sockets[i].IP.c_str(), reponse.c_str());
     1479                        AfficherLog("Reponse recue de %s : %s\n", Sockets[i].IP.c_str(), reponse.c_str());
    13451480
    13461481                        // On vérifie ici les acknowledges
     
    13831518                                    IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : position de l antenne inconnue !\n",
    13841519                                                Sockets[i].IP.c_str());
     1520                                    AfficherLog("ALERTE antenne %s : position de l antenne inconnue !\n",
     1521                                                Sockets[i].IP.c_str());
    13851522
    13861523                                    // La position de l'antenne st donc inconnue
     
    14361573
    14371574                                    IDSetSwitch(&ParkSP, "ALERTE antenne %s : erreur PARK !\n", Sockets[i].IP.c_str());
     1575                                    AfficherLog("ALERTE antenne %s : erreur ABORT !\n",  Sockets[i].IP.c_str());
    14381576                                }
    14391577                                else if (Sockets[i].ack_park && reponse.find("OK")!=string::npos)
     
    14611599
    14621600                                    IDSetSwitch(&AbortSlewSP, "ALERTE antenne %s : erreur ABORT !\n",  Sockets[i].IP.c_str());
     1601                                    AfficherLog("ALERTE antenne %s : erreur ABORT !\n",  Sockets[i].IP.c_str());
    14631602                                }
    14641603                                else if (Sockets[i].ack_abort && reponse.find("OK")!=string::npos)
     
    14851624                                    // Message d'erreur
    14861625
    1487                                     IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : Erreur GOTO !\n",  Sockets[i].IP.c_str());
    1488 
     1626                                    IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : Erreur NACK GOTO !\nRetour : %s\n",  Sockets[i].IP.c_str(), reponse.c_str());
     1627                                    AfficherLog("ALERTE antenne %s : Erreur NACK GOTO !\nRetour : %s\n",  Sockets[i].IP.c_str(), reponse.c_str());
    14891628                                    // On déconnecte l'antenne. Elle ne semble pas en mesure d'exécuter les ordres goto
    14901629
    1491                                     DeconnecterSocket(i);
     1630                                    // 02/04/2012 Le fait de recevoir un nack/eos ne nécessite pas de devoir déconnecter l'antenne
     1631                                    // DeconnecterSocket(i);
    14921632                                }
    14931633                                else if (Sockets[i].ack_goto)
     
    15761716                    DeconnecterSocket(i);
    15771717
    1578                     IDLog("Indi_BAO, SocketException IsPoll : ");
    1579                     IDLog(e.description().c_str());
    1580                     IDLog("\n");
     1718                    AfficherLog("Indi_BAO, SocketException IsPoll : ");
     1719                    AfficherLog(e.description().c_str());
     1720                    AfficherLog("\n");
    15811721                }
    15821722            }
     
    16621802        {
    16631803            // Délais entre deux actualisations
    1664            
     1804
    16651805            // Actualisation toutes les 15 minutes en mode transit (par défaut)
    16661806
    1667             double delai = ActualisationTMTransit / 3600.0 / 24.0;   
    1668            
    1669             // et 5 secs en mode tracking (par défaut)
    1670 
    1671             if (TrackingMode == BAO_TRACKING) delai = ActualisationTMTracking / 3600.0 / 24.0;   
     1807            double delai = ActualisationTMTransit / 3600.0 / 24.0;
     1808
     1809            // et 5 secs en mode tracking (par défaut)
     1810
     1811            if (TrackingMode == BAO_TRACKING) delai = ActualisationTMTracking / 3600.0 / 24.0;
    16721812
    16731813
     
    17051845                    IDSetSwitch(&OnCoordSetSP, "Erreur ! Plus d antennes connectees !");
    17061846
    1707                     if (Suivi) IDLog("Arrêt du suivi !");
     1847                    if (Suivi) AfficherLog("Arrêt du suivi !");
    17081848
    17091849                    RealisationGoto=false;
     
    18101950
    18111951                                //Message à l'attention de l'utilisateur
    1812                                
     1952
    18131953                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : pas d acknowledge recu apres l ordre POSITION. \
    18141954Deconnexion de l antenne.", Sockets[i].IP.c_str());
     1955                                AfficherLog("Erreur sur l antenne %s : pas d acknowledge recu apres l ordre POSITION. \
     1956Deconnexion de l antenne.", Sockets[i].IP.c_str());
    18151957
    18161958                                // On déconnecte l'antenne
    1817                                
    1818                                 DeconnecterSocket(i);
     1959
     1960                                // DeconnecterSocket(i);
    18191961                            }
    18201962                        }
     
    18311973                            // Tout vas bien
    18321974                            // On ne consigne aucune anomalie
    1833                            
     1975
    18341976                            Sockets[i].AttenteExecution = 0;
    18351977                            Sockets[i].AnomaliesExecution = 0;
    18361978
    18371979                            //On passe à l'étape suivante
    1838                            
     1980
    18391981                            Sockets[i].etape++;
    18401982                        }
     
    18531995
    18541996                                // On consigne une erreur grave. L'antenne tarde à répondre
    1855                                
     1997
    18561998                                Sockets[i].AnomaliesExecution++;
    18571999                            }
     
    18592001                            // Aucune réponse de l'antenne depuis plusieurs minutes
    18602002                            // On la déconnecte
    1861                            
     2003
    18622004                            if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
    18632005                            {
     
    18672009
    18682010                                //Message d'erreur
    1869                                
     2011
    18702012                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : la position retournee n est pas valide. \
    18712013Deconnexion de l antenne.", Sockets[i].IP.c_str());
     2014                                AfficherLog("Erreur sur l antenne %s : la position retournee n est pas valide. \
     2015Deconnexion de l antenne.", Sockets[i].IP.c_str());
    18722016
    18732017                                //Déconnexion de l'antenne
    1874                                
    1875                                 DeconnecterSocket(i);
     2018
     2019                                // DeconnecterSocket(i);
    18762020                            }
    18772021                        }
     
    19142058
    19152059                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : pas d acknowledge recu apres l ordre GOTO. Deconnexion de l antenne.", Sockets[i].IP.c_str());
    1916 
    1917                                 DeconnecterSocket(i);
     2060                                AfficherLog("Erreur sur l antenne %s : pas d acknowledge recu apres l ordre GOTO. Deconnexion de l antenne.", Sockets[i].IP.c_str());
     2061
     2062                                // DeconnecterSocket(i);
    19182063                            }
    19192064                        }
     
    19582103                                // Message d'erreur
    19592104                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : l antenne n a pas renvoye GOTO/OK. Deconnexion de l antenne.", Sockets[i].IP.c_str());
     2105                                AfficherLog("Erreur sur l antenne %s : l antenne n a pas renvoye GOTO/OK. Deconnexion de l antenne.", Sockets[i].IP.c_str());
     2106
    19602107
    19612108                                //Déconnexion de l'antenne
    1962                                 DeconnecterSocket(i);
     2109                                // DeconnecterSocket(i);
    19632110                            }
    19642111                        }
     
    19722119
    19732120        ///////////////////////////////////////
    1974         // Réalisation d'un goto - traitement de l'étape 3 
     2121        // Réalisation d'un goto - traitement de l'étape 3
    19752122        // On place cette partie du traitement en dehors du switch et de la boucle
    19762123        // pour pouvoir envoyer les gotos à toutes les antennes lorsque l'on a la confirmation
     
    20312178
    20322179                    IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : deconnexion de l antenne.", Sockets[i].IP.c_str());
     2180                    AfficherLog("Erreur sur l antenne %s : deconnexion de l antenne.", Sockets[i].IP.c_str());
    20332181
    20342182                    // Déconnexion antenne
    20352183
    2036                     DeconnecterSocket(i);
     2184                    // DeconnecterSocket(i);
    20372185                }
    20382186            }
     
    20572205    {
    20582206        // Transit
    2059        
     2207
    20602208    case BAO_TRANSIT:
    20612209
     
    21002248
    21012249        // Tracking
    2102        
     2250
    21032251    case BAO_TRACKING:
    21042252
    21052253        // Éteindre les voyants dans la boîte de dialogue Indi
    2106        
     2254
    21072255        EquatorialCoordsWNP.s = IPS_BUSY;
    21082256        AbortSlewSP.s = IPS_IDLE;
     
    21552303        // Petit message
    21562304
    2157         IDLog("\nHello BAORadio !\n");
     2305        AfficherLog("\nHello BAORadio !\n");
    21582306
    21592307        // On lance le thread !
     
    21662314        if (pthread_create (&th1, NULL, (void*(*)(void*))LancementThread, this) < 0)
    21672315        {
    2168             IDLog("pthread_create error for threadSocket\n");
     2316            AfficherLog("pthread_create error for threadSocket\n");
    21692317        }
    21702318
     
    21792327        ConnectSP.s = IPS_IDLE;
    21802328        IDSetSwitch (&ConnectSP, "BAORadio is offline.");
    2181         IDLog("Telescope is offline.");
     2329        AfficherLog("Telescope is offline.");
    21822330
    21832331        // On déconnecte tous les sockets
     
    22382386        Sockets[numsocket].new_sock << chaine;
    22392387
    2240         IDLog("Commande envoyee a %s: %s", Sockets[numsocket].IP.c_str(), chaine);
     2388        AfficherLog("Commande envoyee a %s: %s", Sockets[numsocket].IP.c_str(), chaine);
    22412389    }
    22422390    catch (SocketException& e)
     
    22462394        DeconnecterSocket(numsocket);
    22472395
    2248         IDLog("Indi_BAO, COMMANDE exception : ");
    2249         IDLog(e.description().c_str());
    2250         IDLog("\n");
     2396        AfficherLog("Indi_BAO, COMMANDE exception : ");
     2397        AfficherLog(e.description().c_str());
     2398        AfficherLog("\n");
    22512399
    22522400        return false;
     
    23282476
    23292477    // ne pas faire des tours complets en Az pour rien...
    2330    
     2478
    23312479    while (deltaAz > NBREPASCODEURSAZ) deltaAz -= NBREPASCODEURSAZ;
    23322480
    23332481    // Doit résoudre tous les problÚmes concernant l'azimut...
    2334    
     2482
    23352483    if (deltaAz > NBREPASCODEURSAZ / 2 )
    23362484    {
     
    23652513{
    23662514    //Il ne faut exécuter la fonction qu'une seule fois
    2367    
     2515
    23682516    static int isInit = 0;
    23692517
     
    24642612    ConnectSP.s = IPS_IDLE;
    24652613    IDSetSwitch(&ConnectSP, "The connection to the telescope is lost.");
    2466     IDLog("arret");
     2614    AfficherLog("arret");
    24672615    return;
    24682616}
Note: See TracChangeset for help on using the changeset viewer.