mmsavar.c

ICCP Toolkit 是在 Tru64下开发Tase.2通信协议的开发包

      naddr[1] = (ST_UCHAR)'\000';
      naddr[2] = (ST_UCHAR)'\000';
      naddr[3] = (ST_UCHAR)'\000';
      if (data_entered = input_hex ((naddr), 4))
	{
	na = (ST_UCHAR *) &info->addr.num_addr;
	na += 3;
	for (i = 0; i < 4; i++)
	  *(na--) = naddr [i];
	}
      break;

    case  (SYM_ADDR) :
      printf (" Enter Symbolic Address : (R) ");
      info->addr.sym_addr = nxt_buf;
      if (data_entered = strget (info->addr.sym_addr))
	nxt_buf += (strlen (info->addr.sym_addr) + 1);
      break;

    case  (UNCON_ADDR) :
      info->addr.unc_addr.unc_ptr = (ST_UCHAR *)nxt_buf;
      if (len = get_var_data ("Unconstrained Address",info->addr.unc_addr.unc_ptr))
	{
	data_entered = SD_TRUE;
	info->addr.unc_addr.unc_len = len;
	nxt_buf += len;
	}
      else
	data_entered = SD_FALSE;
      break;
    }
  return ((ST_BOOLEAN) data_entered);
  }

/************************************************************************/
/*			get_vaspec					*/
/* get variable access specification from operator			*/
/************************************************************************/

ST_BOOLEAN get_vaspec (VAR_ACC_SPEC *info, ST_BOOLEAN get_alt_acc)
  {
ST_BOOLEAN data_entered;
ST_INT num;
VARIABLE_LIST *vl_ptr;

  printf ("   (0:List of Variables, 1:Variable List Name)");
  printf ("\n Enter Variable Access Specification choice (default = 0) : ");
  num = VAR_ACC_VARLIST;
  intget (&num);
  if ((num != VAR_ACC_VARLIST) && (num != VAR_ACC_NAMEDLIST))
    num = VAR_ACC_VARLIST;

  info->var_acc_tag = num;

  if (info->var_acc_tag == VAR_ACC_VARLIST)
    {
    vl_ptr = (VARIABLE_LIST *) (info + 1);
    data_entered = get_var_list (vl_ptr, &info->num_of_variables, get_alt_acc);
    }
  else
    data_entered = get_objname (&info->vl_name);

  return (data_entered);
  }

/************************************************************************/
/*			get_var_list					*/
/* get variable access variable list from operator			*/
/************************************************************************/

ST_BOOLEAN get_var_list (VARIABLE_LIST *vl_ptr, ST_INT *num_of_vars,
			 ST_BOOLEAN get_alt_acc )
  {
ST_BOOLEAN data_entered;
ST_BOOLEAN done;
ST_INT len;

  *num_of_vars = 0;
  done = SD_FALSE;
  while (!done)
    {
    data_entered = get_var_spec (&vl_ptr->var_spec);

    if (data_entered)
      {
#if 1
      if (get_alt_acc && ask ("\n Do you want Alternate Access for this Variable (y,n) (default = n) : ", SD_FALSE))
        {
        vl_ptr->alt_access.data = (ST_UCHAR *)nxt_buf;
        nxt_buf[0] = (ST_CHAR) 0x81;
        nxt_buf[1] = (ST_CHAR) 0x01;
        nxt_buf[2] = (ST_CHAR) 0x7a;
        len = 3;
        nxt_buf += len;
        vl_ptr->alt_access.len  = len;
        vl_ptr->alt_access_pres = SD_TRUE;
#if 0
//      if (len = get_var_data ("Alternate Access", vl_ptr->alt_access.data))
//        {
//        vl_ptr->alt_access_pres = SD_TRUE;
//        vl_ptr->alt_access.len  = len;
//        nxt_buf += len;
//        }
//      else
//        vl_ptr->alt_access_pres = SD_FALSE;
#endif
        }
      else
        vl_ptr->alt_access_pres = SD_FALSE;
#else
      vl_ptr->alt_access_pres = SD_FALSE;
#endif
      }

    if (data_entered)
      {
      (*num_of_vars)++;
      vl_ptr++;
      }
    else
      {
      done = SD_TRUE;
      data_entered = SD_TRUE;			/* list of zero or more */
      }
    }
  
  return (data_entered);
  }

/************************************************************************/
/*			get_var_spec					*/
/* get variable specification from operator				*/
/************************************************************************/

