自学教程：C++ CFE_EVS_SendEvent函数代码示例

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */void CFE_ES_PerfSetTriggerMaskCmd(CFE_SB_MsgPtr_t msg){   uint16 ExpectedLength = sizeof(CFE_ES_PerfSetTrigMaskCmd_t);   CFE_ES_PerfSetTrigMaskCmd_t *cmd = (CFE_ES_PerfSetTrigMaskCmd_t *) msg;   /*    ** Verify command packet length.    */    if (CFE_ES_VerifyCmdLength(msg, ExpectedLength))    {       if(cmd->TriggerMaskNum < CFE_ES_PERF_32BIT_WORDS_IN_MASK ){            Perf->MetaData.TriggerMask[cmd->TriggerMaskNum] = cmd->TriggerMask;            CFE_EVS_SendEvent(CFE_ES_PERF_TRIGMSKCMD_EID, CFE_EVS_DEBUG,                      "Set Performance Trigger Mask Cmd rcvd,num %d, val 0x%x",                      cmd->TriggerMaskNum,cmd->TriggerMaskNum);            CFE_ES_TaskData.CmdCounter++;       }else{           CFE_EVS_SendEvent(CFE_ES_PERF_TRIGMSKERR_EID, CFE_EVS_ERROR,                      "Performance Trigger Mask Cmd Error,Index(%d)out of range(%d)",                      cmd->TriggerMaskNum,CFE_ES_PERF_32BIT_WORDS_IN_MASK);            CFE_ES_TaskData.ErrCounter++;       }    }} /* End of CFE_ES_PerfSetTriggerMaskCmd() */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */void TO_RemoveAllPkt(void){    int32  status;    int i;    for (i=0; (i < (sizeof(TO_SubTable)/sizeof(TO_subsciption_t))); i++)    {       if (TO_SubTable[i].Stream != TO_UNUSED )       {          status = CFE_SB_Unsubscribe(TO_SubTable[i].Stream, TO_Tlm_pipe);          if(status != CFE_SUCCESS)             CFE_EVS_SendEvent(TO_REMOVEALLPTKS_ERR_EID,CFE_EVS_ERROR, "L%d TO Can't Unsubscribe to stream 0x%x status %i", __LINE__,                               TO_SubTable[i].Stream, status);       }    }    /* remove commands as well */    status = CFE_SB_Unsubscribe(TO_LAB_CMD_MID, TO_Cmd_pipe);    if(status != CFE_SUCCESS)       CFE_EVS_SendEvent(TO_REMOVECMDTO_ERR_EID,CFE_EVS_ERROR, "L%d TO Can't Unsubscribe to cmd stream 0x%x status %i", __LINE__,                         TO_LAB_CMD_MID, status);    status = CFE_SB_Unsubscribe(TO_LAB_SEND_HK_MID, TO_Cmd_pipe);    if (status != CFE_SUCCESS)       CFE_EVS_SendEvent(TO_REMOVEHKTO_ERR_EID,CFE_EVS_ERROR, "L%d TO Can't Unsubscribe to cmd stream 0x%x status %i", __LINE__,                         TO_LAB_CMD_MID, status);    CFE_EVS_SendEvent(TO_REMOVEALLPKTS_INF_EID,CFE_EVS_INFORMATION, "L%d TO Unsubscribed to all Commands and Telemetry", __LINE__);} /* End of TO_RemoveAllPkt() */

void CI_ProcessGroundCommand(void){    uint16 CommandCode;    CommandCode = CFE_SB_GetCmdCode(CIMsgPtr);    /* Process "known" CI task ground commands */    switch (CommandCode)    {        case CI_NO_OPERATION_CC:            CI_HkTelemetryPkt.ci_command_count++;            CFE_EVS_SendEvent(CI_COMMANDNOP_INF_EID,CFE_EVS_INFORMATION, "CI: NOP command");            break;        case CI_RESET_COUNTERS_CC:            CI_ResetCounters();            CFE_EVS_SendEvent(CI_COMMANDRST_INF_EID,CFE_EVS_INFORMATION, "CI: RESET command");            break;        /* default case already found during FC vs length test */        default:            break;    }    return;} /* End of CI_ProcessGroundCommand() */

