PY32F030 on CLing

PUYA ADC — 软件触发单次转换（多通道）

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 软件触发单次转换（多通道）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/ADC/ADC_MultiChannelSingleConversion_TriggerSW/Src/main.c

功能简介

ADC（模数转换器）把引脚上的模拟电压转换成数字量，是读取电位器、温湿度、光照等模拟传感器的基础。

本示例演示软件触发 + 单次转换 + 轮询等待的经典用法：

配置 ADC1，12 位分辨率，扫描通道 0、1、4；
上电后先做校准（Calibration），再用 HAL_ADC_Start() 由软件启动一次转换；
用 HAL_ADC_PollForConversion() 轮询等待转换结束，读取结果；
通过串口（USART2，PA2/PA3，115200）把采样值打印出来。

文件名虽带 MultiChannel，但 ContinuousConvMode = DISABLE、ExternalTrigConv = ADC_SOFTWARE_START，本质就是“软件触发、扫描多个通道、各转换一次”的模式，最贴合“软件触发单次转换”的教学需求。

硬件准备

PY32F030 开发板
可调电位器（中间抽头接 PA0 / PA1 / PA4 任一处）或信号源
串口调试工具（USB 转串口接 PA2=TX、PA3=RX，波特率 115200）
板载串口打印由 BSP_USART_Config() 初始化（见 py32f030xx_Start_Kit.c）

完整代码

#include "main.h"

/* ADC 句柄与通道配置、保存 3 路采样值 */
ADC_HandleTypeDef       AdcHandle;
ADC_ChannelConfTypeDef  sConfig;
uint32_t adc_value[3];

/* 静态函数声明 */
static void APP_AdcInit(void);

int main(void)
{
  /* 1. HAL 初始化（含 SysTick 时基） */
  HAL_Init();

  /* 2. 初始化 ADC（含校准） */
  APP_AdcInit();

  /* 3. 初始化调试串口（printf 重定向到 USART2） */
  DEBUG_USART_Config();

  while (1)
  {
    /* 4. 软件启动一次 ADC 转换 */
    HAL_ADC_Start(&AdcHandle);

    for (uint8_t i = 0; i < 3; i++)
    {
      /* 5. 轮询等待本通道转换完成（超时 10000ms） */
      HAL_ADC_PollForConversion(&AdcHandle, 10000);
      /* 6. 读取转换结果（12 位，右对齐） */
      adc_value[i] = HAL_ADC_GetValue(&AdcHandle);
      printf("adc[%u]:%u\r\n", i, (unsigned int)adc_value[i]);
    }

    HAL_Delay(1000);   /* 每秒采样一轮 */
  }
}

/**
  * @brief  ADC 初始化：先复位与校准，再配时钟/分辨率/通道
  */
static void APP_AdcInit(void)
{
  /* 复位 ADC 外设，保证起始状态干净 */
  __HAL_RCC_ADC_FORCE_RESET();
  __HAL_RCC_ADC_RELEASE_RESET();
  __HAL_RCC_ADC_CLK_ENABLE();                    /* 开启 ADC 时钟 */

  AdcHandle.Instance = ADC1;
  /* 上电校准：必须在使用 ADC 前执行，否则精度受影响 */
  if (HAL_ADCEx_Calibration_Start(&AdcHandle) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  AdcHandle.Instance = ADC1;
  AdcHandle.Init.ClockPrescaler      = ADC_CLOCK_SYNC_PCLK_DIV4;   /* ADC 时钟 = PCLK/4 */
  AdcHandle.Init.Resolution          = ADC_RESOLUTION_12B;         /* 12 位分辨率 */
  AdcHandle.Init.DataAlign           = ADC_DATAALIGN_RIGHT;        /* 数据右对齐 */
  AdcHandle.Init.ScanConvMode        = ADC_SCAN_DIRECTION_FORWARD; /* 按通道号顺序扫描 */
  AdcHandle.Init.EOCSelection        = ADC_EOC_SINGLE_CONV;        /* 每完成一次转换产生 EOC */
  AdcHandle.Init.LowPowerAutoWait    = ENABLE;                     /* 等待转换模式，省功耗 */
  AdcHandle.Init.ContinuousConvMode  = DISABLE;                    /* 单次转换（不连续） */
  AdcHandle.Init.DiscontinuousConvMode = DISABLE;                  /* 关闭间断模式 */
  AdcHandle.Init.ExternalTrigConv    = ADC_SOFTWARE_START;         /* 软件触发 */
  AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; /* 无外部触发边沿 */
  AdcHandle.Init.DMAContinuousRequests = DISABLE;                  /* 不使用 DMA */
  AdcHandle.Init.Overrun             = ADC_OVR_DATA_OVERWRITTEN;   /* 溢出时覆盖旧值 */
  AdcHandle.Init.SamplingTimeCommon  = ADC_SAMPLETIME_239CYCLES_5; /* 采样时间 239.5 周期 */
  if (HAL_ADC_Init(&AdcHandle) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  /* 依次把通道 0、1、4 加入扫描序列（Rank 方式排队） */
  sConfig.Channel = ADC_CHANNEL_0;
  sConfig.Rank    = ADC_RANK_CHANNEL_NUMBER;
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) APP_ErrorHandler();

  sConfig.Channel = ADC_CHANNEL_1;
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) APP_ErrorHandler();

  sConfig.Channel = ADC_CHANNEL_4;
  if (HAL_ADC_ConfigChannel(&AdcHandle, &sConfig) != HAL_OK) APP_ErrorHandler();
}

void APP_ErrorHandler(void)
{
  while (1) {}
}

代码分段讲解

1. 校准与时钟

PY32F0xx 的 SAR ADC 上电后必须执行 HAL_ADCEx_Calibration_Start() 消除内部失调，否则读数偏差很大。ADC 时钟通过 ADC_CLOCK_SYNC_PCLK_DIV4 分频得到，需满足数据手册规定的最大 ADC 时钟（通常 ≤ 16MHz）。

2. 软件触发 vs 硬件触发

ExternalTrigConv = ADC_SOFTWARE_START 表示转换由 HAL_ADC_Start() 启动；若用定时器触发，则设为 ADC_EXTERNALTRIGCONV_Tx_TRGO 等并配置边沿。教学阶段用软件触发最简单直观。

3. 单次 / 连续 / 扫描

ContinuousConvMode = DISABLE：每调用一次 HAL_ADC_Start() 只转换一轮（这里 3 个通道各一次）。
ScanConvMode = FORWARD：多通道时按 Rank 顺序自动切换通道。
每个通道转换完都会置 EOC，HAL_ADC_PollForConversion() 就是在等这个标志。

4. 结果换算

12 位右对齐时，读数与电压关系为：

`1`	`电压(V) = 读数 / 4095 × VREF+`

PY32F030 内部参考电压 VREF+ 一般等于 VDDA（多为 3.3V）。

实验现象

串口助手（115200-8-N-1）每秒打印一次：
1 2 3

adc[0]:1234 adc[1]:2047 adc[2]:888
转动接在 PA0/PA1/PA4 的电位器，对应通道数值随之变化（0~4095）。

常见问题

读数一直是 0 或 4095（满偏）？
- 检查引脚是否真的接到模拟信号；悬空输入会被上/下拉拉到极端值。
- 确认 VREF+/VDDA 供电正常。
读数跳动很大？
- 增大 SamplingTimeCommon（采样时间），给内部采样电容更长的充电时间；信号源内阻大时尤其需要。
- 软件上可做多次采样取平均。
想用 DMA 自动搬运多路数据？
- 参考同目录 ADC_ContinuousConversion_DMA，把 DMAContinuousRequests 打开并用 HAL_ADC_Start_DMA()。
想固定单通道采样？
- 只 ConfigChannel 一个通道即可，for 循环删掉多余通道。

小结

ADC 标准流程：开时钟 → 校准 → 配参数 → 配通道 → 启动 → 等待 EOC → 读值。
软件触发 + 轮询是最易理解的入门方式；对实时性要求高时用定时器触发 + DMA。
12 位分辨率下满量程 4095，注意参考电压与采样时间对精度的影响。

拓展应用

接 NTC 热敏电阻做温度计（查表/公式换算温度）。
接光敏电阻做光照检测，配合 PWM 自动调光。
用 DMA + 定时器触发做“示波器”式连续采样，再用串口绘图。
读取内部 ADC_CHANNEL_VREFINT（参考电压）与 ADC_CHANNEL_TEMPSENSOR（温度）做自校准/测温。

PUYA DMA — 内存到内存搬运（SRAM→SRAM）（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

DMA — 内存到内存搬运（SRAM → SRAM）（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/DMA/DMA_SramToSram/Src/main.c

功能简介

DMA（Direct Memory Access，直接存储器访问）允许在不占用 CPU 的情况下让数据在存储器之间或存储器与外设之间自动搬运。CPU 只需“下单”，DMA 控制器在后台搬运，搬完产生中断通知 CPU。

本示例演示最直观的 内存→内存（Memory-to-Memory） 模式：

在源缓冲 aSRC_Const_Buffer[32] 填入 0,1,2,…31；
启动 DMA 把 32 个 32 位字 搬到 aDST_Buffer[32]；
用传输完成中断回调校验数据是否一致；
一致则点亮绿灯，不一致/出错则闪烁报警。

BUFFER_SIZE 在 main.h 中定义为 32。这是理解“DMA 替 CPU 干活”的最佳入门示例；后面接 ADC/SPI 时都是同样的套路，只是源/目的换成外设寄存器。

硬件准备

PY32F030 开发板
板载 LED（观察结果）
无需外接，纯内部 SRAM 搬运

完整代码

#include "main.h"

DMA_HandleTypeDef DmaHandle;
uint32_t aSRC_Const_Buffer[BUFFER_SIZE];  /* 源缓冲 */
uint32_t aDST_Buffer[BUFFER_SIZE];        /* 目的缓冲 */
__IO uint32_t transferCompleteDetected = 0; /* 传输完成标志 */
__IO uint32_t transferErrorDetected    = 0; /* 传输错误标志 */
__IO uint32_t transferFailedDetected   = 0; /* 数据校验失败标志 */

int main(void)
{
  HAL_Init();
  BSP_LED_Init(LED_GREEN);

  /* 准备源数据 0~31 */
  for (uint8_t i = 0; i < BUFFER_SIZE; i++)
    aSRC_Const_Buffer[i] = i;

  APP_DmaConfig();  /* 配置并注册回调、使能中断 */

  /* 启动 DMA 传输（中断方式，CPU 立即返回） */
  if (HAL_DMA_Start_IT(&DmaHandle,
                       (uint32_t)&aSRC_Const_Buffer,  /* 源地址 */
                       (uint32_t)&aDST_Buffer,        /* 目的地址 */
                       BUFFER_SIZE) != HAL_OK)        /* 传输个数（单位=数据宽度） */
  {
    APP_ErrorHandler();
  }

  while (1)
  {
    if (transferFailedDetected == 1 && transferCompleteDetected == 1)
    {
      while (1) { BSP_LED_Toggle(LED_GREEN); HAL_Delay(500); } /* 数据错：快闪 */
    }
    if (transferFailedDetected == 0 && transferCompleteDetected == 1)
    {
      BSP_LED_On(LED_GREEN);   /* 成功：绿灯常亮 */
      while (1) {}
    }
    if (transferErrorDetected == 1)
    {
      BSP_LED_On(LED_GREEN);
      while (1) { BSP_LED_Toggle(LED_GREEN); HAL_Delay(500); } /* 出错：闪烁 */
    }
  }
}

/**
  * @brief  DMA 配置
  */
static void APP_DmaConfig(void)
{
  __HAL_RCC_DMA_CLK_ENABLE();                 /* 开启 DMA 时钟 */

  DmaHandle.Init.Direction           = DMA_MEMORY_TO_MEMORY;  /* 内存到内存 */
  DmaHandle.Init.PeriphInc           = DMA_PINC_ENABLE;       /* 外设(源)地址自增 */
  DmaHandle.Init.MemInc              = DMA_MINC_ENABLE;       /* 内存(目的)地址自增 */
  DmaHandle.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;   /* 源数据宽度 32 位 */
  DmaHandle.Init.MemDataAlignment    = DMA_MDATAALIGN_WORD;   /* 目的数据宽度 32 位 */
  DmaHandle.Init.Mode                = DMA_NORMAL;            /* 普通模式（非循环） */
  DmaHandle.Init.Priority            = DMA_PRIORITY_HIGH;     /* 通道优先级高 */

  DmaHandle.Instance = DMA1_Channel1;          /* 使用 DMA1 通道 1 */
  if (HAL_DMA_Init(&DmaHandle) != HAL_OK) APP_ErrorHandler();

  /* 注册“传输完成”和“传输错误”两个回调 */
  HAL_DMA_RegisterCallback(&DmaHandle, HAL_DMA_XFER_CPLT_CB_ID,  APP_TransferComplete);
  HAL_DMA_RegisterCallback(&DmaHandle, HAL_DMA_XFER_ERROR_CB_ID, APP_TransferError);
  HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);      /* 使能 DMA 中断 */
}

/* 传输完成回调：校验数据 */
static void APP_TransferComplete(DMA_HandleTypeDef *DmaHandle)
{
  for (uint16_t i = 0; i < BUFFER_SIZE; i++)
  {
    if (aDST_Buffer[i] != aSRC_Const_Buffer[i])
    {
      transferFailedDetected = 1;
      break;
    }
  }
  transferCompleteDetected = 1;
}

/* 传输错误回调 */
static void APP_TransferError(DMA_HandleTypeDef *DmaHandle)
{
  transferErrorDetected = 1;
}

代码分段讲解

1. 地址自增与数据宽度

PeriphInc / MemInc = ENABLE：搬运时源、目的地址都自动 +1（按数据宽度递增）。若对固定寄存器（如 USART TDR）搬运，应把对应端设为 DISABLE。
PDATAALIGN_WORD / MDATAALIGN_WORD：每次搬 4 字节。传输个数 BUFFER_SIZE 的单位是“次”，不是字节；32 字 × 4 = 128 字节。

2. 模式 Normal vs Circular

DMA_NORMAL：搬完一次即停。
DMA_CIRCULAR：搬完自动从头再来，常用于 DAC 波形输出、ADC 连续采样等持续场景。

3. 中断回调

HAL_DMA_Start_IT 启动后 CPU 立刻返回，搬运在后台进行；完成后硬件触发 DMA1_Channel1_IRQn，HAL 在中断里调用你注册的 APP_TransferComplete。这就是 DMA “解放 CPU” 的核心。

实验现象

DMA 在后台把 32 个字从源搬到目的；
校验一致：绿灯常亮；不一致或出错：绿灯闪烁。

常见问题

编译报 BUFFER_SIZE 未定义？
- 它在 main.h（#define BUFFER_SIZE 32）中，确认工程包含该头文件。
传输没完成/不进回调？
- 确认 __HAL_RCC_DMA_CLK_ENABLE() 已调用，且 HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn) 已使能。
- 确认 DMA1_Channel1_IRQHandler 在 startup 中正确指向 HAL 的中断处理（库工程默认已连）。
数据错位？
- 检查源/目的地址自增与数据宽度是否匹配；外设寄存器做源/目的时要把对应端 Inc 设为 DISABLE。
想连续搬运？
- 把 Mode 改为 DMA_CIRCULAR，并配合外设（如 ADC/DAC）使用。

小结

DMA 四要素：方向、地址自增、数据宽度、模式（普通/循环）。
内存↔内存、内存↔外设都用同一套 HAL_DMA_* API，区别只在地址与 Inc 配置。
中断方式让 CPU “下单后就去干别的”，搬完由回调通知，是提升效率的关键。

拓展应用

ADC_ContinuousConversion_DMA：ADC 连续采样，DMA 自动把结果搬进数组。
SPI/DMA（见 SPI_TwoBoards_FullDuplexMaster_DMA）：大批量 SPI 数据后台收发。
DMA_CIRCULAR + DAC：播放波形/音频。
双缓冲（Double Buffer）：一边 DMA 搬当前块，CPU 处理上一块，实现零等待流式处理。

PUYA FLASH — 页擦除与写入（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

FLASH — 页擦除与写入（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/FLASH/FLASH_PageEraseAndWrite/Src/main.c

功能简介

MCU 的内部 Flash 不仅能存放程序，也可以像 EEPROM 一样保存掉电不丢失的用户数据（配置参数、校准值、计数器等）。

PY32F0xx 的 Flash 写入有铁律：只能把 1 写成 0，不能把 0 写成 1；要改数据必须先整页擦除（擦除后全为 0xFF）。本示例完整演示标准流程：

等待用户按键（避免每次上电都擦写，延长 Flash 寿命）；
解锁 Flash；
页擦除 目标地址；
校验空白（应为 0xFFFFFFFF）；
按页编程 写入 64 个 32 位数据；
加锁 Flash；
回读校验，一致则点亮绿灯。

