F403特色 on CLing

PUYA CANFD — 经典帧基址 ID 轮询收发 CANFD_Classic_BaseID_polling

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

CANFD — 经典帧基址 ID 轮询收发 CANFD_Classic_BaseID_polling

固件库: PY32F403_Firmware V1.4.5
芯片: PY32F403（Cortex-M4）⭐ F403 特色外设
源文件: PY32F403-STK/Example/CANFD/CANFD_Classic_BaseID_polling/Src/main.c
核心外设: CANFD（兼容 CAN 2.0B / CAN-FD），PA11/PA12

1. 功能简介（大白话）

这是 F403 特色外设 CANFD 的入门例子。它演示「经典 CAN 帧（非 FD）+ 轮询方式」的收发：

把 CANFD 配成经典帧、正常模式、波特率 250Kbps；
设置过滤器：只收 ID = 0x12F 的报文（标准 11 位 ID）；
MCU 自动发一帧 ID=0x123、8 字节数据 {1,2,3,4,5,6,7,8} 出去（给 PC 上的 PCAN-View 看）；
然后轮询等待接收 FIFO 有数据，一旦从 PCAN-View 收到 ID=0x12F 的 8 字节，就通过串口 printf 把数据打出来。

简单说：MCU 主动发一帧 → PC 收到；PC 手动回一帧 0x12F → MCU 收到并打印。整个过程没有中断，CPU 一直「盯着」接收 FIFO 等数据（轮询）。

2. 硬件准备

物品	说明
PY32F403-STK 开发板	自带 CANFD（PA11/PA12）+ 调试串口
USB 转 CAN 模块 + CAN 转接板	接 STK 的 CAN 差分脚
USB 转 TTL 模块	接 STK 的 USART2 看 printf
PC + PCAN-View 软件	收发 CAN 帧

CAN 接线（STK → CAN 转接板）：

STK 板              CAN 转接板
PA11 (CAN_RX)  -->  R21
PA12 (CAN_TX)  -->  R20
GND            -->  GND

CAN 转接板 → USB 转 CAN 模块：

1
2

CAN-H  -->  CAN-H
CAN-L  -->  CAN-L

串口接线（看 printf 输出）：

STK 板          USB 转 TTL 模块
PA02 (TX)  -->  RX
PA03 (RX)  -->  TX
GND        -->  GND

PCAN-View 配置：协议 CAN 2.0，Clock Frequency 20MHz，Nominal Bit Rate 250kBit/s，Data Bit Rate 不设置，Standard。

3. 完整代码（带中文注释）

#include "main.h"

CANFD_HandleTypeDef CanfdHandle;
CANFD_FilterTypeDef CanfdFilter;

CANFD_TxHeaderTypeDef CanfdTxHeader;
uint8_t TxData[] = {0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8};

CANFD_RxHeaderTypeDef CanfdRxHeader;
uint8_t RxData[8] = {0};

/* DLC(数据长度码) → 实际字节数 查表（FD 帧可达 64）*/
uint8_t DLCtoBytes[] = {0,1,2,3,4,5,6,7,8,12,16,20,24,32,48,64};

int main(void)
{
  uint32_t i = 0;
  HAL_Init();
  APP_SystemClockConfig();   /* 系统时钟：HSE；CAN 时钟在 MSP 里配成 20MHz */
  BSP_USART_Config();       /* 调试串口（printf 用，115200）*/

  /* ---------- CANFD 基本配置 ---------- */
  CanfdHandle.Instance                  = CANFD;
  CanfdHandle.Init.FrameFormat          = CANFD_FRAME_CLASSIC;  /* 经典帧（非 FD）*/
  CanfdHandle.Init.Mode                 = CANFD_MODE_NORMAL;     /* 正常模式 */
  CanfdHandle.Init.Prescaler            = 1U;                    /* 波特率分频 */
  CanfdHandle.Init.NominalSyncJumpWidth = 16U;                   /* 同步跳转宽度 */
  CanfdHandle.Init.NominalTimeSeg1      = 64U;                   /* 时间段1 */
  CanfdHandle.Init.NominalTimeSeg2      = 16U;                   /* 时间段2 */
  CanfdHandle.Init.DataSyncJumpWidth    = 16U;                   /* FD 数据段（此处同值）*/
  CanfdHandle.Init.DataTimeSeg1         = 64U;
  CanfdHandle.Init.DataTimeSeg2         = 16U;
  CanfdHandle.Init.SecondSamplePointOffset = 0U;
  if (HAL_CANFD_Init(&CanfdHandle) != HAL_OK) APP_ErrorHandler();

  /* ---------- 过滤器：只收 ID = 0x12F ---------- */
  CanfdFilter.IdType        = CANFD_STANDARD_ID;     /* 11 位标准 ID */
  CanfdFilter.FilterChannel = CANFD_FILTER_CHANNEL_0;
  CanfdFilter.Rank          = CANFD_FILTER_RANK_CHANNEL_NUMBER;
  CanfdFilter.FilterID      = 0x12F;                 /* 目标 ID */
  CanfdFilter.FilterFormat  = 0xFFFFFFFF;
  CanfdFilter.MaskID        = 0x0;                   /* Mask=0 → 精确匹配 0x12F */
  CanfdFilter.MaskFormat    = 0xFFFFFFFF;
  if (HAL_CANFD_ConfigFilter(&CanfdHandle, &CanfdFilter) != HAL_OK) APP_ErrorHandler();

  /* ---------- 启动 CANFD ---------- */
  if (HAL_CANFD_Start(&CanfdHandle) != HAL_OK) APP_ErrorHandler();

  /* ---------- 组装并发送一帧（PTB 优先缓冲）---------- */
  CanfdTxHeader.Identifier  = 0x123;                /* 发出去的帧 ID */
  CanfdTxHeader.IdType      = CANFD_STANDARD_ID;
  CanfdTxHeader.TxFrameType = CANFD_DATA_FRAME;      /* 数据帧 */
  CanfdTxHeader.FrameFormat = CANFD_FRAME_CLASSIC;
  CanfdTxHeader.Handle      = 0x0;
  CanfdTxHeader.DataLength  = CANFD_DLC_BYTES_8;     /* 8 字节 */
  if (HAL_CANFD_AddMessageToTxFifo(&CanfdHandle, &CanfdTxHeader, TxData,
                                   CANFD_TX_FIFO_PTB) != HAL_OK) APP_ErrorHandler();
  if (HAL_CANFD_ActivateTxRequest(&CanfdHandle, CANFD_TXFIFO_PTB_SEND) != HAL_OK)
    APP_ErrorHandler();

  /* ---------- 轮询等待接收 ---------- */
  while (__HAL_CANFD_GET_RX_FIFO_FILL_LEVEL(&CanfdHandle) == CANFD_RX_FIFO_EMPTY) {}
  if (HAL_CANFD_GetRxMessage(&CanfdHandle, &CanfdRxHeader, RxData) != HAL_OK)
    APP_ErrorHandler();

  /* ---------- 打印收到的数据 ---------- */
  printf("decimal data length: %d\r\n", DLCtoBytes[CanfdRxHeader.DataLength]);
  printf("hexadecimal data: \r\n");
  for (i = 0; i < DLCtoBytes[CanfdRxHeader.DataLength]; i++)
    printf("%x ", RxData[i]);

  while (1) {}
}

/**
  * @brief  系统时钟：HSE 作系统时钟；CAN 时钟在 MSP 中单独配成 20MHz
  */
