atm_easysemlibb.c

运用VisualSTATE建模

/*
 * Version:   50
 * Signature: c590 2396 447f 2b56 0c78 d80e
 *
 * Id:        ATM_easySEMLibB.c
 *
 * Function:  Contains all API functions.
 *
 * Generated: Wed Jul 23 14:27:18 2008
 *
 * Coder 5, 4, 1, 1290
 * 
 * This is an automatically generated file. It will be overwritten by the Coder. 
 * 
 * DO NOT EDIT THE FILE! 
 */


#include "ATM_easySEMLibB.h"


#include "CSpyLink.h"


#include <string.h>


#if (VS_CODER_GUID != 0X011dedf72)
#error The generated file does not match the SEMTypes.h header file.
#endif


/*
 * Used internally in the API
 */
#define STATE_SEM_INITIALIZE  0x00
#define STATE_SEM_SIGNAL      0x01
#define STATE_SEM_PREPARE     0x02
#define STATE_SEM_CONSULT     0x03
#define STATE_SEM_OUTPUT      0x04
#define STATE_SEM_OKAY        0x05


/*
 * Conditional Compilation Definitions for the API only.
 */
#define SEM_RDHW_TYPE_1                    0
#define SEM_RDHW_TYPE_2                    1
#define SEM_RDHW_TYPE_3                    0
#define SEM_RDHW_WIDTH_16_BIT              0
#define SEM_RDHW_WIDTH_24_BIT              1
#define SEM_RDHW_WIDTH_32_BIT              0
#define SEM_RDHW_WIDTH_48_BIT              0
#define SEM_RDHW_WIDTH_64_BIT              0
#define SEM_RD_WIDTH_8_BIT                 1
#define SEM_RD_WIDTH_16_BIT                0
#define SEM_RD_WIDTH_32_BIT                0
#define SEM_RDFM_NUMBER                    1
#define SEM_EVENT_GROUP_INDEX              0
#define SEM_EVENT_GROUP_TABLE_INDEX        0
#define SEM_SIGNAL_QUEUE_ERROR_IF_FULL     1
#define SEM_SIGNAL_QUEUE_NO_ERROR_IF_FULL  0
#define SEM_RMN_ACTIONS                    2
#define SEM_RMN_GUARDS                     1
#define SEM_RMN_NEGATIVE_STATE_SYNCS       1
#define SEM_RMN_NEXT_STATES                7
#define SEM_RMN_POSITIVE_STATE_SYNCS       4
#define SEM_RMN_SIGNALS                    1
#define SEM_SIGNAL                         1
#define SEM_EXPL                           0
#define SEM_EXPL_ABS                       0
#define SEM_FORCE_STATE                    0
#define SEM_GET_INPUT_ALL                  0
#define SEM_GET_OUTPUT_ALL                 0
#define SEM_INIT_ALL                       1
#define SEM_MACHINE                        0
#define SEM_NAME                           0
#define SEM_NAME_ABS                       0
#define SEM_NEXT_STATE_CHG                 0
#define SEM_SIGNAL_QUEUE_INFO              0
#define SEM_STATE                          0
#define SEM_STATE_ALL                      0
#define SEM_INIT_EXTERNAL_VARIABLES        0
#define SEM_INIT_INTERNAL_VARIABLES        0
#define VS_ACTION_EXPLS                    0
#define VS_ACTION_FUNCTION_NAMES           0
#define VS_EVENT_EXPLS                     0
#define VS_EVENT_NAMES                     0
#define VS_STATE_EXPLS                     0
#define VS_STATE_NAMES                     0


/* Core model logic struct name */
#define VS ATM_easy


/* SEM data struct name */
#define SEM SEMATM_easy


/* Guard expression handler */
#define VSGuard ATM_easyVSGuard


typedef struct CSpyIdentity {
  const char* signature;
  unsigned systemNumber;
  unsigned instanceNumber;
} CSpyIdentity;


struct ATM_easyCSpyCtrl
{
  unsigned fullInstrumentationP : 1;
  unsigned enableTraceBufferP : 1;/* manipulated by C-SPY */
  unsigned useTraceBufferP : 1;/* for SEMLib */
};


struct ATM_easyCSpyCtrl ATM_easycspyCtrl;


struct ATM_easyTraceBufferElement
{
  union
  {
    SEM_EVENT_TYPE t;
    SEM_STATE_TYPE s;
  } u;
};


struct ATM_easyTraceBufferElement ATM_easyTraceBufferElements[2 * (7 + (2 * (7 + 1)))];


struct ATM_easyTraceBufferEntry
{
  unsigned maxUsed;
  unsigned startIndex;
  unsigned endIndex;
};


