/******************************************************************************
** 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 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_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 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 $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 */
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() */
boolean THRSIM_VerifyCmdLength(CFE_SB_MsgPtr_t Msg, uint16 ExpectedLength) {
boolean result = TRUE;
uint16 ActualLength = CFE_SB_GetTotalMsgLength(Msg);
if (ExpectedLength != ActualLength) {
CFE_SB_MsgId_t MessageId = CFE_SB_GetMsgId(Msg);
uint16 CommandCode = CFE_SB_GetCmdCode(Msg);
CFE_EVS_SendEvent(THRSIM_MSGLEN_ERR_EID, CFE_EVS_ERROR, "Invalid cmd length: MID = 0x%04X, CC = %02u, Exp Len = %u, Len = %u", MessageId, CommandCode, ExpectedLength, ActualLength);
result = FALSE;
THRSIM_AppData.HkPacket.error_count++;
}
return result;
}
boolean Ut_CFE_SB_PacketSent(uint16 MessageID)
{
UtListNode_t *CurrentNode;
CFE_SB_Msg_t *MessagePtr;
CurrentNode = UtList_First(&MsgQueue);
while (CurrentNode) {
MessagePtr = CurrentNode->Data;
if (MessageID == CFE_SB_GetMsgId(MessagePtr)) {
return(TRUE);
}
CurrentNode = CurrentNode->Next;
}
return(FALSE);
}
uint32 Ut_CFE_SB_GetMsgCount(uint16 MessageID)
{
UtListNode_t *CurrentNode;
CFE_SB_Msg_t *MessagePtr;
uint32 MessageCount = 0;
CurrentNode = UtList_First(&MsgQueue);
while (CurrentNode) {
MessagePtr = CurrentNode->Data;
if (MessageID == CFE_SB_GetMsgId(MessagePtr)) {
MessageCount++;
}
CurrentNode = CurrentNode->Next;
}
return(MessageCount);
}
void THRSIM_AppPipe(void) {
CFE_SB_MsgId_t MsgId = CFE_SB_GetMsgId(THRSIM_AppData.MsgPtr);
switch (MsgId) {
case THRSIM_CMD_MID:
THRSIM_ProcessGroundCommand();
break;
case THRSIM_SEND_HK_MID:
THRSIM_ReportHousekeeping();
break;
case THRSIM_TICK_MID:
THRSIM_GetValveStates();
break;
default:
CFE_EVS_SendEvent(THRSIM_MSGID_ERR_EID, CFE_EVS_ERROR, "Received invalid MsgId 0x%04X", MsgId);
THRSIM_AppData.HkPacket.error_count++;
break;
}
}
void *Ut_CFE_SB_FindPacket(uint16 MessageID, uint32 MessageNumber)
{
UtListNode_t *CurrentNode;
CFE_SB_Msg_t *MessagePtr;
uint32 MessageCount = 0;
CurrentNode = UtList_First(&MsgQueue);
while (CurrentNode) {
MessagePtr = CurrentNode->Data;
if (MessageID == CFE_SB_GetMsgId(MessagePtr)) {
MessageCount++;
if (MessageCount == MessageNumber) {
return(CurrentNode->Data);
}
}
CurrentNode = CurrentNode->Next;
}
return(NULL);
}
void SIMCI_AppPipe(void) {
CFE_SB_MsgId_t MsgId;
MsgId = CFE_SB_GetMsgId(SIMCI_AppData.MsgPtr);
switch (MsgId)
{
case SIMCI_CMD_MID:
SIMCI_ProcessGroundCommand();
break;
case SIMCI_SEND_HK_MID:
SIMCI_ReportHousekeeping();
break;
default:
SIMCI_AppData.HkPacket.error_count++;
CFE_EVS_SendEvent(SIMCI_MSGID_ERR_EID, CFE_EVS_ERROR, "SIMCI: received invalid MID=0x%08X", MsgId);
break;
}
}
boolean TT_VerifyCmdLength(CFE_SB_MsgPtr_t msg, uint16 ExpectedLength)
{
boolean result = TRUE;
uint16 ActualLength = CFE_SB_GetTotalMsgLength(msg);
/*
** Verify the command packet length...
*/
if (ExpectedLength != ActualLength)
{
CFE_SB_MsgId_t MessageID = CFE_SB_GetMsgId(msg);
uint16 CommandCode = CFE_SB_GetCmdCode(msg);
CFE_EVS_SendEvent(TT_LEN_ERR_EID, CFE_EVS_ERROR,
"TT: Invalid cmd pkt: ID = 0x%X, CC = %d, Len = %d",
MessageID, CommandCode, ActualLength);
result = FALSE;
TT4_AppData.ErrCount++;
}
return(result);
} /* End of TT_VerifyCmdLength() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
boolean $APPLICATION_NAME$_VerifyCmdLength(CFE_SB_MsgPtr_t msg, uint16 ExpectedLength)
{
boolean result = TRUE;
uint16 ActualLength = CFE_SB_GetTotalMsgLength(msg);
/*
** Verify the command packet length.
*/
if (ExpectedLength != ActualLength)
{
CFE_SB_MsgId_t MessageID = CFE_SB_GetMsgId(msg);
uint16 CommandCode = CFE_SB_GetCmdCode(msg);
CFE_EVS_SendEvent($APPLICATION_NAME$_LEN_ERR_EID, CFE_EVS_ERROR,
"Invalid msg length: ID = 0x%X, CC = %d, Len = %d, Expected = %d",
MessageID, CommandCode, ActualLength, ExpectedLength);
result = FALSE;
$APPLICATION_NAME$_HkTelemetryPkt.$application_name$_command_error_count++;
}
return(result);
} /* End of $APPLICATION_NAME$_VerifyCmdLength() */
int32 SCH_AppPipe(CFE_SB_MsgPtr_t MessagePtr)
{
int32 Result = CFE_SUCCESS;
CFE_SB_MsgId_t MessageID = 0;
uint16 CommandCode = 0;
MessageID = CFE_SB_GetMsgId(MessagePtr);
switch (MessageID)
{
/*
** Housekeeping telemetry request
*/
case SCH_SEND_HK_MID:
Result = SCH_HousekeepingCmd(MessagePtr);
break;
/*
** SCH ground commands
*/
case SCH_CMD_MID:
CommandCode = CFE_SB_GetCmdCode(MessagePtr);
switch (CommandCode)
{
case SCH_NOOP_CC:
SCH_NoopCmd(MessagePtr);
break;
case SCH_RESET_CC:
SCH_ResetCmd(MessagePtr);
break;
case SCH_ENABLE_CC:
SCH_EnableCmd(MessagePtr);
break;
case SCH_DISABLE_CC:
SCH_DisableCmd(MessagePtr);
break;
case SCH_ENABLE_GROUP_CC:
SCH_EnableGroupCmd(MessagePtr);
break;
case SCH_DISABLE_GROUP_CC:
SCH_DisableGroupCmd(MessagePtr);
break;
case SCH_ENABLE_SYNC_CC:
SCH_EnableSyncCmd(MessagePtr);
break;
case SCH_SEND_DIAG_TLM_CC:
SCH_SendDiagTlmCmd(MessagePtr);
break;
/*
** SCH ground commands with unknown command codes...
*/
default:
CFE_EVS_SendEvent(SCH_CC_ERR_EID, CFE_EVS_ERROR,
"Invalid command code: ID = 0x%04X, CC = %d",
MessageID, CommandCode);
SCH_AppData.ErrCounter++;
break;
}
break;
/*
** Unknown message ID's
*/
default:
CFE_EVS_SendEvent(SCH_MD_ERR_EID, CFE_EVS_ERROR,
"Msg with Invalid message ID Rcvd -- ID = 0x%04X",
MessageID);
break;
}
return(Result);
} /* End of SCH_AppPipe() */
void CFE_TIME_TaskPipe(CFE_SB_MsgPtr_t MessagePtr)
{
CFE_SB_MsgId_t MessageID;
uint16 CommandCode;
MessageID = CFE_SB_GetMsgId(MessagePtr);
switch (MessageID)
{
/*
** Housekeeping telemetry request...
*/
case CFE_TIME_SEND_HK_MID:
CFE_TIME_HousekeepingCmd();
break;
/*
** Time at the tone "signal"...
*/
case CFE_TIME_TONE_CMD_MID:
CFE_TIME_ToneSignalCmd();
break;
/*
** Time at the tone "data"...
*/
case CFE_TIME_DATA_CMD_MID:
CFE_TIME_ToneDataCmd(MessagePtr);
break;
/*
** Simulate time at the tone "signal"...
*/
#if (CFE_TIME_CFG_FAKE_TONE == TRUE)
case CFE_TIME_FAKE_CMD_MID:
CFE_TIME_FakeToneCmd();
break;
#endif
/*
** Request for time at the tone "data"...
*/
#if (CFE_TIME_CFG_SERVER == TRUE)
#if (CFE_TIME_CFG_SOURCE != TRUE)
#if (CFE_TIME_CFG_FAKE_TONE != TRUE)
case CFE_TIME_SEND_CMD_MID:
CFE_TIME_ToneSendCmd();
break;
#endif
#endif
#endif
/*
** Time task ground commands...
*/
case CFE_TIME_CMD_MID:
CommandCode = CFE_SB_GetCmdCode(MessagePtr);
switch (CommandCode)
{
case CFE_TIME_NOOP_CC:
CFE_TIME_NoopCmd();
break;
case CFE_TIME_RESET_CC:
CFE_TIME_ResetCmd();
break;
case CFE_TIME_DIAG_TLM_CC:
CFE_TIME_DiagCmd();
break;
case CFE_TIME_SET_STATE_CC:
CFE_TIME_SetStateCmd(MessagePtr);
break;
case CFE_TIME_SET_SOURCE_CC:
CFE_TIME_SetSourceCmd(MessagePtr);
break;
case CFE_TIME_SET_SIGNAL_CC:
CFE_TIME_SetSignalCmd(MessagePtr);
break;
/*
** Time Clients process "tone delay" commands...
*/
case CFE_TIME_ADD_DELAY_CC:
CFE_TIME_SetDelayCmd(MessagePtr, (int16) CFE_TIME_ADD_ADJUST);
break;
case CFE_TIME_SUB_DELAY_CC:
CFE_TIME_SetDelayCmd(MessagePtr, (int16) CFE_TIME_SUB_ADJUST);
break;
/*
** Time Servers process "set time" commands...
*/
case CFE_TIME_SET_TIME_CC:
CFE_TIME_SetTimeCmd(MessagePtr);
break;
case CFE_TIME_SET_MET_CC:
CFE_TIME_SetMETCmd(MessagePtr);
break;
case CFE_TIME_SET_STCF_CC:
CFE_TIME_SetSTCFCmd(MessagePtr);
break;
case CFE_TIME_SET_LEAPS_CC:
CFE_TIME_SetLeapsCmd(MessagePtr);
break;
case CFE_TIME_ADD_ADJUST_CC:
CFE_TIME_AdjustCmd(MessagePtr, (int16) CFE_TIME_ADD_ADJUST);
break;
case CFE_TIME_SUB_ADJUST_CC:
CFE_TIME_AdjustCmd(MessagePtr, (int16) CFE_TIME_SUB_ADJUST);
break;
case CFE_TIME_ADD_1HZADJ_CC:
CFE_TIME_1HzAdjCmd(MessagePtr, (int16) CFE_TIME_ADD_ADJUST);
break;
case CFE_TIME_SUB_1HZADJ_CC:
CFE_TIME_1HzAdjCmd(MessagePtr, (int16) CFE_TIME_SUB_ADJUST);
break;
default:
CFE_TIME_TaskData.ErrCounter++;
CFE_EVS_SendEvent(CFE_TIME_CC_ERR_EID, CFE_EVS_ERROR,
"Invalid command code -- ID = 0x%X, CC = %d",
MessageID, CommandCode);
break;
} /* switch (CFE_TIME_CMD_MID -- command code)*/
break;
default:
/*
** Note: we only increment the command error counter when
** processing CFE_TIME_CMD_MID commands...
*/
CFE_EVS_SendEvent(CFE_TIME_ID_ERR_EID, CFE_EVS_ERROR,
"Invalid message ID -- ID = 0x%X",
MessageID);
break;
} /* switch (message ID) */
return;
} /* End of CFE_TIME_TaskPipe() */
void CFE_TBL_TaskPipe(CFE_SB_Msg_t *MessagePtr)
{
CFE_SB_MsgId_t MessageID = CFE_SB_GetMsgId(MessagePtr);
uint16 CommandCode = CFE_SB_GetCmdCode(MessagePtr);
int16 CmdIndx;
uint32 ActualLength;
CFE_TBL_CmdProcRet_t CmdStatus = CFE_TBL_INC_ERR_CTR; /* Assume a failed command */
/* Search the Command Handler Table for a matching message */
CmdIndx = CFE_TBL_SearchCmdHndlrTbl(MessageID, CommandCode);
/* Check to see if a matching command was found */
if (CmdIndx >= 0)
{
/* Verify Message Length before processing */
ActualLength = CFE_SB_GetTotalMsgLength(MessagePtr);
if (ActualLength == CFE_TBL_CmdHandlerTbl[CmdIndx].ExpectedLength)
{
/* All checks have passed, call the appropriate message handler */
CmdStatus = (CFE_TBL_CmdHandlerTbl[CmdIndx].MsgProcFuncPtr)(MessagePtr);
}
else /* Bad Message Length */
{
CFE_EVS_SendEvent( CFE_TBL_LEN_ERR_EID, CFE_EVS_ERROR,
"Invalid msg length -- ID = 0x%04X, CC = %d, Len = %d (!= %d)",
MessageID, CommandCode, ActualLength,
CFE_TBL_CmdHandlerTbl[CmdIndx].ExpectedLength );
}
/* Only update command counters when message has a command code */
if (CFE_TBL_CmdHandlerTbl[CmdIndx].MsgTypes == CFE_TBL_CMD_MSGTYPE)
{
if (CmdStatus == CFE_TBL_INC_CMD_CTR)
{
CFE_TBL_TaskData.CmdCounter++;
}
else if (CmdStatus == CFE_TBL_INC_ERR_CTR)
{
CFE_TBL_TaskData.ErrCounter++;
}
}
}
else
{
/* Determine whether event message should be */
/* "Bad Command Code" or "Bad Message ID" */
if (CmdIndx == CFE_TBL_BAD_CMD_CODE)
{
CFE_EVS_SendEvent(CFE_TBL_CC1_ERR_EID, CFE_EVS_ERROR,
"Invalid command code -- ID = 0x%04X, CC = %d",
MessageID, CommandCode);
/* Update the command error counter */
CFE_TBL_TaskData.ErrCounter++;
}
else /* CmdIndx == CFE_TBL_BAD_MSG_ID */
{
CFE_EVS_SendEvent(CFE_TBL_MID_ERR_EID, CFE_EVS_ERROR,
"Invalid message ID -- ID = 0x%04X",
MessageID);
/*
** Note: we only increment the command error counter when
** processing messages with command codes
*/
}
}
return;
} /* End of CFE_TBL_TaskPipe() */
/* Only doing subset of total messages;
** NOTE: Currently does EVS, TIME
*/
int32 CFE_SB_SendMsg(CFE_SB_Msg_t *MsgPtr)
{
int32 status = CFE_SUCCESS;
boolean flag = FALSE;
CFE_EVS_Packet_t *packet;
#ifdef UT_VERBOSE
int i;
CFE_EVS_TlmPkt_t *tlmpkt;
#endif
if (SBSendMsgRtn.count > 0)
{
SBSendMsgRtn.count--;
if (SBSendMsgRtn.count == 0)
{
status = SBSendMsgRtn.value;
flag = TRUE;
}
}
if (flag == FALSE)
{
/* Process message per type */
switch (CFE_SB_GetMsgId(MsgPtr))
{
case CFE_EVS_EVENT_MSG_MID:
packet = (CFE_EVS_Packet_t *) MsgPtr;
SendMsgEventIDRtn.value = packet->PacketID.EventID;
#ifdef UT_VERBOSE
SNPRINTF(cMsg, UT_MAX_MESSAGE_LENGTH,
" CFE_SB_SendMsg called: type CFE_EVS_EVENT_MSG_MID\n %lu/%lu/%s %u:%s",
packet->PacketID.SpacecraftID,
packet->PacketID.ProcessorID,
packet->PacketID.AppName,
packet->PacketID.EventID,
packet->Message);
UT_Text(cMsg);
#endif
if (*packet->Message != '\0')
{
SendMsgEventIDRtn.count++;
}
break;
case CFE_EVS_HK_TLM_MID:
SendMsgEventIDRtn.value = CFE_EVS_HK_TLM_MID;
#ifdef UT_VERBOSE
tlmpkt = (CFE_EVS_TlmPkt_t *) MsgPtr;
SNPRINTF(cMsg, UT_MAX_MESSAGE_LENGTH,
" CFE_SB_SendMsg: type CFE_EVS_HK_TLM_MID\n"
" CommandCounter = %d\n"
" CommandErrCounter = %d\n"
" MessageFormatMode = %d\n"
" MessageSendCounter = %d\n"
" MessageTruncCounter = %d\n"
" UnregisteredAppCounter = %d\n"
" OutputPort = %d\n LogFullFlag = %d\n"
" LogMode = %d\n LogOverflowCounter = %d",
tlmpkt->CommandCounter, tlmpkt->CommandErrCounter,
tlmpkt->MessageFormatMode, tlmpkt->MessageSendCounter,
tlmpkt->MessageTruncCounter,
tlmpkt->UnregisteredAppCounter, tlmpkt->OutputPort,
tlmpkt->LogFullFlag, tlmpkt->LogMode,
tlmpkt->LogOverflowCounter);
UT_Text(cMsg);
for (i = 0; i < CFE_ES_MAX_APPLICATIONS; i++)
{
SNPRINTF(cMsg, UT_MAX_MESSAGE_LENGTH,
" AppID = %lu\n AppEnableStatus = %d\n "
"AppMessageSentCounter = %d",
tlmpkt->AppData[i].AppID,
tlmpkt->AppData[i].AppEnableStatus,
tlmpkt->AppData[i].AppMessageSentCounter);
UT_Text(cMsg);
}
#endif
break;
case CFE_TIME_DIAG_TLM_MID:
SendMsgEventIDRtn.value = CFE_TIME_DIAG_TLM_MID;
#ifdef UT_VERBOSE
SNPRINTF(cMsg, UT_MAX_MESSAGE_LENGTH,
"Incomplete TIME command: %d",
CFE_SB_GetMsgId(MsgPtr));
UT_Text(cMsg);
#endif
break;
case CFE_TIME_HK_TLM_MID:
SendMsgEventIDRtn.value = CFE_TIME_HK_TLM_MID;
#ifdef UT_VERBOSE
SNPRINTF(cMsg, UT_MAX_MESSAGE_LENGTH,
"Incomplete TIME housekeeping command: %d",
CFE_SB_GetMsgId(MsgPtr));
UT_Text(cMsg);
#endif
break;
default:
/* Process the message with subsystem specific call */
UT_ProcessSBMsg(MsgPtr);
break;
}
}
return status;
}