static void APP_SystemClockConfig(void)
{
  RCC_OscInitTypeDef  OscInitstruct = {0};
  RCC_ClkInitTypeDef  ClkInitstruct = {0};

  OscInitstruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  OscInitstruct.HSEState       = RCC_HSE_ON;
  OscInitstruct.HSEFreq        = RCC_HSE_16_32MHz;     /* 板载 HSE 24MHz */
  OscInitstruct.HSIState       = RCC_HSI_ON;
  OscInitstruct.HSI48MState    = RCC_HSI48M_OFF;
  OscInitstruct.LSEState       = RCC_LSE_OFF;
  OscInitstruct.LSIState       = RCC_LSI_OFF;
  OscInitstruct.PLL.PLLState   = RCC_PLL_OFF;           /* 系统时钟用 HSE 直驱 */
  if (HAL_RCC_OscConfig(&OscInitstruct) != HAL_OK) APP_ErrorHandler();

  ClkInitstruct.ClockType      = RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK |
                                 RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  ClkInitstruct.SYSCLKSource   = RCC_SYSCLKSOURCE_HSE;  /* 24MHz */
  ClkInitstruct.AHBCLKDivider  = RCC_SYSCLK_DIV1;
  ClkInitstruct.APB1CLKDivider = RCC_HCLK_DIV1;
  ClkInitstruct.APB2CLKDivider = RCC_HCLK_DIV2;
  if (HAL_RCC_ClockConfig(&ClkInitstruct, FLASH_LATENCY_0) != HAL_OK) APP_ErrorHandler();
}

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

附：MSP 里的时钟与引脚配置（HAL_CANFD_Init 自动调用）

