void CFE_TBL_InitData(void)
{
/* Initialize Counters */
CFE_TBL_TaskData.CmdCounter = 0;
CFE_TBL_TaskData.ErrCounter = 0;
CFE_TBL_TaskData.SuccessValCtr = 0;
CFE_TBL_TaskData.FailedValCtr = 0;
/* Get the assigned Application ID for the Table Services Task */
CFE_ES_GetAppID(&CFE_TBL_TaskData.TableTaskAppId);
/* Initialize Command Pipe Parameters */
CFE_TBL_TaskData.PipeDepth = CFE_TBL_TASK_PIPE_DEPTH;
strncpy(CFE_TBL_TaskData.PipeName, CFE_TBL_TASK_PIPE_NAME, 16);
/* Initialize Packet Headers */
CFE_SB_InitMsg(&CFE_TBL_TaskData.HkPacket,
CFE_TBL_HK_TLM_MID,
sizeof(CFE_TBL_HkPacket_t),
TRUE);
CFE_SB_InitMsg(&CFE_TBL_TaskData.TblRegPacket,
CFE_TBL_REG_TLM_MID,
sizeof(CFE_TBL_TblRegPacket_t),
TRUE);
} /* End of CFE_TBL_InitData() */
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: InitApp
**
*/
static int32 InitApp(void)
{
int32 Status = CFE_SUCCESS;
/*
** Initialize 'entity' objects
*/
PKTMGR_Constructor(&LabTlm.PktMgr, PKTMGR_PIPE_NAME, PKTMGR_PIPE_DEPTH);
/*
** Initialize application managers
*/
TBLMGR_Constructor(&LabTlm.TblMgr, LABTLM_DEF_PKTTBL_FILE_NAME);
CFE_SB_CreatePipe(&LabTlm.CmdPipe, CMDMGR_PIPE_DEPTH, CMDMGR_PIPE_NAME);
CFE_SB_Subscribe(LABTLM_CMD_MID, LabTlm.CmdPipe);
CFE_SB_Subscribe(LABTLM_SEND_HK_MID, LabTlm.CmdPipe);
CMDMGR_Constructor(&LabTlm.CmdMgr);
CMDMGR_RegisterFunc(LABTLM_CMD_RESET_FC, LABTLM_ResetAppCmd, 0);
CMDMGR_RegisterFunc(LABTLM_CMD_NOOP_FC, LABTLM_NoOpCmd, 0);
CMDMGR_RegisterFunc(LABTLM_CMD_PKT_TBL_LOAD_FC, TBLMGR_LoadPktTable, TBLMGR_LOAD_TBL_CMD_DATA_LEN);
CMDMGR_RegisterFunc(LABTLM_CMD_PKT_TBL_DUMP_FC, TBLMGR_DumpPktTable, TBLMGR_DUMP_TBL_CMD_DATA_LEN);
CMDMGR_RegisterFunc(LABTLM_CMD_ADD_PKT_FC, PKTMGR_AddPktCmd, PKKTMGR_ADD_PKT_CMD_DATA_LEN);
CMDMGR_RegisterFunc(LABTLM_CMD_REMOVE_PKT_FC, PKTMGR_RemovePktCmd, PKKTMGR_REMOVE_PKT_CMD_DATA_LEN);
CMDMGR_RegisterFunc(LABTLM_CMD_REMOVE_ALL_PKTS_FC, PKTMGR_RemoveAllPktsCmd, 0);
CMDMGR_RegisterFunc(LABTLM_CMD_ENABLE_OUTPUT_FC, PKTMGR_EnableOutputCmd, PKKTMGR_ENABLE_OUTPUT_CMD_DATA_LEN);
CMDMGR_RegisterFunc(LABTLM_CMD_SEND_DATA_TYPES_FC, LABTLM_SendDataTypeTlmCmd, 0);
CFE_SB_InitMsg(&LabTlmHkPkt, LABTLM_TLM_HK_MID, LABTLM_TLM_HK_LEN, TRUE);
InitDataTypePkt();
/*
** Application startup event message
*/
Status = CFE_EVS_SendEvent(LABTLM_INIT_APP_INFO_EID,
CFE_EVS_INFORMATION,
"TO-LAB Initialized. Version %d.%d.%d.%d",
LABTLM_MAJOR_VERSION,
LABTLM_MINOR_VERSION,
LABTLM_REVISION,
LABTLM_MISSION_REV);
return(Status);
} /* End of InitApp() */
/******************************************************************************
** Function: CFE_SB_EarlyInit()
**
** Purpose:
** Initialize the Software Bus routing tables.
**
** Arguments:
**
** Notes:
** This function MUST be called before any SB API's are called.
**
** Return:
** CFE_SUCCESS
*/
int32 CFE_SB_EarlyInit (void) {
int32 Stat = CFE_SUCCESS;
CFE_SB_Default_Qos.Priority = CFE_SB_QOS_LOW_PRIORITY;
CFE_SB_Default_Qos.Reliability = CFE_SB_QOS_LOW_RELIABILITY;
Stat = OS_MutSemCreate(&CFE_SB.SharedDataMutexId, "CFE_SB_DataMutex", 0);
if(Stat != OS_SUCCESS){
CFE_ES_WriteToSysLog("SB shared data mutex creation failed! RC=0x%08x\n",(unsigned int)Stat);
return Stat;
}/* end if */
/* Initialize the state of susbcription reporting */
CFE_SB.SubscriptionReporting = CFE_SB_DISABLE;
/* Initialize the state of sender reporting */
CFE_SB.SenderReporting = CFE_SB_DEFAULT_REPORT_SENDER;
/* Initialize memory partition. */
Stat = CFE_SB_InitBuffers();
if(Stat != CFE_SUCCESS){
/* error reported in CFE_SB_InitBuffers */
return Stat;
}/* end if */
/* Initialize the pipe table. */
CFE_SB_InitPipeTbl();
/* Initialize the routing index look up table */
CFE_SB_InitMsgMap();
/* Initialize the routing table. */
CFE_SB_InitRoutingTbl();
/* Initialize the SB Statistics Pkt */
CFE_SB_InitMsg(&CFE_SB.StatTlmMsg.Hdr.Pri,
CFE_SB_STATS_TLM_MID,
sizeof(CFE_SB_StatMsg_t),
TRUE);
CFE_SB.ZeroCopyTail = NULL;
return Stat;
}/* end CFE_SB_EarlyInit */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void TO_output_data_types_packet(void)
{
int16 i;
char string_variable[10] = "ABCDEFGHIJ";
/* initialize data types packet */
CFE_SB_InitMsg(&data_types_pkt,
TO_LAB_DATA_TYPES_MID,
sizeof(data_types_pkt), TRUE);
CFE_SB_TimeStampMsg((CFE_SB_MsgPtr_t) &data_types_pkt);
/* initialize the packet data */
data_types_pkt.synch = 0x6969;
#if 0
data_types_pkt.bit1 = 1;
data_types_pkt.bit2 = 0;
data_types_pkt.bit34 = 2;
data_types_pkt.bit56 = 3;
data_types_pkt.bit78 = 1;
data_types_pkt.nibble1 = 0xA;
data_types_pkt.nibble2 = 0x4;
#endif
data_types_pkt.bl1 = FALSE;
data_types_pkt.bl2 = TRUE;
data_types_pkt.b1 = 16;
data_types_pkt.b2 = 127;
data_types_pkt.b3 = 0x7F;
data_types_pkt.b4 = 0x45;
data_types_pkt.w1 = 0x2468;
data_types_pkt.w2 = 0x7FFF;
data_types_pkt.dw1 = 0x12345678;
data_types_pkt.dw2 = 0x87654321;
data_types_pkt.f1 = 90.01;
data_types_pkt.f2 = .0000045;
data_types_pkt.df1 = 99.9;
data_types_pkt.df2 = .4444;
for (i=0; i < 10; i++) data_types_pkt.str[i] = string_variable[i];
CFE_SB_SendMsg((CFE_SB_Msg_t *)&data_types_pkt);
} /* End of TO_output_data_types_packet() */
/*
** Function Prologue
**
** Function Name: EVS_SendEventInternal
** from: cfe_evs_utils.c in cFE 3.1, originally named EVS_SendEvent
**
** Purpose: This routine sends an EVS event message out the software bus and all
** enabled output ports if the calling application has been determined to
** be registered and the event message is unfiltered
**
** Assumptions and Notes:
*/
int32 EVS_SendEventInternal(uint32 AppID, CFE_TIME_SysTime_t Time, uint16 EventID, uint16 EventType, char *EventString)
{
int32 Status = CFE_SUCCESS;
CFE_EVS_Packet_t EVS_Packet;
boolean IsFiltered = FALSE;
if(Status == CFE_SUCCESS)
{
if (!(IsFiltered))
{
/* Initialize CCSDS event packet */
CFE_SB_InitMsg(&(EVS_Packet), CFE_EVS_EVENT_MSG_MID, sizeof(CFE_EVS_Packet_t), FALSE);
/* Set the packet timestamp */
CFE_SB_SetMsgTime((CFE_SB_Msg_t *) &EVS_Packet, Time);
/* Initialize event message string */
EVS_Packet.Message[0] = '\0';
/* Obtain task and system information */
/* EVS_Packet.PacketID.SpacecraftID = OS_BSPGetSpacecraftId(); */
CFE_ES_GetAppName(EVS_Packet.PacketID.AppName, AppID, OS_MAX_API_NAME);
/* EVS_Packet.PacketID.ProcessorID = OS_BSPGetProcessorId(); */
EVS_Packet.PacketID.EventID = EventID;
EVS_Packet.PacketID.EventType = EventType;
/* Copy message string to event packet message buffer */
strncpy(EVS_Packet.Message, EventString, CFE_EVS_MAX_MESSAGE_LENGTH);
/* Ensure that the packet is always terminated by a null character */
EVS_Packet.Message[CFE_EVS_MAX_MESSAGE_LENGTH-1] = '\0';
/* send event out software bus */
Status = CFE_SB_SendMsg((CFE_SB_Msg_t *) &EVS_Packet);
}
}
return Status;
} /* End EVS_SendEventInternal */
/*
** Function Prologue
**
** Function Name: CFE_EVS_SendTimedEvent
**
** Purpose: This routine sends a timed event message, with message ID containing the
** current processor/box and task ID as well as the eventID.
**
** Assumptions and Notes:
** Original routine returns CFE_EVS_ERR or CFE_EVS_ERR_NONE.
*/
int32 CFE_EVS_SendTimedEvent (CFE_TIME_SysTime_t Time, uint16 EventID,
uint16 EventType, const char *Spec, ... )
{
char BigBuf[CFE_EVS_MAX_MESSAGE_LENGTH];
char GTBigBuf[CFE_EVS_MAX_MESSAGE_LENGTH + 2];
va_list Ptr;
CFE_EVS_Packet_t EVS_Packet;
/* Handle Preset Return Code */
if (cfe_evs_api_return_value[CFE_EVS_SENDTIMEDEVENT_PROC] != UTF_CFE_USE_DEFAULT_RETURN_CODE)
{
return cfe_evs_api_return_value[CFE_EVS_SENDTIMEDEVENT_PROC];
}
/* Initialize CCSDS event packet */
CFE_SB_InitMsg(&(EVS_Packet), CFE_EVS_EVENT_MSG_MID, sizeof(CFE_EVS_Packet_t), FALSE);
/* Set the packet timestamp */
CFE_SB_SetMsgTime((CFE_SB_Msg_t *) &EVS_Packet, Time);
EVS_Packet.Message[0] = '\0';
/* Copy message to event packet if long format is enabled */
va_start(Ptr, Spec);
vsnprintf(GTBigBuf, CFE_EVS_MAX_MESSAGE_LENGTH +2, Spec, Ptr);
va_end(Ptr);
if (strlen(GTBigBuf) > CFE_EVS_MAX_MESSAGE_LENGTH)
{
UTF_put_text ("Max Event Message Size Exceeded. Permitted %d; Actual %d\n",
CFE_EVS_MAX_MESSAGE_LENGTH, strlen(GTBigBuf));
}
strncpy(BigBuf,GTBigBuf,CFE_EVS_MAX_MESSAGE_LENGTH);
UTF_put_text("TIMED EVENT: %s\n", BigBuf);
return CFE_SUCCESS;
} /* End CFE_EVS_SendTimedEvent */
/******************************************************************************
** Function: InitDataTypePkt
**
*/
static void InitDataTypePkt(void)
{
int16 i;
char StringVariable[10] = "ABCDEFGHIJ";
CFE_SB_InitMsg(&ToDataTypePkt, LABTLM_TLM_DATA_TYPE_MID, LABTLM_TLM_DATA_TYPE_LEN, TRUE);
ToDataTypePkt.synch = 0x6969;
#if 0
ToDataTypePkt.bit1 = 1;
ToDataTypePkt.bit2 = 0;
ToDataTypePkt.bit34 = 2;
ToDataTypePkt.bit56 = 3;
ToDataTypePkt.bit78 = 1;
ToDataTypePkt.nibble1 = 0xA;
ToDataTypePkt.nibble2 = 0x4;
#endif
ToDataTypePkt.bl1 = FALSE;
ToDataTypePkt.bl2 = TRUE;
ToDataTypePkt.b1 = 16;
ToDataTypePkt.b2 = 127;
ToDataTypePkt.b3 = 0x7F;
ToDataTypePkt.b4 = 0x45;
ToDataTypePkt.w1 = 0x2468;
ToDataTypePkt.w2 = 0x7FFF;
ToDataTypePkt.dw1 = 0x12345678;
ToDataTypePkt.dw2 = 0x87654321;
ToDataTypePkt.f1 = 90.01;
ToDataTypePkt.f2 = .0000045;
ToDataTypePkt.df1 = 99.9;
ToDataTypePkt.df2 = .4444;
for (i=0; i < 10; i++) ToDataTypePkt.str[i] = StringVariable[i];
} /* End InitDataTypePkt() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/
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 Test_LoadWID(void)
{
MM_LoadMemWIDCmd_t CmdMsg;
uint32 LocalCrc;
/* Setup the test message header */
CFE_SB_InitMsg(&CmdMsg, MM_CMD_MID, sizeof(MM_LoadMemWIDCmd_t), TRUE);
/*
** Setup the load data array in the command message with the
** maximum amount of data allowed.
*/
memcpy(CmdMsg.DataArray, MM_TestDataSet, MM_MAX_UNINTERRUPTABLE_DATA);
/* Compute the CRC value */
LocalCrc = CFE_ES_CalculateCRC(MM_TestDataSet, MM_MAX_UNINTERRUPTABLE_DATA,
0, CFE_ES_DEFAULT_CRC);
UTF_put_text("**********************************************\n");
UTF_put_text("* Memory Load With Interrupts Disabled Tests *\n");
UTF_put_text("**********************************************\n");
UTF_put_text("\n");
/*
** Test bad symbol name
*/
UTF_put_text("Test Load WID With Bad Symbol Name \n");
UTF_put_text("-----------------------------------\n");
strcpy(CmdMsg.DestSymAddress.SymName, "BadSymName");
CmdMsg.DestSymAddress.Offset = 0;
CmdMsg.NumOfBytes = MM_MAX_UNINTERRUPTABLE_DATA;
CmdMsg.Crc = LocalCrc;
MM_LoadMemWIDCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test bad address
*/
UTF_put_text("Test Load WID With Bad Address \n");
UTF_put_text("-------------------------------\n");
CmdMsg.DestSymAddress.SymName[0] = '\0';
CmdMsg.DestSymAddress.Offset = SIM_BAD_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_UNINTERRUPTABLE_DATA;
CmdMsg.Crc = LocalCrc;
MM_LoadMemWIDCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test bad CRC value
*/
UTF_put_text("Test Load WID With Bad CRC value \n");
UTF_put_text("---------------------------------\n");
CmdMsg.DestSymAddress.SymName[0] = '\0';
CmdMsg.DestSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_UNINTERRUPTABLE_DATA;
CmdMsg.Crc = LocalCrc ^ 0xF0F0F0F0;
MM_LoadMemWIDCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test data size that exceeds configuration limits
*/
UTF_put_text("Test Load WID That Exceeds Configuration Limits \n");
UTF_put_text("------------------------------------------------\n");
CmdMsg.DestSymAddress.SymName[0] = '\0';
CmdMsg.DestSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = 0xFF;
CmdMsg.Crc = LocalCrc;
MM_LoadMemWIDCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test zero byte load
*/
UTF_put_text("Test Load WID With Zero Data Specified \n");
UTF_put_text("---------------------------------------\n");
CmdMsg.DestSymAddress.SymName[0] = '\0';
CmdMsg.DestSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = 0;
CmdMsg.Crc = 0;
MM_LoadMemWIDCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid load of maximum size
*/
UTF_put_text("Test Valid Load WID of Maximum Size \n");
UTF_put_text("------------------------------------\n");
CmdMsg.DestSymAddress.SymName[0] = '\0';
CmdMsg.DestSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_UNINTERRUPTABLE_DATA;
CmdMsg.Crc = LocalCrc;
MM_LoadMemWIDCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid load less than maximum size
*/
UTF_put_text("Test Valid Load WID Less Than Maximum Size \n");
UTF_put_text("-------------------------------------------\n");
CmdMsg.DestSymAddress.SymName[0] = '\0';
CmdMsg.DestSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = 100;
CmdMsg.Crc = CFE_ES_CalculateCRC(MM_TestDataSet, 100, 0,
CFE_ES_DEFAULT_CRC);
MM_LoadMemWIDCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
} /* end Test_LoadWID */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
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() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
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() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int32 HS_SbInit(void)
{
int32 Status = CFE_SUCCESS;
HS_AppData.MsgPtr = (CFE_SB_MsgPtr_t) NULL;
HS_AppData.CmdPipe = 0;
HS_AppData.EventPipe = 0;
HS_AppData.WakeupPipe = 0;
/* Initialize housekeeping packet */
CFE_SB_InitMsg(&HS_AppData.HkPacket,HS_HK_TLM_MID,sizeof(HS_HkPacket_t),TRUE);
/* Create Command Pipe */
Status = CFE_SB_CreatePipe (&HS_AppData.CmdPipe,HS_CMD_PIPE_DEPTH,HS_CMD_PIPE_NAME);
if (Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(HS_CR_CMD_PIPE_ERR_EID, CFE_EVS_ERROR,
"Error Creating SB Command Pipe,RC=0x%08X",Status);
return (Status);
}
/* Create Event Pipe */
Status = CFE_SB_CreatePipe (&HS_AppData.EventPipe,HS_EVENT_PIPE_DEPTH,HS_EVENT_PIPE_NAME);
if (Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(HS_CR_EVENT_PIPE_ERR_EID, CFE_EVS_ERROR,
"Error Creating SB Event Pipe,RC=0x%08X",Status);
return (Status);
}
/* Create Wakeup Pipe */
Status = CFE_SB_CreatePipe (&HS_AppData.WakeupPipe,HS_WAKEUP_PIPE_DEPTH,HS_WAKEUP_PIPE_NAME);
if (Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(HS_CR_WAKEUP_PIPE_ERR_EID, CFE_EVS_ERROR,
"Error Creating SB Wakeup Pipe,RC=0x%08X",Status);
return (Status);
}
/* Subscribe to Housekeeping Request */
Status = CFE_SB_Subscribe(HS_SEND_HK_MID,HS_AppData.CmdPipe);
if (Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(HS_SUB_REQ_ERR_EID, CFE_EVS_ERROR,
"Error Subscribing to HK Request,RC=0x%08X",Status);
return (Status);
}
/* Subscribe to HS ground commands */
Status = CFE_SB_Subscribe(HS_CMD_MID,HS_AppData.CmdPipe);
if (Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(HS_SUB_CMD_ERR_EID, CFE_EVS_ERROR,
"Error Subscribing to Gnd Cmds,RC=0x%08X",Status);
return (Status);
}
/* Subscribe to HS Wakeup Message */
Status = CFE_SB_Subscribe(HS_WAKEUP_MID,HS_AppData.WakeupPipe);
if (Status != CFE_SUCCESS)
{
CFE_EVS_SendEvent(HS_SUB_WAKEUP_ERR_EID, CFE_EVS_ERROR,
"Error Subscribing to Wakeup,RC=0x%08X",Status);
return (Status);
}
/*
** Event message subscription delayed until after startup synch
*/
return(Status);
} /* End of HS_SbInit() */
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;
}
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() */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void Test_SymTblDump(void)
{
MM_SymTblToFileCmd_t DumpSymTblCmdMsg;
/* Setup the test message header */
CFE_SB_InitMsg(&DumpSymTblCmdMsg, MM_CMD_MID, sizeof(MM_SymTblToFileCmd_t), TRUE);
UTF_put_text("***************************\n");
UTF_put_text("* Symbol Table Dump Tests *\n");
UTF_put_text("***************************\n");
UTF_put_text("\n");
/*
** Test empty file name
*/
UTF_put_text("Test symbol dump with empty file name \n");
UTF_put_text("--------------------------------------\n");
DumpSymTblCmdMsg.FileName[0] = '\0';
MM_SymTblToFileCmd((CFE_SB_MsgPtr_t)&DumpSymTblCmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test invalid file name
*/
UTF_put_text("Test symbol dump with invalid file name \n");
UTF_put_text("--------------------------------------\n");
strcpy(DumpSymTblCmdMsg.FileName, "BadFile*Name");
MM_SymTblToFileCmd((CFE_SB_MsgPtr_t)&DumpSymTblCmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test good file name but OS table dump failure
*/
UTF_put_text("Test symbol dump with good filename but bad OS return \n");
UTF_put_text("------------------------------------------------------\n");
UTF_SetOSSymbolTableDumpStatus(OS_ERROR);
strcpy(DumpSymTblCmdMsg.FileName, "IrrelevantFileName");
MM_SymTblToFileCmd((CFE_SB_MsgPtr_t)&DumpSymTblCmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test good file name but OS table dump failure
*/
UTF_put_text("Test symbol dump with good filename but bad OS file \n");
UTF_put_text("----------------------------------------------------\n");
UTF_SetOSSymbolTableDumpStatus(OS_ERR_FILE);
strcpy(DumpSymTblCmdMsg.FileName, "IrrelevantFileName");
MM_SymTblToFileCmd((CFE_SB_MsgPtr_t)&DumpSymTblCmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test good file name and success from OS
*/
UTF_put_text("Test symbol dump with good filename and successful return\n");
UTF_put_text("---------------------------------------------------------\n");
UTF_SetOSSymbolTableDumpStatus(OS_SUCCESS);
strcpy(DumpSymTblCmdMsg.FileName, "GoodFileName");
MM_SymTblToFileCmd((CFE_SB_MsgPtr_t)&DumpSymTblCmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
} /* end Test_SymTblDump */
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 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;
}
void init_cmd_pkt(CCSDS_CmdPkt_t *packet, uint16 mid, uint16 cmd_code){
CFE_SB_InitMsg(packet, mid, sizeof(CCSDS_CmdPkt_t), TRUE);
CFE_SB_SetCmdCode((CFE_SB_MsgPtr_t) packet, cmd_code);
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void Test_DumpInEvent(void)
{
MM_DumpInEventCmd_t CmdMsg;
/* Setup the test message header */
CFE_SB_InitMsg(&CmdMsg, MM_CMD_MID, sizeof(MM_DumpInEventCmd_t), TRUE);
UTF_put_text("**********************************************\n");
UTF_put_text("* Memory Dump In Event Message Tests *\n");
UTF_put_text("**********************************************\n");
UTF_put_text("\n");
/*
** Test bad symbol name
*/
UTF_put_text("Test Dump In Event With Bad Symbol Name \n");
UTF_put_text("----------------------------------------\n");
strcpy(CmdMsg.SrcSymAddress.SymName, "BadSymName");
CmdMsg.SrcSymAddress.Offset = 0;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_RAM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test dump size zero
*/
UTF_put_text("Test Dump In Event With Dump Size Zero \n");
UTF_put_text("---------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = 0;
CmdMsg.MemType = MM_RAM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test dump size too large
*/
UTF_put_text("Test Dump In Event With Dump Size Too Big \n");
UTF_put_text("------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES + 10;
CmdMsg.MemType = MM_RAM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test dump with invalid RAM address
*/
UTF_put_text("Test Dump In Event With Invalid RAM Address \n");
UTF_put_text("--------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_BAD_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_RAM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test dump with invalid EEPROM address
*/
UTF_put_text("Test Dump In Event With Invalid EEPROM Address \n");
UTF_put_text("-----------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_BAD_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_EEPROM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test MEM32 dump with misaligned address
*/
UTF_put_text("Test MEM32 Dump In Event With Misaligned Address \n");
UTF_put_text("-------------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR + 3;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM32;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test MEM32 dump with misaligned data size
*/
UTF_put_text("Test MEM32 Dump In Event With Misaligned Data Size \n");
UTF_put_text("---------------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES - 3;
CmdMsg.MemType = MM_MEM32;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test MEM32 dump with invalid address
*/
UTF_put_text("Test MEM32 Dump In Event With Invalid Address \n");
UTF_put_text("----------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_BAD_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM32;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test MEM16 dump with misaligned address
*/
UTF_put_text("Test MEM16 Dump In Event With Misaligned Address \n");
UTF_put_text("-------------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR + 3;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM16;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test MEM16 dump with misaligned data size
*/
UTF_put_text("Test MEM16 Dump In Event With Misaligned Data Size \n");
UTF_put_text("---------------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES - 3;
CmdMsg.MemType = MM_MEM16;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test MEM16 dump with invalid address
*/
UTF_put_text("Test MEM16 Dump In Event With Invalid Address \n");
UTF_put_text("----------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_BAD_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM16;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test MEM8 dump with invalid address
*/
UTF_put_text("Test MEM8 Dump In Event With Invalid Address \n");
UTF_put_text("---------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_BAD_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM8;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test dump with invalid memory type
*/
UTF_put_text("Test Dump In Event With Invalid Memory Type \n");
UTF_put_text("--------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = 0xFF;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid RAM dump of maximum size
*/
UTF_put_text("Test RAM Dump In Event Max Bytes \n");
UTF_put_text("---------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_RAM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid RAM dump less than maximum size
*/
UTF_put_text("Test RAM Dump In Event Less Than Max Bytes \n");
UTF_put_text("-------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES / 2;
CmdMsg.MemType = MM_RAM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid EEPROM dump of maximum size
*/
UTF_put_text("Test EEPROM Dump In Event Max Bytes \n");
UTF_put_text("------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_EEPROM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_EEPROM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid EEPROM dump less than maximum size
*/
UTF_put_text("Test EEPROM Dump In Event Less Than Max Bytes \n");
UTF_put_text("----------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_EEPROM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES / 2;
CmdMsg.MemType = MM_EEPROM;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid MEM32 dump of maximum size
*/
UTF_put_text("Test MEM32 Dump In Event Max Bytes \n");
UTF_put_text("-----------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM32;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid MEM32 dump less than maximum size
*/
UTF_put_text("Test MEM32 Dump In Event Less Than Max Bytes \n");
UTF_put_text("---------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES / 2;
CmdMsg.MemType = MM_MEM32;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid MEM16 dump of maximum size
*/
UTF_put_text("Test MEM16 Dump In Event Max Bytes \n");
UTF_put_text("-----------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM16;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid MEM16 dump less than maximum size
*/
UTF_put_text("Test MEM16 Dump In Event Less Than Max Bytes \n");
UTF_put_text("---------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES / 2;
CmdMsg.MemType = MM_MEM16;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid MEM8 dump of maximum size
*/
UTF_put_text("Test MEM8 Dump In Event Max Bytes \n");
UTF_put_text("----------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES;
CmdMsg.MemType = MM_MEM8;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
/*
** Test valid MEM8 dump less than maximum size
*/
UTF_put_text("Test MEM8 Dump In Event Less Than Max Bytes \n");
UTF_put_text("--------------------------------------------\n");
CmdMsg.SrcSymAddress.SymName[0] = '\0';
CmdMsg.SrcSymAddress.Offset = SIM_RAM_MEM_ADDR;
CmdMsg.NumOfBytes = MM_MAX_DUMP_INEVENT_BYTES / 2;
CmdMsg.MemType = MM_MEM8;
MM_DumpInEventCmd((CFE_SB_MsgPtr_t)&CmdMsg);
PrintLocalHKVars();
UTF_put_text("\n");
} /* end Test_DumpInEvent */
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;
}
