/*
** Test reset filter calls
*/
void Test_FilterReset (void)
{
CFE_EVS_BinFilter_t filter;
filter.EventID = 1;
filter.Mask = 0x0001;
CFE_EVS_Register(&filter, 1, CFE_EVS_BINARY_FILTER);
/* TEST: invalid ID for filter reset */
UT_Report(CFE_EVS_ResetFilter(CFE_EVS_MAX_EVENT_FILTERS + 1) == CFE_SUCCESS,
"CFE_EVS_ResetFilter", "invalid event ID");
/* TEST: unregistered ID for filter reset */
UT_Report(CFE_EVS_ResetFilter(-1) == CFE_SUCCESS,
"CFE_EVS_ResetFilter", "unregistered event ID");
/* TEST: valid ID for filter reset */
UT_Report(CFE_EVS_ResetFilter(1) == CFE_SUCCESS,
"CFE_EVS_ResetFilter", "valid reset filter");
/* TEST: valid reset of all filters */
UT_Report(CFE_EVS_ResetAllFilters() == CFE_SUCCESS,
"CFE_EVS_ResetAllFilters", "valid reset all filters");
/* Return application to original state, re-register application */
CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER);
}
/*
** 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 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: LABTLM_Main
**
*/
void LABTLM_Main(void)
{
int32 Status = CFE_SEVERITY_ERROR;
uint32 RunStatus = CFE_ES_APP_ERROR;
Status = CFE_ES_RegisterApp();
CFE_EVS_Register(NULL,0,0);
/*
** Perform application specific initialization
*/
if (Status == CFE_SUCCESS)
{
OS_printf("TO-LAB: About to call init\n");
Status = InitApp();
}
/*
** At this point many flight apps use CFE_ES_WaitForStartupSync() to
** synchronize their startup timing with other apps. This is not
** needed.
*/
if (Status == CFE_SUCCESS) RunStatus = CFE_ES_APP_RUN;
/*
** Main process loop
*/
OS_printf("TO-LAB: About to enter loop\n");
while (CFE_ES_RunLoop(&RunStatus))
{
OS_TaskDelay(LABTLM_RUNLOOP_DELAY);
PKTMGR_OutputTelemetry();
ProcessCommands();
} /* End CFE_ES_RunLoop */
/* Write to system log in case events not working */
CFE_ES_WriteToSysLog("LABTLM App terminating, err = 0x%08X\n", Status);
CFE_EVS_SendEvent(LABTLM_EXIT_ERR_EID, CFE_EVS_CRITICAL, "LABTLM App: terminating, err = 0x%08X", Status);
CFE_ES_ExitApp(RunStatus); /* Let cFE kill the task (and any child tasks) */
} /* End of LABTLM_Main() */
/*
** Test functions using an illegal application ID
*/
void Test_IllegalAppID (void)
{
CFE_TIME_SysTime_t time;
/* Set test up with illegal application ID */
UT_SetAppID(CFE_ES_MAX_APPLICATIONS + 1);
/* Call external functions to test behavior with illegal ID */
UT_Report(CFE_EVS_Register(NULL, 0, 0) == CFE_EVS_APP_ILLEGAL_APP_ID,
"CFE_EVS_Register", "illegal app id");
UT_Report(CFE_EVS_Unregister() == CFE_EVS_APP_ILLEGAL_APP_ID,
"CFE_EVS_Unregister", "illegal app id");
UT_Report(CFE_EVS_SendEvent(0, 0, "NULL") == CFE_EVS_APP_ILLEGAL_APP_ID,
"CFE_EVS_SendEvent", "illegal app id");
UT_Report(CFE_EVS_SendTimedEvent(time, 0, 0,"NULL" ) ==
CFE_EVS_APP_ILLEGAL_APP_ID,
"CFE_EVS_SendTimedEvent", "illegal app id");
UT_Report(CFE_EVS_SendEventWithAppID(0, 0, CFE_ES_MAX_APPLICATIONS + 1, "NULL")
== CFE_EVS_APP_ILLEGAL_APP_ID,
"CFE_EVS_SendEventWithAppID", "illegal app id");
UT_Report(CFE_EVS_ResetFilter(0) == CFE_EVS_APP_ILLEGAL_APP_ID,
"CFE_EVS_ResetFilter", "illegal app id");
UT_Report(CFE_EVS_ResetAllFilters() == CFE_EVS_APP_ILLEGAL_APP_ID,
"CFE_EVS_ResetAllFilters", "illegal app id");
/* Return application ID to valid value */
UT_SetAppID(0);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
void $APPLICATION_NAME$_AppInit(void)
{
/*
** Register the app with Executive services
*/
CFE_ES_RegisterApp() ;
/*
** Register the events
*/
CFE_EVS_Register($APPLICATION_NAME$_EventFilters,
sizeof($APPLICATION_NAME$_EventFilters)/sizeof(CFE_EVS_BinFilter_t),
CFE_EVS_BINARY_FILTER);
/*
** Create the Software Bus command pipe and subscribe to housekeeping
** messages
*/
CFE_SB_CreatePipe(&$APPLICATION_NAME$_CommandPipe, $APPLICATION_NAME$_PIPE_DEPTH,"$APPLICATION_NAME$_CMD_PIPE");
CFE_SB_Subscribe($APPLICATION_NAME$_APP_CMD_MID, $APPLICATION_NAME$_CommandPipe);
CFE_SB_Subscribe($APPLICATION_NAME$_APP_SEND_HK_MID, $APPLICATION_NAME$_CommandPipe);
$APPLICATION_NAME$_ResetCounters();
CFE_SB_InitMsg(&$APPLICATION_NAME$_HkTelemetryPkt,
$APPLICATION_NAME$_APP_HK_TLM_MID,
$APPLICATION_NAME$_APP_HK_TLM_LNGTH, TRUE);
CFE_EVS_SendEvent ($APPLICATION_NAME$_STARTUP_INF_EID, CFE_EVS_INFORMATION,
"$Application Name$ App Initialized. Version %d.%d.%d.%d",
$APPLICATION_NAME$_APP_MAJOR_VERSION,
$APPLICATION_NAME$_APP_MINOR_VERSION,
$APPLICATION_NAME$_APP_REVISION,
$APPLICATION_NAME$_APP_MISSION_REV);
} /* End of $APPLICATION_NAME$_AppInit() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void UU_AppInit(void)
{
/* void *TblPointer;
//int32 Status; */
/*
** Initialize app command execution counters...
*/
UU_AppData.CmdCount = 0;
UU_AppData.ErrCount = 0;
UU_AppData.HkPacket.UpdateCount = 0;
/*
** Initialize app configuration data...
*/
strcpy(UU_AppData.PipeName, "UU_CMD_PIPE");
UU_AppData.PipeDepth = 12;
UU_AppData.LimitHK = 2;
UU_AppData.LimitCmd = 4;
/*
** Initialize event filter table...
*/
UU_AppData.EventFilters[0].EventID = UU_INIT_INF_EID;
UU_AppData.EventFilters[0].Mask = CFE_EVS_NO_FILTER;
UU_AppData.EventFilters[1].EventID = UU_NOOP_INF_EID;
UU_AppData.EventFilters[1].Mask = CFE_EVS_NO_FILTER;
UU_AppData.EventFilters[2].EventID = UU_RESET_INF_EID;
UU_AppData.EventFilters[2].Mask = CFE_EVS_NO_FILTER;
UU_AppData.EventFilters[3].EventID = UU_MID_ERR_EID;
UU_AppData.EventFilters[3].Mask = CFE_EVS_NO_FILTER;
UU_AppData.EventFilters[4].EventID = UU_CC1_ERR_EID;
UU_AppData.EventFilters[4].Mask = CFE_EVS_NO_FILTER;
UU_AppData.EventFilters[5].EventID = UU_LEN_ERR_EID;
UU_AppData.EventFilters[5].Mask = CFE_EVS_NO_FILTER;
/*
** Register event filter table...
*/
CFE_EVS_Register(UU_AppData.EventFilters,
UU_EVT_COUNT,
CFE_EVS_BINARY_FILTER);
/*
** Initialize housekeeping packet (clear user data area)...
*/
CFE_SB_InitMsg(&UU_AppData.HkPacket,
CFE_UU_HK_TLM_MID,
sizeof(UU_HkPacket_t), TRUE);
/*
** Create Software Bus message pipe...
*/
CFE_SB_CreatePipe(&UU_AppData.CmdPipe,
UU_AppData.PipeDepth,
UU_AppData.PipeName);
/*
** Subscribe to Housekeeping request commands...
*/
CFE_SB_Subscribe(CFE_UU_SEND_HK_MID,UU_AppData.CmdPipe);
/*
** Subscribe to UU ground command packets...
*/
CFE_SB_Subscribe(CFE_UU_CMD_MID,UU_AppData.CmdPipe);
/*
** Application startup event message...
*/
CFE_EVS_SendEvent(UU_INIT_INF_EID,
CFE_EVS_INFORMATION,
"UU: Application Initialized");
return;
} /* End of UU_AppInit() */
/*
** Test filter registration related calls
*/
void Test_FilterRegistration (void)
{
int i;
CFE_EVS_BinFilter_t filter[CFE_EVS_MAX_EVENT_FILTERS + 1];
CFE_EVS_EVSBinFilter_t *FilterPtr = NULL;
CFE_EVS_Table_t *TablePtr;
uint32 AppID;
CFE_EVS_BitMaskCmd_t bitmaskcmd;
/* TEST: unknown filter */
UT_Report(CFE_EVS_Register(NULL, 0, -1) == CFE_EVS_UNKNOWN_FILTER,
"CFE_EVS_Register","illegal filter option");
/* TEST: valid registration with no filters */
UT_Report(CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER) == CFE_SUCCESS,
"CFE_EVS_Register", "valid w/ no filters");
/* TEST: unregistration with failed ES_putPool */
UT_SetPutPoolFail(1);
UT_Report(CFE_EVS_Unregister() < 0, "CFE_EVS_Unregister",
"unregistration with failed ES_putPool");
UT_SetPutPoolFail(0);
/* Re-register to test valid unregistration */
UT_Report(CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER) == CFE_SUCCESS,
"CFE_EVS_Register", "valid w/ no filters (re-registration)");
/* TEST: valid unregistration */
UT_Report(CFE_EVS_Unregister() == CFE_SUCCESS,
"CFE_EVS_Unregister", "valid call");
/* TEST: valid registration with filter */
filter[0].EventID = 0;
filter[0].Mask = 0x0001;
UT_Report(CFE_EVS_Register(filter, 1, CFE_EVS_BINARY_FILTER) == CFE_SUCCESS,
"CFE_EVS_Register", "valid w/ filter");
/* TEST: multiple valid registration with more than MAX filters */
for (i = 0; i < CFE_EVS_MAX_EVENT_FILTERS + 1; i++){
filter[i].EventID = i;
filter[i].Mask = 1;
}
UT_Report(CFE_EVS_Register(filter, CFE_EVS_MAX_EVENT_FILTERS + 1,
CFE_EVS_BINARY_FILTER) == CFE_EVS_APP_FILTER_OVERLOAD,
"CFE_EVS_Register", "valid over max filters");
/* TEST: Send 1st information message, should get through */
UT_Report(CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "OK") == CFE_SUCCESS,
"CFE_EVS_SendEvent", "1st info message should go through");
/* TEST: Send 2nd information message, should be filtered */
UT_Report(CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "FAILED") == CFE_SUCCESS,
"CFE_EVS_SendEvent", "2nd info message should be filtered");
/* TEST: Send Last information message, which should cause filtering to lock */
CFE_ES_GetAppID(&AppID);
TablePtr = CFE_EVS_GlobalData.EVS_TablePtr[AppID].Address;
FilterPtr = EVS_FindEventID(0, (CFE_EVS_EVSBinFilter_t *)&TablePtr->BinFilters);
FilterPtr->Count = CFE_EVS_MAX_FILTER_COUNT - 1;
UT_Report(CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "OK") == CFE_SUCCESS,
"CFE_EVS_SendEvent", "Last info message should go through");
UT_Report(CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "FAILED") == CFE_SUCCESS,
"CFE_EVS_SendEvent", "Locked info message should be filtered");
UT_Report(CFE_EVS_SendEvent(0, CFE_EVS_INFORMATION, "FAILED") == CFE_SUCCESS,
"CFE_EVS_SendEvent", "Locked info message should still be filtered");
/* Return application to original state, re-register application */
CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int32 HS_AppInit(void)
{
int32 Status = CFE_SUCCESS;
/*
** Initialize operating data to default states...
*/
HS_AppData.ServiceWatchdogFlag = HS_STATE_ENABLED;
HS_AppData.AlivenessCounter = 0;
HS_AppData.RunStatus = CFE_ES_APP_RUN;
HS_AppData.EventsMonitoredCount = 0;
HS_AppData.MsgActExec = 0;
HS_AppData.CurrentAppMonState = HS_APPMON_DEFAULT_STATE;
HS_AppData.CurrentEventMonState = HS_EVENTMON_DEFAULT_STATE;
HS_AppData.CurrentAlivenessState = HS_ALIVENESS_DEFAULT_STATE;
HS_AppData.CurrentCPUHogState = HS_CPUHOG_DEFAULT_STATE;
#if HS_MAX_EXEC_CNT_SLOTS != 0
HS_AppData.ExeCountState = HS_STATE_ENABLED;
#else
HS_AppData.ExeCountState = HS_STATE_DISABLED;
#endif
HS_AppData.MsgActsState = HS_STATE_ENABLED;
HS_AppData.AppMonLoaded = HS_STATE_ENABLED;
HS_AppData.EventMonLoaded = HS_STATE_ENABLED;
HS_AppData.CDSState = HS_STATE_ENABLED;
HS_AppData.CurrentCPUUtilIndex = 0;
HS_AppData.CurrentCPUHoggingTime = 0;
HS_AppData.MaxCPUHoggingTime = HS_UTIL_HOGGING_TIMEOUT;
HS_AppData.UtilCpuAvg = 0;
HS_AppData.UtilCpuPeak = 0;
/*
** Register for event services...
*/
Status = CFE_EVS_Register (NULL, 0, CFE_EVS_BINARY_FILTER);
if (Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("HS App: Error Registering For Event Services, RC = 0x%08X\n", Status);
return (Status);
}
/*
** Create Critical Data Store
*/
Status = CFE_ES_RegisterCDS(&HS_AppData.MyCDSHandle,
sizeof(HS_CDSData_t),
HS_CDSNAME);
if (Status == CFE_ES_CDS_ALREADY_EXISTS)
{
/*
** Critical Data Store already existed, we need to get a
** copy of its current contents to see if we can use it
*/
Status = CFE_ES_RestoreFromCDS(&HS_AppData.CDSData, HS_AppData.MyCDSHandle);
if (Status == CFE_SUCCESS)
{
if((HS_AppData.CDSData.ResetsPerformed != (uint16) ~HS_AppData.CDSData.ResetsPerformedNot) ||
(HS_AppData.CDSData.MaxResets != (uint16) ~HS_AppData.CDSData.MaxResetsNot))
{
/*
** Report error restoring data
*/
CFE_EVS_SendEvent(HS_CDS_CORRUPT_ERR_EID, CFE_EVS_ERROR,
"Data in CDS was corrupt, initializing resets data", Status);
/*
** If data was corrupt, initialize data
*/
HS_SetCDSData(0, HS_MAX_RESTART_ACTIONS);
}
}
else
{
/*
** Report error restoring data
*/
CFE_EVS_SendEvent(HS_CDS_RESTORE_ERR_EID, CFE_EVS_ERROR,
"Failed to restore data from CDS (Err=0x%08x), initializing resets data", Status);
/*
** If data could not be retrieved, initialize data
*/
HS_SetCDSData(0, HS_MAX_RESTART_ACTIONS);
}
Status = CFE_SUCCESS;
}
else if (Status == CFE_SUCCESS)
{
/*
** If CDS did not previously exist, initialize data
*/
HS_SetCDSData(0, HS_MAX_RESTART_ACTIONS);
}
else
{
/*
** Disable saving to CDS
*/
HS_AppData.CDSState = HS_STATE_DISABLED;
/*
** Initialize values anyway (they will not be saved)
*/
HS_SetCDSData(0, HS_MAX_RESTART_ACTIONS);
}
/*
** Set up the HS Software Bus
*/
Status = HS_SbInit();
if(Status != CFE_SUCCESS)
{
return (Status);
}
/*
** Register The HS Tables
*/
Status = HS_TblInit();
if(Status != CFE_SUCCESS)
{
return (Status);
}
/*
** Perform custom initialization (for cpu utilization monitoring)
*/
Status = HS_CustomInit();
/*
** Application initialization event
*/
CFE_EVS_SendEvent (HS_INIT_EID, CFE_EVS_INFORMATION,
"HS Initialized. Version %d.%d.%d.%d",
HS_MAJOR_VERSION,
HS_MINOR_VERSION,
HS_REVISION,
HS_MISSION_REV);
return CFE_SUCCESS;
} /* end HS_AppInit */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int main(void)
{
/*
** API function hook handlers
*/
UTF_SB_set_function_hook(CFE_SB_SUBSCRIBE_HOOK, (void *)&CFE_SB_SubscribeHook);
/*
** Set up output file and HK packet handler
*/
UTF_set_output_filename("fm_utest.out");
UTF_set_packet_handler(FM_HK_TLM_MID, (utf_packet_handler)PrintHKPacket);
UTF_set_packet_handler(FM_DIR_LIST_TLM_MID, (utf_packet_handler)PrintListPacket);
UTF_set_packet_handler(FM_FILE_INFO_TLM_MID, (utf_packet_handler)PrintInfoPacket);
UTF_set_packet_handler(FM_OPEN_FILES_TLM_MID, (utf_packet_handler)PrintOpenPacket);
UTF_set_packet_handler(FM_FREE_SPACE_TLM_MID, (utf_packet_handler)PrintFreePacket);
/*
** Initialize time data structures
*/
UTF_init_sim_time(0.0);
/*
** Initialize ES application data
*/
UTF_ES_InitAppRecords();
UTF_ES_AddAppRecord("FM",0);
CFE_ES_RegisterApp();
/*
** Initialize CDS and table services data structures
*/
CFE_ES_CDS_EarlyInit();
CFE_TBL_EarlyInit();
CFE_EVS_Register(NULL, 0, 0);
/*
* Setup the virtual/physical file system mapping...
*
* The following local machine directory structure is required:
*
* ... fm/fsw/unit_test <-- this is the current working directory
* ... fm/fsw/unit_test/ram <-- physical location for virtual disk "/ram"
*/
UTF_add_volume("/", "ram", FS_BASED, FALSE, FALSE, TRUE, "RAM", "/ram", 0);
OS_mkdir("/ram/sub",0);
OS_mkdir("/ram/sub2",0);
OS_mkdir("/ram/sub2/sub22",0);
OS_mkdir("/ram/sub3",0);
/*
** Run FM application unit tests
*/
UT_TotalTestCount = 0;
UT_TotalFailCount = 0;
UTF_put_text("\n*** FM -- Testing fm_app.c ***\n");
Test_app();
UTF_put_text("\n*** FM -- Testing fm_cmds.c ***\n");
Test_cmds();
UTF_put_text("\n*** FM -- Testing fm_cmd_utils.c ***\n");
Test_utils();
UTF_put_text("\n*** FM -- Testing fm_child.c ***\n");
Test_child();
UTF_put_text("\n*** FM -- Testing fm_tbl.c ***\n");
Test_tbl();
UTF_put_text("\n*** FM -- Total test count = %d, total test errors = %d\n\n", UT_TotalTestCount, UT_TotalFailCount);
/*
** Remove directories created for these tests...
*/
OS_rmdir("/ram/sub3");
OS_rmdir("/ram/sub2/sub22");
OS_rmdir("/ram/sub2");
OS_rmdir("/ram/sub");
/*
** Invoke the main loop test now because the program will end
** when the last entry in the SB sim input file is read.
*/
UTF_CFE_ES_Set_Api_Return_Code(CFE_ES_RUNLOOP_PROC, TRUE);
FM_AppMain();
UTF_CFE_ES_Use_Default_Api_Return_Code(CFE_ES_RUNLOOP_PROC);
return 0;
} /* End of main() */
int32 CFE_TIME_TaskInit(void)
{
int32 Status = CFE_SUCCESS;
Status = CFE_ES_RegisterApp();
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Call to CFE_ES_RegisterApp Failed:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = CFE_EVS_Register(NULL, 0, 0);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Call to CFE_EVS_Register Failed:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = OS_BinSemCreate(&CFE_TIME_TaskData.ToneSemaphore,
CFE_TIME_SEM_TONE_NAME,
CFE_TIME_SEM_VALUE,
CFE_TIME_SEM_OPTIONS);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error creating tone semaphore:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = OS_BinSemCreate(&CFE_TIME_TaskData.LocalSemaphore,
CFE_TIME_SEM_1HZ_NAME,
CFE_TIME_SEM_VALUE,
CFE_TIME_SEM_OPTIONS);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error creating local semaphore:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = CFE_ES_CreateChildTask(&CFE_TIME_TaskData.ToneTaskID,
CFE_TIME_TASK_TONE_NAME,
CFE_TIME_Tone1HzTask,
CFE_TIME_TASK_STACK_PTR,
CFE_TIME_TONE_TASK_STACK_SIZE,
CFE_TIME_TONE_TASK_PRIORITY,
CFE_TIME_TASK_FLAGS);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error creating tone 1Hz child task:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = CFE_ES_CreateChildTask(&CFE_TIME_TaskData.LocalTaskID,
CFE_TIME_TASK_1HZ_NAME,
CFE_TIME_Local1HzTask,
CFE_TIME_TASK_STACK_PTR,
CFE_TIME_1HZ_TASK_STACK_SIZE,
CFE_TIME_1HZ_TASK_PRIORITY,
CFE_TIME_TASK_FLAGS);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error creating local 1Hz child task:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = CFE_SB_CreatePipe(&CFE_TIME_TaskData.CmdPipe,
CFE_TIME_TaskData.PipeDepth,
CFE_TIME_TaskData.PipeName);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error creating cmd pipe:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = CFE_SB_Subscribe(CFE_TIME_SEND_HK_MID,
CFE_TIME_TaskData.CmdPipe);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error subscribing to HK Request:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Subscribe to time at the tone "signal" commands...
*/
#if (CFE_TIME_CFG_CLIENT == TRUE)
Status = CFE_SB_Subscribe(CFE_TIME_TONE_CMD_MID,
CFE_TIME_TaskData.CmdPipe);
#endif
#if (CFE_TIME_CFG_SERVER == TRUE)
Status = CFE_SB_SubscribeLocal(CFE_TIME_TONE_CMD_MID,
CFE_TIME_TaskData.CmdPipe,4);
#endif
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error subscribing to tone cmd:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Subscribe to time at the tone "data" commands...
*/
#if (CFE_TIME_CFG_CLIENT == TRUE)
Status = CFE_SB_Subscribe(CFE_TIME_DATA_CMD_MID,
CFE_TIME_TaskData.CmdPipe);
#endif
#if (CFE_TIME_CFG_SERVER == TRUE)
Status = CFE_SB_SubscribeLocal(CFE_TIME_DATA_CMD_MID,
CFE_TIME_TaskData.CmdPipe,4);
#endif
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error subscribing to time data cmd:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Subscribe to "fake" tone signal commands...
*/
#if (CFE_TIME_CFG_FAKE_TONE == TRUE)
#if (CFE_TIME_CFG_CLIENT == TRUE)
Status = CFE_SB_Subscribe(CFE_TIME_FAKE_CMD_MID,
CFE_TIME_TaskData.CmdPipe);
#endif
#if (CFE_TIME_CFG_SERVER == TRUE)
Status = CFE_SB_SubscribeLocal(CFE_TIME_FAKE_CMD_MID,
CFE_TIME_TaskData.CmdPipe,4);
#endif
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error subscribing to fake tone signal cmds:RC=0x%08X\n",Status);
return Status;
}/* end if */
#endif
/*
** Subscribe to time at the tone "request data" commands...
*/
#if (CFE_TIME_CFG_SERVER == TRUE)
#if (CFE_TIME_CFG_SOURCE != TRUE)
#if (CFE_TIME_CFG_FAKE_TONE != TRUE)
Status = CFE_SB_Subscribe(CFE_TIME_SEND_CMD_MID,
CFE_TIME_TaskData.CmdPipe);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error subscribing to time at the tone request data cmds:RC=0x%08X\n",Status);
return Status;
}/* end if */
#endif
#endif
#endif
/*
** Subscribe to Time task ground command packets...
*/
Status = CFE_SB_Subscribe(CFE_TIME_CMD_MID,
CFE_TIME_TaskData.CmdPipe);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error subscribing to time task gnd cmds:RC=0x%08X\n",Status);
return Status;
}/* end if */
Status = CFE_EVS_SendEvent(CFE_TIME_INIT_EID,
CFE_EVS_INFORMATION,
"cFE TIME Initialized");
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TIME:Error sending init event:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Select primary vs redundant tone interrupt signal...
*/
#if (CFE_TIME_CFG_SIGNAL == TRUE)
OS_SelectTone(CFE_TIME_TaskData.ClockSignal);
#endif
return CFE_SUCCESS;
} /* End of CFE_TIME_TaskInit() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int main(void)
{
char AppName[10];
UTF_SymbolTable_t UTF_Symbol;
strcpy(AppName, "MM");
/*
** Set up to read in script
*/
UTF_add_input_file(MM_CMD_PIPE, "mm_utf_cmds.in");
MM_AppData.CmdPipe = MM_CMD_PIPE; /* Hook for application code */
/*
** Set up output file and HK packet handler
*/
UTF_set_output_filename("mm_utf_test.out");
UTF_set_packet_handler(MM_HK_TLM_MID, (utf_packet_handler)PrintHKPacket);
/*
** Set up simulated memory for loads and dumps
*/
UTF_add_sim_address(SIM_RAM_MEM_ADDR, SIM_RAM_MEM_SIZE,
"MM_RAM_ADDRESS_SPACE");
UTF_add_sim_address(SIM_EEPROM_MEM_ADDR, SIM_EEPROM_MEM_SIZE,
"MM_EEPROM_ADDRESS_SPACE");
/*
** Add these ranges to the OSAL memory table so the CFE_PSP_MemValidateRange
** routine won't barf on them. We set these ranges much bigger than we're
** going to need so we can test bounds checking in MM and not
** CFE_PSP_MemValidateRange.
*/
CFE_PSP_MemRangeSet(0, CFE_PSP_MEM_RAM, SIM_RAM_MEM_ADDR, (MM_MAX_LOAD_FILE_DATA_RAM * 2),
CFE_PSP_MEM_SIZE_BYTE, CFE_PSP_MEM_ATTR_READWRITE);
CFE_PSP_MemRangeSet(1, CFE_PSP_MEM_EEPROM, SIM_EEPROM_MEM_ADDR, (MM_MAX_LOAD_FILE_DATA_EEPROM * 10),
CFE_PSP_MEM_SIZE_BYTE, CFE_PSP_MEM_ATTR_READWRITE);
/*
** Setup the UTF symbol table structures
*/
UTF_InitSymbolTable();
strcpy(UTF_Symbol.symbolName, "GoodSymName");
UTF_Symbol.symbolAddr = SIM_RAM_MEM_ADDR;
UTF_SetSymbolTableEntry(UTF_Symbol);
/*
** Initialize time data structures
*/
UTF_init_sim_time(0.0);
UTF_OSAPI_set_function_hook(OS_GETLOCALTIME_HOOK, TimeHook);
/*
** Initialize the PSP EEPROM Write Ena/Dis return status
*/
UTF_PSP_Set_Api_Return_Code(CFE_PSP_EEPROMWRITEENA_PROC, CFE_PSP_SUCCESS);
UTF_PSP_Set_Api_Return_Code(CFE_PSP_EEPROMWRITEDIS_PROC, CFE_PSP_SUCCESS);
/*
** Register app MM with executive services.
*/
UTF_ES_InitAppRecords();
UTF_ES_AddAppRecord("MM",0);
CFE_ES_RegisterApp();
CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER);
/*
** Initialize table services data structures, though we
** don't use any tables for these tests
*/
CFE_ES_CDS_EarlyInit();
CFE_TBL_EarlyInit();
/*
** Add an entry to the volume table
*/
UTF_add_volume("/", "ram", FS_BASED, FALSE, FALSE, TRUE, "RAM", "/ram", 0);
/*
** Add this hook so we can force a software bus read error
** in our command input file that will make the application exit
*/
UTF_add_special_command("SET_SB_RETURN_CODE", UTF_SCRIPT_SB_Set_Api_Return_Code);
UTF_add_special_command("SET_PSP_RETURN_CODE", UTF_SCRIPT_PSP_Set_Api_Return_Code);
/*
** Initialize the CRC value for our test data set
*/
MM_TestDataSetCRC = CFE_ES_CalculateCRC(MM_TestDataSet, sizeof(MM_TestDataSet),
0, CFE_ES_DEFAULT_CRC);
/*
** This is a function stub in cfs_utils.c that does nothing, but
** by calling it here we can increase our coverage statistics, so
** why not?
*/
CFS_LibInit();
/*
** Call test functions that invoke MM code directly
*/
printf("***UTF MM DRIVER TESTS START***\n\n");
UTF_put_text("\n");
UTF_put_text("***UTF MM DRIVER TESTS START***");
UTF_put_text("\n\n");
Test_Pokes();
Test_Peeks();
Test_LoadWID();
Test_DumpInEvent();
Test_LoadFromFile();
Test_DumpToFile();
Test_Fill();
Test_SymLookup();
Test_SymTblDump();
printf("***UTF MM DRIVER TESTS END***\n\n");
UTF_put_text("\n");
UTF_put_text("***UTF MM DRIVER TESTS END***");
UTF_put_text("\n\n");
/*
** Call Application Main procedure that will test command
** processing through the software bus command pipe via
** the mm_utf_cmds.in command script
*/
printf("***UTF MM CMD PIPE TESTS START***\n\n");
UTF_put_text("\n");
UTF_put_text("***UTF MM CMD PIPE TESTS START***");
UTF_put_text("\n\n");
MM_AppMain();
printf("***UTF MM CMD PIPE TESTS END***\n\n");
UTF_put_text("\n");
UTF_put_text("***UTF MM CMD PIPE TESTS END***");
UTF_put_text("\n\n");
/*
** These tests force some CFE api error returns
** during MM initialization. This increases
** the gcov coverage metrics for the app startup
** code.
*/
printf("***UTF MM APP INIT TESTS START***\n\n");
UTF_put_text("\n");
UTF_put_text("***UTF MM APP INIT TESTS START***");
UTF_put_text("\n\n");
UTF_put_text("\n");
UTF_put_text("Test App Init Error conditions \n");
UTF_put_text("-------------------------------\n");
/*
** Set trigger so CFE_EVS_Register returns something
** other than CFE_SUCCESS (0). Then call app main, this
** should make the app init fail.
*/
UTF_CFE_EVS_Set_Api_Return_Code(CFE_EVS_REGISTER_PROC, 0xc2000003L);
MM_AppMain();
/* Go back to "normal" behavior */
UTF_CFE_EVS_Use_Default_Api_Return_Code(CFE_EVS_REGISTER_PROC);
/*
** Set trigger so CFE_SB_CreatePipe returns an error code
*/
UTF_CFE_SB_Set_Api_Return_Code(CFE_SB_CREATEPIPE_PROC, 0xca000004L);
MM_AppMain();
UTF_CFE_SB_Use_Default_Api_Return_Code(CFE_SB_CREATEPIPE_PROC);
/*
** Set trigger so CFE_SB_Subscribe returns an error code
*/
UTF_CFE_SB_Set_Api_Return_Code(CFE_SB_SUBSCRIBE_PROC, 0xca000009L);
MM_AppMain();
UTF_CFE_SB_Use_Default_Api_Return_Code(CFE_SB_SUBSCRIBE_PROC);
/*
** Hook our own custom function to CFE_SB_Subscribe so we can
** trigger an error return on the SECOND call in MM_AppInit
*/
UTF_SB_set_function_hook(CFE_SB_SUBSCRIBE_HOOK, (void *)&CFE_SB_SubscribeHook);
MM_AppMain();
printf("***UTF MM APP INIT TESTS END***\n\n");
UTF_put_text("\n");
UTF_put_text("***UTF MM APP INIT TESTS END***");
UTF_put_text("\n\n");
return 0;
} /* end main */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int main(void)
{
/*
** Set up output results text file
*/
UTF_set_output_filename("ds_utest.out");
/*
** Set up HK packet handler
*/
UTF_set_packet_handler(DS_HK_TLM_MID, (utf_packet_handler)PrintHKPacket);
/*
** Initialize time data structures
*/
UTF_init_sim_time(0.0);
/*
** Initialize ES application data
*/
UTF_ES_InitAppRecords();
UTF_ES_AddAppRecord("DS",0);
CFE_ES_RegisterApp();
/*
** Initialize CDS and table services data structures
*/
CFE_ES_CDS_EarlyInit();
CFE_TBL_EarlyInit();
/*
* Setup the virtual/physical file system mapping...
*
* The following local machine directory structure is required:
*
* ... ds/fsw/unit_test <-- this is the current working directory
* ... ds/fsw/unit_test/disk/TT <-- physical location for virtual disk "/tt"
*/
UTF_add_volume("/TT", "disk", FS_BASED, FALSE, FALSE, TRUE, "TT", "/tt", 0);
/*
** Delete files created during previous tests
*/
OS_remove("/tt/app00002000.tlm");
OS_remove("/tt/app1980001000000.hk");
OS_remove("/tt/b_00000000.x");
OS_remove("/tt/b_99999999.x");
/*
** Required setup prior to calling many CFE API functions
*/
CFE_ES_RegisterApp();
CFE_EVS_Register(NULL, 0, 0);
/*
** Run DS application unit tests
*/
UTF_put_text("\n*** DS -- Testing ds_cmds.c ***\n");
Test_cmds();
UTF_put_text("\n*** DS -- Testing ds_file.c ***\n");
Test_file();
UTF_put_text("\n*** DS -- Testing ds_table.c ***\n");
Test_table();
UTF_put_text("\n*** DS -- Testing ds_app.c ***\n");
Test_app();
UTF_put_text("\n*** DS -- Total test count = %d, total test errors = %d\n\n", UT_TotalTestCount, UT_TotalFailCount);
/*
** Invoke the main loop "success" test now because the program
** will end when the last entry in the SB input file is read.
*/
UTF_CFE_ES_Set_Api_Return_Code(CFE_ES_RUNLOOP_PROC, TRUE);
UTF_CFE_TBL_Set_Api_Return_Code (CFE_TBL_GETSTATUS_PROC, CFE_TBL_INFO_UPDATE_PENDING);
DS_AppMain();
return 0;
} /* End of main() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void TO_init(void)
{
int32 status;
char PipeName[16];
uint16 PipeDepth;
uint16 i;
char ToTlmPipeName[16];
uint16 ToTlmPipeDepth;
CFE_ES_RegisterApp();
downlink_on = FALSE;
PipeDepth = 8;
strcpy(PipeName, "TO_LAB_CMD_PIPE");
ToTlmPipeDepth = 64;
strcpy(ToTlmPipeName, "TO_LAB_TLM_PIPE");
/*
** Register event filter table...
*/
CFE_EVS_Register(CFE_TO_EVS_Filters,
sizeof(CFE_TO_EVS_Filters)/sizeof(CFE_EVS_BinFilter_t),
CFE_EVS_BINARY_FILTER);
/*
** Initialize housekeeping packet (clear user data area)...
*/
CFE_SB_InitMsg(&to_hk_status,
TO_LAB_HK_TLM_MID,
sizeof(to_hk_status), TRUE);
/* Subscribe to my commands */
status = CFE_SB_CreatePipe(&TO_Cmd_pipe, PipeDepth, PipeName);
if (status == CFE_SUCCESS)
{
CFE_SB_Subscribe(TO_LAB_CMD_MID, TO_Cmd_pipe);
CFE_SB_Subscribe(TO_LAB_SEND_HK_MID, TO_Cmd_pipe);
}
else
CFE_EVS_SendEvent(TO_CRCMDPIPE_ERR_EID,CFE_EVS_ERROR, "L%d TO Can't create cmd pipe status %i",__LINE__,status);
/* Create TO TLM pipe */
status = CFE_SB_CreatePipe(&TO_Tlm_pipe, ToTlmPipeDepth, ToTlmPipeName);
if (status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(TO_TLMPIPE_ERR_EID,CFE_EVS_ERROR, "L%d TO Can't create Tlm pipe status %i",__LINE__,status);
}
/* Subscriptions for TLM pipe*/
for (i=0; (i < (sizeof(TO_SubTable)/sizeof(TO_subsciption_t))); i++)
{
if(TO_SubTable[i].Stream != TO_UNUSED )
status = CFE_SB_SubscribeEx(TO_SubTable[i].Stream,
TO_Tlm_pipe,
TO_SubTable[i].Flags,
TO_SubTable[i].BufLimit);
if (status != CFE_SUCCESS)
CFE_EVS_SendEvent(TO_SUBSCRIBE_ERR_EID,CFE_EVS_ERROR,"L%d TO Can't subscribe to stream 0x%x status %i", __LINE__,
TO_SubTable[i].Stream,status);
}
/*
** Install the delete handler
*/
OS_TaskInstallDeleteHandler((void *)(&TO_delete_callback));
CFE_EVS_SendEvent (TO_INIT_INF_EID, CFE_EVS_INFORMATION,
"TO Lab Initialized. Version %d.%d.%d.%d Awaiting enable command.",
TO_LAB_MAJOR_VERSION,
TO_LAB_MINOR_VERSION,
TO_LAB_REVISION,
TO_LAB_MISSION_REV);
} /* End of TO_Init() */
int32 SIMCI_TaskInit(void) {
int32 Status = CFE_SUCCESS;
CFE_ES_RegisterApp();
SIMCI_AppData.CommandPipe = 0;
SIMCI_AppData.MsgPtr = NULL;
SIMCI_AppData.UplinkSocketID = 0;
SIMCI_AppData.IngestSocketID = 0;
SIMCI_AppData.UplinkSocketConnected = FALSE;
SIMCI_AppData.IngestSocketConnected = FALSE;
/* Set up and register events */
SIMCI_AppData.EventFilters[0].EventID = SIMCI_COMMANDRST_INF_EID;
SIMCI_AppData.EventFilters[0].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[1].EventID = SIMCI_UPLINK_ERR_EID;
SIMCI_AppData.EventFilters[1].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[2].EventID = SIMCI_INGEST_ERR_EID;
SIMCI_AppData.EventFilters[2].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[3].EventID = SIMCI_CRCMDPIPE_ERR_EID;
SIMCI_AppData.EventFilters[3].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[4].EventID = SIMCI_SOCKETCREATE_ERR_EID;
SIMCI_AppData.EventFilters[4].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[5].EventID = SIMCI_SOCKETBIND_ERR_EID;
SIMCI_AppData.EventFilters[5].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[6].EventID = SIMCI_MSGID_ERR_EID;
SIMCI_AppData.EventFilters[6].Mask = CFE_EVS_NO_FILTER;
SIMCI_AppData.EventFilters[7].EventID = SIMCI_CC1_ERR_EID;
SIMCI_AppData.EventFilters[7].Mask = CFE_EVS_NO_FILTER;
CFE_EVS_Register(SIMCI_AppData.EventFilters, SIMCI_FILTERED_EVT_COUNT, CFE_EVS_BINARY_FILTER);
if (Status != CFE_SUCCESS) {
CFE_ES_WriteToSysLog("SIMCI: Error registering events, RC = 0x%08X\n", Status);
return Status;
}
/* Initialize Housekeeping */
CFE_SB_InitMsg(&SIMCI_AppData.HkPacket, SIMCI_HK_TLM_MID, sizeof(SIMCI_HkPacket_t), TRUE);
SIMCI_ResetCounters();
SIMCI_AppData.HkPacket.ingest_socket_connected = FALSE;
SIMCI_AppData.HkPacket.uplink_socket_connected = FALSE;
/* Create a command pipe and subscribe to its messages */
Status = CFE_SB_CreatePipe(&SIMCI_AppData.CommandPipe, SIMCI_PIPE_DEPTH, "SIMCI_CMD_PIPE");
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_CRCMDPIPE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Can't create command pipe, RC=%08X", Status);
return Status;
}
Status = CFE_SB_Subscribe(SIMCI_CMD_MID, SIMCI_AppData.CommandPipe);
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_SUBSCRIBE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error subscribing to SIMCI_CMD_MID(0x%04X), RC=%08X", SIMCI_CMD_MID, Status);
return Status;
}
Status = CFE_SB_Subscribe(SIMCI_SEND_HK_MID, SIMCI_AppData.CommandPipe);
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_SUBSCRIBE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error subscribing to SIMCI_SEND_HK_MID(0x%04X), RC=%08X", SIMCI_SEND_HK_MID, Status);
return Status;
}
/* Set up Uplink socket */
SIMCI_AppData.UplinkSocketID = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (SIMCI_AppData.UplinkSocketID < 0) {
CFE_EVS_SendEvent(SIMCI_SOCKETCREATE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error creating uplink socket, errno=%08X", errno);
return ERROR;
} else {
struct sockaddr_in socket_address;
CFE_PSP_MemSet((void*)&socket_address, 0, sizeof(socket_address));
socket_address.sin_family = AF_INET;
socket_address.sin_addr.s_addr = htonl(INADDR_ANY);
socket_address.sin_port = htons(SIMCI_UPLINK_PORT);
Status = bind(SIMCI_AppData.UplinkSocketID, (struct sockaddr *)&socket_address, sizeof(socket_address));
if (Status == ERROR) {
CFE_EVS_SendEvent(SIMCI_SOCKETBIND_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error binding uplink socket, errno=%08X", errno);
return Status;
} else {
SIMCI_AppData.UplinkSocketConnected = TRUE;
}
}
/* Set up Ingest socket */
SIMCI_AppData.IngestSocketID = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (SIMCI_AppData.IngestSocketID < 0) {
CFE_EVS_SendEvent(SIMCI_SOCKETCREATE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error creating ingest socket, errno=%08X", errno);
return ERROR;
} else {
struct sockaddr_in socket_address;
CFE_PSP_MemSet((void*)&socket_address, 0, sizeof(socket_address));
socket_address.sin_family = AF_INET;
socket_address.sin_addr.s_addr = htonl(INADDR_ANY);
socket_address.sin_port = htons(SIMCI_INGEST_PORT);
Status = bind(SIMCI_AppData.IngestSocketID, (struct sockaddr *)&socket_address, sizeof(socket_address));
if (Status == ERROR) {
CFE_EVS_SendEvent(SIMCI_SOCKETBIND_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error binding ingest socket, errno=%08X", errno);
return Status;
} else {
SIMCI_AppData.IngestSocketConnected = TRUE;
}
}
Status = SIMCI_HWIF_Init();
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(SIMCI_HWIF_ERR_EID, CFE_EVS_ERROR, "Error initializing HWIF, RC=0x%08X", Status);
return Status;
}
/* Install the delete handler */
OS_TaskInstallDeleteHandler((void*)&SIMCI_DeleteCallback);
CFE_EVS_SendEvent(SIMCI_STARTUP_INF_EID, CFE_EVS_INFORMATION, "SIMCI App Initialized");
return CFE_SUCCESS;
}
int32 CFE_TBL_TaskInit(void)
{
int32 Status = CFE_SUCCESS;
/*
** Register Table Services with ES
*/
Status = CFE_ES_RegisterApp();
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TBL:Call to CFE_ES_RegisterApp Failed:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Initialize global Table Services data
*/
CFE_TBL_InitData();
/*
** Register event filter table
*/
Status = CFE_EVS_Register(NULL, 0, 0);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TBL:Call to CFE_EVS_Register Failed:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Create Software Bus message pipe
*/
Status = CFE_SB_CreatePipe(&CFE_TBL_TaskData.CmdPipe,
CFE_TBL_TaskData.PipeDepth,
CFE_TBL_TaskData.PipeName);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TBL:Error creating cmd pipe:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Subscribe to Housekeeping request commands
*/
Status = CFE_SB_Subscribe(CFE_TBL_SEND_HK_MID, CFE_TBL_TaskData.CmdPipe);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TBL:Error subscribing to HK Request:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Subscribe to Table task ground command packets
*/
Status = CFE_SB_Subscribe(CFE_TBL_CMD_MID, CFE_TBL_TaskData.CmdPipe);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TBL:Error subscribing to gnd cmds:RC=0x%08X\n",Status);
return Status;
}/* end if */
/*
** Task startup event message
*/
Status = CFE_EVS_SendEvent(CFE_TBL_INIT_INF_EID, CFE_EVS_INFORMATION, "cFE TBL Initialized. cFE Version %d.%d.%d.%d",
CFE_MAJOR_VERSION,CFE_MINOR_VERSION,CFE_REVISION,CFE_MISSION_REV);
if(Status != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("TBL:Error sending init event:RC=0x%08X\n",Status);
return Status;
}/* end if */
return CFE_SUCCESS;
} /* End of CFE_TBL_TaskInit() */
int32 TO_AppInit(void)
{
int32 iStatus;
uint16 i;
TO_AppData.RunStatus = CFE_ES_APP_RUN;
/* Register the TO app */
CFE_ES_RegisterApp();
/* Setup CMD Pipes */
TO_AppData.CmdPipeDepth = TO_CMD_PIPE_DEPTH ;
strcpy(TO_AppData.CmdPipeName, "TO_CMD_PIPE");
TO_AppData.SchPipeDepth = TO_SCH_PIPE_DEPTH;
strcpy(TO_AppData.SchPipeName, "TO_SCH_PIPE");
/* Initialize event filter table */
TO_AppData.EventFilters[0].EventID = TO_INIT_INF_EID;
TO_AppData.EventFilters[0].Mask = CFE_EVS_NO_FILTER;
TO_AppData.EventFilters[1].EventID = TO_CTODPIPE_ERR_EID;
TO_AppData.EventFilters[1].Mask = CFE_EVS_NO_FILTER;
TO_AppData.EventFilters[2].EventID = TO_SUBSCRIBE_ERR_EID;
TO_AppData.EventFilters[2].Mask = CFE_EVS_NO_FILTER;
TO_AppData.EventFilters[3].EventID = TO_TLMOUTSOCKET_ERR_EID;
TO_AppData.EventFilters[3].Mask = CFE_EVS_NO_FILTER;
TO_AppData.EventFilters[4].EventID = TO_TLMOUTSTOP_ERR_EID;
TO_AppData.EventFilters[4].Mask = CFE_EVS_NO_FILTER;
TO_AppData.EventFilters[5].EventID = TO_MSGID_ERR_EID;
TO_AppData.EventFilters[5].Mask = CFE_EVS_NO_FILTER;
TO_AppData.EventFilters[6].EventID = TO_FNCODE_ERR_EID;
TO_AppData.EventFilters[6].Mask = CFE_EVS_EVERY_OTHER_TWO;
TO_AppData.EventFilters[7].EventID = TO_NOOP_INF_EID;
TO_AppData.EventFilters[7].Mask = CFE_EVS_NO_FILTER;
/* Register event filter table */
iStatus = CFE_EVS_Register(TO_AppData.EventFilters,
TO_EVT_COUNT,
CFE_EVS_BINARY_FILTER);
if ( iStatus != CFE_SUCCESS )
{
CFE_ES_WriteToSysLog("TO App: Error Registering Events");
}
/* Initialize housekeeping packet (clear user data area) */
CFE_SB_InitMsg(&TO_AppData.HkPacket,
TO_HK_TLM_MID,
sizeof(TO_AppData.HkPacket), TRUE);
/* Subscribe for Commands on the Command Pipe */
iStatus = CFE_SB_CreatePipe(&TO_AppData.CmdPipe,
TO_AppData.CmdPipeDepth,
TO_AppData.CmdPipeName);
if (iStatus == CFE_SUCCESS)
{
CFE_SB_Subscribe(TO_CMD_MID, TO_AppData.CmdPipe);
}
else
{
CFE_EVS_SendEvent(TO_CTODPIPE_ERR_EID,CFE_EVS_ERROR,
"TO: Can't create cmd pipe status %i",iStatus);
}
/* Subscribe for the Wakeup and Send_HK messages on the SCH Pipe*/
iStatus = CFE_SB_CreatePipe(&TO_AppData.SchPipe,
TO_AppData.SchPipeDepth,
TO_AppData.SchPipeName);
if (iStatus == CFE_SUCCESS)
{
CFE_SB_Subscribe(TO_SEND_HK_MID, TO_AppData.SchPipe);
CFE_SB_Subscribe(TO_SEND_TLM_MID, TO_AppData.SchPipe);
}
else
{
CFE_EVS_SendEvent(TO_CTODPIPE_ERR_EID,CFE_EVS_ERROR,
"TO: Can't create cmd pipe status %i",iStatus);
}
/* Install the delete handler */
OS_TaskInstallDeleteHandler((void *)(&TO_Cleanup));
/* Register and Load iLoad Table */
iStatus = TO_TableInit();
if(iStatus != CFE_SUCCESS)
{
goto end_of_function;
}
/* Setup TLM Pipes */
for (i=0; i < TO_MAX_TLM_CLASS_QUEUES; i++)
{
if(TO_AppData.Config->ClassQueue[i].Mode == TO_QUEUE_ENABLED)
{
char pipeName[OS_MAX_API_NAME];
sprintf(pipeName, "TO_CLSQUEUE_%u", i);
iStatus = CFE_SB_CreatePipe(&TO_AppData.Config->ClassQueue[i].PipeId,
TO_AppData.Config->ClassQueue[i].Size, pipeName);
if (iStatus != CFE_SUCCESS)
{
CFE_EVS_SendEvent(TO_TLMPIPE_ERR_EID,CFE_EVS_ERROR,
"TO: Can't create Tlm pipe status %i",iStatus);
}
}
}
/* Subscriptions for TLM pipe*/
for (i=0; i < TO_AppData.Config->MaxSubscriptions; i++)
{
if(TO_AppData.Config->Subscription[i].MsgId != TO_UNUSED )
{
CFE_SB_Qos_t qos = {0,0};
uint32 clsQueueIdx = TO_AppData.Config->Subscription[i].ClassQueueIdx;
iStatus = CFE_SB_SubscribeEx(TO_AppData.Config->Subscription[i].MsgId,
TO_AppData.Config->ClassQueue[clsQueueIdx].PipeId,
qos,
TO_AppData.Config->Subscription[i].MsgLimit);
if (iStatus != CFE_SUCCESS)
{
CFE_EVS_SendEvent(TO_SUBSCRIBE_ERR_EID,CFE_EVS_ERROR,
"TO: Can't subscribe to MID 0x%x status 0x%08X index %u",
TO_AppData.Config->Subscription[i].MsgId, iStatus, i);
}
else
{
TO_AppData.HkPacket.PktSubCount++;
}
}
}
for (i=0; i < TO_MAX_TLM_CHANNELS; i++)
{
if(TO_AppData.Config->Channel[i].Mode == TO_CHANNEL_ENABLED)
{
struct sockaddr_in servaddr;
int status;
int reuseaddr=1;
if((TO_AppData.Config->Channel[i].Socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0)
{
TO_AppData.Config->Channel[i].Mode = TO_CHANNEL_DISABLED;
CFE_EVS_SendEvent(TO_TLMOUTSOCKET_ERR_EID,CFE_EVS_ERROR,
"TO: TLM socket errno: %i on channel %u", errno, i);
continue;
}
setsockopt(TO_AppData.Config->Channel[i].Socket, SOL_SOCKET, SO_REUSEADDR, &reuseaddr,sizeof(reuseaddr));
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port=0;
status = bind(TO_AppData.Config->Channel[i].Socket, (struct sockaddr *)&servaddr,sizeof(servaddr));
if(status < 0)
{
CFE_EVS_SendEvent(TO_TLMOUTSOCKET_ERR_EID, CFE_EVS_ERROR,
"TO: TLM bind errno: %i on channel %u", errno, i);
TO_AppData.Config->Channel[i].Mode = TO_CHANNEL_DISABLED;
continue;
}
CFE_EVS_SendEvent(TO_TLMOUTENA_INF_EID, CFE_EVS_INFORMATION,
"TO UDP telemetry output enabled channel %u to %s:%u",
i, TO_AppData.Config->Channel[i].IP, TO_AppData.Config->Channel[i].DstPort);
}
}
TO_AppData.DropFileData = FALSE;
TO_AppData.DropEOF = FALSE;
TO_AppData.DropFIN = FALSE;
TO_AppData.DropACK = FALSE;
TO_AppData.DropMetaData = FALSE;
TO_AppData.DropNAK = FALSE;
TO_AppData.CorruptChecksum = FALSE;
TO_AppData.AdjustFileSize = FALSE;
CFE_EVS_SendEvent (TO_INIT_INF_EID, CFE_EVS_INFORMATION,
"TO Initialized. Version %d.%d.%d.%d Awaiting enable command.",
TO_MAJOR_VERSION,
TO_MINOR_VERSION,
TO_REVISION,
TO_MISSION_REV);
end_of_function:
return iStatus;
}
/*
** Test filter commands
*/
void Test_FilterCmd (void)
{
int i;
CFE_EVS_AppNameCmd_t appnamecmd;
CFE_EVS_AppNameEventIDMaskCmd_t appmaskcmd;
CFE_EVS_AppNameEventIDCmd_t appcmdcmd;
/* Set up event and mask */
appmaskcmd.Mask = 0;
appmaskcmd.EventID = 0;
appcmdcmd.EventID = 0;
/* Run the next series of tests with valid, registered application name */
strcpy((char *)appnamecmd.AppName, "ut_cfe_evs");
strcpy((char *)appmaskcmd.AppName, "ut_cfe_evs");
strcpy((char *)appcmdcmd.AppName, "ut_cfe_evs");
/* Ensure there is no filter for the next tests */
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_DELETE_EVENT_FILTER_CC);
/* TEST: modify filters with valid app but no filter */
/* NOTE: set filter is the same as add filter when one already exists */
/* consider consolidating functionality */
/* delete event filter is the same as setting the filter to */
/* 0xFFFF (I think)... why do this. */
/* Is space really that big of an issue? Just store a filter */
/* value with each event... always there, init to 0xFFFF */
/* I guess if you want multiple filters on same event??? */
/* MULTIPLE FILTERS ON SAME EVENT IS NOT PROTECTED AGAINST!!! */
/* could cause strange behavior */
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_DELETE_EVENT_FILTER_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDMaskCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appmaskcmd, CFE_EVS_CMD_MID,
CFE_EVS_SET_FILTER_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_RESET_FILTER_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appnamecmd, CFE_EVS_CMD_MID,
CFE_EVS_RESET_ALL_FILTERS_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDMaskCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appmaskcmd, CFE_EVS_CMD_MID,
CFE_EVS_ADD_EVENT_FILTER_CC);
/* TEST: modify filters with valid app and filter */
UT_SendMsg((CFE_SB_MsgPtr_t)&appmaskcmd, CFE_EVS_CMD_MID,
CFE_EVS_ADD_EVENT_FILTER_CC);
UT_SendMsg((CFE_SB_MsgPtr_t)&appmaskcmd, CFE_EVS_CMD_MID,
CFE_EVS_SET_FILTER_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_RESET_FILTER_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appnamecmd, CFE_EVS_CMD_MID,
CFE_EVS_RESET_ALL_FILTERS_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_DELETE_EVENT_FILTER_CC);
/* TEST: overfill filters */
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDMaskCmd_t));
for (i = 0; i <= CFE_EVS_MAX_EVENT_FILTERS; i++)
{
UT_SendMsg((CFE_SB_MsgPtr_t)&appmaskcmd, CFE_EVS_CMD_MID,
CFE_EVS_ADD_EVENT_FILTER_CC);
appmaskcmd.EventID++;
}
appmaskcmd.EventID = 0;
/* Return application to original state, re-register application */
CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER);
/* TEST: try filtering the same event twice */
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDMaskCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_ADD_EVENT_FILTER_CC);
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_ADD_EVENT_FILTER_CC);
UT_SetSBTotalMsgLen(sizeof(CFE_EVS_AppNameEventIDCmd_t));
UT_SendMsg((CFE_SB_MsgPtr_t)&appcmdcmd, CFE_EVS_CMD_MID,
CFE_EVS_DELETE_EVENT_FILTER_CC);
/* Return application to original state, re-register application */
CFE_EVS_Register(NULL, 0, CFE_EVS_BINARY_FILTER);
}
void TT_AppInit(void)
{
void *TblPointer;
int32 Status;
/*
** Initialize app command execution counters...
*/
TT4_AppData.CmdCount = 0;
TT4_AppData.ErrCount = 0;
TT4_AppData.HkPacket.UpdateCount = 0;
/*
** Initialize app configuration data...
*/
strcpy(TT4_AppData.PipeName, "TT_CMD_PIPE");
TT4_AppData.PipeDepth = 12;
TT4_AppData.LimitHK = 2;
TT4_AppData.LimitCmd = 4;
/*
** Initialize event filter table...
*/
TT4_AppData.EventFilters[0].EventID = TT_INIT_INF_EID;
TT4_AppData.EventFilters[0].Mask = CFE_EVS_NO_FILTER;
TT4_AppData.EventFilters[1].EventID = TT_NOOP_INF_EID;
TT4_AppData.EventFilters[1].Mask = CFE_EVS_NO_FILTER;
TT4_AppData.EventFilters[2].EventID = TT_RESET_INF_EID;
TT4_AppData.EventFilters[2].Mask = CFE_EVS_NO_FILTER;
TT4_AppData.EventFilters[3].EventID = TT_MID_ERR_EID;
TT4_AppData.EventFilters[3].Mask = CFE_EVS_NO_FILTER;
TT4_AppData.EventFilters[4].EventID = TT_CC1_ERR_EID;
TT4_AppData.EventFilters[4].Mask = CFE_EVS_NO_FILTER;
TT4_AppData.EventFilters[5].EventID = TT_LEN_ERR_EID;
TT4_AppData.EventFilters[5].Mask = CFE_EVS_NO_FILTER;
/*
** Register event filter table...
*/
CFE_EVS_Register(TT4_AppData.EventFilters,
TT_EVT_COUNT,
CFE_EVS_BINARY_FILTER);
/*
** Initialize housekeeping packet (clear user data area)...
*/
CFE_SB_InitMsg(&TT4_AppData.HkPacket,
CFE_TT_HK_TLM_MID,
sizeof(TT_HkPacket_t), TRUE);
/*
** Create Software Bus message pipe...
*/
CFE_SB_CreatePipe(&TT4_AppData.CmdPipe,
TT4_AppData.PipeDepth,
TT4_AppData.PipeName);
/*
** Subscribe to Housekeeping request commands...
*/
CFE_SB_Subscribe(CFE_TT_SEND_HK_MID,TT4_AppData.CmdPipe);
/*
** Subscribe to TT ground command packets...
*/
CFE_SB_Subscribe(CFE_TT_CMD_MID,TT4_AppData.CmdPipe);
/*
** Register & Initialize Table...
*/
Status = CFE_TBL_Register(&TT4_AppData.TblHandle,
"FourNumbers",
4, /* size of table in bytes*/
CFE_TBL_OPT_DBL_BUFFER | CFE_TBL_OPT_LOAD_DUMP,
&TT_TableValidationCallbackFunc);
/* NULL); */
UTF_put_text("CFE_TBL_Register returned %lx\n", Status);
Status = CFE_TBL_Load(TT4_AppData.TblHandle,
CFE_TBL_SRC_FILE,
"/ram/tt_table_values0.dat");
UTF_put_text("CFE_TBL_Load returned %lx\n", Status);
Status = CFE_TBL_GetAddress(&TblPointer,TT4_AppData.TblHandle);
UTF_put_text("CFE_TBL_GetAddress returned %lx\n", Status);
UTF_put_text("The initial values are:%d %d %d %d\n",
*(int8*)TblPointer,*(int8*)(TblPointer+1),
*(int8*)(TblPointer+2),*(int8*)(TblPointer+3));
Status = CFE_TBL_ReleaseAddress(TT4_AppData.TblHandle);
UTF_put_text("CFE_TBL_ReleaseAddress returned %lx\n", Status);
/*
** Application startup event message...
*/
CFE_EVS_SendEvent(TT_INIT_INF_EID,
CFE_EVS_INFORMATION,
"TT: Application Initialized");
return;
} /* End of TT_AppInit() */
int32 SC_AppInit(void)
{
int32 Result;
/* Clear global data structures */
CFE_PSP_MemSet(&SC_OperData, 0, sizeof(SC_OperData_t));
CFE_PSP_MemSet(&SC_AppData, 0, sizeof(SC_AppData_t));
/* Number of ATS and RTS commands already executed this second */
SC_OperData.NumCmdsSec = 0;
/* Continue ATS execution if ATS command checksum fails */
SC_AppData.ContinueAtsOnFailureFlag = SC_CONT_ON_FAILURE_START;
/* Make sure nothing is running */
SC_AppData.NextProcNumber = SC_NONE;
SC_AppData.NextCmdTime[SC_ATP] = SC_MAX_TIME;
SC_AppData.NextCmdTime[SC_RTP] = SC_MAX_TIME;
/* Initialize the SC housekeeping packet */
CFE_SB_InitMsg(&SC_OperData.HkPacket, SC_HK_TLM_MID, sizeof(SC_HkTlm_t), FALSE);
/* Select auto-exec RTS to start during first HK request */
if (CFE_ES_GetResetType(NULL) == CFE_ES_POWERON_RESET)
{
SC_AppData.AutoStartRTS = RTS_ID_AUTO_POWER_ON;
}
else
{
SC_AppData.AutoStartRTS = RTS_ID_AUTO_PROCESSOR;
}
/* Must be able to register for events */
Result = CFE_EVS_Register(NULL,0,CFE_EVS_NO_FILTER);
if (Result != CFE_SUCCESS)
{
CFE_ES_WriteToSysLog("Event Services Register returned: 0x%08X\n", Result);
return(Result);
}
/* Must be able to create Software Bus message pipe */
Result = CFE_SB_CreatePipe(&SC_OperData.CmdPipe, SC_PIPE_DEPTH, SC_CMD_PIPE_NAME);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_CREATE_ERR_EID, CFE_EVS_ERROR,
"Software Bus Create Pipe returned: 0x%08X", Result);
return(Result);
}
/* Must be able to subscribe to HK request command */
Result = CFE_SB_Subscribe(SC_SEND_HK_MID, SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_HK_ERR_EID, CFE_EVS_ERROR,
"Software Bus subscribe to housekeeping returned: 0x%08X", Result);
return(Result);
}
/* Must be able to subscribe to 1Hz wakeup command */
Result = CFE_SB_Subscribe(SC_1HZ_WAKEUP_MID, SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_1HZ_ERR_EID, CFE_EVS_ERROR,
"Software Bus subscribe to 1 Hz cycle returned: 0x%08X", Result);
return(Result);
}
/* Must be able to subscribe to SC commands */
Result = CFE_SB_Subscribe(SC_CMD_MID, SC_OperData.CmdPipe);
if (Result != CFE_SUCCESS)
{
CFE_EVS_SendEvent(SC_INIT_SB_SUBSCRIBE_CMD_ERR_EID, CFE_EVS_ERROR,
"Software Bus subscribe to command returned: 0x%08X", Result);
return(Result);
}
/* Must be able to create and initialize tables */
Result = SC_InitTables();
if (Result != CFE_SUCCESS)
{
return(Result);
}
/* Send application startup event */
CFE_EVS_SendEvent(SC_INIT_INF_EID, CFE_EVS_INFORMATION,
"SC Initialized. Version %d.%d.%d.%d",
SC_MAJOR_VERSION, SC_MINOR_VERSION, SC_REVISION, SC_MISSION_REV);
return(CFE_SUCCESS);
} /* end SC_AppInit() */
int32 THRSIM_Init(void) {
int32 Status = CFE_SUCCESS;
CFE_ES_RegisterApp();
/* Initialize app data */
THRSIM_AppData.CmdPipe = 0;
THRSIM_AppData.MsgPtr = NULL;
/* Set up and register events */
THRSIM_AppData.EventFilters[0].EventID = THRSIM_INIT_INF_EID;
THRSIM_AppData.EventFilters[0].Mask = CFE_EVS_NO_FILTER;
THRSIM_AppData.EventFilters[1].EventID = THRSIM_NOOP_INF_EID;
THRSIM_AppData.EventFilters[1].Mask = CFE_EVS_NO_FILTER;
THRSIM_AppData.EventFilters[2].EventID = THRSIM_CRCMDPIPE_ERR_EID;
THRSIM_AppData.EventFilters[2].Mask = CFE_EVS_NO_FILTER;
THRSIM_AppData.EventFilters[3].EventID = THRSIM_SUBSCRIBE_ERR_EID;
THRSIM_AppData.EventFilters[3].Mask = CFE_EVS_NO_FILTER;
THRSIM_AppData.EventFilters[4].EventID = THRSIM_MSGID_ERR_EID;
THRSIM_AppData.EventFilters[4].Mask = CFE_EVS_NO_FILTER;
THRSIM_AppData.EventFilters[5].EventID = THRSIM_CC1_ERR_EID;
THRSIM_AppData.EventFilters[5].Mask = CFE_EVS_NO_FILTER;
THRSIM_AppData.EventFilters[6].EventID = THRSIM_MSGLEN_ERR_EID;
THRSIM_AppData.EventFilters[6].Mask = CFE_EVS_NO_FILTER;
THRSIM_AppData.EventFilters[7].EventID = THRSIM_PIPE_ERR_EID;
THRSIM_AppData.EventFilters[7].Mask = CFE_EVS_NO_FILTER;
Status = CFE_EVS_Register(THRSIM_AppData.EventFilters, THRSIM_FILTERED_EVT_COUNT, CFE_EVS_BINARY_FILTER);
if (Status != CFE_SUCCESS) {
CFE_ES_WriteToSysLog("Error registering events, RC = 0x%08X\n", Status);
return Status;
}
/* Initialize housekeeping */
CFE_SB_InitMsg(&THRSIM_AppData.HkPacket, THRSIM_HK_TLM_MID, sizeof(THRSIM_HkPacket_t), TRUE);
THRSIM_ResetCounters();
/* Create a command pipe and subscribe to its messages */
Status = CFE_SB_CreatePipe(&THRSIM_AppData.CmdPipe, THRSIM_PIPE_DEPTH, "THRSIM_CMD_PIPE");
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(THRSIM_CRCMDPIPE_ERR_EID, CFE_EVS_ERROR, "Can't create command pipe, RC=0x%08X", Status);
return Status;
}
Status = CFE_SB_Subscribe(THRSIM_CMD_MID, THRSIM_AppData.CmdPipe);
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(THRSIM_SUBSCRIBE_ERR_EID, CFE_EVS_ERROR, "Error subscribing to THRSIM_CMD_MID(0x%04X), RC=0x%08X", THRSIM_CMD_MID, Status);
return Status;
}
Status = CFE_SB_Subscribe(THRSIM_SEND_HK_MID, THRSIM_AppData.CmdPipe);
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(THRSIM_SUBSCRIBE_ERR_EID, CFE_EVS_ERROR, "Error subscribing to THRSIM_SEND_HK_MID(0x%04X), RC=0x%08X", THRSIM_SEND_HK_MID, Status);
return Status;
}
CFE_SB_Subscribe(THRSIM_TICK_MID, THRSIM_AppData.CmdPipe);
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(THRSIM_SUBSCRIBE_ERR_EID, CFE_EVS_ERROR, "Error subscribing to tick message (0x%04X), RC=0x%08X", THRSIM_TICK_MID, Status);
return Status;
}
/* Initialize the output message */
CFE_SB_InitMsg(&THRSIM_AppData.thr_sim_msg, THR_SIM_MID, sizeof(thr_sim_msg_t), TRUE);
Status = THRSIM_HWIF_Init();
if (Status != CFE_SUCCESS) {
CFE_EVS_SendEvent(THRSIM_HWIF_ERR_EID, CFE_EVS_ERROR, "Error initializing HWIF, RC=0x%08X", Status);
return Status;
}
CFE_EVS_SendEvent(THRSIM_INIT_INF_EID, CFE_EVS_INFORMATION, "THRSIM app initialized.");
return CFE_SUCCESS;
}