void HAL_CANFD_MspInit(CANFD_HandleTypeDef *hcan)
{
  RCC_OscInitTypeDef OscInitstruct = {0};
  GPIO_InitTypeDef   GPIO_InitStruct = {0};

  /* PLL 来源 HSE(24M) ×5 = 120MHz */
  OscInitstruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  OscInitstruct.HSEState       = RCC_HSE_ON;
  OscInitstruct.HSEFreq        = RCC_HSE_16_32MHz;
  OscInitstruct.PLL.PLLState   = RCC_PLL_ON;
  OscInitstruct.PLL.PLLSource  = RCC_PLLSOURCE_HSE;
  OscInitstruct.PLL.PLLMUL     = RCC_PLL_MUL5;     /* 24M ×5 = 120MHz */
  HAL_RCC_OscConfig(&OscInitstruct);

  /* CAN 时钟 = PLL /6 = 20MHz（PCAN-View 也要配 20MHz）*/
  __HAL_RCC_CAN_CONFIG(RCC_CANCLKSOURCE_PLL_DIV6);

  __HAL_RCC_CAN_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();

  /* PA11=CAN_RX, PA12=CAN_TX（均 AF10，复用推挽）*/
  GPIO_InitStruct.Pin       = GPIO_PIN_11 | GPIO_PIN_12;
  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull      = GPIO_NOPULL;
  GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF10_CAN;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

4. 代码分段讲解

4.1 经典帧 vs FD 帧

CANFD_FRAME_CLASSIC = 经典 CAN 2.0，单帧最多 8 字节，仲裁段与数据段同速。若改成 CANFD_FRAME_FD，则数据段可用更高波特率、最大 64 字节（对应 DLCtoBytes 表里 12~64 的值）。

4.2 波特率 250K 是怎么来的？

CAN 时钟 = 20MHz，每个 Tq（时间量子）= Prescaler / 20MHz = 50ns。一位 = (SYNC_SEG=1 + TS1=64 + TS2=16) = 81 个 Tq：

`1`	`位时间 = 81 × 50ns ≈ 4.05µs → 波特率 ≈ 247kHz ≈ 250Kbps`

PUYA 的 SyncJumpWidth/TimeSeg1/TimeSeg2 直接以 Tq 个数为单位，所以数值偏大是正常的。FD 帧的 DataTimeSeg1/2 独立控制数据段更高速率。

4.3 过滤器 MaskID=0 的含义

过滤器只在「收到的 ID 与 FilterID(0x12F) 完全一致」时才放进 RX FIFO（MaskID=0 = 精确匹配）。MCU 自己发出的帧 ID 是 0x123（给 PC 看），而它接收的是 PC 发来的 0x12F——所以 PCAN-View 手动发 0x12F 才会被收下并打印；发别的 ID 会被硬件丢弃。

4.4 发送：PTB + 激活

HAL_CANFD_AddMessageToTxFifo(..., CANFD_TX_FIFO_PTB) 把报文放进优先发送缓冲（PTB），HAL_CANFD_ActivateTxRequest(PTB_SEND) 触发硬件发出。STm32 风格里 TX 要显式「激活请求」。

4.5 接收：轮询 FIFO

__HAL_CANFD_GET_RX_FIFO_FILL_LEVEL 查接收 FIFO 是否为空；非空则 HAL_CANFD_GetRxMessage 取出帧头与数据。因为是轮询，CPU 在 while 里空转等，最简单但占 CPU——想解放 CPU 可换 *_IT（中断）版本。

5. 实验现象

烧录复位后，PCAN-View 会立即收到 MCU 发出的 ID=0x123、8 字节 1 2 3 4 5 6 7 8；
在 PCAN-View 里手动发送 ID=0x12F、8 字节 数据；
STK 的调试串口（115200）打印：

1
2
3

decimal data length: 8
hexadecimal data:
x1 x2 x3 x4 x5 x6 x7 x8

（x1~x8 为你从 PCAN-View 发出的数值）

6. 常见问题

现象	原因	解决
PCAN-View 收不到 MCU 发的帧	CANH/CANL 接反 / 没终端电阻	确认差分线序；总线两端各 120Ω
MCU 串口不打印	过滤器 ID 不匹配	用 PCAN-View 发 ID=0x12F；不要发别的
报错误帧/波特率不对	CAN 时钟或 Bit Timing 错	确认 CAN 时钟 20MHz，且 PCAN 配 250K
单板想自测	没有第二节点	把 `Mode` 改为 `CANFD_MODE_LOOPBACK` 内部回环
想发超过 8 字节	用了经典帧	改 `CANFD_FRAME_FD` 并设置 Data 段更高波特率
printf 无输出	串口接线/波特率	PA2→RX、PA3→TX、115200-8-N-1

7. 小结

CANFD 是 F403 特色外设，兼容经典 CAN 2.0B 与 CAN-FD；
引脚固定 PA11(RX)/PA12(TX) AF10，时钟由 PLL 分频而来（本例 20MHz）；
流程：Init → ConfigFilter → Start → AddMessageToTxFifo → ActivateTxRequest → 轮询 Rx；
经典帧单帧 ≤8 字节；过滤器 MaskID=0 做精确 ID 匹配；
本例 250K，MCU 发 0x123、收 0x12F 并打印，是 CAN 入门最佳样本。

8. 拓展应用（学了能做什么项目）

汽车/工业节点：定义 ID 优先级矩阵，多 ECU 协同；
多板互联：用过滤器分组，主节点轮询各从节点传感器；
升级 CAN-FD：提高数据段波特率、传 64 字节，做固件 OTA / 图像下发；
中断化：参考 CANFD_ExtendedID_IT，收帧即进回调，释放 CPU；
回环自测：参考 CANFD_ExtendedID_LBMI/LBME_polling，无外设也能验证协议栈；
BMS / 机器人：多电芯电压、关节状态经 CAN 汇总到主控制器。

返回：CANFD 总览

PUYA ESMC — 外部 QSPI Flash 读写（轮询）ESMC_ReadWrite_Polling

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

ESMC — 外部 QSPI Flash 读写（轮询）ESMC_ReadWrite_Polling

固件库: PY32F403_Firmware V1.4.5
芯片: PY32F403（Cortex-M4）⭐ F403 特色外设
源文件: PY32F403-STK/Example/ESMC/ESMC_ReadWrite_Polling/Src/main.c
核心外设: ESMC（驱动板载 P25Q64 QSPI NOR Flash）

1. 功能简介（大白话）

ESMC 是 F403 用来驱动外部串行 Flash 的专用控制器，本例用它操作板载的 P25Q64（8MB 的 QSPI NOR Flash），把 4096 字节测试数据写进去再读出来比对：

准备 4096 字节测试数据（0,1,2,...,255 循环）；
ESMC 初始化（时钟分频、单线指令、关闭双 Flash）；
写使能 → 等 BUSY 清零；
扇区擦除（4KB）；
开启 QE 位（Quad Enable，让四根数据线生效）；
四线页编程（按 256 字节/页写入）；
四线快读 回读；
校验一致则点亮绿灯，否则熄灭进入错误循环。

相当于给 MCU 「外挂了一块 8MB 硬盘」，且用的是四线 QSPI，比前面 SPI 例程的单线 Flash 快得多。这是 F403 相对基础系列多出来的招牌能力。

2. 硬件准备

物品	说明
PY32F403-STK 开发板	板载 P25Q64 QSPI Flash + 绿色 LED
USB 线	供电 + 下载

ESMC 与 P25Q64 的引脚连接（STK 板载已接好，AF10）：

P25Q64	信号	MCU 引脚
CLK	时钟	PB10
SS0 / CS	片选	PA2
IO0（SI）	数据0	PB1
IO1（SO）	数据1	PB0
IO2（WP）	数据2	PA7
IO3（HOLD）	数据3	PA6

无需串口，结果用 LED 表示：亮 = 成功，不亮/灭 = 失败。

3. 完整代码（带中文注释）

#include "main.h"
#define BUFFERSIZE 4096

ESMC_HandleTypeDef hesmc;
ESMC_InitTypeDef    ESMC_initTypeDef;
uint8_t aRxBuffer[BUFFERSIZE];
uint8_t aTxBuffer[BUFFERSIZE];
uint8_t flashStatus;

/* 函数声明 */
static void APP_EsmcInit(void);
static void APP_WriteEnable(void);
static void APP_EraseSector(uint32_t address);
static void APP_PageProgram(uint8_t *pdata, uint32_t addr, uint32_t Nbytes);
static void APP_DataRead(uint8_t *pData, uint32_t address, uint32_t nBytes);
static HAL_StatusTypeDef APP_DataCheck(uint8_t *pSrc, uint8_t *pDst, uint32_t length);
static void APP_SetFlashStatus(uint8_t status, uint8_t comm);
static uint8_t APP_GetFlashStatus(uint8_t comm);

int main(void)
{
  uint32_t i = 0, cnt = 0, progAddr = 0;
  uint8_t *pData = NULL;
  uint32_t address = 0;

  HAL_Init();
  BSP_LED_Init(LED_GREEN);

  /* 准备测试数据 0,1,2,...,255 循环 */
  for (i = 0; i < BUFFERSIZE; i++) aTxBuffer[i] = i % 256;

  APP_EsmcInit();          /* 1. ESMC 初始化 */

  APP_WriteEnable();        /* 2. 写使能 */
  while (APP_GetFlashStatus(0x05) & 0x01) {}   /* 等 BUSY 清 */

  APP_EraseSector(address); /* 3. 扇区擦除（4KB）*/
  while (APP_GetFlashStatus(P25Q64_READ_STATUS_REG_CMD) & 0x01) {}

  /* 4. 开启 QE 位（状态寄存器1 的 bit1）*/
  flashStatus = APP_GetFlashStatus(P25Q64_READ_STATUS_REG_1_CMD);
  flashStatus |= 0x02;
  APP_WriteEnable();
  while (APP_GetFlashStatus(0x05) & 0x01) {}
  APP_SetFlashStatus(flashStatus, P25Q64_WRITE_STATUS_REG_1_CMD);
  while (APP_GetFlashStatus(P25Q64_READ_STATUS_REG_CMD) & 0x01) {}

  /* 5. 分页编程（每页 256 字节）*/
  cnt = BUFFERSIZE; progAddr = address; pData = aTxBuffer;
  while (cnt / P25Q64_PAGE_SIZE > 0)
  {
    APP_PageProgram(pData, progAddr, P25Q64_PAGE_SIZE);
    while (APP_GetFlashStatus(P25Q64_READ_STATUS_REG_CMD) & 0x01) {}
    cnt      -= P25Q64_PAGE_SIZE;
    progAddr += P25Q64_PAGE_SIZE;
    pData    += P25Q64_PAGE_SIZE;
  }
  if (cnt > 0) {
    APP_PageProgram(pData, progAddr, cnt);
    while (APP_GetFlashStatus(P25Q64_READ_STATUS_REG_CMD) & 0x01) {}
  }

  /* 6. 读回并校验 */
  APP_DataRead(aRxBuffer, address, BUFFERSIZE);
  if (HAL_OK != APP_DataCheck(aRxBuffer, aTxBuffer, BUFFERSIZE))
  {
    BSP_LED_Off(LED_GREEN);
    APP_ErrorHandler();
  }
  BSP_LED_On(LED_GREEN);   /* 成功亮灯 */
  while (1) {}
}

/* ---------- ESMC 初始化 ---------- */
static void APP_EsmcInit(void)
{
  __HAL_RCC_ESMC_CLK_ENABLE();
  hesmc.Instance = ESMC;
  ESMC_initTypeDef.ClockPrescaler = 0x8;             /* 时钟分频（决定 QSPI 速率）*/
  ESMC_initTypeDef.ClockMode      = ESMC_CLOCK_MODE_0; /* CPOL=0, CPHA=0 */
  ESMC_initTypeDef.DualFlash      = ESMC_DUALFLASH_DISABLE;
  hesmc.Init = ESMC_initTypeDef;
  HAL_ESMC_Init(&hesmc);
}

/* ---------- 读状态寄存器 ---------- */
static uint8_t APP_GetFlashStatus(uint8_t command)
{
  ESMC_CommandTypeDef cmdStc = {0};
  uint8_t status;
  cmdStc.TransferFormat    = ESMC_TRANSFER_FORMAT_SINGLE;
  cmdStc.InstructionMode   = ESMC_INSTRUCTION_SINGLE_LINE;
  cmdStc.Instruction       = command;                /* 如 0x05 读状态 */
  cmdStc.AddressMode       = ESMC_ADDRESS_NONE;
  cmdStc.DummyCycles       = 0x0;
  cmdStc.DdrMode           = ESMC_DDR_DISABLE;
  cmdStc.DataMode          = ESMC_DATA_READ;
  cmdStc.NbData            = 1;
  cmdStc.CSPinSel          = ESMC_SELECT_PIN_CS0;     /* 选 CS0(PA2) */
  HAL_ESMC_Command(&hesmc, &cmdStc, 0x0000FFFF);
  HAL_ESMC_Receive(&hesmc, &status, 0x0000FFFF);
  return status;
}

/* ---------- 写状态寄存器 ---------- */
static void APP_SetFlashStatus(uint8_t status, uint8_t command)
{
  ESMC_CommandTypeDef cmdStc = {0};
  cmdStc.TransferFormat  = ESMC_TRANSFER_FORMAT_SINGLE;
  cmdStc.InstructionMode = ESMC_INSTRUCTION_SINGLE_LINE;
  cmdStc.Instruction     = command;                  /* 如 0x31 写状态1 */
  cmdStc.AddressMode     = ESMC_ADDRESS_NONE;
  cmdStc.DataMode        = ESMC_DATA_WRITE;
  cmdStc.NbData          = 1;
  cmdStc.CSPinSel        = ESMC_SELECT_PIN_CS0;
  HAL_ESMC_Command(&hesmc, &cmdStc, 0x0000FFFF);
  HAL_ESMC_Transmit(&hesmc, &status, 0x0000FFFF);
}

/* ---------- 写使能（06h）---------- */
static void APP_WriteEnable(void)
{
  ESMC_CommandTypeDef commandStc = {0};
  commandStc.TransferFormat  = ESMC_TRANSFER_FORMAT_SINGLE;
  commandStc.InstructionMode = ESMC_INSTRUCTION_SINGLE_LINE;
  commandStc.Instruction     = P25Q64_WRITE_ENABLE_CMD; /* 0x06 */
  commandStc.AddressMode     = ESMC_ADDRESS_NONE;
  commandStc.DataMode        = ESMC_DATA_NONE;
  commandStc.CSPinSel        = ESMC_SELECT_PIN_CS0;
  HAL_ESMC_Command(&hesmc, &commandStc, 0x0000FFFF);
}

/* ---------- 扇区擦除（20h，4KB）---------- */
static void APP_EraseSector(uint32_t address)
{
  ESMC_CommandTypeDef cmdStc = {0};
  APP_WriteEnable();
  cmdStc.TransferFormat  = ESMC_TRANSFER_FORMAT_SINGLE;
  cmdStc.InstructionMode = ESMC_INSTRUCTION_SINGLE_LINE;
  cmdStc.Instruction     = P25Q64_SECTOR_ERASE_4K_CMD; /* 0x20 */
  cmdStc.AddressMode     = ESMC_ADDRESS_SINGLE_LINE;
  cmdStc.AddressSize     = ESMC_ADDRESS_24_BITS;
  cmdStc.Address         = address;
  cmdStc.DataMode        = ESMC_DATA_NONE;
  cmdStc.CSPinSel        = ESMC_SELECT_PIN_CS0;
  HAL_ESMC_Command(&hesmc, &cmdStc, 0x0000FFFF);
}

/* ---------- 四线页编程（32h）---------- */
static void APP_PageProgram(uint8_t *pData, uint32_t addr, uint32_t nBytes)
{
  ESMC_CommandTypeDef cmdStc = {0};
  APP_WriteEnable();
  cmdStc.TransferFormat  = ESMC_TRANSFER_FORMAT_QUAD;   /* 四线传输数据 */
  cmdStc.InstructionMode = ESMC_INSTRUCTION_SINGLE_LINE;/* 指令仍单线 */
  cmdStc.Instruction     = P25Q64_QUAD_INPUT_PAGE_PROG_CMD; /* 0x32 */
  cmdStc.AddressMode     = ESMC_ADDRESS_SINGLE_LINE;
  cmdStc.AddressSize     = ESMC_ADDRESS_24_BITS;
  cmdStc.Address         = addr;
  cmdStc.DummyCycles     = 0x0;
  cmdStc.DataMode        = ESMC_DATA_WRITE;
  cmdStc.NbData          = nBytes;
  cmdStc.CSPinSel        = ESMC_SELECT_PIN_CS0;
  HAL_ESMC_Command(&hesmc, &cmdStc, 0x0000FFFF);
  HAL_ESMC_Transmit(&hesmc, pData, 0x0000FFFF);
}

/* ---------- 四线快读（6Bh）---------- */
static void APP_DataRead(uint8_t *pData, uint32_t address, uint32_t nBytes)
{
  ESMC_CommandTypeDef cmdStc = {0};
  cmdStc.TransferFormat  = ESMC_TRANSFER_FORMAT_QUAD;   /* 四线读数据 */
  cmdStc.InstructionMode = ESMC_INSTRUCTION_SINGLE_LINE;
  cmdStc.Instruction     = P25Q64_1I4O_FAST_READ_CMD;  /* 0x6B：指令单线，数据四线 */
  cmdStc.AddressMode     = ESMC_ADDRESS_SINGLE_LINE;
  cmdStc.AddressSize     = ESMC_ADDRESS_24_BITS;
  cmdStc.Address         = address;
  cmdStc.DummyCycles     = DUMMY_CLOCK_CYCLES_READ;     /* 8 个哑周期 */
  cmdStc.DataMode        = ESMC_DATA_READ;
  cmdStc.NbData          = nBytes;
  cmdStc.CSPinSel        = ESMC_SELECT_PIN_CS0;
  HAL_ESMC_Command(&hesmc, &cmdStc, 0x00FFFFFF);
  HAL_ESMC_Receive(&hesmc, pData, 0x00FFFFFF);
}

/* ---------- 数据比对 ---------- */
static HAL_StatusTypeDef APP_DataCheck(uint8_t *pSrc, uint8_t *pDst, uint32_t length)
{
  for (uint32_t i = 0; i < length; i++)
    if (pSrc[i] != pDst[i]) return HAL_ERROR;
  return HAL_OK;
}

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

附：MSP 里的引脚配置（HAL_ESMC_Init 自动调用）

void HAL_ESMC_MspInit(ESMC_HandleTypeDef *hesmc)
{
  __HAL_RCC_ESMC_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();
  __HAL_RCC_GPIOC_CLK_ENABLE();

  GPIO_InitTypeDef GPIO_InitStructure = {0};
  GPIO_InitStructure.Mode      = GPIO_MODE_AF_PP;
  GPIO_InitStructure.Alternate = GPIO_AF10_ESMC;       /* 全部 AF10 */
  GPIO_InitStructure.Speed     = GPIO_SPEED_FREQ_VERY_HIGH;

  /* CLK=PB10, IO0=PB1, IO1=PB0 */
  GPIO_InitStructure.Pin = GPIO_PIN_10; GPIO_InitStructure.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
  GPIO_InitStructure.Pin = GPIO_PIN_1;  HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
  GPIO_InitStructure.Pin = GPIO_PIN_0;  HAL_GPIO_Init(GPIOB, &GPIO_InitStructure);
  /* IO2=PA7, IO3=PA6, SS0=PA2（上拉）*/
  GPIO_InitStructure.Pin = GPIO_PIN_7; GPIO_InitStructure.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
  GPIO_InitStructure.Pin = GPIO_PIN_6; HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
  GPIO_InitStructure.Pin = GPIO_PIN_2; HAL_GPIO_Init(GPIOA, &GPIO_InitStructure);
}

4. 代码分段讲解

4.1 ESMC 的「命令描述符」模型

ESMC 把一次 Flash 访问拆成两步：

HAL_ESMC_Command()：用 ESMC_CommandTypeDef 描述本次操作——指令码、指令线数、是否带地址、地址位数、数据方向（读/写）、数据线数（单/双/四）、数据长度、CS 引脚；
HAL_ESMC_Transmit / Receive：按描述真正搬数据。

这种「描述符 + 传输」模型非常灵活，一套 API 通吃各种 QSPI 器件，不用手写位时序。

4.2 单线指令 + 四线数据

注意一个关键设计：指令阶段几乎都用单线（INSTRUCTION_SINGLE_LINE，成本低兼容好），而数据阶段才用四线（TRANSFER_FORMAT_QUAD）。例如：

写：0x32（QUAD_INPUT_PAGE_PROG）指令单线发，后面数据四线写；
读：0x6B（1I4O_FAST_READ）指令单线发，读回数据四线收，中间插 8 个哑周期（Dummy）。

4.3 四线为什么必须开 QE？

四线要用 IO2/IO3 两根线，但这两根线默认是 WP/HOLD 功能。必须在**状态寄存器 1 的 bit1（QE 位）**置 1，Flash 才把它们切换成数据线。本例在擦除后专门读-改-写状态寄存器开启 QE——没开 QE 就四线读写会失败。

4.4 写使能与 BUSY 轮询（铁律）

任何擦/写前必须发 Write Enable（0x06）；操作期间状态寄存器 BUSY 位=1，代码用 while (GetFlashStatus & 0x01) 轮询等到清零，才能下一步。这是所有 SPI/QSPI NOR Flash 的通用约定。

4.5 页编程与跨页

P25Q64 每页 256 字节，一次最多写一页。本例 4096 字节用 while (cnt / 256 > 0) 循环分 16 页写，余数单独补一页。且每次写前地址所在扇区必须已擦除（4KB 扇区擦除已覆盖这 4096 字节）。

4.6 时钟分频

ClockPrescaler = 0x8 决定 QSPI 接口时钟频率（由 ESMC 输入时钟分频而来）。想提速可减小分频，但要保证在 Flash 手册允许范围内。

5. 实验现象

烧录运行后：绿色 LED 常亮 = 擦→写→读→校验全部成功；
若失败（如型号不匹配、QE 未开、接线错）：LED 不亮或熄灭，卡在 APP_ErrorHandler。

6. 常见问题

现象	原因	解决
LED 不亮（校验失败）	Flash 型号不是 P25Q64	指令宏 `P25Q64_*` 与芯片匹配；换型号需改指令/页大小
四线读写失败	QE 位没成功开启	检查 `APP_SetFlashStatus` 流程，确认状态1 bit1=1
写不进去	没 WriteEnable / 没擦除	写前使能且目标区已擦除（全 0xFF）
BUSY 一直为 1	操作未完成/异常	检查指令与 CS 引脚选择（CS0=PA2）
速率上不去	分频太大	减小 `ClockPrescaler`，勿超 Flash 上限
大块数据慢	轮询阻塞	参考 `ESMC_ReadWrite_DMA`、`ESMC_ReadWriteQuad_IT`

7. 小结

ESMC 是 F403 特色外设，用「命令描述符 + 传输」统一驱动 QSPI/Octo 串行存储器；
QSPI Flash 写流程铁律：写使能 → 等 BUSY → 擦除 → 写使能 → 页编程 → 等 BUSY → 读 → 校验；
指令通常单线发，开 QE 后数据用四线搬，速度翻数倍；
引脚全部 AF10：CLK=PB10、CS=PA2、IO0~3=PB1/PB0/PA7/PA6；
本例擦 4KB、分 16 页写 4096 字节、四线读回，LED 亮即成功。

8. 拓展应用（学了能做什么项目）

字库/图片/UI 资源库：把字模、位图存外部 Flash，内部 Flash 只放代码；
数据记录仪：日志、采样缓存写外部 Flash，断电不丢；
固件 OTA：新固件先存外部 Flash，校验后切换启动；
内存映射 XIP：参考 ESMC_MemoryMapping，把外部 Flash 映射成地址空间直接执行代码，突破内部容量；
双 Flash 并行：参考 ESMC_ReadWrite_TwoFlash_Polling，翻倍带宽；
大块资源搬运：参考 ESMC_ReadWrite_DMA，用 DMA 把音频/视频资源送到 LCD/Codec。

返回：ESMC 总览

PUYA I2S — 双板主机轮询收发 I2S_TwoBoard_CommunicationMaster_Polling

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

I2S — 双板主机轮询收发 I2S_TwoBoard_CommunicationMaster_Polling

固件库: PY32F403_Firmware V1.4.5
芯片: PY32F403（Cortex-M4）⭐ F403 特色外设
源文件: PY32F403-STK/Example/I2S/I2S_TwoBoard_CommunicationMaster_Polling/Src/main.c
核心外设: SPI2 复用为 I2S（PB12=WS / PB13=CK / PB15=SD）

1. 功能简介（大白话）

I2S 是数字音频专用的总线。本例把 PY32F403 的 SPI2 外设切换成 I2S 模式，当作主机（Master），和另一块板（从机 Slave）对传音频样本：

主机先以 I2S_MODE_MASTER_TX 把 16 个 16 位数据 {1,2,...,16} 发给从机；
从机收到后回发同样数据；
主机再切换成 I2S_MODE_MASTER_RX 把从机回发的数据收回来；
比较「发出去的是否等于收回来的」：一致点亮 LED，不一致 LED 闪烁。

虽然是「数据回环」式验证，但流程与真实音频链路完全一致：MCU 用 I2S 把 PCM 样本送给 DAC 播出来，或从 ADC/麦克风收样本。

2. 硬件准备

物品	数量	说明
PY32F403-STK 开发板	2	一块烧主机(Master_Polling)，一块烧从机(Slave_Polling)
USB 线	2	供电 + 下载

接线（主从一一对应，务必共地）：

主机 MASTER              从机 SLAVE
SD  (PB15)  <----->  SD  (PB15)
WS  (PB12)  ----->   WS  (PB12)
CK  (PB13)  ----->   CK  (PB13)
GND         <----->  GND

操作：

主机烧 I2S_TwoBoard_CommunicationMaster_Polling，从机烧 I2S_TwoBoard_CommunicationSlave_Polling；
主从都上电并按复位键；
先按从机用户键让从机先跑，再按主机用户键启动主机；
主从 LED 由灭变常亮 = 收发成功；任一 LED 闪烁 = 失败。

I2S 是同步总线，主机提供 CK 和 WS，从机跟随。所以 CK/WS 是主机→从机单向，SD 双向传数据。

3. 完整代码（带中文注释）

#include "main.h"

I2S_HandleTypeDef I2sHandle;
uint16_t TxBuff[16] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
uint16_t RxBuff[16] = {0};
#define DATA_LENGTH  16

/* 函数声明 */
static void APP_SystemClockConfig(void);
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)
{
  HAL_Init();
  APP_SystemClockConfig();          /* 系统时钟：HSI 8MHz */
  BSP_LED_Init(LED_GREEN);
  BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_GPIO);

  while (BSP_PB_GetState(BUTTON_KEY) == 1) {}   /* 等用户键按下 */

  /* ===== 第一步：配置为主机发送（TX）===== */
  I2sHandle.Instance        = SPI2;                 /* I2S 复用 SPI2 */
  I2sHandle.Init.Mode       = I2S_MODE_MASTER_TX;   /* 主机发送 */
  I2sHandle.Init.Standard   = I2S_STANDARD_PHILIPS; /* 飞利浦标准 */
  I2sHandle.Init.DataFormat = I2S_DATAFORMAT_16B;   /* 16 位样本 */
  I2sHandle.Init.MCLKOutput = I2S_MCLKOUTPUT_DISABLE;/* 不用主时钟 MCLK */
  I2sHandle.Init.AudioFreq  = I2S_AUDIOFREQ_8K;     /* 8kHz 采样率 */
  I2sHandle.Init.CPOL       = I2S_CPOL_HIGH;        /* 时钟空闲高 */
  if (HAL_I2S_Init(&I2sHandle) != HAL_OK) APP_ErrorHandler();

  /* 阻塞发送 16 个样本 */
  if (HAL_I2S_Transmit(&I2sHandle, (uint16_t*)TxBuff, DATA_LENGTH, 5000) != HAL_OK)
    APP_ErrorHandler();
  while (HAL_I2S_GetState(&I2sHandle) != HAL_I2S_STATE_READY) {}  /* 等发完 */

  HAL_Delay(1);   /* 给从机一点准备时间 */

  /* ===== 第二步：切换为主机接收（RX）===== */
  I2sHandle.Init.Mode = I2S_MODE_MASTER_RX;         /* 改为主机接收 */
  if (HAL_I2S_Init(&I2sHandle) != HAL_OK) APP_ErrorHandler();

  /* 阻塞接收 16 个样本 */
  if (HAL_I2S_Receive(&I2sHandle, (uint16_t*)RxBuff, DATA_LENGTH, 5000) != HAL_OK)
    APP_ErrorHandler();
  while (HAL_I2S_GetState(&I2sHandle) != HAL_I2S_STATE_READY) {}

  /* ===== 校验 ===== */
  APP_CheckEndOfTransfer();

  while (1) {}
}

