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

char *cur_alg;
char buf_glb[256];         //глобальный буфер

char alg_conf1[]="alg.cfg";

int Inp_set(word_s ind,alg_str *alg,float *val);
float FormErr(alg_str *alg,char opt);

#define OLD_ALG_CFG 0       //Использование старой конфигурации

#define PTR_C GB->ptr_c
#define NZ GB->nz
#define TYP GB->typ
//#define ALGB GB->algb
#define ALGB1 GB->algb1
#define VHVIR GB->vhvir
#define FORM_OFFS GB->form_offs
#define LEN_STR GB->len_str
#define PTR_STR GB->ptr_str

char *StrMesVirt[]=
  {
//Ошибки вычислителя
   "DOMAIN ошибка в алгб. %.9s",                                                    //0
   "SING ошибка в алгб. %.9s",                                                      //1
   "OVERFLOW ошибка в алгб. %.9s",                                                  //2
   "UNDERFLOW ошибка в алгб. %.9s",                                                 //3
   "TLOSS ошибка в алгб. %.9s",                                                     //4
   "PLOSS ошибка в алгб. %.9s",                                                     //5
   "Неизвестная ошибка %d в алгб. %.9s",                                            //6
//Надписи регулятора
   "",                                                                              //7
   "Алгоблок %3d  Алгоpитм ПИД",                                                    //8
   "Вычислитель %d",                                                                //9
   "",                                                                              //10
   "",                                                                              //11
//Дополнительные собщения
   "Нарушена структура файла %s",                                                   //12
   "Алгоблок %.9s отсутствует в описателе контроллеров",                            //13
   "Имя алгоблока %.9s встречается более 1 раза в описателе контроллеров",          //14
   "Присутствует пустой алгоблок",                                                  //15
   "Вход %.9s алгоблока %.9s отсутствует в описателе контроллеров",                 //16
   "Вход %.9s алгоблока %.9s встречается более 1 раза в описателе контроллеров",    //17
   "Нет памяти для VIRT"                                                            //18
  };


//s_frm *formuls;
//dword form_amount=0;
//s_alg *p_alg;
//word k_alg=0;

frm_str *formuls1;
dword form_am1=0;
alg_str *p_alg1;
word k_alg1=0;

typedef struct
 {controller *ptr_c;        //Указатель на контроллер параметра
  word_s nz;                //Номер записи параметра
  char typ;                 //Тип параметра
//  s_alg *algb;              //Указатель на алгоблок
  alg_str *algb1;
  frm_str *form1;
  float *vhvir;           //Указатель на масив входов алгоблока
  long form_offs;           //Смещение в формуле для свободной формулы
  word len_str;             //Длина строки для свободной формулы
  byte *ptr_str;            //Указатель на строку для свободной формулы
//  char *cur_alg;            //Текущий алгоблок для индикации ошибочного алгоблока
 }a_fli;                         //Текущий контроллер для VIRT

typedef struct
 {char      cipher[9];
  float     koef[15];
 }koef_alg;


typedef struct
 {char      cipher[9];
  word_s    func;
  word_s    subfunc;
  byte      n_inp;
  byte      n_koef;
  struct    {char name[9]; }* vhod;
  float     *koef;
 }algobl1;


typedef struct
 {char      cipher[9];
  word_s    func;
  word_s    subfunc;
  struct
  {
   char     nameX[9];
  }vhod[8];
  float     koef[15];
 }algobl;


//Старая структура s_alg для возможности загрузки старых коэффициэнтов
//typedef struct
// {char      proc;
//  word      nomk:4;
//  word      tip:2;
//  word      nar:10;
//  word_s    nomz;
//  struct
//   {word    nc:4;
//    word    tip:2;
//    word    nar:10;
//    word_s  nz;
//   }vhod[8];
//  float koef[15];
// }s_alg1;


rec_koeff st_kf [15] =
{
 { "Кп =","%7.2f",  5, 36,  -128.0,  128.0, 89,14, 9 ,0.0},
 { "Ти =","%7.2f",  6, 36,     0.0, 9999.0, 89,14, 10,0.0},
 { "Тд =","%7.2f",  7, 36,     0.0, 9999.0, 89,14, 11,0.0},
 { "Тф =","%7.2f",  8, 36,     0.0, 9999.0, 89,14, 12,0.0},
 { "Н1 =","%7.2f",  9, 36,     0.0,  100.0, 89,14, 4 ,0.0},
 { "Н2 =","%7.2f", 10, 36,     0.0,  100.0, 89,14, 5 ,0.0},
 { "Zn =","%7.2f", 11, 36,     0.0,  100.0, 89,14, 6 ,0.0},
 { "К1 =","%7.2f",  5, 50,    -8.0,    8.0, 89,14, 0 ,0.0},
 { "К2 =","%7.2f",  6, 50,    -8.0,    8.0, 89,14, 1 ,0.0},
 { "К3 =","%7.2f",  7, 50,    -8.0,    8.0, 89,14, 2 ,0.0},
 { "К4 =","%7.2f",  8, 50,    -8.0,    8.0, 89,14, 3 ,0.0},
//                         { "Н4 =",  9, 50,  -100.0,  100.0, 89,14, 7},
//                         { "Н5 =", 10, 50,  -100.0,  100.0, 89,14, 8},
//                         { "Тк =",  9, 36,     0.0, 1091.0, 89,14 },
//                         { "Тм =", 10, 36,     0.0, 1091.0, 89,14 }
};


//------------------------------------------
extern float valtec(analog *pt, word_s cod);
extern void  sav_parm(analog *ptra);

extern word_s open_fh(char *namf,word_s init);
extern word_s setting(analog *a_ptr,float work_f);
extern void koeff_sc(analog *a_ptr);
extern byte * z_db(byte *x_db,int len);
extern word_s numrec, lenrec, fh, N_MAN;
extern char  *recfil;

extern word_s c_num;
extern char t_sc[],mas_cur_kf[][180], descr[];

float rangeparm(analog * ptr_a,float prom);
word_s ChekNamePasport(char *str,word_s *nc,word_s *nz);
char *sourceFile = __FILE__;
float calk(a_fli *),komyt(a_fli *),ymn(a_fli *),sym(a_fli *);
float nar(a_fli *), ymndl(a_fli *),esx(a_fli *);
float vard(a_fli *),xsy(a_fli *),es1(a_fli *), es3(a_fli *);
float es4(a_fli *),es5(a_fli *),del(a_fli *),pid(a_fli *), pid_n(a_fli *);
float symn(a_fli *), petl(a_fli *) ,zap1(a_fli *);
float zap2(a_fli *),zad(a_fli *), zad_n(a_fli *);
float volna(a_fli *),srob(a_fli *), blok_dig(a_fli *GB);
float perekl(a_fli *), baj(a_fli *),alarmk(a_fli *);
float free_formul(a_fli *), systep(a_fli *), exp1(a_fli *), im1(a_fli *);
float calk_form(a_fli *, float, byte), imzad(a_fli *), sdel(a_fli *);
void calk_oper(byte symb,float *rez,float parm);
int matherr1(struct exception *err);

dword takt_cpu(void);
#pragma aux takt_cpu = "db 0Fh,31h "\
                       modify [EDX] \
                       value [EAX]  ;

dword time_virt[MAX_CONTR];
/*-------------------------------------------------------------------*/

void taskVIRT(controller *ptr_c)
{
  float prom;
  word_s i,ii;
  analog *ptr_a;
  dword takt_old;
  digit *ptr_d;
  a_fli GB;

  if(ptr_c->period==0 || k_alg1==0) return;
  if(!ptr_c->baud) ptr_c->baud=1;
//Инициализация глобальных переменных конкретного VIRT контроллера
//  for(i=0,val=0;i<c_num;i++)
//   if((c_ptr+i)->typcontr==VIRT)
//    if(ptr_c->nom_ord==i) break;
//    else val++;
//  GB=alg_fli+val;
//---------------

  for(i=0,ptr_a=ptr_c->a_ptr;i<ptr_c->num_ap;i++,ptr_a++)
   {if(ptr_a->nomin_var<0) continue;
    ptr_a->pos_cod=0;
    if(formuls1[p_alg1[ptr_a->nomin_var].form].tip==31)ptr_a->dif_cod=0;
   }

  GB.vhvir=calloc(257,sizeof(float));
/*------------         Цикл  опpоса  ---------------------------------*/

  while(!endrun)
   {
    wait_flag_set(ptr_c->flag, 0L);
    clear_flag(ptr_c->flag);

//-----------------
    if(yes_P5)takt_old=takt_cpu();
//-----------------
    for(ii=0;ii<ptr_c->baud;/*schedule(),*/ii++)
    {
     for(i=0,ptr_a=ptr_c->a_ptr;i<ptr_c->num_ap;i++,ptr_a++)
     {if(/*ptr_a->type_mech==M_INP||*/ptr_a->nolog||ptr_a->nomin_var<0)continue;  // если или логич. запpет обpаб.  //!!
      if(ptr_a->nomin_var>k_alg1-1){ptr_a->novalid=1;continue;}
      ptr_a->dif_var=1;
      cur_alg=(char *)ptr_a;

//      if((prom=calk(ptr_a->nomin_var))==1000000000.){ptr_a->novalid=1;continue;}
//      if(ptr_a->nomin_var==-1){ptr_a->novalid=1;continue;}
      GB.vhvir[256]=ptr_a->var_tech;               //Выход
      GB.ptr_c=ptr_c;GB.nz=i;GB.typ=ANALOG;
      GB.algb1=p_alg1+ptr_a->nomin_var; GB.form1=formuls1+GB.algb1->form;
      if((prom=calk(&GB))==1000000000.){ptr_a->novalid=1;continue;}
      if(ptr_a->var_tech!=prom) ptr_a->var_tech=rangeparm(ptr_a,prom);
     }

     for(i=0,ptr_d=ptr_c->d_ptr;i<ptr_c->num_dp;i++,ptr_d++)
      if(ptr_d->type_par==1||ptr_d->type_par==3||ptr_d->type_par==5)
      {
       cur_alg=(char *)ptr_d;
       if((ptr_d->nom_var-1)<= -1){ptr_d->val_par=ptr_d->val_out;/*ptr_d->novalid=1;*/continue;}

       GB.vhvir[256]=(float)ptr_d->val_out;
       GB.ptr_c=ptr_c;GB.nz=i;GB.typ=DIGIT;
       GB.algb1=p_alg1+ptr_d->nom_var-1; GB.form1=formuls1+GB.algb1->form;
       if(calk(&GB)==1000000000.)ptr_d->novalid=1;
       if(ptr_d->type_par==3) ptr_d->val_par=ptr_d->val_out;
//         if(calk(ptr_d->nom_var-1)==1000000000.)ptr_d->novalid=1;
//       else ptr_d->novalid=0;
      }
      else
      if(ptr_d->type_par==0)
      {
       cur_alg=(char *)ptr_d;
       if((ptr_d->nom_var-1)<= -1)continue;

       GB.vhvir[256]=(float)ptr_d->val_par;
       GB.ptr_c=ptr_c;GB.nz=i;GB.typ=DIGIT;
       GB.algb1=p_alg1+ptr_d->nom_var-1; GB.form1=formuls1+GB.algb1->form;
       if((ptr_d->val_par=calk(&GB))==1000000000.)ptr_d->novalid=1;
      }
      else ptr_d->val_par=ptr_d->val_out;
    }
//------------
    if(yes_P5)time_virt[ptr_c->nom_ord] = takt_cpu() - takt_old;
//------------
   }
}
/*-----------------------------------------------------------------*/
float rangeparm(analog * ptr_a,float prom)
{
 word_s chkal;

 chkal=0;//(ptr_a->max_sc-ptr_a->min_sc)*0.05;
 if(prom>= ptr_a->max_sc+chkal)prom=ptr_a->max_sc+chkal;
 if(prom<= ptr_a->min_sc-chkal)prom=ptr_a->min_sc-chkal;
 return prom;
// ptr_a->novalid=0;
}

