1
// 读写特殊寄存器的方法（CMSIS接口）
2
uint32_t sp = __get_MSP();       // 读取主栈指针
3
__set_MSP(0x20010000);           // 设置主栈指针
4
uint32_t psr = __get_xPSR();    // 读取程序状态寄存器
5
__set_PRIMASK(1);                // 关中断（等价于 __disable_irq()）                        // 关总中断
6
__set_PRIMASK(0);                // 开中断（等价于 __enable_irq()）                         // 开总中断
7
__set_BASEPRI(0x40);             // 屏蔽优先级>=0x40的中断

1
// RTOS中任务切换时的栈指针操作（简化版PendSV处理）
2
void PendSV_Handler(void) {
3
    // 1. 保存当前任务上下文到PSP指向的栈
4
    __asm volatile (
5
        "MRS R0, PSP        \n"  // R0 = 当前任务的PSP
6
        "STMDB R0!, {R4-R11}\n"  // 将R4-R11手动压栈（R0-R3/PC/LR/xPSR硬件自动压）
7
    );
8
    // 保存当前PSP到TCB
9
    current_task->sp = __get_PSP();
10

11
    // 2. 切换到下一个任务
12
    current_task = next_task;
13

14
    // 3. 恢复下一个任务的上下文
15
    __set_PSP(next_task->sp);               // 设置进程栈指针
7 collapsed lines
16
    __asm volatile (
17
        "MRS R0, PSP        \n"                  // 读特殊寄存器
18
        "LDMIA R0!, {R4-R11}\n"  // 从栈恢复R4-R11
19
        "MSR PSP, R0        \n"  // 更新PSP
20
        "BX LR              \n"  // LR=EXC_RETURN，自动恢复R0-R3/PC/LR/xPSR
21
    );
22
}

1
// 为什么面试考AAPCS？因为它直接影响：
2
// 1. 中断现场保存——硬件自动保存哪些寄存器？(R0-R3, R12, LR, PC, xPSR)
3
// 2. RTOS任务切换——需要手动保存哪些？(R4-R11，因为硬件不保存)
4
// 3. C和汇编混编——参数怎么传？返回值怎么拿？
5

6
// 示例：C函数 int add(int a, int b) 的汇编实现
7
// a通过R0传入，b通过R1传入，结果通过R0返回
8
// add:
9
//     ADD R0, R0, R1    @ R0 = a + b
10
//     BX  LR            @ 返回                  // 返回调用者

1
// NVIC常用操作(CMSIS接口)                       // 嵌套向量中断控制器
2
NVIC_EnableIRQ(USART1_IRQn);           // 使能USART1中断
3
NVIC_DisableIRQ(USART1_IRQn);          // 禁用USART1中断
4
NVIC_SetPriority(USART1_IRQn, 2);      // 设置优先级为2
5
NVIC_GetPriority(USART1_IRQn);         // 获取优先级
6
NVIC_SetPendingIRQ(USART1_IRQn);       // 手动挂起中断(软件触发)
7
NVIC_ClearPendingIRQ(USART1_IRQn);     // 清除挂起状态
8

9
// 全局中断控制
10
__disable_irq();  // PRIMASK=1，屏蔽所有可配置中断
11
__enable_irq();   // PRIMASK=0，开放中断

1
中断发生
2
    │
3
    ▼
4
1. 压栈(Stacking) ─── 硬件自动将8个寄存器压入当前栈(PSP→MSP)
5
   │  [高地址]
6
   │  xPSR   ← SP+28
7
   │  PC     ← SP+24  (返回地址)
8
   │  LR     ← SP+20
9
   │  R12    ← SP+16
10
   │  R3     ← SP+12
11
   │  R2     ← SP+8
12
   │  R1     ← SP+4
13
   │  R0     ← SP+0
14
   │  [低地址]
15
   ▼
13 collapsed lines
16
2. 取向量 ─── 从向量表中读取ISR地址(并行执行，与压栈同时)
17
   │
18
   ▼
19
3. 更新寄存器
20
   │  - SP切换到MSP
21
   │  - PC = ISR入口地址