/**
  * @brief  比对收发数据：一致亮灯，不一致闪灯
  */
static void APP_CheckEndOfTransfer(void)
{
  if (APP_Buffercmp8((uint8_t*)TxBuff, (uint8_t*)RxBuff, DATA_LENGTH))
    APP_LedBlinking();           /* 失败闪烁 */
  else
    BSP_LED_On(LED_GREEN);       /* 成功常亮 */
}

static uint8_t APP_Buffercmp8(uint8_t* pBuffer1, uint8_t* pBuffer2, uint8_t BufferLength)
{
  while (BufferLength--)
  {
    if (*pBuffer1 != *pBuffer2) return 1;
    pBuffer1++; pBuffer2++;
  }
  return 0;
}

static void APP_LedBlinking(void)
{
  while (1) { BSP_LED_Toggle(LED_GREEN); HAL_Delay(500); }
}

/**
  * @brief  系统时钟：HSI 8MHz（I2S 时钟由 SPI2/APB1 派生，HAL 内部按 AudioFreq 分频）
  */
static void APP_SystemClockConfig(void)
{
  RCC_OscInitTypeDef  OscInitstruct = {0};
  RCC_ClkInitTypeDef  ClkInitstruct = {0};

  OscInitstruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
  OscInitstruct.HSIState       = RCC_HSI_ON;
  OscInitstruct.HSI48MState    = RCC_HSI48M_OFF;
  OscInitstruct.LSEState       = RCC_LSE_OFF;
  OscInitstruct.LSIState       = RCC_LSI_OFF;
  OscInitstruct.PLL.PLLState   = RCC_PLL_OFF;
  if (HAL_RCC_OscConfig(&OscInitstruct) != HAL_OK) APP_ErrorHandler();

  ClkInitstruct.ClockType      = RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_HCLK |
                                 RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  ClkInitstruct.SYSCLKSource   = RCC_SYSCLKSOURCE_HSI;  /* 8MHz */
  ClkInitstruct.AHBCLKDivider  = RCC_SYSCLK_DIV1;       /* HCLK = 8MHz */
  ClkInitstruct.APB1CLKDivider = RCC_HCLK_DIV1;         /* APB1 = 8MHz（SPI2 源）*/
  ClkInitstruct.APB2CLKDivider = RCC_HCLK_DIV2;         /* APB2 = 4MHz */
  if (HAL_RCC_ClockConfig(&ClkInitstruct, FLASH_LATENCY_0) != HAL_OK) APP_ErrorHandler();
}

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