//-----------------------------------------------------------------------

float calk(a_fli *GB)
{
 word_s ivir;

 for(ivir=0;ivir<formuls1[ALGB1->form].n_inp;ivir++)
 {
  if(ALGB1->inp[ivir].tip==ANALOG) VHVIR[ivir]=((c_ptr+ALGB1->inp[ivir].nc)->a_ptr+ALGB1->inp[ivir].nz)->var_tech;
  if(ALGB1->inp[ivir].tip==DIGIT)  VHVIR[ivir]=(float)((c_ptr+ALGB1->inp[ivir].nc)->d_ptr+ALGB1->inp[ivir].nz)->val_par; //val_out;
  if(ALGB1->inp[ivir].tip==EMPTY)  VHVIR[ivir]=1.;
 }

 switch(GB->form1->tip)
  {
   case  1:return blok_dig(GB); //1000000000.;
   case  2:return komyt(GB);
   case  3:return ymn(GB);
   case  4:return sym(GB);
   case  5:return free_formul(GB);
   case  6:return 1000000000.;
   case  7:return 1000000000.;
   case  8:return ymndl(GB);
   case  9:return esx(GB);
   case 10:return xsy(GB);
   case 11:
   case 12:return es1(GB);
   case 13:return es3(GB);
   case 14:return es4(GB);
   case 15:return es5(GB);
   case 16:return del(GB);
   case 17:return pid_n(GB); //pid(GB);
   case 18:return nar(GB);
   case 19:return zad_n(GB); //zad(GB);
   case 20:return imzad(GB);
   case 21:return petl(GB);
   case 22:return im1(GB);
   case 23:return symn(GB);
   case 24:return sdel(GB);
   case 25:return zap1(GB);
   case 26:return zap2(GB);
   case 27:return vard(GB);
   case 28:return systep(GB);
   case 29:return exp1(GB);
   case 30:return perekl(GB);
   case 31:return volna(GB);
   case 32:return baj(GB);
   case 33:return alarmk(GB);
   case 34:return srob(GB);
  }
 return 1000000000.;
}

float blok_dig(a_fli *GB)
{
 char set=0;
 int  i;

// if(4>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(5>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 for(i=0;i<5;i++) if(ALGB1->inp[i].tip==EMPTY)  VHVIR[i]=0.;

 if(VHVIR[0]&&ALGB1->koef[2]!=1.) { ALGB1->koef[2]=1.; set=1; }
 if(VHVIR[2]&&ALGB1->koef[2]!=2.) { ALGB1->koef[2]=2.; set=1; }
 if(VHVIR[4]&&ALGB1->koef[2]!=3.) { ALGB1->koef[2]=3.; set=1; }
 if(set&&ALGB1->koef[0]>0.) {ALGB1->koef[1]=ALGB1->koef[0]; set=0;}
 if(ALGB1->koef[1]>0.) ALGB1->koef[1]-=PTR_C->period/(HZ*PTR_C->baud);
 else
 {
  ALGB1->koef[1]=0.;
  if(ALGB1->koef[0]>0.)
  {
   if(ALGB1->koef[2]==1.) {ALGB1->koef[2]=0.; VHVIR[0]=0.; Inp_set(0,ALGB1,&VHVIR[0]);}
   if(ALGB1->koef[2]==2.) {ALGB1->koef[2]=0.; VHVIR[2]=0.; Inp_set(2,ALGB1,&VHVIR[2]);}
   if(ALGB1->koef[2]==3.) {ALGB1->koef[2]=0.; VHVIR[4]=0.; Inp_set(4,ALGB1,&VHVIR[4]);}
  }
 }
 return 0.;
}

float srob(a_fli *GB)
{word_s i;
 digit *ptr_d;

// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=DIGIT)return 1000000000.;
 ptr_d=PTR_C->d_ptr+NZ;
 if(ptr_d->type_par!=1)return 1000000000.;
 for(i=0;i<8;i++)
  {if(ALGB1->inp[i].tip!=DIGIT)VHVIR[i]=0;
   else
    {switch(((c_ptr+ALGB1->inp[i].nc)->d_ptr+ALGB1->inp[i].nz)->type_par)
      {case 1 :VHVIR[i]=((c_ptr+ALGB1->inp[i].nc)->d_ptr+ALGB1->inp[i].nz)->val_par;
               if(ALGB1->koef[i]){if(VHVIR[i])VHVIR[i]=0.;else VHVIR[i]=1.;}break;
       case 3 :VHVIR[i]=!((c_ptr+ALGB1->inp[i].nc)->d_ptr+ALGB1->inp[i].nz)->val_par;
               if(ALGB1->koef[i]){if(VHVIR[i])VHVIR[i]=0.;else VHVIR[i]=1.;}break;
       case 5 :if(ALGB1->koef[i])
                VHVIR[i]=((c_ptr+ALGB1->inp[i].nc)->d_ptr+ALGB1->inp[i].nz)->val_par;
               else
                VHVIR[i]=((c_ptr+ALGB1->inp[i].nc)->d_ptr+ALGB1->inp[i].nz)->val_pr2;
               break;
       default:VHVIR[i]=0.;break;
      }
    }
   if(i%2)
    {if(ALGB1->koef[i/2+8])VHVIR[i-1]=VHVIR[i-1]*VHVIR[i];
     else VHVIR[i-1]=VHVIR[i-1]+VHVIR[i];
    }
  }
 if(ALGB1->koef[12])VHVIR[0]=VHVIR[0]*VHVIR[2];
 else VHVIR[0]=VHVIR[0]+VHVIR[2];
 if(ALGB1->koef[13])VHVIR[4]=VHVIR[4]*VHVIR[6];
 else VHVIR[4]=VHVIR[4]+VHVIR[6];
 if(ALGB1->koef[14])VHVIR[0]=VHVIR[0]*VHVIR[4];
 else VHVIR[0]=VHVIR[0]+VHVIR[4];

 if(VHVIR[0])ptr_d->val_par=1;
 else ptr_d->val_par=0;

 return 1.;
}

float alarmk(a_fli *GB)
{word_s ind,i,ii,*balarm;
 analog *ptr_a;

// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(1>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=ANALOG)return 1000000000.;
 ptr_a=PTR_C->a_ptr+NZ;

 if(ALGB1->koef[0])
  {ptr_a->var_tech+=(ptr_a->max_sc-ptr_a->min_sc)/(ALGB1->koef[0]*60.*HZ*PTR_C->baud/PTR_C->period);
   if(ptr_a->var_tech>=ptr_a->max_sc)
    {ptr_a->var_tech=ptr_a->min_sc;
     if((balarm=(word_s *)calloc(k_alg1,sizeof(word_s)))==NULL)return 0.;
     for(ind=ii=0;ii<k_alg1;ii++)if(formuls1[p_alg1[ii].form].tip==32){balarm[ind]=ii;ind++;}
     ind=rand()%ind;
     (p_alg1+balarm[ind])->koef[13]=((c_ptr+(p_alg1+balarm[ind])->inp[0].nc)->a_ptr+(p_alg1+balarm[ind])->inp[0].nz)->var_tech;
     if((p_alg1+balarm[ind])->koef[13]<0.05*((c_ptr+(p_alg1+balarm[ind])->inp[0].nc)->a_ptr+(p_alg1+balarm[ind])->inp[0].nz)->max_sc
        ||(p_alg1+balarm[ind])->koef[13]>0.95*((c_ptr+(p_alg1+balarm[ind])->inp[0].nc)->a_ptr+(p_alg1+balarm[ind])->inp[0].nz)->max_sc)
      (p_alg1+balarm[ind])->koef[14]=3;
     else
      (p_alg1+balarm[ind])->koef[14]=rand()%3+1;
     free(balarm);
    }
  }

 if(ALGB1->koef[1])
  {ALGB1->koef[5]+=10.*PTR_C->period/(ALGB1->koef[1]*60.*HZ*PTR_C->baud);
   if(ALGB1->koef[5]>=10.)
    {ALGB1->koef[5]=0.;

     ind=rand()%c_num;
     for(;;)
      {if((c_ptr+ind)->typcontr==VIRT)break;
       if(++ind==c_num)ind=0;
      }
     i=rand()%(c_ptr+ind)->num_dp;
     for(;;)
      {if(((c_ptr+ind)->d_ptr+i)->type_par==3)break;
       if(++i==(c_ptr+ind)->num_dp)i=0;
      }
     ((c_ptr+ind)->d_ptr+i)->val_par=((c_ptr+ind)->d_ptr+i)->val_out=0;
     ((c_ptr+ind)->d_ptr+i)->dif_out=((c_ptr+ind)->d_ptr+i)->dif_par=1;
    /*eprintf(15,((c_ptr+ind)->d_ptr+i)->cipher);*/
    }
  }

 return ptr_a->var_tech;
}

float baj(a_fli *GB)
{
// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(3>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 switch((word_s)ALGB1->koef[14])
  {case 0:break;

   case 1:VHVIR[0]=min(VHVIR[0],ALGB1->koef[13]);break;
   case 2:VHVIR[0]=max(VHVIR[0],ALGB1->koef[13]);break;
   case 3:VHVIR[0]=ALGB1->koef[13];break;
  }
 VHVIR[0]=min(VHVIR[0],VHVIR[1]);
 if(VHVIR[0]==0.&&ALGB1->koef[1]<=0.)return 1000000000.;
 if(VHVIR[0]<0.&&ALGB1->koef[1]!=ceil(ALGB1->koef[1]))return 1000000000.;
 VHVIR[0]=ALGB1->koef[0]*(float)pow((double)VHVIR[0],(double)ALGB1->koef[1]);

 if(VHVIR[2]==0.&&ALGB1->koef[6]<=0.)return 1000000000.;
 if(VHVIR[2]<0.&&ALGB1->koef[6]!=ceil(ALGB1->koef[6]))return 1000000000.;
 VHVIR[2]=ALGB1->koef[5]*(float)pow((double)VHVIR[2],(double)ALGB1->koef[6]);

 VHVIR[0]=VHVIR[0]+VHVIR[2];
 if(ALGB1->koef[11])
  {ALGB1->koef[12]+=ALGB1->koef[2]*PTR_C->period/(60.*HZ*PTR_C->baud);
   if(ALGB1->koef[12]>=ALGB1->koef[2])ALGB1->koef[12]=ALGB1->koef[14]=ALGB1->koef[11]=ALGB1->koef[13]=0.;
  }
 return VHVIR[0];
}