22
   │  - LR = EXC_RETURN (特殊值，标识返回行为)
23
   │  - IPSR = 异常编号
24
   ▼
25
4. 执行ISR
26
   │
27
   ▼
28
5. 中断返回(BX LR) ─── 硬件自动出栈恢复8个寄存器                // 返回调用者

1
优先级: ISR_A(优先级3) < ISR_B(优先级1)
2

3
时间线:
4
主程序 ──┬───────────────────────────────────────── 主程序
5
         │                                          │
6
         ▼ IRQ_A触发                                │
7
    ISR_A ──┬──────────── ISR_A(继续) ──────────────┘
8
            │ IRQ_B触发(更高优先级)     │
9
            ▼                          │
10
       ISR_B ─────────────────────────┘

1
无尾链:    ISR_A → [出栈12cyc] → [压栈12cyc] → ISR_B   (浪费24周期)
2
有尾链:    ISR_A → [直接跳转~6cyc] → ISR_B              (节省18周期)

1
// 1. 在HardFault_Handler中提取错误信息
2
void HardFault_Handler(void) {
3
    __asm volatile (
4
        "TST LR, #4      \n"  // 判断中断前用的MSP还是PSP
5
        "ITE EQ           \n"
6
        "MRSEQ R0, MSP    \n"  // 用MSP
7
        "MRSNE R0, PSP    \n"  // 用PSP
8
        "B hard_fault_handler_c \n"
9
    );
10
}
11

12
void hard_fault_handler_c(uint32_t *stack_frame) {
13
    // stack_frame指向硬件自动压栈的8个寄存器
14
    volatile uint32_t r0  = stack_frame[0];
15
    volatile uint32_t r1  = stack_frame[1];
17 collapsed lines
16
    volatile uint32_t r2  = stack_frame[2];
17
    volatile uint32_t r3  = stack_frame[3];
18
    volatile uint32_t r12 = stack_frame[4];
19
    volatile uint32_t lr  = stack_frame[5];  // 出错前的返回地址
20
    volatile uint32_t pc  = stack_frame[6];  // 出错的指令地址 ★
21
    volatile uint32_t psr = stack_frame[7];
22

23
    // 读SCB错误状态寄存器
24
    volatile uint32_t cfsr = SCB->CFSR;   // 组合错误状态
25
    volatile uint32_t hfsr = SCB->HFSR;   // HardFault状态
26
    volatile uint32_t mmfar = SCB->MMFAR; // MemManage错误地址
27
    volatile uint32_t bfar = SCB->BFAR;   // BusFault错误地址
28

29
    // 在这里打断点，查看pc值 → 用addr2line定位出错的源码行
30
    // arm-none-eabi-addr2line -e firmware.elf -f -C 0x08001234
31
    while(1);
32
}

1
为什么任务切换不直接在SysTick中断里做？
2

3
SysTick(优先级较高)
4
    │
5
    ▼ 如果在SysTick里直接做任务切换...
6
         │
7
    但此时可能有其他中断正在处理！
8
    直接切换会打断中断处理链 → 出问题！
9

10
正确做法：
11
SysTick (高优先级)          PendSV (最低优先级)
12
    │                           │
13
    ▼                           ▼
14
  决定要切换任务        实际执行上下文切换
15
  设置PendSV挂起  ────→ (等所有中断处理完才执行)
1 collapsed line
16
  SCB->ICSR |= SCB_ICSR_PENDSVSET_Msk;    // 系统控制块

1
// 位带操作原理：SRAM/外设区的每个bit映射到一个32位字地址
2
// 位带别名地址 = 位带别名基址 + (字节偏移 × 32) + (位号 × 4)
3

4
// SRAM位带别名基址 = 0x22000000
5
// 外设位带别名基址 = 0x42000000
6

7
// 示例：原子操作GPIOA ODR的第5位(PA5)
8
// GPIOA ODR地址 = 0x40020014 (STM32F4)
9
// 位带别名地址 = 0x42000000 + (0x20014 × 32) + (5 × 4) = 0x42400294
10