附：MSP 里的引脚配置（HAL_I2S_Init 自动调用）

void HAL_I2S_MspInit(I2S_HandleTypeDef *hi2s)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};
  __HAL_RCC_SPI2_CLK_ENABLE();     /* I2S 复用 SPI2 时钟 */
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /* PB12=WS, PB13=CK, PB15=SD，均 AF14 */
  GPIO_InitStruct.Pin       = GPIO_PIN_12 | GPIO_PIN_13 | GPIO_PIN_15;
  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull      = GPIO_NOPULL;
  GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;
  GPIO_InitStruct.Alternate = GPIO_AF14_I2S2;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
}

4. 代码分段讲解

4.1 为什么用 SPI2 当 I2S？

PY32F403 的 I2S 功能复用在 SPI2 这个外设上（硬件层面共享）。所以代码里 Instance = SPI2，但调用的是 HAL_I2S_* 函数——HAL 会根据你选的 I2S_* 模式把 SPI 模块切到 I2S 工作方式，引脚走 I2S 的 AF14 复用。

4.2 采样率与时钟关系

I2S_AUDIOFREQ_8K 设定目标采样率 8kHz。HAL 内部会用 SPI2（APB1=8MHz）的时钟去分频，产生：

WS 频率 ≈ 8kHz（每 8k 次采样切换一次左右声道）；
CK 频率 = 8k × 16bit × 2声道 = 256kHz。

