1
                    ┌─────────────────────────────────┐
2
                    │        Cortex-M4 内核            │
3
                    │  ┌─────┐ ┌─────┐ ┌──────┐      │
4
                    │  │ CPU │ │NVIC │ │SysTick│      │
5
                    │  │     │ │中断 │ │定时器 │      │
6
                    │  └──┬──┘ └──┬──┘ └───┬──┘      │
7
                    └─────┼──────┼────────┼──────────┘
8
                          │      │        │
9
              ┌───────────┴──────┴────────┴──────────┐
10
              │              AHB 总线                  │
11
              │   (高速: GPIOA~K, DMA, Flash, SRAM)   │
12
              └───────────┬──────┬───────────────────┘
13
                          │      │
14
              ┌───────────┘      └──────────┐
15
              │                              │
22 collapsed lines
16
     ┌────────┴────────┐          ┌─────────┴──────────┐
17
     │    APB2 总线     │          │    APB1 总线        │
18
     │   (高速外设)     │          │   (低速外设)        │
19
     │ USART1/6        │          │ USART2/3/4/5       │
20
     │ SPI1/4          │          │ SPI2/3             │
21
     │ TIM1/8/9/10/11  │          │ TIM2/3/4/5/6/7     │
22
     │ ADC1/2/3        │          │ I2C1/2/3           │
23
     │ EXTI            │          │ CAN1/2             │
24
     └─────────────────┘          │ DAC                │
25
                                  │ IWDG/WWDG          │
26
                                  └────────────────────┘
27

28
时钟树(超级重要!):
29
  HSE(外部晶振8M) → 或 HSI(内部RC 16M)
30
       │
31
       PLL(锁相环) × N / M / P
32
       │
33
  SYSCLK(168MHz@F407)
34
       │
35
  ┌────┼──────┐
36
  AHB  APB2   APB1
37
  168M  84M    42M

1
  ┌──────────────┬──────────────────────┬─────────────────────┐
2
  │ 模式          │ 原理                 │ 典型应用             │
3
  ├──────────────┼──────────────────────┼─────────────────────┤
4
  │ 浮空输入     │ 无上下拉,电平不确定  │ 外部已有确定电平     │
5
  │ 上拉输入     │ 内部上拉到VDD        │ 按键(低电平有效)    │
6
  │ 下拉输入     │ 内部下拉到GND        │ 按键(高电平有效)    │
7
  │ 模拟输入     │ 直连ADC,不经施密特   │ ADC采集             │
8
  │ 推挽输出     │ 可输出高低电平       │ LED、蜂鸣器 ★最常用 │
9
  │ 开漏输出     │ 只能拉低,需外部上拉  │ I2C总线 ★           │
10
  │ 复用推挽     │ 外设控制(推挽)       │ SPI、UART TX         │
11
  │ 复用开漏     │ 外设控制(开漏)       │ I2C                  │
12
  └──────────────┴──────────────────────┴─────────────────────┘
13

14
推挽 vs 开漏:
15
  推挽:  VDD              开漏:   VDD
11 collapsed lines
16
          │                        │
17
        [P-MOS]                  [外部Rp]
18
          │                        │
19
       ───┤ 输出               ───┤ 输出
20
          │                        │
21
        [N-MOS]                  [N-MOS]
22
          │                        │
23
         GND                      GND
24

25
  推挽: 能主动输出高和低, 驱动能力强
26
  开漏: 只能拉低, 高电平靠外部上拉 → 可实现"线与"(I2C)

1
性能排序: M0 < M0+ < M3 < M4 < M7
2
功耗排序: M0+ < M0 < M3 < M4 < M7

1
1. 上电复位（RESET 引脚）
2
2. 从 0x00000000 读取初始 SP（栈指针）
3
3. 从 0x00000004 读取 Reset_Handler 地址
4
4. 跳转到 Reset_Handler
5
5. Reset_Handler 中：
6
   a. 初始化 .data 段（从 Flash 拷贝到 RAM）
7
   b. 清零 .bss 段
8
   c. 调用 SystemInit()（配置时钟）
9
   d. 调用 main()

