Changeset 342 in Sophya for trunk/Poubelle/archTOI.old/archeops.h


Ignore:
Timestamp:
Aug 2, 1999, 3:45:52 PM (26 years ago)
Author:
ansari
Message:

archtoi 2 aout 99

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/Poubelle/archTOI.old/archeops.h

    r319 r342  
    1 
    2 /*======================================================================*/
    3 /*                                                                      */
    4 /*               archeops.h  :  structure de données                    */
    5 /*                                                                      */
    6 /*======================================================================*/
    7 
    8 #define         _archeops
    9 #define         version_num             24
    10 
    11 
    12 /*======================================================================*/
    13 /*                                                                      */
    14 /*                      historique des modifications                    */
    15 /*                                                                      */
    16 /*                                                                      */
    17 /*  VERSION 24:                                                         */
    18 /*                                                                      */
    19 /*      - utilise le fichier archeops.c                                 */
    20 /*      - nb_max_bolo=24  avec nb_bolo_util=18                          */
    21 /*      - change la structure du block dilution                         */
    22 /*                                                                      */
    23 /*                                                                      */
    24 /*                                                                      */
    25 /*                                                                      */
    26 /*======================================================================*/
    27 
    28 
    29 /*======================================================================*/
    30 /*  ---------------  parametres generaux de definition   -------------  */
    31 /*======================================================================*/
    32 
    33 #ifndef int4
    34 #ifdef __alpha
    35 #define int4 int
    36 #undef programme
    37 #else
    38 #define int4 long
    39 #endif
    40 #endif
    41 
    42 #ifdef linux
    43 #undef programme
    44 #endif
    45 
    46 #ifdef  _planck
    47 #define _archeops
    48 #define _trapani
    49 #define _sans_transputer
    50 #endif
    51 
    52 #ifdef  _archeops
    53 /*#define _test_diabolo  relecture des blocks fabriques avec diabolo    */
    54 #define _trapani                /*  configuration  prevue pour Trapani  */
    55 /*#define _kiruna                 block standard prevu pour kiruna      */
    56 #endif
    57 
    58 
    59 
    60 /*======================================================================*/
    61 /*  --------------      valeurs des parametres dans     -------------   */
    62 /*  --------------      les différentes configurations  -------------   */
    63 /*======================================================================*/
    64 /*                                                                      */
    65 /*  configuration pour Trapani : 3 bebos  /  12 bolos                   */
    66 /*                                                                      */
    67 /*  bebo1 :   voies  1  à  6    -->  bolo  1 a  6                       */
    68 /*  bebo2 :   voies  9  à  14   -->  bolo  7 à 12                       */
    69 /*                                                                      */
    70 /*  bebo6 :                                                             */
    71 /*      voies  41 42 43 44      =  carte simplifiee avec AMP01          */
    72 /*      voies  45 et 46         = chauffage pour regulation             */   
    73 /*      on ecrira plus tard le stockage des donnees simplifiees         */
    74 /*                                                                      */
    75 /*                                                                      */
    76 /*======================================================================*/
    77 
    78 /*      nb_per_block    doit etre divisible par 2                                               */
    79 /*      nb_max_bolo     doit etre divisible par 2 pour archeops   (impair pour diabolo ?? )     */
    80 /*      nb_bolo_util    doit etre divisible par 2 pour archeops   (impair pour diabolo ?? )     */
    81 
    82 
    83 #ifdef  _trapani
    84 #define nb_max_bolo             24      /*  nombre maxi de bolos                                */
    85 #define nb_bolo_util            18      /*  nombre de bolos réellement transmis                 */
    86 #define nb_per_block            36      /*  nombre de periodes entieres dans un block           */
    87 #define nb_max_mes_per          88      /*  nb de points maxi dans une periode complete         */
    88 #define nb_photo_diodes         46      /*  nb de canaux de mesure du senseur stellaire         */
    89 #endif
    90 
    91 #ifdef  _kiruna
    92 #define nb_max_bolo             36      /*  nombre maxi de bolos                                */
    93 #define nb_bolo_util            32      /*  nombre de bolos réellement transmis                 */
    94 #define nb_per_block            36      /*  nombre de periodes entieres dans un block           */
    95 #define nb_max_mes_per          88      /*  nb de points maxi dans une periode complete         */
    96 #define nb_photo_diodes         46      /*  nb de canaux de mesure du senseur stellaire         */
    97 #endif
    98 
    99 
    100 #ifdef  _diabolo
    101 #define nb_max_bolo             9       /*  nombre maxi de bolos                                */
    102 #define nb_bolo_util            9       /*  nombre de bolos réellement transmis                 */
    103 #define nb_per_block            20      /*  nombre de periodes entieres dans un block           */
    104 #define nb_max_mes_per          128     /*  nb de points maxi dans une periode complete         */
    105 #define nb_photo_diodes         0       /*  nb de canaux de mesure du senseur stellaire         */
    106 #endif
    107 
    108 #ifdef  _test_diabolo
    109 #define nb_max_bolo             9       /*  nombre maxi de bolos                                */
    110 #define nb_bolo_util            9       /*  nombre de bolos réellement transmis                 */
    111 #define nb_per_block            20      /*  nombre de periodes entieres dans un block           */
    112 #define nb_max_mes_per          128     /*  nb de points maxi dans une periode complete         */
    113 #define nb_photo_diodes         0       /*  nb de canaux de mesure du senseur stellaire         */
    114 #endif
    115 
    116 
    117 #ifdef  _sans_transputer
    118 #define nb_byte_mot             5       /*  nombre d'octets dans un mot d'acquisition planck    */
    119 #else
    120 #define nb_byte_mot             8       /*  nombre d'octets dans un mot d'acquisition archeops  */
    121 #endif
    122 
    123 #define nb_sync                 6       /*  nombre de signaux de synchro                        */
    124 #define nb_element_catalog      256     /* nombre d'éléments catalog par reponse enregistreur   */
    125 
    126 
    127 #ifdef  transmet_data_brute
    128 #define         taille_maxi_block_archeops      sizeof(block_type_data_brute)
    129 #else                                   /*      le plus gros des différents blocks de télémesure*/
    130 #define         taille_maxi_block_archeops      sizeof(block_type_bolo)
    131 #endif
    132 
    133 #define         nombre_de_regul         4
    134 #define         nombre_de_voies         6
    135 #define         nb_type_blocks          20      /*  nombre de type de blocks (multiple de 4)    */
    136 
    137 
    138 /*======================================================================*/
    139 /*  -------     codes  de  controle  pour  la  transmission    -----    */
    140 /*=======================   télécommande      ==========================*/
    141 /*======================================================================*/
    142 
    143 
    144 /*   --------------   codes de reconnaissance des paquets de télécommande       --------------   */   
    145 
    146 #define         debut_telecommande              0x23456789
    147 #define         fin_telecommande                0x98765432
    148 
    149 /*   ------------ codes de direction des commandes envoyées a l'EPLD Archeops   --------------   */   
    150 
    151 #define         tc_dir_transputer               1
    152 #define         tc_dir_reset_epld               3
    153 
    154 /*  -------------  codes  des  prefix des  telecommandes traités le transputer  --------------   */
    155 
    156 #define         tc_horloge                      255     /* (-1) */
    157 #define         tc_cadence1                     128
    158 #define         tc_cadence2                     129
    159 #define         tc_cadence3                     130
    160 #define         tc_regul                        251     /* (-5) */
    161 #define         tc_switch_dil                   250
    162 #define         tc_dac_dil                      249
    163 
    164 /*======================================================================*/
    165 /*      telecommande reduite  sur 18 bit                                */
    166 /*======================================================================*/
    167 
    168 /*______________________________________________________________________________________________*/
    169 /*      1er mot :       code de debut de telecommande reduite                                   */
    170 #define         tc_reduite                      248     
    171 /*______________________________________________________________________________________________*/
    172 /*      2eme mot:       4bit:   16 codes  de direction  tc2                                     */
    173 enum{tc2_reset_epld,tc2_bolo_dacV,tc2_bolo_dacI,tc2_bolo_dacT
    174         ,tc2_bolo_dacL,tc2_bolo_gain,tc2_bolo_voie,tc2_horloge
    175         ,tc2_regul,tc2_auto_bolo,tc2_auto_dilu,tc2_dilution};                   /* 11 codes: reste 5 disponibles*/
    176 
    177 
    178 /*______________________________________________________________________________________________*/
    179 /*      3eme mot:       6bit:                                                                   */
    180 
    181 /*      code2=dac-gain-voie     :       numero de bolo                                          */
    182 
    183 /*      code2=tc2_horloge       :                                                               */
    184 /*              soit un code defini                                                             */
    185 /*              soit le code tc3_vitesse+i avec i=0.. nb_type_block                             */
    186 enum{tc3_periode,tc3_nb_mesures,tc3_temp_mort,tc3_flag,tc3_vitesse};
    187 #define tc3_suite       tc3_vitesse+nb_type_block
    188 
    189 
    190 /*      code2=tc2_regul :                                                                       */
    191 
    192 
    193 /*      code2=tc2_auto_bolo     :                                               */
    194 
    195 
    196 /*      code2=tc2_auto_dilu     :                                               */
    197 /*      les valeurs des parametres d'auto_dilu ne depassent pas 128             */
    198 
    199 
    200 /*      code2=tc2_dilution      :                                               */
    201 
    202 
    203 /*______________________________________________________________________________*/
    204 /*      4eme mot:       8bit:   valeur a ecrire                 */             
    205 
    206 
    207 /*======================================================================*/
    208 /*  -------     codes  de  controle  pour  la  transmission    -----    */
    209 /*=========================   télémesure    ============================*/
    210 /*======================================================================*/
    211 
    212 /*   -------   codes de reconnaissance des paquets de télémesure        */   
    213 
    214 #define         debut_block_mesure              ((int4)0x45627491)
    215 #define         fin_block_mesure                ((int4)0x83260432)
    216 
    217 
    218 
    219 
    220 
    221 /*======================================================================*/
    222 /*  ------------------------------------------------------------------  */
    223 /*  ---------   Les  formats  des  blocks  type   ARCHEOPS      ------- */
    224 /*  ------------------------------------------------------------------  */
    225 /*======================================================================*/
    226 
    227 
    228 
    229 /*==============================================================================================*/
    230 
    231 /*      Le tableau est lut dans le desordre par le mac en lecture de la carte pci :             */
    232 
    233 /*      Les entiers long sont ecrits tels quels                                                 */
    234 /*      Les short sont ecrits permuté 2 a 2 par le tansputer                                    */
    235 /*      Les tables char sont ecrits permuté 4 / 4 par le transputer                             */
    236 /*      A la lecture dans le mac, tout est bon                                                  */
    237 
    238 
    239 /*  ---------    structures N° 0 :   parametres de mesure des bolometres        -------------   */
    240 /*  -----------------------------------------------------------------------------------------   */
    241 
    242 typedef struct 
    243         {
    244         char            bolo_nom[32];           /*  le nom de chaque bolometre                  */
    245         int4            bolo_code_util;         /*  le code d'utilisation du bolo               */
    246         int4            bolo_bebo;              /*  le type d'acquisition:  0 pour MLPA 10 pour BEBODIFF */
    247         int4            bolo_num;               /*  l'adresse hard du bolo                      */
    248         int4            bolo_gain;              /*  le gain du preampli                         */
    249         int4            bolo_capa;              /*  la valeur capa du modulateur                */
    250         int4            bolo_diviseur;          /*  le diviseur de la compensation              */
    251         int4            coef[7];                /*  les coef pour le calcul de la température   */
    252         }
    253         param_un_bolo;
    254 /* code_util des bolos  */
    255 enum{bolo_hors_service,bolo_normal_transmis,bolo_normal_non_transmis,bolo_thermo_simplifie};
    256 
    257        
    258 typedef struct          /*              table des parametres de mesure bolometre                */
    259                         /*      cette table ne change pas (en principe) en cours de mesure      */
    260         {
    261         int4            numero_version;                 /*  numero de version du header archeops.h      */
    262         int4            n_max_bolo;                     /*  nombre maxi de bolos  (divisible par 4)     */
    263         int4            n_per_block;                    /*  nombre de periodes entieres dans un block   */
    264         int4            n_max_mes_per;                  /*  nb de points maxi dans une periode complete */
    265 
    266         int4            nb_bolo;                        /*  nombre de bolometres effectivement lut      */
    267         param_un_bolo   bolo[nb_max_bolo];
    268         }
    269         param_bolo;
    270        
    271        
    272        
    273        
    274 /*     
    275         long            bolo_code_util[nb_max_bolo];   
    276         char            bolo_nom[nb_max_bolo][32];     
    277 
    278         long            bolo_bebo[nb_max_bolo];         
    279         long            bolo_num[nb_max_bolo];         
    280         long            bolo_gain[nb_max_bolo];         
    281 
    282         long            bolo_capa[nb_max_bolo];         
    283         long            bolo_diviseur[nb_max_bolo];     
    284        
    285         long            coef[nb_max_bolo][7];           
    286 
    287         long            presence_bebo;                 
    288         }
    289         param_bolo;
    290 */
    291 
    292 typedef struct                          /*      La structure de transfert transputer vers mac   */ 
    293         {
    294         int4            debut;          /*      code de reconnaissance de debut de block        */
    295         int4            code1;          /*      code1 du block                                  */
    296         int4            code2;          /*      code2 du block                                  */
    297 
    298         param_bolo      param;          /*      les parametres de mesure des bolometres         */
    299 
    300         int4            fin;            /*      code de reconnaissance de fin de block          */
    301         }
    302         block_type_param;                       
    303        
    304 
    305 
    306 
    307 /*  -------------------   structures N° 1 :   journal de bord        ---------------------      */
    308 /*  -----------------------------------------------------------------------------------------   */
    309 #define long_page       10
    310 typedef struct                           
    311         {
    312         int4            code2;          /*      code de la ligne du journal                     */
    313                                         /*      code idem code2 debut de block :                */
    314                                         /*      contient un code de commande                    */
    315                                         /*      et le numero du block lors de la télécommande   */
    316         char            mot[8];         /*      contenu de la ligne du  journal                 */
    317         }
    318         ligne_journal;                 
    319 
    320 
    321 typedef struct                           
    322         {
    323         int4            debut;          /*      code de reconnaissance de debut de block        */
    324         int4            code1;          /*      code1 du block                                  */
    325         int4            code2;          /*      code2 du block                                  */
    326 
    327         ligne_journal   jj[long_page];  /*      block de 10 lignes de journal                   */
    328 
    329         int4            fin;            /*      code de reconnaissance de fin de block          */
    330         }
    331         block_type_journal;                     
    332        
    333 
    334 /*  ---------   structures N° 2 :  reglage_bolo , regul etc..   --------        */
    335 /*  ------------------------------------------------------------------------------------------  */
    336 #define bol_micro_volt(val,gain)        ((1e7*(double)val)/(65536.*gain))
    337 /*  avec  gain = param.bolo_gain[bolo]*gain_ampli(reglage.bolo[bolo])                           */
    338                
    339 
    340 /* gains 0 .. 15 pour MLPA  ///   gain 16..19  pour BEBO   ///   gain 20..22  pour BEDIF        */             
    341 #define def_gains       double gains_reels[32]={1,2,4,8,10,20,40,80,100,200,400,800,1000,2000,4000,8000,0.5,2.5,10,50,0.93,3.777,18.974};
    342                 /*                      gain bediff    10->9.3    40->37.77     200->189.74             */
    343 
    344 
    345 /*  les definitions suivantes s'appliquent a une variable de type    reglage.bolo[bol]          */
    346 #define         gainbrut(aa)    ((char)(((aa).mot1&0x1f)))             
    347 #define         gain_ampli(aa)  gains_reels[gainbrut(aa)]               
    348 #define         phase(aa)       ((char)(((aa).mot1&0x60)>>5))           
    349 #define         comm(aa)        ((char)(((aa).mot1&0x80)>>7))           
    350 #define         dac_V(aa)       ((int)(((aa).mot1&0xfff00)>>8)  )       
    351 #define         dac_I(aa)       ((int)(((aa).mot1&0xfff00000)>>20))             
    352 
    353 #define         voie(aa)        ((char)(((aa).mot2&0xff)))             
    354 #define         dac_T(aa)       ((int)(((aa).mot2&0xfff00)>>8))         
    355 #define         dac_L(aa)       ((int)(((aa).mot2&0xfff00000)>>20))             
    356 
    357 /*
    358 #define         bolo_mot1(dacV,dacI,gainbrut,phase,comm)        ((gainbrut)&0x1f) | (((phase)&3)<<5) | (((comm)&1)<<7) | (((dacV)&0xfff)<<8) | (((dacI)&0xfff)<<20)
    359 #define         bolo_mot2(dacT,dacL,voie)                       ((voie)&0xff)     | (((dacT)&0xfff)<<8) | (((dacL)&0xfff)<<20)
    360 */
    361 
    362 #define         bolo_mot1(dacV,dacI,gainbrut,phase,comm)        (((long)(gainbrut))&0x1f) | ((((long)(phase))&3)<<5) | ((((long)(comm))&1)<<7) | ((((long)(dacV))&0xfff)<<8) | ((((long)(dacI))&0xfff)<<20)
    363 #define         bolo_mot2(dacT,dacL,voie)                       (((long)(voie))&0xff)     | ((((long)(dacT))&0xfff)<<8) | ((((long)(dacL))&0xfff)<<20)
    364 
    365 
    366 typedef struct 
    367         {
    368         int4    mot1;           /*  dac1 = mot[11..0]; dac2=mot1[23..12]        */
    369                                 /*  gain = mot1[27..24]; phase = mot1[31..28];  */
    370         int4    mot2;           /*  dac3 = mot[11..0]; dac4=mot1[23..12]        */
    371                                 /*  voie pour reglages auto  = mot2[31..24];    */
    372         }
    373         reglage_un_bolo;
    374 
    375 
    376 
    377 #ifdef programme        /***********   structure normale pour le mac   ****************/
    378 
    379 typedef struct 
    380         {
    381         char    periode;
    382         char    nb_mesures;
    383         char    temp_mort;
    384         char    flag;
    385         }
    386         horloge;
    387 
    388 typedef struct
    389         {
    390         char    mode;                   /*   on_off et deglitch                         */
    391         char    num_bolo;               /*   numero du bolo utilisé,    */
    392         char    voie_chauf;             /*   la voie de sortie chauffage                */
    393         char    prop;                   /*   zero dans prop -> chauffage=0;             */
    394         char    integ;
    395         char    deriv;
    396         short   chauffage;              /*      valeur effective du chauffage           */     
    397         }
    398         regul_bolo;                     /*  longueur 2 entiers long                     */
    399 
    400 typedef struct
    401         {
    402         char    mode;
    403         char    gain;
    404         char    courant;
    405         char    delai;
    406         }
    407         auto_bolo;                      /*  longueur 1 entiers long                     */
    408 
    409 typedef struct
    410         {
    411         char    vanne;
    412         char    helium;
    413         char    chauffage;
    414         char    piles;
    415         char    transmission;
    416         char    temps_max_vanne;
    417         char    xx7;
    418         char    xx8;
    419         }
    420         auto_dilu;                      /*  longueur 1 entiers long             */
    421 
    422 
    423 
    424 #else           /***********  structure swappée pour le transputer   ****************/
    425 
    426 typedef struct 
    427         {
    428         char    flag;
    429         char    temp_mort;
    430         char    nb_mesures;
    431         char    periode;
    432         }
    433         horloge;
    434        
    435 
    436 typedef struct
    437         {
    438         char    prop;                   /*   zero dans prop -> chauffage=0;             */
    439         char    voie_chauf;             /*   la voie de sortie chauffage                */
    440         char    num_bolo;               /*   numero du bolo utilisé,    */
    441         char    mode;                   /*   on_off et deglitch                         */
    442         short   chauffage;              /*      valeur effective du chauffage           */     
    443         char    deriv;
    444         char    integ;
    445         }
    446         regul_bolo;                     /*  longueur 2 entiers long             */
    447 
    448 
    449 typedef struct
    450         {
    451         char    delai;
    452         char    courant;
    453         char    gain;
    454         char    mode;
    455         }
    456         auto_bolo;                      /*  longueur 1 entiers long             */
    457 
    458 typedef struct
    459         {
    460         char    piles;
    461         char    chauffage;
    462         char    helium;                 /* periode de mesure            */
    463         char    vanne;         
    464         char    xx8;
    465         char    xx7;
    466         char    temps_max_vanne;
    467         char    transmission;
    468         }
    469         auto_dilu;                      /*  longueur 1 entiers long             */
    470 
    471 
    472 #endif          /***********   fin des structures swappées       ****************/
    473 
    474 enum{regul_stop,regul_chauffage_null,regul_sans_deglitch,regul_avec_deglitch};
    475 
    476 #define bit_piles_5V    1
    477 #define bit_piles_15V   2
    478 #define bit_piles_auto  4
    479 
    480 enum{vanne_rien,vanne_ferme,vanne_ouvre,vanne_auto_pression,vanne_auto_pression_piles,vanne_auto_pression_piles_temps};
    481 enum{trans_rien,trans_normal,trans_rapide,trans_lent};
    482 
    483 
    484 typedef struct                                                  /*  long en mot de 32 bit       */
    485         {
    486         horloge                 horloge;                        /*                      1       */
    487         char                    vitesse[nb_type_blocks];        /*                      5       */
    488         reglage_un_bolo         bolo[nb_max_bolo];              /*      18 * 2  =       36      */
    489         auto_bolo               autom[nombre_de_voies];         /*      6  * 1          6       */                                                             
    490         regul_bolo              regul[nombre_de_regul];         /*      4  * 2  =       8       */                                                                     
    491         auto_dilu               dilu;                           /*                      2       */
    492         }
    493         reglage_bolo;                                           /*      total 58                */
    494 
    495 
    496 typedef struct                           
    497         {
    498         int4            debut;          /*      code de reconnaissance de debut de block        */
    499         int4            code1;          /*      code1 du block                                  */
    500         int4            code2;          /*      code2 du block                                  */
    501         reglage_bolo    reglage;                                                                                       
    502         int4            fin;            /*      code de reconnaissance de fin de block          */
    503         }
    504         block_type_reglage;                     
    505        
    506 /*  ---------------------   structures N° 3 :    etat de la dilution    ----------------------- */
    507 /*  ------------------------------------------------------------------------------------------- */
    508 typedef struct                           
    509         {
    510         int4            debut;          /*      code de reconnaissance de debut de block        */
    511         int4            code1;          /*      code1 du block                                  */
    512         int4            code2;          /*      code2 du block                                  */
    513 /*      int4            data_dil[50];    data brutes de la dilution                             */
    514         int4            switch_dil;
    515         int4            ADC_dil[48];    /*      la lecture des 48 ADC de la carte DIL           */
    516         int4            DAC_dil[4];     /*      les 4 dac de la carte dilution                  */
    517         int4            DAC_sst[4];     /*      les 4 dac de la carte sst                       */
    518         int4            gyro_dil[3][nb_per_block*2];    /* les gyros a supprimer                */
    519         int4            fin;            /*      code de reconnaissance de fin de block          */
    520         }
    521         block_type_dilution;                   
    522 
    523 
    524 /*      signification des bit lus dans switch_dil       */
    525 #define switch_EVF              0x00000080      /*      contact fin de course vanne fermee      */
    526 #define switch_EVO              0x00000040      /*      contact fin de course vanne ouverte     */
    527 
    528 /* les bit suivants sont envoyés par telecommande et relus dans switch_dil      */
    529 #define switch_helium           0x00200000      /*  13: commande sond niveau helium     */
    530 #define switch_pile_par_5       0x00100000      /*  12: mise en parallele des piles pour le 5V  */
    531 #define switch_pile_par_15      0x00080000      /*  11: mise en parallele des piles pour le 15V */
    532 #define vanne_EVB               0x00008000      /*  7: commande vanne brooks    */
    533 #define vanne_EVO               0x00010000      /*  8: commande vanne EVO       */
    534 #define vanne_EVV               0x00020000      /*  9: commande vanne EVV       */
    535 #define vanne_EVF               0x00040000      /*  10: commande vanne EVF      */
    536 #define chauffage1              0x00004000      /*  6: chauffage 1      */
    537 #define chauffage2              0x00002000      /*  6: chauffage 1      */
    538 #define chauffage3              0x00001000      /*  6: chauffage 1      */
    539 #define chauffage4              0x00000800      /*  6: chauffage 1      */
    540 #define chauffage5              0x00000400      /*  6: chauffage 1      */
    541 #define chauffage6              0x00000200      /*  6: chauffage 1      */
    542 #define chauffage7              0x00000100      /*  0: chauffage 7      */
    543 
    544 /*  position des mesures sur les multiplexeurs          */
    545 
    546 enum{
    547 /* multiplex11..18:*/   mul11_  ,mul12_ ,p_haut ,p_memb ,t_h1   ,t_h4   ,t_h3   ,t_h2   
    548 /* multiplex21..28:*/,  mul21_  ,mul22  ,p_charb,p_R4   ,mul25_ ,p_C3   ,p_R3   ,mul28 
    549 /* multiplex31..38:*/,  mul31_  ,p_C4   ,p_air  ,t_a3   ,t_b4   ,t_b1   ,t_b2   ,t_a2   
    550 /* multiplex41..48:*/,  t_b3    ,d_4He  ,RP_He  ,mul44  ,d_3He  ,j_he3  ,j_he7  ,j_he4 
    551 /* multiplex51..58:*/,  j_he5   ,j_he1  ,j_he8  ,j_he2  ,j_he6  ,pirani ,mul57  ,mul58 
    552 /* multiplex61..68:*/,  p_m18B  ,p_10B  ,p_m18D ,mul64  ,p_p18B ,p_10T  ,p_Ch   ,p_p18D         
    553         };
    554 enum{t_a1,t_a4};        /* en attendant de trouver leurs places */
    555 /* reste libres :  mul  11 - 12 - 21 - 22 - 25 - 28 - 31 - 44 - 57 - 58 - 64    */
    556 
    557 
    558 
    559 /*  ---------------------   structures N° 4 :     gps           ------------------------------- */
    560 /*  ------------------------------------------------------------------------------------------- */
    561 
    562 typedef struct                           
    563         {
    564         int4            debut;          /*      code de reconnaissance de debut de block        */
    565         int4            code1;          /*      code1 du block                                  */
    566         int4            code2;          /*      code2 du block                                  */
    567 
    568         char            gps[80];        /*      les données GPS (une chaine maxi 80 cara)       */
    569 
    570         int4            fin;            /*      code de reconnaissance de fin de block          */
    571         }
    572         block_type_gps;                 
    573        
    574 
    575 
    576 /*  ---------------------   structures N° 5 :   tous les bolos 1 periode        --------------- */
    577 /*  ------------------------------------------------------------------------------------------- */
    578 typedef struct                           
    579         {
    580         int4            debut;          /*      code de reconnaissance de debut de block        */
    581         int4            code1;          /*      code1 du block                                  */
    582         int4            code2;          /*      code2 du block                                  */
    583        
    584         short           bol_per[nb_max_bolo][nb_max_mes_per];           
    585 
    586         int4            fin;            /*      code de reconnaissance de fin de block          */
    587         }
    588         block_type_une_periode;                 
    589 
    590 /*  ----------------   structures N° 6 :  signals de synchro (pour test au sol) --------------- */
    591 /*  ------------------------------------------------------------------------------------------- */
    592 typedef struct                           
    593         {
    594         int4            debut;          /*      code de reconnaissance de debut de block        */
    595         int4            code1;          /*      code1 du block                                  */
    596         int4            code2;          /*      code2 du block                                  */
    597         char            synchro[nb_sync][nb_per_block*2];       
    598 
    599         int4            fin;            /*      code de reconnaissance de fin de block          */
    600         }
    601         block_type_synchro_sol;                 
    602 
    603 /*  ---------------------   structures N° 7 : block de données de pointage sol      ----------- */
    604 /*  ------------------------------------------------------------------------------------------- */
    605 typedef struct   
    606         {
    607         int4            debut;          /*      code de reconnaissance de debut de block        */
    608         int4            code1;          /*      code1 du block                                  */
    609         int4            code2;          /*      code2 du block                                  */
    610         char            comment[1024];
    611         int4            fin;            /*      code de reconnaissance de fin de block          */
    612         }
    613         block_type_pointage_sol;                       
    614 
    615 
    616 
    617 /*  -------------   structures N° 8 :   données brutes des bolometres    ---------------------- */
    618 /*  ------------------------------------------------------------------------------------------- */
    619 typedef struct                           
    620         {
    621         int4            debut;          /*      code de reconnaissance de debut de block        */
    622         int4            code1;          /*      code1 du block                                  */
    623         int4            code2;          /*      code2 du block                                  */
    624                                         /*      pour chaque bolo, un vecteur 72 points          */
    625         int4            data_bolo[nb_max_bolo][nb_per_block*2];
    626                                         /*      data D.S.       (en mots de 32 bits)            */
    627         int4            fin;            /*      code de reconnaissance de fin de block          */
    628         }
    629         block_type_bolo;                       
    630 
    631 /*  ---------------------   structures N° 9 :   données des gyroscopes et du magnétometre       */
    632 /*  -----------------------------------------------------------------------------------------   */
    633 typedef struct                           
    634         {
    635         int4            debut;          /*      code de reconnaissance de debut de block        */
    636         int4            code1;          /*      code1 du block                                  */
    637         int4            code2;          /*      code2 du block                                  */
    638                                         /* chaque gyro: un vecteur tde 72 valeurs               */
    639         int4            gyros[3][nb_per_block*2];
    640         int4            magneto[3];     /*      1 bit par echantillonage soit 3*32bit>72        */
    641         int4            fin;            /*      code de reconnaissance de fin de block          */
    642         }
    643         block_type_gyro;                       
    644 
    645 /*  ---------------------   structures N° 10 :   données senseur stellaire        -----------   */
    646 /*  -----------------------------------------------------------------------------------------   */
    647 typedef struct                           
    648         {
    649         int4            debut;          /*      code de reconnaissance de debut de block        */
    650         int4            code1;          /*      code1 du block                                  */
    651         int4            code2;          /*      code2 du block                                  */
    652         int4            sst[nb_per_block*2][18];
    653                                         /* chaque mesure: un paquet de 18 mots de 32 bits       */
    654         int4            fin;            /*      code de reconnaissance de fin de block          */
    655         }
    656         block_type_sst;                 
    657 
    658 /*  ---------------------   structures N° 11 :    rien                    -----------           */
    659 /*  -----------------------------------------------------------------------------------------   */
    660 typedef struct                           
    661         {
    662         int4            debut;          /*      code de reconnaissance de debut de block        */
    663         int4            code1;          /*      code1 du block                                  */
    664         int4            code2;          /*      code2 du block                                  */
    665         int4            fin;            /*      code de reconnaissance de fin de block          */
    666         }
    667         block_type11;                   
    668 
    669 /*  ---------------------   structures N° 12 :  data bolo apres compression sur 7 bit    ------ */
    670 /*  ------------------------------------------------------------------------------------------- */
    671 typedef struct                           
    672         {
    673         int4            debut;          /*      code de reconnaissance de debut de block        */
    674         int4            code1;          /*      code1 du block                                  */
    675         int4            code2;          /*      code2 du block                                  */
    676                                         /*      nombre de mots = nb valeurs/4 +1                */
    677                                         /*      pour chaque bolo, un vecteur  19 mots           */
    678         int4            data_bolo[nb_bolo_util][ (nb_per_block/2) +1 ];
    679 
    680         int4            fin;            /*      code de reconnaissance de fin de block          */
    681         }
    682         block_type_bolo_comprime;                       
    683 
    684 /*  ---------------------   structures N° 13 :    block_type_gyro_comprime      -----------     */
    685 /*  -----------------------------------------------------------------------------------------   */
    686 typedef struct                           
    687         {
    688         int4            debut;          /*      code de reconnaissance de debut de block        */
    689         int4            code1;          /*      code1 du block                                  */
    690         int4            code2;          /*      code2 du block                                  */
    691                                         /*      nombre de mots = nb valeurs/4 +1                */
    692         int4            gyro[3][ (nb_per_block/2) +1 ];
    693         int4            fin;            /*      code de reconnaissance de fin de block          */
    694         }
    695         block_type_gyro_comprime;                       
    696 
    697 /*  ---------------------   structures N° 14 :    block_type_sst_comprime       -----------     */
    698 /*  -----------------------------------------------------------------------------------------   */
    699 typedef struct                           
    700         {
    701         int4            debut;          /*      code de reconnaissance de debut de block        */
    702         int4            code1;          /*      code1 du block                                  */
    703         int4            code2;          /*      code2 du block                                  */
    704                                         /*      pour chaque diode, un vecteur  11 mots          */
    705         int4            sst[nb_photo_diodes] [(nb_per_block*2/7) +1 ];
    706         int4            fin;            /*      code de reconnaissance de fin de block          */
    707         }
    708         block_type_sst_comprime;                       
    709 
    710 
    711 
    712 /*  ---------------------   structures N° 15 : catalog_flash      -------       */
    713 /*  ------------------------------------------------------------------------------------------- */
    714 
    715 typedef struct                          /*      etat de l'enregistreur                          */
    716         {
    717         int4            nb_total_catalog;
    718         int4            memoire_libre;
    719         int4            nb_block_erreur;
    720         }status_flash;
    721 
    722 typedef struct   
    723         {
    724         int4            debut;          /*      code de reconnaissance de debut de block        */
    725         int4            code1;          /*      code1 du block                                  */
    726         int4            code2;          /*      code2 du block                                  */
    727        
    728         int4            commande;       /*      la commande a laquelle ce catalog repond        */
    729         status_flash    status;         /*      etat de l'enregistreur                          */
    730         int4            nombre;         /*                                                      */
    731         int4            code[nb_element_catalog];       /* code type et numero                  */
    732         int4            fin;            /*      code de reconnaissance de fin de block          */
    733         }
    734         block_type_catalog_flash;                       
    735 
    736 
    737 /*  ---------------------   structures N° 16 :    cmd_flash                 -----------         */
    738 /*  -----------------------------------------------------------------------------------------   */
    739 typedef struct                           
    740         {
    741         int4            debut;          /*      code de reconnaissance de debut de block        */
    742         int4            code1;          /*      code1 du block                                  */
    743         int4            code2;          /*      code2 du block                                  */
    744         int4            commande;       /*      type de commande a l'enregistreur flash         */
    745         int4            fin;            /*      code de reconnaissance de fin de block          */
    746         }
    747         block_type_cmd_flash;                   
    748 
    749 enum    {flash_catalog_auto,flash_catalog_debut,flash_catalog_fin,flash_catalog_precedent,flash_catalog_suivant
    750                 ,flash_efface_tout1,flash_efface_tout2,flash_efface_tout3
    751                 ,flash_efface_util1,flash_efface_util2,flash_efface_util3};
    752 
    753 
    754 /*  ---------------------   structures N° 17 : block brut de données ctb pour test      ------- */
    755 /*  ------------------------------------------------------------------------------------------- */
    756 typedef struct   
    757         {
    758         int4            debut;          /*      code de reconnaissance de debut de block        */
    759         int4            code1;          /*      code1 du block                                  */
    760         int4            code2;          /*      code2 du block                                  */
    761 #ifdef  transmet_data_brute
    762         char            data[nb_per_block*nb_max_mes_per*nb_byte_mot];
    763 #endif
    764         int4            fin;            /*      code de reconnaissance de fin de block          */
    765         }
    766         block_type_data_brute;                 
    767 
    768 /*  ---------------------   structures N° 18 : block  vide pour l'instant             -------   */
    769 /*  ------------------------------------------------------------------------------------------- */
    770 typedef struct   
    771         {
    772         int4            debut;          /*      code de reconnaissance de debut de block        */
    773         int4            code1;          /*      code1 du block                                  */
    774         int4            code2;          /*      code2 du block                                  */
    775         int4            fin;            /*      code de reconnaissance de fin de block          */
    776         }
    777         block_type_18;                 
    778 
    779 /*  ---------------------   structures N° 19 : block  vide pour l'instant             -------   */
    780 /*  ------------------------------------------------------------------------------------------- */
    781 typedef struct   
    782         {
    783         int4            debut;          /*      code de reconnaissance de debut de block        */
    784         int4            code1;          /*      code1 du block                                  */
    785         int4            code2;          /*      code2 du block                                  */
    786         int4            fin;            /*      code de reconnaissance de fin de block          */
    787         }
    788         block_type_19;                 
    789 
    790 
    791 
    792 /*  ---------   block  modele  (plus gros que tous les autres pour reservation memoire)   ----  */
    793 /*  -----------------------------------------------------------------------------------------   */
    794 
    795 typedef struct                          /*      La structure de transfert transputer vers mac   */ 
    796         {
    797         int4            debut;          /*      code de reconnaissance de debut de block        */
    798         int4            code1;          /*      code1 du block                                  */
    799         int4            code2;          /*      code2 du block                                  */
    800         int4            mot[(taille_maxi_block_archeops)/4];
    801         int4            fin;            /* code de reconnaissance de fin de block               */
    802         }
    803         block_type_modele;                     
    804 
    805 
    806 
    807 
    808 
    809 /*==============================================================================================*/
    810 /*==============================================================================================*/
    811 /*  --------------  définitions permettant de travailler sur les blocks Archeops   -----------  */
    812 /*==============================================================================================*/
    813 /*==============================================================================================*/
    814 
    815 
    816 
    817 enum    {block_param,block_journal,block_reglage,block_dilution,
    818         block_gps,block_une_periode,block_synchro_sol,block_pointage_sol,
    819         block_bolo,block_gyro,block_sst,block_11,
    820         block_bolo_comprime,block_gyro_comprime,block_sst_comprime,block_catalog_flash,
    821         block_cmd_flash,block_data_brute,block_18,block_19};
    822 
    823 
    824 #define def_nom_block   char nom_block[nb_type_blocks][32]={"block_param","block_journal","block_reglage","block_dilution",\
    825                                         "block_gps","block_une_periode","block_synchro_sol","block_pointage_sol",\
    826                                         "block_bolo","block_gyro","block_sst","block_11",\
    827                                         "block_bolo_comprime","block_gyro_comprime","block_sst_comprime","block_catalog_flash",\
    828                                         "block_cmd_flash","block_data_brute","",""};
    829 
    830 
    831 #define def_long_block  int long_block[nb_type_blocks]={sizeof(block_type_param),sizeof(block_type_journal),sizeof(block_type_reglage),sizeof(block_type_dilution),\
    832                                         sizeof(block_type_gps),sizeof(block_type_une_periode),sizeof(block_type_synchro_sol),sizeof(block_type_pointage_sol),\
    833                                         sizeof(block_type_bolo),sizeof(block_type_gyro),sizeof(block_type_sst),sizeof(block_type11),\
    834                                         sizeof(block_type_bolo_comprime),sizeof(block_type_gyro_comprime),sizeof(block_type_sst_comprime),sizeof(block_type_catalog_flash),\
    835                                         sizeof(block_type_cmd_flash),sizeof(block_type_data_brute),sizeof(block_type_18),sizeof(block_type_19)};
    836 
    837 
    838 
    839 
    840 
    841 /*   le code du block contient  8  bit de type                                                  */
    842 /*                              24 bit pour le numero du block(horloge locale)                  */
    843 /*                              12 bit pour la longueur du block  (en octet)                    */
    844 /*                              16 bit pour la somme de test de la validité du block            */
    845 
    846 /*  les define suivants doivent etre utilisés pour tester le type des blocks et les verifier    */
    847 
    848 
    849 #define longueur_block(_bk)     ( (int) ((_bk)->code1>>16)      & 0xffff )     
    850 #define somme_block(_bk)        ( (int)  (_bk)->code1           & 0xffff )
    851 
    852 #define type_block(_bk)         ( (int) ((_bk)->code2>>24)      & 0xff )
    853 #define numero_block(_bk)       ( (int)  (_bk)->code2           & 0xffffff )
    854 
    855 /* ce define cree le mot de controle de somme des blocks et de les verifier a la reception      */
    856 
    857 
    858 /*==============================================================================================*/
    859 /*==============================================================================================*/
    860 /*  -----------------  fonctions utilitaires de gestion des blocks Archeops   ----------------  */
    861 /*==============================================================================================*/
    862 /*==============================================================================================*/
    863 
    864 
    865 /* -------------------------------------------------------------------------------------------- */
    866 /* les fonctions suivantes sont des utilitaires permettant la gestion des blocks archeops       */
    867 /* il faut inclure une seule fois le header archeops.h précéde de :                             */
    868 /*                       #define utilitaires_de_block_archeops                                  */
    869 /* -------------------------------------------------------------------------------------------- */
    870 
    871 
    872 /* ----------------------------   prototypes des fonctions       ------------------------------ */
    873 /* -------------------------------------------------------------------------------------------- */
    874 
    875 
    876 /*      cette fonction calcule le code de somme pour le controle de parité des blocks           */
    877 
    878 int     calcul_somme_block(block_type_modele* blk,int longueur);
    879 
    880 
    881 
    882 
    883 
    884 /*      cette fonction est a apeller lors de la création d'un block apres l'avoir rempli        */
    885 /*      elle permet de creer tous les mots de controle du block                                 */
    886 
    887 void    valide_block(block_type_modele* blk,int type,int block_num);
    888 
    889 
    890 
    891 /*      cette fonction est a apeller pour vérifier la validité d'un block                       */
    892 /*      elle retourne 0 si le block est correct et sinon, un code d'erreur                      */
    893 /*      la seconde fonction sort les erreurs a l'ecran                                          */
    894 
    895 int     verifie_block(block_type_modele* blk);
    896 int     verifie_block_printf(block_type_modele* blk);
    897 
    898 enum    {block_correct,block_type_inconnu,block_longueur_erreur,block_somme_erreur
    899                 ,block_debut_erreur,block_fin_erreur};
    900 
    901 /*      cette fonction transforme un char (sur 8 bit) en double avec une echelle logarythmique  */
    902 /*      elle est en particulier utilisée pour calculer les coef de la regul                     */
    903 
    904 double  val_double(char x);
    905 
    906 /*      cette fonction transforme un char (sur 8 bit) en entier long (echelle logarythmique)    */
    907 /*      elle est en particulier utilisée pour fixer le courant sur les bolometres               */
    908 
    909 unsigned long   val_long(char x);
    910 
    911 int     new_val_dac(int a,char  code);
    912 
    913 
    914 
     1#include "archeops_28.h"
Note: See TracChangeset for help on using the changeset viewer.