/*
* Application entry point.
*/
int main(void) {
uint32 blinker_id;
/* HAL initialization, this also initializes the configured device drivers
and performs the board-specific initializations.*/
halInit();
/* OS initialization.*/
(void) OS_API_Init();
/* Activates the serial driver 2 using the driver default configuration.
PA2(TX) and PA3(RX) are routed to USART2.*/
sdStart(&SD2, NULL);
palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7));
palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7));
/* Starting the blinker thread.*/
(void) OS_TaskCreate(&blinker_id, "blinker", blinker,
(uint32 *)wa_blinker, sizeof wa_blinker,
128, 0);
/* In the ChibiOS/RT OSAL implementation the main() function is an
usable thread with priority 128 (NORMALPRIO), here we just sleep
in a loop printing a message on the serial port.*/
while (true) {
sdWrite(&SD2, (uint8_t *)"Hello World!\r\n", 14);
OS_TaskDelay(500);
}
}
/*
* Application entry point.
*/
int main(void) {
uint32 blinker_id;
/* HAL initialization, this also initializes the configured device drivers
and performs the board-specific initializations.*/
halInit();
/* OS initialization.*/
(void) OS_API_Init();
/* Activates the serial driver 1 using the driver default configuration.*/
sdStart(&SD1, NULL);
/* ARD_D13 is programmed as output (board LED).*/
palClearLine(LINE_ARD_D13);
palSetLineMode(LINE_ARD_D13, PAL_MODE_OUTPUT_PUSHPULL);
/* Starting the blinker thread.*/
(void) OS_TaskCreate(&blinker_id, "blinker", blinker,
(uint32 *)wa_blinker, sizeof wa_blinker,
128, 0);
/* In the ChibiOS/RT OSAL implementation the main() function is an
usable thread with priority 128 (NORMALPRIO), here we just sleep
waiting for a button event, then the test suite is executed.*/
while (true) {
if (palReadLine(LINE_BUTTON_USER))
test_execute((BaseSequentialStream *)&SD1, &nasa_osal_test_suite);
OS_TaskDelay(500);
}
}
void OS_BSPMain( void )
{
int TicksPerSecond;
/*
** Initialize the OS API
*/
OS_API_Init();
/*
** Delay for one second.
*/
TicksPerSecond = sysClkRateGet();
(void) taskDelay( TicksPerSecond );
OS_printf("Starting Up OSAPI App.\n");
/*
** Call OSAL entry point.
*/
OS_Application_Startup();
/*
** Exit the main thread.
** in VxWorks we can delete all of the OS tasks if we want.
*/
}
SYS_DRV_ErrorCode_t Pvware_DRV_Init( void )
{
int iRet = 0;
if( 1 == g_DrivesInitFlag )
{
return SYS_DRV_NO_ERROR;
}
OS_API_Init();
#if 0
iRet = DRV_I2C_Open();
if( 0 != iRet )
{
pbierror("%s DRV_I2C_Open error!\n", __FUNCTION__ );
}
#endif
ConfigInit();
iRet = DRV_Tuner_Init();
if( 0 != iRet )
{
pbierror("%s DRV_Tuner_Init error!\n", __FUNCTION__ );
}
/* The DRV_AV_Init before SFILTER_Init */
iRet = SFILTER_Init();
if( 0 != iRet )
{
pbierror("%s SFILTER_Init error!\n", __FUNCTION__ );
}
iRet = DRV_AV_Init();
if( 0 != iRet )
{
PBIDEBUG("DRV_AV_Init error!");
}
/* PVR INIT */
iRet = SFILTER_PVR_Init();
if( 0 != iRet )
{
pbierror("%s SFILTER_PVR_Init error!\n", __FUNCTION__ );
}
iRet = DRV_PVR_Init();
if( 0 != iRet )
{
pbierror("%s DRV_PVR_Init error!\n", __FUNCTION__ );
}
//CtrlTunerLockLed(1);
//CtrlTunerLockLed(1);
//CtrlTunerLockLed(1);
g_DrivesInitFlag = 1;
return SYS_DRV_NO_ERROR;
}
void OS_Application_Startup(void)
{
uint32 status;
OS_API_Init();
OS_printf("OS Application Startup\n");
status = OS_QueueCreate( &msgq_id, "MsgQ", MSGQ_DEPTH, MSGQ_SIZE, 0);
if ( status != OS_SUCCESS )
{
OS_printf("Error creating Message Queue\n");
}
/*
** 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)timer_id);
OS_printf("Timer Accuracy = %d microseconds \n",(int)timer_accuracy);
}
/*
** 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");
}
}
void Test_OS_API_Init_QueueTableSem_Error(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
OsApi_SetReturnCode(OSAPI_SEMMCREATE_INDEX, 0, 2);
/* Execute Test */
actual = OS_API_Init();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERROR");
}
void Test_OS_API_Init_TimerApiInit_Error(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
OsApi_SetReturnCode(OSAPI_OSTIMERAPIINIT_INDEX, OS_ERROR, 1);
/* Execute Test */
actual = OS_API_Init();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERROR");
}
void Test_OS_API_Init_TaskSpawn_Error(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
OsApi_SetReturnCode(OSAPI_TASKSPAWN_INDEX, VCS_ERROR, 1);
/* Execute Test */
actual = OS_API_Init();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERROR");
}
void Test_OS_API_Init_MsgQCreate_Error(void)
{
int32 expected = OS_ERROR;
int32 actual = 99;
/* Setup Inputs */
OsApi_SetReturnCode(OSAPI_MSGQCREATE_INDEX, 0, 1);
/* Execute Test */
actual = OS_API_Init();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_ERROR");
UtAssert_True(getNTaskDeleteForce() == 1, "taskDeleteForce called");
}
int main(int argc, char* argv[])
#endif
{
UT_os_setup(UT_OS_LOG_FILENAME);
/* UT_OS_LOG_OFF, UT_OS_LOG_MINIMAL, UT_OS_LOG_MODERATE, UT_OS_LOG_EVERYTHING */
UT_os_set_log_verbose(UT_OS_LOG_EVERYTHING);
UT_OS_LOG_MACRO("OSAL Unit Test Output File for osnetwork APIs\n");
OS_API_Init();
UT_os_networkgetid_test();
UT_os_networkgethostname_test();
UT_os_teardown("ut_osnetwork");
return (g_logInfo.nFailed);
}
/******************************************************************************
* FUNCTION NAME:
* None
* DESCRIPTION:
* None
* INPUT:
* None
* OUTPUT:
* None
* RETURN:
* None
* NOTES:
* None
* HISTORY:
* Ver1.00 2007.02.14 Panda Xiong Create
******************************************************************************/
static CLI_REG_CMD_RETURN_T cmd_os_osDebug
(
IN const GT_UI32 n_param,
IN const GT_UI8 *param[]
)
{
GT_UI32 current_param = 1;
if (n_param < 2)
{
UTL_PRT_Printf("\n\rMissing parameter!");
return CLI_PRT_FAIL;
}
if (strcmp(param[current_param], (GT_UI8 *)"start") == 0)
{
GT_UI32 task_1_arg = 1;
GT_UI32 task_2_arg = 2;
UTL_PRT_Printf("\n\r OS_API_Init ...");
OS_API_Init();
UTL_PRT_Printf("\n\r OS_TASK_API_Create Task_1 ...");
OS_TASK_API_Create((GT_UI8 *)"Task_1", task_1, &task_1_arg, KB(1), 6, GT_TRUE);
UTL_PRT_Printf("\n\r OS_TASK_API_Create Task_2 ...");
OS_TASK_API_Create((GT_UI8 *)"Task_2", task_2, &task_2_arg, KB(1), 5, GT_TRUE);
UTL_PRT_Printf("\n\r OS_API_Start ...");
OS_API_Start();
/* never reach here */
UTL_PRT_Printf("\n\rOS Start OK ...");
return CLI_PRT_SUCCESS;
}
else
{
UTL_PRT_Printf("\n\rUnknown parameter!");
return CLI_PRT_FAIL;
}
}
void Test_OS_API_Init_Success(void)
{
int32 expected = OS_SUCCESS;
int32 actual = 99;
uint32 ii = 0;
/* Setup Inputs */
/* Execute Test */
actual = OS_API_Init();
/* Verify Outputs */
UtAssert_True(actual == expected, "actual == OS_SUCCESS");
UtAssert_True(getNTaskDeleteForce() == 0, "taskDeleteForce not called");
for (ii = 0; ii < OS_MAX_TASKS; ++ii)
{
UtAssert_True(OsApi_Adaptor_getTaskTableEntry(ii)->free == TRUE,
"OS_task_table entry is free");
}
for (ii = 0; ii < OS_MAX_QUEUES; ++ii)
{
UtAssert_True(OsApi_Adaptor_getQueueTableEntry(ii)->free == TRUE,
"OS_queue_table entry is free");
}
for (ii = 0; ii < OS_MAX_BIN_SEMAPHORES; ++ii)
{
UtAssert_True(OsApi_Adaptor_getBinSemTableEntry(ii)->free == TRUE,
"OS_bin_sem_table entry is free");
}
for (ii = 0; ii < OS_MAX_COUNT_SEMAPHORES; ++ii)
{
UtAssert_True(OsApi_Adaptor_getCountSemTableEntry(ii)->free == TRUE,
"OS_count_sem_table entry is free");
}
for (ii = 0; ii < OS_MAX_MUTEXES; ++ii)
{
UtAssert_True(OsApi_Adaptor_getMutSemTableEntry(ii)->free == TRUE,
"OS_mut_sem_table_entry is free");
}
}
int main(void)
{
/*
** Initialize the OS API data structures
*/
OS_API_Init();
/*
** Call application specific entry point.
*/
OS_Application_Startup();
/*
** Let the main thread sleep
*/
for ( ;; )
{
sleep(1);
}
return(0);
}
int main(void)
{
int mode;
int status;
/*
** Create local directories for "disk" mount points
** See bsp_voltab for the values
*/
printf("Making directories: ram0, ram1, eeprom1 for OSAL mount points\n");
mode = S_IFDIR |S_IRWXU | S_IRWXG | S_IRWXO;
status = mkdir("ram0", mode);
status = mkdir("ram1", mode);
status = mkdir("eeprom1", mode);
/*
** Initialize the OS API data structures
*/
OS_API_Init();
/*
** Call application specific entry point.
*/
OS_Application_Startup();
/*
** Let the main thread sleep
*/
for ( ;; )
{
sleep(1);
}
return(0);
}
/******************************************************************************
** Function: main()
**
** Purpose:
** BSP Application entry point.
**
** Arguments:
** (none)
**
** Return:
** (none)
*/
int main(int argc, char *argv[])
{
uint32 reset_type;
uint32 reset_subtype;
struct sigaction sa;
struct itimerval timer;
int opt = 0;
int longIndex = 0;
sigset_t mask;
pthread_t thread_id;
struct sched_param thread_params;
int ret;
#ifdef CFE_PSP_EEPROM_SUPPORT
int32 Status;
uint32 eeprom_address;
uint32 eeprom_size;
#endif
/*
** Initialize the CommandData struct
*/
memset(&(CommandData), 0, sizeof(CFE_PSP_CommandData_t));
/*
** Process the arguments with getopt_long(), then
** start the cFE
*/
opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
while( opt != -1 )
{
switch( opt )
{
case 'R':
strncpy(CommandData.ResetType, optarg, CFE_PSP_RESET_NAME_LENGTH);
if ((strncmp(CommandData.ResetType, "PO", CFE_PSP_RESET_NAME_LENGTH ) != 0 ) &&
(strncmp(CommandData.ResetType, "PR", CFE_PSP_RESET_NAME_LENGTH ) != 0 ))
{
printf("\nERROR: Invalid Reset Type: %s\n\n",CommandData.ResetType);
CommandData.GotResetType = 0;
CFE_PSP_DisplayUsage(argv[0]);
break;
}
printf("CFE_PSP: Reset Type: %s\n",(char *)optarg);
CommandData.GotResetType = 1;
break;
case 'S':
CommandData.SubType = strtol(optarg, NULL, 0 );
if ( CommandData.SubType < 1 || CommandData.SubType > 5 )
{
printf("\nERROR: Invalid Reset SubType: %s\n\n",optarg);
CommandData.SubType = 0;
CommandData.GotSubType = 0;
CFE_PSP_DisplayUsage(argv[0]);
break;
}
printf("CFE_PSP: Reset SubType: %d\n",(int)CommandData.SubType);
CommandData.GotSubType = 1;
break;
case 'N':
strncpy(CommandData.CpuName, optarg, CFE_PSP_CPU_NAME_LENGTH );
printf("CFE_PSP: CPU Name: %s\n",CommandData.CpuName);
CommandData.GotCpuName = 1;
break;
case 'C':
CommandData.CpuId = strtol(optarg, NULL, 0 );
printf("CFE_PSP: CPU ID: %d\n",(int)CommandData.CpuId);
CommandData.GotCpuId = 1;
break;
case 'I':
CommandData.SpacecraftId = strtol(optarg, NULL, 0 );
printf("CFE_PSP: Spacecraft ID: %d\n",(int)CommandData.SpacecraftId);
CommandData.GotSpacecraftId = 1;
break;
case 'h':
CFE_PSP_DisplayUsage(argv[0]);
break;
default:
CFE_PSP_DisplayUsage(argv[0]);
break;
}
opt = getopt_long( argc, argv, optString, longOpts, &longIndex );
} /* end while */
/*
** Set the defaults for values that were not given for the
** optional arguments, and check for arguments that are required.
*/
CFE_PSP_ProcessArgumentDefaults(&CommandData);
/*
** Set the reset type
*/
if (strncmp("PR", CommandData.ResetType, 2 ) == 0 )
{
reset_type = CFE_ES_PROCESSOR_RESET;
OS_printf("CFE_PSP: Starting the cFE with a PROCESSOR reset.\n");
}
else
{
reset_type = CFE_ES_POWERON_RESET;
OS_printf("CFE_PSP: Starting the cFE with a POWER ON reset.\n");
}
/*
** Assign the Spacecraft ID, CPU ID, and CPU Name
*/
CFE_PSP_SpacecraftId = CommandData.SpacecraftId;
CFE_PSP_CpuId = CommandData.CpuId;
strncpy(CFE_PSP_CpuName, CommandData.CpuName, CFE_PSP_CPU_NAME_LENGTH);
/*
** Set the reset subtype
*/
reset_subtype = CommandData.SubType;
/*
** Install sigint_handler as the signal handler for SIGINT.
*/
signal(SIGINT, CFE_PSP_SigintHandler);
/*
** Init timer counter
*/
TimerCounter = 0;
/*
** Install timer_handler as the signal handler for SIGVTALRM.
*/
memset (&sa, 0, sizeof (sa));
sa.sa_handler = &CFE_PSP_TimerHandler;
sigaction (SIGALRM, &sa, NULL);
/*
** Configure the timer to expire after 250ms
*/
timer.it_value.tv_sec = 0;
timer.it_value.tv_usec = 250000;
/*
** and every 500ms after that.
*/
timer.it_interval.tv_sec = 0;
timer.it_interval.tv_usec = 250000;
/*
** Initialize the OS API data structures
*/
OS_API_Init();
sleep(1);
/*
** Initialize the reserved memory
*/
CFE_PSP_InitProcessorReservedMemory(reset_type);
/*
** Start the timer
*/
setitimer (ITIMER_REAL, &timer, NULL);
#ifdef CFE_PSP_EEPROM_SUPPORT
/*
** Create the simulated EEPROM segment by mapping a memory segment to a file.
** Since the file will be saved, the "EEPROM" contents will be preserved.
** Set up 512Kbytes of EEPROM
*/
eeprom_size = 0x80000;
Status = CFE_PSP_SetupEEPROM(eeprom_size, &eeprom_address);
if ( Status == 0 )
{
uint32 Dword;
/*
** Install the 2nd memory range as the mapped file ( EEPROM )
*/
Status = CFE_PSP_MemRangeSet (1, CFE_PSP_MEM_EEPROM, eeprom_address,
eeprom_size, CFE_PSP_MEM_SIZE_DWORD, 0 );
OS_printf("CFE_PSP: EEPROM Range (2) created: Start Address = %08X, Size = %08X\n", eeprom_address, eeprom_size);
}
else
{
OS_printf("CFE_PSP: Cannot create EEPROM Range from Memory Mapped file.\n");
}
#endif
/*
** Disable Signals to parent thread and therefore all
** child threads create will block all signals
** Note: Timers will not work in the application unless
** threads are spawned in OS_Application_Startup.
*/
sigfillset(&mask);
sigdelset(&mask, SIGINT); /* Needed to kill program */
sigprocmask(SIG_SETMASK, &mask, NULL);
/*
** Raise the priority of the main thread so ES Main completes
*/
thread_id = pthread_self();
thread_params.sched_priority = sched_get_priority_max(SCHED_FIFO);
ret = pthread_setschedparam(thread_id, SCHED_FIFO, &thread_params);
if ( ret != 0 )
{
OS_printf("Unable to set main thread priority to max\n");
}
/*
** Call cFE entry point.
*/
CFE_ES_Main(reset_type, reset_subtype, 1, (uint8 *)CFE_ES_NONVOL_STARTUP_FILE);
/*
** Re-enable Signals to current thread so that
** any signals will interrupt in this threads context
** ... this is needed for timers
*/
sigprocmask(SIG_UNBLOCK, &mask, NULL);
/*
** Lower the thread priority to before entering the sleep loop
*/
thread_params.sched_priority = sched_get_priority_min(SCHED_FIFO);
ret = pthread_setschedparam(thread_id, SCHED_FIFO, &thread_params);
if ( ret != 0 )
{
OS_printf("Unable to set main thread priority to minimum\n");
}
/*
** Let the main thread sleep
*/
for ( ;; )
{
/*
** Even though this sleep call is for 1 second,
** the sigalarm timer for the 1hz will keep waking
** it up. Keep that in mind when setting the timer down
** to something very small.
*/
sleep(1);
}
return(0);
}
void CFE_PSP_Main( int ModeId, char *StartupFilePath )
{
uint32 reset_type;
uint32 reset_subtype;
rtems_status_code RtemsStatus;
rtems_name RtemsTimerName;
/*
** Initialize the OS API
*/
OS_API_Init();
/*
** Create an interval timer for the 1hz
*/
RtemsTimerName = rtems_build_name('1',' ','H','Z');
RtemsStatus = rtems_timer_create(RtemsTimerName, &RtemsTimerId);
if ( RtemsStatus != RTEMS_SUCCESSFUL )
{
printf("CFE_PSP: Error: Cannot create RTEMS 1hz interval timer\n");
}
/*
** Allocate memory for the cFE memory. Note that this is malloced on
** the COTS board, but will be a static location in the ETU.
*/
printf("Sizeof BSP reserved memory = %d bytes\n",sizeof(CFE_PSP_ReservedMemory_t));
CFE_PSP_ReservedMemoryPtr = malloc(sizeof(CFE_PSP_ReservedMemory_t));
if ( CFE_PSP_ReservedMemoryPtr == NULL )
{
printf("CFE_PSP: Error: Cannot malloc BSP reserved memory!\n");
}
else
{
printf("CFE_PSP: Allocated %d bytes for PSP reserved memory at: 0x%08X\n",
sizeof(CFE_PSP_ReservedMemory_t), (int)CFE_PSP_ReservedMemoryPtr);
}
/*
** Determine Reset type by reading the hardware reset register.
*/
reset_type = CFE_ES_POWERON_RESET;
reset_subtype = CFE_ES_POWER_CYCLE;
/*
** Initialize the reserved memory
*/
CFE_PSP_InitProcessorReservedMemory(reset_type);
/*
** Call cFE entry point. This will return when cFE startup
** is complete.
*/
CFE_ES_Main(reset_type,reset_subtype, 1, (uint8 *)StartupFilePath);
/*
** Setup the timer to fire at 1hz
*/
/* CLOCK TICK */
RtemsStatus = rtems_timer_fire_after(RtemsTimerId, 100, CFE_PSP_1hzTimer, NULL );
if ( RtemsStatus != RTEMS_SUCCESSFUL )
{
printf("CFE_PSP: Error: Cannot setup interval timer to fire at 1hz\n");
}
/*
** Return to the shell/monitor
*/
return;
}
/*
** 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");
}
/******************************************************************************
** Function: CFE_PSP_Start()
**
** Purpose:
** Initialize the PSP and start cFE
**
** Arguments:
** ModeId - Used to indicate which bank of non-volatile memory
** was used to boot. If the bank used to boot this time
** is different from the previous boot, then we re-initialize
** reserved memory.
** StartupFilePath - path to cFE startup file to use
**
** Return:
** (none)
*/
void CFE_PSP_Start( int ModeId, char *StartupFilePath )
{
uint32 reset_type = 0;
uint32 reset_subtype = 0;
uint32 status = 0;
/*
** Initialize the hardware timer for the local time source
** On VxWorks, the default config sets the sysClk to 200 Hz (default 60Hz)
** OS_API_Init() calls OS_TimerAPIInit() which gets the
** clock resolution of the realtime clock, which is based on the sysClk
** and determines the clock accuracy which is used by the scheduler
** timers later. sysClk needs to be at least 200Hz for a 100Hz minor
** frame rate.
*/
CFE_PSP_InitLocalTime();
/*
** Initialize the OS API data structures
*/
status = OS_API_Init();
if(status != OS_SUCCESS)
{
printf("CFE_PSP_Start() - OS_API_Init() fail, RC = 0x%x\n", status);
}
/*
** Setup the pointer to the reserved area in vxWorks.
** This must be done before any of the reset variables are used.
*/
CFE_PSP_ReservedMemoryPtr = (CFE_PSP_ReservedMemory_t *) sysMemTop();
printf("CFE_PSP_Main: Reserved Memory Address %08X\n", (uint32)CFE_PSP_ReservedMemoryPtr);
/* PSP System Initialization */
CFE_PSP_SysInit(&reset_type, &reset_subtype, CFE_PSP_ReservedMemoryPtr->bsp_reset_type);
/*
** Initialize the watchdog, it's left disabled
*/
CFE_PSP_WatchdogInit();
/*
** Initialize the reserved memory
*/
CFE_PSP_InitProcessorReservedMemory(reset_type);
/*
* Adjust system task priorities so that tasks such as the shell are
* at a lower priority that the CFS apps
*/
SetSysTasksPrio();
/*
** Call cFE entry point. This will return when cFE startup
** is complete.
*/
CFE_ES_Main(reset_type, reset_subtype, ModeId, StartupFilePath);
/*
* Initializing the 1Hz timer connects the cFE 1Hz ISR for providing the
* CFS 1Hz time sync, sync the scheduler's 1Hz major frame start to the
* 1Hz timer. This call can only occur after CFE_ES_Main() because the
* 1Hz ISR uses a semaphore that is created when timer services are
* initialized.
*/
CFE_PSP_Init1HzTimer();
CFE_TIME_SetState(CFE_TIME_VALID);
/*
** Enable the watchdog
*/
/* CFE_PSP_WatchdogEnable(); really should be enabled in HS */
printf("CFE_PSP_Start done, exiting.\n");
return;
} /* End CFE_PSP_Main */
