static void test_task_delete(void) {
test_emit_token('A');
(void) OS_TaskInstallDeleteHandler(delete_handler);
while (!OS_TaskDeleteCheck()) {
(void) OS_TaskDelay(1);
}
test_emit_token('B');
}
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() */
/*----------------------------------------------------------------------------*/
void Test_OS_TaskInstallDeleteHandler_IdInvalid(void)
{
int32 expected = OS_ERR_INVALID_ID;
int32 actual = 99;
/* Setup Inputs */
OsApi_Adaptor_setOsTaskKey(OS_MAX_TASKS);
/* Execute Test */
actual = OS_TaskInstallDeleteHandler(dummyFnc);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERR_INVALID_ID");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == 0, "No semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
/*----------------------------------------------------------------------------*/
void Test_OS_TaskInstallDeleteHandler_Success(void)
{
int32 expected = OS_SUCCESS;
int32 actual = 99;
/* Setup Inputs */
uint32 idx = 1;
OsApi_Adaptor_setOsTaskKey(idx);
/* Execute Test */
actual = OS_TaskInstallDeleteHandler(dummyFnc);
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_SUCCESS");
UtAssert_True(OsApi_Adaptor_getTaskTableEntry(idx)->delete_hook_pointer == dummyFnc,
"delete_hook_pointer == expected");
/* Verify Semaphore Usage */
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) > 0, "semaphore taken");
UtAssert_True(getNSemTake(OS_TASK_TABLE_SEM) == getNSemGive(OS_TASK_TABLE_SEM),
"nSemTake == nSemGive");
}
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 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;
}
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);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
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() */