目标地址 FLASH_USER_START_ADDR = 0x08004000（避开存放用户代码的前几页）。DATA[64] 为待写入的 256 字节测试数据。

硬件准备

PY32F030 开发板
板载 LED 与用户键（用于触发与指示）
注意：此操作会改写 Flash 内容，务必确保 0x08004000 之后没有你的程序/数据，否则可能被覆盖！

完整代码

#include "main.h"
#include "py32f030xx_Start_Kit.h"

#define FLASH_USER_START_ADDR   0x08004000   /* 用户数据起始地址（避开代码区） */

const uint32_t DATA[64] = { /* 256 字节测试数据，略 */ };

int main(void)
{
  HAL_Init();
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);
  BSP_LED_Init(LED_GREEN);
  APP_SystemClockConfig();          /* 系统时钟：HSI 24MHz */

  /* 等用户按键，防止每次复位都擦写 Flash */
  while (BSP_PB_GetState(BUTTON_USER)) {}

  HAL_FLASH_Unlock();               /* 1. 解锁 Flash（写/擦前必须） */
  APP_FlashErase();                 /* 2. 页擦除 */
  APP_FlashBlank();                 /* 3. 校验是否为空白（全 0xFF） */
  APP_FlashProgram();               /* 4. 按页编程写入 */
  HAL_FLASH_Lock();                 /* 5. 加锁 Flash */
  APP_FlashVerify();                /* 6. 回读校验 */

  BSP_LED_On(LED_GREEN);            /* 成功：绿灯常亮 */
  while (1) {}
}

/* 页擦除 */
static void APP_FlashErase(void)
{
  uint32_t PAGEError = 0;
  FLASH_EraseInitTypeDef EraseInitStruct = {0};

  EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGEERASE;     /* 页擦除 */
  EraseInitStruct.PageAddress = FLASH_USER_START_ADDR;         /* 起始页地址 */
  EraseInitStruct.NbPages     = sizeof(DATA) / FLASH_PAGE_SIZE;/* 需要擦除的页数 */
  if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
    APP_ErrorHandler();   /* PAGEError 为出错页地址，成功则 0xFFFFFFFF */
}

/* 按页编程：每次写一整页 FLASH_PAGE_SIZE 字节 */
static void APP_FlashProgram(void)
{
  uint32_t flash_program_start = FLASH_USER_START_ADDR;
  uint32_t flash_program_end   = FLASH_USER_START_ADDR + sizeof(DATA);
  uint32_t *src = (uint32_t *)DATA;

  while (flash_program_start < flash_program_end)
  {
    /* 注意：PY32F0xx 以“页”为编程单位（FLASH_TYPEPROGRAM_PAGE） */
    if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_PAGE, flash_program_start, src) == HAL_OK)
    {
      flash_program_start += FLASH_PAGE_SIZE;  /* 源/目的指针同步推进一页 */
      src += FLASH_PAGE_SIZE / 4;
    }
  }
}

/* 校验擦除后是否为空白 */
static void APP_FlashBlank(void)
{
  uint32_t addr = 0;
  while (addr < sizeof(DATA))
  {
    if (0xFFFFFFFF != HW32_REG(FLASH_USER_START_ADDR + addr))
      APP_ErrorHandler();   /* 非空说明擦除失败 */
    addr += 4;
  }
}

/* 回读校验写入是否正确 */
static void APP_FlashVerify(void)
{
  uint32_t addr = 0;
  while (addr < sizeof(DATA))
  {
    if (DATA[addr / 4] != HW32_REG(FLASH_USER_START_ADDR + addr))
      APP_ErrorHandler();
    addr += 4;
  }
}

代码分段讲解

1. 解锁与加锁

Flash 是“危险”资源，HAL 默认禁止写。任何擦/写前必须 HAL_FLASH_Unlock()，操作完 HAL_FLASH_Lock() 重新保护。忘记解锁会直接返回错误。

2. 擦除单位：页（Page）

PY32F0xx Flash 以页为单位擦除（每页大小由 FLASH_PAGE_SIZE 定义，不同容量芯片不同，常见 1KB/2KB）。不能只擦一个字节——擦除会把整页恢复成 0xFF。

3. 编程单位

本系列 HAL_FLASH_Program 使用 FLASH_TYPEPROGRAM_PAGE（按页写入），一次把一整页数据烧入。写入前该页必须已擦除。

4. 为什么要等按键

Flash 有擦写寿命（约 1 万次）。若程序一上电就擦写，反复复位会迅速耗尽寿命。正式用法应在“确实需要保存新数据”时才写，并尽量** wear leveling**（磨损均衡）。

5. 地址安全

0x08004000 要位于用户代码占用区之后。查看工程链接脚本（.ld / Option Bytes）确认你的程序大小，避免覆盖。

实验现象

按用户键后开始擦写；
成功回读一致，绿灯常亮；任一环节失败则卡在 APP_ErrorHandler（可加 LED 提示定位）。

常见问题

HAL_FLASH_Program 返回错误？
- 目标页未先擦除（仍有 0）→ 必须先 HAL_FLASHEx_Erase。
- 未调用 HAL_FLASH_Unlock()。
数据回读不对？
- 编程地址与读取地址不一致；或 src 指针推进量算错（应 FLASH_PAGE_SIZE/4 个 32 位）。
- 写入单位（FLASH_TYPEPROGRAM_PAGE）与页大小不匹配。
程序跑飞/变砖？
- 写入地址覆盖了中断向量表或代码区。务必选在代码末端之后的空闲页；必要时先备份。
想存少量参数？
- 不必每次整页擦。可把一页划成“多槽”，每次找空白槽追加写，写满再整页擦（磨损均衡）。

小结

Flash 操作流程固定：解锁 → 页擦除 →（校验空白）→ 编程 → 加锁 → 回读校验。
核心规则：先擦后写、按页操作、擦除即整页 0xFF。
操作有寿命限制，不可频繁擦写，注意地址安全与磨损均衡。

拓展应用

保存用户配置（如校准系数、设备 ID、工作模式）实现掉电记忆。
实现简易“EEPROM 模拟”：一页多槽 + 磨损均衡。
配合“bootloader”做固件备份/升级（双 bank）。
存运行计数/累计时长等需掉电保留的统计量。

PUYA GPIO — GPIO 翻转输出（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

GPIO — GPIO 翻转输出（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/GPIO/GPIO_Toggle/Src/main.c

功能简介

本示例演示如何让一个 GPIO 引脚工作于推挽输出模式，并在主循环中周期性翻转其电平。GPIO（通用输入输出）是 MCU 最基础、最常用的外设，所有“点灯”“驱动继电器”“软件模拟时序”都建立在它之上。

示例中 LED 连接在 PA11（开发板丝印 LED3），程序每 250ms 翻转一次该引脚，人眼即可看到 LED 闪烁。

硬件准备

PY32F030 开发板（或 PY32F002A / F003 官方 STK 板）
板载 LED（PA11，对应 LED3）
一根 USB 数据线用于供电与下载
无需额外外接元件

提示：如果你手上的板子 LED 不在 PA11，请修改下方宏定义中的引脚即可。

完整代码

#include "main.h"

/* 把板载 LED3 映射成一组好记的宏，方便后续修改 */
#define LED_GPIO_PIN          LED3_PIN          /* LED 引脚：PA11 */
#define LED_GPIO_PORT         LED3_GPIO_PORT    /* LED 端口：GPIOA */
#define LED_GPIO_CLK_ENABLE() LED3_GPIO_CLK_ENABLE() /* 开启 GPIOA 时钟 */

/* 静态函数声明：GPIO 初始化 */
static void APP_GpioConfig(void);

int main(void)
{
  /* 1. 复位所有外设，并初始化 HAL 库与 SysTick 时基 */
  HAL_Init();

  /* 2. 配置 LED 引脚为推挽输出 */
  APP_GpioConfig();

  /* 3. 主循环：每 250ms 翻转一次 LED 电平 */
  while (1)
  {
    HAL_Delay(250);                              /* 阻塞延时 250ms */
    HAL_GPIO_TogglePin(LED_GPIO_PORT, LED_GPIO_PIN); /* 翻转引脚电平 */
  }
}

/**
  * @brief  GPIO 引脚配置函数
  */
static void APP_GpioConfig(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  LED_GPIO_CLK_ENABLE();                        /* 必须先开时钟，否则配置无效 */

  GPIO_InitStruct.Pin   = LED_GPIO_PIN;
  GPIO_InitStruct.Mode  = GPIO_MODE_OUTPUT_PP;  /* 推挽输出模式 */
  GPIO_InitStruct.Pull  = GPIO_PULLUP;          /* 启用上拉 */
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; /* 引脚翻转速度：高速 */
  HAL_GPIO_Init(LED_GPIO_PORT, &GPIO_InitStruct);
}

/**
  * @brief  错误处理：卡死在此处便于调试
  */
void APP_ErrorHandler(void)
{
  while (1)
  {
  }
}

代码分段讲解

1. 时钟使能

LED_GPIO_CLK_ENABLE() 展开为 __HAL_RCC_GPIOA_CLK_ENABLE()。在 PY32（与 STM32 一致）中，任何外设使用前都必须先开启其时钟，否则写寄存器无效。这是初学者最容易遗漏的一步。

2. 引脚模式

GPIO_MODE_OUTPUT_PP：推挽输出。输出高电平时由 VDD 驱动，输出低电平时由内部 NMOS 拉到 GND，驱动能力较强，适合直接驱动 LED。
与之相对的 GPIO_MODE_OUTPUT_OD 为开漏输出，常用于 I2C 等需要“线与”的总线。

3. 翻转与延时

HAL_GPIO_TogglePin()：读取引脚当前电平后取反再写回，是最常用的“闪烁”原语。
HAL_Delay(250)：基于 SysTick 的毫秒级阻塞延时，由 HAL_Init() 内部完成初始化。注意它是阻塞的，期间 CPU 不能做别的事（真实项目推荐用定时器中断替代）。

实验现象

板载 LED（PA11）以约 2Hz（每 250ms 一次）的频率闪烁。
用示波器/逻辑分析仪测量 PA11，可见周期为 500ms 的方波。

常见问题

下载后 LED 不闪？
- 确认引导/下载模式与复位电路正常；确认 LED 实际连接引脚与代码中 LED3_PIN 一致（不同板型可能接在 PB0 / PB1 / PA5）。
- 检查是否选择了正确的芯片型号（PY32F030x8），Flash 容量不同会导致下载失败。
编译报 LED3_PIN 未定义？
- 该宏定义在 Drivers/BSP/PY32F030xx_Start_Kit/py32f030xx_Start_Kit.h 中，确认工程已包含该 BSP 头文件。
闪烁很快/很慢？
- 直接调整 HAL_Delay() 的参数；若使用内部 HSI 且频率与工程设定不一致，实际延时会有偏差。
想用定时器非阻塞闪烁？
- 参考同系列 TIMERx 示例，用定时器更新中断翻转引脚，主循环可空出来做其他任务。

小结

GPIO 输出只需三步：开时钟 → 配置引脚模式 → 写/翻转电平。
HAL_GPIO_TogglePin() + HAL_Delay() 是最简单的闪烁模板，适合作为每个新板子的“点灯”验证程序。
推挽输出（OUTPUT_PP）适合直接驱动 LED；开漏输出（OUTPUT_OD）适合总线应用。

拓展应用

把 HAL_Delay 换成定时器中断，实现“非阻塞”多任务闪烁（如多个 LED 不同频率）。
读取按键（GPIO_INPUT + HAL_GPIO_ReadPin）实现“按键控制 LED 亮灭”。
用 GPIO_SPEED_FREQ_VERY_HIGH 配合精确延时，用单引脚“软”模拟单总线协议（如 DHT11、WS2812）。
结合 PWM（见 TIM1_PWM 示例）做 LED 呼吸灯。

PUYA I2C — 主机轮询通信（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

I2C — 主机轮询通信（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/I2C/I2C_TwoBoard_CommunicationMaster_Polling/Src/main.c

功能简介

I2C（Inter-Integrated Circuit）是一种两线制（SCL 时钟 + SDA 数据）、半双工、一主多从的串行总线，常用于连接 EEPROM、传感器、OLED 屏等。

本示例演示主机（Master）工作方式：

主机先向从机地址 0xA0 发送 15 字节；
再向同一地址接收 15 字节（示例用两块板回环对接，从机把收到的数据原样发回）；
CPU 用轮询方式等待每笔传输完成（HAL_I2C_Master_Transmit/Receive 内部即轮询）；
收发一致则点亮绿灯，不一致则闪烁报警。

虽然工程里函数名带 Master，实际传输由 HAL_I2C_Master_Transmit/Receive 完成，内部是轮询等待，符合“主机轮询通信”的教学目标。

硬件准备

两块 PY32F030 开发板（一主一从），或用一块板把 SDA/SCL 自连做回环
SCL、SDA 各接 4.7kΩ 上拉电阻到 VDD（I2C 开漏总线必须上拉）
交叉连接：主 SCL↔从 SCL，主 SDA↔从 SDA，共地
串口/LED 用于观察结果

完整代码（主机部分）

#include "main.h"

#define DATA_LENGTH      15                /* 数据长度 */
#define I2C_ADDRESS      0xA0              /* 从机地址（7 位地址左移后的写地址） */
#define I2C_SPEEDCLOCK   100000           /* 通信速率 100K */
#define I2C_DUTYCYCLE    I2C_DUTYCYCLE_16_9 /* 快速模式占空比 */

I2C_HandleTypeDef I2cHandle;
uint8_t aTxBuffer[15] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t aRxBuffer[15] = {0};

