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

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

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