/** * @brief main routine for uC/OS-III blinky example * @return Function should not exit. */ int main(void) { OS_ERR os_err; prvSetupHardware(); CPU_Init(); OSInit(&os_err); OSTaskCreate( (OS_TCB *) &vLEDTask1TCB, (CPU_CHAR *) "vLEDTask1", (OS_TASK_PTR) vLEDTask1, (void *) 0, (OS_PRIO) APP_CFG_TASK_START_PRIO, (CPU_STK *) vLEDTask1Stk, (CPU_STK_SIZE) APP_CFG_TASK_START_STK_SIZE_LIMIT, (CPU_STK_SIZE) APP_CFG_TASK_START_STK_SIZE, (OS_MSG_QTY) 0u, (OS_TICK) 0u, (void *) 0, (OS_OPT) (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *) &os_err); OSStart(&os_err); (void) &os_err; return 0; }
static void AppTaskStart (void *p_arg) { (void)p_arg; BSP_Init(); /* Initialize BSP functions */ CPU_Init(); /* Initialize the uC/CPU services */ BSP_Tick_Init(); /* Start Tick Initialization */ Mem_Init(); /* Initialize memory managment module */ Math_Init(); /* Initialize mathematical module */ #if (OS_TASK_STAT_EN > 0) OSStatInit(); /* Determine CPU capacity */ #endif BSP_LED_Off(0); #if (APP_CFG_SERIAL_EN == DEF_ENABLED) App_SerialInit(); /* Initialize Serial communication for application ... */ #endif APP_TRACE_INFO(("Creating Application Events...\n\r")); AppEventCreate(); /* Create Application Events */ APP_TRACE_INFO(("Creating Application Tasks...\n\r")); AppTaskCreate(); /* Create application tasks */ while (DEF_TRUE) { /* Task body, always written as an infinite loop. */ BSP_LED_Toggle(0); OSTimeDlyHMSM(0, 0, 0, 100); } }
static void spc_emu_thread(void) { CPU_Init(&spc_emu); while (1) { /* get a buffer for output */ struct sample_queue_chunk *chunk = samples_get_wrbuf(); if (chunk->id != SPC_EMU_AUDIO) { /* This chunk doesn't contain audio but a command */ if (!emu_thread_process_msg(chunk)) break; /* Have to re-get this pointer to keep semaphore counts correct */ continue; } ENTER_TIMER(render); /* fill samples buffer */ if ( SPC_play(&spc_emu, WAV_CHUNK_SIZE*2, chunk->audio) ) assert( false ); EXIT_TIMER(render); /* done so release it to output */ samples_release_wrbuf(); ci->yield(); } }
int main(void) { OS_ERR err; BSP_IntDisAll(); /* Disable all interrupts. */ CPU_Init(); /* Initialize the uC/CPU Services */ Mem_Init(); /* Initialize Memory Management Module */ Math_Init(); /* Initialize Mathematical Module */ OSInit(&err); /* Init uC/OS-III. */ OSTaskCreate((OS_TCB *)&AppTaskStartTCB, /* Create the start task */ (CPU_CHAR *)"App Task Start", (OS_TASK_PTR )AppTaskStart, (void *)0u, (OS_PRIO )APP_CFG_TASK_START_PRIO, (CPU_STK *)&AppTaskStartStk[0u], (CPU_STK_SIZE )AppTaskStartStk[APP_CFG_TASK_START_STK_SIZE / 10u], (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE, (OS_MSG_QTY )0u, (OS_TICK )0u, (void *)0u, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err); OSStart(&err); /* Start multitasking (i.e. give control to uC/OS-III). */ (void)&err; return (0u); }
bool PSP_InitStart(const CoreParameter &coreParam, std::string *error_string) { if (pspIsIniting) { return false; } #if defined(_WIN32) && defined(_M_X64) INFO_LOG(BOOT, "PPSSPP %s Windows 64 bit", PPSSPP_GIT_VERSION); #elif defined(_WIN32) && !defined(_M_X64) INFO_LOG(BOOT, "PPSSPP %s Windows 32 bit", PPSSPP_GIT_VERSION); #else INFO_LOG(BOOT, "PPSSPP %s", PPSSPP_GIT_VERSION); #endif coreParameter = coreParam; coreParameter.errorString = ""; pspIsIniting = true; if (g_Config.bSeparateCPUThread) { Core_ListenShutdown(System_Wake); CPU_SetState(CPU_THREAD_PENDING); cpuThread = new std::thread(&CPU_RunLoop); cpuThread->detach(); } else { CPU_Init(); } *error_string = coreParameter.errorString; return coreParameter.fileToStart != ""; }
void KernelMain(void) { OS_ERR err; //CPU Init : CPU_Init(); //OS Init : // 1.Idle // 2.Tick // 3.Statistic // 4.Timer Manager // 5.debug // // 6.parameter init OSInit( (OS_ERR *)&err); OSTaskCreate( (OS_TCB *)&taskStartTCB, (CPU_CHAR *)"Task Start", (OS_TASK_PTR)TaskStart, (void *)0, (OS_PRIO ) STARTUP_TASK_PRIO, (CPU_STK *)&taskStartStk[0], (CPU_STK_SIZE)STARTUP_TASK_STK_SIZE / 10, (CPU_STK_SIZE)STARTUP_TASK_STK_SIZE, (OS_MSG_QTY )0, (OS_TICK )0, (void *)0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err); OSStart( (OS_ERR *)&err); }
bool PSP_Init(const CoreParameter &coreParam, std::string *error_string) { INFO_LOG(BOOT, "PPSSPP %s", PPSSPP_GIT_VERSION); coreParameter = coreParam; coreParameter.errorString = ""; if (g_Config.bSeparateCPUThread) { Core_ListenShutdown(System_Wake); CPU_SetState(CPU_THREAD_PENDING); cpuThread = new std::thread(&CPU_RunLoop); cpuThread->detach(); CPU_WaitStatus(cpuThreadReplyCond, &CPU_IsReady); } else { CPU_Init(); } bool success = coreParameter.fileToStart != ""; *error_string = coreParameter.errorString; if (success) { success = GPU_Init(); if (!success) { PSP_Shutdown(); *error_string = "Unable to initialize rendering engine."; } } return success; }
static void AppTaskStart (void *p_arg) { OS_ERR err; #if (APP_CFG_TCPIP_MODULE_EN > 0u) NET_ERR net_err; #endif (void)&p_arg; BSP_Init(); /* Initialize BSP functions */ CPU_Init(); /* Initialize the uC/CPU services */ OS_CPU_TickInit(); /* Init uC/OS periodic time src (SysTick). */ #if (OS_CFG_STAT_TASK_EN > 0u) OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */ #endif Mem_Init(); /* Initialize mem mgmt module, required for TCP-IP. */ #if (APP_CFG_PROBE_COM_MODULE_EN > 0u) AppProbe_Init(); /* Initialize uC/Probe modules */ #endif OSTaskCreate((OS_TCB *)&AppBlinkyTaskTCB, /* Create the start task */ (CPU_CHAR *)"Blinky Task", (OS_TASK_PTR ) AppBlinkyTask, (void *) 0, (OS_PRIO ) BLINKY_TASK_PRIO, (CPU_STK *)&AppBlinkyTaskStk[0], (CPU_STK_SIZE) BLINKY_TASK_STK_SIZE / 10u, (CPU_STK_SIZE) BLINKY_TASK_STK_SIZE, (OS_MSG_QTY ) 0u, (OS_TICK ) 0u, (void *) 0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err); BSP_GraphLCD_Init(); AppGraphLCD_Hdr(); #if (APP_CFG_TCPIP_MODULE_EN > 0u) AppTCPIP_Init(&net_err); /* Initialize uC/TCP-IP & associated applications. */ AppCloud_Init(0); #endif #ifdef CPU_CFG_INT_DIS_MEAS_EN CPU_IntDisMeasMaxCurReset(); #endif AppTCPIP_Cfg = DEF_TRUE; OSTaskDel(&AppTaskStartTCB, /* Delete task because its work is complete */ &err); while (DEF_ON) { ; /* Should not get here! */ } }
int main(int argc,char *argv[]) { CPU_Init(); TRCINIT(); SPI_init(); start(INITIALIZE); return 0; }
int main (void) { OS_ERR err; #if (CPU_CFG_NAME_EN == DEF_ENABLED) CPU_ERR cpu_err; #endif CPU_Init(); /* Initialize the CPU abstraction layer. */ Mem_Init(); /* Initialize the Memory Management Module. */ Math_Init(); /* Initialize the Mathematical Module. */ #if (CPU_CFG_NAME_EN == DEF_ENABLED) CPU_NameSet((CPU_CHAR *)"MKL46Z256VLL4", (CPU_ERR *)&cpu_err); #endif BSP_IntDisAll(); /* Disable all interrupts. */ #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u)) TRACE_INIT(); /* Initialize the µC/Trace recorder. */ TRACE_START(); /* Start recording. */ #endif OSInit(&err); /* Initialize "uC/OS-III, The Real-Time Kernel". */ OSMutexCreate((OS_MUTEX *)&AppMutex, (CPU_CHAR *)"My App. Mutex", (OS_ERR *)&err); OSQCreate ((OS_Q *)&AppQ, (CPU_CHAR *)"My App Queue", (OS_MSG_QTY )10, (OS_ERR *)&err); OSTaskCreate((OS_TCB *)&App_TaskStartTCB, /* Create the startup task. */ (CPU_CHAR *)"Startup Task", (OS_TASK_PTR ) App_TaskStart, (void *) 0, (OS_PRIO ) APP_CFG_TASK_START_PRIO, (CPU_STK *)&App_TaskStartStk[0], (CPU_STK )(APP_CFG_TASK_START_STK_SIZE / 10u), (CPU_STK_SIZE) APP_CFG_TASK_START_STK_SIZE, (OS_MSG_QTY ) 0, (OS_TICK ) 0, (void *) 0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err); OSStart(&err); /* Start multitasking (i.e. give control to uC/OS-III). */ while(DEF_ON) { /* Should Never Get Here */ }; }
//--------------------------------------------------------------------------------------------------- // Main //--------------------------------------------------------------------------------------------------- int main (void) { OS_ERR aErr; SCB_SHPR2=(3<<30); #if (CPU_CFG_NAME_EN == DEF_ENABLED) CPU_ERR aCpuErr; #endif // Initialize the CPU abstraction layer CPU_Init(); //Initialize the Memory Management Module Mem_Init(); // Initialize the Mathematical Module Math_Init(); #if (CPU_CFG_NAME_EN == DEF_ENABLED) CPU_NameSet((CPU_CHAR *)"MKL46Z256VLL4",(CPU_ERR *)&aCpuErr); #endif // Disable all interrupts BSP_IntDisAll(); #if (defined(TRACE_CFG_EN) && (TRACE_CFG_EN > 0u)) TRACE_INIT(); // Initialize the µC/Trace recorder TRACE_START(); // Start recording #endif // Initialize "uC/OS-III, The Real-Time Kernel" OSInit(&aErr); // Création de la tâche de démarrage OSTaskCreate((OS_TCB *)&sAppTaskStartTCB, (CPU_CHAR *)"Startup Task", (OS_TASK_PTR ) AppTaskStart, (void *) 0, (OS_PRIO ) kStartTaskPr, (CPU_STK *)&sAppTaskStartStk[0], (CPU_STK )(kStackSize / 10u), (CPU_STK_SIZE) kStackSize, (OS_MSG_QTY ) 0, (OS_TICK ) 0, (void *) 0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&aErr); // Démarrage du multitâche OSStart(&aErr); // On ne doit jamais se trouver ici... while(1); }
int main(void) { #if (OS_TASK_NAME_EN > 0) CPU_INT08U err; #endif SYS_UnlockReg(); BSP_Init(); /* Initialize BSP functions */ BSP_Set_PLL_Freq(CLK_XTL_12M, PLL_DEFAULT_HZ); /* Configure PLL */ BSP_Set_System_Clock(CLK_PLL, 0); /* Select HCLK source clock as PLL */ SYS_LockReg(); OSInit(); /* Initialize "uC/OS-II, The Real-Time Kernel" */ CPU_Init(); /* Initialize the uC/CPU services */ Mem_Init(); /* Initialize memory managment module */ Math_Init(); /* Initialize mathematical module */ #if (OS_TASK_STAT_EN > 0) OSStatInit(); /* Determine CPU capacity */ #endif OSTaskCreateExt((void (*)(void *)) AppTask_1, /* Create the test task */ (void *) 0, (OS_STK *)&StackOfTask_1[TASK_STACK_SIZE - 1], (INT8U ) TASK_1_PRIO, (INT16U ) TASK_1_PRIO, (OS_STK *)&StackOfTask_1[0], (INT32U ) TASK_STACK_SIZE, (void *) 0, (INT16U )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR)); OSTaskCreateExt((void (*)(void *)) AppTask_2, /* Create the start task */ (void *) 0, (OS_STK *)&StackOfTask_2[TASK_STACK_SIZE - 1], (INT8U ) TASK_2_PRIO, (INT16U ) TASK_2_PRIO, (OS_STK *)&StackOfTask_2[0], (INT32U ) TASK_STACK_SIZE, (void *) 0, (INT16U )(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR)); #if (OS_TASK_NAME_EN > 0) OSTaskNameSet(TASK_1_PRIO, "Task 1", &err); OSTaskNameSet(TASK_2_PRIO, "Task 2", &err); #endif OSStart(); /* Start multitasking (i.e. give control to uC/OS-II) */ return (1); }
void CPU_RunLoop() { setCurrentThreadName("CPU"); FPU_SetFastMode(); if (CPU_NextState(CPU_THREAD_PENDING, CPU_THREAD_STARTING)) { CPU_Init(); CPU_NextState(CPU_THREAD_STARTING, CPU_THREAD_RUNNING); } else if (!CPU_NextState(CPU_THREAD_RESUME, CPU_THREAD_RUNNING)) { ERROR_LOG(CPU, "CPU thread in unexpected state: %d", cpuThreadState); return; } while (cpuThreadState != CPU_THREAD_SHUTDOWN) { CPU_WaitStatus(cpuThreadCond, &CPU_HasPendingAction); switch (cpuThreadState) { case CPU_THREAD_EXECUTE: mipsr4k.RunLoopUntil(cpuThreadUntil); gpu->FinishEventLoop(); CPU_NextState(CPU_THREAD_EXECUTE, CPU_THREAD_RUNNING); break; // These are fine, just keep looping. case CPU_THREAD_RUNNING: case CPU_THREAD_SHUTDOWN: break; case CPU_THREAD_QUIT: // Just leave the thread, CPU is switching off thread. CPU_SetState(CPU_THREAD_NOT_RUNNING); return; default: ERROR_LOG(CPU, "CPU thread in unexpected state: %d", cpuThreadState); // Begin shutdown, otherwise we'd just spin on this bad state. CPU_SetState(CPU_THREAD_SHUTDOWN); break; } } if (coreState != CORE_ERROR) { coreState = CORE_POWERDOWN; } // Let's make sure the gpu has already cleaned up before we start freeing memory. if (gpu) { gpu->FinishEventLoop(); gpu->SyncThread(true); } CPU_Shutdown(); CPU_SetState(CPU_THREAD_NOT_RUNNING); }
/////////////////////////////////////////////////////////////////////////////////////////////////////////// //开始任务 void AppTaskStart (void *p_arg) { OS_ERR err; CPU_Init();//初始化cpu,禁用中断,开启时间戳等 BSP_Tick_Init();//设置滴答定时器 /*------------------------------*/ OSTaskCreate((OS_TCB *)&AppTaskTASK1TCB, (CPU_CHAR *)"task1", (OS_TASK_PTR )task1, (void *)0, (OS_PRIO )APP_CFG_TASK_TASK1_PRIO, (CPU_STK *)&AppTaskTASK1Stk[0], (CPU_STK_SIZE )APP_CFG_TASK_TASK1_STK_SIZE / 10, (CPU_STK_SIZE )APP_CFG_TASK_TASK1_STK_SIZE, (OS_MSG_QTY )0, (OS_TICK )0, (void *)0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err); /*------------------------------*/ OSTaskCreate((OS_TCB *)&AppTaskTASK2TCB, (CPU_CHAR *)"task2", (OS_TASK_PTR )task2, (void *)0, (OS_PRIO )APP_CFG_TASK_TASK2_PRIO, (CPU_STK *)&AppTaskTASK2Stk[0], (CPU_STK_SIZE )APP_CFG_TASK_TASK2_STK_SIZE / 10, (CPU_STK_SIZE )APP_CFG_TASK_TASK2_STK_SIZE, (OS_MSG_QTY )0, (OS_TICK )0, (void *)0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err); /*-------------------------------*/ OSTaskCreate((OS_TCB *)&AppTaskTASK3TCB, (CPU_CHAR *)"task3", (OS_TASK_PTR )task3, (void *)0, (OS_PRIO )APP_CFG_TASK_TASK3_PRIO, (CPU_STK *)&AppTaskTASK3Stk[0], (CPU_STK_SIZE )APP_CFG_TASK_TASK3_STK_SIZE / 10, (CPU_STK_SIZE )APP_CFG_TASK_TASK3_STK_SIZE, (OS_MSG_QTY )0, (OS_TICK )0, (void *)0, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err); //创建好其他任务后就删除自己 OSTaskDel((OS_TCB*)0,&err); }
static void AppTaskStart (void *p_arg) { OS_ERR os_err; (void)p_arg; CPU_Init(); /* Initialize the uC/CPU Services. */ Mem_Init(); /* Initialize the Memory Management Module */ Math_Init(); /* Initialize the Mathematical Module */ BSP_Ser_Init(115200u); OSTaskCreate(&TaskRedTCB, /* Create the red task */ "App Task Red", AppTaskRed, 0u, APP_CFG_TASK_START_PRIO, &TaskRedStk[0u], (APP_CFG_TASK_START_STK_SIZE / 10u), APP_CFG_TASK_START_STK_SIZE, 0u, 0u, 0u, (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_SAVE_FP), &os_err); OSTaskCreate(&TaskGreenTCB, /* Create the green task */ "App Task Green", AppTaskGreen, 0u, APP_CFG_TASK_START_PRIO, &TaskGreenStk[0u], (APP_CFG_TASK_START_STK_SIZE / 10u), APP_CFG_TASK_START_STK_SIZE, 0u, 0u, 0u, (OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR | OS_OPT_TASK_SAVE_FP), &os_err); while (DEF_TRUE) { /* Task body, always written as an infinite loop. */ } }
static void AppTaskStart (void *p_arg) { CPU_INT32U clk_freq; CPU_INT32U ulPHYMR0; CPU_INT32U cnts; OS_ERR err; (void)&p_arg; BSP_Init(); /* Initialize BSP functions */ CPU_Init(); /* Initialize the uC/CPU services */ SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH); /* Enable and Reset the Ethernet Controller. */ SysCtlPeripheralReset(SYSCTL_PERIPH_ETH); ulPHYMR0 = EthernetPHYRead(ETH_BASE, PHY_MR0); /* Power Down PHY */ EthernetPHYWrite(ETH_BASE, PHY_MR0, ulPHYMR0 | PHY_MR0_PWRDN); SysCtlPeripheralDeepSleepDisable(SYSCTL_PERIPH_ETH); clk_freq = BSP_CPUClkFreq(); /* Determine SysTick reference freq. */ cnts = clk_freq / (CPU_INT32U)OSCfg_TickRate_Hz; /* Determine nbr SysTick increments */ OS_CPU_SysTickInit(cnts); /* Init uC/OS periodic time src (SysTick). */ CPU_TS_TmrFreqSet(clk_freq); // #if(MICROSD_EN == 1) /* Mount the file system, using logical disk 0 */ //f_mount(0, &g_sFatFs); /* Create a new log.txt file */ //CmdLineProcess(g_cCmdBuf); // #endif /* Enable Wheel ISR Interrupt */ AppRobotMotorDriveSensorEnable(); /* Call your API here */ OSTaskCreateNew((OS_TCB *)&AppTaskOneTCB, (CPU_CHAR *)"App Task One", (OS_TASK_PTR ) AppTaskOne, (void *) 0, (OS_PRIO ) APP_TASK_ONE_PRIO, (CPU_STK *)&AppTaskOneStk[0], (CPU_STK_SIZE) APP_TASK_ONE_STK_SIZE / 10u, (CPU_STK_SIZE) APP_TASK_ONE_STK_SIZE, (OS_MSG_QTY ) 0u, (OS_TICK ) 0u, (void *)(CPU_INT32U) 1, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err, (OS_PERIOD) 5000); OSTaskCreateNew((OS_TCB *)&AppTaskTwoTCB, (CPU_CHAR *)"App Task Two", (OS_TASK_PTR ) AppTaskTwo, (void *) 0, (OS_PRIO ) APP_TASK_TWO_PRIO, (CPU_STK *)&AppTaskTwoStk[0], (CPU_STK_SIZE) APP_TASK_TWO_STK_SIZE / 10u, (CPU_STK_SIZE) APP_TASK_TWO_STK_SIZE, (OS_MSG_QTY ) 0u, (OS_TICK ) 0u, (void *) (CPU_INT32U) 2, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err,(OS_PERIOD) 7000); OSTaskCreateNew((OS_TCB *)&AppTaskThreeTCB, (CPU_CHAR *)"App Task Three", (OS_TASK_PTR ) AppTaskThree, (void *) 0, (OS_PRIO ) APP_TASK_THREE_PRIO, (CPU_STK *)&AppTaskThreeStk[0], (CPU_STK_SIZE) APP_TASK_THREE_STK_SIZE / 10u, (CPU_STK_SIZE) APP_TASK_THREE_STK_SIZE, (OS_MSG_QTY ) 0u, (OS_TICK ) 0u, (void *)(CPU_INT32U) 3, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err, (OS_PERIOD) 7000); OSTaskCreateNew((OS_TCB *)&AppTaskFourTCB, (CPU_CHAR *)"App Task Four", (OS_TASK_PTR ) AppTaskFour, (void *) 0, (OS_PRIO ) APP_TASK_FOUR_PRIO, (CPU_STK *)&AppTaskFourStk[0], (CPU_STK_SIZE) APP_TASK_FOUR_STK_SIZE / 10u, (CPU_STK_SIZE) APP_TASK_FOUR_STK_SIZE, (OS_MSG_QTY ) 0u, (OS_TICK ) 0u, (void *) (CPU_INT32U) 4, (OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR), (OS_ERR *)&err,(OS_PERIOD) 10000); OSTaskDel((OS_TCB *)0, &err); }
static void startup_task(void *p_arg) { BSP_Init(); //包含了中断向量的初始化 CPU_Init(); // //根据官方代码,时钟要在这里初始化 RCC_ClocksTypeDef rcc_clocks; RCC_GetClocksFreq(&rcc_clocks); SysTick_Config(rcc_clocks.HCLK_Frequency / OS_TICKS_PER_SEC); Mem_Init(); #if(OS_TASK_STAT_EN > 0) OSStatInit(); // Determine CPU capacity. #endif /*TODO:create application tasks here*/ OSTaskDel(OS_PRIO_SELF); }
int main () { OS_ERR os_err; BSP_Init(); CPU_Init(); OSInit(&os_err); if(os_err != OS_ERR_NONE) { APP_TRACE_INFO(("Error initialising OS. OsInit() returned with error %u\r\n", os_err)); } OSTaskCreate((OS_TCB *)&AppTaskStartTCB, (CPU_CHAR *)"App Task Start", (OS_TASK_PTR ) AppTaskStart, (void *) 0, (OS_PRIO ) 5, (CPU_STK *)&AppTaskStartStk[0], (CPU_STK )(4096u / 10u), (CPU_STK_SIZE) 4096u, (OS_MSG_QTY ) 0, (OS_TICK ) 0, (void *) 0, (OS_OPT )(OS_OPT_TASK_STK_CLR), (OS_ERR *)&os_err); if(os_err != OS_ERR_NONE) { APP_TRACE_INFO(("Error creating task. OSTaskCreate() returned with error %u\r\n", os_err)); } OSStart(&os_err); if(os_err != OS_ERR_NONE) { APP_TRACE_INFO(("Error starting. OSStart() returned with error %u\r\n", os_err)); } while (DEF_TRUE) { ; } }
static void AppTaskStart (void *p_arg) { CPU_INT32U clk_freq; CPU_INT32U cnts; OS_ERR err; (void)&p_arg; BSP_Init(); /* Initialize BSP functions */ CPU_Init(); /* Initialize the uC/CPU services */ clk_freq = BSP_CPU_ClkFreq(); /* Determine SysTick reference freq. */ cnts = clk_freq / (CPU_INT32U)OSCfg_TickRate_Hz; /* Determine nbr SysTick increments */ OS_CPU_SysTickInit(cnts); /* Init uC/OS periodic time src (SysTick). */ CPU_TS_TmrFreqSet(clk_freq); #if (OS_CFG_STAT_TASK_EN > 0u) OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */ #endif CPU_IntDisMeasMaxCurReset(); App_ProbeInit(); BSP_LED_On(1); BSP_LED_Off(2); AppDisplayTaskCreate(); while (DEF_ON) { /* Task body, always written as an infinite loop. */ OSTimeDlyHMSM(0u, 0u, 1u, 0u, OS_OPT_TIME_HMSM_STRICT, &err); BSP_LED_Toggle(0); /* Toggle both LEDs every second. */ bLED[0] ^= DEF_TRUE; bLED[1] ^= DEF_TRUE; } }
static void AppTaskStart (void *p_arg) { CPU_INT32U cpu_clk_freq; CPU_INT32U cnts; OS_ERR err; CPU_TS ts; (void)p_arg; OSSemCreate(&AppSem, "Test Sem", 0, &err); BSP_Init(); /* Initialize BSP functions */ CPU_Init(); /* Initialize the uC/CPU services */ cpu_clk_freq = BSP_CPU_ClkFreq(); /* Determine SysTick reference freq. */ cnts = cpu_clk_freq / (CPU_INT32U)OSCfg_TickRate_Hz; /* Determine nbr SysTick increments */ OS_CPU_SysTickInit(cnts); /* Init uC/OS periodic time src (SysTick). */ #if OS_CFG_STAT_TASK_EN > 0u OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */ #endif CPU_IntDisMeasMaxCurReset(); BSP_LED_Off(0); while (DEF_TRUE) { /* Task body, always written as an infinite loop. */ BSP_LED_Toggle(0); #if 0 OSTimeDlyHMSM(0, 0, 0, 100, OS_OPT_TIME_HMSM_STRICT, &err); #endif OSSemPend(&AppSem, 100, OS_OPT_PEND_BLOCKING, &ts, &err); } }
bool PSP_Init(const CoreParameter &coreParam, std::string *error_string) { INFO_LOG(HLE, "PPSSPP %s", PPSSPP_GIT_VERSION); coreParameter = coreParam; coreParameter.errorString = ""; if (g_Config.bSeparateCPUThread) { CPU_SetState(CPU_THREAD_PENDING); cpuThread = new std::thread(&CPU_RunLoop); CPU_WaitStatus(&CPU_IsReady); } else { CPU_Init(); } bool success = coreParameter.fileToStart != ""; *error_string = coreParameter.errorString; if (success) { GPU_Init(); } return success; }
static void AppTaskStart (void *p_arg) { OS_ERR err; CPU_ERR cpu_err; uint32_t value; static uint32_t pulse_flag = 0; CPU_TS64 before, after; char tmp[80]; (void)p_arg; CPU_Init(); Mem_Init(); Math_Init(); BSP_Ser_Init(115200u); while (DEF_ON) { GPIO_DRV_TogglePinOutput( outPTB23 ); value = GPIO_DRV_ReadPinInput( inPTB9 ); if( value ){ if(pulse_flag == 0) before = CPU_TS_Get64(); // in cpu_cfg.h must set: #define CPU_CFG_TS_64_EN DEF_ENABLED pulse_flag = 1; GPIO_DRV_ClearPinOutput( BOARD_GPIO_LED_BLUE ); } else{ GPIO_DRV_SetPinOutput( BOARD_GPIO_LED_BLUE ); if(pulse_flag == 1) { after = CPU_TS_Get64(); // see comment above sprintf( tmp, "Elapsed time in Task R = %f s\n\r", (float)((1.0*(after-before))/CPU_TS_TmrFreqGet( &cpu_err )) ); APP_TRACE_DBG(( tmp )); } pulse_flag = 0; } OSTimeDlyHMSM(0u, 0u, 0u, 200u, OS_OPT_TIME_HMSM_STRICT, &err); } }
void CPU_RunLoop() { Common::SetCurrentThreadName("CPUThread"); if (!CPU_NextState(CPU_THREAD_PENDING, CPU_THREAD_STARTING)) { ERROR_LOG(CPU, "CPU thread in unexpected state: %d", cpuThreadState); return; } CPU_Init(); CPU_NextState(CPU_THREAD_STARTING, CPU_THREAD_RUNNING); while (cpuThreadState != CPU_THREAD_SHUTDOWN) { CPU_WaitStatus(&CPU_HasPendingAction); switch (cpuThreadState) { case CPU_THREAD_EXECUTE: mipsr4k.RunLoopUntil(cpuThreadUntil); gpu->FinishEventLoop(); CPU_NextState(CPU_THREAD_EXECUTE, CPU_THREAD_RUNNING); break; // These are fine, just keep looping. case CPU_THREAD_RUNNING: case CPU_THREAD_SHUTDOWN: break; default: ERROR_LOG(CPU, "CPU thread in unexpected state: %d", cpuThreadState); // Begin shutdown, otherwise we'd just spin on this bad state. CPU_SetState(CPU_THREAD_SHUTDOWN); break; } } if (coreState != CORE_ERROR) { coreState = CORE_POWERDOWN; } CPU_Shutdown(); CPU_SetState(CPU_THREAD_NOT_RUNNING); }
int main (void) { OSInit(); /* Init uC/OS-II. */ CPU_Init(); OSTaskCreateExt(periodicTask, (void *)limits[1], stack1 + (APP_TASK_STK_SIZE - 1), (INT8U)(1), (INT16U)(1), stack1, (INT32U)APP_TASK_STK_SIZE, (void *)limits[1], (INT16U)(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR)); OSTaskCreateExt(periodicTask, (void *)limits[2], stack2 + (APP_TASK_STK_SIZE - 1), (INT8U)(2), (INT16U)(2), stack2, (INT32U)APP_TASK_STK_SIZE, (void *)limits[2], (INT16U)(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR)); OSTaskCreateExt(periodicTask, (void *)limits[3], stack3 + (APP_TASK_STK_SIZE - 1), (INT8U)(3), (INT16U)(3), stack3, (INT32U)APP_TASK_STK_SIZE, (void *)limits[3], (INT16U)(OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR)); OSStart(); /* Start multitasking (i.e. give control to uC/OS-II). */ }
//开始任务函数 void start_task(void *p_arg) { OS_ERR err; CPU_SR_ALLOC(); p_arg = p_arg; CPU_Init(); #if OS_CFG_STAT_TASK_EN > 0u OSStatTaskCPUUsageInit(&err); //统计任务 #endif #ifdef CPU_CFG_INT_DIS_MEAS_EN //如果使能了测量中断关闭时间 CPU_IntDisMeasMaxCurReset(); #endif #if OS_CFG_SCHED_ROUND_ROBIN_EN //当使用时间片轮转的时候 //使能时间片轮转调度功能,时间片长度为1个系统时钟节拍,既1*5=5ms OSSchedRoundRobinCfg(DEF_ENABLED,1,&err); #endif OS_CRITICAL_ENTER(); //进入临界区 OSTaskCreate((OS_TCB * )&Led0TaskTCB, (CPU_CHAR * )"led0 task", (OS_TASK_PTR )led0_task, (void * )0, (OS_PRIO )LED0_TASK_PRIO, (CPU_STK * )&LED0_TASK_STK[0], (CPU_STK_SIZE)LED0_STK_SIZE/10, (CPU_STK_SIZE)LED0_STK_SIZE, (OS_MSG_QTY )0, (OS_TICK )0, (void * )0, (OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, (OS_ERR * )&err); OS_TaskSuspend((OS_TCB*)&StartTaskTCB,&err); //挂起开始任务 OS_CRITICAL_EXIT(); //进入临界区 }
static void AppTaskStart (void *p_arg) { OS_ERR err; (void)p_arg; BSP_Init(); /* Initialize BSP functions */ CPU_Init(); /* Initialize uC/CPU services */ #if OS_CFG_STAT_TASK_EN > 0u OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */ #endif APP_TRACE_DBG(("uCOS-II is Running...\n\r")); while (DEF_ON) { /* Task body, always written as an infinite loop. */ OSTimeDlyHMSM(0, 0, 1, 0); APP_TRACE_DBG(("Time: %d\n\r", OSTimeGet(&err))); } }
static void AppTaskStart (void *p_arg) { CPU_INT32U cpu_clk_freq; CPU_INT32U cnts; OS_ERR err; (void)p_arg; BSP_Init(); /* Initialize BSP functions */ CPU_Init(); cpu_clk_freq = BSP_CPU_ClkFreq(); cnts = cpu_clk_freq / (CPU_INT32U)OSCfg_TickRate_Hz;/* Determine nbr SysTick increments */ OS_CPU_SysTickInit(cnts); /* Init uC/OS periodic time src (SysTick). */ #if OS_CFG_STAT_TASK_EN > 0u OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */ #endif CPU_IntDisMeasMaxCurReset(); //init USART1 BSP_Ser_Init(9600); BSP_Ser_WrStr("start"); //init ADC1, ACC sensor TERM_init_adc(); //init PWM TERM_init_pwm(); //AppTaskCreate(); /* Create application tasks */ TERM_createTask(); }
bool PSP_InitStart(const CoreParameter &coreParam, std::string *error_string) { if (pspIsIniting) { return false; } #if defined(_WIN32) && defined(_M_X64) INFO_LOG(BOOT, "PPSSPP %s Windows 64 bit", PPSSPP_GIT_VERSION); #elif defined(_WIN32) && !defined(_M_X64) INFO_LOG(BOOT, "PPSSPP %s Windows 32 bit", PPSSPP_GIT_VERSION); #else INFO_LOG(BOOT, "PPSSPP %s", PPSSPP_GIT_VERSION); #endif coreParameter = coreParam; coreParameter.errorString = ""; pspIsIniting = true; if (g_Config.bSeparateCPUThread) { Core_ListenShutdown(System_Wake); CPU_SetState(CPU_THREAD_PENDING); cpuThread = new std::thread(&CPU_RunLoop); #ifdef _XBOX SuspendThread(cpuThread->native_handle()); XSetThreadProcessor(cpuThread->native_handle(), 2); ResumeThread(cpuThread->native_handle()); #endif cpuThreadID = cpuThread->get_id(); cpuThread->detach(); } else { CPU_Init(); } *error_string = coreParameter.errorString; bool success = coreParameter.fileToStart != ""; if (!success) { pspIsIniting = false; } return success; }
bool PSP_InitStart(const CoreParameter &coreParam, std::string *error_string) { if (pspIsIniting || pspIsQuiting) { return false; } #if defined(_WIN32) && defined(_M_X64) INFO_LOG(BOOT, "PPSSPP %s Windows 64 bit", PPSSPP_GIT_VERSION); #elif defined(_WIN32) && !defined(_M_X64) INFO_LOG(BOOT, "PPSSPP %s Windows 32 bit", PPSSPP_GIT_VERSION); #else INFO_LOG(BOOT, "PPSSPP %s", PPSSPP_GIT_VERSION); #endif GraphicsContext *temp = coreParameter.graphicsContext; coreParameter = coreParam; if (coreParameter.graphicsContext == nullptr) { coreParameter.graphicsContext = temp; } coreParameter.errorString = ""; pspIsIniting = true; if (g_Config.bSeparateCPUThread) { Core_ListenShutdown(System_Wake); CPU_SetState(CPU_THREAD_PENDING); cpuThread = new std::thread(&CPU_RunLoop); cpuThreadID = cpuThread->get_id(); cpuThread->detach(); } else { CPU_Init(); } *error_string = coreParameter.errorString; bool success = coreParameter.fileToStart != ""; if (!success) { pspIsIniting = false; } return success; }
static void AppTaskStart (void *p_arg) { CPU_INT32U freq; CPU_INT32U cnts; OS_ERR err; (void)p_arg; BSP_Init(); /* Initialize BSP functions */ CPU_Init(); /* Initialize the uC/CPU services */ freq = BSP_CPU_ClkFreq(); /* Determine SysTick reference freq. */ cnts = freq / (CPU_INT32U)OSCfg_TickRate_Hz; /* Determine nbr SysTick increments */ OS_CPU_SysTickInit(cnts); /* Init uC/OS periodic time src (SysTick). */ #if OS_CFG_STAT_TASK_EN > 0u OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */ #endif #ifdef CPU_CFG_INT_DIS_MEAS_EN CPU_IntDisMeasMaxCurReset(); #endif AppEventCreate(); /* Create Application Kernel objects */ AppTaskCreate(); /* Create application tasks */ while (DEF_TRUE) { /* Task body, always written as an infinite loop. */ OSTimeDlyHMSM(0, 0, 0, 200, /* Delay task for 200 ms */ OS_OPT_TIME_HMSM_STRICT, &err); } }