int main(void)
{
  HAL_Init();

  /* 初始化 LED 与按键 */
  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  /* I2C 参数配置 */
  I2cHandle.Instance           = I2C;             /* PY32F0xx 的 I2C 外设名 */
  I2cHandle.Init.ClockSpeed    = I2C_SPEEDCLOCK;   /* 100K */
  I2cHandle.Init.DutyCycle     = I2C_DUTYCYCLE;    /* 快速模式占空比 */
  I2cHandle.Init.OwnAddress1   = I2C_ADDRESS;      /* 自身地址（主模式可不严格） */
  I2cHandle.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  I2cHandle.Init.NoStretchMode   = I2C_NOSTRETCH_DISABLE; /* 允许时钟拉伸 */
  if (HAL_I2C_Init(&I2cHandle) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  /* 等待用户按键按下，再开始通信（避免一上电就发） */
  while (BSP_PB_GetState(BUTTON_KEY) == 1) {}

  /* 主机发送 15 字节，超时 5000ms */
  while (HAL_I2C_Master_Transmit(&I2cHandle, I2C_ADDRESS,
                                 (uint8_t *)aTxBuffer, DATA_LENGTH, 5000) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY); /* 等发送完成 */

  /* 主机接收 15 字节 */
  while (HAL_I2C_Master_Receive(&I2cHandle, I2C_ADDRESS,
                                (uint8_t *)aRxBuffer, DATA_LENGTH, 5000) != HAL_OK)
  {
    APP_ErrorHandler();
  }
  while (HAL_I2C_GetState(&I2cHandle) != HAL_I2C_STATE_READY);

  /* 校验收发数据 */
  APP_CheckEndOfTransfer();

  while (1) {}
}

/* 比较发送与接收缓冲；一致亮灯，否则闪烁 */
static void APP_CheckEndOfTransfer(void)
{
  if (APP_Buffercmp8((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, DATA_LENGTH))
    APP_LedBlinking();
  else
    BSP_LED_On(LED_GREEN);
}

代码分段讲解

1. 地址说明

I2C_ADDRESS = 0xA0 是含读写位的 8 位地址（即 7 位地址 0x50 左移 1 位）。HAL 的 HAL_I2C_Master_Transmit/Receive 内部会自动根据读/写把最低位置 0/1，调用时直接传 0xA0 即可（底层会有兼容处理）。实际对接外部芯片时，请以其数据手册给出的 7 位地址为准。

2. 速率与占空比

ClockSpeed = 100000：标准模式 100kbps；可改 400000 进入快速模式。
快速模式下 DutyCycle 控制 SCL 高低电平比（16_9 或 2）。

3. 轮询方式

HAL_I2C_Master_Transmit(..., Timeout) 内部不断查询状态寄存器直到完成或超时，期间 CPU 被占用，简单但效率低。对性能敏感的场景可改用 IT（中断）或 DMA 版本（同目录有 I2C_TwoBoard_CommunicationMaster_IT / _DMA）。

4. 时钟拉伸

NoStretchMode = DISABLE 表示允许从机在忙时拉低 SCL（时钟拉伸），这是 I2C 规范允许的流控机制，绝大多数从机需要。

实验现象

按下用户键后，主机发送 1~15；
若从机把数据原样返回，主机收到一致数据，绿灯常亮；
若数据不一致或总线异常，绿灯以 500ms 周期闪烁报警。

常见问题

总线卡死 / 收不到数据？
- SCL、SDA 必须有上拉电阻（4.7kΩ 到 VDD），开漏总线无上拉无法拉高。
- 检查接线：SCL↔SCL、SDA↔SDA、主从共地。
- 确认从机地址与数据手册一致（区分 7 位 / 8 位地址）。
HAL_I2C_Master_Transmit 返回 HAL_BUSY/HAL_TIMEOUT？
- 总线可能被某次异常拉低（SDA 卡在低）。可尝试复位或从机重新上电。
- 适当增大 Timeout（如 5000ms）。
写 EEPROM 后马上读不到？
- EEPROM 写周期约 5ms，需在写后延时再读。
如何只读单字节传感器（如温湿度）？
- 先 HAL_I2C_Master_Transmit 发寄存器地址，再 HAL_I2C_Master_Receive 读数据（即“写寄存器指针 + 读数据”组合）。

小结

I2C 主机轮询三步：初始化 HAL_I2C_Init → Master_Transmit 发 → Master_Receive 收。
总线必须上拉，地址要与从机匹配，主从共地。
轮询版代码最简单，适合初学；追求效率改用 IT/DMA 版。

拓展应用

驱动 OLED（SSD1306）、AT24Cxx EEPROM、各类 I2C 传感器（BMP280、SHT30）。
一主多从：用不同从机地址挂多个设备，轮流访问。
用 HAL_I2C_Mem_Write/Read 直接读写带寄存器的器件（如 I2C_MEMADD_SIZE_8BIT）。
把轮询升级为中断/DMA，释放 CPU。

PUYA SPI — 全双工主机（DMA）（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 全双工主机（DMA）（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/SPI/SPI_TwoBoards_FullDuplexMaster_DMA/Src/main.c

功能简介

SPI（Serial Peripheral Interface）是一种四线制、全双工、同步串行总线，速率远高于 I2C，常用于 LCD、Flash、ADC、无线通信模块等。

本示例演示 SPI1 主机 + DMA 全双工通信：

主机通过 HAL_SPI_TransmitReceive_DMA() 同时收发 15 字节；
数据搬运由 DMA 完成，CPU 在传输期间可腾出手做别的事；
传输完成后回调函数里校验收发是否一致，一致则点亮绿灯。
本工程仅提供主机（Master DMA）示例；同目录另有时钟/引脚由 HAL_SPI_MspInit 配置（在 py32f0xx_hal_msp.c 中绑定 SPI1 引脚与 DMA 通道）。

说明：PY32F0xx V1.5.0 的 STK 示例里 SPI 全双工只提供了 DMA 版（无纯轮询版）。若想用轮询，可把 HAL_SPI_TransmitReceive_DMA 换成 HAL_SPI_TransmitReceive（轮询版 API 同样存在），二者配置完全一致。

硬件准备

两块 PY32F030 开发板（一主一从），或用一块板把 MOSI↔MISO 短接做回环
交叉连接：主 MOSI↔从 MOSI，主 MISO↔从 MISO，主 SCK↔从 SCK，主 NSS↔从 NSS，共地
板载 LED / 按键用于交互（示例需按键触发一次传输）

完整代码（主机部分）

#include "main.h"

#define DATA_LENGTH 15

SPI_HandleTypeDef Spi1Handle;
uint8_t TxBuff[15] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t RxBuff[15] = {0};
DMA_HandleTypeDef HdmaCh1;   /* 发送 DMA 通道 */
DMA_HandleTypeDef HdmaCh2;   /* 接收 DMA 通道 */

int main(void)
{
  HAL_Init();
  APP_SystemClockConfig();    /* 配置系统时钟（HSI 8MHz） */

  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  /* SPI1 参数配置 */
  Spi1Handle.Instance               = SPI1;
  Spi1Handle.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; /* 波特率预分频 256 */
  Spi1Handle.Init.Direction         = SPI_DIRECTION_2LINES;      /* 全双工（2 线） */
  Spi1Handle.Init.CLKPolarity       = SPI_POLARITY_LOW;          /* 时钟极性：空闲低 */
  Spi1Handle.Init.CLKPhase          = SPI_PHASE_1EDGE;           /* 第 1 个边沿采样 */
  Spi1Handle.Init.DataSize          = SPI_DATASIZE_8BIT;         /* 8 位数据 */
  Spi1Handle.Init.FirstBit          = SPI_FIRSTBIT_MSB;          /* 高位先发 */
  Spi1Handle.Init.NSS               = SPI_NSS_HARD_OUTPUT;       /* NSS 硬件输出（主机自动拉低） */
  Spi1Handle.Init.Mode              = SPI_MODE_MASTER;           /* 主机模式 */
  if (HAL_SPI_DeInit(&Spi1Handle) != HAL_OK) APP_ErrorHandler();
  if (HAL_SPI_Init(&Spi1Handle) != HAL_OK)   APP_ErrorHandler();

  /* 等按键按下，启动一次全双工收发（DMA 方式） */
  while (BSP_PB_GetState(BUTTON_KEY) == 1) {}
  if (HAL_SPI_TransmitReceive_DMA(&Spi1Handle, (uint8_t*)TxBuff,
                                  (uint8_t*)RxBuff, DATA_LENGTH) != HAL_OK)
  {
    APP_ErrorHandler();
  }

  APP_WaitAndCheckEndOfTransfer();  /* 等传输完成并校验 */

  while (1) {}
}

/* 等待 SPI 回到 READY，再比较收发缓冲 */
static void APP_WaitAndCheckEndOfTransfer(void)
{
  while (Spi1Handle.State != HAL_SPI_STATE_READY) {}
  if (APP_Buffercmp8((uint8_t*)TxBuff, (uint8_t*)RxBuff, DATA_LENGTH))
    APP_LedBlinking();   /* 不一致：闪烁报警 */
  else
    BSP_LED_On(LED_GREEN); /* 一致：绿灯常亮 */
}

代码分段讲解

1. 时钟极性 / 相位（CPOL / CPHA）

SPI 通信双方必须 CPOL、CPHA 一致，否则收到的是错位数据：

本例 CPOL=LOW, CPHA=1EDGE 对应 Mode 0（常用默认）。
四种组合：Mode0(0,0)、Mode1(0,1)、Mode2(1,0)、Mode3(1,1)，按从设备手册选择。

2. 全双工本质

SPI 移位寄存器决定了“发的同时也在收”。HAL_SPI_TransmitReceive 把 TxBuff 逐位发出，同时把 MISO 上的数据逐位存入 RxBuff。回环（MOSI 接 MISO）时，发什么就收到什么，便于自测。

3. DMA vs 轮询

DMA 版：HAL_SPI_TransmitReceive_DMA 启动后由 DMA 控制器搬运数据，CPU 立刻返回，可在回调/状态查询里做别的事，适合大数据量。
轮询版：把上面函数换成 HAL_SPI_TransmitReceive(&Spi1Handle, Tx, Rx, len)（阻塞直到完成），代码更短，适合小数据量教学。

4. NSS 片选

本例 SPI_NSS_HARD_OUTPUT：主机 NSS 引脚由硬件自动在传输时拉低、结束后拉高，省去手动控制。若用软件片选，改 SPI_NSS_SOFT 并自行 HAL_GPIO_WritePin(NSS, RESET/SET)。

实验现象

按下用户键后启动一次 15 字节全双工收发；
回环或正确对接从机时，收发一致，绿灯常亮；
数据异常则绿灯 500ms 周期闪烁。

常见问题

收不到数据 / 全是 0xFF？
- 检查 CPOL/CPHA 是否与从机一致。
- 确认接线：MOSI-MOSI、MISO-MISO、SCK-SCK、NSS-NSS，并共地。
- 波特率（BaudRatePrescaler）不要超过从机最大 SPI 时钟。
想用轮询版？
- 直接调用 HAL_SPI_TransmitReceive()（不带 _DMA），其余配置不变。
DMA 传输只发不收 / 卡在 BUSY？
- 确认 HAL_SPI_MspInit 中已为 SPI1 的 TX/RX 绑定正确的 DMA 通道并使能 DMA 时钟；传输完成需等 State == HAL_SPI_STATE_READY。

小结

SPI 主机配置要点：波特率分频、CPOL/CPHA、数据位宽、MSB/LSB、NSS 方式、主/从模式。
全双工 = 同时收发；回环自测最方便。
DMA 适合大批量数据，轮询版更简单；两者配置相同，仅启动函数不同。

拓展应用

驱动 SPI Flash（W25Qxx）、LCD（ST7735/ILI9341）、SD 卡（SPI 模式）。
对接 SPI ADC（如 ADS1118）、无线模块（nRF24L01、SX1278）。
改用 SPI_NSS_SOFT 一主多从，用不同 NSS 选片。
把 DMA 版改为中断/DMA 双缓冲，实现连续高速数据流（音频、屏幕刷新）。

PUYA TIMER1 — PWM 输出（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

TIMER1 — PWM 输出（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/TIMER1/TIM1_PWM/Src/main.c

功能简介

定时器（TIMER）是 MCU 最灵活的外设之一，可完成定时、计数、PWM 输出、输入捕获、编码器接口等。本示例聚焦最常用的 PWM（脉冲宽度调制）输出。

PY32F030 的 TIM1 是高级定时器，带 4 路独立比较通道。本例配置：

定时器时钟 8MHz（HSI），预分频 800，自动重装载值 ARR = 50；
4 个通道的比较值 CCRx 分别设为 10/20/30/40，于是占空比为 20% / 40% / 60% / 80%；
用 HAL_TIM_PWM_Start() 启动 4 路 PWM，输出到对应引脚（在 HAL_TIM_MspInit 中映射为 TIM1_CH1~CH4）。

PWM 频率 = 定时器时钟 / (预分频 × (ARR+1)) = 8MHz / (800 × 50) = 200Hz。占空比 = CCR / (ARR+1)。

硬件准备

PY32F030 开发板
示波器 / 逻辑分析仪（测 TIM1_CH1~CH4 引脚），或接 4 颗 LED（串限流电阻）观察亮度
无需额外接线（用板载/引脚直出）

完整代码

#include "main.h"

#define PERIOD_VALUE  (uint32_t)(50 - 1)   /* ARR：计数上限 49 */
#define PULSE1_VALUE  10                    /* CH1 比较值 -> 占空比 10/50 = 20% */
#define PULSE2_VALUE  20                    /* CH2 -> 40% */
#define PULSE3_VALUE  30                    /* CH3 -> 60% */
#define PULSE4_VALUE  40                    /* CH4 -> 80% */

TIM_HandleTypeDef    TimHandle;
TIM_OC_InitTypeDef   sConfig;

int main(void)
{
  HAL_Init();
  APP_SystemClockConfig();              /* 系统时钟：HSI 8MHz */

  /* 定时器时基配置 */
  TimHandle.Instance              = TIM1;
  TimHandle.Init.Period           = 50;            /* 自动重装载值 ARR */
  TimHandle.Init.Prescaler        = 800 - 1;       /* 预分频 799 -> 8MHz/800 = 10kHz */
  TimHandle.Init.ClockDivision    = TIM_CLOCKDIVISION_DIV1;
  TimHandle.Init.CounterMode      = TIM_COUNTERMODE_UP;       /* 向上计数 */
  TimHandle.Init.RepetitionCounter = 1 - 1;                  /* 重复计数 0 */
  TimHandle.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_PWM_Init(&TimHandle) != HAL_OK) APP_ErrorHandler();

  /* PWM 输出通道参数 */
  sConfig.OCMode      = TIM_OCMODE_PWM1;     /* PWM 模式 1 */
  sConfig.OCPolarity  = TIM_OCPOLARITY_HIGH; /* 有效电平为高 */
  sConfig.OCFastMode  = TIM_OCFAST_DISABLE;
  sConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH;
  sConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET;
  sConfig.OCIdleState  = TIM_OCIDLESTATE_RESET;

  sConfig.Pulse = PULSE1_VALUE; /* CH1 */
  if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_1) != HAL_OK) APP_ErrorHandler();
  sConfig.Pulse = PULSE2_VALUE; /* CH2 */
  if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_2) != HAL_OK) APP_ErrorHandler();
  sConfig.Pulse = PULSE3_VALUE; /* CH3 */
  if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_3) != HAL_OK) APP_ErrorHandler();
  sConfig.Pulse = PULSE4_VALUE; /* CH4 */
  if (HAL_TIM_PWM_ConfigChannel(&TimHandle, &sConfig, TIM_CHANNEL_4) != HAL_OK) APP_ErrorHandler();

  /* 启动 4 路 PWM 输出 */
  HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_1);
  HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_2);
  HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_3);
  HAL_TIM_PWM_Start(&TimHandle, TIM_CHANNEL_4);

  while (1) {}
}

代码分段讲解

1. 频率与占空比计算

PWM 频率 = TIM_CLK / ((PSC+1) × (ARR+1))。
- 本例：8MHz / (800 × 50) = 200Hz。
某通道占空比 = CCRx / (ARR+1)（PWM1 且极性为高时）：
- CH1：10/50 = 20%，CH2：20/50 = 40%，CH3：30/50 = 60%，CH4：40/50 = 80%。

2. PWM 模式 1 / 2

TIM_OCMODE_PWM1：计数 < CCR 时输出有效（高），≥ CCR 时无效（低）。
TIM_OCMODE_PWM2：极性相反。改变模式或 OCPolarity 可反转波形，但占空比数值关系不变。

3. 引脚映射

TIM1_CH1~CH4 具体复用哪个 GPIO 引脚，由 HAL_TIM_MspInit()（py32f0xx_hal_msp.c）里的 HAL_GPIO_Init + Alternate 决定。若你改了引脚，需同步修改 MSP 配置。

4. 高级定时器 TIM1 的特殊性

TIM1 是高级定时器，带互补输出与死区（可用于电机/电源）。本例未用互补通道（N 端），仅用普通 CH1~CH4 输出。

实验现象

TIM1_CH1~CH4 输出 200Hz PWM，占空比分别为 20% / 40% / 60% / 80%；
接 LED 时可见 4 颗亮度依次递增；示波器可见 4 路不同占空比方波。

常见问题

引脚没波形？
- 确认 MSP 里已把 CHx 引脚复用为 TIM1 并按 Alternate 配置；
- 确认已调用 HAL_TIM_PWM_Start() 对应通道。
想改频率？
- 改 Period（ARR）或 Prescaler：频率与两者成反比。例：要 1kHz，可设 PSC=800-1, ARR=10-1（8MHz/800/10=1kHz）。
想做呼吸灯？
- 在主循环或定时器中断里周期性改变 CCRx：__HAL_TIM_SET_COMPARE(&TimHandle, TIM_CHANNEL_x, newVal);。
占空比算不对？
- 注意是 CCRx / (ARR+1)，且受 OCMode 与 OCPolarity 影响有效区间。

小结

PWM = 定时器在 ARR 范围内循环计数，用 CCR 决定高电平占比。
关键三参数：PSC（分频）、ARR（周期）、CCR（占空比）。
HAL_TIM_PWM_Init → HAL_TIM_PWM_ConfigChannel → HAL_TIM_PWM_Start 三步即可输出。

拓展应用

LED 调光 / 呼吸灯（__HAL_TIM_SET_COMPARE 动态调占空比）。
舵机控制（50Hz PWM，0.5~~2.5ms 脉宽对应 0~~180°）。
直流电机调速（配合 MOSFET/驱动芯片）。
蜂鸣器发声（不同频率 PWM 出不同音调）；多路 PWM 做音乐。
高级用法：互补 PWM + 死区驱动半桥（见 TIM1_ComplementarySignals 系列）。

PUYA USART — 串口轮询收发与 printf 重定向（HAL 库）

Tue, 08 Sep 2026 14:52:21 +0800

USART — 串口轮询收发与 printf 重定向（HAL 库）

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example/USART/USART_HyperTerminal_Polling/Src/main.c
串口重定向: Drivers/BSP/PY32F030xx_Start_Kit/py32f030xx_Start_Kit.c（_write / __io_putchar）

功能简介

USART（通用同步异步收发器）即常说的“串口”，是 MCU 与电脑/模块通信、打印调试信息最常用的通道。本示例做两件事：

轮询收发：串口先发送欢迎语，再用 HAL_UART_Receive 阻塞等待接收 12 字节，收到后原样回显，最后发结束语、点亮 LED。
printf 重定向（本库特色）：BSP 里已实现 _write / __io_putchar，把 C 库 printf 重定向到 USART2，于是在 ADC 等示例里能直接 printf("adc:%u\r\n", val) 打印。

任务要求的 “UART_Printf（printf 重定向）”在 PUYA 固件里不是独立示例，而是由 BSP_USART_Config() + _write 统一提供。下面先讲官方轮询示例，再专门讲 printf 重定向怎么用。

硬件准备

USB 转串口模块（CH340 / CP2102 等）
接线：开发板 PA2(TX) → 模块 RX，PA3(RX) → 模块 TX，共地
电脑端串口助手（SSCOM / XCOM / PuTTY），波特率 115200-8-N-1

完整代码（官方轮询示例）

#include "main.h"

#define COUNTOF(__BUFFER__)     (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE      (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE        (COUNTOF(aTxEndMessage) - 1)

UART_HandleTypeDef UartHandle;
uint8_t aTxStartMessage[] = "\r\n UART Hyperterminal communication based on Polling\r\n Enter 12 characters using keyboard :\r\n";
uint8_t aTxEndMessage[]   = "\r\n Example Finished\r\n";
uint8_t aRxBuffer[12]      = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};

int main(void)
{
  HAL_Init();
  BSP_LED_Init(LED_GREEN);

  /* 串口参数：USART2，115200，8 位，1 停止位，无校验，无流控，收发全开 */
  UartHandle.Instance           = USART2;
  UartHandle.Init.BaudRate      = 115200;
  UartHandle.Init.WordLength    = UART_WORDLENGTH_8B;
  UartHandle.Init.StopBits      = UART_STOPBITS_1;
  UartHandle.Init.Parity        = UART_PARITY_NONE;
  UartHandle.Init.HwFlowCtl     = UART_HWCONTROL_NONE;
  UartHandle.Init.Mode          = UART_MODE_TX_RX;
  UartHandle.Init.OverSampling  = UART_OVERSAMPLING_16;
  UartHandle.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  HAL_UART_Init(&UartHandle);

  /* 1) 发送欢迎语 */
  if (HAL_UART_Transmit(&UartHandle, aTxStartMessage, TXSTARTMESSAGESIZE, 5000) != HAL_OK)
    APP_ErrorHandler();

  /* 2) 阻塞接收 12 字节（串口助手输入 12 个字符） */
  if (HAL_UART_Receive(&UartHandle, aRxBuffer, 12, 5000) != HAL_OK)
    APP_ErrorHandler();

  /* 3) 把收到的 12 字节原样回显 */
  if (HAL_UART_Transmit(&UartHandle, aRxBuffer, 12, 5000) != HAL_OK)
    APP_ErrorHandler();

  /* 4) 发送结束语 */
  if (HAL_UART_Transmit(&UartHandle, aTxEndMessage, TXENDMESSAGESIZE, 5000) != HAL_OK)
    APP_ErrorHandler();

  BSP_LED_On(LED_GREEN);   /* 成功：绿灯常亮 */
  while (1) {}
}

printf 重定向（重点）

py32f030xx_Start_Kit.c 中已实现如下重定向，使得任意示例调用 DEBUG_USART_Config() 后即可使用 printf：

/* printf 最终调用到这里，把每个字符从 USART2 发出 */
int __io_putchar(int ch)
{
  /* 阻塞等待发送数据寄存器空，再写 1 字节 */
  while (!(DEBUG_USART->ISR & USART_ISR_TXE));
  DEBUG_USART->TDR = (ch & 0xFF);
  return ch;
}

/* C 库 write 系统调用：把整个缓冲区逐个字符送出 */
int _write(int file, char *ptr, int len)
{
  int i;
  for (i = 0; i < len; i++)
  {
    __io_putchar(*ptr++);
  }
  return len;
}

使用步骤

在 main() 里调用 DEBUG_USART_Config();（它内部配置 PA2/PA3 为 USART2、115200-8-N-1 并使能时钟）。
工程需勾选 Use MicroLIB（Keil）或链接 libc（GCC/iar），否则 _write 不生效。
之后即可：
1

printf("系统启动 ok，温度=%d℃\r\n", temp);
注意：重定向版是阻塞发送，仅适合调试打印；高吞吐场景请用 HAL_UART_Transmit_DMA 或中断。

代码分段讲解

波特率与时钟：USART2 挂在 APB1，时钟来自 HSI/PLL；波特率 115200 需系统时钟足够且分频匹配，否则乱码。
轮询发送 HAL_UART_Transmit：内部等 TXE 标志直到整帧发完或超时，简单但占用 CPU。
轮询接收 HAL_UART_Receive：阻塞直到收满指定长度或超时；若串口助手发的字节数不足，会一直等（超时 5000ms 后报错）。
重定向原理：C 库的 printf → fputc/_write → __io_putchar → 写 USART 的 TDR，从而形成“打印即串口输出”。

实验现象

串口助手收到欢迎语，提示输入 12 个字符；
输入 12 个字符后，开发板原样回显，再发“Example Finished”，绿灯常亮。

常见问题

串口助手全是乱码？
- 波特率必须与代码一致（115200）；系统时钟（HSI/PLL）设置要匹配库里 DEBUG_USART 的时钟来源。
- 确认 printf 工程勾选了 MicroLIB / 正确链接 libc。
printf 没输出？
- 忘记调用 DEBUG_USART_Config()；或引脚不是 PA2/PA3（被改过需同步改 BSP）。
- 确认 HAL_UART_MODULE_ENABLED 宏已开（否则 printf 重定向分支被编译掉）。
HAL_UART_Receive 卡住？
- 它要收满 12 字节才返回；串口助手发的字符数不够或没勾选“发送新行”都会超时。教学建议先固定长度，或用中断/不定长（见 USART_HyperTerminal_IT）。
TX/RX 接反？
- 必须交叉：板 TX → 模块 RX，板 RX → 模块 TX，并共地。

小结

串口配置三要素：波特率、数据格式（8-N-1）、时钟来源。
轮询收发最简单但阻塞 CPU；正式项目用中断/DMA。
通过 _write/__io_putchar 重定向 printf，是最高效的调试打印手段。

拓展应用

用 printf 打印变量/状态，做在线调试，替代单步。
升级为 HAL_UART_Transmit_IT/DMA 做高吞吐日志或命令解析。
接收中断 + 环形缓冲实现“串口命令行”（解析 AT 指令等）。
双 USART：一个接调试、一个接 WiFi/BLE 模块。

普冉半导体 (Puya) PUYA MCU 示例代码库

Tue, 08 Sep 2026 14:52:21 +0800

PUYA MCU 示例代码库

厂商: 普冉半导体 (Puya)
芯片: PY32F002A、PY32F003、PY32F030、PY32F403、PY32L020

普冉 PY32 系列超低成本 MCU，基于 Cortex-M0+/M4 内核。

固件库版本一览

固件库名称	版本	芯片
PY32F0xx_Firmware	V1.5.0	PY32F002A, PY32F003, PY32F030
PY32F002B_Firmware	V1.2.1	PY32F002B
PY32F403_Firmware	V1.4.5	PY32F403
PY32L020_Firmware	V1.2.1	PY32L020
ebf_py32f030	20250102	PY32F030

HAL 库 vs LL 库

PUYA 的每个系列固件库都同时提供 两套 API，源码分别放在两个示例目录中：

目录	库类型	函数前缀	特点
`Example/`	HAL 库（Hardware Abstraction Layer）	`HAL_`（如 `HAL_GPIO_TogglePin`）	封装度高、跨系列可移植性强，适合快速开发、原型验证
`Example_LL/`	LL 库（Low-Layer）	`LL_`（如 `LL_GPIO_TogglePin`）	接近寄存器操作、代码精简、执行效率高，适合性能敏感 / 资源紧张场景

如何选择？

想尽快跑通功能、后续可能换芯片系列 → 用 HAL 库。
追求最小代码体积、最短中断延迟、对寄存器行为完全掌控 → 用 LL 库。
两者并不互斥：可以在 HAL 工程中直接调用 LL 函数做精细控制（PUYA 的 LL 头文件与 HAL 共存于同一套驱动）。

本站的文档约定

HAL 库版本文档标题标注 （HAL 库），并在 tags 中加入 HAL；
LL 库版本文档标题标注 （LL 库），并在 tags 中加入 LL；
每篇 LL 文档开头都有一段「HAL vs LL」提示框，讲解该外设下两套库的写法差异。

核心外设的 HAL / LL 对照示例（PY32F0xx V1.5.0）：

外设	HAL 版	LL 版
GPIO 翻转	GPIO_Toggle（HAL）	GPIO_Toggle（LL）
USART 轮询	USART_HyperTerminal_Polling（HAL）	USART_HyperTerminal_Polling_Init（LL）
ADC 单通道	ADC_TempSensor（HAL）	ADC_TempSensor_Init（LL）
TIM1 PWM	TIM1_PWM（HAL）	TIM1_PWM_Init（LL）
I2C 主机轮询	I2C 主机轮询（HAL）	I2C 主机轮询（LL）
SPI 全双工主机	SPI 全双工主机 DMA（HAL）	SPI 全双工主机 IT（LL）
DMA 内存搬运	DMA_SramToSram（HAL）	DMA_SramToSram（LL）
Flash 页擦写	FLASH_PageEraseAndWrite（HAL）	FLASH_PageEraseAndWrite（LL）

注：PUYA 的 LL 示例库中，部分外设没有与 HAL 同名示例（如 LL 的 SPI 仅有 DMA/中断版、ADC 无 TriggerSW_Polling 版）。本站选取功能等价的 LL 示例与之配对，并在对应文档中加以说明。

目录导航

左侧导航按外设模块分类，每个模块下列出所有子示例。每个示例包含功能说明、关键配置代码、源文件路径。

PUYA ADC — 单通道转换（内部温度传感器）（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

ADC — 单通道转换（内部温度传感器）（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/ADC/ADC_TempSensor_Init/Src/main.c

功能简介

本示例演示如何用 ADC 读取芯片内部温度传感器的电压，并换算成摄氏度，通过串口打印出来。它是 LL 库里“单通道单次转换”最典型的代表——流程是：校准 ADC → 配置通道与触发源 → 软件触发 → 轮询结束标志 → 读结果 → 换算。

说明：PUYA 的 LL 示例库中没有 ADC_SingleConversion_TriggerSW_Polling 这个同名示例，但 ADC_TempSensor_Init 本质上就是“软件触发 + 单次转换 + 轮询读取”的范式，完全覆盖了你要学的 HAL ADC_SingleConversion_TriggerSW_Polling 的核心套路。把通道从“内部温度传感器”换成某个 GPIO 引脚（如 LL_ADC_CHANNEL_0），就是通用单端采样。

与 HAL 版（HAL_ADC_Start / HAL_ADC_PollForConversion / HAL_ADC_GetValue）相比，LL 把每一步都拆成独立函数，且校准过程需要你手动执行（HAL 在 HAL_ADC_Init 里已悄悄帮你校准过）。

硬件准备

PY32F030 开发板
串口线（用于打印温度，接 USART，由 BSP_USART_Config() 初始化）
无需外部传感器——温度传感器在芯片内部
注意：温度传感器的采样值受芯片自身发热影响，读数仅供参考

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define HighTemp_85        /* 按数据手册选择 85℃ 或 105℃ 标定 */
/* #define HighTemp_105 */

#define ADC_CALIBRATION_TIMEOUT_MS       ((uint32_t) 1)
#define VAR_CONVERTED_DATA_INIT_VALUE    (__LL_ADC_DIGITAL_SCALE(LL_ADC_RESOLUTION_12B) + 1)

__IO uint16_t uhADCxConvertedData = VAR_CONVERTED_DATA_INIT_VALUE;
__IO uint16_t uhADCxConvertedData_Temp = 0;

static void APP_SystemClockConfig(void);
static void APP_AdcConfig(void);
static void APP_AdcEnable(void);
static void APP_AdcCalibrate(void);
static void APP_QuickSort(int32_t arr[], int32_t length);

int main(void)
{
  APP_SystemClockConfig();

  BSP_USART_Config();              /* 初始化调试串口，用于 printf */

  LL_ADC_Reset(ADC1);             /* 复位 ADC */
  LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_ADC1);  /* 开 ADC1 时钟 */

  APP_AdcCalibrate();             /* 校准（LL 必须手动做） */
  APP_AdcConfig();                /* 配置通道、触发源等 */
  APP_AdcEnable();                /* 使能 ADC */

  LL_ADC_REG_StartConversion(ADC1);   /* 软件触发一次转换 */
  while (1)
  {
    if (LL_ADC_IsActiveFlag_EOS(ADC1))    /* 等待“序列转换结束” */
    {
      LL_ADC_ClearFlag_EOS(ADC1);
      uhADCxConvertedData = LL_ADC_REG_ReadConversionData12(ADC1);  /* 读 12 位结果 */

      /* 按所选标定曲线换算温度 */
#if defined(HighTemp_85)
      uhADCxConvertedData_Temp = __LL_ADC_CALC_TEMPERATURE_85(3300, uhADCxConvertedData, LL_ADC_RESOLUTION_12B);
#else
      uhADCxConvertedData_Temp = __LL_ADC_CALC_TEMPERATURE_105(3300, uhADCxConvertedData, LL_ADC_RESOLUTION_12B);
#endif
      printf("Temperature: %d\r\n", uhADCxConvertedData_Temp);
      LL_mDelay(200);
      LL_ADC_REG_StartConversion(ADC1);  /* 再次软件触发 */
    }
  }
}

/**
  * @brief  ADC 配置：通道 + 触发源（软件触发）
  */
static void APP_AdcConfig(void)
{
  __IO uint32_t wait_loop_index = 0;

  LL_ADC_InitTypeDef     ADC_Init            = {0};
  LL_ADC_REG_InitTypeDef LL_ADC_REG_InitType = {0};

  /* ADC 基础参数 */
  ADC_Init.Clock         = LL_ADC_CLOCK_SYNC_PCLK_DIV4;   /* ADC 时钟 = PCLK/4 */
  ADC_Init.DataAlignment = LL_ADC_DATA_ALIGN_RIGHT;       /* 右对齐 */
  ADC_Init.LowPowerMode  = LL_ADC_LP_MODE_NONE;
  ADC_Init.Resolution    = LL_ADC_RESOLUTION_12B;         /* 12 位分辨率 */
  LL_ADC_Init(ADC1, &ADC_Init);

  /* 采样时间 */
  LL_ADC_SetSamplingTimeCommonChannels(ADC1, LL_ADC_SAMPLINGTIME_239CYCLES_5);

  /* 规则转换（Regular）参数 */
  LL_ADC_REG_InitType.ContinuousMode    = LL_ADC_REG_CONV_CONTINUOUS;     /* 连续模式 */
  LL_ADC_REG_InitType.DMATransfer       = LL_ADC_REG_DMA_TRANSFER_NONE;
  LL_ADC_REG_InitType.Overrun           = LL_ADC_REG_OVR_DATA_OVERWRITTEN;
  LL_ADC_REG_InitType.SequencerDiscont  = LL_ADC_REG_SEQ_DISCONT_DISABLE;
  LL_ADC_REG_InitType.TriggerSource     = LL_ADC_REG_TRIG_SOFTWARE;       /* 软件触发 */
  LL_ADC_REG_Init(ADC1, &LL_ADC_REG_InitType);

  LL_ADC_REG_SetSequencerScanDirection(ADC1, LL_ADC_REG_SEQ_SCAN_DIR_BACKWARD);

  /* 打开内部温度传感器通道 */
  LL_ADC_SetCommonPathInternalCh(__LL_ADC_COMMON_INSTANCE(ADC1), LL_ADC_PATH_INTERNAL_TEMPSENSOR);
  /* 等待温度传感器稳定 */
  wait_loop_index = ((LL_ADC_DELAY_TEMPSENSOR_STAB_US * (SystemCoreClock / (100000 * 2))) / 10);
  while (wait_loop_index != 0) { wait_loop_index--; }

  LL_ADC_REG_SetSequencerChannels(ADC1, LL_ADC_CHANNEL_TEMPSENSOR);  /* 选通道 11=温度传感器 */
}

/**
  * @brief  ADC 校准（LL 需手动执行，HAL 在 Init 时已做）
  */
static void APP_AdcCalibrate(void)
{
  /* 多次采样取中位数写入校准寄存器（厂商提供的校准流程） */
  uint32_t ADC_CALRR1_Buff[5];
  int32_t  ADC_CALRR1_BuffInt[5];
  if (LL_ADC_IsEnabled(ADC1) == 0)
  {
    for (int i = 0; i < 5; i++)
    {
      LL_ADC_StartCalibration(ADC1);
      while (LL_ADC_IsCalibrationOnGoing(ADC1) != 0) {}
      ADC_CALRR1_Buff[i]     = *((__IO uint32_t *)(0x40012448));
      ADC_CALRR1_BuffInt[i]  = (int32_t)(ADC_CALRR1_Buff[i] << 9);
    }
    APP_QuickSort(ADC_CALRR1_BuffInt, 5);
    *((__IO uint32_t *)(0x40012450)) = (ADC_CALRR1_BuffInt[2] >> 9);
    *((__IO uint32_t *)(0x40012454)) = *((__IO uint32_t *)(0x4001244C));
    *((__IO uint32_t *)(0x40012444)) |= 0x8000;
    LL_mDelay(1);
  }
}

/**
  * @brief  ADC 使能并等待稳定
  */
static void APP_AdcEnable(void)
{
  LL_ADC_Enable(ADC1);
  LL_mDelay(1);
}