1
地址        内容
2
0x00000000  初始栈指针 (MSP)
3
0x00000004  Reset_Handler
4
0x00000008  NMI_Handler
5
0x0000000C  HardFault_Handler
6
0x00000010  MemManage_Handler
7
...
8
0x00000040  EXTI0_IRQHandler    ← 外部中断0
9
0x00000044  EXTI1_IRQHandler
10
...

1
STM32 GPIO 8种模式:
2

3
输入模式(4种):
4
  浮空输入 ─── GPIO引脚 ──► 输入寄存器 (无上下拉,外部必须给电平)
5
  上拉输入 ─── GPIO引脚 ─┬► 输入寄存器 (内部上拉到VCC)
6
                         R↑VCC
7
  下拉输入 ─── GPIO引脚 ─┬► 输入寄存器 (内部下拉到GND)
8
                         R↓GND
9
  模拟输入 ─── GPIO引脚 ──► ADC     (关闭数字输入,给ADC用)
10

11
输出模式(4种):
12
  推挽输出 ─── P-MOS ┐
13
                      ├── GPIO引脚 (可输出高/低, 驱动能力强)
14
              N-MOS ─┘
15
  开漏输出 ─── N-MOS ─── GPIO引脚 (只能拉低,高需外接上拉)
3 collapsed lines
16
                         适用: I2C, 电平转换
17
  复用推挽 ─── 外设信号 → 推挽输出 (如UART TX, SPI)
18
  复用开漏 ─── 外设信号 → 开漏输出 (如I2C)

1
上拉:            下拉:
2
  VCC              VCC
3
   │                │
4
  [R]上拉          按钮
5
   │                │
6
  ─┤─ GPIO         ─┤─ GPIO
7
   │                │
8
  按钮            [R]下拉
9
   │                │
10
  GND              GND
11

12
上拉: 默认高电平，按下接地→低电平
13
下拉: 默认低电平，按下接VCC→高电平

1
// STM32 优先级分组（4 位优先级）
2
// 抢占优先级: 可以打断低优先级中断（嵌套）
3
// 子优先级: 同抢占优先级时决定先后顺序
4

5
HAL_NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_2);  // 2位抢占+2位子
6
HAL_NVIC_SetPriority(TIM2_IRQn, 1, 0);  // 抢占=1, 子=0
7
HAL_NVIC_EnableIRQ(TIM2_IRQn);

1
// 1. 尽量短（不要做耗时操作）
2
// 2. 不要用 printf/malloc 等不可重入函数
3
// 3. 共享变量加 volatile
4
// 4. 清除中断标志位
5
// 5. 不要在ISR中调用阻塞函数
6

7
void TIM2_IRQHandler(void) {
8
    if (TIM2->SR & TIM_SR_UIF) {
9
        TIM2->SR &= ~TIM_SR_UIF;  // 清标志
10
        volatile_flag = 1;          // 设标志，主循环处理
11
    }
12
}

1
DMA 工作原理:
2

3
无DMA:
4
  外设 ──数据──► CPU ──数据──► 内存  (CPU全程参与)
5

6
有DMA:
7
  外设 ══数据═══════════════► 内存  (CPU只需启动DMA,传输期间可做其他事)
8
         ↑ DMA控制器自动搬运
9

10
DMA传输三要素:
11
  源地址:  外设数据寄存器 / 内存地址
12
  目的地址: 内存地址 / 外设数据寄存器
13
  传输数量: N个数据
14

15
三种传输方向:
7 collapsed lines
16
  外设→内存: ADC采集, UART接收
17
  内存→外设: UART发送, SPI发送, DAC输出
18
  内存→内存: 数据拷贝(代替memcpy)
19

20
DMA通道/流:  每个外设请求映射到特定DMA通道
21
  STM32F1: DMA1(7通道) + DMA2(5通道)
22
  STM32F4: DMA1/DMA2各8个流, 每流8个通道

1
/* 看门狗(Watchdog Timer) */
2

3
/* 原理: 定时器倒计时, 到0时复位MCU
4
 * 软件必须在超时前"喂狗"(重置计数器)
5
 * 如果程序跑飞/死循环 → 无法喂狗 → 自动复位
6
 */
7

8
/* STM32 两种看门狗: */
9

