atm_easysemlibb.c

运用VisualSTATE建模

#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)(i >> 8);
#endif
          i = VS.RD[iRI++];
#if (SEM_RMN_GUARDS)
          nGuard = (unsigned char)(i & 0x0FF);
#endif
          nNxt = (unsigned char)(i >> 8);
          i = VS.RD[iRI++];
          SEM.nAction = (unsigned char)(i & 0x0FF);
#if (SEM_RMN_SIGNALS)
          nSignal = (unsigned char)(i >> 8);
#endif
#endif
#if (SEM_RD_WIDTH_32_BIT && SEM_RDHW_TYPE_1 && SEM_RDHW_WIDTH_32_BIT)
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0X0FF);
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)((i >> 8) & 0X0FF);
#endif
          nNxt = (unsigned char)((i >> 16) & 0x0FF);
          SEM.nAction = (unsigned char)((i >> 24) & 0x0FF);
#endif
#if (SEM_RD_WIDTH_32_BIT && SEM_RDHW_TYPE_3 && SEM_RDHW_WIDTH_64_BIT)
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0x0FF);
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)((i >> 8) & 0x0FF);
#endif
#if (SEM_RMN_GUARDS)
          nGuard = (unsigned char)((i >> 16) & 0x0FF);
#endif
          nNxt = (unsigned char)(i >> 24);
          i = VS.RD[iRI++];
          SEM.nAction = (unsigned char)(i & 0x0FF);
#if (SEM_RMN_SIGNALS)
          nSignal = (unsigned char)((i >> 8) & 0x0FF);
#endif
#endif
#if (VS_NOF_STATE_MACHINES != 0)
          for (nNo = 0 ; nNo < nPos; nNo++)
          {
            SEM_STATE_TYPE sa;
            sa = (SEM_STATE_TYPE) VS.RD[iRI++];
            if (sa != SEM.CSV[VS.SMI[sa]]) {
              goto NextRule;
            }
          }
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          for (nNo = 0; nNo < nNeg; nNo++)
          {
            SEM_STATE_TYPE sa;
            i = VS.RD[iRI++];
            sa = SEM.CSV[VS.SMI[i]];
            if ((sa == STATE_UNDEFINED) || (sa == (SEM_STATE_TYPE) i)) {
              goto NextRule;
            }
          }
#endif
#endif
#if (SEM_RMN_GUARDS)
          if (nGuard)
          {
            for (nNo = 0; nNo < nGuard; nNo++)
            {
              if ((*VSGuard[VS.RD[iRI++]])() == VS_FALSE) {
                goto NextRule;
              }
            }
          }
#endif
          if (ATM_easycspyCtrl.fullInstrumentationP)
          {
            /* For C-SPYLink */
            struct CSpyIdentity id;
            id.signature = "c590 2396 447f 2b56 0c78 d80e";
            id.systemNumber = 0;
            id.instanceNumber = 0;
            _VS_enable_transition(&id, (SEM_RULE_TABLE_INDEX_TYPE)(SEM.iFirstR - 1));
          }

#if (VS_NOF_STATE_MACHINES != 0)
          for (nNo = 0; nNo < nNxt; nNo++)
          {
            SEM_STATE_TYPE sa;
            sa = (SEM_STATE_TYPE) VS.RD[iRI++];
            i = VS.SMI[sa];
            if (SEM.WSV[i] == STATE_UNDEFINED)
            {
              SEM.WSV[i] = sa;
            }
            else if (SEM.WSV[i] != sa)
            {
              SEM._iRI = iRI;
              return (SES_CONTRADICTION);
            }
          }
#endif
#if (SEM_RMN_SIGNALS)
          if (nSignal)
          {
            for (nNo = 0; nNo < nSignal; nNo++)
            {
              i = VS.RD[iRI++];
#if (SEM_SIGNAL_QUEUE_ERROR_IF_FULL)
              if (SEM_SignalQueuePut ((SEM_EVENT_TYPE)i) == SES_SIGNAL_QUEUE_FULL) {
                SEM._iRI = iRI;
                return (SES_SIGNAL_QUEUE_FULL);
              }
#endif
#if (SEM_SIGNAL_QUEUE_NO_ERROR_IF_FULL)
              SEM_SignalQueuePut ((SEM_EVENT_TYPE)i);
#endif
            }
          }