11
#define BITBAND_PERIPH(addr, bit) \
12
    (*(volatile uint32_t *)(0x42000000 + ((addr - 0x40000000) << 5) + ((bit) << 2)))
13

14
// 用法：原子设置PA5（点亮LED）
15
BITBAND_PERIPH(0x40020014, 5) = 1;  // PA5 = HIGH，原子操作
4 collapsed lines
16
BITBAND_PERIPH(0x40020014, 5) = 0;  // PA5 = LOW，原子操作
17

18
// 等效的传统方式（非原子，可能被中断打断）：
19
GPIOA->ODR |= (1 << 5);   // 读-改-写，不安全！

1
// MPU配置示例：保护RTOS内核栈区域
2
void MPU_Config(void) {
3
    HAL_MPU_Disable();
4

5
    MPU_Region_InitTypeDef mpu_init;
6
    mpu_init.Enable = MPU_REGION_ENABLE;
7
    mpu_init.Number = MPU_REGION_NUMBER0;
8
    mpu_init.BaseAddress = 0x20000000;          // SRAM起始
9
    mpu_init.Size = MPU_REGION_SIZE_1KB;        // 保护1KB区域
10
    mpu_init.AccessPermission = MPU_REGION_PRIV_RO; // 特权只读
11
    mpu_init.IsBufferable = MPU_ACCESS_NOT_BUFFERABLE;
12
    mpu_init.IsCacheable = MPU_ACCESS_CACHEABLE;
13
    mpu_init.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
14
    mpu_init.SubRegionDisable = 0;
15
    mpu_init.TypeExtField = MPU_TEX_LEVEL0;
5 collapsed lines
16
    mpu_init.DisableExec = MPU_INSTRUCTION_ACCESS_DISABLE;
17
    HAL_MPU_ConfigRegion(&mpu_init);
18

19
    HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
20
}

1
// Cortex-M7 Cache操作(CMSIS)
2
SCB_EnableICache();    // 使能指令Cache
3
SCB_EnableDCache();    // 使能数据Cache
4

5
// DMA接收完成后，CPU要读DMA缓冲区的数据：
6
SCB_InvalidateDCache_by_Addr(rx_buffer, BUFFER_SIZE);
7
// → 丢弃Cache中的旧数据，强制从内存重新加载
8

9
// CPU填充好发送缓冲区后，DMA要读：
10
SCB_CleanDCache_by_Addr(tx_buffer, BUFFER_SIZE);
11
// → 将Cache中的数据写回到内存，确保DMA读到最新值
12

13
// 或者直接将DMA缓冲区放在Non-cacheable区域(最简单但损失性能)
14
// 通过MPU将该区域配置为Non-cacheable

1
/* STM32F407 链接脚本示例(简化版) */
2
MEMORY
3
{
4
    FLASH (rx)  : ORIGIN = 0x08000000, LENGTH = 1024K  /* 1MB Flash */
5
    RAM (rwx)   : ORIGIN = 0x20000000, LENGTH = 128K   /* 128KB SRAM */
6
    CCMRAM (rw) : ORIGIN = 0x10000000, LENGTH = 64K    /* 64KB CCM RAM */
7
}
8

9
/* 入口点 */
10
ENTRY(Reset_Handler)
11

12
/* 栈大小 */
13
_Min_Stack_Size = 0x400;   /* 1KB栈 */
14
_Min_Heap_Size = 0x200;    /* 512B堆 */
15