10
/* 1. IWDG(独立看门狗): LSI时钟, 独立运行 */
11
IWDG->KR = 0x5555;   // 解锁写保护
12
IWDG->PR = 4;        // 预分频=64
13
IWDG->RLR = 625;     // 重装值(超时≈1s)
14
IWDG->KR = 0xCCCC;   // 启动(启动后无法关闭!)
15
// 喂狗:
7 collapsed lines
16
IWDG->KR = 0xAAAA;   // 重装计数器
17

18
/* 2. WWDG(窗口看门狗): 必须在"窗口"时间内喂狗 */
19
//   太早喂 → 复位!  太晚喂 → 复位!
20
//   只有在窗口期内喂才有效(防止程序乱序执行)
21

22
/* 最佳实践: IWDG(保底) + 每个RTOS任务独立监控 */

1
/* STM32 HAL 设置 PWM 占空比 */
2
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, duty);  /* duty = 0~ARR */

1
/* 读取 ADC 值并转换为电压 */
2
uint16_t adc_val = HAL_ADC_GetValue(&hadc1);
3
float voltage = adc_val * 3.3f / 4096.0f;

1
/* DAC(数模转换器): 数字值 → 模拟电压 */
2

3
/* STM32 DAC: 12位, 输出范围0~VREF(通常3.3V) */
4
/* 输出电压 = VREF × DOR / 4096 */
5

6
HAL_DAC_SetValue(&hdac, DAC_CHANNEL_1,
7
                 DAC_ALIGN_12B_R, 2048);  // 输出≈1.65V
8
HAL_DAC_Start(&hdac, DAC_CHANNEL_1);
9

10
/* DAC + DMA + 定时器 → 输出波形(正弦波/三角波) */
11
uint16_t sine_wave[128];  // 预计算正弦表
12
void gen_sine(void) {
13
    for (int i = 0; i < 128; i++)
14
        sine_wave[i] = (uint16_t)(2048 + 2000 * sin(2*M_PI*i/128));
15
}
3 collapsed lines
16
// DMA循环发送sine_wave → DAC, 定时器触发每个采样点
17
HAL_DAC_Start_DMA(&hdac, DAC_CHANNEL_1,
18
                   (uint32_t*)sine_wave, 128, DAC_ALIGN_12B_R);

1
/* RTC 实时时钟 */
2

3
/* 特点: 独立电源(VBAT), 主电源断开仍计时
4
 * 时钟源: LSE(32.768kHz外部晶振, 精度高)
5
 *         LSI(内部RC, 精度低)
6
 */
7

8
/* 读取时间 */
9
RTC_TimeTypeDef time;
10
RTC_DateTypeDef date;
11
HAL_RTC_GetTime(&hrtc, &time, RTC_FORMAT_BIN);
12
HAL_RTC_GetDate(&hrtc, &date, RTC_FORMAT_BIN);
13
// 注意: 必须先读Time再读Date(硬件锁定机制)
14

15
printf("%02d:%02d:%02d\r\n", time.Hours, time.Minutes, time.Seconds);
10 collapsed lines
16

17
/* RTC闹钟: 指定时间触发中断 */
18
RTC_AlarmTypeDef alarm = {
19
    .AlarmTime.Hours = 7,
20
    .AlarmTime.Minutes = 30
21
};
22
HAL_RTC_SetAlarm_IT(&hrtc, &alarm, RTC_FORMAT_BIN);
23

24
/* RTC唤醒: 低功耗模式下周期唤醒(如每秒/每分钟) */
25
/* 备份寄存器: 掉电不丢失(需VBAT), 存储关键参数 */

1
/* STM32 内部Flash编程 */
2

3
/* Flash特性:
4
 * 读: 随机读取, 和RAM一样快(零等待态需要设置)
5
 * 写: 只能将1→0(必须先擦除再写)
6
 * 擦: 按扇区(Sector)整块擦除, 擦后全0xFF
7
 * 寿命: 约1万次擦写
8
 */
9

10
HAL_FLASH_Unlock();    // 解锁
11

12
// 擦除扇区
13
FLASH_EraseInitTypeDef erase = {
14
    .TypeErase = FLASH_TYPEERASE_SECTORS,
15
    .Sector = FLASH_SECTOR_7,   // 选最后一个扇区存数据
14 collapsed lines
16
    .NbSectors = 1,
17
    .VoltageRange = FLASH_VOLTAGE_RANGE_3
18
};
19
uint32_t err;
20
HAL_FLASHEx_Erase(&erase, &err);
21