想换 44.1k/48k 音乐采样率，把 AudioFreq 改掉即可（前提是主时钟能分频得到，必要时打开 MCLK 给 CODEC 作基准）。

4.3 主机先发后收：同一句柄切 Mode

同一 I2sHandle，先 I2S_MODE_MASTER_TX 发完，再 I2S_MODE_MASTER_RX 收，重新 HAL_I2S_Init 即可切换方向。真实音频链路里方向通常固定（DAC 端只发、ADC 端只收），本例为演示才来回切。

4.4 标准格式必须主从一致

I2S_STANDARD_PHILIPS + I2S_CPOL_HIGH 是从机示例默认的格式。只要主从任何一方格式不同（如改成 MSB 对齐），数据就会错位。这是接 CODEC 时最常踩的坑。

4.5 轮询的局限

HAL_I2S_Transmit/Receive 会阻塞到完成或超时（5s）。教学够用，但连续音频流不能这么干——要用 *_DMA 版把样本流持续搬进/出缓冲。这正是 I2S_..._DMA 示例的用途。

5. 实验现象

正确接线、先跑从机再按主机键后：
- 主机 LED 常亮 = 收发校验成功（收到 {1..16}）；
- 任一板 LED 闪烁 = 失败（查接线、共地、主从格式是否一致）。
若用逻辑分析仪抓 CK/WS/SD，可见 WS 以 8kHz 翻转、SD 上逐位送出样本。

6. 常见问题

现象	原因	解决
LED 一直闪（失败）	没共地 / 线序错 / 从机没先跑	接好 GND，CK/WS 主机→从机，SD 交叉；先按从机键
收到全 0 或错乱	主从 Standard/CPOL 不一致	双方都用 PHILIPS + CPOL_HIGH
音频有杂音/采样率偏	系统时钟与 AudioFreq 不匹配	确认主时钟；必要时开 MCLK 输出
想连续播放音乐	轮询占 CPU	改用 `I2S_..._DMA` + 双缓冲
找不到 I2S 引脚	误用 SPI 引脚	I2S2 = PB12/13/15（AF14），不是普通 SPI2 MOSI/MISO
只有一路声道	只发了单声道	I2S 默认立体声；单声道数据需按格式填充

7. 小结

I2S 是音频专用同步总线，由 SPI2 复用实现（引脚 PB12/13/15，AF14）；
配置四要素：标准格式、位宽、采样率、主/从模式，且主从必须完全一致；
例程用 8kHz、16 位，主机先 Master_TX 发 16 样本、再 Master_RX 收回校验；
轮询简单但占 CPU；真实音频流用 DMA/IT 版（I2S_..._DMA）。

8. 拓展应用（学了能做什么项目）

