任务如何切换---可能没你想的那么简单

/* Scheduler utilities. */
#define portYIELD()                                     \
    {                                                   \
        /* Set a PendSV to request a context switch. */ \
        portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT; \  
                                                        \
        /* Barriers are normally not required but do ensure the code is completely \
         * within the specified behaviour for the architecture. */ \
        __asm volatile ( "dsb" ::: "memory" );                     \
        __asm volatile ( "isb" );                                  \
    }

#define portNVIC_INT_CTRL_REG     ( *( ( volatile uint32_t * ) 0xe000ed04 ) )
#define portNVIC_PENDSVSET_BIT    ( 1UL << 28UL )

高地址
|        |  <--- 一开始SP 初始指向这里（例如 0x20001000）
|  R0    |  <--- 0x20000FFC
|  R1    |
|  R2    |
|  R3    |
|  R12   |
|  LR    |
|  PC    |
|  xPSR  |  <--- 准备进入到中断函数前会自动将不封寄存器压栈。SP 现在指向这里（0x20000FE0）
低地址

void xPortPendSVHandler( void )     
{
    /* This is a naked function. */                                               

    __asm volatile                                                               
    (
        "   mrs r0, psp                         \n"  // 将进程堆栈指针(PSP)的值读取到r0寄存器
        "   isb                                 \n"  // 指令同步隔离，确保前面的指令执行完成
        "                                       \n"
        "   ldr r3, pxCurrentTCBConst           \n" // 加载当前任务控制块(TCB)的地址到r3 r3=&pxCurrentTCB
        "   ldr r2, [r3]                        \n" // 加载当前TCB的值到r2 r2=pxCurrentTCB
        "                                       \n"
        "   stmdb r0!, {r4-r11}                 \n" // 将r4-r11寄存器的值保存到任务栈中，并更新栈指针
        "   str r0, [r2]                        \n" // 因为r2=pxCurrentTCB，所以[r2]就是pxCurrentTCB 指向地址的内容的第一个地址，所以r0=pxTopOfStack
        "                                       \n"
        "   stmdb sp!, {r3, r14}                \n" // 将r3和lr压入msp，r3是当前任务的pxCurrentTCBConst地址，lr是返回地址，之所以保存这两个寄存器是因为在vTaskSwitchContext函数中需要用到，不保存就被覆盖了。
        "   mov r0, %0                          \n" // 将configMAX_SYSCALL_INTERRUPT_PRIORITY加载到r0
        "   msr basepri, r0                     \n" // 设置BASEPRI寄存器，configMAX_SYSCALL_INTERRUPT_PRIORITY，也就是屏蔽优先级低于等于configMAX_SYSCALL_INTERRUPT_PRIORITY的中断。
        "   bl vTaskSwitchContext               \n" // 调用任务切换函数，选择下一个要运行的任务，并保存到pxCurrentTCB中
        "   mov r0, #0                          \n" // 将0加载到r0
        "   msr basepri, r0                     \n" // 恢复BASEPRI设置为0，允许所有中断
        "   ldmia sp!, {r3, r14}                \n" // 从主栈恢复r3和lr的值，也就是
        "                                       \n"
        "   ldr r1, [r3]                        \n" // 加载新的当前TCB的地址到r1 也就是r1=pxCurrentTCB
        "   ldr r0, [r1]                        \n" // 加载新任务的栈指针到r0 也就是r0=pxCurrentTCB->pxTopOfStack
        "   ldmia r0!, {r4-r11}                 \n" // 从pxTopOfStack也就是任务栈栈顶恢复r4-r11寄存器的值
        "   msr psp, r0                         \n" // 更新PSP为新任务的栈指针
        "   isb                                 \n" // 指令同步隔离，确保前面的指令执行完成
        "   bx r14                              \n" // 返回，通过lr跳转回任务代码
        "                                       \n"
        "   .align 4                            \n" // 4字节对齐
        "pxCurrentTCBConst: .word pxCurrentTCB  \n" // 相当于const uint32_t pxCurrentTCBConst = (uint32_t)&pxCurrentTCB;
        ::"i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) // 将configMAX_SYSCALL_INTERRUPT_PRIORITY作为立即数传入
    );
}

* EXC_RETURN_HANDLER         (0xFFFFFFF1UL)     /* return to Handler mode, uses MSP after return*/
* EXC_RETURN_THREAD_MSP      (0xFFFFFFF9UL)     /* return to Thread mode, uses MSP after return*/
* EXC_RETURN_THREAD_PSP      (0xFFFFFFFDUL)     /* return to Thread mode, uses PSP after return*/

void xPortPendSVHandler( void ) __attribute__( ( naked ) );//nake 函数

add:
        push    {r11, lr}       // 前序：将调用者的帧指针(r11)和返回地址(lr)压入堆栈，进行保存
        mov     r11, sp         // 前序：设置当前函数的帧指针，让r11指向当前的栈顶
        sub     sp, sp, #12     // 前序：在堆栈上为局部变量分配12字节的栈空间
        str     r0, [r11, #-4]  // 将参数a (在r0中) 存入堆栈，位置是r11-4
        str     r1, [sp, #4]    // 将参数b (在r1中) 存入堆栈，位置是sp+4
        ldr     r0, [r11, #-4]  // 从堆栈中加载参数a到r0寄存器
        ldr     r1, [sp, #4]    // 从堆栈中加载参数b到r1寄存器
        add     r0, r0, r1      // 核心计算：执行 a + b，结果存放在r0
        str     r0, [sp]        // 将结果c (在r0中) 存入堆栈的顶部
        ldr     r0, [sp]        // 从堆栈顶部加载结果c到r0，准备作为返回值
        mov     sp, r11         // 后序：恢复栈指针到函数初始位置，释放局部变量空间
        pop     {r11, pc}       // 后序：恢复调用者的帧指针(r11)，并将返回地址弹入程序计数器(pc)以完成返回