44 collapsed lines
16
SECTIONS
17
{
18
    /* 1. 向量表和代码段 → 放在Flash */
19
    .isr_vector : {
20
        . = ALIGN(4);
21
        KEEP(*(.isr_vector))  /* 向量表，KEEP防止被优化掉 */
22
        . = ALIGN(4);
23
    } > FLASH
24

25
    .text : {
26
        *(.text)              /* 所有代码 */
27
        *(.text*)
28
        *(.rodata)            /* 只读常量(const) */
29
        *(.rodata*)
30
    } > FLASH
31

32
    /* 2. 初始化数据段 → Flash中存储初值，运行时拷贝到RAM */
33
    .data : {
34
        _sdata = .;
35
        *(.data)
36
        *(.data*)
37
        _edata = .;
38
    } > RAM AT > FLASH        /* 运行地址在RAM，加载地址在Flash */
39

40
    /* 3. BSS段 → RAM中，启动时清零 */
41
    .bss : {
42
        _sbss = .;
43
        *(.bss)
44
        *(.bss*)
45
        *(COMMON)
46
        _ebss = .;
47
    } > RAM
48

49
    /* 4. 堆和栈 */
50
    ._user_heap_stack : {
51
        . = ALIGN(8);
52
        PROVIDE(end = .);     /* malloc从这里开始分配 */
53
        . = . + _Min_Heap_Size;
54
        . = . + _Min_Stack_Size;
55
        . = ALIGN(8);
56
    } > RAM
57

58
    _estack = ORIGIN(RAM) + LENGTH(RAM);  /* 栈顶 = RAM末尾 */
59
}

1
// GCC内联汇编基本语法：
2
// __asm volatile ("汇编指令" : 输出操作数 : 输入操作数 : 被修改的寄存器);
3

4
// 示例1：读取PRIMASK寄存器(判断中断是否被关闭)
5
static inline uint32_t get_primask(void) {
6
    uint32_t result;
7
    __asm volatile ("MRS %0, PRIMASK" : "=r"(result));       // 读特殊寄存器
8
    // %0 对应第一个操作数(result)
9
    // "=r" 表示输出到通用寄存器
10
    return result;
11
}
12

13
// 示例2：原子地关中断并返回之前的状态(RTOS临界区常用)
14
static inline uint32_t enter_critical(void) {
15
    uint32_t primask;
23 collapsed lines
16
    __asm volatile (
17
        "MRS %0, PRIMASK \n"   // 保存当前PRIMASK
18
        "CPSID I         \n"   // 关中断
19
        : "=r"(primask)        // 输出
20
        :                      // 无输入
21
        : "memory"             // 告诉编译器内存可能被修改
22
    );
23
    return primask;
24
}
25

26
static inline void exit_critical(uint32_t primask) {
27
    __asm volatile (
28
        "MSR PRIMASK, %0 \n"   // 恢复PRIMASK
29
        :                      // 无输出
30
        : "r"(primask)         // 输入
31
        : "memory"
32
    );
33
}
34

35
// 使用：
36
uint32_t saved = enter_critical();  // 进入临界区(关中断)
37
// ... 操作共享资源 ...
38
exit_critical(saved);               // 退出临界区(恢复中断状态)

1
// FreeRTOS Tickless模式中WFI的典型用法                                // 等待中断(低功耗)
2
void vPortSuppressTicksAndSleep(TickType_t xExpectedIdleTime) {
3
    // 1. 计算可以睡多久
4
    uint32_t ulReloadValue = xExpectedIdleTime * (configCPU_CLOCK_HZ / configTICK_RATE_HZ);
5

6
    // 2. 停止SysTick，重新加载为长周期
7
    SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
8
    SysTick->LOAD = ulReloadValue - 1;
9
    SysTick->VAL = 0;
10
    SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
11

12
    // 3. 进入睡眠
13
    __DSB();  // 数据同步屏障，确保所有内存操作完成
14
    __WFI();  // 等待中断唤醒
15

7 collapsed lines
16
    // 4. 唤醒后补偿Tick计数
17
    uint32_t ulSleepTicks = ulReloadValue - SysTick->VAL;
18
    vTaskStepTick(ulSleepTicks / (configCPU_CLOCK_HZ / configTICK_RATE_HZ));
19

20
    // 5. 恢复正常SysTick配置
21
    SysTick->LOAD = (configCPU_CLOCK_HZ / configTICK_RATE_HZ) - 1;
22
}

1
虚拟地址(进程A看到的)     MMU翻译        物理地址(实际硬件)
2
   0x00400000     ───────→          0x80100000
3
   0x00401000     ───────→          0x80200000
4
   0x7FFE0000     ───────→          0x80050000 (栈)
5

6
虚拟地址(进程B看到的)     MMU翻译        物理地址
7
   0x00400000     ───────→          0x80300000  ← 不同的物理地址！