void CFE_TIME_1HzAdjCmd(CFE_SB_MsgPtr_t MessagePtr, int16 Direction){    /*    ** 1Hz adjustments are only valid for "Time Servers"...    */    #if (CFE_TIME_CFG_SERVER == TRUE)    CFE_TIME_1HzAdjCmd_t *CommandPtr = (CFE_TIME_1HzAdjCmd_t *) MessagePtr;    CFE_TIME_SysTime_t Adjust;    Adjust.Seconds = CommandPtr->Seconds;    Adjust.Subseconds = CommandPtr->SubSeconds;    CFE_TIME_Set1HzAdj(Adjust, Direction);    CFE_TIME_TaskData.CmdCounter++;    CFE_EVS_SendEvent(CFE_TIME_1HZ_EID, CFE_EVS_INFORMATION,       "STCF 1Hz Adjust -- secs = %d, ssecs = 0x%X, dir[1=Pos, 2=Neg] = %d",                      CommandPtr->Seconds, CommandPtr->SubSeconds, Direction);    #else /* not CFE_TIME_CFG_SERVER */    /*    ** We want to know if disabled commands are being sent...    */    CFE_TIME_TaskData.ErrCounter++;    CFE_EVS_SendEvent(CFE_TIME_1HZ_CFG_EID, CFE_EVS_ERROR,       "1Hz Adjust commands invalid without CFE_TIME_CFG_SERVER set to TRUE");    #endif /* CFE_TIME_CFG_SERVER */    return;} /* End of CFE_TIME_1HzAdjCmd() */

void CFE_TIME_SetLeapsCmd(CFE_SB_MsgPtr_t MessagePtr){    #if (CFE_TIME_CFG_SERVER == TRUE)    CFE_TIME_LeapsCmd_t *CommandPtr = (CFE_TIME_LeapsCmd_t *) MessagePtr;    /*    ** No value checking (leaps may be positive or negative)...    */    CFE_TIME_SetLeaps(CommandPtr->LeapSeconds);    CFE_TIME_TaskData.CmdCounter++;    CFE_EVS_SendEvent(CFE_TIME_LEAPS_EID, CFE_EVS_INFORMATION,                     "Set Leap Seconds = %d", CommandPtr->LeapSeconds);    #else /* not CFE_TIME_CFG_SERVER */    /*    ** We want to know if disabled commands are being sent...    */    CFE_TIME_TaskData.ErrCounter++;    CFE_EVS_SendEvent(CFE_TIME_LEAPS_CFG_EID, CFE_EVS_ERROR,       "Set Leaps commands invalid without CFE_TIME_CFG_SERVER set to TRUE");    #endif /* CFE_TIME_CFG_SERVER */    return;} /* End of CFE_TIME_SetLeapsCmd() */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */void CS_DisableNameAppCmd(CFE_SB_MsgPtr_t MessagePtr){    /* command verification variables */    uint16                                 ExpectedLength = sizeof(CS_AppNameCmd_t);    CS_AppNameCmd_t                      * CmdPtr;         CS_Res_App_Table_Entry_t             * ResultsEntry;    CS_Def_App_Table_Entry_t             * DefinitionEntry;         /* Verify command packet length */    if ( CS_VerifyCmdLength (MessagePtr,ExpectedLength)  )    {        CmdPtr = (CS_AppNameCmd_t *) MessagePtr;                CmdPtr -> Name[OS_MAX_API_NAME - 1] = '/0';                if ( CS_GetAppResTblEntryByName( &ResultsEntry, CmdPtr -> Name))        {                        ResultsEntry -> State = CS_STATE_DISABLED;            ResultsEntry -> TempChecksumValue = 0;            ResultsEntry -> ByteOffset = 0;                        CFE_EVS_SendEvent (CS_DISABLE_APP_NAME_INF_EID,                               CFE_EVS_INFORMATION,                               "Checksumming of app %s is Disabled",                                CmdPtr -> Name);                        if ( CS_GetAppDefTblEntryByName(&DefinitionEntry, CmdPtr -> Name))            {                DefinitionEntry -> State = CS_STATE_DISABLED;                CS_ResetTablesTblResultEntry(CS_AppData.AppResTablesTblPtr);                                CFE_TBL_Modified(CS_AppData.DefAppTableHandle);            }            else             {                CFE_EVS_SendEvent (CS_DISABLE_APP_DEF_NOT_FOUND_DBG_EID,                                   CFE_EVS_DEBUG,                                   "CS unable to update apps definition table for entry %s",                                    CmdPtr -> Name);            }                        CS_AppData.CmdCounter++;        }        else        {            CFE_EVS_SendEvent (CS_DISABLE_APP_UNKNOWN_NAME_ERR_EID,                               CFE_EVS_ERROR,                               "App disable app command failed, app %s not found",                               CmdPtr -> Name);            CS_AppData.CmdErrCounter++;        }    }    return;} /* End of CS_DisableNameAppCmd () */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */void TO_RemovePkt(TO_REMOVE_PKT_t * pCmd){    int32  status;    status = CFE_SB_Unsubscribe(pCmd->Stream, TO_Tlm_pipe);    if(status != CFE_SUCCESS)       CFE_EVS_SendEvent(TO_REMOVEPKT_ERR_EID,CFE_EVS_ERROR,"L%d TO Can't Unsubscribe to Stream 0x%x on pipe %d, status %i",__LINE__,                         pCmd->Stream, TO_Tlm_pipe, status);    else       CFE_EVS_SendEvent(TO_REMOVEPKT_INF_EID,CFE_EVS_INFORMATION,"L%d TO RemovePkt 0x%x",__LINE__, pCmd->Stream);} /* End of TO_RemovePkt() */

void CI_TaskInit(void){    CFE_ES_RegisterApp() ;    CFE_EVS_Register(CI_EventFilters,                     sizeof(CI_EventFilters)/sizeof(CFE_EVS_BinFilter_t),                     CFE_EVS_BINARY_FILTER);    CFE_SB_CreatePipe(&CI_CommandPipe, CI_PIPE_DEPTH,"CI_CMD_PIPE");    CFE_SB_Subscribe(CI_CMD_MID, CI_CommandPipe);    CFE_SB_Subscribe(CI_SEND_HK_MID, CI_CommandPipe);    if ( (CI_SocketID = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)    {        CFE_EVS_SendEvent(CI_SOCKETCREATE_ERR_EID,CFE_EVS_ERROR,"CI: create socket failed = %d", errno);    }    else    {       bzero((char *) &CI_SocketAddress, sizeof(CI_SocketAddress));       CI_SocketAddress.sin_family      = AF_INET;       CI_SocketAddress.sin_addr.s_addr = htonl(INADDR_ANY);       CI_SocketAddress.sin_port        = htons(cfgCI_PORT);       if ( (bind(CI_SocketID, (struct sockaddr *) &CI_SocketAddress, sizeof(CI_SocketAddress)) < 0) )       {           CFE_EVS_SendEvent(CI_SOCKETBIND_ERR_EID,CFE_EVS_ERROR,"CI: bind socket failed = %d", errno);       }       else       {           CI_SocketConnected = TRUE;           #ifdef _HAVE_FCNTL_              /*              ** Set the socket to non-blocking              ** This is not available to vxWorks, so it has to be              ** Conditionally compiled in              */              fcntl(CI_SocketID, F_SETFL, O_NONBLOCK);           #endif       }    }    CI_ResetCounters();    CFE_SB_InitMsg(&CI_HkTelemetryPkt,                   CI_HK_TLM_MID,                   CI_HK_TLM_LNGTH, TRUE);    /*    ** Install the delete handler    */    OS_TaskInstallDeleteHandler((void*)&CI_delete_callback);    CFE_EVS_SendEvent(CI_STARTUP_INF_EID,CFE_EVS_INFORMATION, "CI App Initialized");} /* End of CI_TaskInit() */

/******************************************************************************** Function: TBLMGR_LoadExObjTableCmd***/boolean TBLMGR_LoadExObjTableCmd(const CFE_SB_MsgPtr_t MsgPtr){   const  TBLMGR_LoadTblCmd *LoadTblCmd = (const TBLMGR_LoadTblCmd *) MsgPtr;   int    entry;   /*   ** Set all data and flags to zero.   ** AttrErrCnt - Incremented by XML parser   */	   CFE_PSP_MemSet(&TblMgr->ExObjTbl, 0, sizeof(TBLMGR_ExObjTbl));   TblMgr->ExObjTbl.LoadActive = TRUE;   TblEntryId = 0;   if (ParseXmlFile(LoadTblCmd->FileName, ExObjTblStartElement, ExObjTblEndElement) &&       TblMgr->ExObjTbl.AttrErrCnt == 0)   {      if (LoadTblCmd->LoadType == TBLMGR_LOAD_TBL_REPLACE)      {         TblMgr->ExObjTbl.LastLoadValid = (EXOBJ_LoadTable(&(TblMgr->ExObjTbl.Local)) == TRUE);      } /* End if replace entire table */      else if (LoadTblCmd->LoadType == TBLMGR_LOAD_TBL_UPDATE)      {         TblMgr->ExObjTbl.LastLoadValid = TRUE;         for (entry=0; entry < EXOBJ_TBL_MAX_ENTRY_ID; entry++)         {            if (TblMgr->ExObjTbl.Modified[entry])            {               if (!EXOBJ_LoadTableEntry(entry, &(TblMgr->ExObjTbl.Local.Entry[entry])))                  TblMgr->ExObjTbl.LastLoadValid = FALSE;            }         } /* End pkt loop */      } /* End if update individual records */      else      {         CFE_EVS_SendEvent(TBLMGR_CMD_LOAD_TYPE_ERR_EID,CFE_EVS_ERROR,"TBLMGR: Invalid table command load type %d",LoadTblCmd->LoadType);      }   } /* End if successful parse */   else   {      CFE_EVS_SendEvent(TBLMGR_CMD_LOAD_PARSE_ERR_EID,CFE_EVS_ERROR,"TBLMGR: Table Parsing failure for file %s");   }   return TblMgr->ExObjTbl.LastLoadValid;} /* End of TBLMGR_LoadExObjTableCmd() */

void TT_AppPipe(CFE_SB_MsgPtr_t msg){    CFE_SB_MsgId_t MessageID;    uint16 CommandCode;    MessageID = CFE_SB_GetMsgId(msg);    switch (MessageID)    {        /*        ** Housekeeping telemetry request...        */        case CFE_TT_SEND_HK_MID:            TT_HousekeepingCmd(msg);            break;        /*        ** TT ground commands...        */        case CFE_TT_CMD_MID:            CommandCode = CFE_SB_GetCmdCode(msg);            switch (CommandCode)            {                case TT_NOOP_CC:                    TT_NoopCmd(msg);                    break;                case TT_RESET_CC:                    TT_ResetCmd(msg);                    break;                default:                    CFE_EVS_SendEvent(TT_CC1_ERR_EID, CFE_EVS_ERROR,                     "Invalid ground command code: ID = 0x%X, CC = %d",                                      MessageID, CommandCode);                    break;            }            break;        default:            CFE_EVS_SendEvent(TT_MID_ERR_EID, CFE_EVS_ERROR,                             "Invalid command pipe message ID: 0x%X",                              MessageID);            break;    }    return;} /* End of TT_AppPipe() */

int32 SC_GetLoadTablePointers(void){    int i;    int32 Result;    /* Get buffer address for loadable ATS tables */    for (i = 0; i < SC_NUMBER_OF_ATS; i++)    {                Result = CFE_TBL_GetAddress((void **) &SC_OperData.AtsTblAddr[i], SC_OperData.AtsTblHandle[i]);                                                if ((Result != CFE_TBL_ERR_NEVER_LOADED) && (Result != CFE_TBL_INFO_UPDATED))        {            CFE_EVS_SendEvent(SC_GET_ADDRESS_ATS_ERR_EID, CFE_EVS_ERROR,               "ATS table %d failed Getting Address, returned: 0x%08X", i+1, Result);            return(Result);        }    }    /* Get buffer address for loadable ATS Append table */    Result = CFE_TBL_GetAddress((void **) &SC_OperData.AppendTblAddr, SC_OperData.AppendTblHandle);    if ((Result !=  CFE_TBL_ERR_NEVER_LOADED) && (Result !=  CFE_TBL_INFO_UPDATED))    {        CFE_EVS_SendEvent (SC_GET_ADDRESS_APPEND_ERR_EID, CFE_EVS_ERROR,           "Append ATS table failed Getting Address, returned: 0x%08X", Result);        return(Result);    }    /* Get buffer address for loadable RTS tables */    for (i = 0; i < SC_NUMBER_OF_RTS; i++)    {        Result = CFE_TBL_GetAddress((void **) &SC_OperData.RtsTblAddr[i], SC_OperData.RtsTblHandle[i]);                if ((Result != CFE_TBL_ERR_NEVER_LOADED) && (Result != CFE_TBL_INFO_UPDATED))        {            CFE_EVS_SendEvent(SC_GET_ADDRESS_RTS_ERR_EID, CFE_EVS_ERROR,               "RTS table %d failed Getting Address, returned: 0x%08X", i+1, Result);            return(Result);        }                /* Process new RTS table data */        if (Result == CFE_TBL_INFO_UPDATED)        {            SC_LoadRts(i);        }     }        return(CFE_SUCCESS);   } /* end SC_GetLoadTablePointers() */

/******************************************************************************** Function: DumpTableToFile***/static boolean DumpTableToFile(const char* FileName, const char* FileDescr, DumpTableFuncPtr DumpTableFunc){   CFE_FS_Header_t  CfeStdFileHeader;   int32            FileHandle;   int32            FileStatus;   boolean          RetStatus = FALSE;   /* Create a new dump file, overwriting anything that may have existed previously */   FileHandle = OS_creat(FileName, OS_WRITE_ONLY);   if (FileHandle >= OS_FS_SUCCESS)   {      /* Initialize the standard cFE File Header for the Dump File */      CfeStdFileHeader.SubType = 0x74786574;      strcpy(&CfeStdFileHeader.Description[0], FileDescr);      /* Output the Standard cFE File Header to the Dump File */      FileStatus = CFE_FS_WriteHeader(FileHandle, &CfeStdFileHeader);      if (FileStatus == sizeof(CFE_FS_Header_t))      {         (DumpTableFunc)(FileHandle);         RetStatus = TRUE;      } /* End if successfully wrote file header */      else      {          CFE_EVS_SendEvent(TBLMGR_WRITE_CFE_HDR_ERR_EID,                            CFE_EVS_ERROR,                            "Error writing cFE File Header to '%s', Status=0x%08X",                            FileName, FileStatus);      }   } /* End if file create */   else   {        CFE_EVS_SendEvent(TBLMGR_CREATE_MSG_DUMP_ERR_EID,                          CFE_EVS_ERROR,                          "Error creating CDS dump file '%s', Status=0x%08X",                          FileName, FileHandle);    }   OS_close(FileHandle);   return RetStatus;} /* End of DumpTableToFile() */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */void TO_exec_local_command(CFE_SB_MsgPtr_t cmd){    uint16 CommandCode;    boolean valid = TRUE;    CommandCode = CFE_SB_GetCmdCode(cmd);    switch (CommandCode)    {       case TO_NOP_CC:            CFE_EVS_SendEvent(TO_NOOP_INF_EID,CFE_EVS_INFORMATION, "No-op command");            break;       case TO_RESET_STATUS_CC:            TO_reset_status();            --to_hk_status.command_counter;            break;       case TO_SEND_DATA_TYPES_CC:            TO_output_data_types_packet();            break;       case TO_ADD_PKT_CC:            TO_AddPkt((TO_ADD_PKT_t *)cmd);            break;       case TO_REMOVE_PKT_CC:            TO_RemovePkt( (TO_REMOVE_PKT_t *)cmd);            break;       case TO_REMOVE_ALL_PKT_CC:            TO_RemoveAllPkt();            break;       case TO_OUTPUT_ENABLE_CC:            TO_StartSending( (TO_OUTPUT_ENABLE_PKT_t *)cmd );            downlink_on = TRUE;            break;       default:            CFE_EVS_SendEvent(TO_FNCODE_ERR_EID,CFE_EVS_ERROR, "L%d TO: Invalid Function Code Rcvd In Ground Command 0x%x",__LINE__,                              CommandCode);            valid = FALSE;    }    if (valid)       ++to_hk_status.command_counter;    else       ++to_hk_status.command_error_counter;} /* End of TO_exec_local_command() */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */int32 HS_CustomInit(void){    int32 Status = CFE_SUCCESS;    /*    ** Spawn the Idle Task    */    Status = CFE_ES_CreateChildTask(&HS_CustomData.IdleTaskID,                                           HS_IDLE_TASK_NAME,                                            HS_IdleTask,                                              HS_IDLE_TASK_STACK_PTR,                                       HS_IDLE_TASK_STACK_SIZE,                                      HS_IDLE_TASK_PRIORITY,                                        HS_IDLE_TASK_FLAGS);              if(Status != CFE_SUCCESS)    {        CFE_EVS_SendEvent(HS_CR_CHILD_TASK_ERR_EID, CFE_EVS_ERROR,                          "Error Creating Child Task for CPU Utilization Monitoring,RC=0x%08X",                          Status);        return (Status);    }    /*    ** Connect to CFE TIME's time reference marker (typically 1 Hz) for Idle Task Marking    */    Status = CFE_TIME_RegisterSynchCallback((CFE_TIME_SynchCallbackPtr_t)&HS_MarkIdleCallback);    if (Status != CFE_SUCCESS)    {        CFE_EVS_SendEvent(HS_CR_SYNC_CALLBACK_ERR_EID, CFE_EVS_ERROR,                          "Error Registering Sync Callback for CPU Utilization Monitoring,RC=0x%08X",                          Status);    }    HS_CustomData.UtilMult1 = HS_UTIL_CONV_MULT1;    HS_CustomData.UtilMult2 = HS_UTIL_CONV_DIV;    HS_CustomData.UtilDiv   = HS_UTIL_CONV_MULT2;    HS_CustomData.UtilMask  = HS_UTIL_DIAG_MASK;    HS_CustomData.UtilCycleCounter = 0;    HS_CustomData.UtilMask = HS_UTIL_DIAG_MASK;    HS_CustomData.UtilArrayIndex = 0;    HS_CustomData.UtilArrayMask = HS_UTIL_TIME_DIAG_ARRAY_MASK;    HS_CustomData.ThisIdleTaskExec = 0;    HS_CustomData.LastIdleTaskExec = 0;    HS_CustomData.LastIdleTaskInterval = 0;    return(Status);} /* end HS_CustomInit */

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */void CFE_ES_PerfStartDataCmd(CFE_SB_MsgPtr_t msg){   uint16 ExpectedLength = sizeof(CFE_ES_PerfStartCmd_t);   CFE_ES_PerfStartCmd_t *CmdPtr = (CFE_ES_PerfStartCmd_t *)msg;   /*    ** Verify command packet length.    */    if (CFE_ES_VerifyCmdLength(msg, ExpectedLength))    {      /* Ensure there is no file write in progress before proceeding */      if(CFE_ES_PerfLogDumpStatus.DataToWrite == 0)      {          /* Make sure Trigger Mode is valid */          if ((CmdPtr->TriggerMode >= CFE_ES_PERF_TRIGGER_START) && (CmdPtr->TriggerMode < CFE_ES_PERF_MAX_MODES))          {             CFE_ES_TaskData.CmdCounter++;             Perf->MetaData.Mode = CmdPtr->TriggerMode;             Perf->MetaData.TriggerCount = 0;             Perf->MetaData.DataStart = 0;             Perf->MetaData.DataEnd = 0;             Perf->MetaData.DataCount = 0;             Perf->MetaData.InvalidMarkerReported = FALSE;             Perf->MetaData.State = CFE_ES_PERF_WAITING_FOR_TRIGGER; /* this must be done last */             CFE_EVS_SendEvent(CFE_ES_PERF_STARTCMD_EID, CFE_EVS_DEBUG,                                 "Start collecting performance data cmd received, trigger mode = %d",                                  CmdPtr->TriggerMode);          }          else          {             CFE_ES_TaskData.ErrCounter++;             CFE_EVS_SendEvent(CFE_ES_PERF_STARTCMD_TRIG_ERR_EID, CFE_EVS_ERROR,                  "Cannot start collecting performance data, trigger mode (%d) out of range (%d to %d)",                   CmdPtr->TriggerMode, CFE_ES_PERF_TRIGGER_START, CFE_ES_PERF_TRIGGER_END);          }/* end if */       }       else       {          CFE_ES_TaskData.ErrCounter++;          CFE_EVS_SendEvent(CFE_ES_PERF_STARTCMD_ERR_EID, CFE_EVS_ERROR,               "Cannot start collecting performance data,perf data write in progress");       } /* end if */    }/* end if */} /* End of CFE_ES_PerfStartDataCmd() */

void THRSIM_TaskMain(void) {    uint32 RunStatus = CFE_ES_APP_RUN;    int32  Status = CFE_SUCCESS;    CFE_ES_PerfLogEntry(THRSIM_MAIN_TASK_PERF_ID);    Status = THRSIM_Init();    if (Status != CFE_SUCCESS) {        RunStatus = CFE_ES_APP_ERROR;    }    while (CFE_ES_RunLoop(&RunStatus) == TRUE) {        CFE_ES_PerfLogExit(THRSIM_MAIN_TASK_PERF_ID);        Status = CFE_SB_RcvMsg(&THRSIM_AppData.MsgPtr, THRSIM_AppData.CmdPipe, CFE_SB_PEND_FOREVER);        CFE_ES_PerfLogEntry(THRSIM_MAIN_TASK_PERF_ID);        if (Status == CFE_SUCCESS) {            THRSIM_AppPipe();        } else {            CFE_EVS_SendEvent(THRSIM_PIPE_ERR_EID, CFE_EVS_ERROR, "SB pipe read error, THRSIM will exit.");            RunStatus = CFE_ES_APP_ERROR;        }    }}

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */void TO_process_commands(void){    CFE_SB_Msg_t    *MsgPtr;    CFE_SB_MsgId_t  MsgId;    while(1)    {       switch (CFE_SB_RcvMsg(&MsgPtr, TO_Cmd_pipe, CFE_SB_POLL))       {          case CFE_SUCCESS:               MsgId = CFE_SB_GetMsgId(MsgPtr);               /* For SB return statuses that imply a message: process it. */               switch (MsgId)               {                  case TO_LAB_CMD_MID:                       TO_exec_local_command(MsgPtr);                       break;                  case TO_LAB_SEND_HK_MID:                       TO_output_status();                       break;                  default:                       CFE_EVS_SendEvent(TO_MSGID_ERR_EID,CFE_EVS_ERROR, "L%d TO: Invalid Msg ID Rcvd 0x%x",__LINE__,MsgId);                       break;               }               break;            default:               /* Exit command processing loop if no message received. */               return;       }    }} /* End of TO_process_commands() */

void $APPLICATION_NAME$_ProcessGroundCommand(void){    uint16 CommandCode;    CommandCode = CFE_SB_GetCmdCode($APPLICATION_NAME$_MsgPtr);    /* Process "known" $Application Name$ app ground commands */    switch (CommandCode)    {        case $APPLICATION_NAME$_APP_NOOP_CC:            $APPLICATION_NAME$_HkTelemetryPkt.$application_name$_command_count++;            CFE_EVS_SendEvent($APPLICATION_NAME$_COMMANDNOP_INF_EID,CFE_EVS_INFORMATION,			"$Application Name$: NOOP command");            break;        case $APPLICATION_NAME$_APP_RESET_COUNTERS_CC:            $APPLICATION_NAME$_ResetCounters();            break;        /* default case already found during FC vs length test */        default:            break;    }    return;} /* End of $APPLICATION_NAME$_ProcessGroundCommand() */

/* * * * * * * * * * * * * * * * * * * * * * * *  * * * * * * *  * *  * * * * * *  * * * */void CI_ProcessCommandPacket(void){    CFE_SB_MsgId_t  MsgId;    MsgId = CFE_SB_GetMsgId(CIMsgPtr);    switch (MsgId)    {        case CI_CMD_MID:            CI_ProcessGroundCommand();            break;        case CI_SEND_HK_MID:            CI_ReportHousekeeping();            break;        default:            CI_HkTelemetryPkt.ci_command_error_count++;            CFE_EVS_SendEvent(CI_COMMAND_ERR_EID,CFE_EVS_ERROR,"CI: invalid command packet,MID = 0x%x",                              MsgId);            break;    }    return;} /* End CI_ProcessCommandPacket */

void TO_ProcessCmdMsg(void){    CFE_SB_Msg_t    *MsgPtr;    CFE_SB_MsgId_t  MsgId;    while(1)    /* While loop to execute until all commands received */    {       /* Check for message on cmd pipe and process */       switch (CFE_SB_RcvMsg(&MsgPtr, TO_AppData.CmdPipe, CFE_SB_POLL))       {          case CFE_SUCCESS:               MsgId = CFE_SB_GetMsgId(MsgPtr);               switch (MsgId)               {                  case TO_CMD_MID:                	   /* Call Command Exec Function */                       TO_CmdExec(MsgPtr);                       break;                  default:                       CFE_EVS_SendEvent(TO_MSGID_ERR_EID,CFE_EVS_ERROR,                    		         "TO: Cmd Pipe Invalid Msg ID Rcvd 0x%x",                    		         MsgId);                       break;               }               break;            default:               /* Exit command processing loop if no message received. */               return;       }    }}

void TO_ProcessSchMsg(void){	CFE_SB_MsgId_t  MsgId;	MsgId = CFE_SB_GetMsgId(TO_AppData.MsgPtr);    switch (MsgId)    {    	case TO_SEND_TLM_MID:    	{    		/* Ouput Telemetry */    		TO_SendTlm_t *msg = (TO_SendTlm_t *)TO_AppData.MsgPtr;            TO_ForwardTelemetry(msg->PrioMask);            break;    	}        case TO_SEND_HK_MID:    	{             TO_OutputStatus();             break;    	}        default:    	{             CFE_EVS_SendEvent(TO_MSGID_ERR_EID,CFE_EVS_ERROR,            		           "TO: Sch Pipe Invalid Msg ID Rcvd 0x%x",MsgId);             break;    	}    }}

void EIM_ResetTlmConnection(void){	int status = 0;	struct sockaddr_in si_tmp;	char cBuf[] = {1,0,0,0,0,0,0,0,0,0,0,0,0,0};	int len=14;	OS_printf("EIM: Sending reset message./n");    memset((char *) &si_tmp, 0, sizeof(si_tmp));    si_tmp.sin_family      = AF_INET;    inet_aton(EIM_WIFI_IP, &si_tmp.sin_addr);    si_tmp.sin_port        = htons(EIM_NAV_DATA_PORT);	status = sendto(EIM_AppData.NavSocketID, cBuf, len, 0,				(struct sockaddr *) &si_tmp, sizeof(si_tmp) );	if ( status < 0 )	{		CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR, "EIM: Failed to send NAVDATA reset.  errno: %d", errno);		CFE_ES_ExitChildTask();	}	else	{		OS_printf("EIM: Reset message sent./n");	}}

void UU_AppMain(void){	int32 Status;	int32 Status2;	CFE_SB_PipeId_t pipeId;	char pipeName[10];	void *TblPointer;	CFE_TBL_Handle_t TblHandle;	    /*    ** Register application...    */    /* CFE_ES_RegisterApp(); */    /*    ** Perform application specific initialize     ** including access initial table values.    */    UU_AppInit();    TblHandle = 0; /* original was 5 */                              /*    ** Main process loop (forever)...    */    while (TRUE)    {     	            /*        ** Wait for the next Software Bus message...        */        Status = CFE_SB_RcvMsg(&UU_AppData.MsgPtr,                                  UU_AppData.CmdPipe,                                  4);                                       /*   if (Status == CFE_SB_TIME_OUT) */        if (1)        {        	UTF_put_text("CFE_ES_ResetCFE returned %lx/n",CFE_ES_ResetCFE(5));        	        	UTF_put_text("CFE_ES_RegisterApp returned %lx/n",CFE_ES_RegisterApp());        	  /* This one caused a seg fault */        	  /*UTF_put_text("CFE_ES_GetAppID returned %d/n",CFE_ES_GetAppID((uint32 *)0x3344beef)); */       	   UTF_put_text("CFE_ES_GetAppID returned %lx/n",CFE_ES_GetAppID(0));       	          	   Status2 = CFE_EVS_SendEvent(UU_INIT_INF_EID,                      CFE_EVS_INFORMATION,                     "UU: SendEvent called from UU task's forever loop");           UTF_put_text("CFE_EVS_SendEvent returned %lx/n", Status2);           UTF_put_text("CFE_FS_ReadHeader returned %lx/n", CFE_FS_ReadHeader(0,0));       	   UTF_put_text("CFE_SB_CreatePipe returned %lx/n", CFE_SB_CreatePipe(&pipeId,1,pipeName));       	   UTF_put_text("CFE_SB_RcvMsg returned %lx/n", Status);       	   UTF_put_text(" CFE_TBL_GetAddress returned %lx/n",        	                  CFE_TBL_GetAddress( &TblPointer,TblHandle ));        }                    }} /* End of UU_AppMain() */

/******************************************************************************** Function: ProcessCommands***/static void ProcessCommands(void){   int32           Status;   CFE_SB_Msg_t*   CmdMsgPtr;   CFE_SB_MsgId_t  MsgId;   Status = CFE_SB_RcvMsg(&CmdMsgPtr, LabTlm.CmdPipe, CFE_SB_POLL);   if (Status == CFE_SUCCESS)   {      MsgId = CFE_SB_GetMsgId(CmdMsgPtr);      switch (MsgId)      {         case LABTLM_CMD_MID:            CMDMGR_DispatchFunc(CmdMsgPtr);            break;         case LABTLM_SEND_HK_MID:            LABTLM_SendHousekeepingPkt();            break;         default:            CFE_EVS_SendEvent(LABTLM_INVALID_MID_ERR_EID, CFE_EVS_ERROR,                              "Received invalid command packet,MID = 0x%4X",MsgId);            break;      } /* End Msgid switch */   } /* End if SB received a packet */} /* End ProcessCommands() */

/* * * * * * * * * * * * * * * * * * * * * * * *  * * * * * * *  * *  * * * * */void $APPLICATION_NAME$_ProcessCommandPacket(void){    CFE_SB_MsgId_t  MsgId;    MsgId = CFE_SB_GetMsgId($APPLICATION_NAME$_MsgPtr);    switch (MsgId)    {        case $APPLICATION_NAME$_APP_CMD_MID:            $APPLICATION_NAME$_ProcessGroundCommand();            break;        case $APPLICATION_NAME$_APP_SEND_HK_MID:            $APPLICATION_NAME$_ReportHousekeeping();            break;        default:            $APPLICATION_NAME$_HkTelemetryPkt.$application_name$_command_error_count++;            CFE_EVS_SendEvent($APPLICATION_NAME$_COMMAND_ERR_EID,CFE_EVS_ERROR,			"$Application Name$: invalid command packet,MID = 0x%x", MsgId);            break;    }    return;} /* End $APPLICATION_NAME$_ProcessCommandPacket */

/*** Test enable/disable of port outputs*/void Test_Ports (void){  CFE_EVS_BitMaskCmd_t    bitmaskcmd;  /* TEST: enable all ports, reports implicitly via port output output */  bitmaskcmd.BitMask = 0x0F;  UT_SetSBTotalMsgLen(sizeof(CFE_EVS_BitMaskCmd_t));  UT_SendMsg((CFE_SB_MsgPtr_t)&bitmaskcmd, CFE_EVS_CMD_MID,             CFE_EVS_ENABLE_PORTS_CC);  /* Send a message to test the ports */  CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "Test ports message");  /* Disable all ports to cut down on unneeded output */  bitmaskcmd.BitMask = 0x0F;  UT_SendMsg((CFE_SB_MsgPtr_t)&bitmaskcmd, CFE_EVS_CMD_MID,             CFE_EVS_DISABLE_PORTS_CC);  /* Test sending a bitmask that is out of range */  bitmaskcmd.BitMask = 0xFF;  UT_SendMsg((CFE_SB_MsgPtr_t)&bitmaskcmd, CFE_EVS_CMD_MID,             CFE_EVS_ENABLE_PORTS_CC);  UT_SendMsg((CFE_SB_MsgPtr_t)&bitmaskcmd, CFE_EVS_CMD_MID,             CFE_EVS_DISABLE_PORTS_CC);}

/*** Test functions using an unregistered application*/void Test_UnregisteredApp (void){  /* Unregister the application (it gets registered in CFE_EVS_TaskInit) */  CFE_EVS_Unregister();    /* TEST: application not registered */  UT_Report(CFE_EVS_Unregister() == CFE_EVS_APP_NOT_REGISTERED,            "CFE_EVS_Unregister","app not registered");  UT_Report(CFE_EVS_SendEvent(0, 0, "NULL") == CFE_EVS_APP_NOT_REGISTERED,            "CFE_EVS_SendEvent", "app not registered");  UT_Report(CFE_EVS_ResetFilter(0) == CFE_EVS_APP_NOT_REGISTERED,            "CFE_EVS_ResetFilter", "app not registered");    UT_Report(CFE_EVS_ResetAllFilters() == CFE_EVS_APP_NOT_REGISTERED,            "CFE_EVS_ResetAllFilters", "app not registered");  /* Return application to original state, register application */  CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER);}

void CFE_TIME_ResetCmd(void){    CFE_TIME_TaskData.CmdCounter = 0;    CFE_TIME_TaskData.ErrCounter = 0;    CFE_TIME_TaskData.ToneMatchCount  = 0;    CFE_TIME_TaskData.ToneMatchErrors = 0;    CFE_TIME_TaskData.ToneSignalCount = 0;    CFE_TIME_TaskData.ToneDataCount   = 0;    CFE_TIME_TaskData.ToneIntCount    = 0;    CFE_TIME_TaskData.ToneIntErrors   = 0;    CFE_TIME_TaskData.ToneTaskCount   = 0;    CFE_TIME_TaskData.VersionCount    = 0;    CFE_TIME_TaskData.LocalIntCount   = 0;    CFE_TIME_TaskData.LocalTaskCount  = 0;    CFE_TIME_TaskData.InternalCount   = 0;    CFE_TIME_TaskData.ExternalCount   = 0;    CFE_EVS_SendEvent(CFE_TIME_RESET_EID, CFE_EVS_DEBUG,                     "Reset Counters command");    return;} /* End of CFE_TIME_ResetCmd() */

/*** Test long and short format, also long string*/void Test_Format (void){  int i;  char long_msg[CFE_EVS_MAX_MESSAGE_LENGTH + 2];  CFE_TIME_SysTime_t  time;  CFE_EVS_ModeCmd_t   modecmd;  /* TEST: invalid command to set format */  modecmd.Mode = -1;  UT_SetSBTotalMsgLen(sizeof(CFE_EVS_ModeCmd_t));  UT_SendMsg((CFE_SB_MsgPtr_t)&modecmd, CFE_EVS_CMD_MID,             CFE_EVS_SET_EVENT_FORMAT_MODE_CC);  /* TEST: valid command to set short format, reports implicitly via event */  modecmd.Mode = CFE_EVS_SHORT_FORMAT;  UT_SendMsg((CFE_SB_MsgPtr_t)&modecmd, CFE_EVS_CMD_MID,             CFE_EVS_SET_EVENT_FORMAT_MODE_CC);  CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "FAILED : short format selected");  /* TEST; valid command to set long format, reports implicitly via event */  modecmd.Mode = CFE_EVS_LONG_FORMAT;  UT_SendMsg((CFE_SB_MsgPtr_t)&modecmd, CFE_EVS_CMD_MID,             CFE_EVS_SET_EVENT_FORMAT_MODE_CC);  CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "PASSED : long format selected");  CFE_EVS_SendTimedEvent(time, 0, CFE_EVS_INFORMATION,                         "PASSED : long format selected (SendTimedEvent)");  CFE_EVS_SendEventWithAppID(0, CFE_EVS_INFORMATION, 0,                         "PASSED : long format selected (SendEventWithAppID)");  /* TEST: Send information message with > MAX string length */  for (i = 0; i <= CFE_EVS_MAX_MESSAGE_LENGTH; i++)    long_msg[i] = (char)(i%10 + 48);  long_msg[CFE_EVS_MAX_MESSAGE_LENGTH + 1] = '/0';  UT_Report(CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, long_msg) == CFE_SUCCESS,            "CFE_EVS_SendEvent", "sent info msg with > MAX string length");  UT_Report(CFE_EVS_SendEventWithAppID(0, CFE_EVS_INFORMATION,0, long_msg) == CFE_SUCCESS,            "CFE_EVS_SendEventWithAppID", "sent info msg with > MAX string length");  UT_Report(CFE_EVS_SendTimedEvent(time,0, CFE_EVS_INFORMATION, long_msg) == CFE_SUCCESS,            "CFE_EVS_SendTimedEvent", "sent info msg with > MAX string length");}

