com_sub.cpp

《WinCE.NET嵌入式工业用控制器及自动控制系统设计》的源代码

	   rc= check_alarm(1, Reg.AO_SOFT[i], Reg.AO_L[addr], Reg.AO_DEAD[addr], Reg.AO_SOFT[i], 0.0);
	   bytes= addr/8;
	   bitno= addr%8;
	   Coil_Bit_Write(&Coil.AO_L[bytes], bitno, rc);

	   rc= check_alarm(1, Reg.AO_SOFT[i], Reg.AO_LL[addr], Reg.AO_DEAD[addr], Reg.AO_SOFT[i], 0.0);
	   bytes= addr/8;
	   bitno= addr%8;
	   Coil_Bit_Write(&Coil.AO_LL[bytes], bitno, rc);
   }
}
/*...........................................................................*/
/* calcluation timer table                                            */
/*...........................................................................*/
void calc_timer(int nsec)
{
   int i, bytes, bitno;

   for(i=0; i<CT_MAX_CASE; i++)
   {
	   if(Reg.TM_PSET[i]==0) continue;  // no use
//	   else if(Reg.TM_CURR[i]<=0) continue;  // no ues
	   else if(Reg.TM_CURR[i]>=0 && Reg.TM_CURR[i]<Reg.TM_PSET[i])  // dureing timing
	   {
		   Reg.TM_CURR[i]= Reg.TM_CURR[i] + nsec;
	   }
	   else if(Reg.TM_CURR[i]>= Reg.TM_PSET[i])  // timer up
	   {
		   bytes= i/8;
		   bitno= i%8;
		   Coil_Bit_Write(&Coil.TM_BIT[bytes], bitno, 1);
	   }
   }

   return;
}
/*...........................................................................*/
/* calcluation counter table                                            */
/*...........................................................................*/
void calc_counter(int case_no)
{
   int i, bytes, bitno;

   i= case_no;
   if(Reg.CN_PSET[i]==0) return;  // no use
   else if(Reg.CN_CURR[i]>=0 && Reg.CN_CURR[i]<Reg.CN_PSET[i])  // during counting
   {
	   Reg.CN_CURR[i]= Reg.CN_CURR[i] + 1;
   }

   if(Reg.CN_CURR[i]>= Reg.CN_PSET[i])  // counter up
   {
	   bytes= i/8;
	   bitno= i%8;
	   Coil_Bit_Write(&Coil.CN_BIT[bytes], bitno, 1);
   }

   return;
}
/*...........................................................................*/
/* set timer value                                                           */
/*...........................................................................*/
void set_timer_start(int case_no, short value)
{
   int addr;

   addr= case_no;
   Reg.TM_PSET[addr]= value;
//   Reg.TM_CURR[addr]= 1;  // initial value
   Reg.TM_CURR[addr]= 0;
   return;
}
/*...........................................................................*/
/* set counter value                                                         */
/*...........................................................................*/
void set_counter_start(int case_no, short value)
{
   int addr;

   addr= case_no;
   Reg.CN_PSET[addr]= value;   
   Reg.CN_CURR[addr]= 0;
   return;
}
/*...........................................................................*/
/* check timer up                                                            */
/*...........................................................................*/
int check_timer_up(int case_no)
{
  int bytes, bitno, dd;

  bytes= case_no/8;
  bitno= case_no%8;
  dd= Coil_Bit_Read(&Coil.TM_BIT[bytes], bitno);

  return(dd);
}
/*...........................................................................*/
/* check counter up                                                          */
/*...........................................................................*/
int check_counter_up(int case_no)
{
  int bytes, bitno, dd;

  bytes= case_no/8;
  bitno= case_no%8;
  dd= Coil_Bit_Read(&Coil.CN_BIT[bytes], bitno);

  return(dd);
}
/*...........................................................................*/
/* timer reset                                                               */
/*...........................................................................*/
void timer_reset(int case_no)
{
   int addr, bytes, bitno;      

   addr= case_no;
   Reg.TM_CURR[addr]= 0;     // reset timer current value
   bytes= addr/8;
   bitno= addr%8;
   Coil_Bit_Write(&Coil.TM_BIT[bytes], bitno, 0); // reset Timer contact bit
   
   return;
}
/*...........................................................................*/
/* counter reset                                                             */
/*...........................................................................*/
void counter_reset(int case_no)
{
  int addr, bytes, bitno;

  addr= case_no;
  Reg.CN_CURR[addr]= 0;      // reset Counter current value
  bytes= addr/8;
  bitno= addr%8;
  Coil_Bit_Write(&Coil.CN_BIT[bytes], bitno, 0);

  return;
}
/*...........................................................................*/
/* calcluation plus ON/OFF                                            */
/*...........................................................................*/
void calc_plus_onoff(void)
{
	int i;
	unsigned char *cptr_1, *cptr_2, *cptr_3, *cptr_4; 
	unsigned char data_1, data_2;

	cptr_1= Coil.DI_BARE;
	cptr_2= Coil.DI_OLD;
	cptr_3= Coil.DI_PLON;
	cptr_4= Coil.DI_PLOFF;
	for(i=0; i<DI_MAX_PLUS_BYTE; i++)
	{
		data_1= *(cptr_1+i);
		data_2= *(cptr_2+i);
		*(cptr_3+i)= (data_2 ^ data_1) & data_1;  // plus ON
		*(cptr_4+i)= (data_2 ^ data_1) & data_2;  // plus OFF
	}

	cptr_1= Coil.DO_BARE;
	cptr_2= Coil.DO_OLD;
	cptr_3= Coil.DO_PLON;
	cptr_4= Coil.DO_PLOFF;
	for(i=0; i<DO_MAX_PLUS_BYTE; i++)
	{
		data_1= *(cptr_1+i);
		data_2= *(cptr_2+i);
		*(cptr_3+i)= (data_1 ^ data_2) & data_1;  // plus ON
		*(cptr_4+i)= (data_1 ^ data_2) & data_2;  // plus OFF
	}

}
/*...........................................................................*/
/* bare data to eng. data                                            */
/*...........................................................................*/
float bare_to_eng(float eng, float bare, float rh, float rl, float bh, float bl, float fl)
{
	float val;

	val= bare;
	if( (bh - bl)==0.0) val= 0.0;
	else val= (bare-bl)/(bh-bl);
	if(val<0)  val= 0.0;   // cut minus value
	if(val>1.0) val= 1.0;  // cut over 100%

	val= val*(rh-rl) + rl; // convert to eng. data

	// first order filter
	if(fl>0 && fl<1.0)
		val= (float)(val*fl + eng*(1.0 - fl));

	return(val);
}
/*...........................................................................*/
/* eng. data to bare data                                            */
/*...........................................................................*/
float eng_to_bare(float eng, float bare, float rh, float rl, float bh, float bl)
{
	float val;

	val= eng;
	if( (rh - rl)==0.0) val= 0.0;
	else val= (eng-rl)/(rh-rl);
	if(val<0)  val= 0.0;   // cut minus value
	if(val>1.0) val= 1.0;  // cut over 100%

	val= val*(bh-bl) + bl; // convert to eng. data

	return(val);
}
/*...........................................................................*/
/* check alarm limit                                            */
/*...........................................................................*/
int check_alarm(int type, float eng, float alm, float band, float rh, float rl)
{
	int rc;
	float fl;

	rc= 0;
	if(type==0)  // HH or H alarm
	{
		if(eng >alm) rc=1;
		else  // recover check
		{
			fl= rh - rl;
			if(fl<0.0)  fl= (float)(fl * (-1.0));
			fl= band * fl;  // dead band value
			if( eng<= (alm-band)) rc=0;  // alarm recover
		}
	}
	else if(type==1) // LL or L ALarm
	{
		if(eng <alm) rc=1;
		else  // recover check
		{
			fl= rh - rl;
			if(fl<0.0)  fl= (float)(fl * (-1.0));
			fl= band * fl;  // dead band value
			if( eng>= (alm+band)) rc=0;  // alarm recover
		}
	}

	return(rc);
}
/*...........................................................................*/
/* Read System Table                                            */
/*...........................................................................*/
int read_sys_table()
{
  HANDLE  hFile;
  DWORD   llen, pos;
  CString msg;

  hFile= CreateFile(DEMO_SYS_TBL, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
  if(hFile == INVALID_HANDLE_VALUE)
  {
	msg.Format(_T("Can't open System file: "));
	msg= msg + DEMO_SYS_TBL;
	AfxMessageBox(msg, MB_OK);
	return(-1);
  }
  else
  {
	  llen= 0;
	  llen= GetFileSize(hFile, NULL);
	  pos= sizeof(Reg) + sizeof(Coil) + sizeof(MB_PORT) + sizeof(MB_UNIT) +sizeof(PARA_IO)+sizeof(MIX_UNIT);
	  if(pos != llen)
	  {
		  msg.Format(_T("The system file size[%d] is not correct[original:%d]\n"), llen, pos);
		  msg= msg + DEMO_SYS_TBL;
	 	  AfxMessageBox(msg, MB_OK);
		  return(-1);
	  }
	  msg.Format(_T("Open System file OK: "));
	  msg= msg + DEMO_SYS_TBL;
 	  AfxMessageBox(msg, MB_OK);
	  ReadFile(hFile, (char *)&Reg, sizeof(Reg), &llen, 0);
	  ReadFile(hFile, (char *)&Coil, sizeof(Coil), &llen, 0);
	  ReadFile(hFile, (char *)&MB_PORT, sizeof(MB_PORT), &llen, 0);
	  ReadFile(hFile, (char *)MB_UNIT, sizeof(MB_UNIT), &llen, 0);
	  ReadFile(hFile, (char *)PARA_IO, sizeof(PARA_IO), &llen, 0);
	  ReadFile(hFile, (char *)MIX_UNIT, sizeof(MIX_UNIT), &llen, 0);
  }

  CloseHandle(hFile);
  return(0);
}
/*...........................................................................*/
/* set initial TAG                                            */
/*...........................................................................*/
void set_initial_TAG(void)
{
	int i, j;

   for(i=0; i<ED_MAX; i++)
   {
	   Reg.AI_ENG[i]= Reg.AI_INIT[i];
	   Reg.AO_ENG[i]= Reg.AO_INIT[i];
   }

   for(i=0; i<ED_MAX*4; i++)
   {
	   j= i+ED_MAX;
	   Reg.AI_SOFT[i]= Reg.AI_INIT[j];
	   Reg.AO_SOFT[i]= Reg.AO_INIT[j];
   }

   for(i=0; i<DD_MAX_BYTE; i++)
   {
	   Coil.DI_BARE[i]= Coil.DI_INIT[i];
	   Coil.DO_BARE[i]= Coil.DO_INIT[i];
   }

   for(i=0; i<DD_MAX_BYTE*2; i++)
   {
	   j= i+DD_MAX_BYTE;
	   Coil.DI_SOFT[i]= Coil.DI_INIT[j];
	   Coil.DO_SOFT[i]= Coil.DO_INIT[j];
   }

}
/****************************************************************************/
/*   initial Queue index                                                   */
/****************************************************************************/
int  que_initial(int *r_idx, int *w_idx)
{

   *r_idx= 0;
   *w_idx= 0;
   return(0);
}

/****************************************************************************/
/*   reset Queue data file index                                           */
/****************************************************************************/
int  que_reset(int *r_idx, int *w_idx)
{

   *r_idx= *w_idx;
   return(0);
}
/****************************************************************************/
/*   save  Queue one record data                                           */
/****************************************************************************/
int  que_save(char *qptr, char *data, int rec_len, int max_rec,
              int *r_idx, int *w_idx)
{
   int pos;

   pos= (*w_idx) * rec_len;
   memcpy(qptr+pos, data, rec_len);
   *w_idx= (*w_idx) + 1;
   if( *w_idx >= max_rec) *w_idx= 0;

// discard the first in record(the oldest), when queue is over
   if(*w_idx == *r_idx)
    {
      *r_idx= *r_idx +1;
      if(*r_idx >= max_rec) *r_idx=0;
    }
    return(0);
}
/****************************************************************************/
/*   read  Queue data First In First Out (FIFO)                            */
/****************************************************************************/
int  que_FIFO_read(char *qptr, char *data, int rec_len, int r_idx, int w_idx, int rec_no, int max_rec)
{
   int pos, idx;

   idx= r_idx + rec_no;
   if(idx >=max_rec) idx= idx - max_rec;
   if(idx == w_idx ) return(QUEUE_NO_DATA);
   pos= idx * rec_len;

   memcpy(data, qptr+pos, rec_len);
   return(0);

}
/****************************************************************************/
/*   read  Queue data Last In First Out (LIFO)                             */
/****************************************************************************/
int  que_LIFO_read(char *qptr, char *data, int rec_len, int r_idx, int w_idx, int rec_no, int max_rec)
{
   int pos, idx;


   idx= w_idx - rec_no;
   if(idx < 0) idx= idx + max_rec ;
   if(idx == w_idx ) return(QUEUE_NO_DATA);
   pos= idx * rec_len;

   memcpy(data, qptr+pos, rec_len);
   return(0);
}
/****************************************************************************/
/*   del. Queue data First In First Out (FIFO) record                     */
/****************************************************************************/
int  que_FIFO_del(int max_rec, int *r_idx, int *w_idx)
{

   if(*r_idx == *w_idx ) return(QUEUE_NO_DATA);

   *r_idx= *r_idx +1;
   if(*r_idx >= max_rec) *r_idx=0;

   return(0);
}
/****************************************************************************/
/*   del. Queue data Last In First Out (LIFO) record                      */
/****************************************************************************/
int  que_LIFO_del(int *r_idx, int *w_idx)
{

   if(*r_idx == *w_idx ) return(QUEUE_NO_DATA);
   *w_idx= *w_idx -1;
   if(*w_idx < 0) *w_idx=0;

   return(0);
}
/*...........................................................................*/
/* initial local ICP  module                                                 */
/*...........................................................................*/
int initial_local(void)
{
  int i, temp, slot, module, chnl, gain, mode, m, rc, addr, bytes, bitno;
  CString  msg;
  char string1[20];
  float  fl;

//  msg.Format(_T("PARA_IO: %d %d"), PARA_IO[0].mod_no, PARA_IO[1].mod_no);
//  AfxMessageBox(msg, MB_OK);

  // check I/O Module is corect or not  
  rc= 0;
  for(i=0; i<SLOT_MAX_CASE; i++)
  {
      if(PARA_IO[i].mod_no == 0) continue;  // empty slot
	  slot= i+1;
	  memset(string1, 0 , sizeof(string1));
	  temp=GetNameOfModule(slot, string1);
	  switch(temp)
	  {
	  case 40:
		  if(PARA_IO[i].mod_no != I8040)
		  {
			  rc= -1;
			  msg.Format(_T("Slot-%d is not define I-8040 Module"), slot);
			  AfxMessageBox(msg, MB_OK);
		  }
		  break;
	  case 41:
		  if(PARA_IO[i].mod_no != I8041)
		  {
			  rc= -1;
			  msg.Format(_T("Slot-%d is not define I-8041 Module"), slot);
			  AfxMessageBox(msg, MB_OK);
		  }
		  break;
	  case 42:
		  if(PARA_IO[i].mod_no != I8042)
		  {
			  rc= -1;
			  msg.Format(_T("Slot-%d is not define I-8042 Module"), slot);
			  AfxMessageBox(msg, MB_OK);
		  }
		  break;
	  case 51:
		  if(PARA_IO[i].mod_no != I8051)
		  {
			  rc= -1;
			  msg.Format(_T("Slot-%d is not define I-8051 Module"), slot);
			  AfxMessageBox(msg, MB_OK);
		  }
		  break;
	  case 52: