STM32 dual stack and its use in uC/OS-II

Note: There may be many wrong ideas in it. I hope everyone will correct them in time after discovering them.

First, let's learn about the dual stack. The following picture is from the "Cortex-M3 Definitive Guide". It's a bit boring, but you still need to read it.

Summarize:

1. After the system is reset, the default is MSP. The state after reset is the privileged thread state. In this state, the register CONTROL[1] can be modified (see the picture above). After entering the user privilege state, these registers cannot be modified.

2. MSP or PSP can be used in user privileged mode (that is, non-interrupt service routines established by users), and only MSP can be used in privileged mode (interrupt service routines).

3. Another very important point is that if PSP is used in user mode, the value of the register is saved in the task stack space. After entering the interrupt program, MSP is used. If there is a high-priority interrupt, MSP will continue to be used. When the program exits the last level of interrupt, the user stack is used to restore the register.

The following uses uCOS-II as an example to illustrate:

First, create a stack OS_STK AppTaskStartStk[1024] //32 bits

STM32 is a full stack that grows downward. After the stack is initialized (before PSP is used, MSP is always used).

                 | .... | AppTaskStartStk[0]
                 |-----------------|
                 | .... | AppTaskStartStk[1]
                 |-----------------|
                 | .... |
                 |-----------------| |---- PSP
    Low Memory during Task Switching | .... | |
                 |-----------------| | |---------------| |----------------|
        ^ | R4 | <----|----|--OSTCBStkPtr |<-----| (OS_TCB *) |
        ^ |-----------------| |---------------| |----------------|
        ^ | R5 | | | OSTCBHighRdy
        | |-----------------| |---------------|
        | | R6 | | |
        | |-----------------| |---------------|
        | | R7 | | |
        | |-----------------| |---------------|
        | | R8 | Task's
        | |-----------------| OS_TCB
        | | R9 |
        | |-----------------|
        | | R10 |
      Stack |-----------------|
      Growth | R11 |
       = 1 |-----------------|
        | | R0 = p_arg | <-------- PSP at exception (full stack growing downward)
        | |-----------------|
        | | R1 |
        | |-----------------|
        | | R2 |
        | |-----------------|
        | | R3 |
        | |-----------------|
        | | R12 |
        | |-----------------|
        | | LR |  
        | |-----------------|
        | | SP = task | AppTaskStartStk[1022]
        | |-----------------|
        | | xPSR | AppTaskStartStk[1023]
    High Memory |-----------------|                                       

Before the first execution of the PendSV interrupt, PSP = 0 has been initialized. MSP is used before entering the interrupt, so the values ​​of the registers automatically pushed onto the stack are saved in the system stack. Since it is the first execution, there is no need to manually save PSP and {R4-R11} into the task stack, and then fetch data from the task stack space into registers {R4-R11}. When exiting the interrupt, set bit 2 of LR to ensure that PSP is used when exiting the interrupt, restore the values ​​of the remaining registers (the values ​​of these registers are automatically pushed onto the stack), and finally enter the task. When executing the task program, PSP is used, and any numbers that need to be pushed onto the stack will be entered into the task stack. Now consider two situations.

(1) If there is a high-priority interrupt to be executed, the register values ​​automatically pushed into the stack will be saved in the stack of the current task, and the MSP will be used after entering the interrupt service routine (if the remaining registers need to be saved, the compiler will automatically generate the corresponding assembly code and save it to the system stack instead of the task stack). If there are higher-priority interrupts later, the MSP will continue to be used.

(2) If there is a high-priority task that needs to be executed at this time, then xPSR, PC, LR, R12, R0-R3 are automatically saved to the stack of the current task by hardware, and then PSP and {R4-R11} need to be pushed into the stack manually.

If two data are pushed onto the stack during the execution of a low-priority task, the result of saving the registers after entering the PendSV interrupt is as follows:

   | .... | AppTaskStartStk[0]
                 |-----------------|
                 | .... | AppTaskStartStk[1]
                 |-----------------|
                 | .... |
                 |-----------------| |---- PSP
    Low Memory during Task Switching | .... | |
                 |-----------------| | |---------------| |----------------|
        ^ | R4 | <----|----|--OSTCBStkPtr |<-----| (OS_TCB *) |
        ^ |-----------------| |---------------| |----------------|
        ^ | R5 | | | OSTCBHighRdy
        | |-----------------| |---------------|
        | | R6 | | |
        | |-----------------| |---------------|
        | | R7 | | |
        | |-----------------| |---------------|
        | | R8 | Task's
        | |-----------------| OS_TCB
        | | R9 |
        | |-----------------|
        | | R10 |
      Stack |-----------------|
      Growth | R11 |
       = 1 |-----------------|
        | | R0 = p_arg | <-------- PSP on exception (full stack growing downwards)
        | |-----------------|
        | | R1 |
        | |-----------------|
        | | R2 |
        | |-----------------|
        | | R3 |
        | |-----------------|
        | | R12 |
        | |-----------------|
        | | LR |  
        | |-----------------|
        | | SP = task |

        | |------------------|
        | | xPSR |

        | |-----------------|

        | | 0x11111111 |

        | |------------------|
        | | 0x22222222 |

High Memory |-----------------|