source: Sophya/trunk/Poubelle/archediab.old/archediab.sources/c/acquisition_archeops.c@ 639

Last change on this file since 639 was 639, checked in by ansari, 26 years ago

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