/* APP_QuickSort / APP_SystemClockConfig / APP_ErrorHandler 略（与前述示例同构） */

代码分段讲解

1. 校准：LL 与 HAL 的关键差异

HAL 里你几乎感觉不到“校准”的存在——HAL_ADC_Init() 内部已经帮你调好。LL 里校准是显式的：先 LL_ADC_StartCalibration()，等 LL_ADC_IsCalibrationOnGoing() 清零，再把结果写回校准寄存器。示例里采样 5 次取中位数，是对出厂标定的微调。忽略这步，读数会明显不准。

2. 触发源：软件触发

LL_ADC_REG_InitType.TriggerSource = LL_ADC_REG_TRIG_SOFTWARE 表示“想转换时，由软件写寄存器启动”，对应你点名要学的 ADC_SingleConversion_TriggerSW_*。运行时调用 LL_ADC_REG_StartConversion(ADC1) 即启动一次（连续模式下会持续转换）。

3. 等待结束 + 读结果

HAL：HAL_ADC_PollForConversion() 封装了等待。
LL：直接 LL_ADC_IsActiveFlag_EOS(ADC1) 轮询“序列结束”标志，再 LL_ADC_REG_ReadConversionData12() 读 12 位值。名字虽长，但语义一目了然。

4. 温度换算

__LL_ADC_CALC_TEMPERATURE_85() 是 LL 提供的宏，按 Vref(3300mV)、原始值、分辨率换算成摄氏温度。把通道换成外部 GPIO 引脚时，你只需用 LL_ADC_CHANNEL_x 替换 LL_ADC_CHANNEL_TEMPSENSOR，并去掉“内部通道”那几行。

实验现象

串口每约 200ms 打印一行 Temperature: xx（摄氏度）。
用手摸芯片或吹热气，读数会明显变化（注意：受自热影响，绝对值可能偏高）。

常见问题

读数一直是 0 或满量程？
- 几乎都是漏了“开 ADC1 时钟”或“校准”。LL 不会自动开时钟，也requires 手动校准。
- 确认 LL_ADC_REG_TRIG_SOFTWARE 后确实调用了 LL_ADC_REG_StartConversion()。
温度跳变很大？
- 温度传感器本身噪声较大，可多次采样取平均；示例只打印单次值。
想采样外部引脚怎么改？
- 把 LL_ADC_CHANNEL_TEMPSENSOR 换成 LL_ADC_CHANNEL_0~LL_ADC_CHANNEL_x，并删掉 LL_ADC_SetCommonPathInternalCh(...) 与稳定等待那几行。

小结

LL 的 ADC 使用范式：开时钟 → 校准 → 配置(通道/触发/分辨率) → 使能 → 软件触发 → 轮询 EOS → 读值。
与 HAL 最大的不同是“校准”和“启动转换”都暴露给你自己控制，没有任何隐藏动作。
单通道软件触发轮询，是 LL ADC 最基础也最常用的模板。

拓展应用

改成多通道扫描（LL_ADC_REG_SetSequencerChannels 设多个通道），轮流采样电压/温度。
触发源换成定时器（LL_ADC_REG_TRIG_EXT_TIMx_TRGO），实现固定采样率。
配合 DMA（ADC_MultiChannelSingleConversion_TriggerSW_DMA）让 CPU 完全不介入连续采样。
把温度换算后用于控制风扇/报警，做最简单的温控演示。

PUYA DMA — 内存到内存搬运（SRAM→SRAM）（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

DMA — 内存到内存搬运（SRAM → SRAM）（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/DMA/DMA_SramToSram/Src/main.c

功能简介

本示例演示 DMA 最基础的能力：内存到内存（M2M）搬运。程序在源缓冲区填入 0~31 共 32 个字，然后让 DMA 控制器在后台把它们整批复制到目的缓冲区，期间 CPU 完全空闲。传输完成后在中断里校验数据是否一致：一致则点亮 LED，不一致/出错则 LED 闪烁。

与 HAL 版（HAL_DMA_Start_IT() + HAL_DMA_XferCpltCallback）相比，LL 版让你自己填 LL_DMA_InitTypeDef 并调用 LL_DMA_Init()，再显式使能 TC/TE 中断、配置 NVIC。每一步都对应一个 DMA 寄存器字段，适合想“看清 DMA 怎么配”的读者。

硬件准备

PY32F030 开发板
板载绿 LED（用于指示传输结果）
纯软件示例，无需外部连线

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define BUFFER_SIZE 32

uint32_t aSRC_Const_Buffer[BUFFER_SIZE];   /* 源缓冲 */
uint32_t aDST_Buffer[BUFFER_SIZE];         /* 目的缓冲 */
__IO uint32_t transferCompleteDetected = 0;
__IO uint32_t transferErrorDetected    = 0;
__IO uint32_t transferFailedDetected   = 0;

static void APP_DmaConfig(void);
static void APP_SystemClockConfig(void);

int main(void)
{
  APP_SystemClockConfig();
  BSP_LED_Init(LED_GREEN);

  /* 源缓冲填入 0..31 */
  for (uint8_t i = 0; i < BUFFER_SIZE; i++)
    aSRC_Const_Buffer[i] = i;

  APP_DmaConfig();     /* 配置并启动 DMA */

  while (1)
  {
    if (transferFailedDetected == 1 && transferCompleteDetected == 1)
    {
      while (1) { BSP_LED_Toggle(LED_GREEN); LL_mDelay(500); }  /* 数据错误 */
    }
    if (transferFailedDetected == 0 && transferCompleteDetected == 1)
    {
      BSP_LED_On(LED_GREEN);     /* 数据正确 */
      while (1) {}
    }
    if (transferErrorDetected == 1)
    {
      while (1) { BSP_LED_Toggle(LED_GREEN); LL_mDelay(500); }  /* 传输错误 */
    }
  }
}

/**
  * @brief  DMA 配置：M2M，32 位，地址自增，普通模式
  */
static void APP_DmaConfig(void)
{
  LL_DMA_InitTypeDef dma_initstruct = {0};

  LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1);   /* 开 DMA1 时钟 */

  dma_initstruct.PeriphOrM2MSrcAddress  = (uint32_t)&aSRC_Const_Buffer;  /* 源地址 */
  dma_initstruct.MemoryOrM2MDstAddress  = (uint32_t)&aDST_Buffer;        /* 目的地址 */
  dma_initstruct.Direction              = LL_DMA_DIRECTION_MEMORY_TO_MEMORY; /* M2M */
  dma_initstruct.Mode                   = LL_DMA_MODE_NORMAL;     /* 普通模式(非循环) */
  dma_initstruct.PeriphOrM2MSrcIncMode  = LL_DMA_PERIPH_INCREMENT;/* 源地址自增 */
  dma_initstruct.MemoryOrM2MDstIncMode  = LL_DMA_MEMORY_INCREMENT;/* 目的地址自增 */
  dma_initstruct.PeriphOrM2MSrcDataSize = LL_DMA_PDATAALIGN_WORD; /* 32 位 */
  dma_initstruct.MemoryOrM2MDstDataSize = LL_DMA_MDATAALIGN_WORD; /* 32 位 */
  dma_initstruct.NbData                 = BUFFER_SIZE;
  dma_initstruct.Priority               = LL_DMA_PRIORITY_HIGH;
  if (LL_DMA_Init(DMA1, LL_DMA_CHANNEL_1, &dma_initstruct) != SUCCESS)
    APP_ErrorHandler();

  /* 使能传输完成 / 传输错误中断，并配置 NVIC */
  LL_DMA_EnableIT_TC(DMA1, LL_DMA_CHANNEL_1);
  LL_DMA_EnableIT_TE(DMA1, LL_DMA_CHANNEL_1);
  NVIC_SetPriority(DMA1_Channel1_IRQn, 0);
  NVIC_EnableIRQ(DMA1_Channel1_IRQn);

  LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1);   /* 启动通道 */
}

/* 以下回调在 DMA1_Channel1_IRQHandler 中被调用 */
void APP_TransferCompleteCallback(void)
{
  /* 校验目的缓冲是否等于源缓冲 */
  for (uint16_t i = 0; i < BUFFER_SIZE; i++)
  {
    if (aDST_Buffer[i] != aSRC_Const_Buffer[i])
    {
      transferFailedDetected = 1;
      break;
    }
  }
  transferCompleteDetected = 1;
}
void APP_TransferErrorCallback(void)
{
  transferErrorDetected = 1;
}

/* APP_SystemClockConfig / APP_ErrorHandler 略 */

代码分段讲解

1. 开 DMA 时钟

DMA 挂在 AHB1 上，要用 LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1) 开时钟。漏掉这步 DMA 不工作——和所有外设一样，LL 不会自动帮你开。

2. 配置结构体：每个字段一个寄存器位

LL_DMA_InitTypeDef 的字段几乎与 DMA 通道配置寄存器一一对应：

Direction = MEMORY_TO_MEMORY：内存到内存（需硬件支持 M2M 的通道）。
PeriphOrM2MSrcIncMode / MemoryOrM2MDstIncMode：源/目的地址是否自增（默认外设不自增、内存自增，M2M 下两者都自增）。
PeriphOrM2MSrcDataSize / MemoryOrM2MDstDataSize：数据宽度，这里 32 位（WORD）。
Mode = NORMAL：传完 NbData 个就停（循环模式用 LL_DMA_MODE_CIRCULAR）。
Priority：通道优先级，多通道竞争时生效。

3. 启动：使能中断 + 使能通道

HAL 里 HAL_DMA_Start_IT() 一句把“填寄存器 + 使能中断 + 使能通道”全做了；LL 里你要：先 LL_DMA_Init() 写配置，再 LL_DMA_EnableIT_TC/TE() 开中断，配 NVIC，最后 LL_DMA_EnableChannel() 真正启动。顺序很重要——先配好再使能。

4. 完成回调里校验

传输完成进 APP_TransferCompleteCallback()，这里逐字比对源/目的缓冲。注意：DMA 只是“搬数据”，不会告诉你数据对不对，校验逻辑得你自己写（HAL 同样要你自己在 XferCpltCallback 里校验）。

实验现象

下载运行后，DMA 自动把 32 个字从源搬到目的。
校验一致 → 板载绿 LED 常亮。
若把源缓冲改成随机/未初始化，或人为制造不匹配 → LED 闪烁（数据错误分支）。

常见问题

DMA 完全没动作 / LED 不亮？
- 确认 LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1) 已调用。
- 确认 LL_DMA_EnableChannel() 在配置和中断使能之后调用。
- M2M 搬运需要 DMA 支持内存到内存（PY32F0 的 DMA1 支持）。
中断没进？
- 检查 NVIC_EnableIRQ(DMA1_Channel1_IRQn) 是否配置；确认中断服务程序里调用了 APP_TransferCompleteCallback()。
想连续搬运（如 ADC+DMA 循环采样）？
- 把 Mode 改为 LL_DMA_MODE_CIRCULAR，并去掉 NbData 完成后停止的逻辑。

小结

LL 的 DMA = 开时钟 → 填 LL_DMA_InitTypeDef → LL_DMA_Init → 使能中断 → 使能通道。
相比 HAL 的 HAL_DMA_Start_IT，LL 让你精确控制每个寄存器字段和启动顺序。
DMA 只负责“搬”，数据正确性要靠自己在完成回调里校验。

拓展应用

改成 LL_DMA_MODE_CIRCULAR 做 ADC 连续采样（参考 ADC_MultiChannelSingleConversion_TriggerSW_DMA）。
外设到内存：把源地址换成 &ADC1->DR、方向设为 PERIPH_TO_MEMORY，实现“ADC 自动存数组”。
内存到外设：把目的地址换成 &USARTx->DR，用 DMA 自动发串口大数据块。
多通道搬运时用不同 LL_DMA_CHANNEL_x 并分别配 NVIC 优先级。

PUYA FLASH — 页擦除与写入（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

FLASH — 页擦除与写入（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/FLASH/FLASH_PageEraseAndWrite/Src/main.c

功能简介

本示例演示如何安全地改写片内 Flash：向 0x08004000 起始的用户区写入一段 64 字的测试数据，掉电后仍可保留。完整流程是：解锁 Flash → 配置编程时序 → 页擦除 → 校验空白 → 按页编程 → 加锁 → 回读校验。按键用于避免每次上电都擦写。

与 HAL 版（HAL_FLASH_Unlock / HAL_FLASH_Program / HAL_FLASH_Lock + FLASH_EraseInitTypeDef）相比，LL 版把“每次擦除/编程都要等 BUSY、置/清 EOP、使能/关闭页操作”这些细节完全摊开——更接近 Flash 控制器的真实寄存器时序。

硬件准备

PY32F030 开发板
板载用户按键（BUTTON_USER）、绿 LED
注意：0x08004000 是用户 Flash 区，务必确认没有被你的程序占用（否则会破坏自身代码）

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define FLASH_USER_START_ADDR   0x08004000

const uint32_t DATA[64] = {
  0x01010101, 0x23456789, 0x3456789A, 0x456789AB, /* ... 共 64 字 ... */
  0x23456789, 0xAAAAAAAA, 0x55555555, 0x23456789
};

static void APP_SystemClockConfig(void);
static void APP_FlashErase(void);
static void APP_FlashProgram(void);
static void APP_FlashBlank(void);
static void APP_FlashVerify(void);

int main(void)
{
  APP_SystemClockConfig();

  LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_SYSCFG);
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_PWR);

  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_USER, BUTTON_MODE_GPIO);

  while (BSP_PB_GetState(BUTTON_USER)) {}   /* 等按键，避免每次上电都擦写 */

  LL_FLASH_Unlock(FLASH);                    /* 解锁 Flash */
  LL_FLASH_TIMMING_SEQUENCE_CONFIG_24M();    /* 按 24MHz 配置编程时序 */

  APP_FlashErase();     /* 页擦除 */
  APP_FlashBlank();     /* 校验空白 */
  APP_FlashProgram();   /* 写数据 */
  LL_FLASH_Lock(FLASH); /* 加锁 */

  APP_FlashVerify();    /* 回读校验 */
  BSP_LED_On(LED_GREEN);
  while (1) {}
}

/**
  * @brief  页擦除：逐页擦到覆盖完数据区
  */
static void APP_FlashErase(void)
{
  uint32_t start = FLASH_USER_START_ADDR;
  uint32_t end   = FLASH_USER_START_ADDR + sizeof(DATA);
  while (start < end)
  {
    while (LL_FLASH_IsActiveFlag_BUSY(FLASH) == 1);   /* 等不忙 */
    LL_FLASH_EnableIT_EOP(FLASH);                     /* 使能结束中断标志 */
    LL_FLASH_EnablePageErase(FLASH);                  /* 进入页擦除模式 */
    LL_FLASH_SetEraseAddress(FLASH, start);           /* 设置擦除地址 */
    while (LL_FLASH_IsActiveFlag_BUSY(FLASH) == 1);   /* 等擦完 */
    while (LL_FLASH_IsActiveFlag_EOP(FLASH) == 0);    /* 等 EOP */
    LL_FLASH_ClearFlag_EOP(FLASH);
    LL_FLASH_DisableIT_EOP(FLASH);
    LL_FLASH_DisablePageErase(FLASH);
    start += FLASH_PAGE_SIZE;                         /* 指向下一页 */
  }
}

/**
  * @brief  按页编程
  */
static void APP_FlashProgram(void)
{
  uint32_t start = FLASH_USER_START_ADDR;
  uint32_t end   = FLASH_USER_START_ADDR + sizeof(DATA);
  uint32_t *src = (uint32_t *)DATA;
  while (start < end)
  {
    while (LL_FLASH_IsActiveFlag_BUSY(FLASH) == 1);
    LL_FLASH_EnableIT_EOP(FLASH);
    LL_FLASH_EnablePageProgram(FLASH);                /* 进入页编程模式 */
    LL_FLASH_PageProgram(FLASH, start, src);          /* 写一页 */
    while (LL_FLASH_IsActiveFlag_BUSY(FLASH) == 1);
    while (LL_FLASH_IsActiveFlag_EOP(FLASH) == 0);
    LL_FLASH_ClearFlag_EOP(FLASH);
    LL_FLASH_DisableIT_EOP(FLASH);
    LL_FLASH_DisablePageProgram(FLASH);
    start += FLASH_PAGE_SIZE;
    src   += FLASH_PAGE_SIZE / 4;
  }
}

/**
  * @brief  空白校验：擦除后应为全 0xFFFFFFFF
  */
static void APP_FlashBlank(void)
{
  uint32_t addr = 0;
  while (addr < sizeof(DATA))
  {
    if (0xFFFFFFFF != HW32_REG(FLASH_USER_START_ADDR + addr))
      APP_ErrorHandler();
    addr += 4;
  }
}

/**
  * @brief  回读校验：与源数据一致
  */
static void APP_FlashVerify(void)
{
  uint32_t addr = 0;
  while (addr < sizeof(DATA))
  {
    if (DATA[addr / 4] != HW32_REG(FLASH_USER_START_ADDR + addr))
      APP_ErrorHandler();
    addr += 4;
  }
}