8
   0x00401000     ───────→          0x80400000

1
位带区域(Bit-Band Region):
2
  SRAM:      0x20000000~0x200FFFFF (1MB)
3
  外设:      0x40000000~0x400FFFFF (1MB)
4

5
位带别名区域(Alias Region):
6
  SRAM别名:  0x22000000~0x23FFFFFF
7
  外设别名:  0x42000000~0x43FFFFFF
8

9
映射公式:
10
  alias_addr = alias_base + (byte_offset × 32) + (bit_number × 4)
11

12
用途: 对单个位的原子读写(单总线事务)
13
  正常方式: 读-修改-写(3步, 可能被中断)
14
  位带方式: 直接写别名地址(1步, 原子操作)

1
// 对GPIOA_ODR第5位的原子操作
2
#define GPIOA_ODR_ADDR  0x40020014
3
#define BITBAND_PERIPH(addr, bit)     (0x42000000 + ((addr-0x40000000)<<5) + ((bit)<<2))
4

5
#define PA5_BB  (*(volatile uint32_t*)BITBAND_PERIPH(GPIOA_ODR_ADDR, 5))
6
PA5_BB = 1;  // 置位PA5(原子操作)
7
PA5_BB = 0;  // 清零PA5

1
MSP(Main Stack Pointer):
2
  - 复位后默认使用
3
  - Handler模式(中断)始终使用MSP
4
  - 值从向量表第一个条目加载
5

6
PSP(Process Stack Pointer):
7
  - 线程模式可选使用
8
  - RTOS中每个任务使用独立的PSP
9

10
切换: CONTROL寄存器bit[1]
11
  CONTROL.SPSEL = 0: 线程模式用MSP
12
  CONTROL.SPSEL = 1: 线程模式用PSP(RTOS使用)
13

14
为什么区分？
15
  - 任务栈溢出不会破坏系统栈(MSP)
2 collapsed lines
16
  - 中断有独立栈空间
17
  - 硬件自动在MSP/PSP间切换

1
固定优先级(不可配置):
2
  -3: Reset (最高)
3
  -2: NMI
4
  -1: HardFault
5

6
可配置优先级:
7
  0~255(越小越高), 具体位数取决于实现
8
  STM32: 4位 → 0~15
9

10
优先级分组(PRIGROUP):
11
  8位优先级字段分为: [抢占优先级][子优先级]
12
  Group 2: 2位抢占(0~3) + 2位子优先级(0~3)
13

14
规则:
15
  1. 抢占优先级高 → 可以打断低优先级ISR(嵌套)
2 collapsed lines
16
  2. 同抢占不同子优先级 → 不能嵌套,但同时挂起时先响应子优先级高的
17
  3. 同优先级 → 按中断号(位置)决定(号越小越优先)

1
// SysTick: 24位递减计数器,所有Cortex-M都有
2
// 用途: RTOS心跳/延时基准
3

4
// 配置1ms中断(72MHz系统时钟)
5
SysTick_Config(72000);  // 72MHz / 72000 = 1kHz = 1ms
6

7
// 或手动配置:
8
SysTick->LOAD = 72000 - 1;  // 重载值
9
SysTick->VAL = 0;            // 清零计数器
10
SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk |  // 用系统时钟
11
                SysTick_CTRL_TICKINT_Msk |      // 使能中断
12
                SysTick_CTRL_ENABLE_Msk;        // 使能
13

14
void SysTick_Handler(void) {
15
    HAL_IncTick();  // 为HAL_Delay提供时基
1 collapsed line
16
}

1
// 三种内存屏障(Cortex-M/A都适用):
2

3
// DSB(Data Synchronization Barrier):
4
//   确保DSB之前的所有内存访问完成后才执行后面的指令
5
__DSB();
6
// 用途: SCB寄存器修改后(如设置VTOR/MPU)
7

8
// DMB(Data Memory Barrier):
9
//   确保DMB之前的内存访问在DMB之后的内存访问之前完成
10
__DMB();
11
// 用途: 多核间共享数据/设备寄存器访问顺序
12

