Using FreeRTOS, a basic program architecture is as follows:
After the task is created, the static variable pointer (see< FreeRTOS advanced Chapter 2 - FreeRTOS task creation analysis >Section 7) points to the highest priority ready task. However, the task cannot run at this time, because there is another key step: start the FreeRTOS scheduler.
The scheduler is the core of FreeRTOS operating system, which is mainly responsible for task switching, that is, finding the ready task with the highest priority and making it obtain the CPU running right. The scheduler does not run automatically and needs to be started manually.
The API function vTaskStartScheduler() is used to start the scheduler. It will create an idle task and initialize some static variables. Most importantly, it will initialize the system beat timer and set the corresponding interrupt, and then start the first task. This article is used to analyze the process of starting the scheduler. Like the previous article, starting the scheduler also involves hardware features (such as system beat timer initialization). Therefore, this paper still takes Cortex-M3 architecture as an example.
The simplified source code of the API function vTaskStartScheduler() of the start scheduler is as follows:
This API function first creates an idle task. The idle task uses the lowest priority (level 0). The task handle of the idle task is stored in the static variable xidletask handle. You can call the API function xTaskGetIdleTaskHandle() to obtain the idle task handle.
If the task is created successfully, close the interrupt (when the scheduler starts to terminate and then interrupt again), initialize some static variables, and then call the function xPortStartScheduler() to start the system timer and start the first task. Because setting the system beat timer involves hardware characteristics, the function xPortStartScheduler() is provided by the migration layer. The code of this function is also different for different hardware architectures.
For Cortex-M3 architecture, the implementation of the function xPortStartScheduler() is as follows:
As you can see from the source code, the first large section is redundant code. Because the interrupt priority of Cortex-M3 is somewhat counterintuitive: the higher the interrupt priority value of Cortex-M3, the lower the priority. The task priority of FreeRTOS is the opposite: the higher the priority value, the higher the priority. According to official statistics, when FreeRTOS is used on Cortex-M3 hardware, most of the problems are due to incorrect priority setting. Therefore, in order to make FreeRTOS more robust, the author of FreeRTOS deliberately added redundant code when writing the code of Cortex-M3 architecture migration layer. For detailed interrupt priority settings of Cortex-M3 architecture, refer to< FreeRTOS series Chapter 7 -- special precautions for using FreeRTOS with Cortex-M kernel >A penny.
In the Cortex-M3 architecture, FreeRTOS uses three exceptions for task startup and task switching: SVC, PendSV and SysTick. SVC (system service call) is used for task startup. Some operating systems do not allow applications to directly access hardware, but call it through SVC by providing some system service functions; PendSV (system call can be suspended) is used to complete task switching. Its biggest feature is that if an interrupt with higher priority is running, PendSV will delay the execution until the execution of the high priority interrupt is completed; SysTick is used to generate the system beat clock and provide a time slice. If multiple tasks share the same priority, the next task will be interrupted each time SysTick is interrupted Get a time slice. For detailed description of SVC and PendSV exceptions, the "exception" section of Cortex-M3 authoritative guide is recommended.
Here, the PendSV and SysTick exception priority are set to the lowest, so that the task switching will not interrupt a certain interrupt service program, and the interrupt service program will not be delayed, which simplifies the design and is conducive to system stability.
Next, call the function vportsetuptimerinthrupt() to set the interrupt cycle of SysTick timer and enable the timer to run. This function is relatively simple, that is, to set the corresponding registers of SysTick hardware.
The next key function is prvStartFirstTask(), which is used to start the first task. Let's first look at the source code:
The first few lines of code in the program are used to reset the value of the main stack pointer MSP, indicating that the MSP pointer has been taken over by FreeRTOS since then. It should be noted that the interrupt of Cortex-M3 hardware also uses the MSP pointer. After that, enable the interrupt, use the assembly instruction svc 0 to trigger the SVC interrupt to complete the work of starting the first task. Let's look at the SVC interrupt service function:
From the previous article on task creation, we have learned about the pointer pxCurrentTCB. This is defined in tasks The only global variable in C points to the ready task TCB at the highest priority. We know that the core function of FreeRTOS is to ensure that the ready task at the highest priority obtains CPU permission. Therefore, it can be said that the task pointed to by this pointer is either running or about to run (the scheduler is closed), so this variable is named pxCurrentTCB.
According to< FreeRTOS advanced Chapter 2 - FreeRTOS task creation analysis >In Section 3, we can know that when a task is created, its task stack will be initialized like a task switch, as shown in Figure 1-1. For Cortex-M3 architecture, it is required to stack, PC, LR, R12, R3~R0 and R11 ~ R4 in turn. R11 ~ R4 need to be manually stacked, and other registers are automatically stacked by hardware. The register PC is initialized to the task function pointer vTask_A. In this way, when a task is switched, task a obtains CPU control and the task function vTask_A is out of the stack to the PC register, and then the code of task a will be executed; The LR register is initialized to the function pointer prvTaskExitError, which is an error handling function provided by the migration layer.
The task TCB structure member pxTopOfStack represents the top of the current stack. It points to the last item in the stack, so in the figure it points to R4. Another TCB structure member pxStack represents the starting position of the stack, so in the figure it points to the beginning of the stack.
Figure 1-1: task stack distribution after task creation
Therefore, the SVC interrupt service function uses the global pointer pxCurrentTCB to obtain the TCB of the first task to be started from the beginning, so as to obtain the current stack top pointer of the task. First, take the artificially stacked registers R4~R11 out of the stack, assign the latest stack top pointer to the thread stack pointer PSP, and then cancel the interrupt masking. Here, as long as an interrupt occurs, it can be responded to.
The interrupt service function returns through the assembly of the following two sentences. In the Cortex-M3 architecture, the value of r14 determines the mode of returning from the exception. Here, the last four bits of r14 are bitwise or 0x0d, indicating that stack operations are made from the process stack when returning, entering the thread mode after returning, and returning to the Thumb state.
After executing bx# r14 instruction, the hardware will automatically stack registers xPSR, PC, LR, R12, R3~R0. At this time, the task function pointer vtask of task a_ A will be out of the stack into the PC pointer to start executing task a.
So far, the task vTask_A obtains the CPU Execution Authority, and the scheduler officially starts working.