播放提示音/WAV：I2S DAC（MAX98357A）接 SD/CK/WS，DMA 送 PCM 数据；
录音/声控：I2S MEMS 麦克风做采集，配合 FFT 做频谱；
双向音频：CODEC（WM8978）接 I2S，做通话/采集；
不间断音频流：I2S_..._DMA + 双缓冲，从 Flash/SD 卡连续取数据；
数字功放/语音识别前端：I2S 是标准接口，方便对接各类音频芯片。

返回：I2S 音频总线总览

PUYA — CAN / CAN-FD

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

PUYA — CAN / CAN-FD

固件库: PY32F403_Firmware V1.4.5
芯片: PY32F403（Cortex-M4，最高 72MHz）
示例数: 5
⭐ F403 特色外设：这是 F403 高性能系列相对基础系列（如 PY32F0xx）多出来的能力之一。

1. 一句话理解 CAN / CAN-FD

CAN（Controller Area Network）是一种「差分、多主、带仲裁、抗干扰」的工业串行总线，汽车里几乎全车都用它。两根线 CANH / CANL 拧成双绞线，靠两者电压差传数据——不怕共模干扰、不怕地电位差，一条总线能挂很多节点。

CAN-FD（Flexible Data-rate） 是 CAN 的升级版：

仲裁段速率不变（维持兼容，经典帧 250K/500K 等）；
数据段可以跑更高波特率（如 2M、5M），且单帧数据从 8 字节提升到 64 字节；
适合需要「既要实时又要搬大块数据」的场景（固件升级、图像传感等）。

PY32F403 内置的 CANFD 控制器同时兼容经典 CAN 2.0B 和 CAN-FD，用同一个外设切换即可。

2. 为什么 CAN 比 UART/SPI/I2C 更适合「车规/工业」？

特性	UART	SPI/I2C	CAN
物理层	单端	单端	差分（CANH/CANL）
拓扑	点对点	主从/多设备	多主总线，无主从
仲裁	无	地址/片选	非破坏性位仲裁（ID 小优先）
抗干扰	弱	弱	强（差分 + 重同步）
错误检测	弱	弱	强（CRC/ACK/位监控）
最远/节点	短	短	远、多节点

一句话：CAN 为「恶劣环境下的可靠多节点通信」而生；UART/SPI/I2C 更适合板内/短距离。

3. PY32F403 的 CANFD 关键点

外设名 CANFD，引脚固定复用：PA11 = CAN_RX、PA12 = CAN_TX（均 AF10）；
时钟来源固定为 CAN 专用时钟：例程里开启 HSE(24MHz)→PLL×5=120MHz，再 /6 得到 CAN 时钟 20MHz（PCAN-View 里也要配 20MHz）；
两种帧格式：CANFD_FRAME_CLASSIC（经典，≤8 字节）、CANFD_FRAME_FD（FD，≤64 字节）；
两种 ID：CANFD_STANDARD_ID（11 位）、CANFD_EXTENDED_ID（29 位）；
硬件过滤器（Filter）：只让关心的 ID 进 RX FIFO，减轻 CPU 负担；
发送有 PTB（优先发送缓冲）/STB（次级发送缓冲），接收有 RX FIFO。

4. 波特率怎么算？（Bit Timing）

CAN 波特率由「一个位 = 多少个时间量子（Tq）」决定：

1
2
3

位时间 = (SYNC_SEG + TimeSeg1 + TimeSeg2) × Tq
Tq     = Prescaler / CAN时钟
波特率 = 1 / 位时间

本例：Prescaler=1、NominalSyncJumpWidth=16、NominalTimeSeg1=64、NominalTimeSeg2=16，CAN 时钟 20MHz：

1
2
3

Tq = 1/20MHz = 50ns
位时间 = (1 + 64 + 16) × 50ns = 81 × 50ns ≈ 4.05µs
波特率 ≈ 1/4.05µs ≈ 247kHz ≈ 250Kbps

注意：PUYA 的 SyncJumpWidth/TimeSeg1/TimeSeg2 单位是 Tq 个数（含同步段），所以数值偏大属正常。FD 帧还要独立配 DataTimeSeg1/2（数据段可更高波特率）。

5. 经典帧 vs FD 帧

项目	经典帧 Classic	FD 帧 FD
数据段长度	最大 8 字节	最大 64 字节
数据段波特率	与仲裁段相同	可独立更高
兼容性	所有 CAN 节点	需 FD 节点
适用	控制指令、小数据	固件/大块数据

6. 示例列表

示例	说明	重点
CANFD_Classic_BaseID_polling	经典帧·基址 ID·轮询收发	本文详解
CANFD_BaseID_polling	基址 ID·轮询	入门
CANFD_ExtendedID_IT	扩展 29 位 ID·中断	中断接收
CANFD_ExtendedID_LBME_polling	扩展 ID·外部回环·轮询	自测
CANFD_ExtendedID_LBMI_polling	扩展 ID·内部回环·轮询	自测

本系列重点讲解 CANFD_Classic_BaseID_polling。

7. 常见用途

汽车 ECU 节点（发动机、车身、网关）
工业总线（PLC、传感器组网）
机器人关节通信
电池管理系统（BMS）多电芯采集
固件 OTA（CAN-FD 大块数据下发）
两板/多板可靠互联（替代 UART）

下一篇：CANFD 经典帧基址 ID 轮询收发实例详解

PUYA — ESMC 外部串行存储器控制器 (QSPI)

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

PUYA — ESMC 外部串行存储器控制器 (QSPI)

固件库: PY32F403_Firmware V1.4.5
芯片: PY32F403（Cortex-M4，最高 72MHz）
示例数: 6
⭐ F403 特色外设：ESMC（External Serial Memory Controller）是 F403 高性能系列相对基础系列多出来的能力，用来硬件驱动 QSPI / Octo-SPI / HyperBus 等外部串行存储器。

1. 一句话理解 ESMC / QSPI

QSPI（Quad SPI）就是「4 根数据线的 SPI」——普通 SPI 只有 1 根数据线（MOSI），QSPI 用 IO0~IO3 共 4 根同时传数据，吞吐量是普通 SPI 的约 4 倍。

ESMC 是 PY32F403 内部专门控制这类串行存储器的硬件模块。你不用去用 GPIO 软件模拟时序，而是告诉 ESMC「发什么指令、用几根线、读/写多少字节」，它自动把时序跑完。典型外接一颗 P25Q64（8MB 的 QSPI NOR Flash），相当于给 MCU 扩了 8MB 硬盘。

对比：前面讲的 SPI 例程接的是普通 SPI Flash（单线）；ESMC 接的是 Quad SPI Flash（四线），速度快得多，且有统一的「命令描述符」编程模型。

2. 为什么需要它？

场景	内部 Flash	外部 QSPI Flash（ESMC）
容量	有限（几十~几百 KB）	轻松 8MB / 16MB / 更大
用途	程序代码	字库、图片、音频、UI、固件备份
速度	—	四线模式远高于单线 SPI
XIP	代码就地执行	支持把外部 Flash 映射成内存直接运行（XIP）

3. PY32F403 的 ESMC 关键点

外设名 ESMC，引脚统一复用 AF10：

信号	引脚	说明
CLK	PB10	串行时钟
SS0（CS）	PA2	片选 0
IO0（SI）	PB1	数据线 0
IO1（SO）	PB0	数据线 1
IO2（WP）	PA7	数据线 2（四线时用）
IO3（HOLD）	PA6	数据线 3（四线时用）

支持 单线 / 双线 / 四线（Quad） 传输，以及 DTR（双倍数据率，见 ESMC_ReadWrite_DTR_Polling）；
支持 单 Flash / 双 Flash 并行（DualFlash）；
编程核心是 「命令描述符」模型：先用 ESMC_CommandTypeDef 描述一次操作（指令码、线数、地址、数据方向/长度、CS），再 Transmit/Receive 搬数据。