#endif
          if (SEM.nAction)
          {
            *ActionNo = (SEM_ACTION_EXPRESSION_TYPE)VS.RD[iRI];
            if (SEM.nAction > 1)
            {
              iRI++;
              SEM._iRI = iRI;
              SEM.nAction--;
              SEM.State = STATE_SEM_OUTPUT;
            }
            if (ATM_easycspyCtrl.fullInstrumentationP)
            {
              /* For C-SPYLink */
              struct CSpyIdentity id;
              id.signature = "c590 2396 447f 2b56 0c78 d80e";
              id.systemNumber = 0;
              id.instanceNumber = 0;
              _VS_enable_action(&id, *ActionNo);
            }
            return (SES_FOUND);
          }
NextRule :
          ;
        }
#if (VS_NOF_EVENT_GROUPS != 0)
        {
          SEM.State = STATE_SEM_PREPARE;
          break;
        }
#else
        {
#if (SEM_SIGNAL)
          goto Signal;
#else
          SEM.State = STATE_SEM_OKAY;
          return (SES_OKAY);
#endif
        }
#endif
      case STATE_SEM_OUTPUT :
        if (SEM.nAction)
        {
          *ActionNo = (SEM_ACTION_EXPRESSION_TYPE) VS.RD[SEM._iRI++];
          SEM.nAction--;
          if (ATM_easycspyCtrl.fullInstrumentationP)
          {
            /* For C-SPYLink */
            struct CSpyIdentity id;
            id.signature = "c590 2396 447f 2b56 0c78 d80e";
            id.systemNumber = 0;
            id.instanceNumber = 0;
            _VS_enable_action(&id, *ActionNo);
          }
          return (SES_FOUND);
        }
        SEM.State = STATE_SEM_CONSULT;
        break;
      case STATE_SEM_OKAY :
        return (SES_OKAY);
      default :
        return (SES_EMPTY);
    }
  }
}


#if (SEM_GET_OUTPUT_ALL == 1)
#if (SEM_SIGNAL)
#error SEM_GetOutputAll cannot be used when the Project contains signals.
#endif
unsigned char ATM_easySEM_GetOutputAll (SEM_ACTION_EXPRESSION_TYPE *ActionVector,
  SEM_ACTION_EXPRESSION_TYPE MaxSize)
{
  SEM_ACTION_EXPRESSION_TYPE i;
  unsigned char CC;

  for (i = 0; ((CC = ATM_easySEM_GetOutput(&ActionVector[i])) == SES_FOUND) && i < MaxSize - 1; i++);

  if (CC == SES_OKAY)
  {
    ActionVector[i] = ACTION_EXPRESSION_TERMINATION_ID;
    return (SES_OKAY);
  }
  if (CC == SES_FOUND) {
    return (SES_BUFFER_OVERFLOW);
  }
  return (CC);
}
#endif