22
// 写入(按字/半字/字节)
23
HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, 0x08060000, 0x12345678);
24

25
HAL_FLASH_Lock();      // 重新锁定(防误写)
26

27
/* 注意: 写Flash期间不能读Flash(总线冲突)
28
 * 中断中的代码如果在Flash中会卡死 → Flash操作时关中断
29
 */

1
STM32 低功耗模式:
2

3
┌──────────┬──────────┬────────────┬──────────────┐
4
│ 模式     │ 功耗     │ 唤醒时间   │ 保持内容     │
5
├──────────┼──────────┼────────────┼──────────────┤
6
│ Sleep    │ mA级     │ 1~2μs      │ CPU停,外设跑 │
7
│ Stop     │ μA级     │ 几μs       │ RAM+寄存器   │
8
│ Standby  │ nA级     │ 重启(ms级) │ 仅BKP寄存器  │
9
└──────────┴──────────┴────────────┴──────────────┘
10

11
Sleep:  __WFI();  // CPU时钟停, 外设时钟继续
12
        // 任何中断唤醒
13

14
Stop:   HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON,
15
                               PWR_STOPENTRY_WFI);
8 collapsed lines
16
        // 所有时钟停, EXTI/RTC唤醒
17
        // 唤醒后需重新配置时钟!
18

19
Standby: HAL_PWR_EnterSTANDBYMode();
20
         // 等效于复位, WKUP引脚/RTC唤醒
21
         // RAM内容丢失!
22

23
最佳实践: Tickless RTOS + Stop模式(μA级且保留RAM)

1
/* SystemInit() 通常在启动文件(startup_xxx.s)中调用 */
2
/* Reset_Handler → SystemInit → __main → main */
3

4
void SystemInit(void) {
5
    /* 1. 配置FPU(如果有) */
6
    #if (__FPU_PRESENT == 1)
7
    SCB->CPACR |= (0xF << 20);  // 使能FPU
8
    #endif
9

10
    /* 2. 配置中断向量表偏移 */
11
    SCB->VTOR = FLASH_BASE;  // 指向Flash中的向量表
12
    // Bootloader跳转APP时需要修改VTOR到APP地址
13

14
    /* 3. 初始化时钟(部分版本) */
15
    // 复位时钟到默认状态(HSI)
7 collapsed lines
16
    // 实际时钟树配置通常在 SystemClock_Config() 中
17

18
    /* 注意: SystemInit在C库初始化之前运行
19
     * 不能使用全局变量/printf等
20
     * 只做最基本的硬件初始化
21
     */
22
}

1
/* SysTick: Cortex-M内核自带的24位倒计时定时器 */
2

3
/* 主要用途: 提供OS Tick / HAL_Delay的时基 */
4

5
/* 配置为1ms中断 */
6
SysTick_Config(SystemCoreClock / 1000);  // 每1ms中断一次
7

8
volatile uint32_t uwTick = 0;
9

10
void SysTick_Handler(void) {
11
    uwTick++;            // HAL库的时基
12
    // FreeRTOS: xPortSysTickHandler(); // OS调度
13
}
14

15
/* HAL_Delay实现: */
11 collapsed lines
16
void HAL_Delay(uint32_t ms) {
17
    uint32_t start = uwTick;
18
    while ((uwTick - start) < ms);  // 忙等待
19
}
20

21
/* 注意:
22
 * SysTick是24位 → 最大值16777215
23
 * 168MHz时最长 ≈ 0.1秒
24
 * 用于更长延时需要软件计数
25
 * FreeRTOS占用SysTick → HAL_Delay需换其他定时器做时基
26
 */

1
/* 位带(Bit-Band): Cortex-M3/M4 特性 */
2
/* 将一个bit映射到一个32位地址, 实现原子位操作 */
3

4
/* 位带公式:
5
 * bit_word_addr = bit_band_base + (byte_offset × 32) + (bit_number × 4)
6
 *
7
 * SRAM:   bit_band_base = 0x22000000, byte_offset相对0x20000000
8
 * 外设:   bit_band_base = 0x42000000, byte_offset相对0x40000000
9
 */
10

11
#define BITBAND_SRAM(addr, bit)     (*(volatile uint32_t*)(0x22000000 + ((uint32_t)(addr)-0x20000000)*32 + (bit)*4))
12

