Changeset 650


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

Location:
BAORadio/libindi/libindi
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • BAORadio/libindi/libindi/BAOControl/bao_catalogue.dat

    r643 r650  
     1[star 0]
     2name=POLARIS
     3const=UMi
     4ar=02:31:49.6
     5de=89:15:50.9
     6mag=1.97
     7
    18[star 1]
    29name=KOCAB
  • BAORadio/libindi/libindi/BAOControl/baocontrol.cpp

    r648 r650  
    3434 * Laboratoire de l'Accélérateur Linéaire *\n \
    3535 *                                        *\n \
    36  *             v0.5  23/02/2012           *\n \
     36 *             v0.51 02/04/2012           *\n \
    3737 *        franckrichard033@gmail.com      *\n \
    3838 ******************************************\n\n\n", true);
     
    10401040
    10411041/**************************************************************************************
     1042** Envoie une commande aux antennes
     1043** exemples : P, Z, A, Gf1000f0100
     1044**
     1045***************************************************************************************/
     1046
     1047bool BAOcontrol::EnvoyerCommande(string commande)
     1048{
     1049    stringstream os;
     1050
     1051    try
     1052    {
     1053        *client_socket << "<newTextVector device=\"BAO\" name=\"COMMAND_SET\">";
     1054        *client_socket << "<oneText name=\"COMMAND\">";
     1055        *client_socket << commande;
     1056        *client_socket << "</oneText>";
     1057        *client_socket << "</newTextVector>";
     1058
     1059        if (!VerifReponse("name=\"COMMAND_SET\" state=\"Ok\""))
     1060        {
     1061            ErreurLog("ERREUR fct EnvoyerCommande : pas de réponse du pilote indi_BAO.\n\n");
     1062
     1063            return false;
     1064        }
     1065    }
     1066
     1067    // un problÚme ?
     1068
     1069    catch ( SocketException& e )
     1070    {
     1071        ErreurLog("Exception was caught:" + e.description() + "\n");
     1072
     1073        return false;
     1074    }
     1075
     1076    return true;
     1077}
     1078
     1079
     1080
     1081/**************************************************************************************
    10421082** Place les antennes en position de repos
    10431083**
     
    14671507        // (et donc accessibles à l'antenne)
    14681508
    1469         for (i=1; i<numEtoiles; i++)
     1509        for (i=0; i<numEtoiles; i++)
    14701510        {
    14711511            Azimut(Etoiles[i].ad, Etoiles[i].de, &Etoiles[i].az, &Etoiles[i].ha);
     
    15131553        // pour calibrer l'antenne
    15141554
    1515         for (i=1; i<numEtoiles; i++)
     1555        for (i=0; i<numEtoiles; i++)
    15161556        {
    15171557            if ( Etoiles[i].selectionnee )
     
    20492089
    20502090
     2091    // Envoyer une commande aux antennes
     2092
     2093    if (chaine.find("send")!=string::npos)
     2094    {
     2095        string commande;
     2096
     2097        CommandeOK = true;
     2098
     2099        if (DecompositionCommande(chaine, "send", &commande, NULL))
     2100        {
     2101            switch (commande[0])
     2102            {
     2103              case 'g' : commande[0]='G'; break;
     2104              case 'a' : commande[0]='A'; break;
     2105              case 'z' : commande[0]='Z'; break;
     2106              case 'p' : commande[0]='P'; break;
     2107            }
     2108           
     2109            if (!EnvoyerCommande((string)commande))
     2110            {
     2111              ErreurLog("Erreur ! La commande n'a pas un format correct !");
     2112            }
     2113            else
     2114            {
     2115              AfficherLog("Lire le retour de la commande dans la fenêtre indiserver.\n\n", true);
     2116            }
     2117        }
     2118    }
     2119
     2120   
     2121   
    20512122    // correction de l'alignement d'une antenne par rapport à l'objet visé
    20522123
     
    22852356        cout << "align ip :               Lance la procédure d'alignement de l'antenne d'adresse ip." << endl;
    22862357        cout << "reset ip :               Réinitialise les paramÚtres d'alignement de l'antenne d'adresse ip." << endl;
    2287         cout << "set transit on :         Active le mode de suivi transit." << endl;
     2358        cout << "send comm :              Envoie la commande 'comm' aux antennes." << endl;
     2359        cout << "                         exemples : send P, send A, send Gf1000f1000" << endl;
     2360        cout << "set transit on :         Active le mode de suivi transit." << endl;
    22882361        cout << "set transit delay x :    Fixe la durée entre deux actualisations à x seconde(s) dans le mode transit" << endl;
    22892362        cout << "set tracking on :        Active le mode de suivi tracking." << endl;
     
    30303103    UpdateTime();
    30313104
    3032     numEtoiles = 1;
     3105    numEtoiles = 0;
    30333106
    30343107    // Lecture des étoiles
    30353108
    3036     section = "star 1";
     3109    section = "star 0";
    30373110    key     = "name";
    30383111
     
    32293302
    32303303            ChoixCouleurs==1 ? IDLog(grey1) : IDLog(grey2);
     3304           
     3305            AfficherLog(">" + chaine + "\n\n", false);
    32313306
    32323307            // on met en minuscules
  • BAORadio/libindi/libindi/BAOControl/baocontrol.h

    r648 r650  
    119119    bool EnvoyerDelaisModesTransitEtTracking();
    120120    bool EnvoyerMethodeAlignement();
     121    bool EnvoyerCommande(string commande);
    121122    bool Park();
    122123    bool Abort();
  • BAORadio/libindi/libindi/BAOTest/BAOtest_main.cpp

    r642 r650  
    225225                               std::cout <<  "Microcontrôleur : " << chaine;
    226226
    227                                std::cout <<  "Positionnement de l antenne...\n";
    228                             }
     227                               std::cout <<  "Positionnement de l antenne...\n";                               
     228                            }
     229                           
     230                            // sleep(20);
    229231
    230232                            // sleep(rand()%10);
  • BAORadio/libindi/libindi/communs/logs.cpp

    r644 r650  
    7474    if ( (pFile = fopen(fichier.c_str(), "a")) != NULL)
    7575    {
    76         // On le sauvegarde dans le fichier log
     76        time_t rawtime;
     77        struct tm * timeinfo;
     78
     79        char buffer[80];
     80       
     81        // On sauvegarde la date et l'heure
     82       
     83        time ( &rawtime );
     84        timeinfo = localtime ( &rawtime );
     85        strftime (buffer,80,"%c    ",timeinfo);
     86        fprintf(pFile, buffer);
     87       
     88        // On le sauvegarde dans le fichier log
    7789
    7890        fprintf(pFile, Message.c_str());
  • 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}
  • BAORadio/libindi/libindi/drivers/telescope/BAO.h

    r648 r650  
    2323#include <fstream>
    2424
     25#include <stdarg.h>
     26
    2527#include <termios.h>
    2628#include <unistd.h>
     
    148150    void connection_lost();
    149151    void connection_resumed();
     152   
     153    void AfficherLog(const char* Message,...);
    150154
    151155
     
    166170    IText PortT[1];
    167171    IText ObjectT[1];
     172    IText CommandT[1];
    168173
    169174    /* Numbers */
     
    192197    ITextVectorProperty PortTP;
    193198    ITextVectorProperty ObjectTP;
     199    ITextVectorProperty CommandTP;
    194200
    195201
  • BAORadio/libindi/libindi/result_recherche_bao

    r648 r650  
     1
     2
     3Results from query to  NASA/IPAC Extragalactic Database (NED),
     4which is operated by the Jet Propulsion Laboratory, California Institute of
     5Technology, under contract with the National Aeronautics and Space Administration.
     6This work was (partially) supported by the US National Virtual Observatory
     7development project, which is funded by the National Science Foundation
     8under cooperative agreement AST0122449 with The Johns Hopkins University.
     9
     10
     11
     12queryDateTime:2012-04-01T09:37:58PDT
     13
     14
     15
     16Main Information Table for MESSIER 031
     17
     18
     19
     20Equinox:J2000.0
     21
     22
     23
     24CoordSystem:Equatorial
     25
     26No.|Object Name|RA(deg)|DEC(deg)|Type|Velocity|Redshift|Redshift Flag|Magnitude and Filter|Distance (arcmin)|References|Notes|Photometry Points|Positions|Redshift Points|Diameter Points|Associations
     271|MESSIER 031| 10.68479 |  41.26906 |G|  -300|-0.001001 |    | 4.36||3374|18|138|8|26|7|2
Note: See TracChangeset for help on using the changeset viewer.