static void test_004_001_execute(void) { /* [4.1.1] OS_BinSemCreate() is invoked with sem_id set to NULL, an error is expected.*/ test_set_step(1); { int32 err; err = OS_BinSemCreate(NULL, /* Error.*/ "failing semaphore", 0, 0); test_assert(err == OS_INVALID_POINTER, "NULL not detected"); } /* [4.1.2] OS_BinSemCreate() is invoked with sem_name set to NULL, an error is expected.*/ test_set_step(2); { int32 err; err = OS_BinSemCreate(&bsid, NULL, /* Error.*/ 0, 0); test_assert(err == OS_INVALID_POINTER, "NULL not detected"); } /* [4.1.3] OS_BinSemCreate() is invoked with an invalid sem_initial_value, an error is expected.*/ test_set_step(3); { int32 err; err = OS_BinSemCreate(&bsid, "failing semaphore", 2, /* Error.*/ 0); test_assert(err == OS_INVALID_INT_NUM, "counter error not detected"); } /* [4.1.4] OS_BinSemCreate() is invoked with a very long timer name, an error is expected.*/ test_set_step(4); { #if 0 /* Semaphore name currently not implemented.*/ int32 err; err = OS_BinSemCreate(&bsid, "very very long semaphore name", /* Error.*/ 0, 0); test_assert(err == OS_ERR_NAME_TOO_LONG, "name limit not detected"); #endif } /* [4.1.5] OS_BinSemDelete() is invoked with timer_id set to -1, an error is expected.*/ test_set_step(5); { int32 err; err = OS_BinSemDelete((uint32)-1); test_assert(err == OS_ERR_INVALID_ID, "wrong semaphore id not detected"); } /* [4.1.6] OS_BinSemCreate() is invoked twice with duplicated name, an error is expected, then the queue is deleted using OS_BinSemDelete().*/ test_set_step(6); { int32 err; uint32 bsid1; /*, bsid2;*/ err = OS_BinSemCreate(&bsid1, "my semaphore", 0, 0); test_assert(err == OS_SUCCESS, "semaphore creation failed"); #if 0 /* Semaphore name currently not implemented.*/ err = OS_BinSemCreate(&bsid2, "my semaphore", 0, 0); test_assert(err == OS_ERR_NAME_TAKEN, "name conflict not detected"); #endif err = OS_BinSemDelete(bsid1); test_assert(err == OS_SUCCESS, "semaphore deletion failed"); } }
static void test_004_007_setup(void) { bsid = 0; (void) OS_BinSemCreate(&bsid, "test semaphore", 0, 0); }
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() */
/* ** Main function */ void OS_Application_Startup(void) { uint32 status; OS_bin_sem_prop_t bin_sem_prop; OS_API_Init(); OS_printf("OS Application Startup\n"); /* ** Create the binary semaphore */ status = OS_BinSemCreate( &bin_sem_id, "BinSem1", 1, 0); if ( status != OS_SUCCESS ) { OS_printf("Error creating Binary Sem\n"); } else { status = OS_BinSemGetInfo (bin_sem_id, &bin_sem_prop); OS_printf("Binary Sem ID = %d, value = %d\n", (int)bin_sem_id, (int)bin_sem_prop.value); } /* ** Take the semaphore so the value is 0 and the next SemTake call should block */ status = OS_BinSemTake(bin_sem_id); if ( status != OS_SUCCESS ) { OS_printf("Error calling OS_BinSemTake with bin_sem_id = %d\n",(int)bin_sem_id); } else { status = OS_BinSemGetInfo (bin_sem_id, &bin_sem_prop); OS_printf("Initial Binary Sem Take: value = %d\n", (int)bin_sem_prop.value); } /* ** Create the tasks */ status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_STACK_SIZE, TASK_1_PRIORITY, 0); if ( status != OS_SUCCESS ) { OS_printf("Error creating Task 1\n"); } else { OS_printf("Created Task 1\n"); } status = OS_TaskCreate( &task_2_id, "Task 2", task_2, task_2_stack, TASK_STACK_SIZE, TASK_2_PRIORITY, 0); if ( status != OS_SUCCESS ) { OS_printf("Error creating Task 2\n"); } else { OS_printf("Created Task 2\n"); } status = OS_TaskCreate( &task_3_id, "Task 3", task_3, task_3_stack, TASK_STACK_SIZE, TASK_3_PRIORITY, 0); if ( status != OS_SUCCESS ) { OS_printf("Error creating Task 3\n"); } else { OS_printf("Created Task 3\n"); } /* ** Delay, then release the semaphore */ OS_TaskDelay(2000); status = OS_BinSemFlush(bin_sem_id); OS_printf("Main done!\n"); }
/* ** Name: CFE_ES_Main ** Purpose: This is the entry point to the cFE application code. ** */ void CFE_ES_Main(uint32 StartType, uint32 StartSubtype, uint32 ModeId, uint8 *StartFilePath ) { int i; int32 ReturnCode; /* ** Initialize the Reset variables. This call is required ** Before most of the ES functions can be used including the ** ES System log. */ CFE_ES_SetupResetVariables(StartType, StartSubtype, ModeId); /* ** Initialize the Logic Perf variables ** Because this is in the ES Reset area, it must be called after ** CFE_ES_SetupResetVariables. */ CFE_ES_SetupPerfVariables(StartType); /* ** Announce the startup */ CFE_ES_WriteToSysLog("ES Startup: CFE_ES_Main started\n"); /* ** Create and Mount the filesystems needed */ CFE_ES_InitializeFileSystems(StartType); /* ** Install exception Handlers ( Placeholder ) */ CFE_PSP_AttachExceptions(); /* ** Initialize the ES Application Table ** to mark all entries as unused. */ for ( i = 0; i < CFE_ES_MAX_APPLICATIONS; i++ ) { CFE_ES_Global.AppTable[i].RecordUsed = FALSE; } /* ** Initialize the ES Task Table ** to mark all entries as unused. */ for ( i = 0; i < OS_MAX_TASKS; i++ ) { CFE_ES_Global.TaskTable[i].RecordUsed = FALSE; } /* ** Initialize the ES Generic Counter Table ** to mark all entries as unused. */ for ( i = 0; i < CFE_ES_MAX_GEN_COUNTERS; i++ ) { CFE_ES_Global.CounterTable[i].RecordUsed = FALSE; } /* ** Create the ES Shared Data Mutex */ ReturnCode = OS_MutSemCreate(&(CFE_ES_Global.SharedDataMutex), "ES_DATA_MUTEX", 0 ); if(ReturnCode != OS_SUCCESS) { CFE_ES_WriteToSysLog("ES Startup: Error: ES Shared Data Mutex could not be created. RC=0x%08X\n", ReturnCode); /* ** Delay to allow the message to be read */ OS_TaskDelay(CFE_ES_PANIC_DELAY); /* ** cFE Cannot continue to start up. */ CFE_PSP_Panic(CFE_PSP_PANIC_STARTUP_SEM); } /* end if */ /* ** Create the ES Startup Sync Semaphore */ ReturnCode = OS_BinSemCreate(&(CFE_ES_Global.StartupSyncSemaphore),"ES_SYNC_SEM", 0, 0 ); if(ReturnCode != OS_SUCCESS) { CFE_ES_WriteToSysLog("ES Startup: Error: ES Startup Sync Semaphore could not be created. RC=0x%08X\n", ReturnCode); /* ** Delay to allow the message to be read */ OS_TaskDelay(CFE_ES_PANIC_DELAY); /* ** cFE Cannot continue to start up. */ CFE_PSP_Panic(CFE_PSP_PANIC_STARTUP_SEM); } /* end if */ /* ** Create the tasks, OS objects, and initialize hardware */ CFE_ES_CreateObjects(); /* ** Before the Applications are loaded, set up the state ** variables that allow the startup syncronization to work. ** This depends on a couple of things: ** 1. The fact that the cFE applications all use the CFE_ES_RunLoop Call ** 2. The StartupSyncSemaphore has been created ( see above ) ** 3. The App(s) that wish to wait calls CFE_ES_WaitForStartupSync */ CFE_ES_Global.AppStartupCounter = 0; CFE_ES_Global.StartupFileComplete = FALSE; CFE_ES_Global.StartupSemaphoreReleased = FALSE; /* ** Start the cFE Applications from the disk using the file ** specified in the CFE_ES_NONVOL_STARTUP_FILE or CFE_ES_VOLATILE_STARTUP_FILE ** ( defined in the cfe_platform_cfg.h file ) */ CFE_ES_StartApplications(StartType, StartFilePath ); /* ** Indicate that the startup file is complete. This avoids ** certain race conditions. */ CFE_ES_Global.StartupFileComplete = TRUE; /* ** Startup is complete */ CFE_ES_WriteToSysLog("ES Startup: CFE Core Startup Complete\n"); }
void OS_Application_Startup(void) { uint32 status; OS_bin_sem_prop_t bin_sem_prop; OS_printf("OS Application Startup\n"); /* ** Create the binary semaphore */ status = OS_BinSemCreate( &bin_sem_id, "BinSem1", 1, 0); if ( status != OS_SUCCESS ) { OS_printf("Error creating Binary Sem\n"); } else { status = OS_BinSemGetInfo (bin_sem_id, &bin_sem_prop); OS_printf("Binary Sem ID = %d, value = %d\n", (int)bin_sem_id, (int)bin_sem_prop.value); } /* ** Create a timer */ status = OS_TimerCreate(&timer_id, "Timer 1", &timer_accuracy, &(TimerFunction)); if ( status != OS_SUCCESS ) { OS_printf("Error creating OS Timer\n"); } else { OS_printf("Timer ID = %d\n", (int)bin_sem_id); OS_printf("Timer Accuracy = %d microseconds \n",(int)timer_accuracy); } /* ** Take the semaphore so the value is 0 and the next SemTake call should block */ status = OS_BinSemTake(bin_sem_id); if ( status != OS_SUCCESS ) { OS_printf("Error calling OS_BinSemTake with bin_sem_id = %d\n",(int)bin_sem_id); } else { status = OS_BinSemGetInfo (bin_sem_id, &bin_sem_prop); OS_printf("Initial Binary Sem Take: value = %d\n", (int)bin_sem_prop.value); } /* ** Create the "consumer" task. */ status = OS_TaskCreate( &task_1_id, "Task 1", task_1, task_1_stack, TASK_1_STACK_SIZE, TASK_1_PRIORITY, 0); if ( status != OS_SUCCESS ) { OS_printf("Error creating Task 1\n"); } else { OS_printf("Created Task 1\n"); } /* ** Start the timer */ status = OS_TimerSet(timer_id, timer_start, timer_interval); if ( status != OS_SUCCESS ) { OS_printf("Error calling OS_TimerSet: ID = %d\n", (int)timer_id); } else { OS_printf("Timer programmed\n"); } }