void UU_AppMain(void) { int32 Status; int32 Status2; CFE_SB_PipeId_t pipeId; char pipeName[10]; void *TblPointer; CFE_TBL_Handle_t TblHandle; /* ** Register application... */ /* CFE_ES_RegisterApp(); */ /* ** Perform application specific initialize ** including access initial table values. */ UU_AppInit(); TblHandle = 0; /* original was 5 */ /* ** Main process loop (forever)... */ while (TRUE) { /* ** Wait for the next Software Bus message... */ Status = CFE_SB_RcvMsg(&UU_AppData.MsgPtr, UU_AppData.CmdPipe, 4); /* if (Status == CFE_SB_TIME_OUT) */ if (1) { UTF_put_text("CFE_ES_ResetCFE returned %lx\n",CFE_ES_ResetCFE(5)); UTF_put_text("CFE_ES_RegisterApp returned %lx\n",CFE_ES_RegisterApp()); /* This one caused a seg fault */ /*UTF_put_text("CFE_ES_GetAppID returned %d\n",CFE_ES_GetAppID((uint32 *)0x3344beef)); */ UTF_put_text("CFE_ES_GetAppID returned %lx\n",CFE_ES_GetAppID(0)); Status2 = CFE_EVS_SendEvent(UU_INIT_INF_EID, CFE_EVS_INFORMATION, "UU: SendEvent called from UU task's forever loop"); UTF_put_text("CFE_EVS_SendEvent returned %lx\n", Status2); UTF_put_text("CFE_FS_ReadHeader returned %lx\n", CFE_FS_ReadHeader(0,0)); UTF_put_text("CFE_SB_CreatePipe returned %lx\n", CFE_SB_CreatePipe(&pipeId,1,pipeName)); UTF_put_text("CFE_SB_RcvMsg returned %lx\n", Status); UTF_put_text(" CFE_TBL_GetAddress returned %lx\n", CFE_TBL_GetAddress( &TblPointer,TblHandle )); } } } /* End of UU_AppMain() */
int main(void) { char AppName[10]; strcpy(AppName, "TT"); /********************************/ /* Set up to read in script */ /********************************/ UTF_add_input_file(CFE_TT_CMD_PIPE, "ttscript1.in"); TT_AppData.CmdPipe = CFE_TT_CMD_PIPE; /* Hook for application code */ UTF_add_special_command("LOAD_TABLE_FROM_GROUND", UTF_SCRIPT_LoadTableFromGround); /********************************/ /* Set up output file */ /********************************/ UTF_set_output_filename("test_tbl_api2.ActualOutput"); UTF_set_packet_handler(CFE_TT_HK_TLM_MID, print_housekeeping); UTF_add_volume("/", "ram", FS_BASED, FALSE, FALSE, TRUE, "RAM", "/ram", 0); /**************************************************/ /* Initialize time data structures */ /**************************************************/ UTF_init_sim_time(0.0); UTF_OSAPI_set_function_hook(OS_GETLOCALTIME_HOOK, time_hook); /**************************************************/ /* Call utility to register task TT with */ /* Executive Services. */ /**************************************************/ UTF_ES_InitAppRecords(); UTF_ES_AddAppRecord("TT",0); CFE_ES_RegisterApp(); /* Create Input Files */ Create_Input_File0(); Create_Input_File1(); Create_Input_File2(); Create_Input_File3(); /**************************************************/ /* Initialize Table Services data structures */ /**************************************************/ /* Initialize the CDS */ CFE_ES_CDS_EarlyInit(); CFE_TBL_EarlyInit(); /********************************/ /* Call Main procedure for table owner application*/ /********************************/ TT_AppMain(); return 0; }
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() */
void TT_AppMain(void) { int32 Status; /* ** Register application... */ CFE_ES_RegisterApp(); /* ** Perform application specific initialize ** including access initial table values. */ TT_AppInit(); /* This step simulates the working buffer being */ /* loaded in the background. */ /* UTF_put_text("\n>>Loading new data.\n"); */ /* Status = CFE_TBL_LoadWorkingBuffer(TT_AppData.TblHandle, CFE_TBL_SRC_FILE, "/tt_table_values1.dat"); */ /* UTF_put_text("CFE_TBL_LoadWorkingBuffer returned %lx\n", Status);*/ /* ** Main process loop (forever)... */ while (TRUE) { /* ** Wait for the next Software Bus message... */ Status = CFE_SB_RcvMsg(&TT4_AppData.MsgPtr, TT4_AppData.CmdPipe, 4); if (Status == CFE_SUCCESS) { /* ** Process Software Bus message... */ TT_AppPipe(TT4_AppData.MsgPtr); } /* Access the latest Table Values */ TT_AccessCurrentData(); } } /* End of TT_AppMain() */
/****************************************************************************** ** Function: UTF_CFE_Init ** Purpose: ** Perform all standard initializations for the UTF. */ int32 UTF_CFE_Init(void) { /* Call CFE_ES_RegisterApp before CFE_TBL_EarlyInit to prevent warning */ /* messages. CFE_ES_RegisterApp can be called again later in application */ /* and causes no problem in the UTF environment. */ CFE_ES_RegisterApp(); /* Initialize data structure which will be used by Table Services. */ CFE_TBL_EarlyInit (); /* Initialize data structure which will be used by Executive Services. */ UTF_ES_InitAppRecords(); return CFE_SUCCESS; }
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **/ 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 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 */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 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) { /* ** 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() */
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() */
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; }
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ 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 */
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; }