float volna(a_fli *GB)
{word_s ampl1,ampl2,ampl,prom;
 analog *ptr_a;

// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(1>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=ANALOG)return 1000000000.;
 ptr_a=PTR_C->a_ptr+NZ;

 VHVIR[0]=VHVIR[0]*ALGB1->koef[0];
 ampl1=(word_s)ALGB1->koef[1];
 ampl2=(word_s)ALGB1->koef[2];

 if(ampl1>0&&ALGB1->koef[6]>.1)
  {if(ptr_a->pos_cod<=0)
    {prom=rand()%(2*ampl1+1)-ampl1;
     ampl=prom-(word_s)ALGB1->koef[11];
     ptr_a->pos_cod=(word_s)(ALGB1->koef[6]*60.*HZ*PTR_C->baud/PTR_C->period);
     ptr_a->set_cod=(ampl*300)/ptr_a->pos_cod;
     ALGB1->koef[11]=(float)prom;
    }
   ALGB1->koef[13]+=(VHVIR[0]*ptr_a->set_cod)/30000.;
   ptr_a->pos_cod--;
  }

 if(ampl2>0&&ALGB1->koef[7]>.1)
  {if(ptr_a->dif_cod<=0)
    {prom=rand()%(2*ampl2+1)-ampl2;
     ampl=prom-(word_s)ALGB1->koef[12];
     ptr_a->dif_cod=(word_s)(ALGB1->koef[7]*60.*HZ*PTR_C->baud/PTR_C->period);
     ptr_a->out_cod=(ampl*300)/ptr_a->dif_cod;
     ALGB1->koef[12]=(float)prom;
    }
   ALGB1->koef[14]+=(VHVIR[0]*ptr_a->out_cod)/30000.;
   ptr_a->dif_cod--;
  }

 return VHVIR[0]+ALGB1->koef[13]+ALGB1->koef[14];
}