13
#define BITBAND_PERIPH(addr, bit)     (*(volatile uint32_t*)(0x42000000 + ((uint32_t)(addr)-0x40000000)*32 + (bit)*4))
14

15
/* 使用示例: 操作GPIOA ODR的第5位 */
5 collapsed lines
16
#define PAout(n) BITBAND_PERIPH(&GPIOA->ODR, n)
17
PAout(5) = 1;    // PA5输出高 — 单次写操作, 无需读-改-写
18
PAout(5) = 0;    // PA5输出低 — 原子操作, 中断安全!
19

20
/* 优于 |= 和 &= 的方式(读-改-写非原子) */

1
Cortex-M 特权与模式:
2

3
┌─────────────┬──────────────┐
4
│ 特权级别    │ 执行模式     │
5
├─────────────┼──────────────┤
6
│ 特权(Privileged)          │
7
│  ├── 线程模式  │ 复位后默认运行在此 │
8
│  └── Handler模式│ 中断/异常处理(始终特权) │
9
├─────────────┼──────────────┤
10
│ 非特权(Unprivileged)      │
11
│  └── 线程模式  │ RTOS用户任务(受限) │
12
└─────────────┴──────────────┘
13

14
特权: 可访问所有寄存器/内存/MPU配置
15
非特权: 不能访问某些系统寄存器, 受MPU保护
9 collapsed lines
16

17
切换:
18
  特权→非特权: 修改CONTROL寄存器(MSB)
19
  非特权→特权: 只能通过SVC异常(系统调用)
20

21
RTOS利用:
22
  内核代码: 特权模式(Handler, MSP)
23
  用户任务: 非特权模式(Thread, PSP)
24
  → 任务崩溃不会破坏内核!

1
发送                        接收
2
┌─────┐   TX ──────── RX   ┌─────┐
3
│ MCU │   RX ──────── TX   │ MCU │
4
│  A  │   GND ─────── GND  │  B  │
5
└─────┘                     └─────┘
6

7
数据帧格式:
8
 ┌─────┬────────────┬──────┬─────┐
9
 │起始位│  数据位(8)  │校验位│停止位│
10
 │  0  │ D0...D7    │ 可选 │ 1/2 │
11
 └─────┴────────────┴──────┴─────┘
12

13
波特率 = 每秒传输的比特数（9600/115200 常用）

1
4线全双工:
2
  SCLK ───→ 时钟（主设备产生）
3
  MOSI ───→ 主出从入
4
  MISO ←─── 主入从出
5
  CS   ───→ 片选（低有效）
6

7
时钟极性CPOL + 相位CPHA = 4种模式:
8
  Mode 0: CPOL=0, CPHA=0  最常用
9
  Mode 1: CPOL=0, CPHA=1
10
  Mode 2: CPOL=1, CPHA=0
11
  Mode 3: CPOL=1, CPHA=1

1
// STM32 HAL库 UART中断接收
2
uint8_t rx_byte;
3
uint8_t rx_buf[256];
4
volatile uint16_t rx_len = 0;
5

6
// 启动接收
7
HAL_UART_Receive_IT(&huart1, &rx_byte, 1);
8

9
// 接收完成回调
10
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
11
    if (huart == &huart1) {
12
        rx_buf[rx_len++] = rx_byte;
13
        if (rx_len >= sizeof(rx_buf)) rx_len = 0;  // 防溢出
14
        HAL_UART_Receive_IT(&huart1, &rx_byte, 1);  // 继续接收
15
    }
8 collapsed lines
16
}
17

18
// 寄存器级(更高效):
19
void USART1_IRQHandler(void) {
20
    if (USART1->SR & USART_SR_RXNE) {
21
        rx_buf[rx_len++] = USART1->DR;  // 读DR自动清标志
22
    }
23
}

1
// DMA将内存数据发送到UART(发送)
2
DMA_HandleTypeDef hdma_usart_tx;
3
hdma_usart_tx.Instance = DMA1_Stream6;
4
hdma_usart_tx.Init.Channel = DMA_CHANNEL_4;
5
hdma_usart_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
6
hdma_usart_tx.Init.PeriphInc = DMA_PINC_DISABLE;     // 外设地址不变
7
hdma_usart_tx.Init.MemInc = DMA_MINC_ENABLE;         // 内存地址递增
8
hdma_usart_tx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
9
hdma_usart_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
10
hdma_usart_tx.Init.Mode = DMA_NORMAL;                 // 单次传输
11
hdma_usart_tx.Init.Priority = DMA_PRIORITY_MEDIUM;
12
HAL_DMA_Init(&hdma_usart_tx);
13

