dps2spc3.c

profibus TO RS485 profibus TO RS485

/*~
includes and declarations
~*/
/* formal declaratios for spc3dps2.h */
#define SPC3_DPS2             1
#define SPC3_INTEL_MODE       1
#define SPC3_DATA_XDATA
#define SPC3_FAR

#include "spc3dps2.h"

/*~
literals and macros
~*/
   /*
   +------------------------------------------------------------------------+
   |                           L i t e r a l s                              |
   +------------------------------------------------------------------------+
   */
   /*-- cout of buffers assigned to AUX-buffer --*/
#define ASS_AUX_BUF                            3
   /*-- masks for config-data --*/
#define DPS_CFG_IS_BYTE_FORMAT          (UBYTE)0x30
#define DPS_CFG_BF_LENGTH               (UBYTE)0x0f
#define DPS_CFG_LENGTH_IS_WORD_FORMAT   (UBYTE)0x40
#define DPS_CFG_BF_INP_EXIST            (UBYTE)0x10
#define DPS_CFG_BF_OUTP_EXIST           (UBYTE)0x20
#define DPS_CFG_SF_OUTP_EXIST           (UBYTE)0x80
#define DPS_CFG_SF_INP_EXIST            (UBYTE)0x40
#define DPS_CFG_SF_LENGTH               (UBYTE)0x3f

   /*
   +------------------------------------------------------------------------+
   |                             M a c r o s                                |
   +------------------------------------------------------------------------+
   */
   /*-- startaddress of user-area in the SPC3 in SPC3-format --*/
#define SPC3_BUF_START ((UBYTE)(((UWORD)(dps2_base_ptr -\
			 (UBYTE SPC3_PTR_ATTR*)&spc3)) >> 3))

/*~
Variables
~*/
   /*
   +------------------------------------------------------------------------+
   |                g l o b a l     V a r i a b l e s                       |
   +------------------------------------------------------------------------+
    UBYTE _dps2_x;              /* dummy-byte */

   /*
   +------------------------------------------------------------------------+
   |          "M o d u l" - g l o b a l   V a r i a b l e s                 |
   +------------------------------------------------------------------------+
   */
   static DPS2_BUFINIT dps2_binit;       /* storeage for initialization data */
   static WORD dps2_buf_len = 0;         /* used bufferspace */
   static UBYTE SPC3_PTR_ATTR *dps2_base_ptr =\
				(UBYTE SPC3_PTR_ATTR*)0; /* buffer base address */
   static DPS2_IO_DATA_LEN io_data_len;  /* Struct. f. IO-lens */

   /*
   +------------------------------------------------------------------------+
   |               e x t e r n a l   D e c l a r a t i o n s                |
   +------------------------------------------------------------------------+
   */
#ifndef _IM182
   extern SPC3 SPC3_PTR_ATTR spc3;
#endif

/*~
assign_aux_buf()
~*/

   UWORD assign_aux_buf(UBYTE SPC3_DATA_ATTR *lens, UBYTE count, UBYTE
   SPC3_DATA_ATTR *assign, WORD SPC3_DATA_ATTR *aux_len)
   {
	  UBYTE pos[ASS_AUX_BUF];     /* storage for former position of lens    */
	  UBYTE lensx[ASS_AUX_BUF];   /* working-array for calculated lens      */
	  UBYTE step;                 /* counter for done step                  */
	  UBYTE lx;                   /* temp-var for lenarray-sorting          */
	  UBYTE px;                   /* temp-var dor position-sorting          */
	  UWORD min_len = 0xffff;     /* calculated min-len                     */
	  UBYTE min_step = 0;         /* step at reached min-len                */
	  BYTE i,j;

	  if((count < 2) || (count > ASS_AUX_BUF))
	  {
		 return 0;
	  }
	  /* init position-array */
	  for(i = 0; i < count; i++)
	  {
		 pos[i] = i;
	  }
	  /* init working-array */
	  for(i = 0; i < count; i++)
	  {
		 lensx[i] = lens[i];
	  }
	  /* round up lens to SPC3-lens (8-byte-granularity) */
	  for(i = 0; i < count; i++)
	  {
		 lensx[i] = (lensx[i] + 7) & 0xf8;
	  }
	  /* sorting of lens: gratest len to index 0 */
	  for(i = 0; i < count-1; i++)
	  {
		 for(j = i+1; j < count; j++)
		 {
			if(lensx[i] < lensx[j])
			{
			   /* greater len found */
			   lx = lensx[i];          /* xchg lens */
			   lensx[i] = lensx[j];
			   lensx[j] = lx;
			   px = pos[i];            /* xchg position */
			   pos[i] = pos[j];
			   pos[j] = px;
			}
		 }
	  }
	  /* remove NULL-lens of list */
	  for(i = count-1; i >= 0; i--)
	  {
		 if(lensx[i] == 0)
		 {
			count--;
		 }
	  }
	  if(count == 0)
	  {
		 min_len = 0;     /* error: no lens specified */
	  }
	  /* stepwise assignment to the AUX-buffers */
	  for(step = 0; step < count; step++)
	  {
		 /* determine total len for AUX-buffer 1 */
		 aux_len[0] = 0;

		 for(i = step; i < count; i++)
		 {
			if(aux_len[0] < lensx[i])
			{
			   aux_len[0] = lensx[i];
			}
		 }
		 aux_len[0] = aux_len[0] * (count - step + 1);
		 /* determine total len for AUX-buffer 2 */
		 aux_len[1] = 0;

		 for(i = 0; i < step; i++)
		 {
			if(aux_len[1] < lensx[i])
			{
			   aux_len[1] = lensx[i];
			}
		 }
		 aux_len[1] = aux_len[1] * (step + 1);

		 if((aux_len[0] + aux_len[1]) < min_len)
		 {
			/* neue Minimal-Laenge gefunden */
			min_len = aux_len[0] + aux_len[1];
			min_step = step;
		 }
	  }

	  /*  calculation of len for AUX-buffer 1 */
	  aux_len[0] = 0;

	  for(i = min_step; i < count; i++)
	  {
		 if(aux_len[0] < lensx[i])
		 {
			aux_len[0] = lensx[i];
		 }
	  }
	  /*  setup lens for AUX-buffer 1 */
	  for(i = min_step; i < count; i++)
	  {
		 lens[pos[i]] = aux_len[0];
	  }
	  /*  calculation of len for AUX-buffer 2 */
	  aux_len[1] = 0;

	  for(i = 0; i < min_step; i++)
	  {
		 if(aux_len[1] < lensx[i])
		 {
			aux_len[1] = lensx[i];
		 }
	  }
	  /*  setup lens for AUX-buffer 2 */
	  /*  setup assignment-list */
	  *assign = 0;    /* initial all buffers assigned to AUX-buffer 1 */

	  for(i = 0; i < min_step; i++)
	  {
		 lens[pos[i]] = aux_len[1];
		 *assign |= 0x1 << pos[i];
	  }
	  return min_len;
   }
   /* Ende assign_aux_buf */