/* APP_SystemClockConfig 配置 HSI=24MHz；APP_ErrorHandler 略 */

代码分段讲解

1. 解锁与时序

Flash 上电默认加锁，写操作前必须 LL_FLASH_Unlock()。此外有个 LL 特有、极易遗漏的步骤：LL_FLASH_TIMMING_SEQUENCE_CONFIG_24M()——它按当前 HSI 频率（24MHz）配置 Flash 编程等待时序。频率配错会导致编程失败或读出错误。

2. 页擦除时序（关键）

PY32 的 Flash 只能按页擦除（不能字节擦除），擦前须全 1。LL 的擦除动作由一连串寄存器操作组成：

等 BUSY=0；
使能 EOP 标志；
LL_FLASH_EnablePageErase() 进入页擦除模式；
LL_FLASH_SetEraseAddress() 设地址；
再等 BUSY=0 与 EOP=1，清 EOP、退出擦除模式。

注意每擦一页都要重复这套时序，且地址按 FLASH_PAGE_SIZE 递增。

3. 页编程时序

写入同理：进入页编程模式 → LL_FLASH_PageProgram() 写一页 → 等 BUSY/EOP → 清标志、退出。HAL 把这套时序封在 HAL_FLASH_Program() 里，LL 则逐句暴露，你能清楚看到“模式开关”和“EOP 轮询”的存在。

4. 校验与加锁

擦除后 APP_FlashBlank() 确认全是 0xFFFFFFFF（否则说明没擦干净，进错误）。
编程后 APP_FlashVerify() 回读与源数据比对。
最后 LL_FLASH_Lock() 重新加锁，防止误操作改写代码区。

实验现象

下载程序，复位后按住用户按键触发擦写流程（或先不按，等决定时机）。
流程执行完且校验通过 → 板载绿 LED 常亮。
掉电再上电，0x08004000 处的数据依然保留（可用调试器 memory 窗口查看）。
若校验失败 → 程序停在 APP_ErrorHandler() 死循环（LED 不亮）。

常见问题

写入后读出来是 0x00000000 或乱码？
- 几乎都是漏了 LL_FLASH_TIMMING_SEQUENCE_CONFIG_24M()，或系统时钟实际频率与设置不符。
- 确认解锁 LL_FLASH_Unlock() 在写操作之前。
擦写把程序搞挂了？
- 确认 FLASH_USER_START_ADDR(0x08004000) 不在你程序的占用区间内。用超过芯片容量的地址也会失败。
想存用户配置（如校准值）？
- 把 DATA[] 换成你的结构体，注意按 4 字节对齐；读取时直接从该地址 HW32_REG() 读回。

小结

LL 写 Flash 范式：解锁 → 配时序 → 循环(等BUSY→使能页操作→设地址→等EOP→清标志)擦除/编程 → 加锁 → 校验。
相比 HAL，LL 把“页操作模式开关”“EOP 标志轮询”等底层时序完全摊开，理解更深。
“先配时序、再解锁、按页操作、最后加锁”是必须遵守的铁律。

拓展应用

把示例改成“只在数据变化时才擦写”，延长 Flash 寿命（Flash 擦写次数有限）。
配合“双备份+版本号”做掉电安全的参数存储。
用扇区擦除（FLASH_SectorEraseAndWrite 示例）适配不同颗粒。
结合 IAP（在应用中编程）做固件远程升级。

PUYA GPIO — GPIO 翻转输出（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

GPIO — GPIO 翻转输出（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/GPIO/GPIO_Toggle/Src/main.c

功能简介

本示例与 HAL 版功能完全相同：让一个 GPIO 引脚工作于输出模式，主循环里周期性翻转电平，板载 LED（PA11，丝印 LED3）闪烁。区别只在于底层 API 用的是 LL 库而非 HAL 库。

通过这一最简单示例，可以直观体会 HAL 与 LL 的写法差异：

HAL 用 HAL_GPIO_Init() 传一个 GPIO_InitTypeDef 结构体完成配置；
LL 直接调用 LL_GPIO_SetPinMode() 一行设置模式，更接近“操作寄存器”，代码更短、依赖更少。

硬件准备

PY32F030 开发板（或 PY32F002A / F003 官方 STK 板）
板载 LED（PA11，对应 LED3）
一根 USB 数据线用于供电与下载
无需额外外接元件

提示：若你手上板子的 LED 不在 PA11，修改下方 LED3_PIN 相关宏即可。

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

/* 把板载 LED3 映射成一组好记的宏，方便后续修改 */
#define LED_GPIO_PIN                   LED3_PIN
#define LED_GPIO_PORT                  LED3_GPIO_PORT
#define LED_GPIO_CLK_ENABLE()          LED3_GPIO_CLK_ENABLE()

/* 函数声明 */
static void APP_SystemClockConfig(void);
static void APP_GpioConfig(void);

int main(void)
{
  /* 1. 配置系统时钟（LL 版需要手动配时钟，HAL 在 HAL_Init 里代劳了部分） */
  APP_SystemClockConfig();

  /* 2. 配置 LED 引脚为输出 */
  APP_GpioConfig();

  /* 3. 先熄灭 LED（输出高电平，低电平点亮，取决于硬件） */
  LL_GPIO_SetOutputPin(LED_GPIO_PORT, LED_GPIO_PIN);

  /* 4. 主循环：每 100ms 翻转一次 */
  while (1)
  {
    LL_mDelay(100);                                   /* LL 自带的毫秒延时 */
    LL_GPIO_TogglePin(LED_GPIO_PORT, LED_GPIO_PIN);   /* 翻转引脚电平 */
  }
}

/**
  * @brief  系统时钟配置
  */
static void APP_SystemClockConfig(void)
{
  /* 使能 HSI 并等待就绪 */
  LL_RCC_HSI_Enable();
  while (LL_RCC_HSI_IsReady() != 1) {}

  /* AHB 不分频 */
  LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);

  /* 选 HSISYS 作为系统时钟源 */
  LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_HSISYS);
  while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_HSISYS) {}

  /* APB1 不分频，并初始化 1ms 时基与系统时钟全局变量 */
  LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
  LL_Init1msTick(8000000);
  LL_SetSystemCoreClock(8000000);
}

/**
  * @brief  GPIO 引脚配置
  */
static void APP_GpioConfig(void)
{
  /* 必须先开时钟，否则配置无效（LL 不会自动帮你开） */
  LED_GPIO_CLK_ENABLE();

  /* 一行设置引脚为输出模式，复位后默认就是推挽、低速、无上下拉 */
  LL_GPIO_SetPinMode(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_MODE_OUTPUT);

  /* 下面这些都是“复位默认值”，注释掉也能工作，写出来便于理解
  LL_GPIO_SetPinOutputType(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_OUTPUT_PUSHPULL);
  LL_GPIO_SetPinSpeed(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_SPEED_FREQ_LOW);
  LL_GPIO_SetPinPull(LED_GPIO_PORT, LED_GPIO_PIN, LL_GPIO_PULL_NO);
  */
}

/**
  * @brief  错误处理：卡死在此处便于调试
  */
void APP_ErrorHandler(void)
{
  while (1) {}
}

代码分段讲解

1. LL 没有“统一初始化入口”

HAL 版第一行是 HAL_Init()，它顺手初始化了 HAL 库、SysTick、中断优先级等。LL 版没有这个总入口，所以你需要自己调用 APP_SystemClockConfig() 把系统时钟配好，否则 LL_mDelay() 的时基是错的。

2. 时钟使能：LL 更“裸”

HAL：__HAL_RCC_GPIOA_CLK_ENABLE()（由 LED_GPIO_CLK_ENABLE() 宏展开）。
LL：LED_GPIO_CLK_ENABLE() 这个宏本身两版都用，但它的底层就是直接写 RCC 寄存器。关键点：LL 不会在初始化时自动开时钟，忘记开时钟是 LL 初学者最常见的 bug。

3. 引脚配置：结构体 vs 直接函数

HAL：HAL_GPIO_Init() 接收 GPIO_InitTypeDef，一次设置 Pin/Mode/Pull/Speed。
LL：LL_GPIO_SetPinMode() 单功能函数，一行只做一件事。优点是不需要构造结构体、代码更短；缺点是多个属性要分多行写（不过多数属性复位值就是你要的）。

4. 翻转与延时

LL_GPIO_TogglePin() 与 HAL_GPIO_TogglePin() 语义一致，都是读-反-写。
LL_mDelay(100) 对应 HAL 的 HAL_Delay(100)，都是基于 SysTick 的阻塞毫秒延时。注意 LL 版延时前必须先调 LL_Init1msTick() 设定正确的 tick 频率（在 APP_SystemClockConfig 里已做）。

实验现象

板载 LED（PA11）以约 5Hz（每 100ms 一次）的频率闪烁，比 HAL 版（250ms）更快。
用示波器/逻辑分析仪测量 PA11，可见周期约 200ms 的方波。

常见问题

LED 不闪 / 闪得很怪？
- 先确认 APP_SystemClockConfig() 里 LL_Init1msTick() 的参数和 LL_SetSystemCoreClock() 与实际 HSI 频率一致（本例 8MHz）。参数不对，LL_mDelay 时序会整体偏移。
- 确认 LED 实际引脚与 LED3_PIN 一致。
编译报 LL_GPIO_xxx 未定义？
- LL 函数分散在 stm32py32..._ll_gpio.h 等头文件中，确认工程已包含 py32f030xx_ll_Start_Kit.h 以及对应的 LL 驱动头。
想改成非阻塞闪烁？
- 同 HAL 版思路，用 TIM 更新中断翻转引脚；LL 里对应 LL_TIM_xxx 系列函数（见 TIM1_PWM_Init 示例）。

小结

LL 版 GPIO 输出三步依然是：开时钟 → 设模式 → 翻转/写电平，但全部由 LL_GPIO_* / LL_RCC_* 直接操作完成。
与 HAL 的最大区别：LL 没有 HAL_Init() 这种“一站式”初始化，系统时钟、LL_mDelay 时基都要自己配。
代码更短、编译体积更小、对寄存器行为更透明——这是 LL 的核心价值。

拓展应用

把 LL_mDelay 换成 TIM 中断，做多 LED 不同频率非阻塞闪烁。
配合 LL_GPIO_SetPinOutputType() 把引脚设为开漏（LL_GPIO_OUTPUT_OPENDRAIN），驱动需要线与的总线设备。
用 LL_GPIO_ReadInputPort() 读取按键，实现按键控制 LED（LL 版 GPIO_INPUT 思路同 HAL）。
结合 TIM1_PWM_Init 示例，用 LL_TIM_OC_SetCompareCHx() 做呼吸灯。

PUYA I2C — 主机轮询通信（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

I2C — 主机轮询通信（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/I2C/I2C_TwoBoard_CommunicationMaster_Polling_Init/Src/main.c

功能简介

本示例演示 I2C 主机（Master）轮询模式：按键后，主机先向从机地址 0xA0 发送 15 字节，再从中机读回 15 字节（对端跑 Slave 示例做回环），最后比对收发数据——一致则点亮 LED，不一致则 LED 闪烁报错。

与 HAL 版（HAL_I2C_Master_Transmit / HAL_I2C_Master_Receive 一行搞定）相比，LL 版把 I2C 的完整状态机摊开在你面前：起始条件 → 地址 → 数据 → 停止条件，每一步都靠轮询标志位（SB/ADDR/TXE/BTF/RXNE）推进。代码长，但能让你真正搞懂 I2C“为什么这么写”。

硬件准备

两块 PY32F030 开发板（一块作主、一块作从）
主从板 SCL(PA9) 与 SDA(PA10) 交叉相连，并各自接上拉电阻（示例里已配置内部上拉）
主机板载按键（KEY）、绿 LED
串口/LED 用于判断结果

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define I2C_ADDRESS        0xA0     /* 从机地址 */
#define I2C_SPEEDCLOCK     100000   /* 100K 标准速率 */
#define I2C_STATE_READY    0
#define I2C_STATE_BUSY_TX  1
#define I2C_STATE_BUSY_RX  2

uint8_t aTxBuffer[15] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t aRxBuffer[15] = {0};

uint8_t         *pBuffPtr  = NULL;
__IO uint16_t   XferCount  = 0;
__IO uint32_t   Devaddress = 0;
__IO uint32_t   State      = I2C_STATE_READY;

static void APP_SystemClockConfig(void);
static void APP_ConfigI2cMaster(void);
static void APP_MasterTransmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size);
static void APP_MasterReceive(uint16_t DevAddress, uint8_t *pData, uint16_t Size);
static void APP_CheckEndOfTransfer(void);
static uint8_t APP_Buffercmp8(uint8_t* pBuffer1, uint8_t* pBuffer2, uint8_t BufferLength);
static void APP_LedBlinking(void);

int main(void)
{
  APP_SystemClockConfig();
  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  APP_ConfigI2cMaster();

  while (BSP_PB_GetState(BUTTON_KEY) == 1);   /* 等待按键按下 */

  APP_MasterTransmit(I2C_ADDRESS, (uint8_t *)aTxBuffer, sizeof(aTxBuffer));
  while (State != I2C_STATE_READY);           /* 等发送完 */
  APP_MasterReceive(I2C_ADDRESS, (uint8_t *)aRxBuffer, sizeof(aRxBuffer));
  while (State != I2C_STATE_READY);           /* 等接收完 */

  APP_CheckEndOfTransfer();                   /* 比对结果 */
  while (1) {}
}

/**
  * @brief  I2C 主机 GPIO + 外设配置
  */
static void APP_ConfigI2cMaster(void)
{
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);
  LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_I2C1);

  /* SCL=PA9, SDA=PA10：复用、开漏、上拉、AF6 */
  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
  GPIO_InitStruct.Pin        = LL_GPIO_PIN_9;
  GPIO_InitStruct.Mode       = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed      = LL_GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_OPENDRAIN;   /* I2C 必须开漏 */
  GPIO_InitStruct.Pull       = LL_GPIO_PULL_UP;
  GPIO_InitStruct.Alternate  = LL_GPIO_AF_6;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_10;
  LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

  /* 复位 I2C 外设 */
  LL_APB1_GRP1_ForceReset(LL_APB1_GRP1_PERIPH_I2C1);
  LL_APB1_GRP1_ReleaseReset(LL_APB1_GRP1_PERIPH_I2C1);

  LL_I2C_InitTypeDef I2C_InitStruct = {0};
  I2C_InitStruct.ClockSpeed      = I2C_SPEEDCLOCK;
  I2C_InitStruct.DutyCycle       = LL_I2C_DUTYCYCLE_16_9;
  I2C_InitStruct.OwnAddress1     = I2C_ADDRESS;
  I2C_InitStruct.TypeAcknowledge = LL_I2C_NACK;
  LL_I2C_Init(I2C1, &I2C_InitStruct);
}

/**
  * @brief  LL 主机发送：起始→地址→数据→停止，全程轮询标志
  */
static void APP_MasterTransmit(uint16_t DevAddress, uint8_t *pData, uint16_t Size)
{
  pBuffPtr = pData; XferCount = Size; Devaddress = DevAddress;
  State = I2C_STATE_BUSY_TX;

  LL_I2C_GenerateStartCondition(I2C1);
  while (LL_I2C_IsActiveFlag_SB(I2C1) != 1);           /* 等起始条件发送完 */

  LL_I2C_TransmitData8(I2C1, (Devaddress & (uint8_t)(~0x01)));  /* 发写地址(末位0) */
  while (LL_I2C_IsActiveFlag_ADDR(I2C1) != 1);
  LL_I2C_ClearFlag_ADDR(I2C1);                          /* 清地址标志 */

  while (XferCount > 0)
  {
    while (LL_I2C_IsActiveFlag_TXE(I2C1) != 1);         /* 等发送寄存器空 */
    LL_I2C_TransmitData8(I2C1, *pBuffPtr);              /* 发一字节 */
    pBuffPtr++; XferCount--;
    while (LL_I2C_IsActiveFlag_BTF(I2C1) != 1);         /* 等字节发完(BTF) */
  }

  LL_I2C_GenerateStopCondition(I2C1);                   /* 发停止条件 */
  State = I2C_STATE_READY;
}

/**
  * @brief  LL 主机接收：起始→地址(读)→接收 N 字节→停止
  */
static void APP_MasterReceive(uint16_t DevAddress, uint8_t *pData, uint16_t Size)
{
  pBuffPtr = pData; XferCount = Size; Devaddress = DevAddress;
  State = I2C_STATE_BUSY_RX;

  LL_I2C_AcknowledgeNextData(I2C1, LL_I2C_ACK);        /* 先允许 ACK */
  LL_I2C_GenerateStartCondition(I2C1);
  while (LL_I2C_IsActiveFlag_SB(I2C1) != 1);
  LL_I2C_TransmitData8(I2C1, (Devaddress | 0x1));      /* 发读地址(末位1) */
  while (LL_I2C_IsActiveFlag_ADDR(I2C1) != 1);
  LL_I2C_ClearFlag_ADDR(I2C1);

  while (XferCount > 0)
  {
    while (LL_I2C_IsActiveFlag_RXNE(I2C1) != 1);        /* 等收到一字节 */
    *pBuffPtr = LL_I2C_ReceiveData8(I2C1);              /* 读一字节 */
    pBuffPtr++; XferCount--;
  }
  State = I2C_STATE_READY;
}

