/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
void $APPLICATION_NAME$_AppMain( void )
{
int32 status;
uint32 RunStatus = CFE_ES_APP_RUN;
CFE_ES_PerfLogEntry($APPLICATION_NAME$_APP_PERF_ID);
$APPLICATION_NAME$_AppInit();
/*
** $APPLICATION_NAME$ Runloop
*/
while (CFE_ES_RunLoop(&RunStatus) == TRUE)
{
CFE_ES_PerfLogExit($APPLICATION_NAME$_APP_PERF_ID);
/* Pend on receipt of command packet -- timeout set to 500 millisecs */
status = CFE_SB_RcvMsg(&$APPLICATION_NAME$_MsgPtr, $APPLICATION_NAME$_CommandPipe, 500);
CFE_ES_PerfLogEntry($APPLICATION_NAME$_APP_PERF_ID);
if (status == CFE_SUCCESS)
{
$APPLICATION_NAME$_ProcessCommandPacket();
}
}
CFE_ES_ExitApp(RunStatus);
} /* End of $APPLICATION_NAME$_AppMain() */
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_Lab_AppMain(void)
{
uint32 RunStatus = CFE_ES_APP_RUN;
CFE_ES_PerfLogEntry(TO_MAIN_TASK_PERF_ID);
TO_init();
/*
** TO RunLoop
*/
while(CFE_ES_RunLoop(&RunStatus) == TRUE)
{
CFE_ES_PerfLogExit(TO_MAIN_TASK_PERF_ID);
OS_TaskDelay(TO_TASK_MSEC); /*2 Hz*/
CFE_ES_PerfLogEntry(TO_MAIN_TASK_PERF_ID);
TO_forward_telemetry();
TO_process_commands();
}
CFE_ES_ExitApp(RunStatus);
} /* End of TO_Lab_AppMain() */
/******************************************************************************
** 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() */
void CI_TaskMain( void )
{
int32 status;
uint32 RunStatus = CFE_ES_APP_RUN;
CFE_ES_PerfLogEntry(CI_MAIN_TASK_PERF_ID);
CI_TaskInit();
#ifdef _CI_DELAY_TEST
OS_printf("CI going to delay for 40 seconds before calling runloop\n");
OS_TaskDelay(40000);
#endif
/*
** CI Runloop
*/
while (CFE_ES_RunLoop(&RunStatus) == TRUE)
{
CFE_ES_PerfLogExit(CI_MAIN_TASK_PERF_ID);
/* Pend on receipt of command packet -- timeout set to 500 millisecs */
status = CFE_SB_RcvMsg(&CIMsgPtr, CI_CommandPipe, 500);
CFE_ES_PerfLogEntry(CI_MAIN_TASK_PERF_ID);
if (status == CFE_SUCCESS)
{
CI_ProcessCommandPacket();
}
/* Regardless of packet vs timeout, always process uplink queue */
if (CI_SocketConnected)
{
CI_ReadUpLink();
}
}
CFE_ES_ExitApp(RunStatus);
} /* End of CI_TaskMain() */
void TO_AppMain(void)
{
int32 iStatus;
CFE_ES_PerfLogEntry(TO_MAIN_TASK_PERF_ID);
/* Initialize the TO app*/
iStatus = TO_AppInit();
if (iStatus != CFE_SUCCESS)
{
TO_AppData.RunStatus= CFE_ES_APP_ERROR;
}
/* Application Main Loop */
while(CFE_ES_RunLoop(&TO_AppData.RunStatus) == TRUE)
{
/* Call RecvMsg to pend on sch wakeup msg */
TO_RecvMsg(TO_WAKEUP_TIMEOUT);
}
/* Exit the Application */
CFE_ES_ExitApp(TO_AppData.RunStatus);
}
void SC_AppMain(void)
{
uint32 RunStatus = CFE_ES_APP_RUN;
int32 Result;
/* Register application with cFE */
Result = CFE_ES_RegisterApp();
/* Performance Log (start time counter) */
CFE_ES_PerfLogEntry(SC_APPMAIN_PERF_ID);
/* Startup initialization */
if (Result == CFE_SUCCESS)
{
Result = SC_AppInit();
}
/* Check for start-up error */
if (Result != CFE_SUCCESS)
{
/* Set request to terminate main loop */
RunStatus = CFE_ES_APP_ERROR;
}
/* Main process loop */
while (CFE_ES_RunLoop(&RunStatus))
{
/* Performance Log (stop time counter) */
CFE_ES_PerfLogExit(SC_APPMAIN_PERF_ID);
/* Pend on Software Bus for message */
Result = CFE_SB_RcvMsg(&SC_OperData.MsgPtr, SC_OperData.CmdPipe, CFE_SB_PEND_FOREVER);
/* Performance Log (start time counter) */
CFE_ES_PerfLogEntry(SC_APPMAIN_PERF_ID);
/* Check for Software Bus error */
if (Result == CFE_SUCCESS)
{
/* Invoke command handlers */
SC_ProcessRequest(SC_OperData.MsgPtr);
}
else
{
/* Exit main process loop */
RunStatus = CFE_ES_APP_ERROR;
}
}
/* Check for "fatal" process error */
if (Result != CFE_SUCCESS)
{
/* Send event describing reason for termination */
CFE_EVS_SendEvent(SC_APP_EXIT_ERR_EID, CFE_EVS_ERROR,
"App terminating, Result = 0x%08X", Result);
/* In case cFE Event Services is not working */
CFE_ES_WriteToSysLog("SC App terminating, Result = 0x%08X\n", Result);
}
/* Performance Log (stop time counter) */
CFE_ES_PerfLogExit(SC_APPMAIN_PERF_ID);
/* Let cFE kill the app */
CFE_ES_ExitApp(RunStatus);
} /* end SC_AppMain() */
void SIMCI_TaskMain( void ) {
int32 Status = CFE_SUCCESS;
uint32 RunStatus = CFE_ES_APP_RUN;
struct timeval tv_timeout;
fd_set readfds;
int32 max_fd;
CFE_ES_PerfLogEntry(SIMCI_MAIN_TASK_PERF_ID);
Status = SIMCI_TaskInit();
if (Status != CFE_SUCCESS) {
RunStatus = CFE_ES_APP_ERROR;
}
/* Set up information for select */
max_fd = max(SIMCI_AppData.UplinkSocketID, SIMCI_AppData.IngestSocketID);
max_fd++;
tv_timeout.tv_sec = 0;
tv_timeout.tv_usec = SIMCI_PERIOD_USEC;
/* Runloop */
while (CFE_ES_RunLoop(&RunStatus) == TRUE)
{
FD_ZERO(&readfds);
FD_SET(SIMCI_AppData.UplinkSocketID, &readfds);
FD_SET(SIMCI_AppData.IngestSocketID, &readfds);
CFE_ES_PerfLogExit(SIMCI_MAIN_TASK_PERF_ID);
/* Select on the two sockets + SB pipe */
Status = select(max_fd, &readfds, NULL, NULL, &tv_timeout);
CFE_ES_PerfLogEntry(SIMCI_MAIN_TASK_PERF_ID);
if (Status == 0) {
/* Timed out, process some commands if available */
uint32 i;
for (i = 0; i < SIMCI_PIPE_DEPTH; i++) {
Status = CFE_SB_RcvMsg(&SIMCI_AppData.MsgPtr, SIMCI_AppData.CommandPipe, CFE_SB_POLL);
if (Status == CFE_SUCCESS) {
/* We have a message to process */
SIMCI_AppPipe();
} else if (Status == CFE_SB_NO_MESSAGE) {
/* Nothing to do, go back to sleep */
break;
} else {
SIMCI_AppData.HkPacket.error_count++;
CFE_EVS_SendEvent(SIMCI_PIPE_ERR_EID, CFE_EVS_ERROR, "SIMCI: Error reading command pipe, RC=%08X", Status);
}
}
} else {
if (FD_ISSET(SIMCI_AppData.UplinkSocketID, &readfds)) {
SIMCI_ForwardUplinkPacket();
}
if (FD_ISSET(SIMCI_AppData.IngestSocketID, &readfds)) {
SIMCI_IngestPacket();
}
}
}
CFE_ES_ExitApp(RunStatus);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void HS_AppMain(void)
{
int32 Status = CFE_SUCCESS;
uint32 RunStatus = CFE_ES_APP_RUN;
/*
** Performance Log, Start
*/
CFE_ES_PerfLogEntry(HS_APPMAIN_PERF_ID);
/*
** Register this application with Executive Services
*/
Status = CFE_ES_RegisterApp();
/*
** Perform application specific initialization
*/
if (Status == CFE_SUCCESS)
{
Status = HS_AppInit();
}
/*
** If no errors were detected during initialization, then wait for everyone to start
*/
if (Status == CFE_SUCCESS)
{
CFE_ES_WaitForStartupSync(HS_STARTUP_SYNC_TIMEOUT);
/*
** Enable and set the watchdog timer
*/
CFE_PSP_WatchdogSet(HS_WATCHDOG_TIMEOUT_VALUE);
CFE_PSP_WatchdogService();
CFE_PSP_WatchdogEnable();
CFE_PSP_WatchdogService();
/*
** Subscribe to Event Messages
*/
if (HS_AppData.CurrentEventMonState == HS_STATE_ENABLED)
{
Status = CFE_SB_SubscribeEx(CFE_EVS_EVENT_MSG_MID,
HS_AppData.EventPipe,
CFE_SB_Default_Qos,
HS_EVENT_PIPE_DEPTH);
if (Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(HS_SUB_EVS_ERR_EID, CFE_EVS_ERROR,
"Error Subscribing to Events,RC=0x%08X",Status);
}
}
}
if (Status != CFE_SUCCESS)
{
/*
** Set run status to terminate main loop
*/
RunStatus = CFE_ES_APP_ERROR;
}
/*
** Application main loop
*/
while(CFE_ES_RunLoop(&RunStatus) == TRUE)
{
/*
** Performance Log, Stop
*/
CFE_ES_PerfLogExit(HS_APPMAIN_PERF_ID);
/*
** Task Delay for a configured timeout
*/
#if HS_POST_PROCESSING_DELAY != 0
OS_TaskDelay(HS_POST_PROCESSING_DELAY);
#endif
/*
** Task Delay for a configured timeout
*/
Status = CFE_SB_RcvMsg(&HS_AppData.MsgPtr, HS_AppData.WakeupPipe, HS_WAKEUP_TIMEOUT);
/*
** Performance Log, Start
*/
CFE_ES_PerfLogEntry(HS_APPMAIN_PERF_ID);
/*
** Process the software bus message
*/
if ((Status == CFE_SUCCESS) ||
(Status == CFE_SB_NO_MESSAGE) ||
(Status == CFE_SB_TIME_OUT))
{
Status = HS_ProcessMain();
}
/*
** Note: If there were some reason to exit the task
** normally (without error) then we would set
** RunStatus = CFE_ES_APP_EXIT
*/
if (Status != CFE_SUCCESS)
{
/*
** Set request to terminate main loop
*/
RunStatus = CFE_ES_APP_ERROR;
}
} /* end CFS_ES_RunLoop while */
/*
** Check for "fatal" process error...
*/
if (Status != CFE_SUCCESS)
{
/*
** Send an event describing the reason for the termination
*/
CFE_EVS_SendEvent(HS_APP_EXIT_EID, CFE_EVS_CRITICAL,
"Application Terminating, err = 0x%08X", Status);
/*
** In case cFE Event Services is not working
*/
CFE_ES_WriteToSysLog("HS App: Application Terminating, ERR = 0x%08X\n", Status);
}
HS_CustomCleanup();
/*
** Performance Log, Stop
*/
CFE_ES_PerfLogExit(HS_APPMAIN_PERF_ID);
/*
** Exit the application
*/
CFE_ES_ExitApp(RunStatus);
} /* end HS_AppMain */
void EIM_NavDataTlmMain(void)
{
int32 Status = CFE_SUCCESS;
struct sockaddr_in addrNav;
uint32 RunStatus = CFE_ES_APP_RUN;
Status = CFE_ES_RegisterChildTask();
if(Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR,
"EIM: Failed to register telemetry listener task.");
CFE_ES_ExitChildTask();
}
/*
** Install the delete handler
*/
OS_TaskInstallDeleteHandler((void *)(&EIM_NavDataTlm_delete_callback));
/* Create sockets */
EIM_AppData.NavSocketID = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if(EIM_AppData.NavSocketID < 0)
{
CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR,"EIM: Create Nav telemetry socket failed = %d", errno);
CFE_ES_ExitChildTask();
}
//EIM_AppData.ATCmdSocketID = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
//if(EIM_AppData.ATCmdSocketID < 0)
//{
// CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR,"EIM: Create Nav command socket failed = %d", errno);
// CFE_ES_ExitChildTask();
//}
memset((char *) &addrNav, 0, sizeof(addrNav));
addrNav.sin_family = AF_INET;
addrNav.sin_port = htons(EIM_NAV_DATA_PORT+100);
addrNav.sin_addr.s_addr = htonl(INADDR_ANY);
OS_printf("EIM: Binding NAV socket.\n");
if ( bind(EIM_AppData.NavSocketID, (struct sockaddr *) &addrNav,
sizeof(addrNav)) < 0)
{
CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR,
"EIM: Failed to bind NAV command socket. errno: %d", errno);
CFE_ES_ExitChildTask();
}
/* Set addresses */
//bzero((char *) &EIM_AppData.CmdSocketAddress, sizeof(EIM_AppData.CmdSocketAddress));
//EIM_AppData.CmdSocketAddress.sin_family = AF_INET;
//EIM_AppData.CmdSocketAddress.sin_addr.s_addr = inet_addr("0.0.0.0");
//EIM_AppData.CmdSocketAddress.sin_port = htons(0);
//bzero((char *) &EIM_AppData.CmdARDroneAddress, sizeof(EIM_AppData.CmdARDroneAddress));
//EIM_AppData.CmdARDroneAddress.sin_family = AF_INET;
//EIM_AppData.CmdARDroneAddress.sin_addr.s_addr = inet_addr(EIM_WIFI_IP);
//EIM_AppData.CmdARDroneAddress.sin_port = htons(EIM_AT_PORT);
//if ( bind(EIM_AppData.ATCmdSocketID,
// (struct sockaddr *) &EIM_AppData.CmdSocketAddress,
// sizeof(EIM_AppData.CmdSocketAddress)) < 0)
//{
// CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR,
// "EIM: Failed to bind command socket. errno: %d", errno);
// CFE_ES_ExitChildTask();
//}
//
//EIM_InitATCmdSockets();
OS_TaskDelay(100);
EIM_ResetTlmConnection();
if(CFE_ES_RunLoop(&RunStatus) == FALSE)
{
EIM_AppData.Hk.NavDataState = EIM_NAVDATA_FAILED;
}
else
{
EIM_AppData.Hk.NavDataState = EIM_NAVDATA_ENABLED;
}
while (CFE_ES_RunLoop(&RunStatus) == TRUE)
{
EIM_ReadTelem();
if(EIM_AppData.Hk.ARDroneState.CommWatchdog == TRUE)
{
if(EIM_AppData.Hk.ARDrone2TimedOut == FALSE)
{
CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR, "EIM: ARDrone timedout. Resetting watchdog.");
EIM_AppData.Hk.ARDrone2TimedOut = TRUE;
}
EIM_cmdComWdg();
}
else
{
if(EIM_AppData.Hk.ARDrone2TimedOut == TRUE)
{
CFE_EVS_SendEvent(EIM_TELEM_TASK_ERR_EID, CFE_EVS_ERROR, "EIM: ARDrone watchdog reset.");
EIM_AppData.Hk.ARDrone2TimedOut = FALSE;
}
}
}
close(EIM_AppData.ATCmdSocketID);
close(EIM_AppData.NavSocketID);
EIM_AppData.ATCmdSocketID = 0;
EIM_AppData.NavSocketID = 0;
EIM_AppData.Hk.NavDataState = EIM_NAVDATA_DISABLED;
CFE_ES_ExitApp(RunStatus);
}
