本文详细介绍了FreeRTOS实时操作系统中调度器的启动、挂起及恢复过程。包括开启调度器时的空闲任务创建、中断配置、FPU单元初始化等步骤；调度器挂起与恢复时的任务状态管理和时间补偿机制；以及低功耗模式下时间补偿的具体实现。
1. 开启调度器
vTaskStartScheduler
| + vPortSetupTimerInterrupt 设置systick，初始化低功耗运行系统补偿时间
+----xPortStartScheduler -- + prvEnableVFP 开启浮点运算单元
+ prvStartFirstTask 开启第一个任务，SVC异常处理函数
2. 关闭调度器，啥都没用。
3. 调度器挂起，挂起层数计数变量。
4. 调度器恢复
5. 低功耗模式系统补偿函数
开启调度器
1 void vTaskStartScheduler( void )
2 {
3 BaseType_t xReturn;
4
5
6 /* Add the idle task at the lowest priority. */
7 #if( configSUPPORT_STATIC_ALLOCATION == 1 ) 静态添加空闲任务
8 {
9 StaticTask_t *pxIdleTaskTCBBuffer = NULL;
10 StackType_t *pxIdleTaskStackBuffer = NULL;
11 uint32_t ulIdleTaskStackSize;
12
13 /* The Idle task is created using user provided RAM - obtain the
14 address of the RAM then create the idle task. */ 添加Idle任务
15 vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, &pxIdleTaskStackBuffer, &ulIdleTaskStackSize );
16 xIdleTaskHandle = xTaskCreateStatic( prvIdleTask,
17 "IDLE",
18 ulIdleTaskStackSize,
19 ( void * ) NULL,
20 ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),
21 pxIdleTaskStackBuffer,
22 pxIdleTaskTCBBuffer ); /*lint !e961 */
23
24 if( xIdleTaskHandle != NULL )
25 {
26 xReturn = pdPASS;
27 }
28 else
29 {
30 xReturn = pdFAIL;
31 }
32 }
33 #else
34 {
35 /* The Idle task is being created using dynamically allocated RAM. */
36 xReturn = xTaskCreate( prvIdleTask,
37 "IDLE", configMINIMAL_STACK_SIZE,
38 ( void * ) NULL,
39 ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),
40 &xIdleTaskHandle ); /*lint !e961 */
41 }
42 #endif /* configSUPPORT_STATIC_ALLOCATION */
43
44 #if ( configUSE_TIMERS == 1 )
45 {
46 if( xReturn == pdPASS )
47 {
48 xReturn = xTimerCreateTimerTask(); 创建定时器服务！后面分析
49 }
50 else
51 {
52 mtCOVERAGE_TEST_MARKER();
53 }
54 }
55 #endif /* configUSE_TIMERS */
56
57 if( xReturn == pdPASS )
58 {
59 /* Interrupts are turned off here, to ensure a tick does not occur
60 before or during the call to xPortStartScheduler(). The stacks of
61 the created tasks contain a status word with interrupts switched on
62 so interrupts will automatically get re-enabled when the first task
63 starts to run. */
64 portDISABLE_INTERRUPTS();
65
66 #if ( configUSE_NEWLIB_REENTRANT == 1 ) 【略】
67 {
68 /* Switch Newlib's _impure_ptr variable to point to the _reent
69 structure specific to the task that will run first. */
70 _impure_ptr = &( pxCurrentTCB->xNewLib_reent );
71 }
72 #endif /* configUSE_NEWLIB_REENTRANT */
73
74 xNextTaskUnblockTime = portMAX_DELAY; 三个值的初始化
75 xSchedulerRunning = pdTRUE;
76 xTickCount = ( TickType_t ) 0U;
77
78 /* If configGENERATE_RUN_TIME_STATS is defined then the following
79 macro must be defined to configure the timer/counter used to generate
80 the run time counter time base. */
81 portCONFIGURE_TIMER_FOR_RUN_TIME_STATS(); 时间统计功能若打开，用户实现此宏。
82
83 /* Setting up the timer tick is hardware specific and thus in the
84 portable interface. */
85 if( xPortStartScheduler() != pdFALSE )
86 {
87 /* Should not reach here as if the scheduler is running the
88 function will not return. */ as(因为)
89 }
90 else
91 {
92 /* Should only reach here if a task calls xTaskEndScheduler(). */ 除非(if)
93 }
94 }
95 else
96 {
97 /* This line will only be reached if the kernel could not be started,
98 because there was not enough FreeRTOS heap to create the idle task
99 or the timer task. */
100 configASSERT( xReturn != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY ); idle task 或 timer task 没创建成功
101 }
102
103 /* Prevent compiler warnings if INCLUDE_xTaskGetIdleTaskHandle is set to 0,
104 meaning xIdleTaskHandle is not used anywhere else. */
105 ( void ) xIdleTaskHandle; 防止编译器报错，xTaskGetIdleTaskHandle为0时，编译器提示idle task not use.
106 }
107 /*-----------------------------------------------------------*/
硬件初始化：systick、FPU单元、PendSV中断。
1 BaseType_t xPortStartScheduler( void )
2 {
3 /* configMAX_SYSCALL_INTERRUPT_PRIORITY must not be set to 0.
4 See http://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
5 configASSERT( configMAX_SYSCALL_INTERRUPT_PRIORITY );
6
7 /* This port can be used on all revisions of the Cortex-M7 core other than
8 the r0p1 parts. r0p1 parts should use the port from the
9 /source/portable/GCC/ARM_CM7/r0p1 directory. */
10 configASSERT( portCPUID != portCORTEX_M7_r0p1_ID );
11 configASSERT( portCPUID != portCORTEX_M7_r0p0_ID );
12
13 #if( configASSERT_DEFINED == 1 ) 【略】
14 {
15 volatile uint32_t ulOriginalPriority;
16 volatile uint8_t * const pucFirstUserPriorityRegister = ( uint8_t * ) ( portNVIC_IP_REGISTERS_OFFSET_16 + portFIRST_USER_INTERRUPT_NUMBER );
17 volatile uint8_t ucMaxPriorityValue;
18
19 /* Determine the maximum priority from which ISR safe FreeRTOS API
20 functions can be called. ISR safe functions are those that end in
21 "FromISR". FreeRTOS maintains separate thread and ISR API functions to
22 ensure interrupt entry is as fast and simple as possible.
23
24 Save the interrupt priority value that is about to be clobbered. */
25 ulOriginalPriority = *pucFirstUserPriorityRegister;
26
27 /* Determine the number of priority bits available. First write to all
28 possible bits. */
29 *pucFirstUserPriorityRegister = portMAX_8_BIT_VALUE;
30
31 /* Read the value back to see how many bits stuck. */
32 ucMaxPriorityValue = *pucFirstUserPriorityRegister;
33
34 /* The kernel interrupt priority should be set to the lowest
35 priority. */
36 configASSERT( ucMaxPriorityValue == ( configKERNEL_INTERRUPT_PRIORITY & ucMaxPriorityValue ) );
37
38 /* Use the same mask on the maximum system call priority. */
39 ucMaxSysCallPriority = configMAX_SYSCALL_INTERRUPT_PRIORITY & ucMaxPriorityValue;
40
41 /* Calculate the maximum acceptable priority group value for the number
42 of bits read back. */
43 ulMaxPRIGROUPValue = portMAX_PRIGROUP_BITS;
44 while( ( ucMaxPriorityValue & portTOP_BIT_OF_BYTE ) == portTOP_BIT_OF_BYTE )
45 {
46 ulMaxPRIGROUPValue--;
47 ucMaxPriorityValue <<= ( uint8_t ) 0x01;
48 }
49
50 /* Shift the priority group value back to its position within the AIRCR
51 register. */
52 ulMaxPRIGROUPValue <<= portPRIGROUP_SHIFT;
53 ulMaxPRIGROUPValue &= portPRIORITY_GROUP_MASK;
54
55 /* Restore the clobbered interrupt priority register to its original
56 value. */
57 *pucFirstUserPriorityRegister = ulOriginalPriority;
58 }
59 #endif /* conifgASSERT_DEFINED */
60
61 /* Make PendSV and SysTick the lowest priority interrupts. */
62 portNVIC_SYSPRI2_REG |= portNVIC_PENDSV_PRI;
63 portNVIC_SYSPRI2_REG |= portNVIC_SYSTICK_PRI;
64
65 /* Start the timer that generates the tick ISR. Interrupts are disabled
66 here already. */
67 vPortSetupTimerInterrupt();
68
69 /* Initialise the critical nesting count ready for the first task. */
70 uxCriticalNesting = 0; 临界区嵌套计数器，防止多个临界区时，其中一个临界区退出，导致多个临界区都退出。
71
72 /* Ensure the VFP is enabled - it should be anyway. */
73 prvEnableVFP(); 使能VFP
74
75 /* Lazy save always. */
76 *( portFPCCR ) |= portASPEN_AND_LSPEN_BITS; 使S0~S15和FPSCR寄存器，中断时自动保存和恢复。FPCCR寄存器、惰性压栈，参见《权威指南》12章 浮点运算
77
78 /* Start the first task. */
79 prvStartFirstTask();
80
81 /* Should not get here! */
82 return 0;
83 }
一、开启systick
void vPortSetupTimerInterrupt( void )
{
/* Calculate the constants required to configure the tick interrupt. */
#if configUSE_TICKLESS_IDLE == 1
{
ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ); 系统时钟频率/sysTick频率
xMaximumPossibleSuppressedTicks = portMAX_24_BIT_NUMBER / ulTimerCountsForOneTick; //0xFFF_FFF ul
ulStoppedTimerCompensation = portMISSED_COUNTS_FACTOR / ( configCPU_CLOCK_HZ / configSYSTICK_CLOCK_HZ );
}
#endif /* configUSE_TICKLESS_IDLE */
/* Configure SysTick to interrupt at the requested rate. */
portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL; 设置重装载值
portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT ); 开启xx
}
/* A fiddle欺骗的 factor to estimate the number of SysTick counts that would have
occurred while the SysTick counter is stopped during tickless idle
calculations. */
#define portMISSED_COUNTS_FACTOR ( 45UL ) 详见低功耗运行补偿时间
portNVIC_SYSTICK_CLK_BIT 1<<2
portNVIC_SYSTICK_INT_BIT 1<<1
portNVIC_SYSTICK_ENABLE_BIT 1<<0
#define portNVIC_SYSTICK_CTRL_REG ( * ( ( volatile uint32_t * ) 0xe000e010 ) )
二、开启FPU，浮点处理单元
__asm void prvEnableVFP( void )
{
PRESERVE8
ldr.w r0, =0xE000ED88 ;R0=0XE000ED88 SCB->CPACR寄存器 Coprocessor Access Contrl
ldr r1, [r0] ;从 R0 的地址读取数据赋给 R1
orr r1, r1, #( 0xf << 20 ) ;R1=R1|(0xf<<20) bit20~bit23,开启FPU
str r1, [r0] ;R1 中的值写入 R0 保存的地址中
bx r14
nop
}
CPACR Register to enable floating point unit feature; available on Cortex -M4 with floating point unit only
三、开启第一个任务
__asm void prvStartFirstTask( void )
{
PRESERVE8
/* Use the NVIC offset register to locate the stack. */
ldr r0, =0xE000ED08
ldr r0, [r0] R0地址处的内容,赋值给R0
ldr r0, [r0] 获取MSP初始值
/* Set the msp back to the start of the stack. */
msr msp, r0 复位MSP
/* Globally enable interrupts. */
cpsie i 使能中断，清除PRI MASK
cpsie f 使能中断，清除FAULT MASK
dsb 数据同步屏障?
isb 指令同步屏障?
/* Call SVC to start the first task. */
svc 0 呼叫SVC异常
nop
nop
}
向量表重定位，向量表偏移寄存器(VTOR)。 地址就是 0XE000ED08，通过这个寄存器可以重新定义向量表。
向量表的起始地址保存的就是主栈指针MSP 的初始值。
在 FreeRTOS 中仅仅使用 SVC 异常来启动第一个任务，后面的程序中就再也用不到 SVC 了。
#define xPortPendSVHandler PendSV_Handler
__asm void vPortSVCHandler( void )
{
PRESERVE8
/* Get the location of the current TCB. */
ldr r3, =pxCurrentTCB 获取pxCurrentTCB的存储地址
ldr r1, [r3] 获取当前任务的TCB存储地址
ldr r0, [r1] TCB第一个字段就是任务堆栈的栈顶指针pxTopOfStack，获取它指向的地址
/* Pop the core registers. */
ldmia r0!, {r4-r11, r14} 多加载/存储指令(R0~R3,R12,PC,xPSR是自动压栈出栈的)
msr psp, r0 更新psp任务堆栈指针
isb
mov r0, #0
msr basepri, r0 BASEPRI设为0，开中断
bx r14 中断返回，执行PC指向的任务函数.
}
1. pxCurrentTCB 是一个指向 TCB_t 的指针，这个指针永远指向正在运行的任务。
2. 前三步的目的就是获取要切换到的这个任务的任务栈顶指针，
因为任务所对应的寄存器值，也就是现场都保存在任务的任务堆栈中，
所以需要获取栈顶指针来恢复这些寄存器值！
3. R14 = LR寄存器，恢复时，它的内容为EXC_RETURN = 0xffff_fffd，是初始化任务堆栈时的值。
========================================================
有vTaskStartScheduler 就有 vTaskEndScheduler
/**
* task. h
* void vTaskEndScheduler( void );
*
* NOTE: At the time of writing only the x86 real mode port, which runs on a PC
* in place of DOS, implements this function.
*
* Stops the real time kernel tick. All created tasks will be automatically
* deleted and multitasking (either preemptive or cooperative) will
* stop. Execution then resumes from the point where vTaskStartScheduler ()
* was called, as if vTaskStartScheduler () had just returned.
*
* vTaskEndScheduler () requires an exit function to be defined within the
* portable layer (see vPortEndScheduler () in port. c for the PC port). This
* performs hardware specific operations such as stopping the kernel tick.
*
* vTaskEndScheduler () will cause all of the resources allocated by the
* kernel to be freed - but will not free resources allocated by application
* tasks.
*
*/
void vTaskEndScheduler( void )
{ /* Stop the scheduler interrupts and call the portable scheduler end routine so the original ISRs can be restored if necessary. The port layer must ensure interrupts enable bit is left in the correct state. */
portDISABLE_INTERRUPTS(); 关中断
xSchedulerRunning = pdFALSE;
vPortEndScheduler(); 关调度器
}
void vPortEndScheduler( void )
{/* Not implemented in ports where there is nothing to return to. Artificially force an assert. */
configASSERT( uxCriticalNesting == 1000UL ); 啥都没做~只有x86内核里才使用这个东东。
}
========================================================
========================================================
vTaskSuspendAll() 挂起任务调度器， 调用此函数不需要关闭可屏蔽中断。
void vTaskSuspendAll( void )
{
/* A critical section is not required as the variable is of type
BaseType_t. Please read Richard Barry's reply in the following link to a
post in the FreeRTOS support forum before reporting this as a bug! -
http://goo.gl/wu4acr */
++uxSchedulerSuspended;
}
uxSchedulerSuspended 是挂起嵌套计数器， 调度器挂起是支持嵌套的。
使用函数 xTaskResumeAll()可以恢复任务调度器，调用了几次 vTaskSuspendAll()挂起调度器，同样的也得调用几次 xTaskResumeAll()才会最终恢复任务调度器。
假设现在有这样一种情况， 任务 1 的优先级为 10，此时任务 1 由于等待队列TestQueue 而处于阻塞态 。
但是有段其他的 代码调用函数vTaskSuspendAll()挂起了任务调度器，
在还没有调用 xTaskResumeAll()恢复任务调度器之前，有个在外部中断发生了，在中断服务程序里面调用函数 xQueueSendFromISR()向任务 1 发送了队列 TestQueue。
如果任务调度器没有阻塞的话函数 xQueueSendFromISR()会使任务 1 进入就绪态，也就是将任务 1 添加到优先级 10 对应的就绪列表 pxReadyTasksLists[10]中，这样当任务切换的时候任务 1 就会运行。
但是现在任务调度器由于函数 vTaskSuspendAll()而挂起，这个时候任务 1 就不是添加到任务就绪列表 pxReadyTasksLists[10]中了，而是添加到另一个叫做xPendingReadyList 的列表中，
xPendingReadyList 是个全局变量，在文件 tasks.c 中有定义。
当调用函数 xTaskResumeAll()恢复调度器的时候就会将挂到列表 xPendingReadyList 中的任务重新移动到它们所对应的就绪列表 pxReadyTasksLists 中。
任务调度器恢复
1 BaseType_t xTaskResumeAll( void )
2 {
3 TCB_t *pxTCB = NULL;
4 BaseType_t xAlreadyYielded = pdFALSE;
5
6 /* If uxSchedulerSuspended is zero then this function does not match a
7 previous call to vTaskSuspendAll(). */
8 configASSERT( uxSchedulerSuspended );
9
10 /* It is possible that an ISR caused a task to be removed from an event
11 list while the scheduler was suspended. If this was the case then the
12 removed task will have been added to the xPendingReadyList. Once the
13 scheduler has been resumed it is safe to move all the pending ready
14 tasks from this list into their appropriate ready list. */
15 taskENTER_CRITICAL();
16 {
17 --uxSchedulerSuspended; 嵌套层数变量自减一
18
19 if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE ) 等于0，要恢复调度器了
20 {
21 if( uxCurrentNumberOfTasks > ( UBaseType_t ) 0U )
22 {
23 /* Move any readied tasks from the pending list into the
24 appropriate ready list. */ 从PendingReadList里面，移动到ReadyList.
25 while( listLIST_IS_EMPTY( &xPendingReadyList ) == pdFALSE )
26 {
27 pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) );
28 ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
29 ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
30 prvAddTaskToReadyList( pxTCB );
31
32 /* If the moved task has a priority higher than the current
33 task then a yield must be performed. */
34 if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority ) 新出来的优先级高
35 {
36 xYieldPending = pdTRUE; 切换任务
37 }
38 else
39 {
40 mtCOVERAGE_TEST_MARKER();
41 }
42 }
43
44 if( pxTCB != NULL )
45 {
46 /* A task was unblocked while the scheduler was suspended,
47 which may have prevented the next unblock time from being
48 re-calculated, in which case re-calculate it now. Mainly
49 important for low power tickless implementations, where
50 this can prevent an unnecessary exit from low power
51 state. */
52 prvResetNextTaskUnblockTime(); 重新计算变量xNextTaskUnblockTime，详见 “删除任务 ##5”
53 }
54
55 /* If any ticks occurred while the scheduler was suspended then
56 they should be processed now. This ensures the tick count does
57 not slip逃, and that any delayed tasks are resumed at the correct
58 time. */
59 { 任务调度器挂起时，tick中断不会更新TickCnt，而是更新PendTick【见时间管理章节的TaskIncrementTick函数】
在恢复任务调度时，调用PendTick次TaskIncrementTick()函数，来恢复TickCnt！！
同时，如果有延时任务取消阻塞的动作，也会在TaskIncrementTick函数中进行。
60 UBaseType_t uxPendedCounts = uxPendedTicks; /* Non-volatile copy. */
61
62 if( uxPendedCounts > ( UBaseType_t ) 0U )
63 {
64 do
65 {
66 if( xTaskIncrementTick() != pdFALSE )
67 {
68 xYieldPending = pdTRUE; 置位xYieldPending
69 }
70 else
71 {
72 mtCOVERAGE_TEST_MARKER();
73 }
74 --uxPendedCounts;
75 } while( uxPendedCounts > ( UBaseType_t ) 0U );
76
77 uxPendedTicks = 0;
78 }
79 else
80 {
81 mtCOVERAGE_TEST_MARKER();
82 }
83 }
84
85 if( xYieldPending != pdFALSE ) 如果置位了
86 {
87 #if( configUSE_PREEMPTION != 0 )
88 {
89 xAlreadyYielded = pdTRUE;
90 }
91 #endif
92 taskYIELD_IF_USING_PREEMPTION(); 置位PendSV
93 }
94 else
95 {
96 mtCOVERAGE_TEST_MARKER();
97 }
98 }
99 }
100 else
101 {
102 mtCOVERAGE_TEST_MARKER();
103 }
104 }
105 taskEXIT_CRITICAL();
106
107 return xAlreadyYielded;
108 }
>1 把PendingReadyList里面的任务，恢复到ReadyList当中。(可能引起任务调度)
>2 重新计算NextTaskUnblockTime
>3 弥补在挂起调度器时，漏了的系统滴答时钟节拍。(可能引起任务调度)
========================================================
========================================================
vTaskStepTick()
此函数在使用 FreeRTOS 的低功耗 tickless 模式的时候会用到，即宏 configUSE_TICKLESS_IDLE 为 1。
当使能低功耗 tickless 模式以后在执行空闲任务的时候系统时钟节拍中断就会停止运行，系统时钟中断停止运行的这段时间必须得补上，
这个工作就是由函数 vTaskStepTick()来完成的。
void vTaskStepTick( const TickType_t xTicksToJump )
{
configASSERT( ( xTickCount + xTicksToJump ) <= xNextTaskUnblockTime );
xTickCount += xTicksToJump;
traceINCREASE_TICK_COUNT( xTicksToJump );
}
函数参数 xTicksToJump 是要加上的时间值，系统节拍计数器 xTickCount 加上这个时间值得到新的系统时间。
关于 xTicksToJump 这个时间值的确定。详见“系统低功耗睡眠模式”
啊
扫一扫
2303
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
