LL on CLing

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 风格的可变参数函数，方便打日志。