struct ATM_easyTraceBufferData
{
  unsigned readFrom : 1;
  struct ATM_easyTraceBufferEntry* pWrite;
  struct ATM_easyTraceBufferEntry entries[2];
};


struct ATM_easyTraceBufferData ATM_easytraceBufferData;


#ifdef VS_RUNTIME_INFO
ATM_easyVSRunTimeInfo volatile const VS_RUNTIME_INFO_EXTKW ATM_easyvsRunTimeInfo = 
{
  VS_SIGNATURE_VERSION,
  VS_SIGNATURE_CONTENT
};
#endif


#if (SEM_SIGNAL)
void ATM_easySEM_InitSignalQueue (void)
{
  SEM.SPut = 0;
  SEM.SGet = 0;
  SEM.SUsed = 0;
}


static unsigned char SEM_SignalQueuePut (SEM_EVENT_TYPE SignalNo)
{
  if (SEM.SUsed == 1) {
    return (SES_SIGNAL_QUEUE_FULL);
  }
  SEM.SUsed++;
  SEM.SQueue[SEM.SPut] = SignalNo;
  if (++SEM.SPut == 1) {
    SEM.SPut = 0;
  }
  return (SES_OKAY);
}


static SEM_EVENT_TYPE SEM_SignalQueueGet (void)
{
  SEM_EVENT_TYPE SignalNo;

  if (!SEM.SUsed) {
    return (EVENT_UNDEFINED);
  }
  SEM.SUsed--;
  SignalNo = SEM.SQueue[SEM.SGet];
  if (++SEM.SGet == 1) {
    SEM.SGet = 0;
  }
  return (SignalNo);
}


#if (SEM_SIGNAL_QUEUE_INFO == 1)
void ATM_easySEM_SignalQueueInfo (SEM_SIGNAL_QUEUE_TYPE *NofSignals)
{
  *NofSignals = SEM.SUsed;
}
#endif
#endif


#if (SEM_INIT_ALL)
void ATM_easySEM_InitAll (void)
{
  ATM_easySEM_Init();
#if (SEM_INIT_EXTERNAL_VARIABLES)
  ATM_easySEM_InitExternalVariables();
#endif
#if (SEM_INIT_INTERNAL_VARIABLES)
  ATM_easySEM_InitInternalVariables();
#endif
#if (SEM_SIGNAL)
  ATM_easySEM_InitSignalQueue();
#endif
}
#endif


void ATM_easySEM_Init (void)
{
#ifdef VS_RUNTIME_INFO
  *ATM_easyvsRunTimeInfo.pSignatureVersion;
#endif
#if (VS_NOF_STATE_MACHINES != 0)
  {
    SEM_STATE_MACHINE_TYPE i;
    for (i = 0; i < VS_NOF_STATE_MACHINES; i++)
    {
      SEM.WSV[i] = STATE_UNDEFINED;
      SEM.CSV[i] = STATE_UNDEFINED;
    }
  }
#if (SEM_NEXT_STATE_CHG == 1)
  SEM.Chg = 0;
#endif
#endif
  SEM.State = STATE_SEM_INITIALIZE;

  {
    ATM_easytraceBufferData.readFrom = 0;
    ATM_easytraceBufferData.pWrite = &ATM_easytraceBufferData.entries[1];
    ATM_easytraceBufferData.entries[0].maxUsed = 0;
    ATM_easytraceBufferData.entries[0].startIndex = 0;
    ATM_easytraceBufferData.entries[0].endIndex = 0;
    ATM_easytraceBufferData.entries[1].maxUsed = 0;
    ATM_easytraceBufferData.entries[1].startIndex = (7 + (2 * (7 + 1)));
    ATM_easytraceBufferData.entries[1].endIndex = (7 + (2 * (7 + 1)));
  }
  {
    /* For C-SPYLink */
    struct CSpyIdentity id;
    id.signature = "c590 2396 447f 2b56 0c78 d80e";
    id.systemNumber = 0;
    id.instanceNumber = 0;
    _VS_initialized_break_point(&id);
  }
}


void ATM_easyCSPYLinkInsertTrigger (SEM_EVENT_TYPE EventNo)
{
  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_event(&id, EventNo, 0);
  }
  ATM_easycspyCtrl.useTraceBufferP = ATM_easycspyCtrl.enableTraceBufferP;
  if (ATM_easycspyCtrl.useTraceBufferP)
  {
    SEM_STATE_MACHINE_TYPE i;
    for (i = 0; i < VS_NOF_STATE_MACHINES; ++i)
    {
      ATM_easyTraceBufferElements[ATM_easytraceBufferData.pWrite->endIndex++].u.s = SEM.CSV[i];
    }
    ATM_easyTraceBufferElements[ATM_easytraceBufferData.pWrite->endIndex++].u.t = EventNo;
    ATM_easytraceBufferData.pWrite->maxUsed++;
  }
}