float perekl(a_fli *GB)
{
 char pr;

// if(8>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(7>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 VHVIR[0]=0.;
 if(ALGB1->inp[0].tip==EMPTY)return 1000000000.;
 if(ALGB1->inp[4].tip==DIGIT)
  {if(((c_ptr+ALGB1->inp[4].nc)->d_ptr+ALGB1->inp[4].nz)->val_par)
    {if(((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod!=R_AUTO)
      {((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod=R_AUTO;
       VHVIR[0]=1.;
      }
    }
  }
 if(ALGB1->inp[5].tip==DIGIT)
  {if(((c_ptr+ALGB1->inp[5].nc)->d_ptr+ALGB1->inp[5].nz)->val_par)
    {if(((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod!=R_MAN)
      {((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod=R_MAN;
       VHVIR[0]=1.;
      }
    }
  }
 if(ALGB1->inp[6].tip==DIGIT)
  {if(((c_ptr+ALGB1->inp[6].nc)->d_ptr+ALGB1->inp[6].nz)->val_par)
    {if(((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod!=R_CAS)
      {((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod=R_CAS;
       VHVIR[0]=1.;
      }
    }
  }
 pr=0;
 if(ALGB1->inp[1].tip==ANALOG)
  {if(ALGB1->koef[5]<0&&((c_ptr+ALGB1->inp[1].nc)->a_ptr+ALGB1->inp[1].nz)->var_tech<ALGB1->koef[0])
    pr=1;
   if(ALGB1->koef[5]>0&&((c_ptr+ALGB1->inp[1].nc)->a_ptr+ALGB1->inp[1].nz)->var_tech>ALGB1->koef[0])
    pr=1;

   if(pr&&((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod!=R_AUTO)
    {((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod=R_AUTO;
     VHVIR[0]=1.;
    }
  }

 pr=0;
 if(ALGB1->inp[2].tip==ANALOG)
  {if(ALGB1->koef[6]<0&&((c_ptr+ALGB1->inp[2].nc)->a_ptr+ALGB1->inp[2].nz)->var_tech<ALGB1->koef[1])
    pr=1;
   if(ALGB1->koef[6]>0&&((c_ptr+ALGB1->inp[2].nc)->a_ptr+ALGB1->inp[2].nz)->var_tech>ALGB1->koef[1])
    pr=1;

   if(pr&&((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod!=R_MAN)
    {((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod=R_MAN;
     VHVIR[0]=1.;
    }
  }

 pr=0;
 if(ALGB1->inp[3].tip==ANALOG)
  {if(ALGB1->koef[7]<0&&((c_ptr+ALGB1->inp[3].nc)->a_ptr+ALGB1->inp[3].nz)->var_tech<ALGB1->koef[2])
    pr=1;
   if(ALGB1->koef[7]>0&&((c_ptr+ALGB1->inp[3].nc)->a_ptr+ALGB1->inp[3].nz)->var_tech>ALGB1->koef[2])
    pr=1;

   if(pr&&((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod!=R_CAS)
    {((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->mod_cod=R_CAS;
     VHVIR[0]=1.;
    }
  }

 return VHVIR[0];
}


float exp1(a_fli *GB)
{
// if(8>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 VHVIR[0]=VHVIR[0]*ALGB1->koef[0]+VHVIR[1]*ALGB1->koef[1];
 VHVIR[6]=VHVIR[6]*ALGB1->koef[6]+VHVIR[7]*ALGB1->koef[7];
 if(VHVIR[6]==0.)return 1000000000.;
 VHVIR[4]=VHVIR[4]*ALGB1->koef[4]+VHVIR[5]*ALGB1->koef[5];
 VHVIR[3]=VHVIR[3]*ALGB1->koef[3]*(float)exp((double)(VHVIR[4]/VHVIR[6]));
 if(VHVIR[3]==0.)return 1000000000.;
 return VHVIR[0]+VHVIR[2]*ALGB1->koef[2]/VHVIR[3];
}

float systep(a_fli *GB)
{
// if(6>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 VHVIR[2]=VHVIR[2]*ALGB1->koef[1];
 VHVIR[5]=VHVIR[5]*ALGB1->koef[3];
 if(VHVIR[1]==0.&&VHVIR[2]<=0.)return 1000000000.;
 if(VHVIR[4]==0.&&VHVIR[5]<=0.)return 1000000000.;
 if(VHVIR[1]<0.&&VHVIR[2]!=ceil(VHVIR[2]))return 1000000000.;
 if(VHVIR[4]<0.&&VHVIR[5]!=ceil(VHVIR[5]))return 1000000000.;
 VHVIR[1]=(float)pow((double)VHVIR[1],(double)VHVIR[2]);
 VHVIR[4]=(float)pow((double)VHVIR[4],(double)VHVIR[5]);
 return ALGB1->koef[5]*(ALGB1->koef[0]*VHVIR[0]*VHVIR[1]+ALGB1->koef[2]*VHVIR[3]*VHVIR[4]+ALGB1->koef[4]*VHVIR[6]*VHVIR[7]);
}

float nar(a_fli *GB)
{
 digit *ptr_d;

// if(2>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(1>formuls1[ALGB1->form].n_inp)   return( FormErr(ALGB1,0));

 if(TYP!=DIGIT)return 1000000000.;
 if(ALGB1->inp[0].tip!=ANALOG)return 1.;

 ptr_d=PTR_C->d_ptr+NZ;

 if((ALGB1->koef[0] && VHVIR[0]<ALGB1->koef[0])||(ALGB1->koef[1] && VHVIR[0]>ALGB1->koef[1]))
  ptr_d->val_par=1;
 else
  ptr_d->val_par=0;
 return 1.;
}

float zad_n(a_fli *GB)
{
 digit *ptr_d;
 analog *p_a;
 float kk;

// if(5>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(4>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=DIGIT)return 1000000000.;
 if(ALGB1->inp[0].tip!=ANALOG)return 1000000000.;
 ptr_d=PTR_C->d_ptr+NZ;
 if(ptr_d->type_par!=5)return 1000000000.;

 if(VHVIR[0]==0.)
  {ptr_d->val_par=0;
   ptr_d->val_pr2=1;
  }
 else
 if(VHVIR[0]==100.)
  {ptr_d->val_pr2=0;
   ptr_d->val_par=1;
  }
 else ptr_d->val_par=ptr_d->val_pr2=0;

 if(ALGB1->inp[3].tip!=DIGIT)return 1.;
 if(((c_ptr+ALGB1->inp[3].nc)->d_ptr+ALGB1->inp[3].nz)->type_par!=2)return 1.;
 if(((c_ptr+ALGB1->inp[3].nc)->d_ptr+ALGB1->inp[3].nz)->val_par==0)
  {ptr_d->val_pr4=0;
   return 1.;
  }
 else ptr_d->val_pr4=1;

 if(ALGB1->inp[1].tip==ANALOG)
  {//VHVIR[1]=((c_ptr+ALGB1->inp[1].nc)->a_ptr+ALGB1->inp[1].nz)->var_tech;
   if((ALGB1->koef[0] && VHVIR[1] < ALGB1->koef[0]) || (ALGB1->koef[1] && VHVIR[1] > ALGB1->koef[1]))
    {ptr_d->dif_ot2=ptr_d->val_ot2=1;
     ptr_d->val_out=ptr_d->val_ot3=0;
    }
  }

 if(ALGB1->inp[2].tip==ANALOG)
  {VHVIR[2]=((c_ptr+ALGB1->inp[2].nc)->a_ptr+ALGB1->inp[2].nz)->var_tech;
   if((ALGB1->koef[2] && VHVIR[2] < ALGB1->koef[2]) || (ALGB1->koef[3] && VHVIR[2] > ALGB1->koef[3]))
    {ptr_d->dif_out=ptr_d->val_out=1;
     ptr_d->val_ot2=ptr_d->val_ot3=0;
    }
  }
//------

 p_a=(c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz;
 kk=p_a->var_tech;
 if(ptr_d->val_out)kk+=ALGB1->koef[4];
 if(ptr_d->val_ot2)kk-=ALGB1->koef[4];
 if(kk>100.)kk=100.;if(kk<0.)kk=0.;
 p_a->var_tech = rangeparm(p_a,kk);

 return 1.;
}

float vard(a_fli *GB)
{
// if(5>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(ALGB1->inp[0].tip!=DIGIT)return 1000000000.;
 if(((c_ptr+ALGB1->inp[0].nc)->d_ptr+ALGB1->inp[0].nz)->val_par==0)
  return VHVIR[1]*ALGB1->koef[0];
 else
  {if(VHVIR[6]*VHVIR[7]*ALGB1->koef[4]==0)return 1000000000.;
   else return ALGB1->koef[1]*(VHVIR[2]*VHVIR[3]*ALGB1->koef[2]+VHVIR[4]*VHVIR[5]*ALGB1->koef[3])/(VHVIR[6]*VHVIR[7]*ALGB1->koef[4]);
  }
}

float zap1(a_fli *GB)
{float per;
 analog *ptr_a;

// if(6>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(1>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=ANALOG)return 1000000000.;
 ptr_a=PTR_C->a_ptr+NZ;

 if(ALGB1->koef[5])per=ALGB1->koef[5];
 else per=1.;
 return ptr_a->var_tech*(1.-per*ALGB1->koef[0])+VHVIR[0]*per*ALGB1->koef[0];
}

float zap2(a_fli *GB)
{float kk;
 analog *ptr_a;

// if(1>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(1>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=ANALOG)return 1000000000.;
 ptr_a=PTR_C->a_ptr+NZ;

// kk=(PA->koef[0]+10.*VHVIR[0]);
// if(kk==0)return 1000000000.;
 if(ALGB1->koef[0]==0)return 1000000000.;
 kk=(100.+VHVIR[0])/100.;
 kk/=ALGB1->koef[0];
 return ptr_a->var_tech*(1.-kk)+VHVIR[0]*kk;
}

/*float pid(a_fli *GB)
{word_s ivir;
 float zad=0,ras=0,vih=0,vhod=0,vhod1=0,integ=0,difer=0;
 analog *ptr_a;

 if(TYP!=ANALOG)return 1000000000.;
 ptr_a=PTR_C->a_ptr+NZ;

 if(ALGB->vhod[5].tip==ANALOG)   // если программное задание

  ptr_a->set_cod=((c_ptr+ALGB->vhod[5].nc)->a_ptr+ALGB->vhod[5].nz)->var_cod;

 if(ptr_a->mod_cod!=R_MAN && ptr_a->mod_cod!=R_AUTO && ptr_a->mod_cod!=R_CAS)
  ptr_a->mod_cod=R_MAN;          // РУЧН

 if(ptr_a->mod_cod==R_CAS && ALGB->vhod[6].tip==EMPTY)
  ptr_a->mod_cod=R_AUTO;         //КАС->АВТ если нет ведущего


 for(ivir=1;ivir<5;ivir++)
  if(ALGB->vhod[ivir].tip==EMPTY)
   VHVIR[ivir]=0.;
  else
   VHVIR[ivir]=200.*(float)((c_ptr+ALGB->vhod[ivir].nc)->a_ptr+ALGB->vhod[ivir].nz)->var_cod/ADC_SC-100.;

 vhod=((c_ptr+ALGB->vhod[0].nc)->a_ptr+ALGB->vhod[0].nz)->var_tech;
 if(vhod<ptr_a->min_sc)vhod=ptr_a->min_sc;
 if(vhod>ptr_a->max_sc)vhod=ptr_a->max_sc;


 VHVIR[0]=100.*vhod/(ptr_a->max_sc-ptr_a->min_sc);

 if(ptr_a->mod_cod!=R_MAN)
  {if(ptr_a->mod_cod==R_CAS)      // каскад
    ptr_a->set_cod=((c_ptr+ALGB->vhod[6].nc)->a_ptr+ALGB->vhod[6].nz)->out_cod;

   zad=100.*ptr_a->set_cod/ADC_SC;
   vih=100.*ptr_a->out_cod/ADC_SC-ALGB->koef[13]; // старая пр+дф

   vhod=VHVIR[0]+ALGB->koef[0]*VHVIR[1]+ALGB->koef[1]*VHVIR[2];

   if(vhod>100.)vhod=100.;if(vhod<-100.)vhod=-100.;
   vhod1=ALGB->koef[2]*VHVIR[3]+ALGB->koef[3]*VHVIR[4];
   if(vhod1>100.)vhod1=100.;if(vhod1<-100.)vhod1=-100.;
   ras=vhod+vhod1-zad;
   if(ras>100.)ras=100.;if(ras<-100.)ras=-100.;

   if(fabs(ras)>ALGB->koef[8]/2)
    ras=-1.*(fabs(ras)-ALGB->koef[8]/2)*(ras/fabs(ras));
   else ras=0.;

   if(ALGB->koef[10])integ=PTR_C->period*ras/(ALGB->koef[10]*60.*HZ*PTR_C->baud);
   else            integ=0.;

   difer=ras-ALGB->koef[14];
   difer=(ALGB->koef[11]*difer*HZ*PTR_C->baud)/PTR_C->period;
   ALGB->koef[14]=ras;

   ALGB->koef[13]=ALGB->koef[9]*(ras+difer);
   vih+=ALGB->koef[13];
   if(vih>100.)ALGB->koef[13]-=(vih-100.);
   if(vih<0.)ALGB->koef[13]-=vih;

   vih+=ALGB->koef[9]*integ;

   if(vih>ALGB->koef[5])vih=ALGB->koef[5];if(vih<ALGB->koef[4])vih=ALGB->koef[4];
   ptr_a->out_cod=(word_s)(ADC_SC*vih/100.);

   if(ALGB->vhod[7].tip!=EMPTY && ((c_ptr+ALGB->vhod[7].nc)->a_ptr+ALGB->vhod[7].nz)->mod_cod!=R_CAS)
    ptr_a->out_cod=((c_ptr+ALGB->vhod[7].nc)->a_ptr+ALGB->vhod[7].nz)->set_cod;
  }
 else
  {ptr_a->set_cod=ptr_a->var_cod;
   ALGB->koef[13]=ALGB->koef[14]=0.;
   ptr_a->dif_cod=0.;
  }

 if(ALGB->vhod[0].tip==EMPTY)
  return 0.;
 else
  return ((c_ptr+ALGB->vhod[0].nc)->a_ptr+ALGB->vhod[0].nz)->var_tech;
}     */

//====================================================================
//= float pid_n(a_fli *GB)                                           =
//=  Пид регулятор                                                   =
//= Входы:                                                           =
//=  1 - Переменная                                                  =
//=  2 - Доп. вход 1                                                 =
//=  3 - Доп. вход 2                                                 =
//=  4 - Доп. вход 3                                                 =
//=  5 - Доп. вход 4                                                 =
//=  6 - Программное задание                                         =
//=  7 - Ведущий регулятор                                           =
//=  8 - Выход                                                       =
//= Коеффициенты:                                                    =
//=  1 - Масштабирующ. коеффициент входа 1                           =
//=  2 - Масштабирующ. коеффициент входа 2                           =
//=  3 - Масштабирующ. коеффициент входа 3                           =
//=  4 - Масштабирующ. коеффициент входа 4                           =
//=  5 - Минимальное значение выхода                                 =
//=  6 - Максимальное значение выхода                                =
//=  7 - Зона нечувствительности                                     =
//=  8 - Temp: для фильтра на входе                                  =
//=  9 - Free                                                        =
//=  10 - Коэффициент пропорциональности                             =
//=  11 - Время интегрирования (c)                                   =
//=  12 - Время диференцироввания (с)                                =
//=  13 - Время фильтра на входе (с)                                 =
//=  14 - Temp: для значения интеграла                               =
//=  15 - Temp: для значения дифференциала                           =
//====================================================================

float pid_n(a_fli *GB)
{
 int i;
 float zad=0.,ras=0.,vih=0.,vhod=0.,KInt,Kzdif,Dif,Kf;
 analog *ptr_a,*ptr_a1;

// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)   return( FormErr(ALGB1,0));

 if(TYP!=ANALOG )return 1000000000.;
 ptr_a=PTR_C->a_ptr+NZ;

 for(i=1;i<5;i++)
  if(ALGB1->inp[i].tip!=ANALOG) VHVIR[i]=0.;
  else
  {
   ptr_a1=(c_ptr+ALGB1->inp[i].nc)->a_ptr+ALGB1->inp[i].nz;
   VHVIR[i]= 100.*ptr_a1->var_tech/max(abs(ptr_a1->max_sc),abs(ptr_a1->min_sc));
  }

 if(ALGB1->inp[5].tip==ANALOG)   /* если программное задание */
 {
  ptr_a1=(c_ptr+ALGB1->inp[5].nc)->a_ptr+ALGB1->inp[5].nz;
  ptr_a->set_cod=100.*(ptr_a1->var_tech-ptr_a->min_sc)/(ptr_a->max_sc-ptr_a->min_sc);
 }
 if(ptr_a->mod_cod!=R_MAN && ptr_a->mod_cod!=R_AUTO && ptr_a->mod_cod!=R_CAS) ptr_a->mod_cod=R_MAN;  // РУЧН
 if(ptr_a->mod_cod==R_CAS)
 {
  if(ALGB1->inp[6].tip==EMPTY) ptr_a->mod_cod=R_AUTO; // КАС->АВТ если нет ведущего
  ptr_a->set_cod=((c_ptr+ALGB1->inp[6].nc)->a_ptr+ALGB1->inp[6].nz)->out_cod; // каскад
 }

 zad=100.*ptr_a->set_cod/ADC_SC;
 if(ALGB1->inp[0].tip!=ANALOG) VHVIR[0]=0.;
 else
 {
  ptr_a1=(c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz;
  VHVIR[0]=100.*(ptr_a1->var_tech-ptr_a->min_sc)/(ptr_a->max_sc-ptr_a->min_sc);
 }
//!!!
 if(ALGB1->inp[7].tip!=EMPTY && ptr_a->mod_cod!=R_MAN)
 {
  ptr_a1=(c_ptr+ALGB1->inp[7].nc)->a_ptr+ALGB1->inp[7].nz;
  if((word_s)(ADC_SC*ptr_a1->var_tech/100)!=ptr_a->out_cod)
  {
   ptr_a->out_cod=(word_s)(ADC_SC*ptr_a1->var_tech/100);
   ALGB1->koef[13]=ptr_a1->var_tech-ALGB1->koef[2]*VHVIR[3]-ALGB1->koef[3]*VHVIR[4]-ALGB1->koef[7];
   ALGB1->koef[14]=ALGB1->koef[7]; ptr_a->dif_cod=0.;
  }
 }
//!!!

 vhod=VHVIR[0]+ALGB1->koef[0]*VHVIR[1]+ALGB1->koef[1]*VHVIR[2];
 if(vhod >  100.) vhod=  100.;
 if(vhod < -100.) vhod= -100.;

 ras=zad-vhod;
 if((ras>0. && ras<ALGB1->koef[6]) || (ras<0. && ras > -ALGB1->koef[6])) ras=0.;
 if(ras> 0.) ras -= ALGB1->koef[6];
 if(ras< 0.) ras += ALGB1->koef[6];

 ras*=ALGB1->koef[9];
 if(ras>100.)ras= 100.;if(ras< -100.)ras= -100.;
 if(ALGB1->koef[12] > PTR_C->period/(HZ*PTR_C->baud)) Kf=   PTR_C->period/(ALGB1->koef[12]*HZ*PTR_C->baud);
 else                                                 Kf=   1.;
 ALGB1->koef[7]+=Kf*(ras - ALGB1->koef[7]);                        //Фильтр по входу

 if(ptr_a->mod_cod!=R_MAN)
 {
  if(ALGB1->koef[10] > PTR_C->period/(HZ*PTR_C->baud)) KInt= PTR_C->period/(ALGB1->koef[10]*HZ*PTR_C->baud);
  else                                                 KInt= 1.;
  if(ALGB1->koef[11] > PTR_C->period/(HZ*PTR_C->baud)) Kzdif=PTR_C->period/(ALGB1->koef[11]*HZ*PTR_C->baud);
  else                                                 Kzdif=1.;

//  ALGB->koef[7] += Kf*(ras - ALGB->koef[7]);
  ALGB1->koef[14]-=Kzdif * (ALGB1->koef[14]-ALGB1->koef[7]);        //Задержанный для диференциала
  Dif = ALGB1->koef[7]-ALGB1->koef[14];                             //Диференциал
  ALGB1->koef[13]+=KInt * ALGB1->koef[7];                           //Интегралл
  vih= (ALGB1->koef[7] + ALGB1->koef[13] + Dif);

  vih+=(ALGB1->koef[2]*VHVIR[3]+ALGB1->koef[3]*VHVIR[4]);

  if(vih > ALGB1->koef[5]){ vih=ALGB1->koef[5]; ALGB1->koef[13]=vih-ALGB1->koef[7]-Dif-(ALGB1->koef[2]*VHVIR[3]+ALGB1->koef[3]*VHVIR[4]);}
  if(vih < ALGB1->koef[4]){ vih=ALGB1->koef[4]; ALGB1->koef[13]=vih-ALGB1->koef[7]-Dif-(ALGB1->koef[2]*VHVIR[3]+ALGB1->koef[3]*VHVIR[4]);}

  ptr_a->out_cod=(word_s)(ADC_SC*vih/100.);

//Для каскада
  if(ALGB1->inp[6].tip!=EMPTY)
  {
   if(ptr_a->mod_cod==R_CAS)
   {
    ptr_a->set_cod=((c_ptr+ALGB1->inp[6].nc)->a_ptr+ALGB1->inp[6].nz)->out_cod;
//    ((c_ptr+ALGB->vhod[6].nc)->a_ptr+ALGB->vhod[6].nz)->mod_cod=R_AUTO;
   }
   else
   {
    ((c_ptr+ALGB1->inp[6].nc)->a_ptr+ALGB1->inp[6].nz)->out_cod=ptr_a->set_cod;
    ((c_ptr+ALGB1->inp[6].nc)->a_ptr+ALGB1->inp[6].nz)->mod_cod=R_MAN;
   }
  }
 }
 else
 {
  ALGB1->koef[13]=(100.0*(ptr_a->out_cod)/ADC_SC)-ALGB1->koef[2]*VHVIR[3]-ALGB1->koef[3]*VHVIR[4]-ALGB1->koef[7];
  ALGB1->koef[14]=ALGB1->koef[7]; ptr_a->dif_cod=0.;
 }

 if(ALGB1->inp[7].tip!=EMPTY)
 {
  ptr_a1=(c_ptr+ALGB1->inp[7].nc)->a_ptr+ALGB1->inp[7].nz;
  ptr_a1->var_tech = rangeparm(ptr_a1,100.0*ptr_a->out_cod/ADC_SC);
 }

 if(ALGB1->inp[0].tip==EMPTY) return 0.;
 else return ((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->var_tech;
}

float petl(a_fli *GB)
{
 analog *ptr_a;

// if(1>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(2>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=ANALOG)return 1000000000.;
 ptr_a=PTR_C->a_ptr+NZ;

 VHVIR[0]=ptr_a->var_tech;
 VHVIR[1]=100.0*((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->out_cod/ADC_SC;
 if(fabs(VHVIR[0]-VHVIR[1])<ALGB1->koef[0])return VHVIR[0];
 else
  if(VHVIR[0]>VHVIR[1])return VHVIR[1]+ALGB1->koef[0];
  else return VHVIR[1]-ALGB1->koef[0];
}

float im1(a_fli *GB)
{
// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(2>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 VHVIR[0]=ALGB1->koef[2]+VHVIR[0]*ALGB1->koef[3];
 if(VHVIR[0]==0. && ALGB1->koef[1] <= 0.)return 1000000000.;
 if(VHVIR[0] < 0. && ALGB1->koef[1] != ceil(ALGB1->koef[1]))return 1000000000.;
 VHVIR[0]=ALGB1->koef[0]*(float)pow((double)VHVIR[0],(double)ALGB1->koef[1]);
 if(ALGB1->koef[14] > 0. && ALGB1->koef[14] < 10.)
  VHVIR[1]=(float)(rand()%(word_s)(20.*ALGB1->koef[14]))/10.-ALGB1->koef[14];
 else VHVIR[1]=0;
 return VHVIR[0]+VHVIR[1];
}

float imzad(a_fli *GB)
{analog *ptr_a;
 float kk;

// if(1>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(1>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(TYP!=ANALOG)return 1000000000.;
 if(ALGB1->inp[0].tip!=DIGIT)return 1000000000.;

 ptr_a=PTR_C->a_ptr+NZ;
 if(((c_ptr+ALGB1->inp[0].nc)->d_ptr+ALGB1->inp[0].nz)->type_par!=5)return 1000000000.;
 kk=ptr_a->var_tech;
 if(((c_ptr+ALGB1->inp[0].nc)->d_ptr+ALGB1->inp[0].nz)->val_out)kk+=ALGB1->koef[0];
 if(((c_ptr+ALGB1->inp[0].nc)->d_ptr+ALGB1->inp[0].nz)->val_ot2)kk-=ALGB1->koef[0];
 if(kk>100.)kk=100.;if(kk<0.)kk=0.;
 return kk;
}

float es1(a_fli *GB)
{
 float tmp1;
// if(13>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(4>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 tmp1=VHVIR[1]*ALGB1->koef[0]*ALGB1->koef[5]*ALGB1->koef[10];
 if((GB->form1->tip==11&&VHVIR[0]<tmp1)||(GB->form1->tip==12&&VHVIR[0]>tmp1))
  return VHVIR[2]*ALGB1->koef[1]*ALGB1->koef[6]*ALGB1->koef[11];
 else
  return VHVIR[3]*ALGB1->koef[2]*ALGB1->koef[7]*ALGB1->koef[12];
}

float es5(a_fli *GB)
{
// if(7>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(2>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(VHVIR[0]>VHVIR[1])return VHVIR[1]+(VHVIR[0]-VHVIR[1])*ALGB1->koef[5];
 else                 return VHVIR[1]-(VHVIR[1]-VHVIR[0])*ALGB1->koef[6];
}

float es3(a_fli *GB)
{float tmp1,tmp2,tmp3,tmp4,tmp5;
// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(6>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 tmp1=VHVIR[1]*ALGB1->koef[0]*ALGB1->koef[5]*ALGB1->koef[10];
 tmp2=VHVIR[2]*ALGB1->koef[1]*ALGB1->koef[6]*ALGB1->koef[11];
 tmp3=VHVIR[3]*ALGB1->koef[2]*ALGB1->koef[7]*ALGB1->koef[12];
 tmp4=VHVIR[4]*ALGB1->koef[3]*ALGB1->koef[8]*ALGB1->koef[13];
 tmp5=VHVIR[5]*ALGB1->koef[4]*ALGB1->koef[9]*ALGB1->koef[14];
 if(tmp2<tmp1)return 1000000000.;
 if(VHVIR[0]<tmp1)return tmp3;
 else
  {if(VHVIR[0]<=tmp2)return tmp4;
   else return tmp5;
  }
}

float es4(a_fli *GB)
{
// if(14>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(5>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 switch((word_s)VHVIR[0])
  {case  1:return VHVIR[1]*ALGB1->koef[0]*ALGB1->koef[5]*ALGB1->koef[10];
   case  2:return VHVIR[2]*ALGB1->koef[1]*ALGB1->koef[6]*ALGB1->koef[11];
   case  3:return VHVIR[3]*ALGB1->koef[2]*ALGB1->koef[7]*ALGB1->koef[12];
   case  4:return VHVIR[4]*ALGB1->koef[3]*ALGB1->koef[8]*ALGB1->koef[13];
   default:return 1000000000.;
  }
}

float sym(a_fli *GB)
{
// if(12>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));
 return (ALGB1->koef[0]*VHVIR[0]+ALGB1->koef[1]*VHVIR[1]+ALGB1->koef[2]*VHVIR[2]+
         ALGB1->koef[5]*VHVIR[3]+ALGB1->koef[6]*VHVIR[4]+ALGB1->koef[7]*VHVIR[5]+
         ALGB1->koef[10]*VHVIR[6]+ALGB1->koef[11]*VHVIR[7]);
}

float ymn(a_fli *GB)
{
// if(6>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));
 if(VHVIR[2]==0. || VHVIR[3]==0. || VHVIR[6]==0. || VHVIR[7]==0.)return 1000000000.;
 if(!ALGB1->koef[0]) ALGB1->koef[0]=1.;
 return(ALGB1->koef[0]*ALGB1->koef[5]*VHVIR[0]*VHVIR[1]*VHVIR[4]*VHVIR[5])/(VHVIR[2]*VHVIR[3]*VHVIR[6]*VHVIR[7]);
}

float ymndl(a_fli *GB)
{
 float tmp1,tmp2,tmp3,tmp4;
// if(14>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 tmp1=VHVIR[6]*VHVIR[7]*ALGB1->koef[3]*ALGB1->koef[8]*ALGB1->koef[13];
 if(tmp1==0.)return 1000000000.;
 tmp2=VHVIR[0]*VHVIR[1]*ALGB1->koef[0]*ALGB1->koef[5]*ALGB1->koef[10];
 tmp3=VHVIR[2]*VHVIR[3]*ALGB1->koef[1]*ALGB1->koef[6]*ALGB1->koef[11];
 tmp4=VHVIR[4]*VHVIR[5]*ALGB1->koef[2]*ALGB1->koef[7]*ALGB1->koef[12];
 return tmp2*(tmp3+tmp4/tmp1);
}

float del(a_fli *GB)
{
 float tmp1,tmp2;
// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 tmp1=VHVIR[4]*VHVIR[5]*ALGB1->koef[2]*ALGB1->koef[7]*ALGB1->koef[12]+VHVIR[6]*VHVIR[7]*ALGB1->koef[3]*ALGB1->koef[8]*ALGB1->koef[13]+ALGB1->koef[14];
 if((VHVIR[4])==0.)return 1000000000.;
 tmp2=VHVIR[0]*VHVIR[1]*ALGB1->koef[0]*ALGB1->koef[5]*ALGB1->koef[10]+VHVIR[2]*VHVIR[3]*ALGB1->koef[1]*ALGB1->koef[6]*ALGB1->koef[11]+ALGB1->koef[9];
 return tmp2/tmp1;
}

float sdel(a_fli *GB)
{
// if(12>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(VHVIR[1]==0.||VHVIR[3]==0.||VHVIR[5]==0.||VHVIR[7]==0.)return 1000000000.;
 VHVIR[0]=VHVIR[0]*ALGB1->koef[0]*(ALGB1->koef[8]+ALGB1->koef[1]/VHVIR[1]);
 VHVIR[2]=VHVIR[2]*ALGB1->koef[2]*(ALGB1->koef[9]+ALGB1->koef[3]/VHVIR[3]);
 VHVIR[4]=VHVIR[4]*ALGB1->koef[4]*(ALGB1->koef[10]+ALGB1->koef[5]/VHVIR[5]);
 VHVIR[6]=VHVIR[6]*ALGB1->koef[6]*(ALGB1->koef[11]+ALGB1->koef[7]/VHVIR[7]);
 return VHVIR[0]+VHVIR[2]+VHVIR[4]+VHVIR[6];
}

float symn(a_fli *GB)
{
// if(12>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 VHVIR[0]=VHVIR[0]*ALGB1->koef[8]*(ALGB1->koef[1]+ALGB1->koef[0]*VHVIR[1]);
 VHVIR[2]=VHVIR[2]*ALGB1->koef[9]*(ALGB1->koef[3]+ALGB1->koef[2]*VHVIR[3]);
 VHVIR[4]=VHVIR[4]*ALGB1->koef[10]*(ALGB1->koef[5]+ALGB1->koef[4]*VHVIR[5]);
 VHVIR[6]=VHVIR[6]*ALGB1->koef[11]*(ALGB1->koef[7]+ALGB1->koef[6]*VHVIR[7]);
 return VHVIR[0]+VHVIR[2]+VHVIR[4]+VHVIR[6];
}


float xsy(a_fli *GB)
{
 float tmp1,tmp2,tmp3;
// if(14>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(8>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 tmp1=VHVIR[6]*VHVIR[7]*ALGB1->koef[3]*ALGB1->koef[8]*ALGB1->koef[13];
 if(tmp1==0.)return 1000000000.;
 tmp2=VHVIR[2]*VHVIR[3]*ALGB1->koef[1]*ALGB1->koef[6]*ALGB1->koef[11];
 tmp3=VHVIR[4]*VHVIR[5]*ALGB1->koef[2]*ALGB1->koef[7]*ALGB1->koef[12];
 tmp2=tmp2+tmp3/tmp1;
 tmp3=VHVIR[0]*VHVIR[1]*ALGB1->koef[0]*ALGB1->koef[5]*ALGB1->koef[10];
 if(tmp3==0. && tmp2 <= 0.)        return 1000000000.;
 if(tmp3 <0. && tmp2 != ceil(tmp2))return 1000000000.;
 return (float)pow((double)tmp3,(double)tmp2);
}

float esx(a_fli *GB)
{
 float tmp1,tmp2,tmp3;
// if(15>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(6>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 tmp1=VHVIR[4]*VHVIR[5]*ALGB1->koef[2]*ALGB1->koef[7]*ALGB1->koef[12]+ALGB1->koef[14];
 if(tmp1==0.)return 1000000000.;
 tmp2=VHVIR[0]*VHVIR[1]*ALGB1->koef[0]*ALGB1->koef[5]*ALGB1->koef[10];
 tmp3=VHVIR[2]*VHVIR[3]*ALGB1->koef[1]*ALGB1->koef[6]*ALGB1->koef[11]+ALGB1->koef[13];
 return (float)exp((double)(tmp2+tmp3/tmp1));
}

float komyt(a_fli *GB)
{float rez;word_s ivir;

// if(6>formuls1[ALGB1->form].n_koef) return( FormErr(ALGB1,1));
// if(6>formuls1[ALGB1->form].n_inp)  return( FormErr(ALGB1,0));

 if(ALGB1->inp[0].tip==EMPTY)return 1000000000.;
 for(ivir=5;ivir>0;ivir--)
  {if(ALGB1->inp[ivir].tip==EMPTY||!ALGB1->koef[ivir-1])continue;
   if(((c_ptr+ALGB1->inp[ivir].nc)->a_ptr+ALGB1->inp[ivir].nz)->var_tech>ALGB1->koef[ivir-1])
    {if(((c_ptr+ALGB1->inp[ivir].nc)->a_ptr+ALGB1->inp[ivir].nz)->novalid||
        ((c_ptr+ALGB1->inp[ivir].nc)->a_ptr+ALGB1->inp[ivir].nz)->no_uchet)return 1000000000.;
     return rez=((c_ptr+ALGB1->inp[ivir].nc)->a_ptr+ALGB1->inp[ivir].nz)->var_tech;
    }
  }
 if(!ivir)
  {if(((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->novalid||
      ((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->no_uchet)return 1000000000.;
   return rez=((c_ptr+ALGB1->inp[0].nc)->a_ptr+ALGB1->inp[0].nz)->var_tech;
  }
return 0.;
}
//---------- Свободная формула  -----------------
float free_formul(a_fli *GB)
{
// if(ALGB->subfunc > form_amount || ALGB->subfunc<0)return 0.;
// PTR_STR=formuls[ALGB->subfunc].f_ptr;
// LEN_STR=formuls[ALGB->subfunc].l_frm;
 PTR_STR=GB->form1->form_e;
 LEN_STR=GB->form1->l_frm1;

 FORM_OFFS=0; calk_form(GB,0,0);
 return VHVIR[256];
}

float calk_form(a_fli *GB, float rez,byte h_prior)
{
 int i,ii;
 dword oper;
 float parm=0,temp[10];
 byte b_form;                   //Текущий символ
 byte symb=0;                   //Предыдущая операция
 byte flow_prior=0;             //низкоприоритетной операции на высокоприоритетную
 byte tmb_b;

hom_f:;
 if(FORM_OFFS>LEN_STR-1) goto exit_f;    //Если конец строки
 b_form=PTR_STR[FORM_OFFS];
 if(b_form=='(')
   {FORM_OFFS++;
    if(symb) parm=calk_form(GB,0,0);
    else rez=calk_form(GB,0,0);
    goto hom_f;
   }
 if(b_form==')' || b_form==',' || b_form==';')
   {
exit_f:
    calk_oper(symb,&rez,parm);
    if(!h_prior&&b_form!=';') FORM_OFFS++;
    return rez;
   }
 if(b_form=='Y')                              //Вхыход
   {FORM_OFFS++;
    if(PTR_STR[FORM_OFFS]=='=')
//    {FORM_OFFS++; VHVIR[256]=calk_form(GB,0,0); FORM_OFFS++; goto hom_f;}
    {FORM_OFFS++; VHVIR[256]=calk_form(GB,0,0); Inp_set(-1,ALGB1,&VHVIR[256]); FORM_OFFS++; goto hom_f;}
    if(symb) parm=VHVIR[256]; else rez =VHVIR[256];
    goto hom_f;
   }
 if(b_form=='X')                              //Модифицируемые входы
   {
    oper=PTR_STR[++FORM_OFFS]; ++FORM_OFFS;
    if(PTR_STR[FORM_OFFS]=='='){FORM_OFFS++; VHVIR[oper]=calk_form(GB,0,0); Inp_set(oper,ALGB1,&VHVIR[oper]); FORM_OFFS++; goto hom_f;}
    if(PTR_STR[FORM_OFFS]=='('){FORM_OFFS++; VHVIR[oper]=calk_form(GB,0,0); Inp_set(oper,ALGB1,&VHVIR[oper]);}
    if(symb) parm=VHVIR[oper]; else rez =VHVIR[oper];
    goto hom_f;
   }
 if(b_form=='K')                              //Модифицируемые константы
   {
    oper=PTR_STR[++FORM_OFFS]; ++FORM_OFFS;
    if(PTR_STR[FORM_OFFS]=='='){FORM_OFFS++; ALGB1->koef[oper]=calk_form(GB,0,0); FORM_OFFS++; goto hom_f;}
    if(PTR_STR[FORM_OFFS]=='('){FORM_OFFS++; ALGB1->koef[oper]=calk_form(GB,0,0);}
    if(symb) parm=ALGB1->koef[oper]; else rez =ALGB1->koef[oper];
    goto hom_f;
   }
 if(b_form=='C')                              //Фиксированные константы
   {
    if(symb) parm= *(float *)(PTR_STR+(++FORM_OFFS));
    else rez= *(float *)(PTR_STR+(++FORM_OFFS));
    FORM_OFFS+=4; goto hom_f;
   }
//-----------------------

 if(b_form=='&' || b_form=='|')                 {i=5;  goto m1;}
 if(b_form=='>' || b_form=='<' || b_form=='~')  {i=10; goto m1;}
 if(b_form=='+' || b_form=='-')                 {i=15; goto m1;}
 if(b_form=='*' || b_form=='/')                 {i=20; goto m1;}
 if(b_form=='^')
 {i=25;
m1:
  if(!symb) {symb=b_form;flow_prior=i;++FORM_OFFS; goto hom_f;}
  if(flow_prior==i){calk_oper(symb,&rez,parm); symb=b_form; ++FORM_OFFS; goto hom_f;}
  if(flow_prior> i)
  {calk_oper(symb,&rez,parm);
   if(h_prior) return rez;
   flow_prior=i;
   symb=b_form;
   ++FORM_OFFS;
   goto hom_f;
  }
  if(flow_prior < i) { parm=calk_form(GB,parm,1); goto hom_f; }
 }
// if(b_form==' '||b_form==0x0D||b_form==0x0A){++FORM_OFFS; goto hom_f;}
//            ---- Дополнительные операции ----
 oper=*(dword *)(PTR_STR+FORM_OFFS);
 if((oper&0x0000FFFF) =='ip')                  //pi
 { FORM_OFFS+=2; if(symb) parm=3.14159256; else rez=3.14159256; goto hom_f; }
 if((oper&0x00FFFFFF) =='krb'){ FORM_OFFS=LEN_STR; goto exit_f;}   //brk
 if((oper&0x00FFFFFF) =='qrf')                 //frq
     {
      FORM_OFFS+=3;
      if(symb) parm=(PTR_C->baud*HZ)/PTR_C->period;
      else     rez= (PTR_C->baud*HZ)/PTR_C->period;
      goto hom_f;
     }
 if(oper =='(pxe')                             //exp()
     {
      FORM_OFFS+=4;
      if(symb) parm=exp(calk_form(GB,0,0));
      else     rez=exp(calk_form(GB,0,0));
      goto hom_f;
     }
 if(oper =='(sba')                             //abs()
     {
      FORM_OFFS+=4;
      if(symb) parm=fabs(calk_form(GB,0,0));
      else     rez=fabs(calk_form(GB,0,0));
      goto hom_f;
     }
 if(oper =='(gis')                             //sig()
     {
      FORM_OFFS+=4;
      temp[0]= calk_form(GB,0,0);
      if(temp[0]>=0.) temp[0]=1.0; else temp[0]=-1.0;
      if(symb) parm=temp[0]; else rez= temp[0];
      goto hom_f;
     }
 if(oper =='(soc')                             //cos()
     {
      FORM_OFFS+=4;
      if(symb) parm=cos(calk_form(GB,0,0));
      else     rez=cos(calk_form(GB,0,0));
      goto hom_f;
     }
 if((oper&0x00FFFFFF) =='(nl')                       //ln()
     {
      FORM_OFFS+=3;
      if(symb) parm=log(calk_form(GB,0,0));
      else     rez=log(calk_form(GB,0,0));
      goto hom_f;
     }
 if(oper =='(nis')                             //sin()
     {
      FORM_OFFS+=4;
      if(symb) parm=sin(calk_form(GB,0,0));
      else     rez=sin(calk_form(GB,0,0));
      goto hom_f;
     }
 if(oper =='(dnr')                             //sin()
     {
      FORM_OFFS+=4;
      if(symb) parm=((float)rand()/(float)RAND_MAX)*calk_form(GB,0,0);
      else     rez=(float)((float)rand()/(float)RAND_MAX)*calk_form(GB,0,0);
      goto hom_f;
     }
 if(oper =='(xam')                             //sin()
     {
      FORM_OFFS+=4;
      temp[1]=calk_form(GB,0,0); temp[2]=calk_form(GB,0,0);
      if(symb) parm= max(temp[1],temp[2]);
      else     rez= max(temp[1],temp[2]);
      goto hom_f;
     }
 if(oper =='(nim')                             //sin()
     {
      FORM_OFFS+=4;
      temp[1]=calk_form(GB,0,0); temp[2]=calk_form(GB,0,0);
      if(symb) parm= min(temp[1],temp[2]);
      else     rez= min(temp[1],temp[2]);
      goto hom_f;
     }
 if(oper =='(gsm')                             //msg()
     {
      FORM_OFFS+=4;
      temp[9]=calk_form(GB,0,0);
      for(;PTR_STR[FORM_OFFS]!='"';FORM_OFFS++);
      for(i=0,FORM_OFFS++;FORM_OFFS+i<=LEN_STR-1;i++)
       if(PTR_STR[FORM_OFFS+i]=='"')
        {strncpy(buf_glb,PTR_STR+FORM_OFFS,i); FORM_OFFS+=i; buf_glb[i]=0; i=0; break; }
      for(FORM_OFFS++;FORM_OFFS<=LEN_STR-1;FORM_OFFS++)
      {
       if(PTR_STR[FORM_OFFS]==','||PTR_STR[FORM_OFFS]==')')
       {
        FORM_OFFS++; ii=0;
        while(PTR_STR[FORM_OFFS-1]==',') {temp[ii]=calk_form(GB,0,0); ii++;}
        sprintf(srv_mes.mess,buf_glb,temp[0],temp[1],temp[2],temp[3],temp[4],temp[5]);
        srv_mes.tip_mes=temp[9]; s_mes();
//        if(temp[9] == 1.)      eprintf(RED_,buf_glb,temp[0],temp[1],temp[2],temp[3],temp[4],temp[5]);
//        else if(temp[9] == 2.) eprintf(YELLOW_,buf_glb,temp[0],temp[1],temp[2],temp[3],temp[4],temp[5]);
//        else if(temp[9] == 3.) mesprintf(RED_,buf_glb,temp[0],temp[1],temp[2],temp[3],temp[4],temp[5]);
        if(symb) parm= 0.; else rez= 0.;
        goto hom_f;
       }
      }
     }
 if((oper&0x00FFFFFF) =='(fi')                             //if()  :
     {
      FORM_OFFS+=3;
      if(calk_form(GB,0,0) > 0)
      {
       if(symb) parm=calk_form(GB,0,0);
       else rez=calk_form(GB,0,0);
       if(PTR_STR[FORM_OFFS-1]==')'){FORM_OFFS--;goto hom_f;}
       if(FORM_OFFS>LEN_STR-1)goto hom_f;
       i=0;
       while(FORM_OFFS<=LEN_STR-1)
       {tmb_b=PTR_STR[FORM_OFFS];
        if(tmb_b=='K' || tmb_b=='X')FORM_OFFS+=1;
        if(tmb_b=='C') FORM_OFFS+=4;
        if(tmb_b=='(') i++;
        if(tmb_b==')') {i--;if(i== -1){FORM_OFFS++;goto hom_f;}}
        if(tmb_b=='"') for(FORM_OFFS++;(FORM_OFFS<=LEN_STR-1)&&PTR_STR[FORM_OFFS]!='"';FORM_OFFS++);
        FORM_OFFS++;
       }
       goto hom_f;
      }
      i=0;
      while(FORM_OFFS<=LEN_STR-1)
      {tmb_b=PTR_STR[FORM_OFFS];
       if(tmb_b=='K' || tmb_b=='X')FORM_OFFS+=1;
       if(tmb_b=='C') FORM_OFFS+=4;
       if(tmb_b=='(') i++;
       if(tmb_b==')') {i--;if(i== -1)goto hom_f;}
       if(tmb_b==',' && !i)
       {
        FORM_OFFS++;
        if(symb) parm=calk_form(GB,0,0);
        else rez=calk_form(GB,0,0);
        goto hom_f;
       }
       if(tmb_b=='"') for(FORM_OFFS++;(FORM_OFFS<=LEN_STR-1)&&PTR_STR[FORM_OFFS]!='"';FORM_OFFS++);
       FORM_OFFS++;
      }
      goto hom_f;
     }
 return 0.;
}
//--------------------------------------------------------------
void calk_oper(byte symb,float *rez,float parm)
{
  if(symb=='+'){ *rez +=parm; return;}
  if(symb=='-'){ *rez -=parm; return;}
  if(symb=='*'){ *rez *=parm; return;}
  if(symb=='/'){ *rez /=parm; return;}
  if(symb=='^'){ *rez=pow(*rez,parm); return;}
  if(symb=='>'){ if(*rez >parm)*rez=1;else *rez=0; return;}
  if(symb=='<'){ if(*rez <parm)*rez=1;else *rez=0; return;}
  if(symb=='~'){ if(*rez==parm)*rez=1;else *rez=0; return;}
  if(symb=='&'){ *rez=*rez &&parm; return;}
  if(symb=='|'){ *rez=*rez ||parm; return;}
}

int Inp_set(word_s ind,alg_str *alg,float *val)
{
 word_s val1;
 char *str;
 analog *ptr_a;
 digit *ptr_d;

 if(ind<0)
  if(alg->tip==ANALOG)
  {
   ptr_a=(c_ptr+alg->nc)->a_ptr+alg->nz;
   ptr_a->var_tech = rangeparm(ptr_a,*val); ptr_a->novalid=0;
   return 0;
  }
  else
  {
   ptr_d=(c_ptr+alg->nc)->d_ptr+alg->nz;
   ((c_ptr+alg->nc)->d_ptr+alg->nz)->val_par/*val_out*/ = *val; return 0;
  }

 if(ind>formuls1[alg->form].n_inp)
 {
  if(alg->tip==ANALOG) str = ((c_ptr+alg->nc)->a_ptr+alg->nz)->cipher;
  else                 str = ((c_ptr+alg->nc)->d_ptr+alg->nz)->cipher;
  eprintf(GRAY_,"В %s, входов более чем установлено",str);
  return 0;
 }

 if(alg->inp[ind].tip==ANALOG)
 {
  ptr_a=(c_ptr+alg->inp[ind].nc)->a_ptr+alg->inp[ind].nz;
  if((c_ptr+alg->inp[ind].nc)->typcontr!=VIRT)
  {
     *val=rangeparm(ptr_a,*val);
//new!!!
     val1=(float)ADC_SC*(*val - ptr_a->min_sc)/(ptr_a->max_sc-ptr_a->min_sc)+0.5;
     if(val1<0)            { val1 = 0 ;     ptr_a->novalid=1; }
     else if(val1 > ADC_SC){ val1 = ADC_SC; ptr_a->novalid=1; }
//new!!!
     if(!SetAnalogVal(c_ptr+alg->inp[ind].nc,ptr_a,val1)) return(0);
     else return(-1);
  }
  else { *val=ptr_a->var_tech=rangeparm(ptr_a,*val); ptr_a->novalid=0; return 0; }
 }
 if(alg->inp[ind].tip==DIGIT)
 {
  ptr_d=(c_ptr+alg->inp[ind].nc)->d_ptr+alg->inp[ind].nz;
     if((c_ptr+alg->inp[ind].nc)->typcontr!=VIRT)
     {
       if(!SetDigVal(c_ptr+alg->inp[ind].nc,ptr_d,*val)) return(0);
       else return(-1);
     }
     else { ((c_ptr+alg->inp[ind].nc)->d_ptr+alg->inp[ind].nz)->val_par/*val_out*/ = *val; return(0); }
 }
 return 0;
}

float FormErr(alg_str *alg,char opt)
{
 char *str;

 if(alg->tip==ANALOG) str = ((c_ptr+alg->nc)->a_ptr+alg->nz)->cipher;
 else                 str = ((c_ptr+alg->nc)->d_ptr+alg->nz)->cipher;
 if(opt) eprintf(GRAY_,"В %s, коэффициентов более чем установлено",str);
 else    eprintf(GRAY_,"В %s, входов более чем установлено",str);
 return(1000000000.);
}

//---------- Обработчик ошибок в математических функциях -------
int matherr1(struct exception *err)
{
 if(err->type==DOMAIN){eprintf(RED_,StrMesVirt[0],cur_alg);return(1);}
 if(err->type==SING){eprintf(RED_,StrMesVirt[1],cur_alg);return(1);}
 if(err->type==OVERFLOW){eprintf(RED_,StrMesVirt[2],cur_alg);return(1);}
 if(err->type==UNDERFLOW){eprintf(RED_,StrMesVirt[3],cur_alg);return(1);}
 if(err->type==TLOSS){eprintf(RED_,StrMesVirt[4],cur_alg);return(1);}
 if(err->type==PLOSS){eprintf(RED_,StrMesVirt[5],cur_alg);return(1);}
 eprintf(RED_,StrMesVirt[6],err->type,cur_alg);

 return(1);
}
//******************* Для изображения регулятора ****************************
int Get_info_contrVIRT(controller *p_c, analog *p_a,int n_mess,rec_info_reg *info_reg)
{
 if(n_mess==0)
 {info_reg->color=CYAN_; info_reg->str=4; info_reg->col=2; sprintf(info_reg->string,StrMesVirt[8],p_a->nomin_var+1); }
 else if(n_mess==1)
 {info_reg->color=WHITE_; info_reg->str=6; info_reg->col=2; sprintf(info_reg->string,StrMesVirt[9],p_c->nomcontr); }
 else return(-1);
 return(0);
}
//-------------------------------------------------------------------
int set_kfVIRT(controller *p_c, analog *p_a, word_s nom_kf, float valk)
{
 (p_alg1+p_a->nomin_var)->koef[st_kf[nom_kf].index] = valk;
 return(0);
}
//-----------------------------------------------------------------
void insert_VIRT(controller *ctr,int n_contr,char *Basa,int mode)
{
 char str[256];

 if(mode==InsContr)
 {
  GetFieldItDbf(Basa,n_contr,"SPEED",str); (ctr+n_contr)->baud=atoi(str);
 }
}
//------------------ Инициализация VIRT ------------------------------
void enable_VIRT()
{
 dword k,ofs_alg;
 word_s i,ii,iii,ld_zap,ld_contr,ld_tip;
 controller *ptr_c;
 analog *ptr_a;
 digit *ptr_d;
 byte len_1;
 int fh,n_2=0,n_3=0;
 char str_ptr1[25],str_ptr2[10],*str1,*str2;

  regpar *aptr;
  digpar *dptr;
  regpar regp;
  digpar digp;
  aptr=(regpar *)&regp;
  dptr=(digpar *)&digp;

//---------------------- Новая загрузка alg_stat.cfg вместо param.reg и param.dig
  if((fh=sopen(NameFile[23],O_BINARY|O_RDONLY,SH_DENYNO))!=-1)
  {
   read(fh,(char *)&k,4);
   if(!(k%sizeof(regpar)))
    if(!((filelength(fh)-k-4)%sizeof(digpar)))
    {
     for(i=0;i<k/sizeof(regpar);i++)
     {
      read(fh,aptr,sizeof(regpar));
      for(ii=0,ptr_c=c_ptr;ii<c_num;ii++,ptr_c++)
       for(iii=0,ptr_a=ptr_c->a_ptr;iii<ptr_c->num_ap;iii++,ptr_a++)
        if(ptr_a->type_mech!=M_INP)                                 //!!
         if(!strncmp(aptr->cipher,ptr_a->cipher,9))
         {ptr_a->var_tech=aptr->var_tech;
          ptr_a->var_cod=aptr->var_cod;
          ptr_a->set_cod=aptr->set_cod;
          ptr_a->dif_cod=aptr->dif_cod;
          ptr_a->out_cod=aptr->out_cod;
          if(ptr_a->type_mech)ptr_a->mod_cod=aptr->mod_cod;
          ptr_a->novalid=aptr->novalid;
          ptr_a->bound_reg=aptr->bound_reg;
          ptr_a->bound_al=aptr->bound_al;
          goto next_an;
         }
      next_an:;
     }
     for(i=0;i<(filelength(fh)-k-4)/sizeof(digpar);i++)
     {
      read(fh,dptr,sizeof(digpar));
      for(ii=0,ptr_c=c_ptr;ii<c_num;ii++,ptr_c++)
       for(iii=0,ptr_d=ptr_c->d_ptr;iii<ptr_c->num_dp;iii++,ptr_d++)
        if(!strncmp(dptr->cipher,ptr_d->cipher,9))
         {ptr_d->val_par=dptr->val_par;
          ptr_d->val_pr2=dptr->val_pr2;
          ptr_d->val_pr3=dptr->val_pr3;
          ptr_d->val_pr4=dptr->val_pr4;
          ptr_d->val_out=dptr->val_out;
          ptr_d->val_ot2=dptr->val_ot2;
          ptr_d->val_ot3=dptr->val_ot3;
          goto next_dig;
         }
      next_dig:;
     }
    }
   close(fh);
  }

//---------------  NEW  -----------------------------------------------------------------
 if((fh=open_fh(alg_conf1,0)) == -1) return;
 read(fh,&ofs_alg,4); read(fh,&form_am1,2);
 formuls1=(frm_str *)calloc(form_am1,sizeof(frm_str));
 for(iii=0;iii<form_am1;iii++)
 {
  read(fh,&len_1,1);
  formuls1[iii].name=(char *)calloc(1,len_1+1);
  read(fh,formuls1[iii].name,len_1); formuls1[iii].name[len_1]=0;
  read(fh,&formuls1[iii].tip,1);
  read(fh,&formuls1[iii].n_inp,1); read(fh,&formuls1[iii].n_koef,1);
  formuls1[iii].name_inp=(char **)calloc(formuls1[iii].n_inp, sizeof(char **));
  for(ii=0;ii<formuls1[iii].n_inp;ii++)
  {
   read(fh,&len_1,1);
   formuls1[iii].name_inp[ii]=(char *)calloc(len_1+1,1);
   read(fh,formuls1[iii].name_inp[ii],len_1); formuls1[iii].name_inp[ii][len_1]=0;
  }
  formuls1[iii].name_kf=(char **)calloc(formuls1[iii].n_koef,sizeof(char **));
  for(ii=0;ii<formuls1[iii].n_koef;ii++)
  {
   read(fh,&len_1,1);
   formuls1[iii].name_kf[ii]=(char *)calloc(len_1+1,1);
   read(fh,formuls1[iii].name_kf[ii],len_1); formuls1[iii].name_kf[ii][len_1]=0;
  }
  read(fh,&formuls1[iii].l_frm,2);
  formuls1[iii].formul = (char *)calloc(formuls1[iii].l_frm+1,1);
  read(fh,formuls1[iii].formul,formuls1[iii].l_frm);
  formuls1[iii].formul[formuls1[iii].l_frm]=0;
  if(formuls1[iii].tip==5)
  {
   str1=formuls1[iii].formul;
   str2=formuls1[iii].form_e = (char *)calloc(formuls1[iii].l_frm,1);
   for(i=0,n_2=0;i<formuls1[iii].l_frm;i++)
   {
    if(*(word *)(str1+i) =='//'){for(;(i<formuls1[iii].l_frm && str1[i]!=0x0D);i++); continue;}
    if(str1[i]=='"')
    { str2[n_2++]=str1[i++];
      for(;i<formuls1[iii].l_frm;i++,n_2++)
      { str2[n_2]=str1[i]; if(str1[i]=='"') {str2[n_2++]=str1[i]; break;} } continue;
    }
    if(str1[i]==' '||str1[i]=='\x0D'||str1[i]=='\x0A') continue;
    if(str1[i]=='K'||str1[i]=='X'){ str2[n_2]=str1[i];i++;n_2++;str2[n_2]=str1[i]; n_2++; continue;}
    if(str1[i]=='C') {str2[n_2]=str1[i];i++;n_2++; *(float*)(str2+n_2)=*(float*)(str1+i);i+=3;n_2+=4;continue;}
    str2[n_2]=str1[i];n_2++;
   }
   if(n_2!=formuls1[iii].l_frm) formuls1[iii].form_e=(char *)realloc(formuls1[iii].form_e,n_2);
   formuls1[iii].l_frm1=n_2;
  }
 }

 lseek(fh,0,SEEK_SET); lseek(fh,ofs_alg,SEEK_SET);
 read(fh,&k_alg1,2);
 p_alg1=(alg_str *)calloc(k_alg1,sizeof(alg_str));
 for(i=0;i<k_alg1;i++)
 {
  read(fh,str_ptr1,9); str_ptr1[9]=0;
//   -------------
  ld_tip=ChekNamePasport(str_ptr1,&ld_contr,&ld_zap);
  if(ld_tip==-1)eprintf(GRAY_,StrMesVirt[13],str_ptr1);
  if(ld_tip==-2)eprintf(GRAY_,StrMesVirt[14],str_ptr1);
  if(ld_tip==EMPTY)eprintf(GRAY_,StrMesVirt[15]);
  if(ld_tip==ANALOG)((c_ptr+ld_contr)->a_ptr+ld_zap)->nomin_var=i;
  if(ld_tip==DIGIT) ((c_ptr+ld_contr)->d_ptr+ld_zap)->nom_var=i+1;
  p_alg1[i].nc=ld_contr;p_alg1[i].tip=ld_tip;p_alg1[i].nz=ld_zap;       //!!!!!!!!!!!!!!!!!
//   -------------
  read(fh,&len_1,1); p_alg1[i].disript=(char *)calloc(len_1+1,1);
  read(fh,p_alg1[i].disript,len_1);
  read(fh,&p_alg1[i].form,2);

  n_2=formuls1[p_alg1[i].form].n_inp;

  p_alg1[i].inp = calloc(n_2,sizeof(*p_alg1[i].inp));
  for(ii=0;ii<n_2;ii++)
  {
   read(fh,str_ptr2,9);
//    ------------  NEW ------------------------------------------------
   ld_tip=ChekNamePasport(str_ptr2,&ld_contr,&ld_zap);
   if(ld_tip==-1)
   {
    eprintf(GRAY_,StrMesVirt[16],str_ptr2,str_ptr1);
    p_alg1[i].inp[ii].nc=0;p_alg1[i].inp[ii].tip=EMPTY;p_alg1[i].inp[ii].nz=0;
    continue;
   }
   if(ld_tip==-2)
   {
    eprintf(GRAY_,StrMesVirt[17],str_ptr2,str_ptr1);
    p_alg1[i].inp[ii].nc=0;p_alg1[i].inp[ii].tip=EMPTY;p_alg1[i].inp[ii].nz=0;
    continue;
   }
   p_alg1[i].inp[ii].nc=ld_contr;p_alg1[i].inp[ii].tip=ld_tip;p_alg1[i].inp[ii].nz=ld_zap;       //!!!!!!!!!!!!!!!!!
//    ------------
  }
  n_3=formuls1[p_alg1[i].form].n_koef;
  p_alg1[i].koef = calloc(n_3,sizeof(*p_alg1[i].koef));
  for(ii=0;ii<n_3;ii++) read(fh,&p_alg1[i].koef[ii],4);
 }
 close(fh);
}

//------------------------- Выключение контролеров VIRT -------------
void disable_VIRT()
{
  digit *ptr_d;
  analog *ptr_a;
  controller *ptr_c;
  word_s i,ii,j,fh,tmp;
  dword counter,ofs_alg;

//  koef_alg *p_alg1;
//  algobl *p_alg2;
  regpar regp;
  digpar digp;
  regpar *aptr;
  digpar *dptr;
  aptr=(regpar *)&regp;
  dptr=(digpar *)&digp;

  if(!model_save) return;

//------------------------ Не очень новое сохранение alg_stat.cfg вместо param.reg и param.dig
  fh=sopen(NameFile[23],O_BINARY|O_RDWR|O_CREAT|O_TRUNC,SH_DENYNO,S_IWRITE);
  lseek(fh,4,SEEK_SET);                                 //сдвиг на смещение на дискретных параметров
  for(i=0,counter=0,ptr_c=c_ptr;i<c_num;i++,ptr_c++)
   for(j=0,ptr_a=ptr_c->a_ptr;j<ptr_c->num_ap;j++,ptr_a++)
    if(ptr_a->type_mech!=M_INP)                //!!
    {
      aptr->var_tech=ptr_a->var_tech;
      aptr->var_cod=ptr_a->var_cod;
      aptr->set_cod=ptr_a->set_cod;
      aptr->dif_cod=ptr_a->dif_cod;
      aptr->out_cod=ptr_a->out_cod;
      aptr->mod_cod=ptr_a->mod_cod;
      aptr->novalid=ptr_a->novalid;
      aptr->bound_reg=ptr_a->bound_reg;

      aptr->bound_al=ptr_a->bound_al;
      aptr->cipher[0]='\0';
      strcat(aptr->cipher,ptr_a->cipher);
      write(fh,(char *)aptr,sizeof(regpar));
      counter+=sizeof(regpar);
    }
    else sav_parm(ptr_a);                //??????
  for(i=0,ptr_c=c_ptr;i<c_num;i++,ptr_c++)
   for(j=0,ptr_d=ptr_c->d_ptr;j<ptr_c->num_dp;j++,ptr_d++)
     {dptr->val_par=ptr_d->val_par;
      dptr->val_pr2=ptr_d->val_pr2;
      dptr->val_pr3=ptr_d->val_pr3;
      dptr->val_pr4=ptr_d->val_pr4;
      dptr->val_out=ptr_d->val_out;
      dptr->val_ot2=ptr_d->val_ot2;
      dptr->val_ot3=ptr_d->val_ot3;
      dptr->cipher[0]='\0';
      strcat(dptr->cipher,ptr_d->cipher);
      write(fh,(char *)dptr,sizeof(digpar));
     }
  lseek(fh,0,SEEK_SET);
  write(fh,(char *)&counter,4);
  close(fh);

//----------------------------------  NEW  ------------------------------------

 fh=sopen(alg_conf1,O_BINARY|O_RDWR,SH_DENYNO,S_IWRITE);
 lseek(fh,0,SEEK_SET); read(fh,&ofs_alg,4);
 lseek(fh,ofs_alg-4,SEEK_CUR);
 read(fh,&tmp,2);

 for(i=0;i<k_alg1;i++)
 {
  lseek(fh,9,SEEK_CUR);
  read(fh,&tmp,1);
  lseek(fh,(byte)tmp,SEEK_CUR);
  lseek(fh,2,SEEK_CUR);
  lseek(fh,formuls1[p_alg1[i].form].n_inp*9,SEEK_CUR);
  for(ii=0;ii<formuls1[p_alg1[i].form].n_koef;ii++) write(fh,&p_alg1[i].koef[ii],4);
 }
 close(fh);
}
//-------------------------------------------------------------
word_s ChekNamePasport(char *str,word_s *nc,word_s *nz)
{
 word_s i,ii,tip;
 controller *ptr_c;
 analog *ptr_a;
 digit *ptr_d;
 char numb_found=0;

 if(str[0]==0x20){ *nc=0;*nz=0;return(EMPTY);}
 for(i=0,ptr_c=c_ptr;i<c_num;i++,ptr_c++)
 {
  for(ii=0,ptr_a=ptr_c->a_ptr;ii<ptr_c->num_ap;ii++,ptr_a++)
   if(!memcmp(str,ptr_a->cipher,9)){ numb_found++; *nc=i; *nz=ii;tip=0;}
  for(ii=0,ptr_d=ptr_c->d_ptr;ii<ptr_c->num_dp;ii++,ptr_d++)
   if(!memcmp(str,ptr_d->cipher,9)){ numb_found++; *nc=i;*nz=ii;tip=1;}
 }
 if(numb_found>1)return(-2);
 if(!numb_found)return(-1);
 return(tip);
}

int get_kfVIRT(controller *p_c, analog *p_a,void **koef)
{
 int i,n;
 n=sizeof(st_kf)/sizeof(rec_koeff);
 for(i=0; i < n; i++)
  if(p_a->nomin_var>=0) st_kf[i].znach = (p_alg1+p_a->nomin_var)->koef[st_kf[i].index];//(p_alg+p_a->nomin_var)->koef[st_kf[i].index];
  else st_kf[i].znach = 0.;
 *koef=st_kf;
 return(n);
}

//-------------------- Установка дискретного параметра ----------------------------
int SetDigVal_VIRT(controller *ctr, digit *p_d,int val)
{
 p_d->val_par=val; return(0);
}
//-------------------- Установка аналогового параметра ----------------------------
int SetAnalogVal_VIRT(controller *ctr, analog *p_a,int val)
{
 p_a->var_cod=val;
 p_a->var_tech=valtec(p_a,p_a->var_cod);
 return(0);
}

void DelSpace(char *str,char len)
{
 int iii;
 for(iii=len-1;iii>=0;iii--)
  if(str[iii]==' ')str[iii]=0;
  else break;
}