4. QSPI Flash 的通用操作铁律

无论什么型号（P25Q64、W25Q 等），写流程都遵循：

1
2

写使能(Write Enable, 0x06) → 等 BUSY 清 → 擦除(扇区/块) → 等 BUSY 清
→ 写使能 → 页编程(Page Program) → 等 BUSY 清 → 读数据 → 校验

写前必须写使能，否则指令被忽略；
操作期间状态寄存器 BUSY 位=1，必须轮询等到清零；
Flash 只能 1→0，不能直接 0→1，写前必须先擦除（擦除才回到 0xFF）；
一次页编程最多 256 字节，跨页要分多次。

5. 典型「命令描述符」写法

ESMC_CommandTypeDef cmd = {0};
cmd.TransferFormat    = ESMC_TRANSFER_FORMAT_QUAD;     /* 四线传输 */
cmd.InstructionMode   = ESMC_INSTRUCTION_SINGLE_LINE;  /* 指令仍单线发 */
cmd.Instruction       = P25Q64_QUAD_INPUT_PAGE_PROG_CMD;/* 四线页编程指令 0x32 */
cmd.AddressMode       = ESMC_ADDRESS_SINGLE_LINE;
cmd.AddressSize       = ESMC_ADDRESS_24_BITS;
cmd.Address           = addr;
cmd.DummyCycles       = 0;
cmd.DataMode          = ESMC_DATA_WRITE;
cmd.NbData            = nBytes;
cmd.CSPinSel          = ESMC_SELECT_PIN_CS0;          /* 选 CS0(PA2) */
HAL_ESMC_Command(&hesmc, &cmd, 0x0000FFFF);
HAL_ESMC_Transmit(&hesmc, pData, 0x0000FFFF);        /* 真正送出数据 */

6. 示例列表

示例	说明	重点
ESMC_ReadWrite_Polling	间接模式轮询擦/写/读	本文详解
ESMC_ReadWrite_DMA	间接模式 DMA 搬运	大块数据
ESMC_ReadWriteQuad_IT	四线 + 中断	非阻塞
ESMC_ReadWrite_DTR_Polling	双倍数据率	更高速
ESMC_ReadWrite_TwoFlash_Polling	双 Flash 并行	翻倍带宽
ESMC_MemoryMapping	内存映射（XIP）	当内置存储访问

本系列重点讲解 ESMC_ReadWrite_Polling。

7. 常见用途

字库 / 图片 / UI 资源存储（内部 Flash 只放代码）
数据记录仪（日志、采样缓存）
固件备份 / OTA 暂存
内存映射 XIP：把代码放到外部 Flash 直接执行，突破内部容量
大块音频/视频资源搬运到 LCD / Codec

下一篇：ESMC 外部 Flash 读写（轮询）实例详解

PUYA — I2S 音频总线

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

PUYA — I2S 音频总线

固件库: PY32F403_Firmware V1.4.5
芯片: PY32F403（Cortex-M4，最高 72MHz）
示例数: 6
⭐ F403 特色能力：I2S 由 SPI2 外设复用而来，是音频专用同步串行总线，基础系列（PY32F0xx）通常没有。

1. 一句话理解 I2S

I2S（Inter-IC Sound）是专为数字音频设计的同步串行总线，用来在 MCU 和音频芯片（DAC、ADC、CODEC、MEMS 麦克风）之间传 PCM 音频数据。

它和 SPI 长得很像（都是时钟+数据），但有本质区别：

	SPI	I2S
用途	通用数据	音频样本流
线	SCK/MOSI/MISO/NSS	CK(位时钟)/WS(声道选择)/SD(数据)+可选 MCLK
关键参数	CPOL/CPHA	采样率 AudioFreq、声道、位宽
数据含义	任意字节	左/右声道音频样本

一句话：要播音乐、录音、接麦克风，就用 I2S，而不是 SPI。

2. PY32F403 的 I2S 资源

I2S 由 SPI2 外设复用而来（所以例程里 Instance = SPI2）；
引脚（AF14）：PB12 = WS（声道选择）、PB13 = CK（位时钟）、PB15 = SD（数据）；
可选 MCLK 主时钟输出（本例关闭 I2S_MCLKOUTPUT_DISABLE）；
支持标准格式（飞利浦/MSB/LSB 对齐/PCM）、16/24/32 位数据、常见采样率（8K~48K+）；
三种搬运方式同 SPI：轮询 / 中断(IT) / DMA（音频流必用 DMA）。

3. I2S 的「三根半」线

信号	含义	谁产生
CK（BCLK）	位时钟，每个 bit 一个脉冲	主机
WS（LRCK）	声道选择，0=左/1=右，频率 = 采样率	主机
SD	串行音频数据（MSB 先行）	发送方
MCLK（可选）	主时钟（通常 = 256×采样率），给 CODEC 作基准	主机可选输出

采样率关系：WS 频率 ≈ 采样率（如 8kHz）；CK 频率 = 采样率 × 位宽 × 声道数（如 8k×16×2 = 256kHz）。HAL 会根据 AudioFreq 自动算分频。

4. 标准格式（Standard）别选错

I2S_STANDARD_PHILIPS（飞利浦标准）最常用；此外还有 MSB 对齐、LSB 对齐、PCM 等。主从双方的 Standard、CPOL、DataFormat、AudioFreq 必须完全一致，否则音频错位/杂音。

5. 典型使用流程（主机轮询）

I2sHandle.Instance        = SPI2;                    /* I2S 复用 SPI2 */
I2sHandle.Init.Mode       = I2S_MODE_MASTER_TX;     /* 主机发送（驱动 DAC）*/
I2sHandle.Init.Standard   = I2S_STANDARD_PHILIPS;
I2sHandle.Init.DataFormat = I2S_DATAFORMAT_16B;
I2sHandle.Init.MCLKOutput = I2S_MCLKOUTPUT_DISABLE;
I2sHandle.Init.AudioFreq  = I2S_AUDIOFREQ_8K;       /* 8kHz 采样率 */
I2sHandle.Init.CPOL       = I2S_CPOL_HIGH;
HAL_I2S_Init(&I2sHandle);                            /* 内部调 MSP 配 PB12/13/15 */

HAL_I2S_Transmit(&I2sHandle, TxBuf, LEN, 5000);     /* 阻塞发 */
while (HAL_I2S_GetState(&I2sHandle) != HAL_I2S_STATE_READY) {}

引脚在 HAL_I2S_MspInit() 配置：PB12/13/15 均 AF14，复用推挽。

6. 示例列表

示例	说明	重点
I2S_TwoBoard_CommunicationMaster_Polling	双板·主机·轮询	本文详解
I2S_TwoBoard_CommunicationMaster_IT	双板·主机·中断	非阻塞
I2S_TwoBoard_CommunicationMaster_DMA	双板·主机·DMA	音频流
I2S_TwoBoard_CommunicationSlave_Polling	双板·从机·轮询	从机视角
I2S_TwoBoard_CommunicationSlave_IT	双板·从机·中断
I2S_TwoBoard_CommunicationSlave_DMA	双板·从机·DMA

本系列重点讲解 I2S_TwoBoard_CommunicationMaster_Polling。

7. 常见用途

驱动 I2S DAC（如 MAX98357A）播放提示音 / WAV
读取 I2S MEMS 麦克风做录音 / 声控
接 CODEC（如 WM8978）做双向通话
DMA + 双缓冲实现不间断音频流
数字功放、语音识别前端

下一篇：I2S 双板主机轮询收发实例详解