ST_BOOLEAN get_var_spec (VARIABLE_SPEC *vs_ptr)
  {
ST_BOOLEAN data_entered;
ST_INT num;
ST_INT len;


  printf ("\n   (0:Name, 1:Address, 2:Description, 3:Scat Access, 4:Inval)");
  printf ("\n Enter List of Variables choice, or RETURN to end List : ");
  num = 5;
  intget (&num);

  if (num == VA_SPEC_NAMED       ||
      num == VA_SPEC_ADDRESSED   ||  
      num == VA_SPEC_DESCRIBED   || 
      num == VA_SPEC_SCATTERED   || 
      num == VA_SPEC_INVALIDATED)
    {
    vs_ptr->var_spec_tag = num;
    }
  else
    num = 5;

  switch (num)
    {
    case  (VA_SPEC_NAMED) :
      data_entered = get_objname (&vs_ptr->vs.name);
      break;

    case  (VA_SPEC_ADDRESSED) :
      data_entered = get_address (&vs_ptr->vs.address);
      break;

    case  (VA_SPEC_DESCRIBED) :
      printf (" Variable Description : \n");
      data_entered = get_address (&vs_ptr->vs.var_descr.address);
      if (data_entered)
        {
        vs_ptr->vs.var_descr.type.data = (ST_UCHAR *)nxt_buf;
        if (len = get_var_data ("Type Specification",
			vs_ptr->vs.var_descr.type.data))
          {
          vs_ptr->vs.var_descr.type.len = len;
          nxt_buf += len;
          }
        else
          data_entered = SD_FALSE;
        }
      break;

    case  (VA_SPEC_SCATTERED) :
      vs_ptr->vs.sa_descr.data = (ST_UCHAR *)nxt_buf;
      if (len = get_var_data ("Scattered Access", vs_ptr->vs.sa_descr.data))
        {
        data_entered = SD_TRUE;
        vs_ptr->vs.sa_descr.len = len;
        nxt_buf += len;
        }
      else
        data_entered = SD_FALSE;
      break;

    case  (VA_SPEC_INVALIDATED) :
      data_entered = SD_TRUE;
      break;

    case  (5) :
      data_entered = SD_FALSE;
      break;
    }

  return (data_entered);
  }

/************************************************************************/
/*			get_acc_rslt					*/
/************************************************************************/

ST_BOOLEAN get_acc_rslt (ACCESS_RESULT *dest)
  {
ST_BOOLEAN data_entered;
ST_INT num;
ST_INT	code;
ST_INT len;

  printf ("\n   (0:Failure, 1:Success)");
  printf ("\n Enter Access Result (default = 1) :");
  num = ACC_RSLT_SUCCESS;
  intget (&num);
  if ((num == ACC_RSLT_SUCCESS) || (num == ACC_RSLT_FAILURE))
    dest->acc_rslt_tag = num;
  else
    num = ACC_RSLT_SUCCESS;

  switch (num)
    {
    case (ACC_RSLT_FAILURE) :
      printf (" Enter Failure Code (default = 0) :");
      code = 0;
      intget (&code);
      dest->failure = code;
      data_entered = SD_TRUE;
      break;

    case (ACC_RSLT_SUCCESS) :
      dest->va_data.data = (ST_UCHAR *)nxt_buf;
      if (len = get_var_data ("Data", dest->va_data.data))
	{
	data_entered = SD_TRUE;
	dest->va_data.len = len;
	nxt_buf += len;
	}
      else
	data_entered = SD_FALSE;
      break;

    case (2) :
      data_entered = SD_FALSE;
      break;
    }
  return (data_entered);
  }

/************************************************************************/
/*			get_var_data					*/
/************************************************************************/

ST_INT get_var_data (ST_CHAR  *prompt, ST_UCHAR  *dest)
  {
ST_INT len;

  flush_keys ();
  printf ("\n Enter %s : ", prompt);
  len = input_hex (dest, max_input);
  return (len);
  }

/************************************************************************/
/*			get_write_data					*/
/* function to get write data from the user, given the type		*/
/************************************************************************/

ST_RET get_write_data (OBJECT_NAME *type, ST_CHAR  *source, ST_INT chan)
  {
NAMED_TYPE *tptr;

  if (tptr = ms_find_named_type_obj (type,chan))
    {
    get_arb_write_data (source, tptr->rt_head, tptr->rt_num);
    flush_keys ();
    return (SD_SUCCESS);
    }
  return (SD_FAILURE);
  }


ST_RET getWrArrStart (RT_AA_CTRL *rtaa)
  {
  printf (" ArrayStart\n");
  return (SD_SUCCESS);
  }

ST_RET getWrArrEnd   (RT_AA_CTRL *rtaa)
  {
  printf (" ArrayEnd\n");
  return (SD_SUCCESS);
  }

ST_RET getWrStrStart (RT_AA_CTRL *rtaa)
  {
  printf (" StructureStart\n");
  return (SD_SUCCESS);
  }

ST_RET getWrStrEnd   (RT_AA_CTRL *rtaa)
  {
  printf (" StructureEnd\n");
  return (SD_SUCCESS);
  }

ST_RET getWrInt8  (ST_INT8   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  printf (" Enter INTEGER 8 value  : ");
  intget (&i);
  *((ST_UCHAR *) data_dest) = (ST_UCHAR) i;
  return (SD_SUCCESS);
  }

ST_RET getWrInt16 (ST_INT16  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT	tempint;

  printf (" Enter INTEGER 16 value : ");
  intget (&tempint);
  *data_dest = (ST_INT16) tempint;
  return (SD_SUCCESS);
  }

ST_RET getWrInt32 (ST_INT32   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG	templong;

  printf (" Enter INTEGER 32 value : ");
  longget (&templong);
  *data_dest = (ST_INT32) templong;
  return (SD_SUCCESS);
  }