14
// 使用
15
HAL_UART_Transmit_DMA(&huart1, tx_data, len);

1
// STM32 ADC多通道DMA连续采集
2
uint16_t adc_buf[4];  // 4通道结果
3

4
// 配置: 扫描模式+连续转换+DMA
5
hadc.Init.ScanConvMode = ENABLE;
6
hadc.Init.ContinuousConvMode = ENABLE;
7
hadc.Init.NbrOfConversion = 4;
8
hadc.Init.DMAContinuousRequests = ENABLE;
9

10
// 配置各通道(排列顺序决定adc_buf中的位置)
11
sConfig.Channel = ADC_CHANNEL_0; sConfig.Rank = 1;
12
HAL_ADC_ConfigChannel(&hadc, &sConfig);
13
// ... 配置Channel 1,2,3
14

15
// 启动
2 collapsed lines
16
HAL_ADC_Start_DMA(&hadc, (uint32_t*)adc_buf, 4);
17
// adc_buf会被DMA自动持续更新!

1
// TIM3通道1输出1kHz,50%占空比的PWM
2
// 假设定时器时钟=72MHz
3
htim3.Init.Prescaler = 72 - 1;          // 72MHz/72 = 1MHz
4
htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
5
htim3.Init.Period = 1000 - 1;           // 1MHz/1000 = 1kHz
6
htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
7
HAL_TIM_PWM_Init(&htim3);
8

9
// 通道配置
10
sConfigOC.OCMode = TIM_OCMODE_PWM1;
11
sConfigOC.Pulse = 500;                   // CCR=500 → 50%占空比
12
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
13
HAL_TIM_PWM_ConfigChannel(&htim3, &sConfigOC, TIM_CHANNEL_1);
14

15
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_1);
3 collapsed lines
16

17
// 动态调节占空比:
18
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_1, new_duty);

1
// 用输入捕获测量外部信号频率
2
volatile uint32_t capture1 = 0, capture2 = 0;
3
volatile uint32_t frequency = 0;
4

5
void HAL_TIM_IC_CaptureCallback(TIM_HandleTypeDef *htim) {
6
    if (htim->Channel == HAL_TIM_ACTIVE_CHANNEL_1) {
7
        capture2 = HAL_TIM_ReadCapturedValue(htim, TIM_CHANNEL_1);
8
        if (capture2 > capture1) {
9
            uint32_t diff = capture2 - capture1;
10
            frequency = HAL_RCC_GetPCLK1Freq() / (htim->Init.Prescaler + 1) / diff;
11
        }
12
        capture1 = capture2;
13
    }
14
}

1
// W25Q64 SPI Flash驱动要点
2
// 1. 读ID验证连接
3
uint32_t w25q_read_id(void) {
4
    uint8_t cmd = 0x9F;
5
    uint8_t id[3];
6
    CS_LOW();
7
    HAL_SPI_Transmit(&hspi1, &cmd, 1, 100);
8
    HAL_SPI_Receive(&hspi1, id, 3, 100);
9
    CS_HIGH();
10
    return (id[0]<<16) | (id[1]<<8) | id[2];
11
}
12

13
// 2. 擦除(必须先擦后写!)
14
void w25q_erase_sector(uint32_t addr) {
15
    w25q_write_enable();
17 collapsed lines
16
    uint8_t cmd[4] = {0x20, addr>>16, addr>>8, addr};
17
    CS_LOW();
18
    HAL_SPI_Transmit(&hspi1, cmd, 4, 100);
19
    CS_HIGH();
20
    w25q_wait_busy();  // 等待完成(~几十ms)
21
}
22

23
// 3. 页编程(每次最多256字节)
24
void w25q_page_program(uint32_t addr, uint8_t *data, uint16_t len) {
25
    w25q_write_enable();
26
    uint8_t cmd[4] = {0x02, addr>>16, addr>>8, addr};
27
    CS_LOW();
28
    HAL_SPI_Transmit(&hspi1, cmd, 4, 100);
29
    HAL_SPI_Transmit(&hspi1, data, len, 100);
30
    CS_HIGH();
31
    w25q_wait_busy();
32
}

