source: Sophya/trunk/Poubelle/archediab.old/archeops.h@ 645

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

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