#if (SEM_NEXT_STATE_CHG == 1)
unsigned char ATM_easySEM_NextStateChg (void)
#else
unsigned char ATM_easySEM_NextState (void)
#endif
{
  unsigned char CC;
  SEM_ACTION_EXPRESSION_TYPE nAction;

  if (SEM.State != STATE_SEM_OKAY)
  {
    while ((CC = ATM_easySEM_GetOutput (&nAction)) == SES_FOUND) {
      ;
    }
    if (CC != SES_OKAY) {
      return(CC);
    }
  }
#if (VS_NOF_STATE_MACHINES != 0)
  {
    SEM_STATE_MACHINE_TYPE i;
    for (i = 0; i < VS_NOF_STATE_MACHINES; i++)
    {
      if (SEM.WSV[i] != STATE_UNDEFINED)
      {
#if (SEM_NEXT_STATE_CHG == 1)
        if (SEM.CSV[i] != SEM.WSV[i]) {
          SEM.Chg = 1;
        }
#endif
        SEM.CSV[i] = SEM.WSV[i];
        SEM.WSV[i] = STATE_UNDEFINED;
      }
      if (ATM_easycspyCtrl.useTraceBufferP && (ATM_easytraceBufferData.pWrite->maxUsed <= 2))
        ATM_easyTraceBufferElements[ATM_easytraceBufferData.pWrite->endIndex++].u.s = SEM.CSV[i];
    }
    if (ATM_easycspyCtrl.useTraceBufferP)
    {
      if (ATM_easytraceBufferData.readFrom == 0)
      {
        ATM_easytraceBufferData.readFrom = 1;
        ATM_easytraceBufferData.pWrite = &ATM_easytraceBufferData.entries[0];
        ATM_easytraceBufferData.entries[0].maxUsed = 0;
        ATM_easytraceBufferData.entries[0].startIndex = (7 + (2 * (7 + 1)));
        ATM_easytraceBufferData.entries[0].endIndex = (7 + (2 * (7 + 1)));
      }
      else
      {
        ATM_easytraceBufferData.readFrom = 0;
        ATM_easytraceBufferData.pWrite = &ATM_easytraceBufferData.entries[1];
        ATM_easytraceBufferData.entries[1].maxUsed = 0;
        ATM_easytraceBufferData.entries[1].startIndex = 0;
        ATM_easytraceBufferData.entries[1].endIndex = 0;
      }
    }
  }
#endif
  SEM.State = STATE_SEM_INITIALIZE;

#if (SEM_NEXT_STATE_CHG == 1)
  if (SEM.Chg)
  {
    SEM.Chg = 0;
    if (ATM_easycspyCtrl.fullInstrumentationP)
    {
      /* For C-SPYLink */
      struct CSpyIdentity id;
      id.signature = "c590 2396 447f 2b56 0c78 d80e";
      id.systemNumber = 0;
      id.instanceNumber = 0;
      _VS_end_macro_step(&id);
    }
    return (SES_FOUND);
  }
  if (ATM_easycspyCtrl.fullInstrumentationP)
  {
    /* For C-SPYLink */
    struct CSpyIdentity id;
    id.signature = "c590 2396 447f 2b56 0c78 d80e";
    id.systemNumber = 0;
    id.instanceNumber = 0;
    _VS_end_macro_step(&id);
  }
  return (SES_OKAY);
#else
  if (ATM_easycspyCtrl.fullInstrumentationP)
  {
    /* For C-SPYLink */
    struct CSpyIdentity id;
    id.signature = "c590 2396 447f 2b56 0c78 d80e";
    id.systemNumber = 0;
    id.instanceNumber = 0;
    _VS_end_macro_step(&id);
  }
  return (SES_OKAY);
#endif
}