unsigned char ATM_easySEM_Deduct (SEM_EVENT_TYPE EventNo)
{
  if (VS_NOF_EVENTS <= EventNo) {
    return (SES_RANGE_ERR);
  }
  SEM.EventNo = EventNo;
  SEM.State = STATE_SEM_PREPARE;
#if (VS_NOF_EVENT_GROUPS != 0)
  SEM.DIt = 2;
#endif
  ATM_easyCSPYLinkInsertTrigger(EventNo);
  return (SES_OKAY);
}


unsigned char ATM_easySEM_GetOutput (SEM_ACTION_EXPRESSION_TYPE *ActionNo)
{
  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_enter_get_output(&id);
  }
  for(;;)
  {
    switch (SEM.State)
    {
#if (SEM_SIGNAL)
      case STATE_SEM_SIGNAL :
Signal :
        if (ATM_easycspyCtrl.useTraceBufferP && SEM.SUsed)
        {
          if (ATM_easytraceBufferData.pWrite->maxUsed <= 2)
          {
            SEM_STATE_MACHINE_TYPE i;
            for (i = 0; i < VS_NOF_STATE_MACHINES; ++i)
            {
              ATM_easyTraceBufferElements[ATM_easytraceBufferData.pWrite->endIndex++].u.s = SEM.WSV[i];
            }
            if (ATM_easytraceBufferData.pWrite->maxUsed < 2)
              ATM_easyTraceBufferElements[ATM_easytraceBufferData.pWrite->endIndex++].u.t = SEM.SQueue[SEM.SGet];
          }
          ATM_easytraceBufferData.pWrite->maxUsed++;
        }
        if (ATM_easycspyCtrl.fullInstrumentationP && SEM.SUsed)
        {
          /* For C-SPYLink */
          struct CSpyIdentity id;
          id.signature = "c590 2396 447f 2b56 0c78 d80e";
          id.systemNumber = 0;
          id.instanceNumber = 0;
          _VS_enable_signal(&id, SEM.SQueue[SEM.SGet]);
        }
        SEM.EventNo = SEM_SignalQueueGet ();
        if (SEM.EventNo == EVENT_UNDEFINED)
        {
          SEM.State = STATE_SEM_OKAY;
          return (SES_OKAY);
        }
#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;
            }
          }
        }
#endif
        goto FirstRule;
#endif
      case STATE_SEM_PREPARE :
#if (VS_NOF_EVENT_GROUPS != 0)
#if (SEM_EVENT_GROUP_INDEX)
        if (SEM.DIt == 1)
        {
          SEM.EventNo = VS.EGI[SEM.EventNo];
          if (SEM.EventNo == EVENT_GROUP_UNDEFINED)
          {
#if (SEM_SIGNAL)
            SEM.DIt = 0;
            goto Signal;
#else
            SEM.State = STATE_SEM_OKAY;
            return (SES_OKAY);
#endif
          }
          SEM.EventNo += VS_NOF_EVENTS;
        }
        else if (SEM.DIt == 0)
        {
#if (SEM_SIGNAL)
          goto Signal;
#else
          SEM.State = STATE_SEM_OKAY;
          return (SES_OKAY);
#endif
        }
        SEM.DIt--;
#endif
#if (SEM_EVENT_GROUP_TABLE_INDEX)
        if (SEM.DIt == 0)
        {
          if (++SEM.iFirstEgi >= SEM.iLastEgi)
          {
#if (SEM_SIGNAL)
            goto Signal;
#else
            SEM.State = STATE_SEM_OKAY;
            return (SES_OKAY);
#endif
          }
          SEM.EventNo = VS.EGT[SEM.iFirstEgi];
          SEM.EventNo += VS_NOF_EVENTS;
        }
        else if (SEM.DIt == 1)
        {
          SEM.iFirstEgi = VS.EGTI[SEM.EventNo];
          SEM.iLastEgi = VS.EGTI[SEM.EventNo + 1];
          if (SEM.iFirstEgi == SEM.iLastEgi)
          {
#if (SEM_SIGNAL)
            SEM.DIt = 0;
            goto Signal;
#else
            SEM.State = STATE_SEM_OKAY;
            return (SES_OKAY);
#endif
          }
          SEM.EventNo = VS.EGT[SEM.iFirstEgi];
          SEM.EventNo += VS_NOF_EVENTS;
          SEM.DIt--;
        }
        else if (SEM.DIt == 2)
        {
          SEM.DIt--;
        }
