#include "complex.h"
#include "arh.h"
#include "screen.h"

#define tyear1 ttm1->tm_year

resourceptr r_sb;      /* ресурс файла архива событий */
resourceptr r_cut;     /* ресурс файла архива суточных */
resourceptr r_mec;     /* ресурс файла архива месячных */
resourceptr r_eq;      /* pесуpс файла аpхива обоpудования */
resourceptr r_mgn;     /* ресурс файла архива мгновенных */
cpr mg,cu,mc,m_nr,m_sb;

word_s ia;
struct tm *ttm,*ttm1,*ttm2;
struct stat *buff;
char   *bf_su,*bf_sm,*bufmg,*buf_cu,*buf_a,bf_1min;
//arh    mgn,cut[KDN],mec[KMEC];
arh    mgn, *cut, *mec;
m_kod  *sur,*bufm,*smr;
m_ck   *bf_cu,*bf_a;
long   t_arch_an;
time_t t1;

#pragma pack(1)
typedef struct
{
 short  year;
 byte   mons;
 byte   day;
 byte   hour;
 byte   min;
 byte   sec;
 short  n_param;
}head_Up;

typedef struct
{
 byte  novalid;
 byte  status;
 float value;
}Up_str;

typedef struct
{
    byte      type  ;           /* тип параметра 0-анал. 1-дискр. */
    char      cipher [9];       /* шифp паpаметpа */
    char      namepar [25];     /* наименование паpаметpа */
    char      unit [9];         /* единица измеpения */
    byte      typobr ;          /* тип обр: 0-нет,1-усред.,2-интегр.,3-счет. */
    byte      typsc ;           /* тип шкалы:0-лин;1-квадp;2-эл.ед */
    float     scmin ;           /* нижний пpедел шкалы */
    float     scmax ;           /* веpхний пpедел шкалы */
    float     tgmin  ;          /* нижняя pеглам. гpаница */
    float     tgmax  ;          /* веpхняя pеглам. гpаница */
    float     almin  ;          /* нижняя аваpийная гpаница */
    float     almax  ;          /* веpхняя аваpийная гpаница */
    word_s    pra ;             /* номеp паpаметpа в раб.буферах архивов */
    word_s    prb ;             /* номеp паpаметpа в раб.буферах архивов */
    word_s    prc ;             /* номеp паpаметpа в раб.буферах архивов */
    word_s    prd ;             /* номеp паpаметpа в раб.буферах архивов */
    byte      archive ;         /* пpизн. аpхивиp. события */
    byte      archive1;         /* пpизн. аpхивиp. работы оборуд. */
} sprav;

#pragma pack()

word_s kzawr;
char *buf1;

#if (EDITQ)
 extern word_s e_num;
 extern edit_q *e_ptr;
 extern edit_q *ed;
#endif

#if (ARH_MOD)
 extern byte * p_rer;
 extern flagptr sut_flag;
 extern word_s mes_flag;
 extern word_s sut_fil;
 extern word_s sut_blk;
 extern word_s mes_fil;
 extern word_s mes_blk;
#endif

word_s into=5;

void prm();
void usr_min();
void usr_hour();
extern void pnet();
word_s opena(cpr,char *);
word_s disksize(long x);
float msh_an(word_s);
char *F_name(word_s,char *),*F_name1(word_s,char *);
word_s tden,atmec;
word_s tyz[DISPLAY],tmthz[DISPLAY],tdz[DISPLAY],thz[DISPLAY],tminz[DISPLAY];   //   для хpанения вpемени вызова пpотокола
//#########################################################################
//                 задача аpхивации мгновенных,усpедненных
//                 пятиминутных и сpеднечасовых значений
//#########################################################################
flagptr arh_fl;              // указат. на флаг пеpиодичности задач
tlinkptr arh_tm;             // указат. на таймеp пеpиодичности задач

extern void copy_arc(void);
extern void tbs_in_a(void);
extern dir_from_copy();
extern byte arh_sql;