13
// ISB(Instruction Synchronization Barrier):
14
//   刷新流水线,确保之后的指令重新取指
15
__ISB();
6 collapsed lines
16
// 用途: 修改CONTROL寄存器/中断优先级后
17

18
// 常见组合:
19
SCB->VTOR = new_vtor;
20
__DSB();  // 确保VTOR写入完成
21
__ISB();  // 确保后续取指用新向量表

1
// MPU: 内存保护单元(防止越界访问)
2
// Cortex-M3/M4: 8个Region
3
// Cortex-M7: 8或16个Region
4

5
// 配置Region 0: 保护栈底(检测栈溢出)
6
MPU->RNR = 0;  // Region Number
7
MPU->RBAR = STACK_BOTTOM_ADDR;  // 基地址
8
MPU->RASR = MPU_RASR_ENABLE_Msk |
9
            (4 << MPU_RASR_SIZE_Pos) |  // 32字节(2^(4+1))
10
            (0 << MPU_RASR_AP_Pos) |     // No Access
11
            MPU_RASR_XN_Msk;             // 不可执行
12

13
// 使能MPU
14
MPU->CTRL = MPU_CTRL_ENABLE_Msk | MPU_CTRL_PRIVDEFENA_Msk;
15
__DSB();
3 collapsed lines
16
__ISB();
17

18
// 栈溢出时 → MemManage Fault → 可以记录并安全处理

1
AAPCS(ARM Architecture Procedure Call Standard):
2

3
寄存器使用约定:
4
  R0~R3:  参数传递 + 返回值(R0) + 临时寄存器(Caller保存)
5
  R4~R11: 局部变量(Callee保存, 被调方需要压栈保护)
6
  R12:    IP(Intra-Procedure scratch)
7
  R13:    SP(栈指针)
8
  R14:    LR(链接寄存器, 保存返回地址)
9
  R15:    PC(程序计数器)
10

11
函数调用规则:
12
  1. 前4个参数通过R0~R3传递, 更多通过栈
13
  2. 返回值放R0(64位用R0+R1)
14
  3. 栈8字节对齐
15
  4. 被调方必须保存R4~R11(如果使用)
2 collapsed lines
16

17
面试意义: 理解ISR为什么只自动保存R0~R3,R12,LR,PC,xPSR

1
正常中断流程:
2
  入栈(12周期) → ISR_A → 出栈(12周期)
3
  → 入栈(12周期) → ISR_B → 出栈(12周期)
4
  总开销: 48周期
5

6
尾链优化(Tail-Chaining):
7
  入栈(12周期) → ISR_A → (不出栈)直接→ ISR_B → 出栈(12周期)
8
  中间: 6周期(取新向量)
9
  总开销: 30周期!
10

11
条件: ISR_A执行完时ISR_B已挂起(同优先级或更低)
12
效果: 减少中断切换开销,提高实时性
13

14
延迟到达(Late-Arriving):
15
  如果入栈期间更高优先级中断来了:
3 collapsed lines
16
  → 不需要重新入栈(已经在入栈了)
17
  → 直接从向量表取高优先级ISR地址
18
  → 效果: 高优先级中断延迟只有6周期

1
ARM32指令集: 每条4字节, 强大但代码密度低
2
Thumb指令集: 每条2字节, 代码小但功能受限
3
Thumb-2: 2字节+4字节混合, 兼顾代码密度和性能
4

5
Cortex-M系列: 只支持Thumb-2(不支持ARM32)
6
Cortex-A系列: ARM32 + Thumb-2都支持(可切换)
7

8
切换: BX指令, 目标地址bit0=1表示Thumb模式
9
  BX R0  // R0最低位决定ARM/Thumb
10

11
为什么Cortex-M只用Thumb-2?
12
  - 代码密度高(Flash小的MCU很重要)
13
  - Thumb-2已经足够强大(32位指令处理复杂操作)
14
  - 简化硬件设计(不需要ARM/Thumb切换逻辑)

1
// Cortex-M4/M7有单精度FPU(M7还有双精度)
2
// 必须启用才能使用浮点指令!
3