1
// 读取MPU6050加速度数据
2
#define MPU6050_ADDR  0x68
3

4
int16_t accel_x, accel_y, accel_z;
5

6
void mpu6050_read_accel(void) {
7
    uint8_t buf[6];
8
    // 从寄存器0x3B连续读取6字节(XH,XL,YH,YL,ZH,ZL)
9
    HAL_I2C_Mem_Read(&hi2c1, MPU6050_ADDR<<1, 0x3B,
10
                     I2C_MEMADD_SIZE_8BIT, buf, 6, 100);
11
    accel_x = (int16_t)(buf[0]<<8 | buf[1]);
12
    accel_y = (int16_t)(buf[2]<<8 | buf[3]);
13
    accel_z = (int16_t)(buf[4]<<8 | buf[5]);
14
}
15

6 collapsed lines
16
// 初始化: 解除睡眠
17
void mpu6050_init(void) {
18
    uint8_t data = 0x00;
19
    HAL_I2C_Mem_Write(&hi2c1, MPU6050_ADDR<<1, 0x6B,
20
                      I2C_MEMADD_SIZE_8BIT, &data, 1, 100);
21
}

1
// 独立看门狗(IWDG): LSI驱动,独立于主时钟
2
hiwdg.Instance = IWDG;
3
hiwdg.Init.Prescaler = IWDG_PRESCALER_64;   // LSI(40kHz)/64 = 625Hz
4
hiwdg.Init.Reload = 1250;                    // 1250/625 = 2秒超时
5
HAL_IWDG_Init(&hiwdg);
6

7
// 喂狗
8
HAL_IWDG_Refresh(&hiwdg);
9

10
// 窗口看门狗(WWDG): 必须在窗口期内喂狗
11
// 太早喂或太晚喂都会复位
12
hwwdg.Init.Prescaler = WWDG_PRESCALER_8;
13
hwwdg.Init.Window = 80;     // 窗口上限
14
hwwdg.Init.Counter = 127;   // 计数初值(递减到0x40时复位)
15
HAL_WWDG_Init(&hwwdg);

1
// STM32低功耗模式(由浅到深):
2
// Sleep → Stop → Standby
3

4
// Sleep模式: CPU停,外设继续
5
HAL_SuspendTick();
6
HAL_PWR_EnterSLEEPMode(PWR_MAINREGULATOR_ON, PWR_SLEEPENTRY_WFI);
7
HAL_ResumeTick();
8
// 唤醒: 任意中断
9

10
// Stop模式: 所有时钟停,HSE/HSI关闭,保留SRAM
11
HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
12
SystemClock_Config();  // 唤醒后需重新配置时钟!
13
// 唤醒: EXTI中断/RTC
14

15
// Standby模式: 最省电(~2uA),SRAM丢失
2 collapsed lines
16
HAL_PWR_EnterSTANDBYMode();
17
// 唤醒: WKUP引脚/RTC/复位 → 相当于重新启动

1
GPIO_InitTypeDef gpio;
2
gpio.Pin = GPIO_PIN_5;
3
gpio.Mode = GPIO_MODE_OUTPUT_PP;    // 推挽输出
4
gpio.Pull = GPIO_NOPULL;
5
gpio.Speed = GPIO_SPEED_FREQ_LOW;   // 低速(够用就行,减少EMI)
6
HAL_GPIO_Init(GPIOA, &gpio);

1
// 按键中断(PA0下降沿触发)
2
GPIO_InitTypeDef gpio;
3
gpio.Pin = GPIO_PIN_0;
4
gpio.Mode = GPIO_MODE_IT_FALLING;   // 下降沿触发中断
5
gpio.Pull = GPIO_PULLUP;            // 内部上拉
6
HAL_GPIO_Init(GPIOA, &gpio);
7

8
HAL_NVIC_SetPriority(EXTI0_IRQn, 2, 0);
9
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
10

11
// 中断处理
12
void EXTI0_IRQHandler(void) {
13
    HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
14
}
15