void  Arh_an()
{
 char *fl1, *fl2, *fl3;
 word_s i,j,np_ark,kkk=0,ii,hd,n_1;
 analog *ptr_a; controller *ptr_c;
 long mgn_nz;
 head_Up head;
 Up_str  Up_str_1;
 m_texn  *Marh;
 m_texn  *Harh;
 m_texn  *Darh;

 cut=(arh *)calloc(sizeof(arh),NDayArh);
 mec=(arh *)calloc(sizeof(arh),NMonsArh);
 mgn.hn=0; strcpy(mgn.ifl,NameFile[34]);

 if(arh_sql) CreateSprav();

 for(j=0;j<NDayArh;j++) {F_name(j,cut[j].ifl); cut[j].hn=0;}
 for(j=0;j<NMonsArh;j++){F_name1(j,mec[j].ifl);mec[j].hn=0;}

 nom_gr_sob();

#if (EDITQ)
// опр-ние N параметра в архиве для корректировки расходов
 for(ia=0,ed=e_ptr; ia<e_num; ia++,ed++)
 {
  ed->n_q=ed->nz_q;
  ed->n_t=ed->nz_t;
  ed->n_p=ed->nz_p;

  for (j=0,ptr_c=c_ptr; j<ed->nc_q; j++,ptr_c++) ed->n_q+=ptr_c->num_ap;
  for (j=0,ptr_c=c_ptr; j<ed->nc_t; j++,ptr_c++) ed->n_t+=ptr_c->num_ap;
  for (j=0,ptr_c=c_ptr; j<ed->nc_p; j++,ptr_c++) ed->n_p+=ptr_c->num_ap;
 }
#endif

 arh_fl=create_flag(NULL,"P_FLAG");
 arh_tm=create_timer(NULL,into*HZ,arh_fl,TKIND_FLAG,1);                   //@
// инициализация
 ttm=(struct tm *)calloc(1,sizeof(struct tm)); if(ttm==NULL){o_kz_al("arh_an.c-ttm");return;}
 time(&t1); t_loct(&t1,ttm);
 tden=tekden(tyear,tyday);atmec=tekmec(tyear,tmon);
 ttm1=(struct tm *)calloc(1,sizeof(struct tm)); if(ttm1==NULL){o_kz_al("arh_an.c-ttm1");return;}
 memcpy(ttm1,ttm,sizeof(struct tm));
 ttm2=(struct tm *)calloc(1,sizeof(struct tm)); if(ttm2==NULL){o_kz_al("arh_an.c-ttm2");return;}
 memcpy(ttm2,ttm,sizeof(struct tm));

// обнуление вpемени вызова пpотокола
 for(i=0;i<DISPLAY;i++)tyz[i]=tmthz[i]=tdz[i]=thz[i]=tminz[i]=0;
// расчет справочной информации
 mgn_nz=mg.tbl=((long)tden*86400+(long)thour*3600+tmin*60+tsec)/into;        //@
 cu.tbl=(thour1*60+tmin1)/intu;
 mc.tbl=(tday1-1)*24+thour1;
// расчет количества архивируемых параметров
 for(ia=0,ptr_c=c_ptr,mc.kpar=0,mg.kpar=0;ia<c_num;ia++,ptr_c++) mg.kpar+=ptr_c->num_ap;
 mc.kpar=cu.kpar=mg.kpar;
//  расчет размеров буферов
 mc.dlbl=cu.dlbl=mg.dlbl=mg.kpar*sizeof(m_kod)+sizeof(long);
// 1min.dlbl=mg.kpar*sizeof(float);
//  расчет количества блоков
 mg.kbl=86400*(long)NDayArh/into;                                                //@
 cu.kbl=24*60/intu;
 mc.kbl=31*24;
// резервирование места под массивы для накопления
 Marh=(m_texn *)calloc(mg.kpar, sizeof(m_texn));
 Harh=(m_texn *)calloc(cu.kpar, sizeof(m_texn));
 Darh=(m_texn *)calloc(mc.kpar, sizeof(m_texn));

 bf_su=(char *)calloc(1,cu.dlbl); if(bf_su==NULL){o_kz_al("arh_an.c-bf_su");return;}
 bf_sm=(char *)calloc(1,mc.dlbl); if(bf_sm==NULL){o_kz_al("arh_an.c-bf_sm");return;}

 sur=(m_kod *)(bf_su+sizeof(long));
 smr=(m_kod *)(bf_sm+sizeof(long));

 bufmg=(char *)calloc(1,mg.dlbl); if(bufmg==NULL){o_kz_al("arh_an.c-bufmg");return;}
 memset(bufmg,0,mg.dlbl);

 buf1=(char *)calloc(0x10000,1);//(size_mem()-1),1024);

// открытие файлов архива
 mgn.hn=sopen(mgn.ifl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);
 if(mgn.hn==-1)
 {
  if(disksize(mg.dlbl*mg.kbl))
  {fgtext(RED_,200,160,"Нет места для архивов %ld",mg.dlbl*mg.kbl); free(buf1);return; }
  mgn.hn=opena(mg,mgn.ifl);
 }
 else if(filelength(mgn.hn)!=mg.dlbl*mg.kbl)
 {eprintf(RED_,"Несоответствие длины архива"); free(buf1);return; }

 for(j=0;j<NDayArh;j++)
 {
  cut[j].hn=sopen(cut[j].ifl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);
  if(cut[j].hn==-1)
  {
   if(disksize(cu.dlbl*cu.kbl))
   {fgtext(RED_,200,160,"Нет места для архивов %ld",cu.dlbl*cu.kbl); free(buf1);return; }
   cut[j].hn=opena(cu,cut[j].ifl);/*close(cut[j].hn);*/
  }
  else
  if(filelength(cut[j].hn)!=cu.dlbl*cu.kbl)
  {eprintf(RED_,"Несоответствие длины архива"); free(buf1);return; }
  close(cut[j].hn);
 }
 cut[tden].hn=sopen(cut[tden].ifl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);

 for(j=0;j<NMonsArh;j++)
 {mec[j].hn=sopen(mec[j].ifl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);
  if(mec[j].hn==-1)
  {if(disksize(mc.dlbl*mc.kbl))
   {fgtext(RED_,200,160,"Нет места для архивов %ld",mc.dlbl*mc.kbl); free(buf1);return; }
   mec[j].hn=opena(mc,mec[j].ifl);/*close(mec[j].hn);*/
  }
  else if(filelength(mec[j].hn)!=mc.dlbl*mc.kbl)
  {eprintf(RED_,"Несоответствие длины архива"); free(buf1);return; }
  close(mec[j].hn);
 }
 mec[atmec].hn=sopen(mec[atmec].ifl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);

 free(buf1);

 buf_cu=(char *)calloc((mg.kpar),sizeof(m_ck)); if(buf_cu==NULL){o_kz_al("arh_an.c-bf_cu");return;}
 bf_cu=(m_ck *)buf_cu;

 buf_a=(char *)calloc((mg.kpar),sizeof(m_ck)); if(buf_a==NULL){o_kz_al("arh_an.c-bf_a");return;}
 bf_a=(m_ck *)buf_a;

 r_read(mec[atmec].hn,bf_sm,mc.dlbl,mc.tbl*mc.dlbl,SEEK_SET,r_mec);

 if((long)*bf_sm!=0 )
 {
  t_loct((long *)bf_sm,ttm);
  if(tmon==tmon1 && tyear==tyear1)
  {kkk=1;
   for(ia=0,ptr_c=c_ptr,np_ark=0;ia<c_num;ia++,ptr_c++)
    for(j=0,ptr_a=ptr_c->a_ptr;j<ptr_c->num_ap;j++,ptr_a++,np_ark++)
     if ((smr+np_ark)->count) (bf_a+np_ark)->ck =0; else (bf_a+np_ark)->ck = 1;
  }
 }

 if (!kkk)
 {
  memset(bf_sm,0,mc.dlbl);
  for(ia=0,ptr_c=c_ptr,np_ark=0;ia<c_num;ia++,ptr_c++)
   for(j=0,ptr_a=ptr_c->a_ptr;j<ptr_c->num_ap;j++,ptr_a++,np_ark++) (smr+np_ark)->count = 1;
 }
 kkk=0;

//*******************
// copy_arc(); tbs_in_a();
//*******************
// time(&t1);
// t_loct(&t1,ttm);
// mgn_nz=mg.tbl=(long)tden*17280+((long)thour*3600+tmin*60+tsec)/5;

 while(!endrun)
 {                                 /* циклическая часть */

#if (DEBUG)
  view_text(2,73,8,"ARHAN");
#endif
#if (DOG_TIMER==1)
  tsk_outp(0x443,30);
#elif (DOG_TIMER==2)
  tsk_inp(0x43);
  tsk_inp(0x443);
#endif

  wait_flag_set(arh_fl,0L);clear_flag(arh_fl);
  time(&t_arch_an); t_loct(&t_arch_an,ttm);

//---------------------------------------------------------------------
  if(arh_sql)
  {
   if(ttm->tm_min!=ttm2->tm_min)
   {
    for(n_1=0,i=0;i<c_num;i++) n_1+=c_ptr[i].num_ap;
    fl1=calloc(1,n_1*sizeof(Up_str)+sizeof(head_Up));
    fl2=calloc(1,n_1*sizeof(Up_str)+sizeof(head_Up));
    fl3=calloc(1,n_1*sizeof(Up_str)+sizeof(head_Up));

    head.year=ttm->tm_year+1900; head.mons=ttm->tm_mon+1;
    head.day=ttm->tm_mday;       head.hour=ttm->tm_hour;
    head.min=ttm->tm_min;        head.sec=ttm->tm_sec;
    head.n_param=mg.kpar;
    memcpy(fl1,&head,sizeof(head_Up)); memcpy(fl2,&head,sizeof(head_Up)); memcpy(fl3,&head,sizeof(head_Up));

    for(np_ark=0,i=0;i<c_num;i++)
     for(ii=0;ii<c_ptr[i].num_ap;ii++,np_ark++)
     {
      if(!Marh[np_ark].count) continue;
      Up_str_1.novalid= 100-(Marh[np_ark].valid/Marh[np_ark].count)*100;
      Up_str_1.status=0; Up_str_1.value= Marh[np_ark].zn;
      memcpy(fl1+sizeof(head_Up)+np_ark*sizeof(Up_str),&Up_str_1,sizeof(Up_str));

      if(Harh[np_ark].valid||Marh[np_ark].valid)
       Harh[np_ark].zn=(Harh[np_ark].zn*Harh[np_ark].valid+Marh[np_ark].zn*Marh[np_ark].valid)/(Harh[np_ark].valid+Marh[np_ark].valid);
      Harh[np_ark].count+=Marh[np_ark].count; Harh[np_ark].valid+=Marh[np_ark].valid;
      Marh[np_ark].valid=Marh[np_ark].count=Marh[np_ark].zn=0;

      if(Darh[np_ark].valid||Harh[np_ark].valid)
       Darh[np_ark].zn=(Darh[np_ark].zn*Darh[np_ark].valid+Harh[np_ark].zn*Harh[np_ark].valid)/(Darh[np_ark].valid+Harh[np_ark].valid);
      Darh[np_ark].count+=Harh[np_ark].count; Darh[np_ark].valid+=Harh[np_ark].valid;

      Up_str_1.novalid= 100-(Harh[np_ark].valid/Harh[np_ark].count)*100;
      Up_str_1.status=0; Up_str_1.value= Harh[np_ark].zn;
      memcpy(fl2+sizeof(head_Up)+np_ark*sizeof(Up_str),&Up_str_1,sizeof(Up_str));

      Up_str_1.novalid= 100-(Darh[np_ark].valid/Darh[np_ark].count)*100;
      Up_str_1.status=0; Up_str_1.value= Darh[np_ark].zn;
      memcpy(fl3+sizeof(head_Up)+np_ark*sizeof(Up_str),&Up_str_1,sizeof(Up_str));

      if(ttm->tm_hour!=ttm2->tm_hour)
      {
       Harh[np_ark].valid=Harh[np_ark].count=Harh[np_ark].zn=0;
       if(ttm->tm_mday!=ttm2->tm_mday)
        Darh[np_ark].valid=Darh[np_ark].count=Darh[np_ark].zn=0;
      }
      schedule();
     }
    memcpy(ttm2,ttm,sizeof(struct tm));

    hd= sopen(NameFile[21],O_BINARY|O_RDWR|O_CREAT|O_TRUNC,SH_DENYNO,S_IWRITE);
    if(hd== -1) eprintf(RED_,"Не создан: %s",NameFile[21]);
    else {write(hd,fl1,n_1*sizeof(Up_str)+sizeof(head_Up)); close(hd);}
    hd= sopen(NameFile[20],O_BINARY|O_RDWR|O_CREAT|O_TRUNC,SH_DENYNO,S_IWRITE);
    if(hd== -1) eprintf(RED_,"Не создан: %s",NameFile[20]);
    else {write(hd,fl2,n_1*sizeof(Up_str)+sizeof(head_Up)); close(hd);}
    hd= sopen(NameFile[19],O_BINARY|O_RDWR|O_CREAT|O_TRUNC,SH_DENYNO,S_IWRITE);
    if(hd== -1) eprintf(RED_,"Не создан: %s",NameFile[19]);
    else {write(hd,fl3,n_1*sizeof(Up_str)+sizeof(head_Up)); close(hd);}
    free(fl1); free(fl2); free(fl3);
   }
   for(np_ark=0,i=0;i<c_num;i++)
    for(ii=0;ii<c_ptr[i].num_ap;ii++,np_ark++)
    {
     if(c_ptr[i].a_ptr[ii].novalid==0 && !c_ptr[i].a_ptr[ii].no_uchet)  // накопление для усреднения
     {
      if(c_ptr[i].a_ptr[ii].sum_ysr!=3)
       Marh[np_ark].zn=(Marh[np_ark].zn*Marh[np_ark].valid+c_ptr[i].a_ptr[ii].var_tech)/(Marh[np_ark].valid+1);
      else Marh[np_ark].zn=c_ptr[i].a_ptr[ii].var_tech;
      Marh[np_ark].valid++;
     }
     else Marh[np_ark].zn=0.0;
     Marh[np_ark].count++;
    }
  }
//---------------------------------------------------------------------
  if (tmin!=tmin1 && tmin%intu==0)//(thour*60+tmin)%intu==0)
  {
   usr_min();
   if(thour!=thour1)usr_hour();
   for(ia=0,ptr_c=c_ptr,np_ark=0;ia<c_num;ia++,ptr_c++)
    for(j=0,ptr_a=ptr_c->a_ptr;j<ptr_c->num_ap;j++,ptr_a++,np_ark++)
    {
     if(bf_cu[np_ark].ck==0)
     {
      if (ptr_a->sum_ysr!=3)
      {
       (smr+np_ark)->zn=(word_s)(((float)(smr+np_ark)->zn*(bf_a+np_ark)->ck+(sur+np_ark)->zn)/((bf_a+np_ark)->ck+1));
       (bf_a+np_ark)->ck ++;
      }
      else
      { (bf_a+np_ark)->ck=1; (smr+np_ark)->zn=(sur+np_ark)->zn; }
      (smr+np_ark)->count=0;
     }
     else
     {
      if (!(bf_a+np_ark)->ck ) (smr+np_ark)->count=1;
      (bf_cu+np_ark)->ck=0;
     }
    }

   if(!kkk) kkk=1;
   else
   {
    memcpy(bf_sm,&t_arch_an,sizeof(long));
    mc.tbl=(tday-1)*24+thour;
    r_write(mec[atmec].hn,bf_sm,mc.dlbl,mc.tbl*mc.dlbl,SEEK_SET,mec[atmec].ifl,r_mec);
   }
   memset(bf_su,0,cu.dlbl);
   t1=t_arch_an;
   memcpy(ttm1,ttm,sizeof(struct tm));
  }
                                                                                                /*  запись мгновенных в буфер  */
  memcpy(bufmg,&t_arch_an,sizeof(long));
  bufm=(m_kod *)(bufmg+sizeof(long));          // запись в архив времени
  np_ark=0;
  for(ia=0,ptr_c=c_ptr;ia<c_num;ia++,ptr_c++)
  {
   for(j=0,ptr_a=ptr_c->a_ptr;j<ptr_c->num_ap;j++,ptr_a++)
   {
    (bufm+np_ark)->count=ptr_a->novalid;   // достоверность
    (bufm+np_ark)->zn=ptr_a->var_cod;      // значение в кодах

    if(ptr_a->novalid==0 && !ptr_a->no_uchet)  // накопление для усреднения
    {
     if(ptr_a->sum_ysr!=3)
      (sur+np_ark)->zn=(word_s)(((float)(sur+np_ark)->zn*(bf_cu+np_ark)->ck+ptr_a->var_cod)/((bf_cu+np_ark)->ck+1));
     else (sur+np_ark)->zn=ptr_a->var_cod;
     (bf_cu+np_ark)->ck++;
    }
    np_ark++;
   }
  }
//  запись буфера мгновенных в архив

  mg.tbl=((long)tden*86400+(long)thour*3600+tmin*60+tsec)/into;             //@
  if (mgn_nz < mg.tbl) r_write(mgn.hn,bufmg,mg.dlbl,mgn_nz*mg.dlbl,SEEK_SET,mgn.ifl,r_mgn);
  mgn_nz=mg.tbl;
  r_write(mgn.hn,bufmg,mg.dlbl,mg.tbl*mg.dlbl,SEEK_SET,mgn.ifl,r_mgn);
  if (mgn_nz==mg.kbl-1) mgn_nz=0;
  else mgn_nz++;

  memset(bufmg,0,mg.dlbl);
 }                                   // конец архивации
 usr_min();usr_hour();close(mgn.hn);close(cut[tden].hn);close(mec[atmec].hn);
}