4
// 启用FPU(通常在SystemInit中)
5
SCB->CPACR |= ((3UL << 10*2) | (3UL << 11*2));  // CP10+CP11全访问
6
__DSB();
7
__ISB();
8

9
// 编译选项: -mfpu=fpv4-sp-d16 -mfloat-abi=hard
10
// hard: 浮点参数通过FPU寄存器传递(最快)
11
// soft: 浮点用软件模拟(无FPU时)
12
// softfp: 软件ABI但用FPU指令(兼容)
13

14
// 注意: RTOS上下文切换需要保存FPU寄存器!
15
// FreeRTOS: configENABLE_FPU = 1
1 collapsed line
16
// 惰性保存: Cortex-M4/M7支持惰性FPU上下文保存

1
ARM支持大端和小端, Cortex-M默认小端:
2

3
小端(Little-Endian): 低字节在低地址
4
  0x12345678 存储: [78][56][34][12] (地址递增)
5

6
大端(Big-Endian): 高字节在低地址
7
  0x12345678 存储: [12][34][56][78]
8

9
字节序指令:
10
  REV: 反转字节序(32位)
11
  REV16: 反转半字节序(16位)
12
  REVSH: 带符号扩展的半字反转
13

14
使用场景:
15
  网络协议(TCP/IP)用大端 → 需要转换:
1 collapsed line
16
  htonl()/ntohl(): 主机字节序 ↔ 网络字节序

1
// 默认向量表在Flash起始(0x08000000)
2
// Bootloader+App场景需要重映射
3

4
// App的向量表在0x08010000:
5
SCB->VTOR = 0x08010000;  // 设置向量表偏移
6
__DSB();
7
__ISB();
8

9
// 对齐要求: 向量表起始地址必须对齐到大于等于向量数×4的2的幂
10
// STM32F4(82个向量): 82×4=328→向上取2的幂=512字节对齐
11

12
// RAM中的向量表(动态修改中断处理函数):
13
uint32_t vectorTable_RAM[128] __attribute__((aligned(512)));
14
memcpy(vectorTable_RAM, (void*)0x08000000, sizeof(vectorTable_RAM));
15
vectorTable_RAM[USART1_IRQn+16] = (uint32_t)my_new_handler;
1 collapsed line
16
SCB->VTOR = (uint32_t)vectorTable_RAM;

1
// Cortex-M向量表(32位地址数组)
2
// 位于Flash起始位置(0x08000000)
3

4
__attribute__((section(".isr_vector")))
5
const uint32_t vector_table[] = {
6
    (uint32_t)&_estack,        // [0] 初始MSP值
7
    (uint32_t)Reset_Handler,   // [1] Reset
8
    (uint32_t)NMI_Handler,     // [2] NMI
9
    (uint32_t)HardFault_Handler,// [3] HardFault
10
    (uint32_t)MemManage_Handler,// [4] MemManage
11
    (uint32_t)BusFault_Handler, // [5] BusFault
12
    (uint32_t)UsageFault_Handler,// [6] UsageFault
13
    0, 0, 0, 0,                // [7-10] Reserved
14
    (uint32_t)SVC_Handler,     // [11] SVCall
15
    // ... 后续为外部中断
4 collapsed lines
16
    (uint32_t)USART1_IRQHandler, // 中断号+16
17
};
18

19
// 上电时硬件自动: MSP=vector_table[0], PC=vector_table[1]

1
STM32的DMA和CPU共享AHB总线:
2
  DMA传输时可能和CPU争抢总线
3

4
仲裁策略:
5
  1. 轮询(Round Robin): DMA和CPU交替
6
  2. DMA优先: CPU暂停几个周期让DMA完成
7

8
实际影响:
9
  - DMA burst传输期间CPU可能暂停
10
  - 高带宽DMA(如ADC连续采样)会降低CPU性能
11
  - Cortex-M7: 多总线/AXI → DMA和CPU可以并行(不同总线)
12

13
嵌入式考量:
14
  - DMA缓冲区放在不同SRAM Bank(减少冲突)
15
  - 时间关键代码从TCM(紧耦合内存)执行