/*~
dps2_calculate_inp_outp_len()
~*/
  /*****************************************************
//  函数名：dps2_calculate_inp_outp_len          	//
//  软件名称及版本： 1.0				        //
//  系统/模块名称：  Profibus从站			        //
//  编写工程师：    Schmidt Xaver（SIMENS demo）	        //
//  编写及完成日期：2001-12-20     			//
//  最后修改日期与修改人：唐铭山			        //
//  引用或继承的函数名：					//
//  简单功能与实现方法描述：				 //
//  传递参数列表：					 //
//  调用者名称：						//
//  被调用者名称：					 //
********************************************************/
   DPS2_IO_DATA_LEN SPC3_DATA_ATTR *dps2_calculate_inp_outp_len (UBYTE
   SPC3_PTR_ATTR* cfg_ptr, UWORD cfg_len)
   {
	  UBYTE temp_inp_data_len;
	  UBYTE temp_outp_data_len;
	  UBYTE length;
	  UBYTE count;
	  UBYTE specific_data_length;
	  UBYTE result_ok;

	  result_ok = TRUE;
	  temp_inp_data_len  = 0;
	  temp_outp_data_len = 0;

	  if ((cfg_len >  0) && (cfg_len <= dps2_binit.cfg_buf_len))
	  {
		 for ( ; (cfg_len > 0) && result_ok; cfg_len -= count)
		 {
			count = 0;

			if (*cfg_ptr & DPS_CFG_IS_BYTE_FORMAT)
			{
			   count++;

			   /* cfg_ptr points to ID-byte, CFG_BF means "CFG_IS_BYTE_FORMAT" */
			   length = (UBYTE)( (*cfg_ptr & DPS_CFG_BF_LENGTH) + 1);

			   if (*cfg_ptr & DPS_CFG_LENGTH_IS_WORD_FORMAT)
			   {
				  length *= 2;
			   }
			   if (*cfg_ptr & DPS_CFG_BF_OUTP_EXIST)
			   {
				  temp_outp_data_len = temp_outp_data_len + length;
			   }
			   if (*cfg_ptr & DPS_CFG_BF_INP_EXIST)
			   {
				  temp_inp_data_len = temp_inp_data_len + length;
			   }
			   cfg_ptr++;
			}
			else
			{
			   /* cfg_ptr points to the headerbyte of special ID-format */
			   /* CFG_SF means "CFG_IS_SPECIAL_FORMAT" */
			   if (*cfg_ptr & DPS_CFG_SF_OUTP_EXIST)
			   {
				  count++;                /* next byte contains the length of ou
										  tp_data */
				  length = (UBYTE)((*(cfg_ptr + count) & DPS_CFG_SF_LENGTH) +1
				  );

				  if (*(cfg_ptr + count) & DPS_CFG_LENGTH_IS_WORD_FORMAT)
				  {
					 temp_outp_data_len = temp_outp_data_len + (UBYTE)(2*length
					 );
				  }
				  else
				  {
					 temp_outp_data_len = temp_outp_data_len + length;
				  }
			   }
			   if (*cfg_ptr & DPS_CFG_SF_INP_EXIST)
			   {
				  count++;                /* next byte contains the length of in
										  p_data */
				  length = (UBYTE)((*(cfg_ptr + count) & DPS_CFG_SF_LENGTH) +1
				  );

				  if (*(cfg_ptr + count) & DPS_CFG_LENGTH_IS_WORD_FORMAT)
				  {
					 temp_inp_data_len = temp_inp_data_len + (UBYTE)(2*length);
				  }
				  else
				  {
					 temp_inp_data_len = temp_inp_data_len + length;
				  }
			   }
			   specific_data_length = (UBYTE)(*cfg_ptr & DPS_CFG_BF_LENGTH);

			   if (specific_data_length != 15)
			   {
				  count = (UBYTE)(count + 1 + specific_data_length);
				  cfg_ptr = cfg_ptr + count;
			   }
			   else
			   {
				  result_ok = FALSE;
			   }
			}
		 }

		 if ( (cfg_len != 0) ||
				(
				(((UWORD)temp_inp_data_len + 7) & 0xfff8 +
				((UWORD)temp_outp_data_len + 7) & 0xfff8)
				> dps2_binit.din_dout_buf_len) )
		 {
			result_ok = FALSE;
		 }
	  }