/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
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() */