5 collapsed lines
16
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
17
    if (GPIO_Pin == GPIO_PIN_0) {
18
        // 按键处理(注意消抖!)
19
    }
20
}

1
// RTC配置(LSE 32.768kHz)
2
hrtc.Instance = RTC;
3
hrtc.Init.AsynchPrediv = 127;    // 32768/(127+1)=256Hz
4
hrtc.Init.SynchPrediv = 255;     // 256/(255+1)=1Hz
5
HAL_RTC_Init(&hrtc);
6

7
// 设置时间
8
RTC_TimeTypeDef time = {.Hours=12, .Minutes=0, .Seconds=0};
9
HAL_RTC_SetTime(&hrtc, &time, RTC_FORMAT_BIN);
10

11
// 闹钟配置(用于低功耗唤醒)
12
RTC_AlarmTypeDef alarm;
13
alarm.AlarmTime.Seconds = 30;    // 30秒后唤醒
14
alarm.AlarmMask = RTC_ALARMMASK_ALL & ~RTC_ALARMMASK_SECONDS;
15
HAL_RTC_SetAlarm_IT(&hrtc, &alarm, RTC_FORMAT_BIN);

1
hcan.Instance = CAN1;
2
hcan.Init.Prescaler = 6;           // 48MHz/6=8MHz Tq
3
hcan.Init.Mode = CAN_MODE_NORMAL;
4
hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
5
hcan.Init.TimeSeg1 = CAN_BS1_13TQ;
6
hcan.Init.TimeSeg2 = CAN_BS2_2TQ;  // 8M/(1+13+2)=500kbps
7
hcan.Init.AutoBusOff = DISABLE;
8
hcan.Init.AutoRetransmission = ENABLE;
9
HAL_CAN_Init(&hcan);
10

11
// 发送
12
CAN_TxHeaderTypeDef tx_header;
13
tx_header.StdId = 0x123;
14
tx_header.IDE = CAN_ID_STD;
15
tx_header.RTR = CAN_RTR_DATA;
3 collapsed lines
16
tx_header.DLC = 8;
17
uint32_t mailbox;
18
HAL_CAN_AddTxMessage(&hcan, &tx_header, tx_data, &mailbox);

1
// TIM6做1ms基本定时中断
2
htim6.Instance = TIM6;
3
htim6.Init.Prescaler = 72 - 1;      // 72MHz/72=1MHz
4
htim6.Init.Period = 1000 - 1;       // 1MHz/1000=1kHz=1ms
5
HAL_TIM_Base_Init(&htim6);
6
HAL_TIM_Base_Start_IT(&htim6);
7

8
volatile uint32_t tick_ms = 0;
9

10
void TIM6_IRQHandler(void) {
11
    HAL_TIM_IRQHandler(&htim6);
12
}
13

14
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim) {
15
    if (htim == &htim6) tick_ms++;
6 collapsed lines
16
}
17

18
void delay_ms(uint32_t ms) {
19
    uint32_t start = tick_ms;
20
    while (tick_ms - start < ms);
21
}

1
// 方法1: 重写fputc(标准库)
2
int fputc(int ch, FILE *f) {
3
    HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 10);
4
    return ch;
5
}
6

7
// 方法2: syscalls重写_write(GCC/Newlib)
8
int _write(int fd, char *ptr, int len) {
9
    HAL_UART_Transmit(&huart1, (uint8_t*)ptr, len, 100);
10
    return len;
11
}
12

13
// 使用:
14
printf("Temperature: %.1f C\n", temp);

1
// STM32内部Flash写入(保存配置参数)
2
void flash_write_config(uint32_t addr, uint32_t *data, uint16_t len) {
3
    HAL_FLASH_Unlock();
4

5
    // 先擦除(整页)
6
    FLASH_EraseInitTypeDef erase;
7
    erase.TypeErase = FLASH_TYPEERASE_PAGES;
8
    erase.PageAddress = addr;
9
    erase.NbPages = 1;
10
    uint32_t error;
11
    HAL_FLASHEx_Erase(&erase, &error);
12

13
    // 逐字编程
14
    for (int i = 0; i < len; i++) {
15
        HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, addr + i*4, data[i]);
5 collapsed lines
16
    }
17

18
    HAL_FLASH_Lock();
19
}
20
// 注意: 不能在执行中的Flash上擦写(除非代码在RAM中运行)