void CFE_TIME_AdjustCmd(CFE_SB_MsgPtr_t MessagePtr, int16 Direction){    CFE_TIME_TimeCmd_t *CommandPtr = (CFE_TIME_TimeCmd_t *) MessagePtr;    /*    ** Verify command arguments...    */    if (CommandPtr->MicroSeconds < 1000000)    {        #if (CFE_TIME_CFG_SERVER == TRUE)        CFE_TIME_SysTime_t Adjust;        Adjust.Seconds = CommandPtr->Seconds;        Adjust.Subseconds = CFE_TIME_Micro2SubSecs(CommandPtr->MicroSeconds);        CFE_TIME_SetAdjust(Adjust, Direction);        CFE_TIME_TaskData.CmdCounter++;        CFE_EVS_SendEvent(CFE_TIME_DELTA_EID, CFE_EVS_INFORMATION,           "STCF Adjust -- secs = %d, usecs = %d, ssecs = 0x%X, dir[1=Pos, 2=Neg] = %d",                          CommandPtr->Seconds, CommandPtr->MicroSeconds,                          CFE_TIME_Micro2SubSecs(CommandPtr->MicroSeconds),                          Direction);        #else /* not CFE_TIME_CFG_SERVER */        /*        ** We want to know if disabled commands are being sent...        */        CFE_TIME_TaskData.ErrCounter++;        CFE_EVS_SendEvent(CFE_TIME_DELTA_CFG_EID, CFE_EVS_ERROR,           "STCF Adjust commands invalid without CFE_TIME_CFG_SERVER set to TRUE");        #endif /* CFE_TIME_CFG_SERVER */    }    else    {        CFE_TIME_TaskData.ErrCounter++;        CFE_EVS_SendEvent(CFE_TIME_DELTA_ERR_EID, CFE_EVS_ERROR,           "Invalid STCF Adjust -- secs = %d, usecs = %d, dir[1=Pos, 2=Neg] = %d",                          CommandPtr->Seconds, CommandPtr->MicroSeconds, Direction);    }    return;} /* End of CFE_TIME_AdjustCmd() */