/* APP_CheckEndOfTransfer / APP_Buffercmp8 / APP_LedBlinking / 时钟与错误处理
   与前述示例同构，略 */

代码分段讲解

1. 开漏 + 上拉：I2C 物理层铁律

I2C 总线靠“线与”工作，SCL/SDA 必须开漏（LL_GPIO_OUTPUT_OPENDRAIN）+ 外部/内部上拉。示例用内部上拉（LL_GPIO_PULL_UP）。HAL 版在 HAL_I2C_Init 里通过 I2C_HandleTypeDef 同样隐含了这些设置，但 LL 让你看得一清二楚。

2. 发送状态机（核心）

LL 的发送就是“手搓 I2C 协议帧”：

LL_I2C_GenerateStartCondition() 拉出 START；
等 SB 标志 → 写从机地址（写=地址&0xFE）；
等 ADDR 标志并清除 → 进入数据传输；
每字节等 TXE（发送寄存器空）写数据，再等 BTF（字节传输完）；
最后 LL_I2C_GenerateStopCondition() 发 STOP。

对比 HAL：HAL_I2C_Master_Transmit() 把以上 5 步全藏在库里，你只传“地址+缓冲区+长度”。

3. 接收状态机

接收时地址末位置 1（读=地址|0x01），之后轮询 RXNE 逐字节读取。示例为简化只演示了“固定长度、一直 ACK”的情形；HAL 内部还处理了“最后一字节发 NACK + STOP”的时序细节（源码里那些 XferCount<=3 的分支就是干这个的）。

4. 没有超时！

注意这些 while(标志 != 1); 都是死等。真实总线若从机无响应（地址错、没接上拉、线断），程序会卡死。真实项目务必加超时或改用中断（I2C_TwoBoard_CommunicationMaster_IT_Init）。

实验现象

主从两块板 SCL/SDA 连接好，从机先跑 Slave 示例。
主机按下 KEY，先向 0xA0 发 15 字节。
主机再读回 15 字节，与发送缓冲比对。
一致 → 绿 LED 常亮；不一致 → 绿 LED 闪烁。

常见问题

卡在等 ADDR / 一直不进数据？
- 最常见：从机地址不对、SCL/SDA 没接上拉、主从没共地。
- 确认从机确实在跑对应的 Slave 示例并监听 0xA0。
死等卡死？
- LL 轮询无超时。用逻辑分析仪看波形，确认 START/地址是否真的出现在总线上。
想用中断而不是轮询？
- 参考 I2C_TwoBoard_CommunicationMaster_IT_Init，用 LL_I2C_EnableIT_xxx + 回调处理。

小结

LL 的 I2C 主机 = 手搓协议帧：START → 地址 → 数据 → STOP，每步轮询标志。
相比 HAL 的“一行收发”，LL 代码长但完全透明，没有隐藏时序。
物理层（开漏+上拉）和“无超时死等”是两个最需要警惕的点。

拓展应用

把轮询改成中断/IT 版本，避免阻塞主循环。
接入真实传感器（如 EEPROM、温湿度芯片），把 0xA0 换成器件真实地址。
用 DMA 搬运长数据（参考 I2C_TwoBoard_CommunicationMaster_DMA_Init）。
增加超时退出，提升总线异常时的鲁棒性。

PUYA SPI — 全双工主机（中断方式）（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

SPI — 全双工主机（中断方式）（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/SPI/SPI_TwoBoards_FullDuplexMaster_IT_Init/Src/main.c

功能简介

本示例演示 SPI 全双工主机（Master），使用中断方式：按键后使能 SPI1，通过 TXE/RXNE 中断逐字节发送 15 字节，同时接收对方回环的数据，结束后比对收发一致性——一致则点亮 LED，否则 LED 闪烁。

说明：PUYA 的 LL 示例库里 SPI 只有 DMA 和中断（IT）两种版本，没有轮询（Polling）版。你点名要的 SPI_TwoBoards_FullDuplexMaster_Polling 在 LL 中不存在，这里用最接近、也最能体现 LL 风格的 ..._IT_Init（中断方式）来替代。HAL 版则有 ..._Master_DMA，可作为对照。

与 HAL 版（HAL_SPI_TransmitReceive）相比，LL 版把“每个字节的收发”交给中断回调函数 APP_SpiTxCallback() / APP_SpiRxCallback() 完成，主循环只需等传输完成——这正是 LL 在“不阻塞 CPU”场景下的典型写法。

硬件准备

两块 PY32F030 开发板（一块主机、一块从机，跑对应 Slave 示例做回环）
SPI 连线：主机 PB3(SCK) ↔ 从机 SCK，PB4(MISO) ↔ MISO，PB5(MOSI) ↔ MOSI
主机板载按键（KEY）、绿 LED

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

uint8_t aTxBuffer[] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
uint8_t ubNbDataToTransmit = sizeof(aTxBuffer);
uint8_t ubTransmitIndex = 0;

uint8_t aRxBuffer[sizeof(aTxBuffer)] = {0};
uint8_t ubNbDataToReceive = sizeof(aTxBuffer);
uint8_t ubReceiveIndex = 0;

static void APP_SystemClockConfig(void);
static void APP_ConfigSPI(void);
static void APP_WaitAndCheckEndOfTransfer(void);
static uint8_t APP_Buffercmp8(uint8_t* pBuffer1, uint8_t* pBuffer2, uint8_t BufferLength);
static void APP_LedBlinking(void);

int main(void)
{
  APP_SystemClockConfig();
  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  APP_ConfigSPI();                        /* 配置 SPI1 + 中断 */

  while (BSP_PB_GetState(BUTTON_KEY) == 1);   /* 等按键 */

  LL_SPI_Enable(SPI1);                    /* 使能 SPI1，中断随即开始搬运 */
  APP_WaitAndCheckEndOfTransfer();        /* 等传输完并校验 */

  while (1) {}
}

/**
  * @brief  SPI1 配置（PB3/4/5 复用 + 参数 + 中断）
  */
static void APP_ConfigSPI(void)
{
  LL_SPI_InitTypeDef   SPI_InitStruct = {0};
  LL_GPIO_InitTypeDef GPIO_InitStruct = {0};

  LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_SPI1);
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOB);

  /* PB3=SCK, PB4=MISO, PB5=MOSI，全部复用 AF0 */
  GPIO_InitStruct.Pin        = LL_GPIO_PIN_3;
  GPIO_InitStruct.Mode       = LL_GPIO_MODE_ALTERNATE;
  GPIO_InitStruct.Speed      = LL_GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  GPIO_InitStruct.Pull       = LL_GPIO_PULL_UP;
  GPIO_InitStruct.Alternate  = LL_GPIO_AF_0;
  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_4;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;     /* MISO 无需上拉 */
  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  GPIO_InitStruct.Pin = LL_GPIO_PIN_5;
  GPIO_InitStruct.Pull = LL_GPIO_PULL_NO;
  LL_GPIO_Init(GPIOB, &GPIO_InitStruct);

  /* SPI1 中断 */
  NVIC_SetPriority(SPI1_IRQn, 1);
  NVIC_EnableIRQ(SPI1_IRQn);

  /* SPI 参数：全双工、主机、8 位、极性高/相位1边沿、软件 NSS、128 分频 */
  SPI_InitStruct.TransferDirection = LL_SPI_FULL_DUPLEX;
  SPI_InitStruct.Mode              = LL_SPI_MODE_MASTER;
  SPI_InitStruct.DataWidth         = LL_SPI_DATAWIDTH_8BIT;
  SPI_InitStruct.ClockPolarity     = LL_SPI_POLARITY_HIGH;
  SPI_InitStruct.ClockPhase        = LL_SPI_PHASE_1EDGE;
  SPI_InitStruct.NSS               = LL_SPI_NSS_SOFT;
  SPI_InitStruct.BaudRate          = LL_SPI_BAUDRATEPRESCALER_DIV128;
  SPI_InitStruct.BitOrder          = LL_SPI_MSB_FIRST;
  LL_SPI_Init(SPI1, &SPI_InitStruct);

  LL_SPI_SetRxFIFOThreshold(SPI1, LL_SPI_RX_FIFO_TH_QUARTER);  /* RXNE 在收到 1 字节时置位 */

  LL_SPI_EnableIT_TXE(SPI1);   /* 使能“发送空”中断 */
  LL_SPI_EnableIT_RXNE(SPI1);  /* 使能“接收非空”中断 */
  LL_SPI_EnableIT_ERR(SPI1);   /* 使能错误中断 */
}

/* 以下回调由 SPI1 中断服务程序调用（在 stm32py32xx_it.c 中） */
void APP_SpiRxCallback(void)
{
  aRxBuffer[ubReceiveIndex++] = LL_SPI_ReceiveData8(SPI1);   /* 读 DR 同时清 RXNE */
}
void APP_SpiTxCallback(void)
{
  LL_SPI_TransmitData8(SPI1, aTxBuffer[ubTransmitIndex++]);  /* 写 DR 启动一次收发 */
}
void APP_SpiTransferErrorCallback(void)
{
  LL_SPI_DisableIT_RXNE(SPI1);
  LL_SPI_DisableIT_TXE(SPI1);
  APP_LedBlinking();
}

/**
  * @brief  等待收发完成并比对
  */
static void APP_WaitAndCheckEndOfTransfer(void)
{
  while (ubTransmitIndex != ubNbDataToTransmit) {}   /* 等发完 */
  LL_SPI_DisableIT_TXE(SPI1);
  while (ubNbDataToReceive > ubReceiveIndex) {}      /* 等收完 */
  LL_SPI_DisableIT_RXNE(SPI1);

  if (APP_Buffercmp8((uint8_t*)aTxBuffer, (uint8_t*)aRxBuffer, ubNbDataToTransmit))
    APP_LedBlinking();
  else
    BSP_LED_On(LED_GREEN);
}
/* APP_Buffercmp8 / APP_LedBlinking / 时钟与错误处理 略 */

代码分段讲解

1. GPIO 复用与 SPI 参数

PB3/4/5 设为 LL_GPIO_MODE_ALTERNATE + Alternate = LL_GPIO_AF_0 接到 SPI1。SPI 参数结构体 LL_SPI_InitTypeDef 与 HAL 的 SPI_HandleTypeDef.Init 字段几乎一一对应：全双工、主机、8 位、CPOL/CPHA、软件 NSS、波特率分频、MSB 优先。

2. 中断方式的核心：TXE / RXNE 回调

HAL 的 HAL_SPI_TransmitReceive() 内部要么轮询、要么用 DMA；LL 这里走中断：

使能 LL_SPI_EnableIT_TXE()：发送缓冲区空时进中断 → APP_SpiTxCallback() 写一个字节，SPI 硬件同时自动收一个字节；
使能 LL_SPI_EnableIT_RXNE()：收到一个字节进中断 → APP_SpiRxCallback() 读走它。

因为 SPI 是全双工，每发一个必然同时收一个，所以两个索引独立推进，主循环只需等两者都到头。

3. FIFO 阈值

LL_SPI_SetRxFIFOThreshold(..., LL_SPI_RX_FIFO_TH_QUARTER) 让 RXNE 在“收到 1 个字节”时就置位（而不是等 FIFO 半满），保证逐字节中断行为正确。这是 LL 才需要你显式关心的底层细节。

4. 为什么 LL 没有“轮询 SPI”示例

SPI 全双工收发天然适合“发一个收一个”的流式处理，用中断/DMA 比忙等更高效；而 HAL 为了 API 对称提供了 HAL_SPI_TransmitReceive（轮询版）。LL 把“怎么搬”的选择权完全交给你——你可以轻松把本例的 IT 改成轮询（去掉中断、在主循环里查 LL_SPI_IsActiveFlag_TXE）。

实验现象

主从板 SPI 四线连好，从机跑 Slave 示例。
主机按下 KEY，SPI1 使能，开始全双工收发 15 字节。
收发结束，数据比对一致 → 绿 LED 常亮；不一致 → 绿 LED 闪烁。

常见问题

收发数据对不上？
- 确认主从 CPOL/CPHA 一致（本例极性高/相位1边沿）。
- 确认 NSS 处理：本例用软件 NSS（LL_SPI_NSS_SOFT），硬件 NSS 引脚未参与，接线时从机片选要正确拉低。
只进 TX 中断不出 RX？
- 多半是 MISO 线没连通或主从没共地；SPI 收不到字节，RXNE 永远不会置位。
想用 DMA？
- 参考 SPI_TwoBoards_FullDuplexMaster_DMA_Init，用 LL_DMA_* 把缓冲区交给 DMA 搬运，CPU 零参与。

小结

LL 的 SPI 全双工主机 = 配 GPIO 复用 + 配 SPI 参数 + 选中断/DMA/轮询搬运 + 使能。
相比 HAL 的一行 HAL_SPI_TransmitReceive，LL 让你自己决定“字节怎么搬”，中断回调写法最贴近硬件。
SPI 没有 LL 轮询示例，但把 IT 版本去掉中断、改轮询标志即可等价实现。

拓展应用

把 IT 改成纯轮询（查 LL_SPI_IsActiveFlag_TXE/RXNE），代码更简单便于理解。
改用 DMA 搬运长帧，提升吞吐（参考 _DMA_Init）。
接真实 SPI 器件（LCD、Flash、传感器），把回环逻辑换成器件寄存器读写。
增加超时判断，避免从机异常时主循环死等。

PUYA TIMER1 — PWM 输出（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

TIMER1 — PWM 输出（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/TIM/TIM1_PWM_Init/Src/main.c

功能简介

本示例用高级定时器 TIM1 在 PA8 / PA9 / PA10 上输出 3 路 PWM（PWM2 模式），比较值分别设为 250 / 500 / 750，对应占空比 25% / 50% / 75%。接上 LED 即可看到三档亮度，接示波器能看到三路相位相同的 PWM 波。

与 HAL 版（用 HAL_TIM_PWM_Start() 一行启动）相比，LL 版的“启动”被拆成几个显式步骤：配置 GPIO 复用 → 配置输出比较通道 LL_TIM_OC_Init() → 配时基 LL_TIM_Init() → LL_TIM_EnableAllOutputs()（高级定时器特有）→ LL_TIM_EnableCounter()。你会对“PWM 到底怎么出来的”理解得更透。

硬件准备

PY32F030 开发板
可选：3 颗 LED（分别接 PA8 / PA9 / PA10，串 1kΩ 电阻到 GND），或示波器/逻辑分析仪 3 通道
注意：TIM1 是高级定时器，输出前要额外使能主输出（MOE 位）

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

static void APP_SystemClockConfig(void);
static void APP_ConfigTIM1Base(void);
static void APP_ConfigPWMChannel(void);

int main(void)
{
  APP_SystemClockConfig();                       /* 系统时钟配到 24MHz（本例需要） */

  LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_TIM1);  /* 开 TIM1 时钟 */
  LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);   /* 开 GPIOA 时钟 */

  APP_ConfigPWMChannel();    /* 先配 GPIO 复用 + 输出比较参数 */
  APP_ConfigTIM1Base();      /* 再配时基并使能计数器 */

  while (1) {}
}

/**
  * @brief  配置 PWM 引脚复用 + 3 路输出比较
  */
static void APP_ConfigPWMChannel(void)
{
  LL_GPIO_InitTypeDef  TIM1CH1MapInit = {0};
  LL_TIM_OC_InitTypeDef TIM_OC_Initstruct = {0};

  /* PA8/PA9/PA10 复用为 TIM1_CH1/CH2/CH3，AF2 */
  TIM1CH1MapInit.Pin        = LL_GPIO_PIN_8 | LL_GPIO_PIN_9 | LL_GPIO_PIN_10;
  TIM1CH1MapInit.Mode       = LL_GPIO_MODE_ALTERNATE;
  TIM1CH1MapInit.Alternate  = LL_GPIO_AF_2;
  TIM1CH1MapInit.Speed      = LL_GPIO_SPEED_FREQ_HIGH;
  TIM1CH1MapInit.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
  TIM1CH1MapInit.Pull       = LL_GPIO_PULL_NO;
  LL_GPIO_Init(GPIOA, &TIM1CH1MapInit);

  /* 三路都用 PWM2 模式、输出使能、高有效 */
  TIM_OC_Initstruct.OCMode      = LL_TIM_OCMODE_PWM2;
  TIM_OC_Initstruct.OCState     = LL_TIM_OCSTATE_ENABLE;
  TIM_OC_Initstruct.OCPolarity  = LL_TIM_OCPOLARITY_HIGH;
  TIM_OC_Initstruct.OCIdleState = LL_TIM_OCIDLESTATE_LOW;

  TIM_OC_Initstruct.CompareValue = 250;        /* CH1 比较值 250 → 占空比 25% */
  LL_TIM_OC_Init(TIM1, LL_TIM_CHANNEL_CH1, &TIM_OC_Initstruct);

  TIM_OC_Initstruct.CompareValue = 500;        /* CH2 比较值 500 → 占空比 50% */
  LL_TIM_OC_Init(TIM1, LL_TIM_CHANNEL_CH2, &TIM_OC_Initstruct);

  TIM_OC_Initstruct.CompareValue = 750;        /* CH3 比较值 750 → 占空比 75% */
  LL_TIM_OC_Init(TIM1, LL_TIM_CHANNEL_CH3, &TIM_OC_Initstruct);
}