ST_RET getWrInt64 (ST_INT64   *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Enter INTEGER 64 value : ");
  longget ((ST_LONG *)data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrUint8 (ST_UINT8  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  printf (" Enter UNSIGNED 8 value  : ");
  intget (&i);
  *((ST_UCHAR *) data_dest) = (ST_UCHAR) i;
  return (SD_SUCCESS);
  }

ST_RET getWrUint16(ST_UINT16 *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT	tempint;

  printf (" Enter UNSIGNED 16 value : ");
  intget (&tempint);
  *data_dest = (ST_UINT16) tempint;
  return (SD_SUCCESS);
  }

ST_RET getWrUint32(ST_UINT32  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG	templong;

  printf (" Enter UNSIGNED 32 value : ");
  longget (&templong);
  *data_dest = (ST_UINT32) templong;
  return (SD_SUCCESS);
  }

ST_RET getWrUint64(ST_UINT64  *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Enter UNSIGNED 64 value : ");
  longget ((ST_LONG *)data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrFlt   (ST_FLOAT  *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Enter ST_FLOAT value      : ");
  floatget ((ST_FLOAT *)data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrDbl   (ST_DOUBLE *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Enter ST_DOUBLE value     : ");
  doubleget ((ST_DOUBLE *)data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrOct   (ST_UCHAR  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT	i;

  if (rtaa->rt->u.p.el_len < 0)  		/* variable length */
    {
    printf (" Enter OCTET STR length  : ");
    intget (&i);
    *((ST_INT16 *) data_dest) = (ST_INT16) i;
    printf (" Enter OCTET STR value  : ");
    input_hex ((ST_UCHAR *)(data_dest+2), abs (rtaa->rt->u.p.el_len));
    }
  else
    {
    printf (" Enter OCTET STR value  : ");
    input_hex ((ST_UCHAR *)data_dest, abs (rtaa->rt->u.p.el_len));
    }
  return (SD_SUCCESS);
  }

ST_RET getWrBool  (ST_BOOLEAN  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  printf (" Enter Boolean value    : ");
  intget (&i);
  *((ST_BOOLEAN *) data_dest) = (ST_BOOLEAN) i;
  return (SD_SUCCESS);
  }

ST_RET getWrBcd1  (ST_INT8   *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT i;

  printf (" Enter BCD 8 value      : ");
  intget (&i);
  *((ST_UCHAR *) data_dest) = (ST_UCHAR) i;
  return (SD_SUCCESS);
  }

ST_RET getWrBcd2  (ST_INT16  *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Enter BCD 16 value     : ");
  intget ((ST_INT *) data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrBcd4  (ST_INT32  *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Enter BCD 32 value     : ");
  longget ((ST_LONG *)data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrBs    (ST_UCHAR  *data_dest, RT_AA_CTRL *rtaa)
  {
ST_INT	i;
  if (rtaa->rt->u.p.el_len < 0)  		/* variable length */
    {
    printf (" Enter BIT STR length  : ");
    intget (&i);
    *((ST_INT16 *) data_dest) = (ST_INT16) i;
    i = (i+7)/8;				/* bytes not bits */
    printf (" Enter BIT STR value  : ");
    input_hex ((ST_UCHAR *)(data_dest+2), i);
    }
  else
    {
    printf (" Enter BIT STRING value : ");
    i = (abs (rtaa->rt->u.p.el_len)+7)/8;		/* bytes not bits */
    input_hex ((ST_UCHAR *)data_dest, i);
    }
  return (SD_SUCCESS);
  }

ST_RET getWrVis   (ST_CHAR  *data_dest, RT_AA_CTRL *rtaa)
  {
  printf (" Enter VIS STRING value : ");
  strget (data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrBt4   (ST_INT32 *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG val;
  printf (" Enter BTOD Number ms since midnight: ");
  longget (&val);
  *data_dest = (ST_INT32) val;
  return (SD_SUCCESS);
  }

ST_RET getWrBt6   (ST_INT32 *data_dest, RT_AA_CTRL *rtaa)
  {
ST_LONG val;
  printf (" Enter BTOD Number ms since midnight: ");
  longget (&val);
  *data_dest = (ST_INT32) val;
  printf (" Enter BTOD Number days since 1/1/1984: ");
  longget (&val);
  *(data_dest+1) = (ST_INT32) val;
  return (SD_SUCCESS);
  }

ST_RET getWrGt   (time_t *data_dest, RT_AA_CTRL *rtaa)
  {
  time (data_dest);
  return (SD_SUCCESS);
  }

ST_RET getWrUtc   (MMS_UTC_TIME *data_dest, RT_AA_CTRL *rtaa)
  {
  data_dest->secs = time(NULL);
  data_dest->fraction += 1;
  data_dest->qflags = 0x11;
  return (SD_SUCCESS);
  }


M_ARB_DATA_CTRL arb_write_ctrl =
  {
  getWrArrStart, /* arrStart 	*/
  getWrArrEnd, 	 /* arrEnd    	*/
  getWrStrStart, /* strStart  	*/
  getWrStrEnd, 	 /* strEnd    	*/
  getWrInt8,