#endif
#endif
#if (SEM_SIGNAL)
FirstRule :
#endif
        SEM.iFirstR = VS.RTI[SEM.EventNo];
        SEM.iLastR = VS.RTI[SEM.EventNo + 1];
        SEM.State = STATE_SEM_CONSULT;
      case STATE_SEM_CONSULT :
        while (SEM.iFirstR < SEM.iLastR)
        {
          SEM_INTERNAL_TYPE i;
          VS_UINT8 nNo;
          VS_UINT8 nPos;
          VS_UINT8 nNxt;
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          VS_UINT8 nNeg;
#endif
#if (SEM_RMN_SIGNALS)
          VS_UINT8 nSignal;
#endif
#if (SEM_RMN_GUARDS)
          VS_UINT8 nGuard;
#endif
          SEM_RULE_INDEX_TYPE iRI;

          iRI = VS.RI[SEM.iFirstR++];
#if (SEM_RD_WIDTH_8_BIT && SEM_RDHW_TYPE_1 && SEM_RDHW_WIDTH_16_BIT)
          i = VS.RD[iRI++];
          nNxt = (unsigned char)(i & 0x0F);
          SEM.nAction = (unsigned char)(i >> 4);
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0x0F);
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)(i >> 4);
#endif
#endif
#if (SEM_RD_WIDTH_8_BIT && SEM_RDHW_TYPE_2 && SEM_RDHW_WIDTH_24_BIT)
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0x0F);
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)(i >> 4);
#endif
          i = VS.RD[iRI++];
#if (SEM_RMN_GUARDS)
          nGuard = (unsigned char)(i & 0x0F);
#endif
          nNxt = (unsigned char)(i >> 4);
          i = VS.RD[iRI++];
          SEM.nAction = (unsigned char)(i & 0x0F);
#if (SEM_RMN_SIGNALS)
          nSignal = (unsigned char)(i >> 4);
#endif
#endif
#if (SEM_RD_WIDTH_8_BIT && SEM_RDHW_TYPE_1 && SEM_RDHW_WIDTH_32_BIT)
          SEM.nAction = (unsigned char)VS.RD[iRI++];
          nNxt = (unsigned char)VS.RD[iRI++];
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)VS.RD[iRI++];
#else
          iRI++;
#endif
          nPos = (unsigned char)VS.RD[iRI++];
#endif
#if (SEM_RD_WIDTH_8_BIT && SEM_RDHW_TYPE_2 && SEM_RDHW_WIDTH_48_BIT)
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)VS.RD[iRI++];
#else
          iRI++;
#endif
          nPos = (unsigned char)VS.RD[iRI++];
          nNxt = (unsigned char)VS.RD[iRI++];
#if (SEM_RMN_GUARDS)
          nGuard = (unsigned char)VS.RD[iRI];
#endif
          iRI++;
#if (SEM_RMN_SIGNALS)
          nSignal = (unsigned char)VS.RD[iRI];
#endif
          iRI++;
          SEM.nAction = (unsigned char)VS.RD[iRI++];
#endif
#if (SEM_RD_WIDTH_16_BIT && SEM_RDHW_TYPE_1 && SEM_RDHW_WIDTH_16_BIT)
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0x0F);
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)((i >> 4) & 0x0F);
#endif
          nNxt = (unsigned char)((i >> 8) & 0x0F);
          SEM.nAction = (unsigned char)((i >> 12) & 0x0F);
#endif
#if (SEM_RD_WIDTH_16_BIT && SEM_RDHW_TYPE_3 && SEM_RDHW_WIDTH_32_BIT)
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0x0F);
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)((i >> 4) & 0x0F);
#endif
#if (SEM_RMN_GUARDS)
          nGuard = (unsigned char)((i >> 8) & 0x0F);
#endif
          nNxt = (unsigned char)(i >> 12);
          i = VS.RD[iRI++];
          SEM.nAction = (unsigned char)(i & 0x0F);
#if (SEM_RMN_SIGNALS)
          nSignal = (unsigned char)((i >> 4) & 0x0F);
#endif
#endif
#if (SEM_RD_WIDTH_16_BIT && SEM_RDHW_TYPE_1 && SEM_RDHW_WIDTH_32_BIT)
          i = VS.RD[iRI++];
          nNxt = (unsigned char)(i & 0x0FF);
          SEM.nAction = (unsigned char)(i >> 8);
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0x0FF);
#if (SEM_RMN_NEGATIVE_STATE_SYNCS)
          nNeg = (unsigned char)(i >> 8);
#endif
#endif
#if (SEM_RD_WIDTH_16_BIT && SEM_RDHW_TYPE_2 && SEM_RDHW_WIDTH_48_BIT)
          i = VS.RD[iRI++];
          nPos = (unsigned char)(i & 0x0FF);