/*------------------------------------------------------------------------*/
        /* п/п проверки на конец месяца */
/*------------------------------------------------------------------------*/
void prm()
{
 if(tmon!=tmon1)
 {
  close(mec[atmec].hn);
  atmec=tekmec(tyear,tmon);
  mec[atmec].hn=sopen(mec[atmec].ifl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);
 }
}
 /*----------------------------------------------------------------------*/
          /* п/п откpытия-создания файла */
 /*----------------------------------------------------------------------*/
word_s opena(cpr mac,char *nfl)
{
 word_s fle;
 long kzap,size,ost,post,kbl,i;
 fle=sopen(nfl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);

 if(fle==-1)
 {fle=sopen(nfl,O_BINARY|O_RDWR|O_CREAT,SH_DENYNO,S_IREAD|S_IWRITE);
  o_kz_f(fle,nfl);

  _setcolor(0);
  _rectangle(_GFILLINTERIOR,100,100,540,130);

  _setcolor(15);
  fgtext(15,280,100,"%s",nfl);
  _rectangle(_GBORDER,/* _GFILLINTERIOR*/100,120,540,130);

  size=mac.dlbl*mac.kbl;
  kzap=size/0xfffe;
  if((ost=size%0xfffe))post=1;
  kbl=kzap+post;


  for (i=0;i<kzap;i++)
  {kzawr=write(fle,buf1,0xfffe);
   _rectangle(_GFILLINTERIOR,102,122,102+(word_s)((436./kzap)*(i+1)),128);
#if (DOG_TIMER==1)
   tsk_outp(0x443,30);
#elif (DOG_TIMER==2)
   tsk_inp(0x43);
   tsk_inp(0x443);
#endif
   o_kz_f(kzawr,nfl);
  }

  if(post)
  {kzawr=write(fle,buf1,(unsigned)ost);
   _rectangle(_GFILLINTERIOR,102,122,538,128);
   o_kz_f(kzawr,nfl);
  }

  close (fle);
  fle=sopen(nfl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);
 }
 else if(filelength(fle)!=mac.dlbl*mac.kbl) eprintf(RED_,"Несоответствие длины архива");
 return(fle);
}
/*--------------------------------------------------------------------------
         п/п усреднения на 5-ти минутном интервале
----------------------------------------------------------------------------*/
void usr_min()
{
// усреднение на интервале intu
 cu.tbl=(thour1*60+tmin1)/intu;
 t_arch_an-=60;memcpy(bf_su,&t_arch_an,sizeof(long));
 time(&t_arch_an);t_loct(&t_arch_an,ttm);
 for(ia=0;ia<cu.kpar;ia++)
 {
  if((bf_cu+ia)->ck==0) {(sur+ia)->count=1; (sur+ia)->zn=0; (bf_cu+ia)->ck=1;}
  else { (sur+ia)->count=0; (bf_cu+ia)->ck=0; }
 }
#if (!MOD_ARH)
 r_write(cut[tden].hn,bf_su,cu.dlbl,cu.tbl*cu.dlbl,SEEK_SET,cut[tden].ifl,r_cut);
#endif
#if (ARH_MOD)
 memcpy(p_rer,bf_su,cu.dlbl);
 sut_fil=tden;
 sut_blk=cu.tbl;
 set_flag(sut_flag);
#endif

 if(thour!=thour1&&thour==0)
 {
  close(cut[tden].hn);tden=tekden(tyear,tyday);
  cut[tden].hn=sopen(cut[tden].ifl,O_BINARY|O_RDWR,SH_DENYNO,S_IREAD|S_IWRITE);
 }
}
//--------------------------------------------------------------------------
//                 п/п усреднения на часовом интервале
//--------------------------------------------------------------------------
void usr_hour()
{
 mc.tbl=(tday1-1)*24+thour1;
 memcpy(bf_sm,&t1,sizeof(long));        // запись в архив времени
 for (ia=0;ia<mc.kpar;ia++)
 {
  if ((bf_a+ia)->ck==0) { (smr+ia)->count=1; (smr+ia)->zn=0;}// недостоверен
  else { (smr+ia)->count=0; (bf_a+ia)->ck=0; } // достоверен
 }

#if (!MOD_ARH)
 r_write(mec[atmec].hn,bf_sm,mc.dlbl,mc.tbl*mc.dlbl,SEEK_SET,mec[atmec].ifl,r_mec);
#endif
#if (ARH_MOD)
 memcpy(p_rer+cu.dlbl,bf_sm,mc.dlbl);
 mes_fil=atmec;
 mes_blk=mc.tbl;
 mes_flag=1;
#endif

 memset (bf_sm,0,mc.dlbl);
 prm();      /* проверка на конец месяца */
}

