/*======================================================================*/ /* */ /* archeops.h : structure de données */ /* */ /*======================================================================*/ #define _archeops #define version_num 28 /* defini ici que si l'on n'a pas inclu ecclib.h qui contient les memes definitions */ #ifndef _ECC_LIB_H_ #define ECC_TOTAL 255 #define ECC_DATA 239 /* Nb de bytes de data encodes */ #define ECC_SIZE (ECC_TOTAL-ECC_DATA) /* Nb de bytes encodeurs */ #define SIZE_HEAD sizeof(int4)*3 /* 3 mots d'entete de blocs */ #endif /*======================================================================*/ /* */ /* historique des modifications */ /* */ /* */ /* VERSION 24: */ /* */ /* - utilise le fichier archeops.c */ /* - nb_max_bolo=24 avec nb_bolo_util=18 */ /* - change la structure du block param */ /* - change la structure du block dilution */ /* */ /* VERSION 25: */ /* */ /* - la compression marche */ /* - 4 signaux synchro O.K. */ /* - change la structure dil : contient les temperatures */ /* */ /* VERSION 26: */ /* */ /* - int4 pour compatibilité toutes machines */ /* */ /* VERSION 27: */ /* - ajout dans chaque block-type d'une structure "ecc" dont la */ /* taille est adaptee a la taille du bloc: */ /* on ajoute 16 bytes servant a la correction d'erreur */ /* pour chaque paquet de 241 bytes de donnees. */ /* les bytes d'ECC sont calcules avant envoi sur la ligne */ /* telemesure. */ /* Ils peuvent servir a l'arrivee pour verifier et corriger quand */ /* c'est possible les donnees. On peut corriger au maximu 7 bytes */ /* erronnes. */ /* */ /* VERSION 28: */ /* - corrigée la taille du block gyroscope avec ecc */ /* - compatible avec la generation de l'ecc dans le transputer */ /* - mais sans ecc: trops long a calculer */ /*======================================================================*/ /*======================================================================*/ /* --------------- parametres generaux de definition ------------- */ /*======================================================================*/ #ifndef int4 #ifdef __alpha #define int4 int #undef programme #else #define int4 long #endif #endif #ifdef linux #undef programme #endif #ifdef _planck #define _archeops #define _trapani #define _sans_transputer #endif #ifdef _archeops /*#define _test_diabolo relecture des blocks fabriques avec diabolo */ #define _trapani /* configuration prevue pour Trapani */ /*#define _kiruna block standard prevu pour kiruna */ #endif /*======================================================================*/ /* -------------- valeurs des parametres dans ------------- */ /* -------------- les différentes configurations ------------- */ /*======================================================================*/ /* */ /* configuration pour Trapani : 3 bebos / 12 bolos */ /* */ /* bebo1 : voies 1 à 6 --> bolo 1 a 6 */ /* bebo2 : voies 9 à 14 --> bolo 7 à 12 */ /* */ /* bebo6 : */ /* voies 41 42 43 44 = carte simplifiee avec AMP01 */ /* voies 45 et 46 = chauffage pour regulation */ /* on ecrira plus tard le stockage des donnees simplifiees */ /* */ /* */ /*======================================================================*/ /* nb_per_block doit etre divisible par 2 */ /* nb_max_bolo doit etre divisible par 2 pour archeops (impair pour diabolo ?? ) */ /* nb_bolo_util doit etre divisible par 2 pour archeops (impair pour diabolo ?? ) */ #ifdef _trapani #define nb_max_bolo 24 /* nombre maxi de bolos */ #define nb_bolo_util 18 /* nombre de bolos réellement transmis */ #define nb_per_block 36 /* nombre de periodes entieres dans un block */ #define nb_max_mes_per 88 /* nb de points maxi dans une periode complete */ #define nb_photo_diodes 46 /* nb de canaux de mesure du senseur stellaire */ #endif #ifdef _kiruna #define nb_max_bolo 36 /* nombre maxi de bolos */ #define nb_bolo_util 32 /* nombre de bolos réellement transmis */ #define nb_per_block 36 /* nombre de periodes entieres dans un block */ #define nb_max_mes_per 88 /* nb de points maxi dans une periode complete */ #define nb_photo_diodes 46 /* nb de canaux de mesure du senseur stellaire */ #endif #ifdef _diabolo #define nb_max_bolo 9 /* nombre maxi de bolos */ #define nb_bolo_util 9 /* nombre de bolos réellement transmis */ #define nb_per_block 20 /* nombre de periodes entieres dans un block */ #define nb_max_mes_per 128 /* nb de points maxi dans une periode complete */ #define nb_photo_diodes 0 /* nb de canaux de mesure du senseur stellaire */ #endif #ifdef _test_diabolo #define nb_max_bolo 9 /* nombre maxi de bolos */ #define nb_bolo_util 9 /* nombre de bolos réellement transmis */ #define nb_per_block 20 /* nombre de periodes entieres dans un block */ #define nb_max_mes_per 128 /* nb de points maxi dans une periode complete */ #define nb_photo_diodes 0 /* nb de canaux de mesure du senseur stellaire */ #endif #ifdef _sans_transputer #define nb_byte_mot 5 /* nombre d'octets dans un mot d'acquisition planck */ #else #define nb_byte_mot 8 /* nombre d'octets dans un mot d'acquisition archeops */ #endif #define nb_max_nom_bolo 24 /* nombre maxi de noms et coef bolo dans la table */ #define nb_sync 4 /* nombre de signaux de synchro */ /* 6 pour diabolo */ /* toujours multiple de 4 pour archeops */ #define nb_element_catalog 256 /* nombre d'éléments catalog par reponse enregistreur */ #ifdef transmet_data_brute #define taille_maxi_block_archeops sizeof(block_type_data_brute) #else /* le plus gros des différents blocks de télémesure*/ #define taille_maxi_block_archeops sizeof(block_type_bolo) #endif #define nombre_de_regul 4 #define nombre_de_voies 6 #define nb_type_blocks 20 /* nombre de type de blocks (multiple de 4) */ #define nb_modes_telemesure 10 #define nb_modes_flash 3 /*======================================================================*/ /* ------- codes de controle pour la transmission ----- */ /*======================= télécommande ==========================*/ /*======================================================================*/ /* -------------- codes de reconnaissance des paquets de télécommande -------------- */ #define debut_telecommande 0x23456789 #define fin_telecommande 0x98765432 /* ------------ codes de direction des commandes envoyées a l'EPLD Archeops -------------- */ #define tc_dir_transputer 1 #define tc_dir_reset_epld 3 #define tc_dir_reset_trp 4 /* ------------- codes des prefix des telecommandes traités le transputer -------------- */ #define tc_horloge 255 /* (-1) */ #define tc_cadence1 128 #define tc_cadence2 129 #define tc_cadence3 130 #define tc_regul 251 /* (-5) */ #define tc_switch_dil 250 #define tc_dac_dil 249 /*======================================================================*/ /* telecommande reduite sur 18 bit */ /*======================================================================*/ /*______________________________________________________________________________________________*/ /* 1er mot : code de debut de telecommande reduite */ #define tc_reduite 248 /*______________________________________________________________________________________________*/ /* 2eme mot: 4bit: 16 codes de direction tc2 */ enum{tc2_reset_epld,tc2_bolo_dacV,tc2_bolo_dacI,tc2_bolo_dacT ,tc2_bolo_dacL,tc2_bolo_gain,tc2_bolo_voie,tc2_horloge ,tc2_regul,tc2_auto_bolo,tc2_auto_dilu,tc2_dilution ,tc2_raz_fet,tc2_reset}; /* 13 codes: reste 3 disponibles*/ /*______________________________________________________________________________________________*/ /* 3eme mot: 6bit: */ /* code2=dac-gain-voie : numero de bolo */ /* code2=tc2_horloge : */ /* soit un code defini */ enum{tc3_commande,tc3_periode,tc3_nb_mesures,tc3_temp_mort,tc3_flag}; /* code2=tc2_regul : */ /* code2=tc2_auto_bolo : */ /* code2=tc2_auto_dilu : */ /* les valeurs des parametres d'auto_dilu ne depassent pas 128 */ /* code2=tc2_dilution : commandes setbit,clrbit */ enum{tc3_clr_bit_dil,tc3_set_bit_dil,tc3_fet_raz}; /* code2=tc2_reset : commandes setbit,clrbit */ #define tc3_reset 13 #define tc4_reset 73 /*______________________________________________________________________________*/ /* 4eme mot: 8bit: valeur a ecrire */ /*======================================================================*/ /* ------- codes de controle pour la transmission ----- */ /*========================= télémesure ============================*/ /*======================================================================*/ /* ------- codes de reconnaissance des paquets de télémesure */ #define debut_block_mesure 0x45627491 #define fin_block_mesure 0x83260432 /*======================================================================*/ /* ------------------------------------------------------------------ */ /* --------- Les formats des blocks type ARCHEOPS ------- */ /* ------------------------------------------------------------------ */ /*======================================================================*/ /*==============================================================================================*/ /* Le tableau est lut dans le desordre par le mac en lecture de la carte pci : */ /* Les entiers long sont ecrits tels quels */ /* Les short sont ecrits permuté 2 a 2 par le tansputer */ /* Les tables char sont ecrits permuté 4 / 4 par le transputer */ /* A la lecture dans le mac, tout est bon */ /* --------- structures N° 0 : parametres de mesure des bolometres ------------- */ /* ----------------------------------------------------------------------------------------- */ typedef struct { int4 numero_nom_coef; /* le numero pour retrouver le nom et les coef */ int4 bolo_code_util; /* le code d'utilisation du bolo */ int4 bolo_bebo; /* l'acquisition: 0 pour MLPA 10 pour BEBODIFF*/ int4 bolo_num; /* l'adresse hard du bolo */ int4 bolo_gain; /* le gain du preampli */ int4 bolo_capa; /* la valeur capa du modulateur */ int4 bolo_diviseur; /* le diviseur de la compensation */ } param_un_bolo; typedef struct { char bolo_nom[32]; /* le nom de chaque bolometre */ int4 coef[7]; /* les coef pour le calcul de la température */ } nom_et_coef_bolo; /* code_util des bolos */ enum{bolo_hors_service,bolo_normal_transmis,bolo_normal_non_transmis,bolo_thermo_simplifie}; typedef struct /* table des parametres de mesure bolometre */ /* cette table ne change pas (en principe) en cours de mesure */ { int4 numero_version; /* numero de version du header archeops.h */ int4 n_max_bolo; /* nombre maxi de bolos (divisible par 4) */ int4 n_per_block; /* nombre de periodes entieres dans un block */ int4 n_max_mes_per; /* nb de points maxi dans une periode complete */ int4 nb_bolo; /* nombre de bolometres effectivement lut */ param_un_bolo bolo[nb_max_bolo]; nom_et_coef_bolo nom_coef[nb_max_nom_bolo]; /* nombre de nom et coef bolo */ } param_bolo; /* int4 bolo_code_util[nb_max_bolo]; char bolo_nom[nb_max_bolo][32]; int4 bolo_bebo[nb_max_bolo]; int4 bolo_num[nb_max_bolo]; int4 bolo_gain[nb_max_bolo]; int4 bolo_capa[nb_max_bolo]; int4 bolo_diviseur[nb_max_bolo]; int4 coef[nb_max_bolo][7]; int4 presence_bebo; } param_bolo; */ typedef struct /* La structure de transfert transputer vers mac */ { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ param_bolo param; /* les parametres de mesure des bolometres */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof( param_bolo)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_param; /* ------------------- structures N° 1 : journal de bord --------------------- */ /* ----------------------------------------------------------------------------------------- */ #define long_page 10 typedef struct { int4 code2; /* code de la ligne du journal */ /* code idem code2 debut de block : */ /* contient un code de commande */ /* et le numero du block lors de la télécommande */ char mot[8]; /* contenu de la ligne du journal */ } ligne_journal; typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ ligne_journal jj[long_page]; /* block de 10 lignes de journal */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(ligne_journal)*long_page+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_journal; /* --------- structures N° 2 : reglage_bolo , regul etc.. -------- */ /* ------------------------------------------------------------------------------------------ */ /* les definitions suivantes s'appliquent a une variable de type reglage.bolo[bol] */ #define gainbrut(aa) ((char)(((aa).mot1&0x1f))) #define phase(aa) ((char)(((aa).mot1&0x60)>>5)) #define comm(aa) ((char)(((aa).mot1&0x80)>>7)) #define dac_V(aa) ((int)(((aa).mot1&0xfff00)>>8) ) #define dac_I(aa) ((int)(((aa).mot1&0xfff00000)>>20)) #define voie(aa) ((char)(((aa).mot2&0xff))) #define dac_T(aa) ((int)(((aa).mot2&0xfff00)>>8)) #define dac_L(aa) ((int)(((aa).mot2&0xfff00000)>>20)) /* #define bolo_mot1(dacV,dacI,gainbrut,phase,comm) ((gainbrut)&0x1f) | (((phase)&3)<<5) | (((comm)&1)<<7) | (((dacV)&0xfff)<<8) | (((dacI)&0xfff)<<20) #define bolo_mot2(dacT,dacL,voie) ((voie)&0xff) | (((dacT)&0xfff)<<8) | (((dacL)&0xfff)<<20) */ #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) #define bolo_mot2(dacT,dacL,voie) (((long)(voie))&0xff) | ((((long)(dacT))&0xfff)<<8) | ((((long)(dacL))&0xfff)<<20) typedef struct { int4 mot1; /* dac1 = mot[11..0]; dac2=mot1[23..12] */ /* gain = mot1[27..24]; phase = mot1[31..28]; */ int4 mot2; /* dac3 = mot[11..0]; dac4=mot1[23..12] */ /* voie pour reglages auto = mot2[31..24]; */ } reglage_un_bolo; #ifdef programme /*********** structure normale pour le mac ****************/ typedef struct { char periode; char nb_mesures; char temp_mort; char flag; } horloge; typedef struct { char mode; /* on_off et deglitch */ char num_bolo; /* numero du bolo utilisé, */ char voie_chauf; /* la voie de sortie chauffage */ char prop; /* zero dans prop -> chauffage=0; */ char integ; char deriv; short chauffage; /* valeur effective du chauffage */ } regul_bolo; /* longueur 2 entiers int4 */ typedef struct { char mode; char gain; char courant; char delai; } auto_bolo; /* longueur 1 entiers int4 */ typedef struct { char vanne; char helium; char chauffage; char piles; char transmission; char temps_max_vanne; char xx7; char xx8; } auto_dilu; /* longueur 1 entiers int4 */ #else /*********** structure swappée pour le transputer ****************/ typedef struct { char flag; char temp_mort; char nb_mesures; char periode; } horloge; typedef struct { char prop; /* zero dans prop -> chauffage=0; */ char voie_chauf; /* la voie de sortie chauffage */ char num_bolo; /* numero du bolo utilisé, */ char mode; /* on_off et deglitch */ short chauffage; /* valeur effective du chauffage */ char deriv; char integ; } regul_bolo; /* longueur 2 entiers int4 */ typedef struct { char delai; char courant; char gain; char mode; } auto_bolo; /* longueur 1 entiers int4 */ typedef struct { char piles; char chauffage; char helium; /* periode de mesure */ char vanne; char xx8; char xx7; char temps_max_vanne; char transmission; } auto_dilu; /* longueur 1 entiers int4 */ #endif /*********** fin des structures swappées ****************/ enum{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}; #define bit_piles_5V 1 #define bit_piles_15V 2 #define bit_piles_auto 4 enum{vanne_zero,vanne_rien,vanne_ferme,vanne_ouvre,vanne_auto_pression,vanne_auto_P_T}; /*enum{trans_zero,trans_rien,trans_normal,trans_rapide,trans_lent};*/ enum{helium_zero,helium_continu,helium_40s,helium_400s}; typedef struct /* int4 en mot de 32 bit */ { horloge horloge; /* 1 */ reglage_un_bolo bolo[nb_max_bolo]; /* 18 * 2 = 36 */ auto_bolo autom[nombre_de_voies]; /* 6 * 1 6 */ regul_bolo regul[nombre_de_regul]; /* 4 * 2 = 8 */ auto_dilu dilu; /* 2 */ } reglage_bolo; /* total 58 */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ reglage_bolo reglage; #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(reglage_bolo)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_reglage; /* --------------------- structures N° 3 : etat de la dilution ----------------------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ int4 switch_dil; int4 ADC_dil[48]; /* la lecture des 48 ADC de la carte DIL */ int4 DAC_dil[4]; /* les 4 dac de la carte dilution */ int4 DAC_sst[4]; /* les 4 dac de la carte sst */ int4 temperature[4]; /* valeurs lues sur cartes BEDIFF modifiees */ /* int4 gyro_dil[3][nb_per_block*2]; les gyros (block gyros) */ /* int4 data_dil[50]; data brutes de la dilution */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*64+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_dilution; /* --------------------- structures N° 4 : gps ------------------------------- */ /* ------------------------------------------------------------------------------------------- */ #define GPS_DATA 80 typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ char gps[GPS_DATA]; /* les données GPS (une chaine maxi 80 cara) */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((GPS_DATA+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_gps; /* --------------------- structures N° 5 : tous les bolos 1 periode --------------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ short bol_per[nb_max_bolo][nb_max_mes_per]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(short)*nb_max_bolo*nb_max_mes_per+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_une_periode; /* ---------------- structures N° 6 : signals de synchro (pour test au sol) --------------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ char synchro[nb_per_block*2][nb_sync]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((nb_per_block*nb_sync*2+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_synchro_sol; /* --------------------- structures N° 7 : block de données de pointage sol ----------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ char comment[1024]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((1024+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_pointage_sol; /* ------------- structures N° 8 : données brutes des bolometres ---------------------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ /* pour chaque bolo, un vecteur 72 points */ int4 data_bolo[nb_max_bolo][nb_per_block*2]; /* data D.S. (en mots de 32 bits) */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*nb_max_bolo*nb_per_block*2+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_bolo; /* --------------------- structures N° 9 : données des gyroscopes */ /* ----------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ /* chaque gyro: un vecteur tde 72 valeurs */ int4 gyro[3][nb_per_block*2]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*3*nb_per_block*2+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_gyro; /* --------------------- structures N° 10 : données senseur stellaire ----------- */ /* ----------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ int4 sst[nb_per_block*2][18]; /* chaque mesure: un paquet de 18 mots de 32 bits */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*nb_per_block*2*18+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_sst; /* --------------------- structures N° 11 : rien ----------- */ /* ----------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type11; /* --------------------- structures N° 12 : data bolo apres compression sur 7 bit ------ */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ /* nombre de mots = nb valeurs/4 +1 */ /* pour chaque bolo, un vecteur 19 mots */ unsigned int4 data_bolo[nb_bolo_util][ (nb_per_block/2) +1 ]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*nb_bolo_util*((nb_per_block/2) +1)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_bolo_comprime; /* --------------------- structures N° 13 : block_type_gyro_comprime ----------- */ /* ----------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ /* nombre de mots = nb valeurs/4 +1 */ unsigned int4 gyro[3][ (nb_per_block/2) +1 ]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*3*((nb_per_block/2) +1)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_gyro_comprime; /* --------------------- structures N° 14 : block_type_sst_comprime ----------- */ /* ----------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ /* pour chaque diode, un vecteur 11 mots */ unsigned int4 sst[nb_photo_diodes] [(nb_per_block*2/7) +1 ]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*nb_photo_diodes*((nb_per_block*2/7) +1)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_sst_comprime; /* --------------------- structures N° 15 : block_type_status_flash -------*/ /* ---------------------------------------------------------------- */ /* ** Quelque soit la commande, l'enregistreur renvoie toujours le meme type de bloc comprenant la commande, un mot d'erreur eventuel et le status. ** L'enregistreur ne prend jamais l'initiative d'envoyer un bloc de status (sauf dans le cas ci-dessous). ** Au reset, le controleur est un peu lent a demarrer (quelques secondes). Pour que tu puisse savoir quand il est pret, je propose de t'envoyer un bloc de type "block_type_status_flash" des que je suis pret (comme si tu avais envoye un bloc "block_type_cmd_flash" avec la commande "FLASH_STATUS_REQUEST" */ typedef struct {/* etat de l'enregistreur */ int4 nb_total_blocks ; int4 memoire_libre ; int4 nb_block_erreur ; } status_flash; typedef struct { unsigned int4 debut ; unsigned int4 code1 ; unsigned int4 code2 ; int4 commande; /* la commande a laquelle ce bloc repond */ int4 erreur ; /* Si la commande a induit une erreur */ status_flash status ; /* etat de l'enregistreur */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*2 + sizeof(status_flash)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif unsigned int4 fin ; /* code de reconnaissance de fin de block */ } block_type_status_flash ; /* --------------------- structures N° 16 : block_type_cmd_flash ---------*/ /* ------------------------------------------------------------------ */ typedef struct { unsigned int4 debut ; unsigned int4 code1 ; unsigned int4 code2 ; int4 commande; /* type de commande a l'enregistreur flash */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_cmd_flash; /* Commands from Transputer to Recorder */ enum { FLASH_STATUS_REQUEST, FLASH_EFFACE_TOUT1, FLASH_EFFACE_TOUT2, FLASH_EFFACE_TOUT3, FLASH_EFFACE_UTIL1, FLASH_EFFACE_UTIL2, FLASH_EFFACE_UTIL3 } ; /* Errors from Recorder to Transputer. Pending question: what to do in case of FLASH_ERASE_END_ERROR ? */ enum { FLASH_STATUS_OK, /* Pas d'erreur */ FLASH_BAD_SEQUENCE, /* Mauvaise sequence d'effacement */ FLASH_ERASE_START, /* Debut d'effacement */ FLASH_ERASE_END_OK, /* Fin d'effacement OK */ FLASH_ERASE_END_ERROR /* Erreur pendant l'effacement */ } ; /* --------------------- structures N° 17 : block brut de données ctb pour test ------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ #ifdef transmet_data_brute char data[nb_per_block*nb_max_mes_per*nb_byte_mot]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((nb_per_block*nb_max_mes_per*nb_byte_mot+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif #else #ifdef _ECC_LIB_H_ unsigned char ecc[((((SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_data_brute; /* --------------------- structures N° 18 : block vide pour l'instant ------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_18; /* --------------------- structures N° 19 : block vide pour l'instant ------- */ /* ------------------------------------------------------------------------------------------- */ typedef struct { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ #ifdef _ECC_LIB_H_ unsigned char ecc[((((SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_19; /* --------- block modele (plus gros que tous les autres pour reservation memoire) ---- */ /* ----------------------------------------------------------------------------------------- */ typedef struct /* La structure de transfert transputer vers mac */ { int4 debut; /* code de reconnaissance de debut de block */ int4 code1; /* code1 du block */ int4 code2; /* code2 du block */ int4 mot[(taille_maxi_block_archeops)/4]; #ifdef _ECC_LIB_H_ unsigned char ecc[((((sizeof(int4)*(taille_maxi_block_archeops/4)+SIZE_HEAD)/ECC_DATA)+1)*ECC_SIZE)] ; #endif int4 fin; /* code de reconnaissance de fin de block */ } block_type_modele; /*==============================================================================================*/ /*==============================================================================================*/ /* -------------- définitions permettant de travailler sur les blocks Archeops ----------- */ /*==============================================================================================*/ /*==============================================================================================*/ enum {block_param,block_journal,block_reglage,block_dilution, block_gps,block_une_periode,block_synchro_sol,block_pointage_sol, block_bolo,block_gyro,block_sst,block_11, block_bolo_comprime,block_gyro_comprime,block_sst_comprime,block_status_flash, block_cmd_flash,block_data_brute,block_18,block_19}; #define def_nom_block char nom_block[nb_type_blocks][32]={"block_param","block_journal","block_reglage","block_dilution",\ "block_gps","block_une_periode","block_synchro_sol","block_pointage_sol",\ "block_bolo","block_gyro","block_sst","block_11",\ "block_bolo_comprime","block_gyro_comprime","block_sst_comprime","block_status_flash",\ "block_cmd_flash","block_data_brute","",""}; #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),\ sizeof(block_type_gps),sizeof(block_type_une_periode),sizeof(block_type_synchro_sol),sizeof(block_type_pointage_sol),\ sizeof(block_type_bolo),sizeof(block_type_gyro),sizeof(block_type_sst),sizeof(block_type11),\ sizeof(block_type_bolo_comprime),sizeof(block_type_gyro_comprime),sizeof(block_type_sst_comprime),sizeof(block_type_status_flash),\ sizeof(block_type_cmd_flash),sizeof(block_type_data_brute),sizeof(block_type_18),sizeof(block_type_19)}; /* le code du block contient 8 bit de type */ /* 24 bit pour le numero du block(horloge locale) */ /* 12 bit pour la longueur du block (en octet) */ /* 16 bit pour la somme de test de la validité du block */ /* les define suivants doivent etre utilisés pour tester le type des blocks et les verifier */ #define longueur_block(_bk) ( (int) ((_bk)->code1>>16) & 0xffff ) #define somme_block(_bk) ( (int) (_bk)->code1 & 0xffff ) #define type_block(_bk) ( (int) ((_bk)->code2>>24) & 0xff ) #define numero_block(_bk) ( (int) (_bk)->code2 & 0xffffff ) /* ce define cree le mot de controle de somme des blocks et de les verifier a la reception */ /*==============================================================================================*/ /*==============================================================================================*/ /* ----------------- fonctions utilitaires de gestion des blocks Archeops ---------------- */ /*==============================================================================================*/ /*==============================================================================================*/ /* -------------------------------------------------------------------------------------------- */ /* les fonctions suivantes sont des utilitaires permettant la gestion des blocks archeops */ /* il faut inclure une seule fois le header archeops.h précéde de : */ /* #define utilitaires_de_block_archeops */ /* -------------------------------------------------------------------------------------------- */ /* ---------------------------- prototypes des fonctions ------------------------------ */ /* -------------------------------------------------------------------------------------------- */ /* cette fonction calcule le code de somme pour le controle de parité des blocks */ int calcul_somme_block(block_type_modele* blk,int longueur); /* cette fonction est a apeller lors de la création d'un block apres l'avoir rempli */ /* elle permet de creer tous les mots de controle du block */ void valide_block(block_type_modele* blk,int type,int block_num); /* cette fonction est a apeller pour vérifier la validité d'un block */ /* elle retourne 0 si le block est correct et sinon, un code d'erreur */ /* la seconde fonction sort les erreurs a l'ecran */ int verifie_block(block_type_modele* blk); int verifie_block_printf(block_type_modele* blk); enum {block_correct,block_type_inconnu,block_longueur_erreur,block_somme_erreur ,block_debut_erreur,block_fin_erreur}; /* cette fonction transforme un char (sur 8 bit) en double avec une echelle logarythmique */ /* elle est en particulier utilisée pour calculer les coef de la regul */ double val_double(char x); /* cette fonction transforme un char (sur 8 bit) en entier int4 (echelle logarythmique) */ /* elle est en particulier utilisée pour fixer le courant sur les bolometres */ unsigned int4 val_long(char x); int new_val_dac(int a,char code);