/**
  * @brief  配置 TIM1 时基并使能
  */
static void APP_ConfigTIM1Base(void)
{
  LL_TIM_InitTypeDef TIM1CountInit = {0};

  TIM1CountInit.ClockDivision     = LL_TIM_CLOCKDIVISION_DIV1;  /* 不分频 */
  TIM1CountInit.CounterMode       = LL_TIM_COUNTERMODE_UP;      /* 向上计数 */
  TIM1CountInit.Prescaler         = 2400 - 1;                   /* 预分频 2400 */
  TIM1CountInit.Autoreload        = 1000 - 1;                   /* 自动重装载 1000 */
  TIM1CountInit.RepetitionCounter = 0;
  LL_TIM_Init(TIM1, &TIM1CountInit);

  LL_TIM_EnableAllOutputs(TIM1);   /* 高级定时器：使能主输出 MOE */
  LL_TIM_EnableCounter(TIM1);      /* 启动计数器 */
}

/**
  * @brief  系统时钟配置到 24MHz
  */
static void APP_SystemClockConfig(void)
{
  LL_RCC_HSI_Enable();
  LL_RCC_HSI_SetCalibFreq(LL_RCC_HSICALIBRATION_24MHz);
  while (LL_RCC_HSI_IsReady() != 1) {}
  LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
  LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_HSISYS);
  while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_HSISYS) {}
  LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
  LL_Init1msTick(24000000);
  LL_SetSystemCoreClock(24000000);
}

void APP_ErrorHandler(void)
{
  while (1) {}
}

代码分段讲解

1. 时基与 PWM 频率

定时器时钟 = 系统时钟 24MHz。
Prescaler = 2400-1 → 计数时钟 = 24MHz / 2400 = 10kHz。
Autoreload = 1000-1 → 一个 PWM 周期 = 1000 个计数 = 100ms，即 PWM 频率 10Hz。
占空比 = CompareValue / (Autoreload+1)：250→25%、500→50%、750→75%（PWM2 模式下高/低电平关系与 PWM1 相反，但占空比数值算法相同）。

2. GPIO 复用

PA8/9/10 要设为 LL_GPIO_MODE_ALTERNATE 并指定 Alternate = LL_GPIO_AF_2 才能把引脚内部连到 TIM1。这一步和 USART 的 AF 配置思路完全一致。

3. 输出比较：LL 的“逐通道 Init”

HAL 里 HAL_TIM_PWM_ConfigChannel() 一次配一个通道；LL 里把“通道参数”封装成 LL_TIM_OC_InitTypeDef，逐个通道 LL_TIM_OC_Init()。三路只有 CompareValue 不同，其余（PWM2、使能、极性）共用一套。

4. 高级定时器特有的“主输出使能”

LL_TIM_EnableAllOutputs(TIM1) 设置的是 TIM1 的 BDTR.MOE 位。这是高级定时器（TIM1/TIM16/17）独有的：不使能主输出，PWM 引脚不会有波形。通用定时器（TIM3 等）则不需要这步——这是初学者最容易踩的坑。

5. 启动

最后 LL_TIM_EnableCounter(TIM1) 启动计数器，PWM 立即从引脚输出。LL 没有 HAL_TIM_PWM_Start() 这种“一键启动”，而是“配好 → 使能输出 → 使能计数”三步走。

实验现象

PA8 / PA9 / PA10 输出频率约 10Hz 的 PWM，占空比分别约 25% / 50% / 75%。
接 LED：三颗亮度明显不同（25% 最暗，75% 最亮）。
示波器三路波形相位相同，仅高电平宽度不同。

常见问题

引脚没波形？
- 八成是漏了 LL_TIM_EnableAllOutputs()（高级定时器必须使能主输出）。
- 确认 GPIO 复用 Alternate = LL_GPIO_AF_2 且引脚确实是 PA8/9/10。
频率不对 / 占空比反了？
- 频率由 Prescaler × (Autoreload+1) 与定时器时钟共同决定，先确认系统时钟是 24MHz。
- PWM1 与 PWM2 模式高/低电平相反，想要“比较值越大越亮”可改用 LL_TIM_OCMODE_PWM1。
想动态调占空比？
- 运行中调用 LL_TIM_OC_SetCompareCHx(TIM1, 新值) 即可实时改占空比，无需重新 Init。

小结

LL 配置 PWM 四步：开时钟 → 配 GPIO 复用 → 配 OC 通道参数 → 配时基并使能（高级定时器别忘了主输出）。
相比 HAL 的 HAL_TIM_PWM_Start()，LL 把“使能主输出”“使能计数器”都摊开给你，理解更深、控制更细。
调占空比用 LL_TIM_OC_SetCompareCHx()，调频率改 Prescaler / Autoreload。

拓展应用

在定时器更新中断里逐步改变 CompareValue，做“呼吸灯”。
多路 PWM 组合驱动 RGB LED 调色。
用 PWM 触发 ADC（LL_TIM_SetTriggerOutput）实现同步采样。
改用 TIM3（通用定时器）重复本例，体会“无需主输出使能”的差异。

PUYA USART — 串口轮询收发（LL 库）

Tue, 08 Sep 2026 14:52:21 +0800

USART — 串口轮询收发（LL 库）

HAL vs LL：PUYA 固件库提供 HAL 和 LL 两套 API。

HAL 库：封装度高，可移植性强，适合快速开发

LL 库：接近寄存器操作，代码精简效率高，适合性能敏感场景本文使用 LL 库版本。

固件库: PY32F0xx_Firmware V1.5.0
芯片: PY32F030（PY32F002A / F003 同库可参考）
源文件: PUYA/PY32F0xx_Firmware_V1.5.0/Projects/PY32F030-STK/Example_LL/USART/USART_HyperTerminal_Polling_Init/Src/main.c

功能简介

本示例实现串口“超级终端”式的轮询（Polling）通信：上电后先向电脑发送一段欢迎语，再接收你从键盘敲入的 12 个字符，原样回传，最后点亮 LED 表示测试通过。

与 HAL 版（用 HAL_UART_Transmit / HAL_UART_Receive 一行搞定）不同，LL 版没有封装好的“发 N 字节”函数，需要你自己用 LL_USART_TransmitData8() 逐字节发送，并用 LL_USART_IsActiveFlag_TXE() / LL_USART_IsActiveFlag_RXNE() 轮询标志位。这正是 LL 的典型特征：给你最底层的积木，组合方式由你决定。

硬件准备

PY32F030 开发板
USB 转串口线（或板载 ST-Link VCP），连接到 USART1 的 TX(PA2) / RX(PA3)
电脑端串口助手（如 PuTTY、串口调试助手），波特率 9600 / 8N1
板载绿 LED（用于测试通过指示）

完整代码

#include "main.h"
#include "py32f030xx_ll_Start_Kit.h"

#define COUNTOF(__BUFFER__)   (sizeof(__BUFFER__) / sizeof(*(__BUFFER__)))
#define TXSTARTMESSAGESIZE    (COUNTOF(aTxStartMessage) - 1)
#define TXENDMESSAGESIZE      (COUNTOF(aTxEndMessage) - 1)

uint8_t aRxBuffer[12] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
uint8_t aTxStartMessage[] = "\n\r USART Hyperterminal communication based on polling \n\r Enter 12 characters using keyboard :\n\r";
uint8_t aTxEndMessage[] = "\n\r Example Finished\n\r";

uint8_t *TxBuff = NULL;
__IO uint16_t TxCount = 0;
uint8_t *RxBuff = NULL;
__IO uint16_t RxCount = 0;

static void APP_SystemClockConfig(void);
static void APP_ConfigUsart(USART_TypeDef *USARTx);
static void APP_UsartTransmit(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size);
static void APP_UsartReceive(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size);

int main(void)
{
  APP_SystemClockConfig();

  BSP_LED_Init(LED_GREEN);          /* 初始化 LED，用于测试通过指示 */

  APP_ConfigUsart(USART1);          /* 配置 USART1：PA2/PA3，9600-8N1 */

  /* 发送欢迎语 */
  APP_UsartTransmit(USART1, (uint8_t*)aTxStartMessage, TXSTARTMESSAGESIZE);
  /* 接收 12 字节 */
  APP_UsartReceive(USART1, (uint8_t *)aRxBuffer, 12);
  /* 回传接收到的数据 */
  APP_UsartTransmit(USART1, (uint8_t*)aRxBuffer, 12);
  /* 发送结束语 */
  APP_UsartTransmit(USART1, (uint8_t*)aTxEndMessage, TXENDMESSAGESIZE);

  BSP_LED_On(LED_GREEN);            /* 测试通过，亮灯 */
  while (1) {}
}

/**
  * @brief  系统时钟配置（LL 版，手动配 HSI + 时基）
  */
static void APP_SystemClockConfig(void)
{
  LL_RCC_HSI_Enable();
  while (LL_RCC_HSI_IsReady() != 1) {}
  LL_RCC_SetAHBPrescaler(LL_RCC_SYSCLK_DIV_1);
  LL_RCC_SetSysClkSource(LL_RCC_SYS_CLKSOURCE_HSISYS);
  while (LL_RCC_GetSysClkSource() != LL_RCC_SYS_CLKSOURCE_STATUS_HSISYS) {}
  LL_RCC_SetAPB1Prescaler(LL_RCC_APB1_DIV_1);
  LL_Init1msTick(8000000);
  LL_SetSystemCoreClock(8000000);
}

/**
  * @brief  USART 配置：GPIO 复用 + 波特率等参数
  */
static void APP_ConfigUsart(USART_TypeDef *USARTx)
{
  if (USARTx == USART1)
  {
    LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA);          /* 开 GPIOA 时钟 */
    LL_APB1_GRP2_EnableClock(LL_APB1_GRP2_PERIPH_USART1);       /* 开 USART1 时钟 */

    LL_GPIO_InitTypeDef GPIO_InitStruct = {0};
    GPIO_InitStruct.Pin        = LL_GPIO_PIN_2;                 /* PA2 = TX */
    GPIO_InitStruct.Mode       = LL_GPIO_MODE_ALTERNATE;        /* 复用功能 */
    GPIO_InitStruct.Speed      = LL_GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL;
    GPIO_InitStruct.Pull       = LL_GPIO_PULL_UP;
    GPIO_InitStruct.Alternate  = LL_GPIO_AF1_USART1;            /* 复用为 USART1 */
    LL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = LL_GPIO_PIN_3;                       /* PA3 = RX */
    LL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  }
  /* 若用 USART2，结构类似，复用 AF4，此处略 */

  /* USART 参数 */
  LL_USART_InitTypeDef USART_InitStruct = {0};
  USART_InitStruct.BaudRate            = 9600;
  USART_InitStruct.DataWidth           = LL_USART_DATAWIDTH_8B;
  USART_InitStruct.StopBits            = LL_USART_STOPBITS_1;
  USART_InitStruct.Parity              = LL_USART_PARITY_NONE;
  USART_InitStruct.TransferDirection   = LL_USART_DIRECTION_TX_RX;
  USART_InitStruct.HardwareFlowControl = LL_USART_HWCONTROL_NONE;
  USART_InitStruct.OverSampling        = LL_USART_OVERSAMPLING_16;
  LL_USART_Init(USARTx, &USART_InitStruct);

  LL_USART_ConfigAsyncMode(USARTx);     /* 配置为全双工异步模式 */
  LL_USART_Enable(USARTx);              /* 使能 USART 模块 */
}

/**
  * @brief  LL 轮询发送：逐字节等待 TXE 后写入
  */
static void APP_UsartTransmit(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size)
{
  TxBuff  = pData;
  TxCount = Size;
  while (TxCount > 0)
  {
    while (LL_USART_IsActiveFlag_TXE(USARTx) != 1);   /* 等待发送数据寄存器空 */
    LL_USART_TransmitData8(USARTx, *TxBuff);          /* 写入一个字节 */
    TxBuff++;
    TxCount--;
  }
  while (LL_USART_IsActiveFlag_TC(USARTx) != 1);      /* 等待发送完成 */
}

/**
  * @brief  LL 轮询接收：逐字节等待 RXNE 后读取
  */
static void APP_UsartReceive(USART_TypeDef *USARTx, uint8_t *pData, uint16_t Size)
{
  RxBuff  = pData;
  RxCount = Size;
  while (RxCount > 0)
  {
    while (LL_USART_IsActiveFlag_RXNE(USARTx) != 1);  /* 等待接收数据寄存器非空 */
    *RxBuff = LL_USART_ReceiveData8(USARTx);          /* 读出一个字节 */
    RxBuff++;
    RxCount--;
  }
}

void APP_ErrorHandler(void)
{
  while (1) {}
}

代码分段讲解

1. 时钟与 GPIO 复用

LL 里 GPIO 和 USART 的时钟分属不同的“组”：GPIO 在 LL_IOP_GRP1，USART1 在 LL_APB1_GRP2。这和 HAL 的 __HAL_RCC_xxx_CLK_ENABLE() 宏对应，但名字更直白地反映了总线分组。PA2/PA3 要设为 LL_GPIO_MODE_ALTERNATE 并指定 Alternate = LL_GPIO_AF1_USART1，才能把引脚接到 USART1。

2. 参数配置：结构体 + Init

LL 的 LL_USART_Init() 同样接收结构体，这一点和 HAL 的 UART_InitTypeDef 很像——LL 并不是完全不用结构体，而是把“一次性参数”用结构体批量写入，把“运行时动作”拆成独立函数。

3. 发送：手动轮询 TXE

HAL 一句 HAL_UART_Transmit() 内部帮你做了“等待 TXE→写 DR→等待 TC”的循环；LL 把这段循环直接暴露给你：

1
2

while (LL_USART_IsActiveFlag_TXE(USARTx) != 1);  /* 等空 */
LL_USART_TransmitData8(USARTx, byte);            /* 写一字节 */

好处是你可以精确控制发送节奏、插入其它操作，甚至做“发送一半去干别的事”这类 HAL 难以表达的逻辑。

4. 接收：手动轮询 RXNE

同理，接收就是等 RXNE（接收寄存器非空）后 LL_USART_ReceiveData8() 读一个字节。注意 LL 没有“超时”概念，若对方不发数据，这里的 while 会永远等下去——真实项目务必加超时或改用中断/DMA。

实验现象

打开串口助手（9600 / 8N1），复位开发板。
先收到欢迎语：USART Hyperterminal communication based on polling ... Enter 12 characters ...。
在串口助手输入恰好 12 个字符并发送，开发板原样回传这 12 个字符。
最后收到 Example Finished，板载绿 LED 点亮，表示流程成功。

常见问题

串口助手收不到任何字符？
- 确认 TX/RX 交叉连接（板子 TX 接 USB 转串口的 RX）。
- 确认波特率 9600、8 位数据、1 停止位、无校验、无流控，与代码一致。
- 确认 APP_SystemClockConfig() 里系统时钟确实是 8MHz（LL_Init1msTick(8000000)），否则波特率实际值会偏离。
输入不足 12 字符程序就“卡住”？
- LL 轮询接收没有超时，必须收满 12 字节才继续。这是示例故意为之；真实项目建议加超时或改用中断。
想重定向 printf？
- LL 版需要自己实现 _write() / fputc() 并在里面调用 LL_USART_TransmitData8()；HAL 版则常配合 HAL_UART_Transmit 做重定向（参见 HAL 版文档）。

小结

LL 串口收发 = 结构体配参数 + 独立函数做动作 + 手动轮询标志位。
相比 HAL_UART_Transmit/Receive，LL 代码更长，但每一步都看得见、改得动，没有隐藏的超时/状态机。
性能敏感或资源紧张时，LL 能省下 HAL 那一层封装开销。

拓展应用

给轮询接收加超时计数，避免“永远等待”。
改用 LL_USART_EnableIT_RXNE() + 中断回调函数，实现不阻塞的串口接收（参考 USART_HyperTerminal_IT_Init）。
用 DMA 搬运大量数据（参考 USART_HyperTerminal_DMA_Init），CPU 几乎零参与。
把发送函数封装成 printf 风格的可变参数函数，方便打日志。