#if (SEM_NAME == 1)
unsigned char ATM_easySEM_Name (unsigned char IdentType, 
  SEM_EXPLANATION_TYPE IdentNo, char *Text, unsigned short MaxSize)
{
  char  c, *s;
  unsigned short i;

  if (!MaxSize) {
    return (SES_TEXT_TOO_LONG);
  }
  switch (IdentType)
  {
#if (VS_EVENT_NAMES != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.ENames + VS.ENI[IdentNo];
      break;
#endif
#if ((VS_STATE_NAMES != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.SNames + VS.SNI[IdentNo];
      break;
#endif
#if ((VS_ACTION_FUNCTION_NAMES != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.ANames + VS.ANI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }
  for (i = 0; i < MaxSize; i++)
  {
    c = *s++;
    *Text++ = c;
    if (c == '\0') {
      return (SES_OKAY);
    }
  }
  Text--;
  *Text = '\0';
  return (SES_TEXT_TOO_LONG);
}
#endif


#if (SEM_NAME_ABS == 1)
unsigned char ATM_easySEM_NameAbs (unsigned char IdentType, 
  SEM_EXPLANATION_TYPE IdentNo, char const **Text)
{
  switch (IdentType)
  {
#if (VS_EVENT_NAMES != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.ENames + VS.ENI[IdentNo];
      break;
#endif
#if ((VS_STATE_NAMES != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.SNames + VS.SNI[IdentNo];
      break;
#endif
#if ((VS_ACTION_FUNCTION_NAMES != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.ANames + VS.ANI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }
  return (SES_OKAY);
}
#endif


#if (SEM_EXPL == 1)
unsigned char ATM_easySEM_Expl (unsigned char IdentType, SEM_EXPLANATION_TYPE IdentNo,
  char *Text, unsigned short MaxSize)
{
  char  c, *s;
  unsigned short i;

  if (!MaxSize) {
    return (SES_TEXT_TOO_LONG);
  }
  switch (IdentType)
  {
#if (VS_EVENT_EXPLS != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.EExpls + VS.EEI[IdentNo];
      break;
#endif
#if ((VS_STATE_EXPLS != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.SExpls + VS.SEI[IdentNo];
      break;
#endif
#if ((VS_ACTION_EXPLS != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      s = (char *)VS.AExpls + VS.AEI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }

  for (i = 0; i < MaxSize; i++)
  {
    c = *s++;
    *Text++ = c;
    if (c == '\0') {
      return (SES_OKAY);
    }
  }
  Text--;
  *Text = '\0';
  return (SES_TEXT_TOO_LONG);
}
#endif


#if (SEM_EXPL_ABS == 1)
unsigned char ATM_easySEM_ExplAbs (unsigned char IdentType,
  SEM_EXPLANATION_TYPE IdentNo, char const **Text)
{
  switch (IdentType)
  {
#if (VS_EVENT_EXPLS != 0)
    case EVENT_TYPE :
      if (VS_NOF_EVENTS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.EExpls + VS.EEI[IdentNo];
      break;
#endif
#if ((VS_STATE_EXPLS != 0) && (VS_NOF_STATES != 0))
    case STATE_TYPE :
      if (VS_NOF_STATES <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.SExpls + VS.SEI[IdentNo];
      break;
#endif
#if ((VS_ACTION_EXPLS != 0) && (VS_NOF_ACTION_FUNCTIONS != 0))
    case ACTION_TYPE :
      if (VS_NOF_ACTION_FUNCTIONS <= IdentNo) {
        return (SES_RANGE_ERR);
      }
      *Text = (char const *)&VS.AExpls + VS.AEI[IdentNo];
      break;
#endif
    default :
      return (SES_TYPE_ERR);
  }
  return (SES_OKAY);
}
#endif


#if (SEM_STATE == 1)
unsigned char ATM_easySEM_State (SEM_STATE_MACHINE_TYPE StateMachineNo,
  SEM_STATE_TYPE *StateNo)
{
  if (VS_NOF_STATE_MACHINES <= StateMachineNo) {
    return (SES_RANGE_ERR);
  }
#if (VS_NOF_STATE_MACHINES != 0)
  *StateNo = SEM.CSV[StateMachineNo];
#else
  *StateNo = 0;
#endif
  return (SES_FOUND);
}
#endif


#if (SEM_STATE_ALL == 1)
unsigned char ATM_easySEM_StateAll (SEM_STATE_TYPE *StateVector,
  SEM_STATE_MACHINE_TYPE MaxSize)
{
  SEM_STATE_MACHINE_TYPE i;

  if (VS_NOF_STATE_MACHINES > MaxSize) {
    return (SES_BUFFER_OVERFLOW);
  }

#if (VS_NOF_STATE_MACHINES != 0)
  for (i = 0; i < VS_NOF_STATE_MACHINES; i++) {
    StateVector[i] = SEM.CSV[i];
  }
#else
  for (i = 0; i < VS_NOF_STATE_MACHINES; i++) {
    StateVector[i] = 0;
  }
#endif
  return (SES_FOUND);
}
#endif


#if (SEM_MACHINE == 1)
unsigned char ATM_easySEM_Machine (SEM_STATE_TYPE StateNo,
  SEM_STATE_MACHINE_TYPE *StateMachineNo)
{
  if (VS_NOF_STATES <= StateNo) {
    return (SES_RANGE_ERR);
  }
#if (VS_NOF_STATE_MACHINES != 0)
  *StateMachineNo = VS.SMI[StateNo];
#else
  *StateMachineNo = 0;
#endif
  return (SES_FOUND);
}
#endif


#if (SEM_FORCE_STATE == 1)
unsigned char ATM_easySEM_ForceState (SEM_STATE_TYPE StateNo)
{
  if (VS_NOF_STATES <= StateNo) {
    return (SES_RANGE_ERR);
  }
#if (VS_NOF_STATE_MACHINES != 0)
  SEM.CSV[VS.SMI[StateNo]] = StateNo;
#endif
  return (SES_OKAY);
}
#endif