| [637] | 1 | #define utilitaires_de_block_archeops
|
|---|
| 2 |
|
|---|
| 3 | #include "diabolo.h"
|
|---|
| 4 | #include "bolo.h"
|
|---|
| 5 | #include "acqui.h"
|
|---|
| 6 | #include "carte_acqui.h"
|
|---|
| 7 | #include "carte_pci.h"
|
|---|
| 8 | #include "trace.h"
|
|---|
| 9 | #include "corel.h"
|
|---|
| 10 | #include "montimer.h"
|
|---|
| 11 | #include "synchro.h"
|
|---|
| 12 | #include "fichier.h"
|
|---|
| 13 | #include "onde.h"
|
|---|
| 14 | #include "tm.h"
|
|---|
| 15 | #include "tache.h"
|
|---|
| 16 | #include "compress.h"
|
|---|
| 17 | #include "controle.h"
|
|---|
| 18 | #include "menu.h"
|
|---|
| 19 |
|
|---|
| 20 |
|
|---|
| 21 |
|
|---|
| 22 |
|
|---|
| 23 | //*****************************************************************************************
|
|---|
| 24 | // ***
|
|---|
| 25 | #ifdef _archeops //--------- pour Archeops ------------------------------ ***
|
|---|
| 26 | //--------------- lit block Archeops ------------------------------ ***
|
|---|
| 27 | // ***
|
|---|
| 28 | //*****************************************************************************************
|
|---|
| 29 |
|
|---|
| 30 |
|
|---|
| 31 | // la fonction litblock
|
|---|
| 32 | // 1 elle lit dans la table de telemesures
|
|---|
| 33 | // 2 elle teste le type de block et sa validité (somme des bits et code fin)
|
|---|
| 34 | // 3 elle appelle la fonction de traitement en lui fournissant un pointeur sur le block
|
|---|
| 35 | // 4 elle sauve le block dans le fichier
|
|---|
| 36 | // C'est la fonction acqui qui apelle lit_block qui avance le pointeur de la table de telemesures
|
|---|
| 37 |
|
|---|
| 38 |
|
|---|
| 39 | block_type_modele bktm; // memoire pour block local pour copie lors de la decompression
|
|---|
| 40 |
|
|---|
| 41 | block_type_synchro_sol blk_sync2; // block memoire pour les synchro sol qui seront traitées lors
|
|---|
| 42 | // de la lecture du block bolo
|
|---|
| 43 |
|
|---|
| 44 |
|
|---|
| 45 |
|
|---|
| 46 | #define blk_tm (&tt->tm.btm[tt->tm.pos_lit].tmtrx) // pointeur sur le block télémesure a lire)
|
|---|
| 47 |
|
|---|
| 48 | void lit_block_archeops(int err)
|
|---|
| 49 | {
|
|---|
| 50 | if(verifie_block_printf(blk_tm)) return;
|
|---|
| 51 |
|
|---|
| [643] | 52 | {
|
|---|
| 53 | def_nom_block
|
|---|
| 54 | static int mon_num_block;
|
|---|
| 55 | if(mon_num_block!=numero_block(blk_tm))
|
|---|
| 56 | {
|
|---|
| 57 | mon_num_block=numero_block(blk_tm);
|
|---|
| 58 | printf("\n%d ->",mon_num_block);
|
|---|
| 59 | }
|
|---|
| 60 | printf(" %s ",nom_block[type_block(blk_tm)]);
|
|---|
| 61 | }
|
|---|
| [637] | 62 |
|
|---|
| 63 | switch(type_block(blk_tm))
|
|---|
| 64 | {
|
|---|
| 65 | case block_param : break;
|
|---|
| 66 |
|
|---|
| 67 | case block_journal : traite_block_journal((block_type_journal*)blk_tm); break;
|
|---|
| 68 |
|
|---|
| 69 | case block_reglage : traite_block_reglage((block_type_reglage*)blk_tm); break;
|
|---|
| 70 |
|
|---|
| 71 | case block_dilution : traite_block_dilution((block_type_dilution*)blk_tm); break;
|
|---|
| 72 |
|
|---|
| 73 | case block_gps : traite_block_gps((block_type_gps*)blk_tm); break;
|
|---|
| 74 |
|
|---|
| 75 | case block_une_periode : traite_block_une_periode((block_type_une_periode*)blk_tm); break;
|
|---|
| 76 |
|
|---|
| 77 | case block_bolo : traite_block_bolo((block_type_bolo*)blk_tm); break;
|
|---|
| [643] | 78 | case block_bolo_comprime : traite_block_bolo_comprime((block_type_bolo_comprime*)blk_tm); break;
|
|---|
| [637] | 79 |
|
|---|
| 80 | case block_sst : traite_block_sst((block_type_sst*)blk_tm); break;
|
|---|
| [643] | 81 | case block_sst_comprime : traite_block_sst_comprime((block_type_sst_comprime*)blk_tm); break;
|
|---|
| 82 |
|
|---|
| 83 | case block_gyro : traite_block_gyro((block_type_gyro*)blk_tm); break;
|
|---|
| 84 | case block_gyro_comprime : traite_block_gyro_comprime((block_type_gyro_comprime*)blk_tm); break;
|
|---|
| [637] | 85 |
|
|---|
| 86 | case block_synchro_sol : traite_block_synchro_sol((block_type_synchro_sol*)blk_tm); break;
|
|---|
| 87 |
|
|---|
| [643] | 88 | case block_status_flash : printf("******************status flash recut ********************* \n");son(133); break;
|
|---|
| 89 |
|
|---|
| [637] | 90 | #ifdef transmet_data_brute
|
|---|
| 91 | case block_data_brute : traite_block_data_brute((block_type_data_brute*)blk_tm); break;
|
|---|
| 92 | #endif
|
|---|
| 93 |
|
|---|
| 94 | default : {def_nom_block printf("block de type %s non traité par le programme \n",nom_block[type_block(blk_tm)]);}
|
|---|
| 95 | break;
|
|---|
| 96 | }
|
|---|
| 97 |
|
|---|
| 98 | ecrit_fichier_ARCH(blk_tm);
|
|---|
| 99 |
|
|---|
| 100 | }
|
|---|
| 101 | #undef blk_tm
|
|---|
| 102 |
|
|---|
| 103 | //*****************************************************************************************
|
|---|
| 104 | // ***
|
|---|
| 105 | // ------------------ traitement des blocks --------------- ***
|
|---|
| 106 | // ***
|
|---|
| 107 | //*****************************************************************************************
|
|---|
| 108 |
|
|---|
| 109 |
|
|---|
| 110 |
|
|---|
| 111 |
|
|---|
| 112 | //-----------------------------------------------------------------------------------------
|
|---|
| 113 | // ------------- block type 1 : lit le journal ------------------ ------------
|
|---|
| 114 | //-----------------------------------------------------------------------------------------
|
|---|
| 115 | void traite_block_journal(block_type_journal* blk)
|
|---|
| 116 | {
|
|---|
| 117 | int i,code,blocknum;
|
|---|
| 118 | if(!fenetre(fenetre_journal)) nouveauT(fenetre_journal,0,"journal");
|
|---|
| 119 |
|
|---|
| 120 | //printf("ecrit une page du journal \n");
|
|---|
| 121 | for(i=0;i<long_page;i++)
|
|---|
| 122 | {
|
|---|
| 123 | code=type_block(&blk->jj[i]);
|
|---|
| 124 | blocknum=numero_block(&blk->jj[i]);
|
|---|
| 125 | if(code) break; // code vaut 1 pour vider une page de journal incomplete
|
|---|
| 126 | ecritT(fenetre_journal,fin_f,"block_num= %d code %d ==> %d %d %d %d %d %d %d %d \n",
|
|---|
| 127 | blocknum,code,
|
|---|
| 128 | blk->jj[i].mot[0],blk->jj[i].mot[1],blk->jj[i].mot[2],blk->jj[i].mot[3],
|
|---|
| 129 | blk->jj[i].mot[0],blk->jj[4].mot[5],blk->jj[i].mot[6],blk->jj[i].mot[7]);
|
|---|
| 130 | }
|
|---|
| 131 | }
|
|---|
| 132 |
|
|---|
| 133 | //-----------------------------------------------------------------------------------------
|
|---|
| 134 | // ------------- block type 2 : block_reglage ------------------ ------------
|
|---|
| 135 | //-----------------------------------------------------------------------------------------
|
|---|
| 136 | void traite_block_reglage(block_type_reglage* blk)
|
|---|
| 137 | {
|
|---|
| 138 |
|
|---|
| 139 | //printf(" recut un block reglage *********************************** \n\n");
|
|---|
| 140 |
|
|---|
| 141 | gg->reglage=blk->reglage;
|
|---|
| 142 | tt->reglage=blk->reglage;
|
|---|
| 143 | rafraichis_fenetres();
|
|---|
| 144 | }
|
|---|
| 145 |
|
|---|
| 146 |
|
|---|
| 147 | //-----------------------------------------------------------------------------------------
|
|---|
| 148 | // --------------------- block type 3 : lit les data dilution ------------------------
|
|---|
| 149 | //-----------------------------------------------------------------------------------------
|
|---|
| 150 | //
|
|---|
| 151 | // fonction void traite_block_dilution(block_type_dilution*blk)
|
|---|
| 152 | //
|
|---|
| 153 | // la fonction est dans le module dilution.c
|
|---|
| 154 |
|
|---|
| 155 |
|
|---|
| 156 |
|
|---|
| 157 | //-----------------------------------------------------------------------------------------
|
|---|
| 158 | // --------------------- block type 4 : lit la chaine GPS ------------------------
|
|---|
| 159 | //-----------------------------------------------------------------------------------------
|
|---|
| 160 | void traite_block_gps(block_type_gps* blk)
|
|---|
| 161 | {
|
|---|
| 162 | int i;
|
|---|
| 163 | char c1;
|
|---|
| 164 | if(!fenetre(fenetre_GPS)) nouveauT(fenetre_GPS,0,"lecture GPS");
|
|---|
| 165 |
|
|---|
| 166 | //printf("ecrit une ligne GPS \n");
|
|---|
| 167 |
|
|---|
| 168 | if(blk->gps[0])
|
|---|
| 169 | {
|
|---|
| 170 | ecritT(fenetre_GPS,fin_f,"gps --> ");
|
|---|
| 171 | for(i=0;i<80;i++)
|
|---|
| 172 | {
|
|---|
| 173 | c1=blk->gps[i];
|
|---|
| 174 | if (c1) ecritT(fenetre_GPS,fin_f,"%c",c1&0x7f);
|
|---|
| 175 | else i=80;
|
|---|
| 176 | if(c1==13) i=80;
|
|---|
| 177 | }
|
|---|
| 178 | }
|
|---|
| 179 | }
|
|---|
| 180 |
|
|---|
| 181 |
|
|---|
| 182 |
|
|---|
| 183 | //-----------------------------------------------------------------------------------------
|
|---|
| 184 | // ------------- block type 5 : lit les courbes de bolos individuelles ------------
|
|---|
| 185 | // nb_per_block est le nombre de periodes entieres dans le block
|
|---|
| 186 | // --> le nombre de courbes lues est egal a nb_per_block qui doit etre <= nb_max_bolo
|
|---|
| 187 | //-----------------------------------------------------------------------------------------
|
|---|
| 188 | void traite_block_une_periode(block_type_une_periode* blk)
|
|---|
| 189 | {
|
|---|
| 190 | int j,i;
|
|---|
| 191 | for(j=0;j<nb_max_bolo;j++) for (i=0;i<gg->reglage.horloge.nb_mesures;i++)
|
|---|
| 192 | gg->bol_per[j][i]=blk->bol_per[j][i]^0x7fff; // 16 bit -> 15 bit utile + phase
|
|---|
| 193 | // change le signe des 15 bits utiles
|
|---|
| 194 | affi_bolo(); // affichage des bolo individuels
|
|---|
| 195 | }
|
|---|
| 196 |
|
|---|
| 197 |
|
|---|
| 198 |
|
|---|
| 199 |
|
|---|
| 200 | //-----------------------------------------------------------------------------------------
|
|---|
| 201 | // ------------- block type 6 : block_synchro_sol ------------------ ------------
|
|---|
| 202 | //-----------------------------------------------------------------------------------------
|
|---|
| 203 | void traite_block_synchro_sol(block_type_synchro_sol* blk)
|
|---|
| 204 | {
|
|---|
| 205 | blk_sync2 = *blk;
|
|---|
| 206 | // ne fait rien: le block synchro precede toujours le block bolo
|
|---|
| 207 | }
|
|---|
| 208 |
|
|---|
| 209 |
|
|---|
| 210 |
|
|---|
| [639] | 211 |
|
|---|
| [637] | 212 | //-----------------------------------------------------------------------------------------
|
|---|
| 213 | // --------------------- block type 12 : décomprime les données bolo ------------
|
|---|
| 214 | //-----------------------------------------------------------------------------------------
|
|---|
| 215 | void traite_block_bolo_comprime(block_type_bolo_comprime* blk)
|
|---|
| 216 | {
|
|---|
| [643] | 217 | int j,jc;
|
|---|
| [637] | 218 | #define blk2 ((block_type_bolo*)(&bktm)) // pointeur sur la memoire locale
|
|---|
| 219 | // maintenant, decomprime blk pour le reecrire dans blk2
|
|---|
| [639] | 220 | /*printf("comprime: ds1= %x , %x ds2= %x , %x ",
|
|---|
| [637] | 221 | ( (blk->data_bolo[0][0] & 0xffff0000)>>11 ) & 0x001fffe0,
|
|---|
| 222 | ( (blk->data_bolo[0][0] & 0x0000ffff)<<5 ) & 0x001fffe0,
|
|---|
| 223 | ( (blk->data_bolo[1][0] & 0xffff0000)>>11 ) & 0x001fffe0,
|
|---|
| 224 | ( (blk->data_bolo[1][0] & 0x0000ffff)<<5 ) & 0x001fffe0);
|
|---|
| [639] | 225 | */
|
|---|
| [643] | 226 | /*
|
|---|
| [637] | 227 | for(j=0;j<nb_bolo_util;j++)
|
|---|
| 228 | {
|
|---|
| [639] | 229 | decompress_7_2((long *)blk->data_bolo[j],blk2->data_bolo[j],nb_per_block*2);
|
|---|
| [637] | 230 | }
|
|---|
| [643] | 231 | */
|
|---|
| 232 | jc=0;for(j=0;j<nb_max_bolo;j++) // jc = bolo_comprime // j=bolo normal
|
|---|
| 233 | {
|
|---|
| 234 | if( (parametr.bolo[j].bolo_code_util==bolo_normal_transmis) && (jc<nb_bolo_util) )
|
|---|
| 235 | {
|
|---|
| 236 | decompress_7_2((long *)blk->data_bolo[jc],blk2->data_bolo[j],nb_per_block*2);
|
|---|
| 237 | jc++;
|
|---|
| 238 | }
|
|---|
| 239 | }
|
|---|
| [639] | 240 | /*printf("ds1= %x , %x ds2= %x , %x \n",
|
|---|
| [637] | 241 | blk2->data_bolo[0][0],
|
|---|
| 242 | blk2->data_bolo[0][1],
|
|---|
| 243 | blk2->data_bolo[1][0],
|
|---|
| 244 | blk2->data_bolo[1][1]);
|
|---|
| [639] | 245 | */
|
|---|
| [637] | 246 | valide_block(&bktm,block_bolo,numero_block(blk)); // pour recopier le numero de block
|
|---|
| 247 | traite_block_bolo(blk2);
|
|---|
| 248 | }
|
|---|
| 249 |
|
|---|
| 250 |
|
|---|
| 251 |
|
|---|
| 252 |
|
|---|
| 253 | //-----------------------------------------------------------------------------------------
|
|---|
| 254 | // ------------- block type 8 : block_bolo ------------------ ------------
|
|---|
| 255 | //-----------------------------------------------------------------------------------------
|
|---|
| 256 | void traite_block_bolo(block_type_bolo* blk)
|
|---|
| 257 | {
|
|---|
| 258 | static num_block_local;
|
|---|
| 259 | int i,j,nb_coups,glitch;
|
|---|
| 260 | static ancien_don_bolo[nb_max_bolo];
|
|---|
| 261 | int secondes;
|
|---|
| 262 |
|
|---|
| 263 | glitch=litD(fenetre_acquisition,e_deglitch,0L);
|
|---|
| 264 |
|
|---|
| 265 | num_block_local++;
|
|---|
| 266 | if(num_block_local!=numero_block(blk)) {printf(" erreur numblock=%d\n",numero_block(blk));num_block_local=numero_block(blk);}
|
|---|
| 267 |
|
|---|
| 268 | secondes=(int) (gg->periode_echantillonage*(double)num_block_local*(double)nb_per_block*2.);
|
|---|
| 269 | //printf("numblock=%d sec=%d \n",num_block_local,secondes);
|
|---|
| 270 | ecritD(fenetre_controle,con_time,"%d",secondes);
|
|---|
| 271 |
|
|---|
| 272 | nb_coups= gg->reglage.horloge.nb_mesures/2 - gg->reglage.horloge.temp_mort;
|
|---|
| 273 |
|
|---|
| 274 | /*
|
|---|
| 275 | if( (num_block_local%10)==0) // impression des valeurs un block sur 10
|
|---|
| 276 | {
|
|---|
| 277 | int aa = (nb_coups<<14) + (nb_coups*190) ;
|
|---|
| 278 | printf(" nb coups dans une somme : %d \n",nb_coups);
|
|---|
| 279 | for(j=0;j<20;j+=2)
|
|---|
| 280 | printf("ds1= %x , %x ds2= %x , %x ",
|
|---|
| 281 | blk->data_bolo[0][j],
|
|---|
| 282 | blk->data_bolo[0][j+1],
|
|---|
| 283 | blk->data_bolo[1][j],
|
|---|
| 284 | blk->data_bolo[1][j+1]);
|
|---|
| 285 | printf("ds1= %8.1f , %8.1f ds2= %8.1f , %8.1f \n",
|
|---|
| 286 | (double)(blk->data_bolo[0][j]- aa),
|
|---|
| 287 | (double)(blk->data_bolo[0][j+1]- aa),
|
|---|
| 288 | (double)(blk->data_bolo[1][j]- aa),
|
|---|
| 289 | (double)(blk->data_bolo[1][j+1]- aa));
|
|---|
| 290 | }
|
|---|
| 291 | */
|
|---|
| 292 |
|
|---|
| 293 | // ------------- lit les valeur detection synchrone ------------------
|
|---|
| 294 |
|
|---|
| 295 | #define val_DS(j,i) (blk->data_bolo[j][i]&0x1fffff)
|
|---|
| [639] | 296 | //#define synchro_DS(j,i) ((blk->data_bolo[j][i]>>20)&1)
|
|---|
| [637] | 297 |
|
|---|
| 298 | for (i=0;i<nb_per_block*2;i++)
|
|---|
| 299 | {
|
|---|
| 300 | int aa,s;
|
|---|
| 301 | aa = (nb_coups<<14) + (nb_coups*190) ;
|
|---|
| 302 | if( i%2) s=1;else s=-1;
|
|---|
| 303 |
|
|---|
| 304 | for(j=0;j<nb_max_bolo;j++)
|
|---|
| 305 | {
|
|---|
| 306 | gg->don.don_bolo[j]=0.5*(ancien_don_bolo[j]+s*(((val_DS(j,i)-aa)<<1)/nb_coups)); // copy bolos
|
|---|
| 307 | ancien_don_bolo[j]=s*(((val_DS(j,i)-aa)<<1)/nb_coups);
|
|---|
| 308 | }
|
|---|
| 309 |
|
|---|
| [639] | 310 | for(j=0;j<nb_sync;j++)
|
|---|
| 311 | {
|
|---|
| 312 | gg->don.sync[j]=blk_sync2.synchro[i][j];
|
|---|
| 313 | }
|
|---|
| 314 |
|
|---|
| 315 |
|
|---|
| 316 | // gg->don.sync[j]=synchro_DS(j,i);
|
|---|
| [637] | 317 |
|
|---|
| 318 | gg->temps_cntl=num_block_local*nb_per_block*2+i; // temps controlleur en demi-periodes
|
|---|
| 319 | // printf("gg->temps_cntl=%d \n",gg->temps_cntl);
|
|---|
| 320 | // exec_synchro(0,100,err); // en premier pour construire le flag scan_en_cours
|
|---|
| 321 | exec_synchro(0,100,0); // en premier pour construire le flag scan_en_cours
|
|---|
| 322 | // le trace ds et 1p est fait avec les points corelles du coups precedent !!!
|
|---|
| 323 |
|
|---|
| 324 | GetDateTime(&gg->temps_mac);
|
|---|
| 325 | if(gg->fichier_dia2_ouvert) ecrit_fichier_dia2(gg->don,gg->temps_cntl,gg->temps_mac); // ecrit les donnees dans le fichier
|
|---|
| 326 |
|
|---|
| 327 | if(glitch) deglitch();
|
|---|
| 328 | corel();
|
|---|
| 329 |
|
|---|
| 330 | //if(gg->trace_ouvert&1) exec_trace_tout(fenetre_trace_tout,tache_de_fond,0);
|
|---|
| 331 | for(j=0;j<8;j++) if(gg->trace_tout[j]) exec_trace_tout(gg->trace_tout[j],tache_de_fond,0);
|
|---|
| 332 | if( (gg->trace_ouvert&16) && // trace carte et pas de select synchro
|
|---|
| 333 | (! (gg->trace_ouvert&32))) trace_annexe(gg->corel);
|
|---|
| 334 | if(gg->flag_fou) foufou();
|
|---|
| 335 | if(gg->trace_ouvert&8) exec_ondelette(fenetre_ondelette,0,0);
|
|---|
| 336 |
|
|---|
| 337 |
|
|---|
| 338 | }
|
|---|
| 339 |
|
|---|
| 340 | // _____________ affichage numerique de la valeur d'un bolometre _______________
|
|---|
| 341 | j=litD(fenetre_acquisition,e_bolo,0L)-1;
|
|---|
| 342 | if( (j<0) ou (j>=nb_max_bolo) ) ecritD(fenetre_acquisition,e_valeur,"--");
|
|---|
| 343 | else ecritD(fenetre_acquisition,e_valeur,"b%d=%g µV",j+1,xbol(j));
|
|---|
| 344 |
|
|---|
| 345 |
|
|---|
| 346 | }
|
|---|
| 347 |
|
|---|
| 348 |
|
|---|
| 349 |
|
|---|
| 350 |
|
|---|
| 351 | #ifdef transmet_data_brute
|
|---|
| 352 | //-----------------------------------------------------------------------------------------
|
|---|
| 353 | // ------------- block type 15 : lit data brute (block recut de l'EPLD) ------------ ------------
|
|---|
| 354 | // ------------- utilise uniquement pour la mise au point ------------
|
|---|
| 355 | //-----------------------------------------------------------------------------------------
|
|---|
| 356 | void traite_block_data_brute(block_type_data_brute* blk)
|
|---|
| 357 | {
|
|---|
| 358 | int i,k;
|
|---|
| 359 | static int qq=0;
|
|---|
| 360 | qq++;
|
|---|
| 361 | //if(qq>20)
|
|---|
| 362 | {
|
|---|
| 363 | qq=0;
|
|---|
| 364 | printf(" data brutes : ");
|
|---|
| 365 | for(k=0;k<10;k+=5) {printf(" ");for (i=0;i<5;i++) printf(" %x", (unsigned char) blk->data[k+i+1]);}
|
|---|
| 366 | printf("\n");
|
|---|
| 367 | for(k=0;k<nb_per_block;k++) printf("%d",(blk->data[k*tt->reglage.horloge.nb_mesures*nb_byte_mot+5]>>6)&0x3);
|
|---|
| 368 | printf("\n");
|
|---|
| 369 | // for(k=0;k<2;k++)
|
|---|
| 370 | {
|
|---|
| 371 | // printf("%d",(blk->data[k*tt->reglage.horloge.nb_mesures*nb_byte_mot+2]>>6)&0x3);
|
|---|
| 372 | for(i=0;i<tt->reglage.horloge.nb_mesures;i++)
|
|---|
| 373 | {
|
|---|
| 374 | // printf("%d",(blk->data[(k*tt->reglage.horloge.nb_mesures+i)*nb_byte_mot+5]>>6)&0x3);
|
|---|
| 375 | }
|
|---|
| 376 | // printf("\n");
|
|---|
| 377 | }
|
|---|
| 378 |
|
|---|
| 379 | }
|
|---|
| 380 | }
|
|---|
| 381 | #endif
|
|---|
| 382 |
|
|---|
| 383 |
|
|---|
| 384 |
|
|---|
| 385 |
|
|---|
| 386 | #endif
|
|---|
| 387 |
|
|---|
![(please configure the [header_logo] section in trac.ini)](/PI/chrome/site/your_project_logo.png){kind=logo}
