source: Sophya/trunk/Poubelle/archediab.old/archediab.sources/c/fichier_archeops.c@ 2010

#include "diabolo.h"
#include "fichier.h"


block_type_modele       bktm2;          // memoire pour block local pour fabrication block
block_type_bolo         blk_bol;
block_type_synchro_sol  blk_sync;
int                     index=0;
int                     num_block=0;
unsigned long           temps_debut_arch;

/*
void  valide_block(block_type_modele* blk,int type,int block_num)
        {
        int somme;
        def_long_block
        blk->debut              =       debut_block_mesure;
        blk->code2              =       (block_num & 0xffffff ) | ( (type<<24)&0xff000000 );
        blk->mot[(long_block[type]/4)-4]  =     fin_block_mesure;
        calcul_somme_block(blk,longueur);
        blk->code1              =       (long_block[type]<<16)  |       somme;
        }

*/



void    fabrique_block_type_param(void)
{
#define blk  ((block_type_param*)(&bktm2))      // pointeur sur la memoire locale
blk->param      =       parametr;

valide_block(&bktm2,block_param,num_block);
#undef blk
ecrit_fichier_ARCH(&bktm2);
}



void    fabrique_block_type_reglage(void)
{
#define blk  ((block_type_reglage*)(&bktm2))    // pointeur sur la memoire locale
blk->reglage    =       gg->reglage;

valide_block(&bktm2,block_reglage,num_block);
#undef blk
ecrit_fichier_ARCH(&bktm2);
}




void    fabrique_block_type_une_periode(void)
{
#define blk  ((block_type_une_periode*)(&bktm2))        // pointeur sur la memoire locale

//  a ecrire boucle pour copier les periodes simples
int j,i;                
for(j=0;j<nb_max_bolo;j++)      for (i=0;i<nb_max_mes_per;i++)
                blk->bol_per[j][i]=gg->bol_per[j][i]^0x7fff;    // 16 bit -> 15 bit utile + phase
                                                                // change le signe des 15 bits utiles           
valide_block(&bktm2,block_une_periode,num_block);
#undef blk
ecrit_fichier_ARCH(&bktm2);
}

//      short           bol_per[nb_max_bolo][nb_max_mes_per];           



//  cette fonction rempli un block coups par coups et l'ecrit quand il est plein

void    fabrique_block_type_bolo_synchro(void)
{
int j;
int nb_coups,aa,s;
static compt_block_reg=0;

nb_coups= gg->reglage.horloge.nb_mesures/2 - gg->reglage.horloge.temp_mort;
aa = (nb_coups<<14) + (nb_coups*190) ;
if( index%2) s=1;else   s=-1;
//gg->don.don_bolo[j] =  s*(((blk->data_bolo[j][i]-aa)<<1)/nb_coups)
for(j=0;j<nb_max_bolo;j++)      blk_bol.data_bolo[j][index]=aa+((gg->don.don_bolo[j]*s*nb_coups)>>1);
for(j=0;j<nb_sync;j++)          blk_sync.synchro[j][index]=gg->don.sync[j];

index++;
if( index < (nb_per_block*2) ) return;

index=0;
num_block++;

valide_block( (block_type_modele*) &blk_sync,block_synchro_sol,num_block);
ecrit_fichier_ARCH( (block_type_modele*) &blk_sync);


valide_block( (block_type_modele*) &blk_bol,block_bolo,num_block);
ecrit_fichier_ARCH( (block_type_modele*) &blk_bol);

compt_block_reg++;
if(compt_block_reg>20)
        {
        compt_block_reg=0;
        fabrique_block_type_reglage();
        }
}





//---------------------------------------------------------------------------------------
//---------------    ecrit  les  fichiers     ARCH        -------------------------------
//---------------------------------------------------------------------------------------


void    ecrit_fichier_ARCH(block_type_modele * bktp)
{
unsigned long ttx;
int long_b=longueur_block(bktp);

GetDateTime(&ttx);
if(gg->scan_en_cours)   temps_debut_arch=ttx;
if( (!gg->scan_en_cours)  && ( (ttx-temps_debut_arch) > 2*temps_max_fichier) )
        {
//      printf(" fichier Archeops sans scan de plus de 10 minutes: fich_new \n");
        GetDateTime(&temps_debut_arch);         // pour ne pas le faire deux fois
        fich_new(0,0);                          // pour limiter la duree des fichiers arch
        }

if(fenetre(fichier_arch_1))
        {
//      position(fichier_arch_1,fin_f);
        ecritF(fichier_arch_1,long_b,bktp);
        }
if(fenetre(fichier_arch_2))
        {
//      position(fichier_arch_2,fin_f);
        ecritF(fichier_arch_2,long_b,bktp);
        }
}



void exec_ARCH(int fen,int item,double valeur,...)      // exec du fichier lui_meme
                                                        // apellé pour les deux fichiers ARCH ouverts et fermés
{
switch(item)
        {
        case ouverture  :       
                if( (fen!=fichier_arch_1) && (fen!=fichier_arch_2) )    
                        {
#ifdef _archeops
                        ouvre('ACTI',0,1,"lit_fichier_arch",exec_lit_fichier_ARCH,(void*)fen);
#else
                        printf(" ne peut pas relire les fichiers archeops \n");
                        printf("il faut compiler avec archeops ou planck  \n");
#endif
                        break;
                        }
//                                                                                      
//*****************************************************************************************
                printf("nouveau fichier archeops : %s  \n",titre(fen));
                gg->fichier_arch_ouvert=1;
                GetDateTime(&temps_debut_arch);
                fabrique_block_type_param();
                fabrique_block_type_reglage();
                break;


        case fermeture :
                gg->fichier_arch_ouvert=0;

//              if( (fen!=fichier_arch_1) && (fen!=fichier_arch_2) )  break;
//              fich_save_partiel(3);

//              litD(fenetre_fichier,f_comment,E->commentaires);
//              ecritD(fenetre_fichier,f_comment,"../..");
                break;
                
        }
}