Ignore:
Timestamp:
Mar 7, 2012, 6:19:29 PM (14 years ago)
Author:
frichard
Message:

Méthode d'alignement TAKI et AFFINE

Location:
BAORadio/libindi/libindi/drivers/telescope
Files:
2 edited

Legend:

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

    r642 r648  
    4343    init_properties();
    4444
    45     // Le bouton connect de la boîte de dialogue d'indi8BAO
     45    // Le bouton connect de la boîte de dialogue d'indi_BAO
    4646    // est dans l'état IDLE au démarrage
    4747
     
    5252    lastRA                = 0.0;
    5353    lastDEC               = 0.0;
     54   
     55    // Jour julien de la derniÚre actualisation
     56   
    5457    JJAnc                 = 0.0;
    5558
    5659    // Variables d'état
    5760
    58     currentSet            =  0;         // Variables internes d'Indi, ne pas toucher
    59     lastSet               = -1;         // Variable interne d'Indi, ne pas toucher
     61    currentSet            =  0;
    6062
    6163    // Nombre d'antennes connectées
     
    6567    // Le mode tracking est activé par défaut
    6668
    67     TrackingMode          =  1;
     69    TrackingMode          =  BAO_TRACKING;
     70   
     71    // Méthode d'alignement par défaut
     72   
     73    MethodeAlignement     = SIMPLE;
    6874
    6975    // délais en sec entre deux actualisations
    7076    // dans les modes transit et tracking
    7177
    72     ActualisationTMTransit  = 15.0 * 60.0;    // Délai entre 2 actualisations dans le mode transit
     78    ActualisationTMTransit  = 15.0 * 60.0;    // Délai entre 2 actualisations dans le mode transit (en sec)
     79   
    7380    ActualisationTMTracking = 5.0;            //                "                 "        tracking
    7481
     
    8693    RealisationGoto       = false;
    8794
    88     // vaut true si l'utilisateur demande l'annulation du mouvement en cours
     95    // = true si l'utilisateur demande l'annulation du mouvement en cours
    8996
    9097    Abort                 = false;
    9198
    92     // vaut true si l'utilisateur demande de mettre les antennes en mode park
     99    // = true si l'utilisateur demande de mettre les antennes en mode park
    93100
    94101    Park                  = false;
    95102
    96     // vaut true un objet est actuellement suivi par les antennes
     103    // = true si un objet est actuellement suivi par les antennes
    97104
    98105    Suivi                 = false;
    99106
    100     // vaut true si l'utilisateur demande à sortir de l'application -> permet de fermer le thread
     107    // = true si l'utilisateur sort de l'application -> permet de fermer le thread
    101108
    102109    Exit                  = false;
     110   
     111    // Initialisation des paramÚtres atmosphériques par défaut
    103112   
    104113    Pression              = 1013.0;
     
    141150BAO::~BAO()
    142151{
    143     //On informe le thread que nous allons sortir
     152    // On informe le thread que nous allons sortir
    144153
    145154    Exit = true;
     
    161170
    162171    // Petit message à l'attention de l'utilisateur
    163     // permet de savoir si le destructeur est bien atteint
     172    // permet de savoir si le destructeur a bien été atteint
    164173
    165174    IDLog("Sortie de indi_BAO\n");
     
    257266
    258267/**************************************************************************************
    259 ** Initialisation de la boîte de dialogue INDI (suite)
    260 ** Vider tous les vecteurs
     268** Définition de tous les vecteurs de la boîte de dialogue INDI
     269** Cette procédure doit être obligatoirement présente dans tous pilotes Indi
    261270**
    262271***************************************************************************************/
     
    271280    IDDefSwitch(&ConnectSP, NULL);
    272281    IDDefText(&ObjectTP, NULL);
    273     IDDefNumber(&EquatorialCoordsWNP, NULL);
    274     IDDefNumber(&GeographicCoordsWNP, NULL);
    275     IDDefNumber(&PressionTempWNP, NULL);
     282    IDDefNumber(&EquatorialCoordsWNP, NULL);     
    276283    IDDefSwitch(&OnCoordSetSP, NULL);
    277284    IDDefSwitch(&AlignmentSP, NULL);
     
    282289    IDDefNumber(&ActualisationNP1, NULL);
    283290    IDDefNumber(&ActualisationNP2, NULL);
    284 }
    285 
    286 
    287 /**************************************************************************************
    288 ** Initialisation des vecteurs INDI
    289 ** ParamÚtres par défaut
     291    IDDefNumber(&PressionTempWNP, NULL);
     292    IDDefNumber(&GeographicCoordsWNP, NULL); 
     293}
     294
     295
     296/**************************************************************************************
     297** Initialisation des vecteurs de la boîte Indi
     298** Cette procédure doit être obligatoirement présente dans tous pilotes Indi
    290299**
    291300***************************************************************************************/
     
    333342** En cas de changement de texte dans la boîte de dialogue (par exemple : changement du
    334343** nom de l'objet) alors suivre l'objet...
    335 ** Cette fonction n'est pas encore utilisée
    336 ** TODO: faut-il pouvoir modifier le nom de l'objet depuis la boîte ?
    337 ** pas sûr que cela soit utile: kstars et BAOcontrol permettent de faire cela
     344** Cette fonction n'est pas utilisée
     345** TODO: faut-il proposer cette fonction depuis la boîte alors qu'il est déjà
     346** possible de le faire depuis  Kstars et BAOcontrol ?
     347**
    338348**
    339349***************************************************************************************/
     
    372382** Exemple : longitude, latitude, ar, dec etc...) -> prendre en compte les modifications
    373383**
     384** 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
     386** (ex : les coordonnées géographiques, les coordonnées horaires de l'objet etc...)
     387** double names[] contient la liste de tous les champs modifiables dans chaque rubrique
     388** (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
     390** sous la forme d'une chaîne de caractÚres
     391**
    374392***************************************************************************************/
    375393
     
    400418    if (!strcmp (name, GeographicCoordsWNP.name))
    401419    {
    402         // l'utilisateur a modifié un les coordonnées géographiques de la boite indi
     420        // l'utilisateur a modifié une des coordonnées géographiques de la boite indi
    403421
    404422        int i = 0, nset = 0;
    405423
    406424        // En cas d'erreur, on doit pouvoir sortir avec des paramÚtres par défaut
    407         //ici la latitude et la longitude vondront 0.0
     425        // ici la latitude et la longitude valent 0.0
    408426
    409427        Latitude  = 0.0;
     
    412430        // pour ce vecteur, on sait qu'il y a n éléments possibles
    413431        // Exemple pour la rubrique coordonnées géographique de la boîte indi
    414         // il y a deux éléments : la longtude et la latitude
    415         // pour la rubrique alignement, il y aen a trois par exemple :
    416         // simple, affine et taki
     432        // il y a deux éléments : la longitude et la latitude
     433        // pour la rubrique alignement, il y a en a trois : simple, affine et taki
    417434
    418435        for (i = 0; i < n; i++)
     
    425442            if (eqp == &GeographicCoordsWN[0])
    426443            {
    427                 //ici on a identifié la zone latitude de la boîte de dialogue
    428                 // Value[i] contient la chaine de caractÚre correspondante dans la boîte
     444                // ici on a identifié la zone latitude de la boîte de dialogue
     445                // Value[i] contient la chaîne de caractÚre correspondante dans la boîte
    429446                // C'est la valeur saisie par l'utilisateur
    430447
     
    459476        if (nset == 2)
    460477        {
    461             //Vérification
    462             //IDLog("Geographic : RA %5.2f - DEC %5.2f\n", Latitude, Longitude);
    463 
    464             //nset vaut 2, on sommes donc sûrs qu'il n'y a pas de problÚme dans les valeurs
     478            // Vérification
     479            // IDLog("Geographic : RA %5.2f - DEC %5.2f\n", Latitude, Longitude);
     480
     481            // nset vaut 2, nous sommes donc sûrs qu'il n'y a pas de problÚme dans les valeurs
    465482            // saisies par l'utilisateur
    466483            // voir le code plus haut pour comprendre...
    467484
    468             // On change la couleur de la "diode" de la rubrique coordonnées géographiques de la boîte
    469             // en vert
     485            // On change la couleur de la "diode" de la rubrique coordonnées
     486            // géographiques de la boîte en vert
    470487
    471488            GeographicCoordsWNP.s = IPS_OK;
     
    478495        {
    479496            // quelque chose cloche
    480             // peut-être l'une des veleurs saisies par l'utilisateur n'est-elle pas dans
     497            // peut-être l'une des valeurs saisies par l'utilisateur n'est-elle pas dans
    481498            // le bon intervalle ? ex : lat = 150°
    482499
     
    496513
    497514        // c'est bon. On peut donc transmettre les nouvelles valeurs à la classe astro
    498         // qui utilisera ces informations pur calculer l'azimut des objets et le tsl en particulier...
     515        // qui utilisera ces informations pur calculer l'azimut des objets et le temps sidéral local en particulier...
    499516
    500517        DefinirLongitudeLatitude(Longitude, Latitude);
     
    533550            else if (eqp == &EquatorialCoordsWN[1])
    534551            {
    535                 //même chose pour la déclinaison
     552                // même chose pour la déclinaison
    536553                newDEC = values[i];
    537554
     
    553570            targetDEC = newDEC;
    554571
    555             // on les affiches dans les logs
     572            // on les affiche dans les logs
    556573
    557574            fs_sexa(RAStr, newRA, 2, 3600);
     
    602619            if (eqp == &PressionTempWN[0])
    603620            {
    604                 // on a compris que l'utilisateur avait changé l'ascension droite de l'objet
     621                // on a compris que l'utilisateur a changé l'ascension droite de l'objet
    605622
    606623                // on affecte la nouvelle valeur à newRA
     
    649666    if (!strcmp (name, ActualisationNP1.name))
    650667    {
    651         // on a ici exactement le même fonctionnement que précédement
    652         // on régle ici les valeurs des delais entre deux actualisations
     668        // on a ici exactement le même fonctionnement que précédemment
     669        // on rÚgle ici les valeurs des délais entre deux actualisations
    653670        // de la position en mode transit et tracking
    654         // retourne un message d'erreur si les durées ne sont pas exprimées
    655         // dans un intervalle > 0.0 et < 3600
     671        // Retourne un message d'erreur si les durées ne sont pas exprimées
     672        // dans un intervalle > 0 et < 3600
    656673
    657674        double newAct1 = 1.0;
     
    717734/**************************************************************************************
    718735** L'utilisateur clique sur l'un des boutons de la boîte Indi
    719 **
     736** Même observation que pour la procédure précédente
     737**
    720738***************************************************************************************/
    721739
     
    767785            return;
    768786
    769         currentSet = get_switch_index(&AlignmentSP);
    770         AlignmentSP.s = IPS_OK;
     787        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;
    771794        IDSetSwitch(&AlignmentSP, NULL);
    772795
    773         for (int i=0; i<MAXALIGNEMENTANTENNE; i++)
    774         {
    775             switch (currentSet)
     796        for (int i=0; i<MAXHOSTNAME; i++)
     797        {
     798            switch (MethodeAlignement)
    776799            {
    777800            case 1 :
     
    846869** l'utilisation d'un thread permet de contourner le problÚme de la fonction accept
    847870** qui est bloquante.
     871** L'adresse IP de l'antenne qui a effectué la connexion est consignée dans la variable IP
     872** de la structure Sockets. L'état de l'antenne (connected) est placée à true
    848873**
    849874***************************************************************************************/
     
    858883
    859884            Sockets[SocketsNumber].IP = server.recupip(Sockets[SocketsNumber].new_sock);
    860 
    861             Sockets[SocketsNumber++].Connected = true;
     885           
     886            Sockets[SocketsNumber].AlignementAntenne->MethodeAlignement = MethodeAlignement;
     887
     888            Sockets[SocketsNumber++].Connected = true;     
    862889
    863890            InitThreadOK = true;
     
    894921/**************************************************************************************
    895922** Extraction de la position de l'antenne aprÚs l'envoi de la commande P
    896 ** Le retour de la commande P est POSITION/valeur_az/valeur_alt/
    897 ** ExtractPosition retourne donc Valeur_az et Valeur_alt
     923** Le retour de la commande P est POSITION/valeur_az/valeur_alt/
     924** Ce retour est envoyé dans la chaîne str
     925** ExtractPosition retourne une structure Position contenant Valeur_az et Valeur_alt
     926** Ex: ExtractPosition("POSITION/0100/0001/", result)  retourne result.x=100 et result.y=1
    898927**
    899928***************************************************************************************/
     
    929958
    930959/************************************************************************************
    931 ** Cette procédure, aprÚs avoir appliqué la matrice de rotation aux coordonnées
    932 ** visées par l'utilisateur, convertit les coordonnées équatoriales de l'objet visé
    933 ** en unités de codeurs des paraboles
     960** Cette procédure, aprÚs avoir appliqué la matrice de rotation aux coordonnées de l'objet
     961** visées par l'utilisateur, effectue les conversions en unités codeurs des paraboles
    934962** (càd en nb de tours des deux axes moteurs depuis la position PARK)
    935963**
     
    954982        if (Sockets[i].Connected)
    955983        {
    956             newRA = newRA2;
     984            newRA  = newRA2;
    957985            newDEC = newDEC2;
    958986         
     
    960988            // sur les coordonnées horaires de l'objet visé
    961989
    962             // il faut vérifier auparavent que la matrice de rotation est disponible
     990            // il faut vérifier auparavant que la matrice de rotation est disponible
    963991            // pour l'antenne i
    964992
    965993            if  (Sockets[i].AlignementAntenne->Matrice_ok)
    966994            {
    967                 // On est bien dans le cas de l'allignement AFFINE ou Taki
     995                // On est bien dans le cas de l'alignement AFFINE ou Taki
    968996
    969997                if (Sockets[i].AlignementAntenne->MethodeAlignement ==  AFFINE ||
    970                         Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI)
     998                    Sockets[i].AlignementAntenne->MethodeAlignement ==  TAKI)
    971999                {
    9721000                    // On crée un vecteur avec pour coordonnées
    9731001                    // x = Angle horaire de l'objet visé
    974                     // y = déclainaison de l'objet
     1002                    // y = déclinaison de l'objet
    9751003                    // z = 1.0
    9761004                    // Voir la documentation pour plus d'explications sur le calcul affine/taki
     
    9991027                    // On récupÚre les nouvelles coordonnées. z ne nous intéresse pas
    10001028
    1001                     newRA  = VerifAngle(result.x+GetTSL());
     1029                    newRA  = VerifAngle(result.x + GetTSL());
    10021030                    newDEC = result.y;
    10031031
     
    10231051                }
    10241052            }
    1025                    IDLog("Nouvelles Coordonnées AD =%s  Dec = %s\n", DHMS(newRA*N180divPi, true).c_str(), DHMS(newDEC*N180divPi, false).c_str());               
    1026 
    1027 
     1053   
    10281054            // Calcule la hauteur et l'azimut de la zone du ciel pointée (en fonction de la date et du lieu d'observation)
    10291055
     
    10421068
    10431069                // On constitue un vecteur vect
    1044                 // Les coordonnées du vecteur correspondont à la position
    1045                 // d'un point sur une sphÚre de rayon 1
    1046                 // avec une latitude = targetAlt et une longitude=targetAz
    1047                 // on reconnait bien les formules de passage des coordonnées
     1070                // Les coordonnées du vecteur correspondent à la position
     1071                // d'un point défini par une latitude targetAlt et une longitude targetAz
     1072                // sur une sphÚre de rayon 1.
     1073                // On reconnaît les formules de passage des coordonnées
    10481074                // sphériques aux coordonnées rectangulaires
    1049                
    10501075               
    10511076
     
    10671092                    targetAz = atan( result.y / result.x );
    10681093                   
    1069                     if (result.x < 0) targetAz+=Pi;
     1094                    if (result.x < 0) targetAz += Pi;
    10701095                }
    10711096                else targetAz = Pidiv2;
     
    11071132
    11081133
    1109             //Conversion des deux angles en pas codeurs
     1134            // Conversion des deux angles en pas codeurs
    11101135
    11111136            if ( targetAlt < HAUTMIN )
     
    11401165                //4000 pas pour 360° sur l'axe az
    11411166
    1142                 Sockets[i].TargetPosition.x = (int) Arrondi( targetAz * 4000.0 / 360.0);
     1167                Sockets[i].TargetPosition.x = (int) Arrondi( targetAz * (double)NBREPASCODEURSAZ / 360.0);
    11431168               
    11441169                // Message de debug
    11451170
    1146                 IDLog("Nbre de pas codeurs Az = %i        Alt = %i\n", Sockets[i].TargetPosition.x, Sockets[i].TargetPosition.y);
     1171                IDLog("Nbre de pas codeurs Az = %i  Alt = %i\n", Sockets[i].TargetPosition.x, Sockets[i].TargetPosition.y);
    11471172            }
    11481173        }
     
    11531178
    11541179/************************************************************************************
    1155 * Retourne le nombre d'antennes actuellement connectées
    1156 *
     1180** Retourne le nombre d'antennes actuellement connectées
     1181**
    11571182************************************************************************************/
    11581183
     
    11871212** Procédure principale
    11881213** Elle est appelée toutes les ms
     1214**
    11891215***************************************************************************************/
    11901216
     
    11991225    struct timezone tz;
    12001226
    1201     //si pas de connexion avec le seveur d'indi -> on sort
     1227    //si pas de connexion avec le serveur d'indi -> on sort
    12021228
    12031229    if (!is_connected()) return;
     
    12271253        DefinirDateHeure(Annee, Mois, Jour, Heu, Min, Sec);
    12281254
    1229         //Puis on calule le temps sidéral local, le JJ etc.
     1255        // Puis on calcule le temps sidéral local, le JJ etc.
    12301256
    12311257        CalculTSL();
     
    12431269                    Sockets[i].AlignementAntenne->TransmettreParametresClasseAstro(Annee, Mois, Jour, Heu, Min, Sec, Longitude, Latitude, Pression, Temp);         
    12441270                   
    1245                     Sockets[i].AlignementAntenne->ChargementParametresAlignement(Sockets[i].IP, "/home/" + (string)getenv("USER") + "/AlignementAntennes.cfg", targetRA * 15 * Pidiv180, targetDEC * Pidiv180);
     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                    }
    12461281                }
    12471282            }
     
    12681303
    12691304        /////////////////////////////////////////////////
    1270         // Début des échanges avec les microcontrÃŽleurs
    1271 
    1272         // Analyse des réponses des microcontrÃŽleurs
     1305        // Début des échanges avec les micro-contrÃŽleurs
     1306
     1307        // Analyse des réponses des micro-contrÃŽleurs
    12731308
    12741309        for (int i=1; i<SocketsNumber; i++)
     
    12801315                    string reponse, buffereponse;
    12811316
    1282                     // on récupÚre la réponse du microcontrÃŽleur
     1317                    // on récupÚre la réponse du micro-contrÃŽleur
    12831318
    12841319                    Sockets[i].new_sock >> reponse;
     
    13361371                            if (reponse.find("POSITION") != string::npos)
    13371372                            {
    1338                                 // Il y a une erreur signalée par le microcontroleur
     1373                                // Il y a une erreur signalée par le micro-contrÃŽleur
    13391374
    13401375                                if (reponse.find("NACK") != string::npos)
     
    13641399                                    {
    13651400                                        // La fonction extractPositon confirme que les positions transmises
    1366                                         // par le microcontrÃŽleur sont valides
     1401                                        // par le micro-contrÃŽleur sont valides
    13671402
    13681403                                        OnCoordSetSP.s = IPS_OK;
     
    13931428                                if (reponse.find("NACK") != string::npos)
    13941429                                {
    1395                                     // Une erreur  est retournée par le microcontroleur concernant la commande Park
     1430                                    // Une erreur  est retournée par le micro-contrÃŽleur concernant la commande Park
    13961431                                    // On affiche le voyant Park en rouge dans la boîte indi...
    13971432
     
    14181453                                if (reponse.find("NACK") != string::npos)
    14191454                                {
    1420                                     // Une erreur  est retournée par le microcontroleur concernant la commande Abort
     1455                                    // Une erreur  est retournée par le micro-contrÃŽleur concernant la commande Abort
    14211456                                    // On affiche le voyant Park en rouge dans la boîte indi...
    14221457
     
    14431478                                if (reponse.find("NACK") != string::npos)
    14441479                                {
    1445                                     // Une erreur  est retournée par le microcontroleur concernant la commande Goto
     1480                                    // Une erreur  est retournée par le micro-contrÃŽleur concernant la commande Goto
    14461481                                    // On affiche le voyant Park en rouge dans la boîte indi...
    14471482
     
    14521487                                    IDSetSwitch(&OnCoordSetSP, "ALERTE antenne %s : Erreur GOTO !\n",  Sockets[i].IP.c_str());
    14531488
    1454                                     // On déconnecte l'antenne. Elle ne semble pas en mesure d'executer les ordres goto
     1489                                    // On déconnecte l'antenne. Elle ne semble pas en mesure d'exécuter les ordres goto
    14551490
    14561491                                    DeconnecterSocket(i);
     
    14601495                                    if (reponse.find("OK") != string::npos)
    14611496                                    {
    1462                                         // On a ici la confirmation que l'antenne 'i' a bien réalisé
    1463                                         // le goto
     1497                                        // On a ici la confirmation que l'antenne 'i' a bien réalisé le goto
    14641498
    14651499                                        // On prend note
     
    14881522                                        }
    14891523
    1490                                         // Si le nombre d'antennes connectées est >0
     1524                                        // Si le nombre d'antennes connectées est > 0
    14911525                                        // et que toutes les antennes connectées ont
    14921526                                        // réalisé le goto alors...
     
    14951529                                        {
    14961530                                            // C'est bon ! Tout marche bien...
    1497                                             // On actualise l'AR et la dec dans la boîte de dialogue
     1531                                            // On actualise l'AD et la Dec dans la boîte de dialogue
    14981532
    14991533                                            lastRA  = targetRA;
     
    15591593            Suivi = false;
    15601594
    1561             // On arrête l'enchaînement des actions
    1562             // pour réaliser un goto
     1595            // On arrête l'enchaînement des actions nécessaires à la réalisation d'un goto
    15631596
    15641597            RealisationGoto = false;
     
    16171650            InitAntennes();
    16181651
    1619             //Pour permettre de refaire un park
     1652            // Pour permettre de refaire un park
    16201653
    16211654            Park = false;
     
    16291662        {
    16301663            // Délais entre deux actualisations
    1631 
    1632             double delai = ActualisationTMTransit / 3600.0 / 24.0;   // Actualisation toutes les 15 minutes en mode transit (par défaut)
    1633 
    1634             if (TrackingMode == 2) delai = ActualisationTMTracking / 3600.0 / 24.0;   //et 5 secs en mode tracking (par défaut)
    1635 
    1636 
    1637             // On actualise la position si le delai est dépassé
     1664           
     1665            // Actualisation toutes les 15 minutes en mode transit (par défaut)
     1666
     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;   
     1672
     1673
     1674            // On actualise la position si le délai est dépassé
    16381675
    16391676            if (GetJJ() - JJAnc > delai)
    16401677            {
    1641                 // Cette variable vaudra true lorsque le goto aura été réalisé
     1678                // Cette variable vaut true lorsque le goto a été réalisé
    16421679
    16431680                UpdatedGoto = false;
     
    17061743                    case 0 :
    17071744                    {
    1708                         // On doit intialiser l'acknowledge à false
     1745                        // On doit initialiser l'acknowledge à false
    17091746
    17101747                        Sockets[i].ack_pos    = false;
     
    17651802
    17661803                            // Les erreurs graves s'accumulent. Pas de réponse aprÚs plusieurs minutes
    1767                             // Il faut déconnecter l'antenne
     1804                            // -> Il faut déconnecter l'antenne
    17681805                            if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
    17691806                            {
     
    17721809                                OnCoordSetSP.s = IPS_ALERT;
    17731810
    1774                                 //Message à l'attentnio de l'utilisateur
     1811                                //Message à l'attention de l'utilisateur
     1812                               
    17751813                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : pas d acknowledge recu apres l ordre POSITION. \
    17761814Deconnexion de l antenne.", Sockets[i].IP.c_str());
    17771815
    17781816                                // On déconnecte l'antenne
     1817                               
    17791818                                DeconnecterSocket(i);
    17801819                            }
     
    17921831                            // Tout vas bien
    17931832                            // On ne consigne aucune anomalie
     1833                           
    17941834                            Sockets[i].AttenteExecution = 0;
    17951835                            Sockets[i].AnomaliesExecution = 0;
    17961836
    17971837                            //On passe à l'étape suivante
     1838                           
    17981839                            Sockets[i].etape++;
    17991840                        }
     
    18121853
    18131854                                // On consigne une erreur grave. L'antenne tarde à répondre
     1855                               
    18141856                                Sockets[i].AnomaliesExecution++;
    18151857                            }
     
    18171859                            // Aucune réponse de l'antenne depuis plusieurs minutes
    18181860                            // On la déconnecte
     1861                           
    18191862                            if (Sockets[i].AnomaliesExecution > MAXANOMALIES)
    18201863                            {
     
    18241867
    18251868                                //Message d'erreur
     1869                               
    18261870                                IDSetSwitch(&OnCoordSetSP, "Erreur sur l antenne %s : la position retournee n est pas valide. \
    18271871Deconnexion de l antenne.", Sockets[i].IP.c_str());
    18281872
    18291873                                //Déconnexion de l'antenne
     1874                               
    18301875                                DeconnecterSocket(i);
    18311876                            }
     
    18981943                            if (Sockets[i].AttenteExecution > MAXATTENTE)
    18991944                            {
    1900                                 // On prolonge l'attente afin de recevoit un GOTO OK
     1945                                // On prolonge l'attente afin de recevoir un GOTO OK
    19011946
    19021947                                Sockets[i].etape = 5;
     
    19051950                            }
    19061951
    1907                             // On déconnecte l'antenne s'il n'y a pas de coonfirmation du goto au bout de 2 minutes
     1952                            // On déconnecte l'antenne s'il n'y a pas de confirmation du goto au bout de 2 minutes
    19081953                            if (Sockets[i].AnomaliesExecution > MAXANOMALIESGOTO)
    19091954                            {
     
    19271972
    19281973        ///////////////////////////////////////
    1929         // Traitement de l'étape 3 de la réalisation d'un goto
     1974        // Réalisation d'un goto - traitement de l'étape 3
    19301975        // On place cette partie du traitement en dehors du switch et de la boucle
    1931         // pour pouvoir envoyer les ordres gotos à toutes les antennes lorsque l'on a la confirmation
    1932         // qu'elles sont toutes prêtes à executer cet ordre (être à l'étape 3 pour un socket)
     1976        // pour pouvoir envoyer les gotos à toutes les antennes lorsque l'on a la confirmation
     1977        // qu'elles sont toutes prêtes à exécuter cet ordre (être à l'étape 3 pour un socket)
    19331978        // -> meilleure synchronisation
    19341979
     
    20042049/**************************************************************************************
    20052050** Mode transit ou tracking
     2051**
    20062052***************************************************************************************/
    20072053
     
    20112057    {
    20122058        // Transit
     2059       
    20132060    case BAO_TRANSIT:
    20142061
    2015         //Eteindre les voyants dans la boîte de dialogue Indi
     2062        // Ã‰teindre les voyants dans la boîte de dialogue Indi
    20162063        EquatorialCoordsWNP.s = IPS_BUSY;
    20172064        AbortSlewSP.s = IPS_IDLE;
     
    20262073        InitAntennes();
    20272074
    2028         // On garde la trace du début du Goto pour enchainer les actualisations
     2075        // On garde la trace du début du Goto pour enchaîner les actualisations
    20292076
    20302077        JJAnc = GetJJ();
     
    20362083        // Mode transit activé
    20372084
    2038         TrackingMode = 1;
     2085        TrackingMode = BAO_TRANSIT;
    20392086
    20402087        // On suit un objet
     
    20532100
    20542101        // Tracking
     2102       
    20552103    case BAO_TRACKING:
    20562104
    2057         //Eteindre les voyants dans la boîte de dialogue Indi
     2105        // Éteindre les voyants dans la boîte de dialogue Indi
     2106       
    20582107        EquatorialCoordsWNP.s = IPS_BUSY;
    20592108        AbortSlewSP.s = IPS_IDLE;
     
    20702119        ADDEC2Motor(targetRA, targetDEC);
    20712120
    2072         TrackingMode = 2;
     2121        TrackingMode = BAO_TRACKING;
    20732122
    20742123        Suivi = true;
     
    20882137/**************************************************************************************
    20892138** Connexion / Déconnexion avec le télescope
     2139**
    20902140***************************************************************************************/
    20912141
     
    22702320
    22712321    // problÚme 1 : si deltaAz > à un demi-tours - soit 2000 pas codeur alors
    2272     // on fait le trajet dans le sens inverse pour aller plus vite
     2322    // on fait le trajet en sens inverse pour aller plus vite
    22732323
    22742324    // problÚme 2 : Passage au méridien
     
    22782328
    22792329    // ne pas faire des tours complets en Az pour rien...
     2330   
    22802331    while (deltaAz > NBREPASCODEURSAZ) deltaAz -= NBREPASCODEURSAZ;
    22812332
    22822333    // Doit résoudre tous les problÚmes concernant l'azimut...
     2334   
    22832335    if (deltaAz > NBREPASCODEURSAZ / 2 )
    22842336    {
     
    23132365{
    23142366    //Il ne faut exécuter la fonction qu'une seule fois
     2367   
    23152368    static int isInit = 0;
    23162369
  • BAORadio/libindi/libindi/drivers/telescope/BAO.h

    r642 r648  
    5757
    5858    int sendalertes;                        // une requête 'send' a généré une erreur sur le réseau
    59     int AttenteExecution;                   // L'antenne parvient-elle à executer un cycle de commandes ?
     59    int AttenteExecution;                   // L'antenne parvient-elle à exécuter un cycle de commandes ?
    6060    int AnomaliesExecution;                 // Erreur critique. L'antenne ne répond plus !
    61     int etape;                              // étape dans le cycle de commandes/réponses entre PC et microcontroleurs
     61    int etape;                              // étape dans le cycle de commandes/réponses entre PC et micro-contrÃŽleurs
    6262
    6363    bool Connected;                         // le micro-contrÃŽleur est-il connecté ?
    6464    bool PosValides;                        // le micro-contrÃŽleur a-t-il donné une position des moteurs valide ?
    6565    bool ack_status;                        // Etat des acknowledges ?
    66     bool ack_pos;                           // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre POSITION ?
    67     bool ack_park;                          // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre PARK ?
    68     bool ack_abort;                         // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre ABORT ?
    69     bool ack_goto;                          // le PC a-t-il reçu une confirmation du microcontroleurs aprÚs un ordre GOTO ?
     66    bool ack_pos;                           // le PC a-t-il reçu une confirmation du micro-contrÃŽleurs aprÚs un ordre POSITION ?
     67    bool ack_park;                          // le PC a-t-il reçu une confirmation du micro-contrÃŽleurs aprÚs un ordre PARK ?
     68    bool ack_abort;                         // le PC a-t-il reçu une confirmation du micro-contrÃŽleurs aprÚs un ordre ABORT ?
     69    bool ack_goto;                          // le PC a-t-il reçu une confirmation du micro-contrÃŽleurs aprÚs un ordre GOTO ?
    7070    bool GotoOk;                            // Est-ce que le dernier goto est OK ?
    7171
    7272    Position TargetPosition;                // Position à atteindre
    73     Position Pos;                           // derniÚre position retournée par le microcontrÃŽleur
     73    Position Pos;                           // derniÚre position retournée par le micro-contrÃŽleur
    7474   
    7575    Alignement *AlignementAntenne;          // Contient les paramÚtres d'alignement de l'antenne 
     
    7979// Le PC et les antennes communiquent par le biais du port 8000 sur le réseau Ethernet
    8080
    81 ServerSocket server( 8000 );         
     81ServerSocket server( BAO_PORT );         
    8282
    8383class BAO : public Astro
     
    206206    double lastDEC;                      // ...et la déclinaison
    207207    double JJAnc;                        // Sauvegarde du jour julien lors de la derniÚre actualisation de la position (fct Goto)
    208     double ActualisationTMTransit;       // Délai entre deux actualisations dans les modes transit
    209     double ActualisationTMTracking;      //  "                 "                     "     tracking
     208    double ActualisationTMTransit;       // Délai entre deux actualisations dans les modes transit (en sec)
     209    double ActualisationTMTracking;      //  "                 "                     "     tracking (en sec)
    210210    double Longitude;                    // Longitude et latitude du lieu d'observation
    211211    double Latitude;
     
    221221
    222222    int    currentSet;                   // mode de suivi actuel - tracking ou transit
    223     int    lastSet;                      // Variable interne de l'interface indi - ne pas toucher
    224     int    TrackingMode;                 // 1 : Transit           2: Tracking
     223    int    MethodeAlignement;            // Méthode d'alignement
     224    BAO_STATUS  TrackingMode;            // Mode de suivi actuellement activé
    225225};
    226226
Note: See TracChangeset for help on using the changeset viewer.