char *F_name(word_s day,char *name_f)
{strcpy(name_f,"a_cut");
 itoa(day,name_f+5,10);
 strcat(name_f,".bin");
 return(name_f);
}
char *F_name1(word_s day,char *name_f)
{strcpy(name_f,"a_mec");
 itoa(day,name_f+5,10);
 strcat(name_f,".bin");
 return(name_f);
}


word_s tekden(word_s god,word_s den)
{long i=0;word_s j;

 for(j=93;j<god;j++) {if(j%4)i+=365; else i+=366; }
 return (word_s)((i+den+1)%NDayArh);
}

word_s tekmec(word_s god,word_s mes)
{word_s i=1,j;

 for(j=92;j<god;j++)i+=12;
 return (i+mes)%NMonsArh;
}

word_s disksize(long x)
{
 unsigned drive;
 struct diskfree_t drvinfo;

 _dos_getdrive( &drive );
 _dos_getdiskfree( drive, &drvinfo );
 if(x>((long)drvinfo.avail_clusters * drvinfo.sectors_per_cluster * drvinfo.bytes_per_sector ))return 1;
 else return 0;
}

void CreateSprav(void)
{
 int hd,np_ark=0,i,ii;
 sprav *ptr_sp;
 analog *ptr_a;

 hd=sopen(NameFile[22],O_BINARY|O_RDWR|O_CREAT|O_TRUNC,SH_DENYNO,S_IWRITE);
 if(hd==-1) return;
 lseek(hd,0L,SEEK_SET);
 ptr_sp=(sprav *)calloc(1,sizeof(sprav)); if(ptr_sp==NULL) return;
 for(i=0;i<c_num;i++)
  for(ii=0;ii<c_ptr[i].num_ap;ii++,np_ark++)
  {
   ptr_a=&c_ptr[i].a_ptr[ii];
   ptr_sp->type=0;                            // тип параметра 0-анал. 1-дискр.
   strncpy(&ptr_sp->cipher,ptr_a->cipher,9);  // шифp паpаметpа
   strncpy(&ptr_sp->namepar,ptr_a->name,25);  // наименование паpаметpа
   strncpy(&ptr_sp->unit,ptr_a->unit,9);      // единица измеpения
   ptr_sp->typobr =ptr_a->sum_ysr;            // тип обработки 0-нет,1-усред.,2-интегр.,3-счет.
   ptr_sp->typsc  =ptr_a->type_sc;            // тип шкалы:0-лин;1-квадp;2-эл.ед
   ptr_sp->scmin  =ptr_a->min_sc;             // нижний пpедел шкалы
   ptr_sp->scmax  =ptr_a->max_sc;             // веpхний пpедел шкалы
   ptr_sp->tgmin  =valtec(ptr_a,ptr_a->min_reg);  // нижняя pеглам. гpаница
   ptr_sp->tgmax  =valtec(ptr_a,ptr_a->max_reg);  // веpхняя pеглам. гpаница
   ptr_sp->almin  =valtec(ptr_a,ptr_a->min_al);   // нижняя аваpийная гpаница
   ptr_sp->almax  =valtec(ptr_a,ptr_a->max_al);   // веpхняя аваpийная гpаница
   ptr_sp->pra    =np_ark;                    // номеp паpаметpа в раб.буферах архивов
   ptr_sp->prb    =np_ark;                    // номеp паpаметpа в раб.буферах архивов
   ptr_sp->prc    =np_ark;                    // номеp паpаметpа в раб.буферах архивов
   ptr_sp->prd    =np_ark;                    // номеp паpаметpа в раб.буферах архивов
   ptr_sp->archive=0 ;                        // пpизн. аpхивиp. события
   ptr_sp->archive1=0;                        // пpизн. аpхивиp. работы оборуд.
   write(hd,ptr_sp,sizeof(sprav));
  }
 close(hd); free(ptr_sp);
}