不知名LZJ的博客 https://www.mcoi.top/ 分享技术与经历 | 学习嵌入式ing Wed, 16 Sep 2026 06:16:50 GMT https://validator.w3.org/feed/docs/rss2.html https://github.com/jpmonette/feed zh-CN All rights reserved 2026, L_Z_J <![CDATA[STM32-HAL库学习笔记]]> https://www.mcoi.top/article/Post-stm32-hal https://www.mcoi.top/article/Post-stm32-hal Tue, 01 Oct 2024 00:00:00 GMT
😀
一个简单的开头

介绍

此笔记为观看B站UP：超子说物联网所写，感谢老师。老师的架构真的特别好！
我在学习HAL库之前有标准库基础，所以学习稍快，但会尽量详细记录
笔记和项目文件在gitee开源了
大家可以在我的gitee仓库 中下载笔记源文件、STM32F1C8T6资料等
笔记源文件可以在Notion中导入
正在更新~
超子物联网 HAL库学习 写作不易，如果您觉得写的不错，欢迎给博主来一波点赞、收藏~让博主更有动力吧！

内容导航

子页面开头

超子物联网 HAL库学习 汇总入口：超子物联网HAL库笔记：[汇总] 写作不易，如果您觉得写的不错，欢迎给博主来一波点赞、收藏~让博主更有动力吧！
 

准备篇

1. HAL库简介

HAL库
  • HAL库（Hardware Abstraction Layer）是STMicroelectronics提供的STM32微控制器的硬件抽象层库。
  • 它通过一套统一的API接口，简化了对STM32外设的配置和操作，使开发者能够更快速地进行嵌入式系统开发，而不必深入了解底层硬件细节。
HAL库的优点
  • 高层次抽象：HAL库提供了高层次的抽象接口，简化了对硬件外设的操作。开发者可以通过调用库函数完成复杂的硬件配置，而不必直接操作寄存器。
  • 易于使用：由于提供了丰富的库函数和示例代码，开发者可以快速上手进行开发，减少了开发时间。
  • 一致性和移植性：HAL库在不同的STM32系列中保持了一致的API接口，增强了代码的移植性和重用性。如果需要更换STM32系列微控制器，代码的修改量较小。
  • 简化调试：由于HAL库屏蔽了底层的寄存器操作，调试过程中更容易定位和解决问题，减少了开发和维护的复杂性。
  • 代码维护性好：HAL库的高层次封装和良好的代码结构使得代码更容易维护和更新。
对比标准固件库的不同
  1. 抽象层次：
      • 标准固件库：直接操作寄存器，提供底层硬件访问，要求开发者对STM32微控制器的寄存器有较深入的理解。
      • HAL库：提供高层次的抽象接口，屏蔽底层寄存器操作，使开发者可以更快速地进行开发。
  1. 代码复杂性：
      • 标准固件库：代码较复杂，涉及大量的寄存器配置，开发者需要处理更多的细节。
      • HAL库：代码简洁易读，通过调用库函数进行配置和操作，减少了代码量和复杂性。
  1. 学习曲线：
  • 标准固件库：学习曲线较陡，需要花费较多时间了解和掌握硬件细节。
  • HAL库：学习曲线较缓，提供了丰富的示例代码和文档，开发者可以快速上手。
  1. 开发效率：
  • 标准固件库：适合对性能和功耗有严格要求的项目，但开发和调试时间较长。
  • HAL库：提高了开发效率，适合快速开发和原型设计，缩短了开发周期。
  1. 移植性：
  • 标准固件库：不同系列的STM32微控制器之间存在较大的差异，代码移植工作量较大。
  • HAL库：提供一致的API接口，增强了代码的移植性和重用性，不同系列之间的移植工作量较小。

2. 创建HAL库工程模板

1. 制作文件模板

  • 先找一个位置，存放工程模板
  • 在工程模板中 添加 User、Library 、 Hardware 、 CMSIS 文件夹：
    • User：
      • main.c
    • Library：
      • Include
      • Source
    • Hardware：
      • Include
      • Source
    • CMSIS ：
      • Include
      • Source
  • 解压并打开
  • 拷贝HAL库（Library）
      1. 进入\STM32Cube_FW_F1_V1.8.0\Drivers\STM32F1xx_HAL_Driver 把头文件夹 Inc 和源文件夹 Src 移动到自己的Library的对应的文件中
  • 拷贝启动文件（CMSIS\Include）
      1. 先进入内核文件\STM32Cube_FW_F1_V1.8.0\Drivers\CMSIS
      1. 进入头文件\CMSIS\Include 把所有文件拷贝到自己的CMSIS/Include文件中 再进入\CMSIS\Device\ST\STM32F1xx\Include 把所有文件拷贝到自己的CMSIS/Include文件中
  • 拷贝源文件（CMSYS\Source）
      1. 进入\STM32Cube_FW_F1_V1.8.0\Drivers\CMSIS\Device\ST\STM32F1xx\Source\Templates
      1. 把\Templates 文件的的system_stm32f1xx.c拷贝到自己的CMSIS/Source文件中
      1. 再进入/arm文件下，把所有文件拷贝到自己的CMSIS/Source文件中
  • 编辑Hardware文件夹
      • 分别在源文件家和头文件夹添加stm32f1xx_it.c 和stm32f1xx_it.h 代码如下

stm32f1xx_it.c

stm32f1xx_it.h

最后需要把自己的Library文件中的Include 文件中的stm32f1xx_hal_conf_template.h 更名为 stm32f1xx_hal_conf.h 。否则编译会找不到这个头文件

文件结构

2. Keil 创建工程

  1. 创建工程、选择User为目录。
  1. 点击木箱子设置分组
      • User 、 Library 、 Hardware 、 CMSIS
  1. 导入文件
      • 这里只导入必备的。以后用哪个再加那个
      • Library：
        • stm32f1xx_hal.c
        • stm32f1xx_hal_cortex.c
        • stm32f1xx_hal_gpio.c
        • stm32f1xx_hal_gpio_ex.c
        • stm32f1xx_hal_rcc.c
        • stm32f1xx_hal_rcc_ex.c
      • CNSIS：
        • system_stm32f1xx.c
        • startup_stm32f103xb.s
      • User：
        • main.c
  1. 在魔术棒中设置：
      2. C/C++中： 在Define输入STM32F103xB (目的是通知编译器我们用的是xb) 添加头文件路径（Hardware、CMSIS、Library）。以后有别的添加则再添加。 Target中：
      选择ARM编译器为v6.16 否则会报错
  1. 在main.c中引入头文件stm32f1xx_hal.h （在hal.c中可找到）
  1. 最后编译即可。0错误0警告

3. HAL库结构初步分析

  • 以HAL库的串口为例来讲解
      1. 串口分为USART和UART 他们分别是同步通信和异步通信。一般我们用异步的
          2. 所以这里我们添加uart.c的文件。
      1. hal库之中，串口包含三种方式： 轮询、中断、DMA。所以在库文件中必须添加DMA库
          2. 所以我们这里添加DMA.c的文件
  • 在HAL库中每个外设都有两个关键的部分：
      1. Private：（私有的），是HAL库内部自己调用的
      1. Exported：（对外的），我们的应用程序中去调用。Exported分为四个部分
          • types，各种Struct结构体，用于外设功能配置。对应了CubeMax软件的配置项
          • constants，上方各种Struct结构体中的成员的可以配置的选项
          • macro，宏定义，相当于直接对寄存器操作。因为在某些时候调用api反而效率不高
          • functions，API函数。
      这些是可以在文件中验证的。hal_uart.c中 可见
      我们对CubeMax的操作，实际上就是与这些结构体、成员变量一一对应的
      一个外设的相关结构体会被定义在一个总的结构体中。比如串口是UART_HandleTypedef
 

时钟篇

1. 汇编启动文件调用SystemInit对时钟的配置内容

汇编的启动文件（.s结尾的那个）在每次复位时，都是先调用SystemInit函数去配置时钟。 默认的最终时钟是 使用的是内部的HSI 内部高速时钟 8MHZ
  • SystemInit首先会设置CR寄存器（时钟控制寄存器）把位0置1（使用内部高速时钟）。
  • 然后会去设置CFGR寄存器，主要是设置路径，以及倍频之类的东西

2. HAL库输出内部时钟HSI

我们可以调用HAL_RCC_MCOConfig 来把时钟输出8MHZ的方波到默认的PA8上验证一下。
在使用HAL库前要用HAL_Init()初始化一下。
main.c
HAL_Init();//初始化HAL库
HAL_RCC_MCOConfig(RCC_MCO1,RCC_MCO1SOURCE_SYSCLK,RCC_MCODIV_1);//PA8引脚输出、系统时钟、不分频
所以仅仅需要这两行就可以输出时钟了。示波器验证正确。
 

3. 使用内部HSI时钟通过PLL倍频到64MHZ

注意
  • APB1最大时钟为36MHZ
  • APB2最大时钟为72MHZ
notion image
需要设置的。和路线，其实就是在函数中一步步设置。
代码如下
main.c
#include "stm32f1xx_hal.h"
#include "rcc.h"
/*函 数 名：hal库rcc输出内部8Mhz方波
*参 数：
*返 回 值：
*注意事项：
*/
uint32_t HCLKFreq = 0;//显示时钟树三处频率
uint32_t PCLK1Freq = 0;
uint32_t PCLK2Freq = 0;
int main (void)
{
HAL_Init();//初始化HAL库
RCC_ClockInit();//配置时钟树初始化
HAL_RCC_MCOConfig(RCC_MCO1,RCC_MCO1SOURCE_SYSCLK,RCC_MCODIV_1);//PA8引脚输出、系统时钟、不分频
HCLKFreq = HAL_RCC_GetHCLKFreq();
PCLK1Freq = HAL_RCC_GetPCLK1Freq();
PCLK2Freq = HAL_RCC_GetPCLK2Freq();
while(1)
{
}
}
#include "stm32f1xx_hal.h"
#include "rcc.h"
void RCC_ClockInit()
{
RCC_OscInitTypeDef RCC_OsInitStructure; //设置内外部时钟源配置结构体
RCC_ClkInitTypeDef RCC_ClkInitStructure;//设置总线时钟结构体
RCC_OsInitStructure.OscillatorType = RCC_OSCILLATORTYPE_HSI; //选择震荡电路为内部高速
RCC_OsInitStructure.HSIState = RCC_HSI_ON; //打开时钟
RCC_OsInitStructure.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; //设置微调值 默认
RCC_OsInitStructure.PLL.PLLState = RCC_PLL_ON; //设置PLL为打开
RCC_OsInitStructure.PLL.PLLSource = RCC_PLLSOURCE_HSI_DIV2; //选择PLL输入为内部高速时钟
RCC_OsInitStructure.PLL.PLLMUL = RCC_PLL_MUL16; //设置16倍频
HAL_RCC_OscConfig(&RCC_OsInitStructure); //传给话务员..
RCC_ClkInitStructure.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 |RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_SYSCLK;//需要配置的时钟
RCC_ClkInitStructure.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; //SYSCLK系统时钟输入源 PLL作为系统时钟
RCC_ClkInitStructure.AHBCLKDivider = RCC_SYSCLK_DIV1; //AHB预分频 1分频
RCC_ClkInitStructure.APB1CLKDivider = RCC_HCLK_DIV2; //APB1预分频 2分频
RCC_ClkInitStructure.APB2CLKDivider = RCC_HCLK_DIV1; //APB2预分频 1分频
HAL_RCC_ClockConfig(&RCC_ClkInitStructure,FLASH_LATENCY_2);//传给话务员，并且根据频率设置FLASH等待周期为2
//话务员相关配置可以在API函数中找到。结构体相关配置在结构体和成员中可找到
}
结果如下（转换成10进制）：分别为 64M 32M 64M
notion image
 

4. 使用外部HSE时钟通过PLL倍频到72MHZ

流程如下
notion image
只修改了rcc.c的文件
rcc.c
#include "stm32f1xx_hal.h"
#include "rcc.h"
void RCC_ClockInit()
{
RCC_OscInitTypeDef RCC_OsInitStructure; //设置内外部时钟源配置结构体
RCC_ClkInitTypeDef RCC_ClkInitStructure;//设置总线时钟结构体
RCC_OsInitStructure.OscillatorType = RCC_OSCILLATORTYPE_HSE; //选择震荡电路为外部高速
RCC_OsInitStructure.HSEState = RCC_HSE_ON; //打开HSE时钟
RCC_OsInitStructure.HSEPredivValue = RCC_HSE_PREDIV_DIV1; //不分频
RCC_OsInitStructure.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; //设置微调值 默认
RCC_OsInitStructure.PLL.PLLState = RCC_PLL_ON; //设置PLL为打开
RCC_OsInitStructure.PLL.PLLSource = RCC_PLLSOURCE_HSE; //选择PLL输入为外部高速时钟
RCC_OsInitStructure.PLL.PLLMUL = RCC_PLL_MUL9; //设置9倍频
HAL_RCC_OscConfig(&RCC_OsInitStructure); //传给话务员..
RCC_ClkInitStructure.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_PCLK1 |RCC_CLOCKTYPE_PCLK2 | RCC_CLOCKTYPE_SYSCLK;//需要配置的时钟
RCC_ClkInitStructure.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK; //SYSCLK系统时钟输入源 PLL作为系统时钟
RCC_ClkInitStructure.AHBCLKDivider = RCC_SYSCLK_DIV1; //AHB预分频 1分频
RCC_ClkInitStructure.APB1CLKDivider = RCC_HCLK_DIV2; //APB1预分频 2分频
RCC_ClkInitStructure.APB2CLKDivider = RCC_HCLK_DIV1; //APB2预分频 1分频
HAL_RCC_ClockConfig(&RCC_ClkInitStructure,FLASH_LATENCY_2);//传给话务员，并且根据频率设置FLASH等待周期为2
//话务员相关配置可以在API函数中找到。结构体相关配置在结构体和成员中可找到
}
结果：
notion image

5. HAL_Init库函数源码分析 及 Systick时基

HAL_Init 是 HAL库要求我们调用的第一个函数。
下面是HAL_Init调用时 做的工作：
  1. 把指令预取功能打开
  1. 设置中断分组
  1. 将Systick作为时间基准，配置为1ms的中断
  1. 初始化底层硬件
  1. 返回 HAL_OK
标准库和HAL库的很大的一个区别：Systick
  • 每次进入Systick中断时 对32位全局变量uwTick累加1
  • 提供了HAL_GetTick 获取uwTick全局变量
Systick时基最常用的地方就是各个外设采用阻塞轮训处理数据时，做超时判断、阻塞延时、

中断处理函数及weak弱声明中断回调函数详解

一、STM32 中断处理方式概述

在 STM32 的开发中，中断是一种非常重要的机制，用于响应外部事件或内部异常情况。STM32 在启动文件（stmxxxxx.s）中为我们预先定义了所有中断的中断服务函数。这意味着当特定的中断发生时，处理器会自动跳转到相应的中断服务函数处执行代码。

二、标准库中断处理方式

在标准库中，处理中断需要开发者自己去判断中断标志位，确定中断是否发生，然后执行相应的操作，最后还需要手动清除中断标志位。例如在 EXTI15_10_IRQHandler 中断服务函数中，开发者需要通过检查特定的线（比如线 12）的中断标志位来判断该中断是否发生，如果中断标志位为真，则执行特定的操作，最后还需要清除线 12 产生的中断标志位，以确保下次中断能够正确响应。

三、HAL 库中断处理方式

  1. 自动判断与清除标志位：
      • HAL 库（以 gpio.c 为例）为各个外设的中断提供了更加便捷的处理方式。在 HAL 库提供的中断处理函数中，会自动判断中断标志位并清除标志位。例如在 void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)函数中，首先使用__HAL_GPIO_EXTI_GET_IT(GPIO_Pin)!= 0x00u来判断标志位，确定中断是否发生。如果中断发生，接着使用__HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin)来清除标志位，确保下次中断能够正常响应。
  1. 回调函数机制：
      • 在自动判断和清除标志位的函数中，还提供了一个回调函数HAL_GPIO_EXTI_Callback(GPIO_Pin)。这个回调函数的作用是在中断发生并且标志位被正确处理后，执行用户自定义的操作。
  1. 弱声明的回调函数：
      • 在自动判断和清除标志位的函数下，会有回调函数有一个弱声明：__weak void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)。这个弱声明的回调函数只是为了防止编译报错而存在的，它内部实际上什么操作都不执行，只是通过UNUSED(GPIO_Pin)来告诉编译器这个参数虽然没有被使用，防止产生编译错误。
  1. 强声明的回调函数：
      • 开发者可以在自己的代码中定义一个 “强声明” 的中断回调函数，即void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)。当程序编译时，会自动使用这个强声明的回调函数替代弱声明的回调函数。这样，当中断发生时，就会执行开发者自定义的回调函数，而不是弱声明的空函数。
gpio.c中判断中断、清除中断、执行回调函数和对应的弱声明的代码部分：
//stm启动文件中已经定义的中断服务函数
void HAL_GPIO_EXTI_IRQHandler(uint16_t GPIO_Pin)
{
if (__HAL_GPIO_EXTI_GET_IT(GPIO_Pin) != 0x00u)//帮我们判断标志位
{
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_Pin);//帮我们清除标志位
HAL_GPIO_EXTI_Callback(GPIO_Pin);//执行回调函数
}
}
// 弱声明 的回调函数 只是为了防止报错用
__weak void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
UNUSED(GPIO_Pin);//什么都不执行，只是为了防止编译时报错：没有使用xxx
}

四、在程序中的应用

为了让 HAL 库的中断处理函数能够正确地响应中断并执行自定义的回调函数，我们只需要在 it.c 文件中，在中断发生时跳转到 HAL 库的中断处理函数。这样，当中断发生时，HAL 库的中断处理函数就会自动帮我们判断中断标志位、清除标志位，并进入对应的回调函数，执行我们自定义的操作。
比如（以gpio.c为例）：
it.c文件：
void EXTI15_10_IRQHandler (void) //如果发生了这个中断
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);//跳转到HAL库的中断处理
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_12);//跳转到HAL库的中断处理
}
/ 注册回调函数 /
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == GPIO_PIN_13) // 判断是不是13线
{
// 执行13线程序
// ...
}
else if (GPIO_Pin == GPIO_PIN_12) // 判断是不是12线
{
// 执行12线程序
// ...
}
}

串口篇

这篇文章介绍了HAL库大多的使用方法，并配有详细的思路和注释。

一、介绍

HAL库在 异步通信UART 串口部分提供了三种方式：
  • 轮询阻塞
  • 非阻塞中断 或者 DMA
  • 所以在使用串口时，也要添加DMA.c到库
以STM32C8T6为例，有三个串口资源：
  • USART1：
    • TX：PA9 可重映射为 PB 6
    • RX：PA10 可重映射为 PB 7
  • USART2：
    • TX：PA2
    • RX：PA3
  • USART3：
    • TX：PB10
    • RX：PB11

二、HAL库：阻塞轮询方式 实现USART1 串口 异步收发

1. 引脚定义

  • USART1：
    • TX：PA9
    • RX：PA10

2. 补充：为什么在while循环接收时，没必要对HAL_ERROR、HAL_BUSY进行处理

HAL_ERROR：
  • 用于判断buff为空指针或者数据长度为0的情况
HAL_BUSY：
  • 用于判断Busy状态
所以我们只需要判断他的另外两种状态，HAL_OK(在规定时间内接收到n个数据)、和HAL_TIMEOUT(未在规定时间接收到n个数据，导致超时退出接收)

3. 注意事项：

  • HAL库的串口初始化， 硬件部分的时钟以及GPIO口的配置，需要我们自己来配置
      • 在HAL_UART_Init(&Uart1); 函数被调用时。 会调用一个weak弱声明的void HAL_UART_MspInit(UART_HandleTypeDef *huart) 函数。 这个函数就是留给我们强声明 配置硬件用的。我们需要在里边打开 串口1 和 GPIO的 时钟。
  • 需要注意的是USART1与定时器的引脚有冲突。 如果发生冲突 可以重映射 串口到别的引脚。
  • RxXferSiZe是用来记录接收总量的
  • RxXferCount是用来记录剩余需要接收数量的
注意，这里的RxXferCount 进到while中就先减1 了。这个知识点后面会用到

4. 串口1初始化部分：

5. 串口1配置硬件部分

6. 主函数部分

  • 主函数中。需要使用接收串口的函数：HAL_UART_Receive(&Uart1,Buff,Rx_Size,200)
      • 他的参数分别为：串口配置结构体地址、接收缓冲区（我们自己定义的数组）、预计接收的字节个数（我们自己定义）、超时时间（单位为ms）
      这里的 Rx_Size 为 200
      因此我们需要在UART.h 头文件中添加结构体对外声明extern UART_HandleTypeDef Uart1;
  • 接收串口的函数会有 四个返回值：
    • HAL_OK、 代表此次在200ms内接受到了 200 字节。 （也就是与预计相等）
    • HAL_ERROR 、代表传参错误、 比如超时时间为0、或者数据缓冲区地址为空
    • HAL_TIMEOUT 、代表未能在规定时间内接收到 200 个字节
      • 往往分为两种情况： 1、接收了但没接收完、2、一点没接收
    • HAL_BUSY、代表已经在接受了。你别来烦我
下面可以看代码来分析

三、HAL库：阻塞轮询方式 实现串口2、3 和串口1重映射

1. 引脚定义

  • USART1：
    • TX：PA9 可重映射为 PB 6
    • RX：PA10 可重映射为 PB 7
  • USART2：
    • TX：PA2
    • RX：PA3
  • USART3：
    • TX：PB10
    • RX：PB11

2. 关键代码：

  • 如果需要重映射，则还需要打开AFIO的时钟和 使用重映射 API：

3. 串口1、2、3、初始化部分：

与之前的无异，只是添加拷贝了三次

4. 主函数部分

  • 与之前的一样，想使用什么修改下”UartX“参数就行，

四、HAL库：中断方式 实现串口1 定长数组异步收发

我们就使用上一小节所讲的多指针定位+循环收发缓冲区方案设计，来实现这次的中断接收~

1. 注意事项

  1. HAL库为 串口中断提供了很多回调函数。 比如 错误回调、半完成回调、Rx、Tx完成回调。你需要用什么回调，就声明什么回调~
      • 这里只用了接收完成回调函数：void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
          • 其中“RxCpltCallback” 可以分解为以下部分：
        • “Rx” 通常代表 “Receive”，即接收。
        • “Cplt” 通常代表 “Complete”，即完成。
        • “Callback” 即回调，指的是当某个特定事件发生时被调用的函数。
  1. 我们在回调函数中。 我们将接收缓冲区的数据memcpy到 发送缓冲区。 并置 接收完成标志位。 在主函数中，只需要循环检测 标志位 后 并发送发送缓冲区中的数据就可以完成接收并发送数据了。 中断接收在接收到数据之后 需要在回调函数中要重新打开。 因为中断接收一次会自动关闭
  1. 在使用UART 的IT 接收时。要配置NVIC ：USART 线的 优先级和 使能USART线
  1. 这里的定长，是因为中断只有接收到20个字节之后，才会进入回调函数

2. 初始化UART1部分

  • 主要关注中断 完成接收回调函数部分。 主要完成了数据cpy 和置位接收状态以及 重新启动接收数据。
  • 以及关注定义的接收、发送缓冲区和Rx_Date接收状态标志位

3. UART硬件初始化回调

3. 回调函数部分

/ 强声明的错误回调函数 /
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的发送完成回调函数 /
void HAL_UART_TxHalfCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}

4. 函数测试部分

  • 主要完成了轮询检测状态并返回接收到的 拷贝到 发送缓冲区 的 数据
#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "key.h"
#include "Uart.h"
/函 数 名：HAL库：中断方式。实现UART串口数据收发。 定长 20字节 /
int main (void)
{
HAL_Init();//初始化HAL库
RccClock_Init();//配置时钟树72M
LED_Init();
Uart1_Init(921600);//初始化串口1
while(1)
{
if(Rx_Date == 1) //如果接收标志位置1
{
Rx_Date = 0;
HAL_UART_Transmit_IT(&Uart1,Tx_Buff,20);//发送 发送缓冲区的20个字节
}
}
}

五、多指针定位+循环收发缓冲区方案设计（“六”为实践此方案）

1. 介绍

轮询阻塞的方式效率不高，一般会使用中断或者DMA方式收发数据
这时就需要定义一个缓冲区，这里暂定为2048字节。
  • 缓冲区为一个、一维数组，循环使用，要注意缓冲区不要出现回卷覆盖，接收的数据要及时处理。

2. 大致思路

标记2048缓冲区每次数据的起始和结束位置
  • 创建一个标记结构体，成员为指针pS（Start）和pE（Een）。他们用来在2048的缓冲区中，指向每次接收的数据的开头和起始位置。
  • 使用我们刚才创建的‘标记结构体’，创建一个有10个成员的数组SN
  • 创建一个IN和OUT指针，初始化时指向SN数组的起始位置（0号成员）
  • 创建一个END指针，指向SN数组的结束位置（9号成员）
巧妙地判断接收到数据，并循环利用标记
  • 当第一次接收到数据之后，使用0号成员的pS、pE指针定位数组的起始和结束位置， 同时IN++，指向数组SN的1号成员
    • 此时，可以在while循环中判断，当OUT指针与IN指针不指向同一个位置了，那么就代表已经缓冲区收到数据了。在处理完数据之后，使得OUT++，指向第1号成员~
  • 当第pS跳到END指向的位置时，应使得PS下次跳的位置为数组SN的起始位置：数据回滚，防止越界
防止2048缓冲区空余位置不够
  • 约定每次接收数据的MAX值，防止空余位置不够。
  • 所以在每次接收之后，都需要判断空余位置，若小于MAX值，则直接回卷，防止越界
利用空闲中断，完成对数据的处理
  • 定义了单次接收的最大值MAX，若MAX=256，那么别人一次发送的值最多为255字节，因为当一次次发送256时，会同时触发完成中断和空闲中断，这是不允许的。
  • 我们只利用空闲中断对数据进行处理哦~

六、HAL库：空闲中断方式实现串口1+不定长数据接收+循环收发缓冲区+收发数据

1. 不定长接收数据的实现思路及相关函数

在使用简单串口时，无法知道对方给我发送的确切的数据量。我就没法确切的定义我们需要接收多少个字节的字节。只能接收到固定长度的字节后统一处理。
要实现不定长接收数据，我们通常是利用空闲中断。
notion image
当一次连续的接收完成后，会出现空闲帧，然后进入空闲中断中。
我们就可以利用空闲中断，来判断当前为一次数据的接收结束。
然后可以利用RxferCount，来获取本次接受了多少个字节。
在空闲中断回调中，我们可以对数据进行处理或判断

注意：

  1. 定义了单次接收的最大值MAX，若MAX=256，那么别人一次发送的值最多为255字节，因为当一次次发送256时，会同时触发完成中断和空闲中断，这是不允许的。
  1. 一定要想明白，位置控制数组rxLocation 和 rxInPtr和 rxOutPtr的关系，可以看图理解
      2. notion image
      notion image
  • 我们只利用空闲中断对数据进行处理哦~

相关函数

  • 空闲中断打开函数：__HAL_UART_ENABLE_IT(&uart1.uart,UART_IT_IDLE);
  • 在每次进入中断后，判断是否为空闲中断： if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE))
  • 清除空闲标志位 __HAL_UART_CLEAR_FLAG(&uart1.uart, UART_FLAG_IDLE);
  • 终止当前的接收(会把RxferCount清零) HAL_UART_AbortReceive_IT(&uart1.uart);
  • 终止接收回调函数
      • void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
  • 发送完成回调函数
      • HAL_UART_TxCpltCallback

2. 程序设计

STM32C8T6单片机一共有20K的RAM

2.1 设计介绍：

  • 定义缓冲区宏
/ 缓冲区宏定义 /
#define U1_RX_SIZE 2048
#define U1_TX_SIZE 2048
#define U1_RX_MAX 256 //这里需要注意，我们是利用空闲中断对数据进行处理，不能单次发送256字节，否则进入完成中断
/ 缓冲区 /
uint8_t U1_Rx_Buff[U1_RX_SIZE];
uint8_t U1_Tx_Buff[U1_TX_SIZE];
/ Location Ctrl Block /
/ （接收/发送）位置控制块 /
typedef struct{
uint8_t* start;
uint8_t* end;
}LCB;
/ Uart Ctrl Block /
/ 串口控制块 /
typedef struct{
uint32_t rxCount; //记录接收缓冲区中当前已有的数据量
uint32_t txCount; //记录发送缓冲区中当前已有的数据量
LCB rxLocation[10]; //记录接收缓冲区每次接收的位置
LCB txLocation[10]; //记录发送缓冲区每次接收的位置
LCB* rxInPtr; //指向下次接收缓冲区存放位置
LCB* rxOutPtr; //指向下次接收缓冲区读取位置
LCB* rxEndPtr; //指向接收缓冲区结束位置
LCB* txInPtr; //指向下次发送缓冲区存放位置
LCB* txOutPtr; //指向下次发送缓冲区读取位置
LCB* txEndPtr; //指向发送缓冲区结束位置
UART_HandleTypeDef uart; //串口总控结构体
uint8_t TxState; //发送忙碌标志位
}UCB;
/ 初始化 /
void U1_Init(uint32_t bandrate);
/ 初始化UCB控制块指针 /
void U1_PtrInit(void);
/ 转移RxBuff数据到TxBuff /
void U1_DataRxToTx(uint8_t* data, uint32_t data_len);
/ 总控结构体 /
extern UCB uart1;
/ 缓冲区 /
extern uint8_t U1_Rx_Buff[U1_RX_SIZE];
extern uint8_t U1_Tx_Buff[U1_TX_SIZE];
/ 状态位 /
extern uint8_t rxState;

2.2 文件架构：

  • Uart.h ：定义了 宏、结构体、函数与变量声明
  • Uart.c ：主要针对串口 1 进行配置：空闲中断打开和处理、包括初始化参数、设置缓冲区指针….
  • stm32fxx_It.c ： 主要是 void USART1_IRQHandler(void) 的中断函数：该函数是串口 1 的中断服务函数。首先调用 HAL 库的中断处理函数，后续 检测到串口 1 进入空闲状态时，清除空闲中断标志位，计算接收字节数量并累加，然后终止接收，触发终止接收回调函数。终止接收回调函数在Uart.c中
  • main.c ：在主循环中，通过判断接收和发送缓冲区的指针状态，实现数据的接收和发送，并在指针到达末尾时进行回卷操作。当接收缓冲区有数据时，将其拷贝到发送缓冲区并移动输出指针；当发送缓冲区有数据且处于空闲状态时，发送数据并移动输出指针。

uart.h

#ifndef __UART_H
#define __UART_H
#include "stm32f1xx_hal.h"
#include "stdint.h"
#include "string.h"
/ 缓冲区宏定义 /
#define U1_RX_SIZE 2048
#define U1_TX_SIZE 2048
#define U1_RX_MAX 256 //这里需要注意，我们是利用空闲中断对数据进行处理，不能单次发送256字节，否则进入完成中断
/ Location Ctrl Block /
/ （接收/发送）位置控制块 /
typedef struct{
uint8_t* start;
uint8_t* end;
}LCB;
/ Uart Ctrl Block /
/ 串口控制块 /
typedef struct{
uint32_t rxCount; //记录接收缓冲区中当前已有的数据量
uint32_t txCount; //记录发送缓冲区中当前已有的数据量
LCB rxLocation[10]; //记录接收缓冲区每次接收的位置
LCB txLocation[10]; //记录发送缓冲区每次接收的位置
LCB* rxInPtr; //指向下次接收缓冲区存放位置
LCB* rxOutPtr; //指向下次接收缓冲区读取位置
LCB* rxEndPtr; //指向接收缓冲区结束位置
LCB* txInPtr; //指向下次发送缓冲区存放位置
LCB* txOutPtr; //指向下次发送缓冲区读取位置
LCB* txEndPtr; //指向发送缓冲区结束位置
UART_HandleTypeDef uart; //串口总控结构体
uint8_t TxState; //发送忙碌标志位
}UCB;
/ 初始化 /
void U1_Init(uint32_t bandrate);
/ 初始化UCB控制块指针 /
void U1_PtrInit(void);
/ 转移RxBuff数据到TxBuff /
void U1_DataRxToTx(uint8_t* data, uint32_t data_len);
/ 总控结构体 /
extern UCB uart1;
/ 缓冲区 /
extern uint8_t U1_Rx_Buff[U1_RX_SIZE];
extern uint8_t U1_Tx_Buff[U1_TX_SIZE];
/ 状态位 /
extern uint8_t rxState;
#endif

uart.c

#include "uart.h"
/ 创建串口总控结构体 /
UCB uart1;
/ 缓冲区 /
uint8_t U1_Rx_Buff[U1_RX_SIZE];
uint8_t U1_Tx_Buff[U1_TX_SIZE];
/ 初始化串口 /
void U1_Init(uint32_t bandrate){
uart1.uart.Instance = USART1; //使用那个串口
uart1.uart.Init.BaudRate = bandrate; //波特率
uart1.uart.Init.WordLength = UART_WORDLENGTH_8B; //数据位长度
uart1.uart.Init.StopBits = UART_STOPBITS_1; //停止位
uart1.uart.Init.Parity = UART_PARITY_NONE; //校验模式
uart1.uart.Init.Mode = UART_MODE_TX_RX; //传输模式
uart1.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE; //流控
HAL_UART_Init(&uart1.uart);
/ 初始化UCB控制块指针 /
U1_PtrInit();
/ 打开空闲中断 /
__HAL_UART_ENABLE_IT(&uart1.uart,UART_IT_IDLE);
/ 开始接收数据 /
HAL_UART_Receive_IT(&uart1.uart, uart1.rxInPtr->start, U1_RX_MAX); //接收位置为当前LCB位置控制块的In指针所指向的缓冲区的位置
}
/ 初始化U1_UCB控制块指针 /
void U1_PtrInit(void){
uart1.rxCount = 0;
uart1.rxInPtr = &uart1.rxLocation[0];
uart1.rxOutPtr = &uart1.rxLocation[0];
uart1.rxEndPtr = &uart1.rxLocation[9];
uart1.rxInPtr->start = &U1_Rx_Buff[0]; //让当前接收位置控制块的start，指向下一次接收到的数据将要存放的位置
uart1.txCount = 0;
uart1.txInPtr = &uart1.txLocation[0];
uart1.txOutPtr = &uart1.txLocation[0];
uart1.txEndPtr = &uart1.txLocation[9];
uart1.txInPtr->start = &U1_Tx_Buff[0]; //让当前发送位置控制块的start，指向下一次需要发送的数据的存放位置
}
/ 转移U1_Rx_Buff数据到 U1_Tx_Buff /
void U1_DataRxToTx(uint8_t* data, uint32_t data_len){
/ 判断剩余空间是否足够，要不要回卷 /
if((U1_TX_SIZE - uart1.txCount) > data_len){
/ 如果够 /
uart1.txInPtr->start = &U1_Tx_Buff[uart1.txCount];
}
else{/ 如果剩余空间不够 /
uart1.txCount = 0;
uart1.txInPtr->start = &U1_Tx_Buff[0];
}
/ 复制data到U1_Tx_Buff缓冲区 /
memcpy(uart1.txInPtr->start, data, data_len);
/ 累加txCount /
uart1.txCount += data_len;
/ 标记这次的发送数据的结束位置 /
uart1.txInPtr->end = &U1_Tx_Buff[uart1.txCount - 1];
/ 移动txIn /
uart1.txInPtr++;
/ 判断txIn指针是否需要回卷 /
if(uart1.txInPtr == uart1.txEndPtr){
uart1.txInPtr = &uart1.txLocation[0];
}
}
/ UART硬件初始化回调 /
void HAL_UART_MspInit(UART_HandleTypeDef *huart){
GPIO_InitTypeDef GPIO_InitType;
if(huart->Instance == USART1){ //判断那个串口在进行初始化
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_9;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
//打开了串口1的总中断
HAL_NVIC_SetPriority(USART1_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
}else if(huart->Instance == USART2){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
}else if(huart->Instance == USART3){
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_11;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
}
}
/ 强声明的接收完成回调函数 /
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的错误回调函数 /
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的发送完成回调函数 /
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
/ 发送完成，标志位清零 /
uart1.TxState = 0;
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的接收终止回调函数 /
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
/ 标记结束位置 /
uart1.rxInPtr->end = &U1_Rx_Buff[uart1.rxCount - 1];
/ 挪动rxIn指针 /
uart1.rxInPtr++;
/ 判断rxIn指针是否需要回卷 /
if(uart1.rxInPtr == uart1.rxEndPtr){
uart1.rxInPtr = &uart1.rxLocation[0];
}
/ 判断接收缓冲区是否需要回卷 /
if((U1_RX_SIZE - uart1.rxCount) < U1_RX_MAX){
uart1.rxCount = 0;
uart1.rxInPtr->start = &U1_Rx_Buff[0];
}else{
/ 剩余位置够 /
uart1.rxInPtr->start = &U1_Rx_Buff[uart1.rxCount];
}
/ 重新开启中断接收 /
HAL_UART_Receive_IT(&uart1.uart, uart1.rxInPtr->start, U1_RX_MAX);
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}

stm32fxx_It.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}
/-------------------------------------------------/
/函数名：串口1中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
/ 在每次进入中断后，判断是否为空闲中断 /
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
/ 清除空闲标志位 /
//__HAL_UART_CLEAR_FLAG(&uart1.uart, UART_FLAG_IDLE);
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
/ 获取这次传输了多少字节 /
uart1.rxCount += (U1_RX_MAX - uart1.uart.RxXferCount);
/ 终止当前的接收(会把RxferCount清零) /
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
while(1){
/ 判断接收缓冲区是否有数据 /
if(uart1.rxInPtr != uart1.rxOutPtr){
/ 转移这次接收的一段数据到发送缓冲区 /
U1_DataRxToTx(uart1.rxOutPtr->start, (uart1.rxOutPtr->end - uart1.rxOutPtr->start + 1));
/ 移动rxOutPtr到下一次cpy的地址 /
uart1.rxOutPtr++;
/ 判断rxOutPtr是否需要回卷 /
if(uart1.rxOutPtr == uart1.rxEndPtr){
uart1.rxOutPtr = &uart1.rxLocation[0];
}
}
/ 判断发送缓冲区是否有数据 /
if((uart1.txInPtr != uart1.txOutPtr) && (uart1.TxState == 0) ){
uart1.TxState = 1;
/ 发送数据 /
HAL_UART_Transmit_IT(&uart1.uart, uart1. txOutPtr->start, (uart1.txOutPtr->end - uart1.txOutPtr->start + 1));
/ 移动txOutPtr到下一次cpy的地址 /
uart1.txOutPtr++;
/ 判断txOutPtr是否需要回卷 /
if(uart1.txOutPtr == uart1.txEndPtr){
uart1.txOutPtr = &uart1.txLocation[0];
}
}
}
}
 

七、HAL库：空闲中断方式实现串口123+不定长数据接收+循环收发缓冲区+收发数据

在第七小节拓展而来：实现串口1 2 3 同时收发数据，可以用来控制多个设备用

uart.h

#ifndef __UART_H
#define __UART_H
#include "stm32f1xx_hal.h"
#include "stdint.h"
#include "string.h"
/ 缓冲区宏定义 /
#define U1_RX_SIZE 2048 //接收缓冲区长度
#define U1_TX_SIZE 2048 //发送缓冲区长度
#define U1_RX_MAX 256 //最大单次发送量（实际值 - 1 = 255字节）
#define U2_RX_SIZE 2048
#define U2_TX_SIZE 2048
#define U2_RX_MAX 256
#define U3_RX_SIZE 2048
#define U3_TX_SIZE 2048
#define U3_RX_MAX 256
/ Location Ctrl Block /
/ （接收/发送）位置控制块 /
typedef struct{
uint8_t* start;
uint8_t* end;
}LCB;
/ Uart Ctrl Block /
/ 串口控制块 /
typedef struct{
uint32_t rxCount; //记录接收缓冲区中当前已有的数据量
uint32_t txCount; //记录发送缓冲区中当前已有的数据量
LCB rxLocation[10]; //记录接收缓冲区每次接收的位置
LCB txLocation[10]; //记录发送缓冲区每次接收的位置
LCB* rxInPtr; //指向下次接收缓冲区存放位置
LCB* rxOutPtr; //指向下次接收缓冲区读取位置
LCB* rxEndPtr; //指向接收缓冲区结束位置
LCB* txInPtr; //指向下次发送缓冲区存放位置
LCB* txOutPtr; //指向下次发送缓冲区读取位置
LCB* txEndPtr; //指向发送缓冲区结束位置
UART_HandleTypeDef uart; //串口总控结构体
uint8_t TxState; //发送忙碌标志位
}UCB;
/ 初始化 /
void U1_Init(uint32_t bandrate);
void U2_Init(uint32_t bandrate);
void U3_Init(uint32_t bandrate);
/ 初始化UCB控制块指针 /
void U1_PtrInit(void);
void U2_PtrInit(void);
void U3_PtrInit(void);
/ 转移RxBuff数据到TxBuff /
void U1_DataRxToTx(uint8_t* data, uint32_t data_len);
void U2_DataRxToTx(uint8_t* data, uint32_t data_len);
void U3_DataRxToTx(uint8_t* data, uint32_t data_len);
/ 总控结构体 /
extern UCB uart1;
extern UCB uart2;
extern UCB uart3;
/ 缓冲区 /
extern uint8_t U1_Rx_Buff[U1_RX_SIZE];
extern uint8_t U1_Tx_Buff[U1_TX_SIZE];
extern uint8_t U2_Rx_Buff[U2_RX_SIZE];
extern uint8_t U2_Tx_Buff[U2_TX_SIZE];
extern uint8_t U3_Rx_Buff[U3_RX_SIZE];
extern uint8_t U3_Tx_Buff[U3_TX_SIZE];
#endif

uart.c

#include "uart.h"
/ 创建串口总控结构体 /
UCB uart1;
UCB uart2;
UCB uart3;
/ 缓冲区 /
uint8_t U1_Rx_Buff[U1_RX_SIZE];
uint8_t U1_Tx_Buff[U1_TX_SIZE];
uint8_t U2_Rx_Buff[U2_RX_SIZE];
uint8_t U2_Tx_Buff[U2_TX_SIZE];
uint8_t U3_Rx_Buff[U3_RX_SIZE];
uint8_t U3_Tx_Buff[U3_TX_SIZE];
/ 初始化串口 /
void U1_Init(uint32_t bandrate){
uart1.uart.Instance = USART1; //使用那个串口
uart1.uart.Init.BaudRate = bandrate; //波特率
uart1.uart.Init.WordLength = UART_WORDLENGTH_8B; //数据位长度
uart1.uart.Init.StopBits = UART_STOPBITS_1; //停止位
uart1.uart.Init.Parity = UART_PARITY_NONE; //校验模式
uart1.uart.Init.Mode = UART_MODE_TX_RX; //传输模式
uart1.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE; //流控
HAL_UART_Init(&uart1.uart);
/ 初始化UCB控制块指针 /
U1_PtrInit();
}
/ 初始化串口 /
void U2_Init(uint32_t bandrate){
uart2.uart.Instance = USART2; //使用那个串口
uart2.uart.Init.BaudRate = bandrate; //波特率
uart2.uart.Init.WordLength = UART_WORDLENGTH_8B; //数据位长度
uart2.uart.Init.StopBits = UART_STOPBITS_1; //停止位
uart2.uart.Init.Parity = UART_PARITY_NONE; //校验模式
uart2.uart.Init.Mode = UART_MODE_TX_RX; //传输模式
uart2.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE; //流控
HAL_UART_Init(&uart2.uart);
/ 初始化UCB控制块指针 /
U2_PtrInit();
}
/ 初始化串口 /
void U3_Init(uint32_t bandrate){
uart3.uart.Instance = USART3; //使用那个串口
uart3.uart.Init.BaudRate = bandrate; //波特率
uart3.uart.Init.WordLength = UART_WORDLENGTH_8B; //数据位长度
uart3.uart.Init.StopBits = UART_STOPBITS_1; //停止位
uart3.uart.Init.Parity = UART_PARITY_NONE; //校验模式
uart3.uart.Init.Mode = UART_MODE_TX_RX; //传输模式
uart3.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE; //流控
HAL_UART_Init(&uart3.uart);
/ 初始化UCB控制块指针 /
U3_PtrInit();
}
/ 初始化U1_UCB控制块指针 /
void U1_PtrInit(void){
uart1.rxCount = 0;
uart1.rxInPtr = &uart1.rxLocation[0];
uart1.rxOutPtr = &uart1.rxLocation[0];
uart1.rxEndPtr = &uart1.rxLocation[9];
uart1.rxInPtr->start = &U1_Rx_Buff[0];
uart1.txCount = 0;
uart1.txInPtr = &uart1.txLocation[0];
uart1.txOutPtr = &uart1.txLocation[0];
uart1.txEndPtr = &uart1.txLocation[9];
uart1.txInPtr->start = &U1_Tx_Buff[0];
__HAL_UART_ENABLE_IT(&uart1.uart,UART_IT_IDLE);
HAL_UART_Receive_IT(&uart1.uart, uart1.rxInPtr->start, U1_RX_MAX);
}
void U2_PtrInit(void){
uart2.rxCount = 0;
uart2.rxInPtr = &uart2.rxLocation[0];
uart2.rxOutPtr = &uart2.rxLocation[0];
uart2.rxEndPtr = &uart2.rxLocation[9];
uart2.rxInPtr->start = &U2_Rx_Buff[0];
uart2.txCount = 0;
uart2.txInPtr = &uart2.txLocation[0];
uart2.txOutPtr = &uart2.txLocation[0];
uart2.txEndPtr = &uart2.txLocation[9];
uart2.txInPtr->start = &U2_Tx_Buff[0];
__HAL_UART_ENABLE_IT(&uart2.uart,UART_IT_IDLE);
HAL_UART_Receive_IT(&uart2.uart, uart2.rxInPtr->start, U2_RX_MAX);
}
void U3_PtrInit(void){
uart3.rxCount = 0;
uart3.rxInPtr = &uart3.rxLocation[0];
uart3.rxOutPtr = &uart3.rxLocation[0];
uart3.rxEndPtr = &uart3.rxLocation[9];
uart3.rxInPtr->start = &U3_Rx_Buff[0];
uart3.txCount = 0;
uart3.txInPtr = &uart3.txLocation[0];
uart3.txOutPtr = &uart3.txLocation[0];
uart3.txEndPtr = &uart3.txLocation[9];
uart3.txInPtr->start = &U3_Tx_Buff[0];
__HAL_UART_ENABLE_IT(&uart3.uart,UART_IT_IDLE);
HAL_UART_Receive_IT(&uart3.uart, uart3.rxInPtr->start, U3_RX_MAX);
}
/ 转移Rx_Buff数据到 Tx_Buff /
void U1_DataRxToTx(uint8_t* data, uint32_t data_len){
if((U1_TX_SIZE - uart1.txCount) > data_len){
uart1.txInPtr->start = &U1_Tx_Buff[uart1.txCount];
}
else{
uart1.txCount = 0;
uart1.txInPtr->start = &U1_Tx_Buff[0];
}
memcpy(uart1.txInPtr->start, data, data_len);
uart1.txCount += data_len;
uart1.txInPtr->end = &U1_Tx_Buff[uart1.txCount - 1];
uart1.txInPtr++;
if(uart1.txInPtr == uart1.txEndPtr){
uart1.txInPtr = &uart1.txLocation[0];
}
}
void U2_DataRxToTx(uint8_t* data, uint32_t data_len){
if((U2_TX_SIZE - uart2.txCount) > data_len){
uart2.txInPtr->start = &U2_Tx_Buff[uart2.txCount];
}
else{
uart2.txCount = 0;
uart2.txInPtr->start = &U2_Tx_Buff[0];
}
memcpy(uart2.txInPtr->start, data, data_len);
uart2.txCount += data_len;
uart2.txInPtr->end = &U2_Tx_Buff[uart2.txCount - 1];
uart2.txInPtr++;
if(uart2.txInPtr == uart2.txEndPtr){
uart2.txInPtr = &uart2.txLocation[0];
}
}
void U3_DataRxToTx(uint8_t* data, uint32_t data_len){
if((U3_TX_SIZE - uart3.txCount) > data_len){
uart3.txInPtr->start = &U3_Tx_Buff[uart3.txCount];
}
else{
uart3.txCount = 0;
uart3.txInPtr->start = &U3_Tx_Buff[0];
}
memcpy(uart3.txInPtr->start, data, data_len);
uart3.txCount += data_len;
uart3.txInPtr->end = &U3_Tx_Buff[uart3.txCount - 1];
uart3.txInPtr++;
if(uart3.txInPtr == uart3.txEndPtr){
uart3.txInPtr = &uart3.txLocation[0];
}
}
/ UART硬件初始化回调 /
void HAL_UART_MspInit(UART_HandleTypeDef *huart){
GPIO_InitTypeDef GPIO_InitType;
if(huart->Instance == USART1){
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_9;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART1_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
}else if(huart->Instance == USART2){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART2_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
}else if(huart->Instance == USART3){
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_11;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
HAL_NVIC_SetPriority(USART3_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART3_IRQn);
}
}
/ 强声明的接收完成回调函数 /
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的错误回调函数 /
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的发送完成回调函数 /
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
/ 发送完成，标志位清零 /
uart1.TxState = 0;
}else if(huart->Instance == USART2){
uart2.TxState = 0;
}else if(huart->Instance == USART3){
uart3.TxState = 0;
}
}
/ 强声明的接收终止回调函数 /
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.rxInPtr->end = &U1_Rx_Buff[uart1.rxCount - 1];
uart1.rxInPtr++;
if(uart1.rxInPtr == uart1.rxEndPtr){
uart1.rxInPtr = &uart1.rxLocation[0];
}
if((U1_RX_SIZE - uart1.rxCount) < U1_RX_MAX){
uart1.rxCount = 0;
uart1.rxInPtr->start = &U1_Rx_Buff[0];
}else{
uart1.rxInPtr->start = &U1_Rx_Buff[uart1.rxCount];
}
HAL_UART_Receive_IT(&uart1.uart, uart1.rxInPtr->start, U1_RX_MAX);
}else if(huart->Instance == USART2){
uart2.rxInPtr->end = &U2_Rx_Buff[uart2.rxCount - 1];
uart2.rxInPtr++;
if(uart2.rxInPtr == uart2.rxEndPtr){
uart2.rxInPtr = &uart2.rxLocation[0];
}
if((U2_RX_SIZE - uart2.rxCount) < U2_RX_MAX){
uart2.rxCount = 0;
uart2.rxInPtr->start = &U2_Rx_Buff[0];
}else{
uart2.rxInPtr->start = &U2_Rx_Buff[uart2.rxCount];
}
HAL_UART_Receive_IT(&uart2.uart, uart2.rxInPtr->start, U2_RX_MAX);
}else if(huart->Instance == USART3){
uart3.rxInPtr->end = &U3_Rx_Buff[uart3.rxCount - 1];
uart3.rxInPtr++;
if(uart3.rxInPtr == uart3.rxEndPtr){
uart3.rxInPtr = &uart3.rxLocation[0];
}
if((U3_RX_SIZE - uart3.rxCount) < U3_RX_MAX){
uart3.rxCount = 0;
uart3.rxInPtr->start = &U3_Rx_Buff[0];
}else{
uart3.rxInPtr->start = &U3_Rx_Buff[uart3.rxCount];
}
HAL_UART_Receive_IT(&uart3.uart, uart3.rxInPtr->start, U3_RX_MAX);
}
}

stm32fxx_It.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}
/-------------------------------------------------/
/函数名：串口1中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
/ 在每次进入中断后，判断是否为空闲中断 /
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
/ 清除空闲标志位 /
//__HAL_UART_CLEAR_FLAG(&uart1.uart, UART_FLAG_IDLE);
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
/ 获取这次传输了多少字节 /
uart1.rxCount += (U1_RX_MAX - uart1.uart.RxXferCount);
/ 终止当前的接收(会把RxferCount清零) /
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
/-------------------------------------------------/
/函数名：串口2中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
uart2.rxCount += (U2_RX_MAX - uart2.uart.RxXferCount);
HAL_UART_AbortReceive_IT(&uart2.uart);
}
}
/-------------------------------------------------/
/函数名：串口3中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.rxCount += (U3_RX_MAX - uart3.uart.RxXferCount);
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
U2_Init(921600);
U3_Init(921600);
while(1){
/ ------------------UART1------------------ /
/ 判断接收缓冲区是否有数据 /
if(uart1.rxInPtr != uart1.rxOutPtr){
U1_DataRxToTx(uart1.rxOutPtr->start, (uart1.rxOutPtr->end - uart1.rxOutPtr->start + 1));
uart1.rxOutPtr++;
if(uart1.rxOutPtr == uart1.rxEndPtr){
uart1.rxOutPtr = &uart1.rxLocation[0];
}
}
/ 判断发送缓冲区是否有数据 /
if((uart1.txInPtr != uart1.txOutPtr) && (uart1.TxState == 0) ){
uart1.TxState = 1;
HAL_UART_Transmit_IT(&uart1.uart, uart1. txOutPtr->start, (uart1.txOutPtr->end - uart1.txOutPtr->start + 1));
uart1.txOutPtr++;
if(uart1.txOutPtr == uart1.txEndPtr){
uart1.txOutPtr = &uart1.txLocation[0];
}
}
/ ------------------UART2------------------ /
if(uart2.rxInPtr != uart2.rxOutPtr){
U2_DataRxToTx(uart2.rxOutPtr->start, (uart2.rxOutPtr->end - uart2.rxOutPtr->start + 1));
uart2.rxOutPtr++;
if(uart2.rxOutPtr == uart2.rxEndPtr){
uart2.rxOutPtr = &uart2.rxLocation[0];
}
}
/ 判断发送缓冲区是否有数据 /
if((uart2.txInPtr != uart2.txOutPtr) && (uart2.TxState == 0) ){
uart2.TxState = 1;
HAL_UART_Transmit_IT(&uart2.uart, uart2. txOutPtr->start, (uart2.txOutPtr->end - uart2.txOutPtr->start + 1));
uart2.txOutPtr++;
if(uart2.txOutPtr == uart2.txEndPtr){
uart2.txOutPtr = &uart2.txLocation[0];
}
}
/ ------------------UART3------------------ /
if(uart3.rxInPtr != uart3.rxOutPtr){
U3_DataRxToTx(uart3.rxOutPtr->start, (uart3.rxOutPtr->end - uart3.rxOutPtr->start + 1));
uart3.rxOutPtr++;
if(uart3.rxOutPtr == uart3.rxEndPtr){
uart3.rxOutPtr = &uart3.rxLocation[0];
}
}
/ 判断发送缓冲区是否有数据 /
if((uart3.txInPtr != uart3.txOutPtr) && (uart3.TxState == 0) ){
uart3.TxState = 1;
HAL_UART_Transmit_IT(&uart3.uart, uart3. txOutPtr->start, (uart3.txOutPtr->end - uart3.txOutPtr->start + 1));
uart3.txOutPtr++;
if(uart3.txOutPtr == uart3.txEndPtr){
uart3.txOutPtr = &uart3.txLocation[0];
}
}
}
}
 

八、HAL库：DMA不定长接收 + 空闲中断 + 循环收发缓冲区 串口123收发数据

1. 介绍

DMA（Direct Memory Access）是一种直接内存访问技术，
可以在不经过CPU的情况下实现外设与内存之间的数据传输，提高数据传输效率

2. DMA实现的相关函数

#define __HAL_LINKDMA(HANDLE, PPP_DMA_FIELD, DMA_HANDLE) do{ (HANDLE)->PPP_DMA_FIELD = &(DMA_HANDLE); (DMA_HANDLE).Parent = (HANDLE); } while(0U)
  • 三个参数：第一个是外设句柄，第二个是外设句柄内的一个DMA句柄指针，最后一个参数是DMA句柄。
  • 每个外设的句柄结构体中都一个该外设关于DMA相关的设置例如串口为
    • DMA_HandleTypeDef *hdmatx; UART TX 的DMA句柄参数
    • DMA_HandleTypeDef *hdmarx; UART RX 的DMA句柄参数
    • 函数的第二个参数用于指定外设中的 DMA 请求标识符。 不同外设有不同含义： 如在定时器中可对应更新、捕获 / 比较等事件的 DMA 请求标识符，用于触发相关 DMA 传输实现自动更新参数等； 在 SPI 中是发送或接收 DMA 请求标识符，能实现高速自动收发数据； 在 ADC 中则通常是转换完成 DMA 请求标识符，可将转换结果自动存储到内存缓冲区。 总之，该参数起到将特定外设事件与 DMA 传输关联起来的作用，以提高数据传输处理效率。
调用这个API，会把用到DMA的外设总控结构体和DMA响应通道的总控结构体 进行双向的父子链接， 也就是 你能找到我 我也能找到你。
DMA 1 - 7 有各自的中断入口点， 有各自的 中断处理函数。
通过这个Link 就建立起来的 DMA和外设的双向的链接了。
然后HAL库会自动配置好 在 发生特定事件时，对内存进行搬运的代码。
 
__HAL_DMA_GET_COUNTER(__HANDLE__);
  • HANDLE用到DMA的外设
获取DMA剩余 未传输的数据量

3. 注意事项：

  1. DMA有不同的通道，也就需要有不同的DMA总控结构体， 例如 串口3的Tx在通道2 ， Rx在通道3…
      2. 所以在选用DMA通道的时候， 一定要选对！千万不要Link错了
      notion image
  1. 使用串口的DMA接收和发送之后， 是不会通过中断来接收的（RXNE）
  1. 使用串口的DMA发送之后， 会进入发送完成回调函数， 和 中断等一样。
      2. （DMA发送完毕之后会置TCIE 发送完成中断为 1）
  1. 注意循环和正常模式。

4. 程序设计

3.1 大致流程

  1. 打开DMA时钟
  1. 配置 DMA_HandleTypeDef 类型的 DMA通道
      • 实例、初始化的方向、存储区是否递增、目标地址是否自增、两方字长、工作模式等
  1. 通过__HAL_LINKDMA 链接 外设与通道，并配置第二个参数。在发生发送、或接收事件时，开始搬运数据。
  1. 打开对应通道的中断（虽然暂时不用）
  1. 可以利用__HAL_DMA_GET_COUNTER函数来获得当前DMA的未搬运的量

uart.h

uart.c

/ UART硬件初始化回调 /
void HAL_UART_MspInit(UART_HandleTypeDef *huart){
GPIO_InitTypeDef GPIO_InitType;
if(huart->Instance == USART1){
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE(); //打开DMA时钟
GPIO_InitType.Pin = GPIO_PIN_9;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART1_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
/ DMA配置 /
// 发送配置
uart1.dmaTx.Instance = DMA1_Channel4; //DMA通道:4
uart1.dmaTx.Init.Direction = DMA_MEMORY_TO_PERIPH; //方向：存储区到外设
uart1.dmaTx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE; //存储区数据宽度
uart1.dmaTx.Init.MemInc = DMA_MINC_ENABLE; //存储区是否递增？
uart1.dmaTx.Init.Mode = DMA_NORMAL; //工作模式（正常或循环）
uart1.dmaTx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE; //外设数据宽度
uart1.dmaTx.Init.PeriphInc = DMA_PINC_DISABLE; //目标地址是否递增？
uart1.dmaTx.Init.Priority = DMA_PRIORITY_MEDIUM; //优先级
//链接
__HAL_LINKDMA(huart, hdmatx, uart1.dmaTx);
//初始化
HAL_DMA_Init(&uart1.dmaTx);
//打开DMA通道中断
HAL_NVIC_SetPriority(DMA1_Channel4_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
// 接收配置
uart1.dmaRx.Instance = DMA1_Channel5; //DMA通道:5
uart1.dmaRx.Init.Direction = DMA_PERIPH_TO_MEMORY; //方向：外设区到存储
uart1.dmaRx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart1.dmaRx.Init.MemInc = DMA_MINC_ENABLE;
uart1.dmaRx.Init.Mode = DMA_NORMAL;
uart1.dmaRx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart1.dmaRx.Init.PeriphInc = DMA_PINC_DISABLE;
uart1.dmaRx.Init.Priority = DMA_PRIORITY_MEDIUM;
//链接
__HAL_LINKDMA(huart, hdmarx, uart1.dmaRx);
//初始化
HAL_DMA_Init(&uart1.dmaRx);
//打开DMA中断
HAL_NVIC_SetPriority(DMA1_Channel5_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
}else if(huart->Instance == USART2){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART2_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
/ DMA配置 /
uart2.dmaTx.Instance = DMA1_Channel7;
uart2.dmaTx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart2.dmaTx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmaTx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmaTx.Init.Mode = DMA_NORMAL;
uart2.dmaTx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmaTx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmaTx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart2.dmaTx);
HAL_DMA_Init(&uart2.dmaTx);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
uart2.dmaRx.Instance = DMA1_Channel6;
uart2.dmaRx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart2.dmaRx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmaRx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmaRx.Init.Mode = DMA_NORMAL;
uart2.dmaRx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmaRx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmaRx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart2.dmaRx);
HAL_DMA_Init(&uart2.dmaRx);
HAL_NVIC_SetPriority(DMA1_Channel6_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
}else if(huart->Instance == USART3){
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_11;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
HAL_NVIC_SetPriority(USART3_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART3_IRQn);
/ DMA配置 /
uart3.dmaTx.Instance = DMA1_Channel2;
uart3.dmaTx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart3.dmaTx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmaTx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmaTx.Init.Mode = DMA_NORMAL;
uart3.dmaTx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmaTx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmaTx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart3.dmaTx);
HAL_DMA_Init(&uart3.dmaTx);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
uart3.dmaRx.Instance = DMA1_Channel3;
uart3.dmaRx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart3.dmaRx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmaRx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmaRx.Init.Mode = DMA_NORMAL;
uart3.dmaRx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmaRx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmaRx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart3.dmaRx);
HAL_DMA_Init(&uart3.dmaRx);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}
}
/ 强声明的接收完成回调函数 /
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的错误回调函数 /
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}else if(huart->Instance == USART2){
}else if(huart->Instance == USART3){
}
}
/ 强声明的发送完成回调函数 /
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
/ 发送完成，标志位清零 /
uart1.TxState = 0;
}else if(huart->Instance == USART2){
uart2.TxState = 0;
}else if(huart->Instance == USART3){
uart3.TxState = 0;
}
}
/ 强声明的接收终止回调函数 /
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.rxInPtr->end = &U1_Rx_Buff[uart1.rxCount - 1];
uart1.rxInPtr++;
if(uart1.rxInPtr == uart1.rxEndPtr){
uart1.rxInPtr = &uart1.rxLocation[0];
}
if((U1_RX_SIZE - uart1.rxCount) < U1_RX_MAX){
uart1.rxCount = 0;
uart1.rxInPtr->start = &U1_Rx_Buff[0];
}else{
uart1.rxInPtr->start = &U1_Rx_Buff[uart1.rxCount];
}
HAL_UART_Receive_DMA(&uart1.uart, uart1.rxInPtr->start, U1_RX_MAX);
}else if(huart->Instance == USART2){
uart2.rxInPtr->end = &U2_Rx_Buff[uart2.rxCount - 1];
uart2.rxInPtr++;
if(uart2.rxInPtr == uart2.rxEndPtr){
uart2.rxInPtr = &uart2.rxLocation[0];
}
if((U2_RX_SIZE - uart2.rxCount) < U2_RX_MAX){
uart2.rxCount = 0;
uart2.rxInPtr->start = &U2_Rx_Buff[0];
}else{
uart2.rxInPtr->start = &U2_Rx_Buff[uart2.rxCount];
}
HAL_UART_Receive_DMA(&uart2.uart, uart2.rxInPtr->start, U2_RX_MAX);
}else if(huart->Instance == USART3){
uart3.rxInPtr->end = &U3_Rx_Buff[uart3.rxCount - 1];
uart3.rxInPtr++;
if(uart3.rxInPtr == uart3.rxEndPtr){
uart3.rxInPtr = &uart3.rxLocation[0];
}
if((U3_RX_SIZE - uart3.rxCount) < U3_RX_MAX){
uart3.rxCount = 0;
uart3.rxInPtr->start = &U3_Rx_Buff[0];
}else{
uart3.rxInPtr->start = &U3_Rx_Buff[uart3.rxCount];
}
HAL_UART_Receive_DMA(&uart3.uart, uart3.rxInPtr->start, U3_RX_MAX);
}
}

stm32fxx_It.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_13);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}
/-------------------------------------------------/
/函数名：串口1中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
/ 在每次进入中断后，判断是否为空闲中断 /
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
/ 清除空闲标志位 /
//__HAL_UART_CLEAR_FLAG(&uart1.uart, UART_FLAG_IDLE);
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
/ 获取这次传输了多少字节 /
//uart1.rxCount += (U1_RX_MAX - uart1.uart.RxXferCount);
uart1.rxCount += (U1_RX_MAX - (__HAL_DMA_GET_COUNTER(&uart1.dmaRx))); //利用DMA的api 获取剩余未发送数据量
/ 终止当前的接收(会把RxferCount清零) /
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
/-------------------------------------------------/
/函数名：串口2中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
uart2.rxCount += (U2_RX_MAX - (__HAL_DMA_GET_COUNTER(&uart2.dmaRx)));
HAL_UART_AbortReceive_IT(&uart2.uart);
}
}
/-------------------------------------------------/
/函数名：串口3中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.rxCount += (U3_RX_MAX - (__HAL_DMA_GET_COUNTER(&uart3.dmaRx)));
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}
/-------------------------------------------------/
/函数名：DMA通道4中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void DMA1_Channel4_IRQHandler(void) //Uart1 Tx通道
{
HAL_DMA_IRQHandler(&uart1.dmaTx);
}
/-------------------------------------------------/
/函数名：DMA通道5中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void DMA1_Channel5_IRQHandler(void) //Uart1 Rx通道
{
HAL_DMA_IRQHandler(&uart1.dmaRx);
}
/-------------------------------------------------/
/函数名：DMA通道7中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void DMA1_Channel7_IRQHandler(void) //Uart2 Tx通道
{
HAL_DMA_IRQHandler(&uart2.dmaTx);
}
/-------------------------------------------------/
/函数名：DMA通道6中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void DMA1_Channel6_IRQHandler(void) //Uart2 Rx通道
{
HAL_DMA_IRQHandler(&uart2.dmaRx);
}
/-------------------------------------------------/
/函数名：DMA通道2中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void DMA1_Channel2_IRQHandler(void) //Uart3 Tx通道
{
HAL_DMA_IRQHandler(&uart3.dmaTx);
}
/-------------------------------------------------/
/函数名：DMA通道3中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void DMA1_Channel3_IRQHandler(void) //Uart3 Rx通道
{
HAL_DMA_IRQHandler(&uart3.dmaRx);
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
U2_Init(921600);
U3_Init(921600);
while(1){
/ ------------------UART1------------------ /
/ 判断接收缓冲区是否有数据 /
if(uart1.rxInPtr != uart1.rxOutPtr){
U1_DataRxToTx(uart1.rxOutPtr->start, (uart1.rxOutPtr->end - uart1.rxOutPtr->start + 1));
uart1.rxOutPtr++;
if(uart1.rxOutPtr == uart1.rxEndPtr){
uart1.rxOutPtr = &uart1.rxLocation[0];
}
}
/ 判断发送缓冲区是否有数据 /
if((uart1.txInPtr != uart1.txOutPtr) && (uart1.TxState == 0) ){
uart1.TxState = 1;
HAL_UART_Transmit_DMA(&uart1.uart, uart1. txOutPtr->start, (uart1.txOutPtr->end - uart1.txOutPtr->start + 1));
uart1.txOutPtr++;
if(uart1.txOutPtr == uart1.txEndPtr){
uart1.txOutPtr = &uart1.txLocation[0];
}
}
/ ------------------UART2------------------ /
if(uart2.rxInPtr != uart2.rxOutPtr){
U2_DataRxToTx(uart2.rxOutPtr->start, (uart2.rxOutPtr->end - uart2.rxOutPtr->start + 1));
uart2.rxOutPtr++;
if(uart2.rxOutPtr == uart2.rxEndPtr){
uart2.rxOutPtr = &uart2.rxLocation[0];
}
}
/ 判断发送缓冲区是否有数据 /
if((uart2.txInPtr != uart2.txOutPtr) && (uart2.TxState == 0) ){
uart2.TxState = 1;
HAL_UART_Transmit_DMA(&uart2.uart, uart2. txOutPtr->start, (uart2.txOutPtr->end - uart2.txOutPtr->start + 1));
uart2.txOutPtr++;
if(uart2.txOutPtr == uart2.txEndPtr){
uart2.txOutPtr = &uart2.txLocation[0];
}
}
/ ------------------UART3------------------ /
if(uart3.rxInPtr != uart3.rxOutPtr){
U3_DataRxToTx(uart3.rxOutPtr->start, (uart3.rxOutPtr->end - uart3.rxOutPtr->start + 1));
uart3.rxOutPtr++;
if(uart3.rxOutPtr == uart3.rxEndPtr){
uart3.rxOutPtr = &uart3.rxLocation[0];
}
}
/ 判断发送缓冲区是否有数据 /
if((uart3.txInPtr != uart3.txOutPtr) && (uart3.TxState == 0) ){
uart3.TxState = 1;
HAL_UART_Transmit_DMA(&uart3.uart, uart3. txOutPtr->start, (uart3.txOutPtr->end - uart3.txOutPtr->start + 1));
uart3.txOutPtr++;
if(uart3.txOutPtr == uart3.txEndPtr){
uart3.txOutPtr = &uart3.txLocation[0];
}
}
}
}
 
 

九、HAL库：双机通信，DMA方式收发 控制对方LED灯

在上面的基础上进行修改

1. 大概思路

在本机 按键按下时，进入中断。在中断回调中使用UART1 发送数据LED_ON或LED_OFF
在UART1接收到数据时，进行判断，使用strcmp函数
插线的话，两个设备 TX对RX RX对TX， GND对GND就Ok了
 

十、HAL库：单线半双工，双机通信，DMA方式收发 控制对方LED灯

在上面的基础上进行修改

1. 单线半双工简介

两个单片机之间通过串口，单线半双工通信。
半双工：同一时间只能发送或者接收，此时仅使用TX引脚
注意：此时TX引脚需要配置为OD模式，外接上拉电阻

2. 大概思路

在本机 按键按下时，进入中断。在中断回调中使用UART1 发送数据LED_ON或LED_OFF
在UART1接收到数据时，进行判断，使用strcmp函数
插线的话，两个设备 TX对RX RX对TX， GND对GND就Ok了

3. 注意

  • 在初始化时，要使用HAL_HalfDuplex_Init 来初始化
  • 单线半双工用的是串口的Tx引脚， 注意Tx引脚要初始化为AF_OD 模式，并且接上拉电阻
  • 一般在初始化的时候，默认为单线半双工的接收状态，只有在使用发送的时候，才使用HAL_HalfDuplex_EnableTransmitter(&uart1.uart);来使能单线半双工的发射模式。并且在发送完成之后，（一般使用发送完成回调）把发射模式重置为默认的接收模式。HAL_HalfDuplex_EnableReceiver(&uart1.uart);

十一、HAL库：多主机通信 地址检测唤醒 定时器超时 DMA不定长接收

1. 设备唤醒介绍

1.1 唤醒方式：

  • 三个及以上单片机之间通过串口，相互通信收发数据时。
  • 此时我们需要涉及到主机和从机之分，从机的唤醒有分为：地址 or 空闲唤醒

1.2 地址唤醒：

  • 每个从机会具备一个硬件的从机地址， 地址会记录在USART_CR2寄存器的ADD，占用了4个二进制位。范围0x00~0x0F
  • 但是主机在发送时，需要区分地址 还是数据：如果最高位为1，表示地址，为0表示数据。 所以主机发送的数据，首个字节是从机的地址，范围应该是0x80~0x8F， 8表示最高位7为1。 所以在发送数据时，最高位为 0 数据的有效位为 bit0~bit6 7位数据

1.3 多处理器通信：

与I2C类似,主机Tx为PP模式
  • 主机的tx，接到各个从设备的Rx引脚。 从机的tx输出逻辑 地与（线与）在一起，
  • 注意：
    • 从机的Tx不能为PP模式，否则两个从机输出1 、0会形成短路。
    • 从机的Tx‘应该为OD模式，外接上拉电阻。
    • 并且上拉电阻尽量选择外部上拉电阻，否则选择内部上拉，在波特率比较高的时候，电压上拉速度慢，导致检测为0等情况。
  • USART_CR1寄存器的RWU位
    • RWU可以被硬件自动控制或在某个条件先由软件写入
    • RWU高电平表示从机为静默模式，不会接收数据
    • RWU低电平表示从机为正常模式，会接收数据
    • 从机通过判断地址，来切换到正常模式，
    • 未匹配的地址可以把正常模式的从机返回为静默模式，也可以手动返回为静默模式，
    • 在初始化从机之后 需要手动把RWU变为高电平：静默模式

2. 特别注意：

  1. DMA在搬运UART的的数据时，会顺便把RXNE的标志位硬件清除。所以在开启DMA接收时，RXNE在软件上检测不到标志位为1
  1. 多处理器有空闲总线唤醒机制，只要用了多处理器的模式，那么空闲中断就不会产生了
      2. 就不能使用空闲中断来进行数据的不定长接收，可以换一种方式：使用定时器的超时判断，来进行数据的不定长接收。

2.1 使用定时器的超时判断，来进行数据的不定长接收思路详解

假设波特率为9600 ，那么一秒钟最快能发送960个字节，也就是1ms多点。也就是在一个连续的数据流中，每个字节的传输间隔为1ms。
现在开一个定时器，定时时间为大于1ms的值，比如 15 ms。
在每次接收一个字节之后，都清空定时器的计数值。 当定时器超时时，就代表当前一次的数据已经传输完毕。
优点：利用空闲中断时，如果数据发生波动，那么会把一个数据分成两次数据。 而定时器不会，定时器时通过时间判断。 初始化定时器 用于超时计时TIM4_TimerInit(300,7200); 30ms超时时间
需要 打开接收中断 __HAL_UART_ENABLE_IT(&uart2.uart,UART_IT_RXNE);
判断接收标志位 if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_RXNE)){
文件部分
  • 需要修改hal_uart.c（虽然不建议，但是只能这样了）
  • 关闭了RXNE中断和发生空闲中断，让每次接收字节后都进入自己的函数中stm32f1xx_hal_uart.c
uint32_t cr1its = READ_REG(huart->Instance->CR1);
uint32_t cr3its = READ_REG(huart->Instance->CR3);
uint32_t errorflags = 0x00U;
uint32_t dmarequest = 0x00U;
/ If no error occurs /
errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
//删除 RXNE中断
//if (errorflags == RESET)
//{
// / UART in mode Receiver -------------------------------------------------/
// if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
// {
// UART_Receive_IT(huart);
// return;
// }
//}
/ If some errors occur /
if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
{
/ UART parity error interrupt occurred ----------------------------------/
if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_PE;
}
/ UART noise error interrupt occurred -----------------------------------/
if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_NE;
}
/ UART frame error interrupt occurred -----------------------------------/
if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_FE;
}
/ UART Over-Run interrupt occurred --------------------------------------/
if (((isrflags & USART_SR_ORE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_ORE;
}
/ Call UART Error Call back function if need be --------------------------/
if (huart->ErrorCode != HAL_UART_ERROR_NONE)
{
/ UART in mode Receiver -----------------------------------------------/
if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
{
UART_Receive_IT(huart);
}
/* If Overrun error occurs, or if any error occurs in DMA mode reception,
consider error as blocking */
dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
if (((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
{
/* Blocking error : transfer is aborted
Set the UART state ready to be able to start again the process,
Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
UART_EndRxTransfer(huart);
/ Disable the UART DMA Rx request if enabled /
if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
{
CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
/ Abort the UART DMA Rx channel /
if (huart->hdmarx != NULL)
{
/* Set the UART DMA Abort callback :
will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */
huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;
if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
{
/ Call Directly XferAbortCallback function in case of error /
huart->hdmarx->XferAbortCallback(huart->hdmarx);
}
}
else
{
/ Call user error callback /
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
}
}
else
{
/ Call user error callback /
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
}
}
else
{
/* Non Blocking error : transfer could go on.
Error is notified to user through user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
huart->ErrorCode = HAL_UART_ERROR_NONE;
}
}
return;
} / End if some error occurs /
/ UART in mode Transmitter ------------------------------------------------/
//删除 发送缓冲区空的中断
// if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
// {
// UART_Transmit_IT(huart);
// return;
// }
/ UART in mode Transmitter end --------------------------------------------/
if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
{
UART_EndTransmit_IT(huart);
return;
}
/ 写自己的中断回调，现在只能进入我们这个了。 /
#include "uart.h"
#include "timer.h"
else
{
if(uart2.RxState == 0){ / 首字节 /
__HAL_TIM_ENABLE(&htim4); //打开tim4的计数
uart2.RxStat = 1; //标记接收
}else{/ 后续字节 /
__HAL_TIM_SET_COUNTER(&htim4, 0)//清除tim4的计数
}
}
}

2. 要测试功能

主机SW8(PC14)发送：S1_LED(让从机1 LED4翻转状态 UART1
主机SW11(PA0)发送：S2_LED(让从机2 LED4翻转状态)
从机1+从机2 SW8(PC14)：LED ON(让主机LED4点亮) UART2
从机1+从机2 SW11(PA0)：LED OFF(让主机LED4熄灭) UART3
一般情况下，从机不会主动发送数据，因为这里并没有硬件仲裁机制。 一般都是主机问，从机答

3. 相关函数

  • 可以使用转义字符，在字符串中插入16进制数 用于指定从机地址((uint8_t*)"\x81S1_LED", 7); \为转义字符 x0x81 为插入的16进制数， 字节为1字节
  • 从机初始化函数：HAL_MultiProcessor_Init(&uart2.uart, 0x01, UART_WAKEUPMETHOD_ADDRESSMARK);
    • 第一个参数，串口总控结构体
    • 第二个参数，设备地址：0x00~0x0F
    • 第三个参数，唤醒方法：地址唤醒或者空闲唤醒

4. 主机程序

uart.c

#include "stm32f1xx_hal.h"
#include "uart.h"
UCB uart1;
UCB uart2;
UCB uart3;
uint8_t U1_RxBuff[U1_RX_SIZE];
uint8_t U1_TxBuff[U1_TX_SIZE];
uint8_t U2_RxBuff[U2_RX_SIZE];
uint8_t U2_TxBuff[U2_TX_SIZE];
uint8_t U3_RxBuff[U3_RX_SIZE];
uint8_t U3_TxBuff[U3_TX_SIZE];
void U1_Init(uint32_t bandrate){
uart1.uart.Instance = USART1;
uart1.uart.Init.BaudRate = bandrate;
uart1.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart1.uart.Init.StopBits = UART_STOPBITS_1;
uart1.uart.Init.Parity = UART_PARITY_NONE;
uart1.uart.Init.Mode = UART_MODE_TX_RX;
uart1.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_UART_Init(&uart1.uart);
U1_PtrInit();
}
void U1_PtrInit(void){
uart1.RxInPtr = &uart1.RxLocation[0];
uart1.RxOutPtr = &uart1.RxLocation[0];
uart1.RxEndPtr = &uart1.RxLocation[9];
uart1.RxCounter = 0;
uart1.RxInPtr->start = U1_RxBuff;
uart1.TxInPtr = &uart1.TxLocation[0];
uart1.TxOutPtr = &uart1.TxLocation[0];
uart1.TxEndPtr = &uart1.TxLocation[9];
uart1.TxCounter = 0;
uart1.TxInPtr->start = U1_TxBuff;
__HAL_UART_ENABLE_IT(&uart1.uart, UART_IT_IDLE);
HAL_UART_Receive_DMA(&uart1.uart,uart1.RxInPtr->start,U1_RX_MAX);
}
void U1_Txdata(uint8_t *data, uint32_t data_len){
if((U1_TX_SIZE - uart1.TxCounter )>=data_len){
uart1.TxInPtr->start = &U1_TxBuff[uart1.TxCounter];
}else{
uart1.TxCounter = 0;
uart1.TxInPtr->start = U1_TxBuff;
}
memcpy(uart1.TxInPtr->start,data,data_len);
uart1.TxCounter += data_len;
uart1.TxInPtr->end = &U1_TxBuff[uart1.TxCounter - 1];
uart1.TxInPtr++;
if(uart1.TxInPtr == uart1.TxEndPtr){
uart1.TxInPtr = &uart1.TxLocation[0];
}
}
void U2_Init(uint32_t bandrate){
uart2.uart.Instance = USART2;
uart2.uart.Init.BaudRate = bandrate;
uart2.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart2.uart.Init.StopBits = UART_STOPBITS_1;
uart2.uart.Init.Parity = UART_PARITY_NONE;
uart2.uart.Init.Mode = UART_MODE_TX_RX;
uart2.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_HalfDuplex_Init(&uart2.uart);
HAL_HalfDuplex_EnableReceiver(&uart2.uart);
U2_PtrInit();
}
void U2_PtrInit(void){
uart2.RxInPtr = &uart2.RxLocation[0];
uart2.RxOutPtr = &uart2.RxLocation[0];
uart2.RxEndPtr = &uart2.RxLocation[9];
uart2.RxCounter = 0;
uart2.RxInPtr->start = U2_RxBuff;
uart2.TxInPtr = &uart2.TxLocation[0];
uart2.TxOutPtr = &uart2.TxLocation[0];
uart2.TxEndPtr = &uart2.TxLocation[9];
uart2.TxCounter = 0;
uart2.TxInPtr->start = U2_TxBuff;
__HAL_UART_ENABLE_IT(&uart2.uart, UART_IT_IDLE);
HAL_UART_Receive_DMA(&uart2.uart,uart2.RxInPtr->start,U2_RX_MAX);
}
void U2_Txdata(uint8_t *data, uint32_t data_len){
if((U2_TX_SIZE - uart2.TxCounter )>=data_len){
uart2.TxInPtr->start = &U2_TxBuff[uart2.TxCounter];
}else{
uart2.TxCounter = 0;
uart2.TxInPtr->start = U2_TxBuff;
}
memcpy(uart2.TxInPtr->start,data,data_len);
uart2.TxCounter += data_len;
uart2.TxInPtr->end = &U2_TxBuff[uart2.TxCounter - 1];
uart2.TxInPtr++;
if(uart2.TxInPtr == uart2.TxEndPtr){
uart2.TxInPtr = &uart2.TxLocation[0];
}
}
void U3_Init(uint32_t bandrate){
uart3.uart.Instance = USART3;
uart3.uart.Init.BaudRate = bandrate;
uart3.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart3.uart.Init.StopBits = UART_STOPBITS_1;
uart3.uart.Init.Parity = UART_PARITY_NONE;
uart3.uart.Init.Mode = UART_MODE_TX_RX;
uart3.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_HalfDuplex_Init(&uart3.uart);
HAL_HalfDuplex_EnableReceiver(&uart3.uart);
U3_PtrInit();
}
void U3_PtrInit(void){
uart3.RxInPtr = &uart3.RxLocation[0];
uart3.RxOutPtr = &uart3.RxLocation[0];
uart3.RxEndPtr = &uart3.RxLocation[9];
uart3.RxCounter = 0;
uart3.RxInPtr->start = U3_RxBuff;
uart3.TxInPtr = &uart3.TxLocation[0];
uart3.TxOutPtr = &uart3.TxLocation[0];
uart3.TxEndPtr = &uart3.TxLocation[9];
uart3.TxCounter = 0;
uart3.TxInPtr->start = U3_TxBuff;
__HAL_UART_ENABLE_IT(&uart3.uart, UART_IT_IDLE);
HAL_UART_Receive_DMA(&uart3.uart,uart3.RxInPtr->start,U3_RX_MAX);
}
void U3_Txdata(uint8_t *data, uint32_t data_len){
if((U3_TX_SIZE - uart3.TxCounter )>=data_len){
uart3.TxInPtr->start = &U3_TxBuff[uart3.TxCounter];
}else{
uart3.TxCounter = 0;
uart3.TxInPtr->start = U3_TxBuff;
}
memcpy(uart3.TxInPtr->start,data,data_len);
uart3.TxCounter += data_len;
uart3.TxInPtr->end = &U3_TxBuff[uart3.TxCounter - 1];
uart3.TxInPtr++;
if(uart3.TxInPtr == uart3.TxEndPtr){
uart3.TxInPtr = &uart3.TxLocation[0];
}
}
void HAL_UART_MspInit(UART_HandleTypeDef *huart){
GPIO_InitTypeDef GPIO_InitType;
if(huart->Instance == USART1){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_9;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART1_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
uart1.dmatx.Instance = DMA1_Channel4;
uart1.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart1.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart1.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart1.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart1.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart1.dmatx.Init.Mode = DMA_NORMAL;
uart1.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart1.dmatx);
HAL_DMA_Init(&uart1.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel4_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
uart1.dmarx.Instance = DMA1_Channel5;
uart1.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart1.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart1.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart1.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart1.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart1.dmarx.Init.Mode = DMA_NORMAL;
uart1.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart1.dmarx);
HAL_DMA_Init(&uart1.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel5_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
}else if(huart->Instance == USART2){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_AF_OD;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART2_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
uart2.dmatx.Instance = DMA1_Channel7;
uart2.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart2.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmatx.Init.Mode = DMA_NORMAL;
uart2.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart2.dmatx);
HAL_DMA_Init(&uart2.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
uart2.dmarx.Instance = DMA1_Channel6;
uart2.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart2.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmarx.Init.Mode = DMA_NORMAL;
uart2.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart2.dmarx);
HAL_DMA_Init(&uart2.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel6_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
}else if(huart->Instance == USART3){
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_OD;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
HAL_NVIC_SetPriority(USART3_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART3_IRQn);
uart3.dmatx.Instance = DMA1_Channel2;
uart3.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart3.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmatx.Init.Mode = DMA_NORMAL;
uart3.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart3.dmatx);
HAL_DMA_Init(&uart3.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
uart3.dmarx.Instance = DMA1_Channel3;
uart3.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart3.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmarx.Init.Mode = DMA_NORMAL;
uart3.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart3.dmarx);
HAL_DMA_Init(&uart3.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}
}
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.TxState = 0;
}else if(huart->Instance == USART2){
uart2.TxState = 0;
}else if(huart->Instance == USART3){
uart3.TxState = 0;
}
}
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.RxInPtr->end = &U1_RxBuff[uart1.RxCounter - 1];
uart1.RxInPtr++;
if(uart1.RxInPtr == uart1.RxEndPtr){
uart1.RxInPtr = &uart1.RxLocation[0];
}
if((U1_RX_SIZE - uart1.RxCounter)<U1_RX_MAX){
uart1.RxCounter = 0;
uart1.RxInPtr->start = U1_RxBuff;
}else{
uart1.RxInPtr->start = &U1_RxBuff[uart1.RxCounter];
}
HAL_UART_Receive_DMA(&uart1.uart,uart1.RxInPtr->start,U1_RX_MAX);
}else if(huart->Instance == USART2){
uart2.RxInPtr->end = &U2_RxBuff[uart2.RxCounter - 1];
uart2.RxInPtr++;
if(uart2.RxInPtr == uart2.RxEndPtr){
uart2.RxInPtr = &uart2.RxLocation[0];
}
if((U2_RX_SIZE - uart2.RxCounter)<U2_RX_MAX){
uart2.RxCounter = 0;
uart2.RxInPtr->start = U2_RxBuff;
}else{
uart2.RxInPtr->start = &U2_RxBuff[uart2.RxCounter];
}
HAL_UART_Receive_DMA(&uart2.uart,uart2.RxInPtr->start,U2_RX_MAX);
}else if(huart->Instance == USART3){
uart3.RxInPtr->end = &U3_RxBuff[uart3.RxCounter - 1];
uart3.RxInPtr++;
if(uart3.RxInPtr == uart3.RxEndPtr){
uart3.RxInPtr = &uart3.RxLocation[0];
}
if((U3_RX_SIZE - uart3.RxCounter)<U3_RX_MAX){
uart3.RxCounter = 0;
uart3.RxInPtr->start = U3_RxBuff;
}else{
uart3.RxInPtr->start = &U3_RxBuff[uart3.RxCounter];
}
HAL_UART_Receive_DMA(&uart3.uart,uart3.RxInPtr->start,U3_RX_MAX);
}
}

uart.h

#ifndef __UART_H
#define __UART_H
#include "string.h"
#include "stdint.h"
#include "stm32f1xx_hal_uart.h"
#include "stm32f1xx_hal_dma.h"
#define U1_TX_SIZE 2048
#define U1_RX_SIZE 2048
#define U1_RX_MAX 256
#define U2_TX_SIZE 2048
#define U2_RX_SIZE 2048
#define U2_RX_MAX 256
#define U3_TX_SIZE 2048
#define U3_RX_SIZE 2048
#define U3_RX_MAX 256
typedef struct{
uint8_t *start;
uint8_t *end;
}LCB;
typedef struct{
uint32_t RxCounter;
uint32_t TxCounter;
uint32_t TxState;
LCB RxLocation[10];
LCB TxLocation[10];
LCB *RxInPtr;
LCB *RxOutPtr;
LCB *RxEndPtr;
LCB *TxInPtr;
LCB *TxOutPtr;
LCB *TxEndPtr;
UART_HandleTypeDef uart;
DMA_HandleTypeDef dmatx;
DMA_HandleTypeDef dmarx;
}UCB;
void U1_Init(uint32_t bandrate);
void U2_Init(uint32_t bandrate);
void U3_Init(uint32_t bandrate);
void U1_PtrInit(void);
void U2_PtrInit(void);
void U3_PtrInit(void);
void U1_Txdata(uint8_t *data, uint32_t data_len);
void U2_Txdata(uint8_t *data, uint32_t data_len);
void U3_Txdata(uint8_t *data, uint32_t data_len);
extern UCB uart1;
extern UCB uart2;
extern UCB uart3;
#endif

sw.c

#include "stm32f1xx_hal.h"
#include "sw.h"
#include "uart.h"
uint8_t sw1_sta,sw2_sta; //0:没有按下 1：按下了
void SW_Init(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
GPIO_InitType.Mode = GPIO_MODE_INPUT;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Mode = GPIO_MODE_INPUT;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
}
void SW_InitEvent(void){
GPIO_InitTypeDef GPIO_InitType;
//SW1
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_EVT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
}
void SW_InitEventOut(void){
GPIO_InitTypeDef GPIO_InitType;
//PA3
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_GPIOEx_ConfigEventout(AFIO_EVENTOUT_PORT_A,AFIO_EVENTOUT_PIN_3);
HAL_GPIOEx_EnableEventout();
}
//mode 0：按下执行 1：抬起执行
void SW_Init_IT(uint8_t mode){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
if(mode == 0)
GPIO_InitType.Mode = GPIO_MODE_IT_RISING;
else
GPIO_InitType.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI15_10_IRQn,4,0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
if(mode == 0)
GPIO_InitType.Mode = GPIO_MODE_IT_RISING;
else
GPIO_InitType.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI0_IRQn,3,0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
}
void SW_Init_IT2(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
GPIO_InitType.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI15_10_IRQn,4,0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI0_IRQn,3,0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
}
//返回值 0：无按键触发 8：SW8触发
//mode 0：按下执行 1：抬起执行
uint8_t SW_Scan(uint8_t mode){
uint32_t i;
/-------------SW8------------------/
if((SW1_IN == 1)&&(sw1_sta == 0)){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 0){
return 0;
}
}
sw1_sta = 1;
if(mode == 0){
return 8;
}
}else if((SW1_IN == 0)&&(sw1_sta == 1)){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 1){
return 0;
}
}
sw1_sta = 0;
if(mode == 1){
return 8;
}
}
/-------------SW11------------------/
if((SW2_IN == 0)&&(sw2_sta == 0)){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 1){
return 0;
}
}
sw2_sta = 1;
if(mode == 0){
return 11;
}
}else if((SW2_IN == 1)&&(sw2_sta == 1)){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return 0;
}
}
sw2_sta = 0;
if(mode == 1){
return 11;
}
}
return 0;
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
uint32_t i;
//SW8:PC13 SW11:PA0（抢占优先级高）
switch(GPIO_Pin){
case GPIO_PIN_14: if(SW1_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 0){
return;
}
}
U1_Txdata((uint8_t *)"x81S1_LED",7);
//U2_Txdata((uint8_t *)"LED_ON",6);
//U3_Txdata((uint8_t *)"LED_ON",6);
}else if(SW1_IN == 0){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 1){
return;
}
}
HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_0);
}
break;
case GPIO_PIN_0: if(SW2_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return;
}
}
U1_Txdata((uint8_t *)"x82S2_LED",7);
//U2_Txdata((uint8_t *)"LED_OFF",7);
//U3_Txdata((uint8_t *)"LED_OFF",7);
}else if(SW2_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return;
}
}
HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_0);
}
break;
}
}

sw.h

#ifndef __SW_H
#define __SW_H
#include "stdint.h"
#define SW1_IN HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_14)
#define SW2_IN HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)
void SW_Init(void);
uint8_t SW_Scan(uint8_t mode);
void SW_Init_IT(uint8_t mode);
void SW_Init_IT2(void);
void SW_InitEvent(void);
void SW_InitEventOut(void);
#endif

led.c

#include "stm32f1xx_hal.h"
#include "led.h"
void LED_Init(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_13;
GPIO_InitType.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
}
void LED_ON(void){
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
}
void LED_OFF(void){
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
}
void LED_Toggle(void){
HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_13);
}

led.h

#ifndef __LED_H
#define __LED_H
void LED_Init(void);
void LED_ON(void);
void LED_OFF(void);
void LED_Toggle(void);
#endif

stm32f1xx_it.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
uart1.RxCounter += (U1_RX_MAX - __HAL_DMA_GET_COUNTER(&uart1.dmarx));
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx));
HAL_UART_AbortReceive_IT(&uart2.uart);
}
}
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx));
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}
void DMA1_Channel4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmatx);
}
void DMA1_Channel5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmarx);
}
void DMA1_Channel7_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmatx);
}
void DMA1_Channel6_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmarx);
}
void DMA1_Channel2_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart3.dmatx);
}
void DMA1_Channel3_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart3.dmarx);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
int main(void){
HAL_Init();
RccClock_Init();
SW_Init_IT(0);
LED_Init();
U1_Init(921600);
U2_Init(921600);
U3_Init(921600);
while(1){
//串口1收发
if(uart1.RxOutPtr != uart1.RxInPtr){
if(((uart1.RxOutPtr->end - uart1.RxOutPtr->start + 1)==6)&&(memcmp(uart1.RxOutPtr->start,"LED_ON",6) == 0)){
LED_ON();
}else if(((uart1.RxOutPtr->end - uart1.RxOutPtr->start + 1)==7)&&(memcmp(uart1.RxOutPtr->start,"LED_OFF",7) == 0)){
LED_OFF();
}
uart1.RxOutPtr++;
if(uart1.RxOutPtr == uart1.RxEndPtr){
uart1.RxOutPtr = &uart1.RxLocation[0];
}
}
if((uart1.TxOutPtr != uart1.TxInPtr)&&(uart1.TxState==0)){
uart1.TxState = 1;
HAL_UART_Transmit_DMA(&uart1.uart,uart1.TxOutPtr->start,uart1.TxOutPtr->end - uart1.TxOutPtr->start + 1);
uart1.TxOutPtr++;
if(uart1.TxOutPtr == uart1.TxEndPtr){
uart1.TxOutPtr = &uart1.TxLocation[0];
}
}
//串口2收发
if(uart2.RxOutPtr != uart2.RxInPtr){
if(((uart2.RxOutPtr->end - uart2.RxOutPtr->start + 1)==6)&&(memcmp(uart2.RxOutPtr->start,"LED_ON",6) == 0)){
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_RESET);
}else if(((uart2.RxOutPtr->end - uart2.RxOutPtr->start + 1)==7)&&(memcmp(uart2.RxOutPtr->start,"LED_OFF",7) == 0)){
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_SET);
}
uart2.RxOutPtr++;
if(uart2.RxOutPtr == uart2.RxEndPtr){
uart2.RxOutPtr = &uart2.RxLocation[0];
}
}
if((uart2.TxOutPtr != uart2.TxInPtr)&&(uart2.TxState==0)){
uart2.TxState = 1;
HAL_HalfDuplex_EnableTransmitter(&uart2.uart);
HAL_UART_Transmit_DMA(&uart2.uart,uart2.TxOutPtr->start,uart2.TxOutPtr->end - uart2.TxOutPtr->start + 1);
uart2.TxOutPtr++;
if(uart2.TxOutPtr == uart2.TxEndPtr){
uart2.TxOutPtr = &uart2.TxLocation[0];
}
}
//串口3收发
if(uart3.RxOutPtr != uart3.RxInPtr){
if(((uart3.RxOutPtr->end - uart3.RxOutPtr->start + 1)==6)&&(memcmp(uart3.RxOutPtr->start,"LED_ON",6) == 0)){
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_RESET);
}else if(((uart3.RxOutPtr->end - uart3.RxOutPtr->start + 1)==7)&&(memcmp(uart3.RxOutPtr->start,"LED_OFF",7) == 0)){
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_SET);
}
uart3.RxOutPtr++;
if(uart3.RxOutPtr == uart3.RxEndPtr){
uart3.RxOutPtr = &uart3.RxLocation[0];
}
}
if((uart3.TxOutPtr != uart3.TxInPtr)&&(uart3.TxState==0)){
uart3.TxState = 1;
HAL_HalfDuplex_EnableTransmitter(&uart3.uart);
HAL_UART_Transmit_DMA(&uart3.uart,uart3.TxOutPtr->start,uart3.TxOutPtr->end - uart3.TxOutPtr->start + 1);
uart3.TxOutPtr++;
if(uart3.TxOutPtr == uart3.TxEndPtr){
uart3.TxOutPtr = &uart3.TxLocation[0];
}
}
}
}

5. 从机1程序

uart.c

#include "stm32f1xx_hal.h"
#include "uart.h"
UCB uart1;
UCB uart2;
UCB uart3;
uint8_t U1_RxBuff[U1_RX_SIZE];
uint8_t U1_TxBuff[U1_TX_SIZE];
uint8_t U2_RxBuff[U2_RX_SIZE];
uint8_t U2_TxBuff[U2_TX_SIZE];
uint8_t U3_RxBuff[U3_RX_SIZE];
uint8_t U3_TxBuff[U3_TX_SIZE];
void U1_Init(uint32_t bandrate){
uart1.uart.Instance = USART1;
uart1.uart.Init.BaudRate = bandrate;
uart1.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart1.uart.Init.StopBits = UART_STOPBITS_1;
uart1.uart.Init.Parity = UART_PARITY_NONE;
uart1.uart.Init.Mode = UART_MODE_TX_RX;
uart1.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_UART_Init(&uart1.uart);
U1_PtrInit();
}
void U1_PtrInit(void){
uart1.RxInPtr = &uart1.RxLocation[0];
uart1.RxOutPtr = &uart1.RxLocation[0];
uart1.RxEndPtr = &uart1.RxLocation[9];
uart1.RxCounter = 0;
uart1.RxInPtr->start = U1_RxBuff;
uart1.TxInPtr = &uart1.TxLocation[0];
uart1.TxOutPtr = &uart1.TxLocation[0];
uart1.TxEndPtr = &uart1.TxLocation[9];
uart1.TxCounter = 0;
uart1.TxInPtr->start = U1_TxBuff;
__HAL_UART_ENABLE_IT(&uart1.uart, UART_IT_IDLE);
HAL_UART_Receive_DMA(&uart1.uart,uart1.RxInPtr->start,U1_RX_MAX);
}
void U1_Txdata(uint8_t *data, uint32_t data_len){
if((U1_TX_SIZE - uart1.TxCounter )>=data_len){
uart1.TxInPtr->start = &U1_TxBuff[uart1.TxCounter];
}else{
uart1.TxCounter = 0;
uart1.TxInPtr->start = U1_TxBuff;
}
memcpy(uart1.TxInPtr->start,data,data_len);
uart1.TxCounter += data_len;
uart1.TxInPtr->end = &U1_TxBuff[uart1.TxCounter - 1];
uart1.TxInPtr++;
if(uart1.TxInPtr == uart1.TxEndPtr){
uart1.TxInPtr = &uart1.TxLocation[0];
}
}
void U2_Init(uint32_t bandrate){
uart2.uart.Instance = USART2;
uart2.uart.Init.BaudRate = bandrate;
uart2.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart2.uart.Init.StopBits = UART_STOPBITS_1;
uart2.uart.Init.Parity = UART_PARITY_NONE;
uart2.uart.Init.Mode = UART_MODE_TX_RX;
uart2.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_MultiProcessor_Init(&uart2.uart, 0x01, UART_WAKEUPMETHOD_ADDRESSMARK); //多设备初始化
HAL_MultiProcessor_EnterMuteMode(&uart2.uart); //手动进入静默模式
TIM4_TimerInit(300, 7200); //定时器超时时间30ms
U2_PtrInit();
}
void U2_PtrInit(void){
uart2.RxInPtr = &uart2.RxLocation[0];
uart2.RxOutPtr = &uart2.RxLocation[0];
uart2.RxEndPtr = &uart2.RxLocation[9];
uart2.RxCounter = 0;
uart2.RxInPtr->start = U2_RxBuff;
uart2.TxInPtr = &uart2.TxLocation[0];
uart2.TxOutPtr = &uart2.TxLocation[0];
uart2.TxEndPtr = &uart2.TxLocation[9];
uart2.TxCounter = 0;
uart2.TxInPtr->start = U2_TxBuff;
uart2.RxState = 0; //初始化接受状态为0
__HAL_UART_ENABLE_IT(&uart2.uart, UART_IT_RXNE); //打开接收中断
HAL_UART_Receive_DMA(&uart2.uart,uart2.RxInPtr->start,U2_RX_MAX);
}
void U2_Txdata(uint8_t *data, uint32_t data_len){
if((U2_TX_SIZE - uart2.TxCounter )>=data_len){
uart2.TxInPtr->start = &U2_TxBuff[uart2.TxCounter];
}else{
uart2.TxCounter = 0;
uart2.TxInPtr->start = U2_TxBuff;
}
memcpy(uart2.TxInPtr->start,data,data_len);
uart2.TxCounter += data_len;
uart2.TxInPtr->end = &U2_TxBuff[uart2.TxCounter - 1];
uart2.TxInPtr++;
if(uart2.TxInPtr == uart2.TxEndPtr){
uart2.TxInPtr = &uart2.TxLocation[0];
}
}
void U3_Init(uint32_t bandrate){
uart3.uart.Instance = USART3;
uart3.uart.Init.BaudRate = bandrate;
uart3.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart3.uart.Init.StopBits = UART_STOPBITS_1;
uart3.uart.Init.Parity = UART_PARITY_NONE;
uart3.uart.Init.Mode = UART_MODE_TX_RX;
uart3.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_HalfDuplex_Init(&uart3.uart);
HAL_HalfDuplex_EnableReceiver(&uart3.uart);
U3_PtrInit();
}
void U3_PtrInit(void){
uart3.RxInPtr = &uart3.RxLocation[0];
uart3.RxOutPtr = &uart3.RxLocation[0];
uart3.RxEndPtr = &uart3.RxLocation[9];
uart3.RxCounter = 0;
uart3.RxInPtr->start = U3_RxBuff;
uart3.TxInPtr = &uart3.TxLocation[0];
uart3.TxOutPtr = &uart3.TxLocation[0];
uart3.TxEndPtr = &uart3.TxLocation[9];
uart3.TxCounter = 0;
uart3.TxInPtr->start = U3_TxBuff;
__HAL_UART_ENABLE_IT(&uart3.uart, UART_IT_IDLE);
HAL_UART_Receive_DMA(&uart3.uart,uart3.RxInPtr->start,U3_RX_MAX);
}
void U3_Txdata(uint8_t *data, uint32_t data_len){
if((U3_TX_SIZE - uart3.TxCounter )>=data_len){
uart3.TxInPtr->start = &U3_TxBuff[uart3.TxCounter];
}else{
uart3.TxCounter = 0;
uart3.TxInPtr->start = U3_TxBuff;
}
memcpy(uart3.TxInPtr->start,data,data_len);
uart3.TxCounter += data_len;
uart3.TxInPtr->end = &U3_TxBuff[uart3.TxCounter - 1];
uart3.TxInPtr++;
if(uart3.TxInPtr == uart3.TxEndPtr){
uart3.TxInPtr = &uart3.TxLocation[0];
}
}
void HAL_UART_MspInit(UART_HandleTypeDef *huart){
GPIO_InitTypeDef GPIO_InitType;
if(huart->Instance == USART1){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_9;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART1_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
uart1.dmatx.Instance = DMA1_Channel4;
uart1.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart1.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart1.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart1.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart1.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart1.dmatx.Init.Mode = DMA_NORMAL;
uart1.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart1.dmatx);
HAL_DMA_Init(&uart1.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel4_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
uart1.dmarx.Instance = DMA1_Channel5;
uart1.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart1.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart1.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart1.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart1.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart1.dmarx.Init.Mode = DMA_NORMAL;
uart1.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart1.dmarx);
HAL_DMA_Init(&uart1.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel5_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
}else if(huart->Instance == USART2){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_AF_OD; //OD模式
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART2_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
uart2.dmatx.Instance = DMA1_Channel7;
uart2.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart2.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmatx.Init.Mode = DMA_NORMAL;
uart2.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart2.dmatx);
HAL_DMA_Init(&uart2.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
uart2.dmarx.Instance = DMA1_Channel6;
uart2.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart2.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmarx.Init.Mode = DMA_NORMAL;
uart2.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart2.dmarx);
HAL_DMA_Init(&uart2.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel6_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
}else if(huart->Instance == USART3){
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_OD;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
HAL_NVIC_SetPriority(USART3_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART3_IRQn);
uart3.dmatx.Instance = DMA1_Channel2;
uart3.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart3.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmatx.Init.Mode = DMA_NORMAL;
uart3.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart3.dmatx);
HAL_DMA_Init(&uart3.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
uart3.dmarx.Instance = DMA1_Channel3;
uart3.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart3.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmarx.Init.Mode = DMA_NORMAL;
uart3.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart3.dmarx);
HAL_DMA_Init(&uart3.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}
}
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.TxState = 0;
}else if(huart->Instance == USART2){
uart2.TxState = 0;
}else if(huart->Instance == USART3){
uart3.TxState = 0;
}
}
/ 接收终止回调 /
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.RxInPtr->end = &U1_RxBuff[uart1.RxCounter - 1];
uart1.RxInPtr++;
if(uart1.RxInPtr == uart1.RxEndPtr){
uart1.RxInPtr = &uart1.RxLocation[0];
}
if((U1_RX_SIZE - uart1.RxCounter)<U1_RX_MAX){
uart1.RxCounter = 0;
uart1.RxInPtr->start = U1_RxBuff;
}else{
uart1.RxInPtr->start = &U1_RxBuff[uart1.RxCounter];
}
HAL_UART_Receive_DMA(&uart1.uart,uart1.RxInPtr->start,U1_RX_MAX);
}else if(huart->Instance == USART2){
uart2.RxInPtr->end = &U2_RxBuff[uart2.RxCounter - 1];
uart2.RxInPtr++;
if(uart2.RxInPtr == uart2.RxEndPtr){
uart2.RxInPtr = &uart2.RxLocation[0];
}
if((U2_RX_SIZE - uart2.RxCounter)<U2_RX_MAX){
uart2.RxCounter = 0;
uart2.RxInPtr->start = U2_RxBuff;
}else{
uart2.RxInPtr->start = &U2_RxBuff[uart2.RxCounter];
}
HAL_MultiProcessor_EnterMuteMode(&uart2.uart); //手动进入静默模式
__HAL_UART_ENABLE_IT(&uart2.uart, UART_IT_RXNE); //打开接收中断
HAL_UART_Receive_DMA(&uart2.uart,uart2.RxInPtr->start,U2_RX_MAX);
}else if(huart->Instance == USART3){
uart3.RxInPtr->end = &U3_RxBuff[uart3.RxCounter - 1];
uart3.RxInPtr++;
if(uart3.RxInPtr == uart3.RxEndPtr){
uart3.RxInPtr = &uart3.RxLocation[0];
}
if((U3_RX_SIZE - uart3.RxCounter)<U3_RX_MAX){
uart3.RxCounter = 0;
uart3.RxInPtr->start = U3_RxBuff;
}else{
uart3.RxInPtr->start = &U3_RxBuff[uart3.RxCounter];
}
HAL_UART_Receive_DMA(&uart3.uart,uart3.RxInPtr->start,U3_RX_MAX);
}
}

uart.h

/-----------------------------------------------------/
/ 程序结构 /
/-----------------------------------------------------/
/USER ：包含程序的 main 函数，是整个程序的入 /
/HW ：包含开发板各种功能外设的驱动程序 /
/LIB ：官方提供的 HAL 库文件 /
/CMSIS ：CM3 内核相关的启动文件系统文件 /
/-----------------------------------------------------/
/ /
/ 实现定时器功能的头文件 /
/ /
/-----------------------------------------------------/
#ifndef _TIMER_H
#define _TIMER_H
#include "stdint.h"
#include "stm32f1xx_hal_tim.h"
extern TIM_HandleTypeDef htim4; //外部变量声明
void TIM4_TimerInit(uint16_t, uint16_t); //函数声明
#endif

sw.c

#include "stm32f1xx_hal.h"
#include "sw.h"
#include "uart.h"
uint8_t sw1_sta,sw2_sta; //0:没有按下 1：按下了
void SW_Init(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
GPIO_InitType.Mode = GPIO_MODE_INPUT;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Mode = GPIO_MODE_INPUT;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
}
void SW_InitEvent(void){
GPIO_InitTypeDef GPIO_InitType;
//SW1
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_EVT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
}
void SW_InitEventOut(void){
GPIO_InitTypeDef GPIO_InitType;
//PA3
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_GPIOEx_ConfigEventout(AFIO_EVENTOUT_PORT_A,AFIO_EVENTOUT_PIN_3);
HAL_GPIOEx_EnableEventout();
}
//mode 0：按下执行 1：抬起执行
void SW_Init_IT(uint8_t mode){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
if(mode == 0)
GPIO_InitType.Mode = GPIO_MODE_IT_RISING;
else
GPIO_InitType.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI15_10_IRQn,4,0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
if(mode == 0)
GPIO_InitType.Mode = GPIO_MODE_IT_RISING;
else
GPIO_InitType.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI0_IRQn,3,0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
}
void SW_Init_IT2(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
GPIO_InitType.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI15_10_IRQn,4,0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI0_IRQn,3,0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
}
//返回值 0：无按键触发 8：SW8触发
//mode 0：按下执行 1：抬起执行
uint8_t SW_Scan(uint8_t mode){
uint32_t i;
/-------------SW8------------------/
if((SW1_IN == 1)&&(sw1_sta == 0)){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 0){
return 0;
}
}
sw1_sta = 1;
if(mode == 0){
return 8;
}
}else if((SW1_IN == 0)&&(sw1_sta == 1)){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 1){
return 0;
}
}
sw1_sta = 0;
if(mode == 1){
return 8;
}
}
/-------------SW11------------------/
if((SW2_IN == 0)&&(sw2_sta == 0)){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 1){
return 0;
}
}
sw2_sta = 1;
if(mode == 0){
return 11;
}
}else if((SW2_IN == 1)&&(sw2_sta == 1)){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return 0;
}
}
sw2_sta = 0;
if(mode == 1){
return 11;
}
}
return 0;
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
uint32_t i;
//SW8:PC13 SW11:PA0（抢占优先级高）
switch(GPIO_Pin){
case GPIO_PIN_14: if(SW1_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 0){
return;
}
}
//U1_Txdata((uint8_t *)"x81S1_LED",7);
U2_Txdata((uint8_t *)"LED_ON",6);
//U3_Txdata((uint8_t *)"LED_ON",6);
}else if(SW1_IN == 0){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 1){
return;
}
}
HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_0);
}
break;
case GPIO_PIN_0: if(SW2_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return;
}
}
//U1_Txdata((uint8_t *)"x82S2_LED",7);
U2_Txdata((uint8_t *)"LED_OFF",7);
//U3_Txdata((uint8_t *)"LED_OFF",7);
}else if(SW2_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return;
}
}
HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_0);
}
break;
}
}

sw.h

#ifndef __SW_H
#define __SW_H
#include "stdint.h"
#define SW1_IN HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_14)
#define SW2_IN HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)
void SW_Init(void);
uint8_t SW_Scan(uint8_t mode);
void SW_Init_IT(uint8_t mode);
void SW_Init_IT2(void);
void SW_InitEvent(void);
void SW_InitEventOut(void);
#endif

led.c

#include "stm32f1xx_hal.h"
#include "led.h"
void LED_Init(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_13;
GPIO_InitType.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
}
void LED_ON(void){
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
}
void LED_OFF(void){
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
}
void LED_Toggle(void){
HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_13);
}

led.h

#ifndef __LED_H
#define __LED_H
void LED_Init(void);
void LED_ON(void);
void LED_OFF(void);
void LED_Toggle(void);
#endif

stm32f1xx_it.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
#include "timer.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
uart1.RxCounter += (U1_RX_MAX - __HAL_DMA_GET_COUNTER(&uart1.dmarx));
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
int aaa;
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
//if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
// __HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
// uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx));
// HAL_UART_AbortReceive_IT(&uart2.uart);
//}
aaa++;
}
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx));
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}
void DMA1_Channel4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmatx);
}
void DMA1_Channel5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmarx);
}
void DMA1_Channel7_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmatx);
}
void DMA1_Channel6_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmarx);
}
void DMA1_Channel2_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart3.dmatx);
}
void DMA1_Channel3_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart3.dmarx);
}
//定时器中断处理函数
void TIM4_IRQHandler(void)
{
HAL_TIM_IRQHandler(&htim4);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}

timer.c

/-----------------------------------------------------/
/ 程序结构 /
/-----------------------------------------------------/
/USER ：包含程序的 main 函数，是整个程序的入 /
/HW ：包含开发板各种功能外设的驱动程序 /
/LIB ：官方提供的 HAL 库文件 /
/CMSIS ：CM3 内核相关的启动文件系统文件 /
/-----------------------------------------------------/
/ /
/ 实现定时器功能的源文件 /
/ /
/-----------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "timer.h"
#include "uart.h"
TIM_HandleTypeDef htim4; //定时器4总控制结构体
/-------------------------------------------------/
/函数名：定时器4 定时初始化 /
/参 数：arr：自动重装值 /
/参 数：psc：时钟预分频数 /
/返回值：无 /
/-------------------------------------------------/
void TIM4_TimerInit(uint16_t arr, uint16_t psc)
{
htim4.Instance = TIM4; //设置使用哪个定时器
htim4.Init.Prescaler = psc - 1; //设置预分频器的值
htim4.Init.Period = arr - 1; //设置自动重载值
htim4.Init.CounterMode = TIM_COUNTERMODE_UP; //设置计数模式
htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; //自动重载预装载 禁止
HAL_TIM_Base_Init(&htim4); //配置，如果失败进入if
__HAL_TIM_CLEAR_IT(&htim4, TIM_IT_UPDATE); //清除定时器4的中断标志
__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE); //打开更新中断
}
/-------------------------------------------------/
/函数名：定时器底层驱动，开启时钟，设置中断优先级 /
/参 数：htim：定时器句柄 /
/返回值：无 /
/说 明：此函数会被HAL_TIM_Base_Init()函数调用 /
/-------------------------------------------------/
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance==TIM4){ //判断是哪个定时器
__HAL_RCC_TIM4_CLK_ENABLE(); //使能定时器时钟
HAL_NVIC_SetPriority(TIM4_IRQn,4,0); //设置中断优先级，中断分组在HAL_Init()函数中，被设置为4
HAL_NVIC_EnableIRQ(TIM4_IRQn); //开启定时器中断
}
}
/---------------------------------------------------/
/函数名：定时器中断回调函数 /
/参 数：htim：定时器句柄 /
/返回值：无 /
/说 明：此函数会被HAL_TIM_IRQHandler()中断函数调用 /
/---------------------------------------------------/
//超时回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance==TIM4){ //判断是哪个定时器
__HAL_TIM_DISABLE(htim); //关闭定时器4的计数
__HAL_TIM_SET_COUNTER(htim,0); //清零定时器4计数器
uart2.RxState = 0; //恢复首字节接收标志位
uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx)); //记录剩余未发送
HAL_UART_AbortReceive_IT(&uart2.uart); //终止接收
}
}

stm32f1xx_hal_uart.c

void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
{
uint32_t isrflags = READ_REG(huart->Instance->SR);
uint32_t cr1its = READ_REG(huart->Instance->CR1);
uint32_t cr3its = READ_REG(huart->Instance->CR3);
uint32_t errorflags = 0x00U;
uint32_t dmarequest = 0x00U;
/ If no error occurs /
errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
//删除 RXNE中断
//if (errorflags == RESET)
//{
// / UART in mode Receiver -------------------------------------------------/
// if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
// {
// UART_Receive_IT(huart);
// return;
// }
//}
/ If some errors occur /
if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
{
/ UART parity error interrupt occurred ----------------------------------/
if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_PE;
}
/ UART noise error interrupt occurred -----------------------------------/
if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_NE;
}
/ UART frame error interrupt occurred -----------------------------------/
if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_FE;
}
/ UART Over-Run interrupt occurred --------------------------------------/
if (((isrflags & USART_SR_ORE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_ORE;
}
/ Call UART Error Call back function if need be --------------------------/
if (huart->ErrorCode != HAL_UART_ERROR_NONE)
{
/ UART in mode Receiver -----------------------------------------------/
if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
{
UART_Receive_IT(huart);
}
/* If Overrun error occurs, or if any error occurs in DMA mode reception,
consider error as blocking */
dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
if (((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
{
/* Blocking error : transfer is aborted
Set the UART state ready to be able to start again the process,
Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
UART_EndRxTransfer(huart);
/ Disable the UART DMA Rx request if enabled /
if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
{
CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
/ Abort the UART DMA Rx channel /
if (huart->hdmarx != NULL)
{
/* Set the UART DMA Abort callback :
will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */
huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;
if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
{
/ Call Directly XferAbortCallback function in case of error /
huart->hdmarx->XferAbortCallback(huart->hdmarx);
}
}
else
{
/ Call user error callback /
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
}
}
else
{
/ Call user error callback /
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
}
}
else
{
/* Non Blocking error : transfer could go on.
Error is notified to user through user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
huart->ErrorCode = HAL_UART_ERROR_NONE;
}
}
return;
} / End if some error occurs /
/ UART in mode Transmitter ------------------------------------------------/
//删除 发送缓冲区空的中断
// if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
// {
// UART_Transmit_IT(huart);
// return;
// }
/ UART in mode Transmitter end --------------------------------------------/
if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
{
UART_EndTransmit_IT(huart);
return;
}
/ 写自己的中断回调，现在只能进入我们这个了。 /
#include "uart.h"
#include "timer.h"
else
{
if(uart2.RxState == 0){ / 首字节 /
__HAL_TIM_ENABLE(&htim4); //打开tim4的计数
uart2.RxStat = 1; //标记接收
}else{/ 后续字节 /
__HAL_TIM_SET_COUNTER(&htim4, 0)//清除tim4的计数
}
}
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
int main(void){
HAL_Init();
RccClock_Init();
SW_Init_IT(0);
LED_Init();
U1_Init(9600);
U2_Init(9600);
U3_Init(9600);
while(1){
//串口1收发
if(uart1.RxOutPtr != uart1.RxInPtr){
if(((uart1.RxOutPtr->end - uart1.RxOutPtr->start + 1)==6)&&(memcmp(uart1.RxOutPtr->start,"LED_ON",6) == 0)){
LED_ON();
}else if(((uart1.RxOutPtr->end - uart1.RxOutPtr->start + 1)==7)&&(memcmp(uart1.RxOutPtr->start,"LED_OFF",7) == 0)){
LED_OFF();
}
uart1.RxOutPtr++;
if(uart1.RxOutPtr == uart1.RxEndPtr){
uart1.RxOutPtr = &uart1.RxLocation[0];
}
}
if((uart1.TxOutPtr != uart1.TxInPtr)&&(uart1.TxState==0)){
uart1.TxState = 1;
HAL_UART_Transmit_DMA(&uart1.uart,uart1.TxOutPtr->start,uart1.TxOutPtr->end - uart1.TxOutPtr->start + 1);
uart1.TxOutPtr++;
if(uart1.TxOutPtr == uart1.TxEndPtr){
uart1.TxOutPtr = &uart1.TxLocation[0];
}
}
//串口2收发
if(uart2.RxOutPtr != uart2.RxInPtr){
if(((uart2.RxOutPtr->end - uart2.RxOutPtr->start + 1)==7)&&(memcmp(uart2.RxOutPtr->start,"x81S1_LED",7) == 0)){
LED_Toggle();
}
uart2.RxOutPtr++;
if(uart2.RxOutPtr == uart2.RxEndPtr){
uart2.RxOutPtr = &uart2.RxLocation[0];
}
}
if((uart2.TxOutPtr != uart2.TxInPtr)&&(uart2.TxState==0)){
uart2.TxState = 1;
HAL_UART_Transmit_DMA(&uart2.uart,uart2.TxOutPtr->start,uart2.TxOutPtr->end - uart2.TxOutPtr->start + 1);
uart2.TxOutPtr++;
if(uart2.TxOutPtr == uart2.TxEndPtr){
uart2.TxOutPtr = &uart2.TxLocation[0];
}
}
//串口3收发
if(uart3.RxOutPtr != uart3.RxInPtr){
if(((uart3.RxOutPtr->end - uart3.RxOutPtr->start + 1)==6)&&(memcmp(uart3.RxOutPtr->start,"LED_ON",6) == 0)){
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_RESET);
}else if(((uart3.RxOutPtr->end - uart3.RxOutPtr->start + 1)==7)&&(memcmp(uart3.RxOutPtr->start,"LED_OFF",7) == 0)){
HAL_GPIO_WritePin(GPIOB,GPIO_PIN_0,GPIO_PIN_SET);
}
uart3.RxOutPtr++;
if(uart3.RxOutPtr == uart3.RxEndPtr){
uart3.RxOutPtr = &uart3.RxLocation[0];
}
}
if((uart3.TxOutPtr != uart3.TxInPtr)&&(uart3.TxState==0)){
uart3.TxState = 1;
HAL_HalfDuplex_EnableTransmitter(&uart3.uart);
HAL_UART_Transmit_DMA(&uart3.uart,uart3.TxOutPtr->start,uart3.TxOutPtr->end - uart3.TxOutPtr->start + 1);
uart3.TxOutPtr++;
if(uart3.TxOutPtr == uart3.TxEndPtr){
uart3.TxOutPtr = &uart3.TxLocation[0];
}
}
}
}

6. 从机2程序

uart.c

#include "stm32f1xx_hal.h"
#include "uart.h"
UCB uart1;
UCB uart2;
UCB uart3;
uint8_t U1_RxBuff[U1_RX_SIZE];
uint8_t U1_TxBuff[U1_TX_SIZE];
uint8_t U2_RxBuff[U2_RX_SIZE];
uint8_t U2_TxBuff[U2_TX_SIZE];
uint8_t U3_RxBuff[U3_RX_SIZE];
uint8_t U3_TxBuff[U3_TX_SIZE];
void U1_Init(uint32_t bandrate){
uart1.uart.Instance = USART1;
uart1.uart.Init.BaudRate = bandrate;
uart1.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart1.uart.Init.StopBits = UART_STOPBITS_1;
uart1.uart.Init.Parity = UART_PARITY_NONE;
uart1.uart.Init.Mode = UART_MODE_TX_RX;
uart1.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_UART_Init(&uart1.uart);
U1_PtrInit();
}
void U1_PtrInit(void){
uart1.RxInPtr = &uart1.RxLocation[0];
uart1.RxOutPtr = &uart1.RxLocation[0];
uart1.RxEndPtr = &uart1.RxLocation[9];
uart1.RxCounter = 0;
uart1.RxInPtr->start = U1_RxBuff;
uart1.TxInPtr = &uart1.TxLocation[0];
uart1.TxOutPtr = &uart1.TxLocation[0];
uart1.TxEndPtr = &uart1.TxLocation[9];
uart1.TxCounter = 0;
uart1.TxInPtr->start = U1_TxBuff;
__HAL_UART_ENABLE_IT(&uart1.uart, UART_IT_IDLE);
HAL_UART_Receive_DMA(&uart1.uart,uart1.RxInPtr->start,U1_RX_MAX);
}
void U1_Txdata(uint8_t *data, uint32_t data_len){
if((U1_TX_SIZE - uart1.TxCounter )>=data_len){
uart1.TxInPtr->start = &U1_TxBuff[uart1.TxCounter];
}else{
uart1.TxCounter = 0;
uart1.TxInPtr->start = U1_TxBuff;
}
memcpy(uart1.TxInPtr->start,data,data_len);
uart1.TxCounter += data_len;
uart1.TxInPtr->end = &U1_TxBuff[uart1.TxCounter - 1];
uart1.TxInPtr++;
if(uart1.TxInPtr == uart1.TxEndPtr){
uart1.TxInPtr = &uart1.TxLocation[0];
}
}
void U2_Init(uint32_t bandrate){
uart2.uart.Instance = USART2;
uart2.uart.Init.BaudRate = bandrate;
uart2.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart2.uart.Init.StopBits = UART_STOPBITS_1;
uart2.uart.Init.Parity = UART_PARITY_NONE;
uart2.uart.Init.Mode = UART_MODE_TX_RX;
uart2.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_MultiProcessor_Init(&uart2.uart, 0x01, UART_WAKEUPMETHOD_ADDRESSMARK); //多设备初始化
HAL_MultiProcessor_EnterMuteMode(&uart2.uart); //手动进入静默模式
TIM4_TimerInit(300, 7200); //定时器超时时间30ms
U2_PtrInit();
}
void U2_PtrInit(void){
uart2.RxInPtr = &uart2.RxLocation[0];
uart2.RxOutPtr = &uart2.RxLocation[0];
uart2.RxEndPtr = &uart2.RxLocation[9];
uart2.RxCounter = 0;
uart2.RxInPtr->start = U2_RxBuff;
uart2.TxInPtr = &uart2.TxLocation[0];
uart2.TxOutPtr = &uart2.TxLocation[0];
uart2.TxEndPtr = &uart2.TxLocation[9];
uart2.TxCounter = 0;
uart2.TxInPtr->start = U2_TxBuff;
uart2.RxState = 0; //初始化接受状态为0
__HAL_UART_ENABLE_IT(&uart2.uart, UART_IT_RXNE); //打开接收中断
HAL_UART_Receive_DMA(&uart2.uart,uart2.RxInPtr->start,U2_RX_MAX);
}
void U2_Txdata(uint8_t *data, uint32_t data_len){
if((U2_TX_SIZE - uart2.TxCounter )>=data_len){
uart2.TxInPtr->start = &U2_TxBuff[uart2.TxCounter];
}else{
uart2.TxCounter = 0;
uart2.TxInPtr->start = U2_TxBuff;
}
memcpy(uart2.TxInPtr->start,data,data_len);
uart2.TxCounter += data_len;
uart2.TxInPtr->end = &U2_TxBuff[uart2.TxCounter - 1];
uart2.TxInPtr++;
if(uart2.TxInPtr == uart2.TxEndPtr){
uart2.TxInPtr = &uart2.TxLocation[0];
}
}
void U3_Init(uint32_t bandrate){
uart3.uart.Instance = USART3;
uart3.uart.Init.BaudRate = bandrate;
uart3.uart.Init.WordLength = UART_WORDLENGTH_8B;
uart3.uart.Init.StopBits = UART_STOPBITS_1;
uart3.uart.Init.Parity = UART_PARITY_NONE;
uart3.uart.Init.Mode = UART_MODE_TX_RX;
uart3.uart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
HAL_MultiProcessor_Init(&uart3.uart, 0x02, UART_WAKEUPMETHOD_ADDRESSMARK); //多设备初始化
HAL_MultiProcessor_EnterMuteMode(&uart3.uart); //手动进入静默模式
TIM4_TimerInit(300, 7200); //定时器超时时间30ms
U3_PtrInit();
}
void U3_PtrInit(void){
uart3.RxInPtr = &uart3.RxLocation[0];
uart3.RxOutPtr = &uart3.RxLocation[0];
uart3.RxEndPtr = &uart3.RxLocation[9];
uart3.RxCounter = 0;
uart3.RxInPtr->start = U3_RxBuff;
uart3.TxInPtr = &uart3.TxLocation[0];
uart3.TxOutPtr = &uart3.TxLocation[0];
uart3.TxEndPtr = &uart3.TxLocation[9];
uart3.TxCounter = 0;
uart3.TxInPtr->start = U3_TxBuff;
uart3.RxState = 0; //初始化接受状态为0
__HAL_UART_ENABLE_IT(&uart3.uart, UART_IT_RXNE); //打开接收中断
HAL_UART_Receive_DMA(&uart3.uart,uart3.RxInPtr->start,U3_RX_MAX);
}
void U3_Txdata(uint8_t *data, uint32_t data_len){
if((U3_TX_SIZE - uart3.TxCounter )>=data_len){
uart3.TxInPtr->start = &U3_TxBuff[uart3.TxCounter];
}else{
uart3.TxCounter = 0;
uart3.TxInPtr->start = U3_TxBuff;
}
memcpy(uart3.TxInPtr->start,data,data_len);
uart3.TxCounter += data_len;
uart3.TxInPtr->end = &U3_TxBuff[uart3.TxCounter - 1];
uart3.TxInPtr++;
if(uart3.TxInPtr == uart3.TxEndPtr){
uart3.TxInPtr = &uart3.TxLocation[0];
}
}
void HAL_UART_MspInit(UART_HandleTypeDef *huart){
GPIO_InitTypeDef GPIO_InitType;
if(huart->Instance == USART1){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART1_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_9;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART1_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART1_IRQn);
uart1.dmatx.Instance = DMA1_Channel4;
uart1.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart1.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart1.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart1.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart1.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart1.dmatx.Init.Mode = DMA_NORMAL;
uart1.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart1.dmatx);
HAL_DMA_Init(&uart1.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel4_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
uart1.dmarx.Instance = DMA1_Channel5;
uart1.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart1.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart1.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart1.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart1.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart1.dmarx.Init.Mode = DMA_NORMAL;
uart1.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart1.dmarx);
HAL_DMA_Init(&uart1.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel5_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
}else if(huart->Instance == USART2){
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_USART2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_AF_OD; //OD模式
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(USART2_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART2_IRQn);
uart2.dmatx.Instance = DMA1_Channel7;
uart2.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart2.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmatx.Init.Mode = DMA_NORMAL;
uart2.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart2.dmatx);
HAL_DMA_Init(&uart2.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
uart2.dmarx.Instance = DMA1_Channel6;
uart2.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart2.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart2.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart2.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart2.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart2.dmarx.Init.Mode = DMA_NORMAL;
uart2.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart2.dmarx);
HAL_DMA_Init(&uart2.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel6_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel6_IRQn);
}else if(huart->Instance == USART3){
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_USART3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_10;
GPIO_InitType.Mode = GPIO_MODE_AF_OD; //OD模式
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
GPIO_InitType.Pin = GPIO_PIN_11;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
HAL_NVIC_SetPriority(USART3_IRQn,3,0);
HAL_NVIC_EnableIRQ(USART3_IRQn);
uart3.dmatx.Instance = DMA1_Channel2;
uart3.dmatx.Init.Direction = DMA_MEMORY_TO_PERIPH;
uart3.dmatx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmatx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmatx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmatx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmatx.Init.Mode = DMA_NORMAL;
uart3.dmatx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmatx, uart3.dmatx);
HAL_DMA_Init(&uart3.dmatx);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
uart3.dmarx.Instance = DMA1_Channel3;
uart3.dmarx.Init.Direction = DMA_PERIPH_TO_MEMORY;
uart3.dmarx.Init.PeriphInc = DMA_PINC_DISABLE;
uart3.dmarx.Init.MemInc = DMA_MINC_ENABLE;
uart3.dmarx.Init.PeriphDataAlignment = DMA_PDATAALIGN_BYTE;
uart3.dmarx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
uart3.dmarx.Init.Mode = DMA_NORMAL;
uart3.dmarx.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(huart, hdmarx, uart3.dmarx);
HAL_DMA_Init(&uart3.dmarx);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn,3,0);
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}
}
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}
}
void HAL_UART_ErrorCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
}
}
void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.TxState = 0;
}else if(huart->Instance == USART2){
uart2.TxState = 0;
}else if(huart->Instance == USART3){
uart3.TxState = 0;
}
}
/ 接收终止回调 /
void HAL_UART_AbortReceiveCpltCallback(UART_HandleTypeDef *huart)
{
if(huart->Instance == USART1){
uart1.RxInPtr->end = &U1_RxBuff[uart1.RxCounter - 1];
uart1.RxInPtr++;
if(uart1.RxInPtr == uart1.RxEndPtr){
uart1.RxInPtr = &uart1.RxLocation[0];
}
if((U1_RX_SIZE - uart1.RxCounter)<U1_RX_MAX){
uart1.RxCounter = 0;
uart1.RxInPtr->start = U1_RxBuff;
}else{
uart1.RxInPtr->start = &U1_RxBuff[uart1.RxCounter];
}
HAL_UART_Receive_DMA(&uart1.uart,uart1.RxInPtr->start,U1_RX_MAX);
}else if(huart->Instance == USART2){
uart2.RxInPtr->end = &U2_RxBuff[uart2.RxCounter - 1];
uart2.RxInPtr++;
if(uart2.RxInPtr == uart2.RxEndPtr){
uart2.RxInPtr = &uart2.RxLocation[0];
}
if((U2_RX_SIZE - uart2.RxCounter)<U2_RX_MAX){
uart2.RxCounter = 0;
uart2.RxInPtr->start = U2_RxBuff;
}else{
uart2.RxInPtr->start = &U2_RxBuff[uart2.RxCounter];
}
HAL_MultiProcessor_EnterMuteMode(&uart2.uart); //手动进入静默模式
__HAL_UART_ENABLE_IT(&uart2.uart, UART_IT_RXNE); //打开接收中断
HAL_UART_Receive_DMA(&uart2.uart,uart2.RxInPtr->start,U2_RX_MAX);
}else if(huart->Instance == USART3){
uart3.RxInPtr->end = &U3_RxBuff[uart3.RxCounter - 1];
uart3.RxInPtr++;
if(uart3.RxInPtr == uart3.RxEndPtr){
uart3.RxInPtr = &uart3.RxLocation[0];
}
if((U3_RX_SIZE - uart3.RxCounter)<U3_RX_MAX){
uart3.RxCounter = 0;
uart3.RxInPtr->start = U3_RxBuff;
}else{
uart3.RxInPtr->start = &U3_RxBuff[uart3.RxCounter];
}
HAL_MultiProcessor_EnterMuteMode(&uart3.uart); //手动进入静默模式
__HAL_UART_ENABLE_IT(&uart3.uart, UART_IT_RXNE); //打开接收中断
HAL_UART_Receive_DMA(&uart3.uart,uart3.RxInPtr->start,U3_RX_MAX);
}
}

uart.h

/-----------------------------------------------------/
/ 程序结构 /
/-----------------------------------------------------/
/USER ：包含程序的 main 函数，是整个程序的入 /
/HW ：包含开发板各种功能外设的驱动程序 /
/LIB ：官方提供的 HAL 库文件 /
/CMSIS ：CM3 内核相关的启动文件系统文件 /
/-----------------------------------------------------/
/ /
/ 实现定时器功能的头文件 /
/ /
/-----------------------------------------------------/
#ifndef _TIMER_H
#define _TIMER_H
#include "stdint.h"
#include "stm32f1xx_hal_tim.h"
extern TIM_HandleTypeDef htim4; //外部变量声明
void TIM4_TimerInit(uint16_t, uint16_t); //函数声明
#endif

sw.c

#include "stm32f1xx_hal.h"
#include "sw.h"
#include "uart.h"
uint8_t sw1_sta,sw2_sta; //0:没有按下 1：按下了
void SW_Init(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
GPIO_InitType.Mode = GPIO_MODE_INPUT;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Mode = GPIO_MODE_INPUT;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
}
void SW_InitEvent(void){
GPIO_InitTypeDef GPIO_InitType;
//SW1
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_2;
GPIO_InitType.Mode = GPIO_MODE_EVT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
}
void SW_InitEventOut(void){
GPIO_InitTypeDef GPIO_InitType;
//PA3
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_3;
GPIO_InitType.Mode = GPIO_MODE_AF_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_HIGH;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_GPIOEx_ConfigEventout(AFIO_EVENTOUT_PORT_A,AFIO_EVENTOUT_PIN_3);
HAL_GPIOEx_EnableEventout();
}
//mode 0：按下执行 1：抬起执行
void SW_Init_IT(uint8_t mode){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
if(mode == 0)
GPIO_InitType.Mode = GPIO_MODE_IT_RISING;
else
GPIO_InitType.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI15_10_IRQn,4,0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
if(mode == 0)
GPIO_InitType.Mode = GPIO_MODE_IT_RISING;
else
GPIO_InitType.Mode = GPIO_MODE_IT_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI0_IRQn,3,0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
}
void SW_Init_IT2(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_14;
GPIO_InitType.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLDOWN;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI15_10_IRQn,4,0);
HAL_NVIC_EnableIRQ(EXTI15_10_IRQn);
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Mode = GPIO_MODE_IT_RISING_FALLING;
GPIO_InitType.Pull = GPIO_PULLUP;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(EXTI0_IRQn,3,0);
HAL_NVIC_EnableIRQ(EXTI0_IRQn);
}
//返回值 0：无按键触发 8：SW8触发
//mode 0：按下执行 1：抬起执行
uint8_t SW_Scan(uint8_t mode){
uint32_t i;
/-------------SW8------------------/
if((SW1_IN == 1)&&(sw1_sta == 0)){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 0){
return 0;
}
}
sw1_sta = 1;
if(mode == 0){
return 8;
}
}else if((SW1_IN == 0)&&(sw1_sta == 1)){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 1){
return 0;
}
}
sw1_sta = 0;
if(mode == 1){
return 8;
}
}
/-------------SW11------------------/
if((SW2_IN == 0)&&(sw2_sta == 0)){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 1){
return 0;
}
}
sw2_sta = 1;
if(mode == 0){
return 11;
}
}else if((SW2_IN == 1)&&(sw2_sta == 1)){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return 0;
}
}
sw2_sta = 0;
if(mode == 1){
return 11;
}
}
return 0;
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
uint32_t i;
//SW8:PC13 SW11:PA0（抢占优先级高）
switch(GPIO_Pin){
case GPIO_PIN_14: if(SW1_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 0){
return;
}
}
//U1_Txdata((uint8_t *)"x81S1_LED",7);
//U2_Txdata((uint8_t *)"LED_ON",6);
U3_Txdata((uint8_t *)"LED_ON",6);
}else if(SW1_IN == 0){
for(i=0;i<0x7FFF;i++){
if(SW1_IN == 1){
return;
}
}
HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_0);
}
break;
case GPIO_PIN_0: if(SW2_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return;
}
}
//U1_Txdata((uint8_t *)"x82S2_LED",7);
//U2_Txdata((uint8_t *)"LED_OFF",7);
U3_Txdata((uint8_t *)"LED_OFF",7);
}else if(SW2_IN == 1){
for(i=0;i<0x7FFF;i++){
if(SW2_IN == 0){
return;
}
}
HAL_GPIO_TogglePin(GPIOB,GPIO_PIN_0);
}
break;
}
}

sw.h

#ifndef __SW_H
#define __SW_H
#include "stdint.h"
#define SW1_IN HAL_GPIO_ReadPin(GPIOC,GPIO_PIN_14)
#define SW2_IN HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0)
void SW_Init(void);
uint8_t SW_Scan(uint8_t mode);
void SW_Init_IT(uint8_t mode);
void SW_Init_IT2(void);
void SW_InitEvent(void);
void SW_InitEventOut(void);
#endif

led.c

#include "stm32f1xx_hal.h"
#include "led.h"
void LED_Init(void){
GPIO_InitTypeDef GPIO_InitType;
__HAL_RCC_GPIOC_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_13;
GPIO_InitType.Mode = GPIO_MODE_OUTPUT_PP;
GPIO_InitType.Speed = GPIO_SPEED_FREQ_LOW;
HAL_GPIO_Init(GPIOC,&GPIO_InitType);
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
}
void LED_ON(void){
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
}
void LED_OFF(void){
HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_RESET);
}
void LED_Toggle(void){
HAL_GPIO_TogglePin(GPIOC,GPIO_PIN_13);
}

led.h

#ifndef __LED_H
#define __LED_H
void LED_Init(void);
void LED_ON(void);
void LED_OFF(void);
void LED_Toggle(void);
#endif

stm32f1xx_it.c

/-------------------------------------------------/
/ 超子说物联网STM32系列开发板 /
/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
#include "timer.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
uart1.RxCounter += (U1_RX_MAX - __HAL_DMA_GET_COUNTER(&uart1.dmarx));
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
//if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
// __HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
// uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx));
// HAL_UART_AbortReceive_IT(&uart2.uart);
//}
}
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
//if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
// __HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
// uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx));
// HAL_UART_AbortReceive_IT(&uart3.uart);
//}
}
void DMA1_Channel4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmatx);
}
void DMA1_Channel5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmarx);
}
void DMA1_Channel7_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmatx);
}
void DMA1_Channel6_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmarx);
}
void DMA1_Channel2_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart3.dmatx);
}
void DMA1_Channel3_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart3.dmarx);
}
//定时器中断处理函数
void TIM4_IRQHandler(void)
{
HAL_TIM_IRQHandler(&htim4);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}

timer.c

/-----------------------------------------------------/
/ 程序结构 /
/-----------------------------------------------------/
/USER ：包含程序的 main 函数，是整个程序的入 /
/HW ：包含开发板各种功能外设的驱动程序 /
/LIB ：官方提供的 HAL 库文件 /
/CMSIS ：CM3 内核相关的启动文件系统文件 /
/-----------------------------------------------------/
/ /
/ 实现定时器功能的源文件 /
/ /
/-----------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "timer.h"
#include "uart.h"
TIM_HandleTypeDef htim4; //定时器4总控制结构体
/-------------------------------------------------/
/函数名：定时器4 定时初始化 /
/参 数：arr：自动重装值 /
/参 数：psc：时钟预分频数 /
/返回值：无 /
/-------------------------------------------------/
void TIM4_TimerInit(uint16_t arr, uint16_t psc)
{
htim4.Instance = TIM4; //设置使用哪个定时器
htim4.Init.Prescaler = psc - 1; //设置预分频器的值
htim4.Init.Period = arr - 1; //设置自动重载值
htim4.Init.CounterMode = TIM_COUNTERMODE_UP; //设置计数模式
htim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE; //自动重载预装载 禁止
HAL_TIM_Base_Init(&htim4); //配置，如果失败进入if
__HAL_TIM_CLEAR_IT(&htim4, TIM_IT_UPDATE); //清除定时器4的中断标志
__HAL_TIM_ENABLE_IT(&htim4, TIM_IT_UPDATE); //打开更新中断
}
/-------------------------------------------------/
/函数名：定时器底层驱动，开启时钟，设置中断优先级 /
/参 数：htim：定时器句柄 /
/返回值：无 /
/说 明：此函数会被HAL_TIM_Base_Init()函数调用 /
/-------------------------------------------------/
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance==TIM4){ //判断是哪个定时器
__HAL_RCC_TIM4_CLK_ENABLE(); //使能定时器时钟
HAL_NVIC_SetPriority(TIM4_IRQn,4,0); //设置中断优先级，中断分组在HAL_Init()函数中，被设置为4
HAL_NVIC_EnableIRQ(TIM4_IRQn); //开启定时器中断
}
}
/---------------------------------------------------/
/函数名：定时器中断回调函数 /
/参 数：htim：定时器句柄 /
/返回值：无 /
/说 明：此函数会被HAL_TIM_IRQHandler()中断函数调用 /
/---------------------------------------------------/
//超时回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance==TIM4){ //判断是哪个定时器
__HAL_TIM_DISABLE(htim); //关闭定时器4的计数
__HAL_TIM_SET_COUNTER(htim,0); //清零定时器4计数器
uart3.RxState = 0; //恢复首字节接收标志位
uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx)); //记录剩余未发送
HAL_UART_AbortReceive_IT(&uart3.uart); //终止接收
}
}

stm32f1xx_hal_uart.c

void HAL_UART_IRQHandler(UART_HandleTypeDef *huart)
{
uint32_t isrflags = READ_REG(huart->Instance->SR);
uint32_t cr1its = READ_REG(huart->Instance->CR1);
uint32_t cr3its = READ_REG(huart->Instance->CR3);
uint32_t errorflags = 0x00U;
uint32_t dmarequest = 0x00U;
/ If no error occurs /
errorflags = (isrflags & (uint32_t)(USART_SR_PE | USART_SR_FE | USART_SR_ORE | USART_SR_NE));
//删除 RXNE中断
//if (errorflags == RESET)
//{
// / UART in mode Receiver -------------------------------------------------/
// if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
// {
// UART_Receive_IT(huart);
// return;
// }
//}
/ If some errors occur /
if ((errorflags != RESET) && (((cr3its & USART_CR3_EIE) != RESET) || ((cr1its & (USART_CR1_RXNEIE | USART_CR1_PEIE)) != RESET)))
{
/ UART parity error interrupt occurred ----------------------------------/
if (((isrflags & USART_SR_PE) != RESET) && ((cr1its & USART_CR1_PEIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_PE;
}
/ UART noise error interrupt occurred -----------------------------------/
if (((isrflags & USART_SR_NE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_NE;
}
/ UART frame error interrupt occurred -----------------------------------/
if (((isrflags & USART_SR_FE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_FE;
}
/ UART Over-Run interrupt occurred --------------------------------------/
if (((isrflags & USART_SR_ORE) != RESET) && ((cr3its & USART_CR3_EIE) != RESET))
{
huart->ErrorCode |= HAL_UART_ERROR_ORE;
}
/ Call UART Error Call back function if need be --------------------------/
if (huart->ErrorCode != HAL_UART_ERROR_NONE)
{
/ UART in mode Receiver -----------------------------------------------/
if (((isrflags & USART_SR_RXNE) != RESET) && ((cr1its & USART_CR1_RXNEIE) != RESET))
{
UART_Receive_IT(huart);
}
/* If Overrun error occurs, or if any error occurs in DMA mode reception,
consider error as blocking */
dmarequest = HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR);
if (((huart->ErrorCode & HAL_UART_ERROR_ORE) != RESET) || dmarequest)
{
/* Blocking error : transfer is aborted
Set the UART state ready to be able to start again the process,
Disable Rx Interrupts, and disable Rx DMA request, if ongoing */
UART_EndRxTransfer(huart);
/ Disable the UART DMA Rx request if enabled /
if (HAL_IS_BIT_SET(huart->Instance->CR3, USART_CR3_DMAR))
{
CLEAR_BIT(huart->Instance->CR3, USART_CR3_DMAR);
/ Abort the UART DMA Rx channel /
if (huart->hdmarx != NULL)
{
/* Set the UART DMA Abort callback :
will lead to call HAL_UART_ErrorCallback() at end of DMA abort procedure */
huart->hdmarx->XferAbortCallback = UART_DMAAbortOnError;
if (HAL_DMA_Abort_IT(huart->hdmarx) != HAL_OK)
{
/ Call Directly XferAbortCallback function in case of error /
huart->hdmarx->XferAbortCallback(huart->hdmarx);
}
}
else
{
/ Call user error callback /
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
}
}
else
{
/ Call user error callback /
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
}
}
else
{
/* Non Blocking error : transfer could go on.
Error is notified to user through user error callback */
#if (USE_HAL_UART_REGISTER_CALLBACKS == 1)
/Call registered error callback/
huart->ErrorCallback(huart);
#else
/Call legacy weak error callback/
HAL_UART_ErrorCallback(huart);
#endif / USE_HAL_UART_REGISTER_CALLBACKS /
huart->ErrorCode = HAL_UART_ERROR_NONE;
}
}
return;
} / End if some error occurs /
/ UART in mode Transmitter ------------------------------------------------/
//删除 发送缓冲区空的中断
// if (((isrflags & USART_SR_TXE) != RESET) && ((cr1its & USART_CR1_TXEIE) != RESET))
// {
// UART_Transmit_IT(huart);
// return;
// }
/ UART in mode Transmitter end --------------------------------------------/
if (((isrflags & USART_SR_TC) != RESET) && ((cr1its & USART_CR1_TCIE) != RESET))
{
UART_EndTransmit_IT(huart);
return;
}
/ 写自己的中断回调，现在只能进入我们这个了。 /
#include "uart.h"
#include "timer.h"
else
{
if(uart3.RxState == 0){ / 首字节 /
__HAL_TIM_ENABLE(&htim4); //打开tim4的计数
uart3.RxStat = 1; //标记接收
}else{/ 后续字节 /
__HAL_TIM_SET_COUNTER(&htim4, 0)//清除tim4的计数
}
}
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
int main(void){
HAL_Init();
RccClock_Init();
SW_Init_IT(0);
LED_Init();
U1_Init(921600);
U2_Init(921600);
U3_Init(921600);
while(1){
//串口1收发
if(uart1.RxOutPtr != uart1.RxInPtr){
if(((uart1.RxOutPtr->end - uart1.RxOutPtr->start + 1)==6)&&(memcmp(uart1.RxOutPtr->start,"LED_ON",6) == 0)){
LED_ON();
}else if(((uart1.RxOutPtr->end - uart1.RxOutPtr->start + 1)==7)&&(memcmp(uart1.RxOutPtr->start,"LED_OFF",7) == 0)){
LED_OFF();
}
uart1.RxOutPtr++;
if(uart1.RxOutPtr == uart1.RxEndPtr){
uart1.RxOutPtr = &uart1.RxLocation[0];
}
}
if((uart1.TxOutPtr != uart1.TxInPtr)&&(uart1.TxState==0)){
uart1.TxState = 1;
HAL_UART_Transmit_DMA(&uart1.uart,uart1.TxOutPtr->start,uart1.TxOutPtr->end - uart1.TxOutPtr->start + 1);
uart1.TxOutPtr++;
if(uart1.TxOutPtr == uart1.TxEndPtr){
uart1.TxOutPtr = &uart1.TxLocation[0];
}
}
//串口2收发
if(uart2.RxOutPtr != uart2.RxInPtr){
if(((uart2.RxOutPtr->end - uart2.RxOutPtr->start + 1)==7)&&(memcmp(uart2.RxOutPtr->start,"x81S1_LED",7) == 0)){
LED_Toggle();
}
uart2.RxOutPtr++;
if(uart2.RxOutPtr == uart2.RxEndPtr){
uart2.RxOutPtr = &uart2.RxLocation[0];
}
}
if((uart2.TxOutPtr != uart2.TxInPtr)&&(uart2.TxState==0)){
uart2.TxState = 1;
HAL_UART_Transmit_DMA(&uart2.uart,uart2.TxOutPtr->start,uart2.TxOutPtr->end - uart2.TxOutPtr->start + 1);
uart2.TxOutPtr++;
if(uart2.TxOutPtr == uart2.TxEndPtr){
uart2.TxOutPtr = &uart2.TxLocation[0];
}
}
//串口3收发
if(uart3.RxOutPtr != uart3.RxInPtr){
if(((uart3.RxOutPtr->end - uart3.RxOutPtr->start + 1)==7)&&(memcmp(uart3.RxOutPtr->start,"x82S2_LED",7) == 0)){
LED_Toggle();
}
uart3.RxOutPtr++;
if(uart3.RxOutPtr == uart3.RxEndPtr){
uart3.RxOutPtr = &uart3.RxLocation[0];
}
}
if((uart3.TxOutPtr != uart3.TxInPtr)&&(uart3.TxState==0)){
uart3.TxState = 1;
HAL_UART_Transmit_DMA(&uart3.uart,uart3.TxOutPtr->start,uart3.TxOutPtr->end - uart3.TxOutPtr->start + 1);
uart3.TxOutPtr++;
if(uart3.TxOutPtr == uart3.TxEndPtr){
uart3.TxOutPtr = &uart3.TxLocation[0];
}
}
}
}

十二、HAL库：多主机通信 空闲检测唤醒 定时器超时 DMA不定长接收

1. 空闲总线检测

空闲唤醒没有硬件从机地址，需要自己在程序中加入从机地址，并进行管理
RWU被写入1时，USART进入静默模式。当检测到 一空闲帧时，它被唤醒。然后RWU被硬件清零，
 
所以，在空闲总线唤醒模式下HAL_MultiProcessor_Init 多设备初始化的第二个参数（从机地址）时无效的

2. 思路：

因为空闲总线检测没有从机没有硬件地址，那么思路可以为下：
  1. 从机默认为正常模式，如果地址匹配，那么继续执行后续操作。
  1. 如果地址未匹配，那么在应用程序中，调用子函数，将这个从机的RWU变为高电平。静默模式。不对后续的数据进行接收
  1. 当这一段数据接收完毕，空闲帧出现时，就会重新把从机的RWU拉低为低电平。变为正常模式
  1. 总结理解：大部分时间为正常模式，当判断地址之后，如果不是自己的地址就进入静默模式，不接收。当这一段数据完毕之后，空闲帧出现，硬件自动拉低RWU。变会正常模式

3. 程序

相较上一节：”HAL库：多主机通信 地址检测唤醒 定时器超时 DMA不定长接收“
主机部分：
  • 仅改变了发送数据，由 0x81 变为0x01 .因为此时不是地址检测唤醒，不需要告诉从机这段字节为地址（bit7 为 1）
从机部分：
  • 修改主程序判断接收数据的地址由0x81-> 0x01
  • 仅在初始化时，改变了下HAL_MultiProcessor_Init 的第三个参数（唤醒方式）为UART_WAKEUPMETHOD_IDLELINE （第二个参数为无效参数） 初始化时和接收完成后不需要进入静默模式，（因为空闲帧会立刻把RWU置位为0，进入正常模式）
  • 在stm32f1xx_hal_uart.c中，添加判断地址并进入或不进入静默模式的程序。
/ 写自己的中断回调，现在只能进入我们这个了。 /
if(uart2.RxState == 0){ / 首字节 /
__HAL_TIM_ENABLE(&htim4); //打开tim4的计数
uart2.RxState = 1; //标记接收
/ 判断地址 /
if(*uart2.RxInPtr->start != 0x01){//判断第一个字节是不是自己的地址
HAL_MultiProcessor_EnterMuteMode(&uart1.uart); //进入静默模式
}
}else{/ 后续字节 /
__HAL_TIM_SET_COUNTER(&htim4, 0);//清除tim4的计数
}
 

十三、串口1 2 3 Printf 格式化输出

void U3_Printf(char* format, ...){
uint8_t tempbuff[256];
va_list ap;
va_start(ap, format);
vsprintf((char*)tempbuff, format, ap);
va_end(ap);
uint16_t i;
for(i = 0; i < strlen((char*)tempbuff); i++){
while(!__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_TXE)); //发送寄存器空，才开始发送
uart3.uart.Instance->DR = tempbuff[i]; //把数据依次放入DR 寄存器，发送出去
}
while(!__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_TC)); //发送完成，退出printf
}
代码解析：
  1. 这个函数有一个参数format，它是一个指向字符的指针，代表格式化字符串 在 C 语言中，函数参数中的 “...” 表示可变参数列表，也称为可变参数。
  1. 首先定义了一个大小为 256 的无符号 8 位整数数组 tempbuff，用于存储格式化后的字符串。
  1. 使用可变参数列表的机制。
      • va_list ap; 定义一个可变参数列表指针。
      • va_start(ap, format); 初始化可变参数列表指针，使其指向第一个可变参数，这里 format 是格式化字符串，后面的参数可以是任意类型和数量。
      • vsprintf((char*)tempbuff, format, ap); 使用可变参数列表将格式化后的字符串存储到 tempbuff 数组中。
      • va_end(ap); 标记可变参数列表结束。
  1. 然后通过一个循环逐个字符地将 tempbuff 中的内容发送到 UART3。
      • 在循环中，使用 while(!__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_TXE)); 等待发送寄存器为空，即可以发送下一个字符。
      • 当发送寄存器为空时，将 tempbuff 中的字符逐个放入 UART3 的数据寄存器 uart3.uart.Instance->DR 进行发送。
  1. 最后，使用 while(!__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_TC)); 等待发送完成标志位，确保所有数据都已发送完毕后退出函数。

十四、通信双方，参数不匹配时会出现哪些错误

这里用到了错误回调函数HAL_UART_ErrorCallback
我们利用两个实验板，测试通信参数不匹配时，产生哪些错误
利用串口2 相互通信
利用串口1 printf输出提示信息
  • 波特率不匹配：噪声错误，不是每次每次都会发生，会伴随无效数据
  • 数据字长不匹配时：一个8位 一个9位 帧错误
  • 校验不匹配时：PE 校验错误
一旦错误产生，会终止当前的数据传输。

定时器[外部模式]篇

一、资源介绍：STM32F103C8T6定时器资源介绍

高级定时器（TIM1）

  • 时基单元包含：
    • 计数器寄存器（TIMx_CNT）
    • 预分频器寄存器（TIMx_PSC）
    • 自动装载寄存器（TIMx_ARR）
    • 重复次数寄存器（TIMx_RCR）

通用定时器（TIM2、TIM3、TIM4）

  • 时基单元包含：
    • 计数器寄存器（TIMx_CNT）
    • 预分频器寄存器（TIMx_PSC）
    • 自动装载寄存器（TIMx_ARR）

定时器1 外部通道：

  • 通道 1：PA8，DMA1_Channel2
  • 通道 2：PA9，DMA1_Channel3
  • 通道 ETR：PA12

定时器2 外部通道：

  • 通道 1：PA0（重映射 PA15），DMA1_Channel5（如果重映射，需要内部上拉）
  • 通道 2：PA1（重映射 PB3），DMA1_Channel7
  • 通道 ETR：PA0（重映射 PA15）

定时器3 外部通道：

  • 通道 1：PA6（重映射 PB4），DMA1_Channel6（如果重映射，需要内部上拉）
  • 通道 2：PA7（重映射 PB5）
  • 通道 ETR：无

定时器4 外部通道：

  • 通道 1：PB6，DMA1_Channel1
  • 通道 2：PB7，DMA1_Channel4
  • 通道 ETR：无

来自江协的定时器基本结构图

notion image

二、HAL库：TIM1 外部时钟模式1 轮询方式 按键计数

1. 功能说明

  • 按下按键，定时器计数

2. 注意事项*

  1. 引脚冲突问题
      2. 外部时钟模式1，定时器1：
      通道1 PA8 DMA1_Channel2
      通道2 PA9 DMA1_Channel3
      而串口1的Tx也为PA9
      所以要善用重映射功能（会重映射到PB6），避免引脚冲突
      并且在切换不同的通道的时候，注意GPIO口的初始化与上下拉配置
  1. ED双边沿检测，不过滤波器
  1. 外部时钟模式1 通往TRGI， TRGI会产生一个触发事件 会置位TIF为1，也就是HAL库的TIM_FLAG_TRIGGER标志位会置1，我们可以通过判断标志位来进行判断单次的触发事件。
      2. notion image
      notion image
notion image
notion image
  1. 通道1 、2 上的滤波器解释
      2. notion image

3. 相关函数

  • 重映射串口1
    • __HAL_RCC_AFIO_CLK_ENABLE();
    • __HAL_AFIO_REMAP_USART1_ENABLE();
  • TIM_ClockConfigTypeDef 时钟配置总控结构体
  • 基础的定时器配置初始化（定时器1通道 2举例）
  • 初始化硬件配置回调函数
 

4. 程序

time.c

__HAL_TIM_ENABLE_IT(&tim4, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim4, (uint32_t*)tim4_dmaBuff, 4);
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE(); //使能时钟
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitType;
GPIO_InitType.Pin = GPIO_PIN_9;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //上拉
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
//
// HAL_NVIC_SetPriority(TIM1_UP_IRQn, 3, 0); //配置、打开 更新中断
// HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
//
// / DMA配置 /
// tim1_dmaup.Instance = DMA1_Channel5;
// tim1_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
// tim1_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
// tim1_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
// tim1_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
// tim1_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim1_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim1_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim1, hdma[TIM_DMA_ID_UPDATE], tim1_dmaup);
// HAL_DMA_Init(&tim1_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
//
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM2_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
/ DMA配置 /
tim2_dmaup.Instance = DMA1_Channel2;
tim2_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim2_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim2_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim2_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim2_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim2_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim2, hdma[TIM_DMA_ID_UPDATE], tim2_dmaup);
HAL_DMA_Init(&tim2_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM3_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
/ DMA配置 /
tim3_dmaup.Instance = DMA1_Channel3;
tim3_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim3_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim3_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim3_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim3_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim3_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim3_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim3, hdma[TIM_DMA_ID_UPDATE], tim3_dmaup);
HAL_DMA_Init(&tim3_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM4_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
/ DMA配置 /
tim4_dmaup.Instance = DMA1_Channel7;
tim4_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim4_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim4_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim4_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim4_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim4_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim4_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim4, hdma[TIM_DMA_ID_UPDATE], tim4_dmaup);
HAL_DMA_Init(&tim4_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
}
}
//定时器 硬件 De 回调函数
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_DISABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_DISABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_DISABLE();
}
}
//更新中断 回调函数(同时也是DMA完成的回调函数)
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
/ 判断TIM是否为Ready状态，如果是 则是DMA完成中断进入的回调函数 /
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA1 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 1 定时时间:%drn",time1++);
}
}else if(htim->Instance == TIM2){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA2 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 2 定时时间:%drn",time2++);
}
}else if(htim->Instance == TIM3){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA3 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 3 定时时间:%drn",time3++);
}
}else if(htim->Instance == TIM4){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA4 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 4 定时时间:%drn",time4++);
}
}
}
//DMA 半完成回调函数
void HAL_TIM_PeriodElapsedHalfCpltCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}
}

time.h

#ifndef __TIME_H
#define __TIME_H
#include "uart.h"
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
extern DMA_HandleTypeDef tim1_dmaup;
extern DMA_HandleTypeDef tim2_dmaup;
extern DMA_HandleTypeDef tim3_dmaup;
extern DMA_HandleTypeDef tim4_dmaup;
/ 初始化函数 /
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep);
void Timer2_Init(uint16_t arr, uint16_t psc);
void Timer3_Init(uint16_t arr, uint16_t psc);
void Timer4_Init(uint16_t arr, uint16_t psc);
#endif

main.c

while(1){
/ 获取更新标志位 /
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); ///清除标志位
U1_Printf("定时器 1 更新事件rn");
}
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_TRIGGER)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_TRIGGER); ///清除标志位
U1_Printf("定时器 1 触发事件:%drn", __HAL_TIM_GET_COUNTER(&tim1)); //输出当前计数值
}
}

三、HAL库：TIM1 外部模式1 ETR通道 轮询方式 按键计数

1. 注意事项*

  1. ETR的通道有专门的预分频器，需要按需配置预分频器TIM_CLOCKPRESCALER_DIV1/2/4/8
      2. notion image
  1. 特别注意：当设置ETR的预分频器为2、4、8分频时，如果ETR的有效电平（取决于是否ETR反向）与IO的引脚默认电平不匹配，那么复位后首次按下会直接产生一次触发事件，后续正常。
      • 解决办法：匹配IO与ETR的有效电平 （例如IO下拉，ETR有效电平为低电平，也就是ETR反转。那么就能匹配默认电平与ETR，就不会出现上述错误）
  1. 特别注意：如果通道的 分频因子 加大（同时加大分频因子），会使得检测变慢，也就是频率和带宽就变低了，变得更严格。会导致复位之后立刻产生一次触发事件。
      • 解决办法：在启动定时器之前，
          • 先进行一段时间的延时操作，再清除TIm的Counter和TRIG触发事件标志位
          这样就能保证在启动时不会有任何触发事件产生（添加延时的原因是因为程序运行太快了，得等段时间反映。）

2. 相关函数

  • TIM_ClockConfigTypeDef 时钟配置总控结构体
  • 基础的定时器配置初始化（定时器1通道 2举例）
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动 清除 定时器 更新事件
/ 外部模式1 ETR通道 /
tim1_clock.ClockSource = TIM_CLOCKSOURCE_ETRMODE1; //通道1 ETR
tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_INVERTED; //ETR反向 （低电平或下降沿有效） 为了匹配IO和ETR，防止复位后按一下就产生触发事件
//tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_NOINVERTED; //ETR不反向 （高电平或上升沿有效）
tim1_clock.ClockPrescaler = TIM_CLOCKPRESCALER_DIV4; //ETR的预分频器配置
tim1_clock.ClockFilter = 0x03; //滤波（注意是外部时钟的波）
HAL_TIM_ConfigClockSource(&tim1, &tim1_clock); //初始化定时器时钟配置
/ 防止加大分频因子或滤波强度而导致的 复位后产生触发事件 /
HAL_Delay(50);
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_TRIGGER); ///清除触发事件标志位
__HAL_TIM_SET_COUNTER(&tim1, 0); // 清除计数值
HAL_TIM_Base_Start(&tim1); //打开定时器（轮询方式）
}
  • 初始化硬件配置回调函数

3. 程序

time.c

#include "stm32f1xx_hal.h"
#include "time.h"
TIM_HandleTypeDef tim1; //（高级）定时器1总控结构体
TIM_HandleTypeDef tim2;
TIM_HandleTypeDef tim3;
TIM_HandleTypeDef tim4;
DMA_HandleTypeDef tim1_dmaup;
DMA_HandleTypeDef tim2_dmaup;
DMA_HandleTypeDef tim3_dmaup;
DMA_HandleTypeDef tim4_dmaup;
TIM_ClockConfigTypeDef tim1_clock; //时钟配置结构体
uint16_t tim1_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim2_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim3_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim4_dmaBuff[4] = {20000, 30000, 40000, 50000};
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动 清除 定时器 更新事件
/ 外部模式1 ETR通道 /
tim1_clock.ClockSource = TIM_CLOCKSOURCE_ETRMODE1; //通道1 ETR
tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_INVERTED; //ETR反向 （低电平或下降沿有效） 为了匹配IO和ETR，防止复位后按一下就产生触发事件
//tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_NOINVERTED; //ETR不反向 （高电平或上升沿有效）
tim1_clock.ClockPrescaler = TIM_CLOCKPRESCALER_DIV4; //ETR的预分频器配置
tim1_clock.ClockFilter = 0x03; //滤波（注意是外部时钟的波）
HAL_TIM_ConfigClockSource(&tim1, &tim1_clock); //初始化定时器时钟配置
/ 防止加大分频因子或滤波强度而导致的 复位后产生触发事件 /
HAL_Delay(50);
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_TRIGGER); ///清除触发事件标志位
__HAL_TIM_SET_COUNTER(&tim1, 0); // 清除计数值
HAL_TIM_Base_Start(&tim1); //打开定时器（轮询方式）
}
//定时器 2
void Timer2_Init(uint16_t arr, uint16_t psc)
{
tim2.Instance = TIM2;
tim2.Init.Period = arr;
tim2.Init.Prescaler = psc;
tim2.Init.CounterMode = TIM_COUNTERMODE_UP;
tim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim2);
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim2, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim2, (uint32_t*)tim2_dmaBuff, 4);
}
//定时器 3
void Timer3_Init(uint16_t arr, uint16_t psc)
{
tim3.Instance = TIM3;
tim3.Init.Period = arr;
tim3.Init.Prescaler = psc;
tim3.Init.CounterMode = TIM_COUNTERMODE_UP;
tim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim3);
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim3, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim3, (uint32_t*)tim3_dmaBuff, 4);
}
//定时器 4
void Timer4_Init(uint16_t arr, uint16_t psc)
{
tim4.Instance = TIM4;
tim4.Init.Period = arr;
tim4.Init.Prescaler = psc;
tim4.Init.CounterMode = TIM_COUNTERMODE_UP;
tim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim4);
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim4, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim4, (uint32_t*)tim4_dmaBuff, 4);
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE(); //使能时钟
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitTypeDef GPIO_InitType;
GPIO_InitType.Pin = GPIO_PIN_12;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
GPIO_InitType.Speed = GPIO_SPEED_FREQ_MEDIUM;
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
//
// HAL_NVIC_SetPriority(TIM1_UP_IRQn, 3, 0); //配置、打开 更新中断
// HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
//
// / DMA配置 /
// tim1_dmaup.Instance = DMA1_Channel5;
// tim1_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
// tim1_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
// tim1_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
// tim1_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
// tim1_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim1_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim1_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim1, hdma[TIM_DMA_ID_UPDATE], tim1_dmaup);
// HAL_DMA_Init(&tim1_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
//
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM2_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
/ DMA配置 /
tim2_dmaup.Instance = DMA1_Channel2;
tim2_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim2_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim2_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim2_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim2_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim2_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim2, hdma[TIM_DMA_ID_UPDATE], tim2_dmaup);
HAL_DMA_Init(&tim2_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM3_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
/ DMA配置 /
tim3_dmaup.Instance = DMA1_Channel3;
tim3_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim3_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim3_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim3_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim3_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim3_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim3_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim3, hdma[TIM_DMA_ID_UPDATE], tim3_dmaup);
HAL_DMA_Init(&tim3_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM4_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
/ DMA配置 /
tim4_dmaup.Instance = DMA1_Channel7;
tim4_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim4_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim4_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim4_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim4_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim4_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim4_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim4, hdma[TIM_DMA_ID_UPDATE], tim4_dmaup);
HAL_DMA_Init(&tim4_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
}
}
//定时器 硬件 De 回调函数
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_DISABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_DISABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_DISABLE();
}
}
//更新中断 回调函数(同时也是DMA完成的回调函数)
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
/ 判断TIM是否为Ready状态，如果是 则是DMA完成中断进入的回调函数 /
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA1 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 1 定时时间:%drn",time1++);
}
}else if(htim->Instance == TIM2){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA2 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 2 定时时间:%drn",time2++);
}
}else if(htim->Instance == TIM3){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA3 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 3 定时时间:%drn",time3++);
}
}else if(htim->Instance == TIM4){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA4 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 4 定时时间:%drn",time4++);
}
}
}
//DMA 半完成回调函数
void HAL_TIM_PeriodElapsedHalfCpltCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}
}

time.h

#ifndef __TIME_H
#define __TIME_H
#include "uart.h"
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
extern DMA_HandleTypeDef tim1_dmaup;
extern DMA_HandleTypeDef tim2_dmaup;
extern DMA_HandleTypeDef tim3_dmaup;
extern DMA_HandleTypeDef tim4_dmaup;
/ 初始化函数 /
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep);
void Timer2_Init(uint16_t arr, uint16_t psc);
void Timer3_Init(uint16_t arr, uint16_t psc);
void Timer4_Init(uint16_t arr, uint16_t psc);
#endif

main.c

while(1){
/ 获取更新标志位 /
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); ///清除标志位
U1_Printf("定时器 1 更新事件rn");
}
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_TRIGGER)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_TRIGGER); ///清除标志位
U1_Printf("定时器 1 触发事件:%drn", __HAL_TIM_GET_COUNTER(&tim1)); //输出当前计数值
}
}

四、HAL库：TIM234 外部模式1 通道1 2 轮询方式 重映射通道 边沿检测 按键计数

1. 注意事项*

  1. 引脚冲突问题
      2. 要善用重映射功能，避免引脚冲突
      并且在切换不同的通道的时候，注意GPIO口的初始化与上下拉配置
  1. 还是引脚冲突问题
      2. 单片机在默认状态佳，SW+JTAG仿真都是开启状态的。
      当定时器2 的通道1 重映射会映射到 PA15，会与JTAG的引脚冲突。注意一下需要
  1. 如果映射TIM2时， 一旦设计仿真接口切换为普通接口，需要在初始化时保持一致
      2. notion image

2. 程序

time.c

#include "stm32f1xx_hal.h"
#include "time.h"
TIM_HandleTypeDef tim1; //定时器结构体
TIM_HandleTypeDef tim2;
TIM_HandleTypeDef tim3;
TIM_HandleTypeDef tim4;
DMA_HandleTypeDef tim1_dmaup; //DMA通道配置结构体
DMA_HandleTypeDef tim2_dmaup;
DMA_HandleTypeDef tim3_dmaup;
DMA_HandleTypeDef tim4_dmaup;
TIM_ClockConfigTypeDef tim1_clock; //时钟配置结构体
TIM_ClockConfigTypeDef tim2_clock;
TIM_ClockConfigTypeDef tim3_clock;
TIM_ClockConfigTypeDef tim4_clock;
uint16_t tim1_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim2_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim3_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim4_dmaBuff[4] = {20000, 30000, 40000, 50000};
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动 清除 定时器 更新事件
/ 外部模式1 ETR通道 /
tim1_clock.ClockSource = TIM_CLOCKSOURCE_ETRMODE1; //通道1 ETR
tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_INVERTED; //ETR反向 （低电平或下降沿有效）
//tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_NOINVERTED; //ETR不反向 （高电平或上升沿有效）
tim1_clock.ClockPrescaler = TIM_CLOCKPRESCALER_DIV1; //ETR的预分频器配置
tim1_clock.ClockFilter = 0x03; //滤波（注意是外部时钟的波）
HAL_TIM_ConfigClockSource(&tim1, &tim1_clock); //初始化定时器时钟配置
HAL_TIM_Base_Start(&tim1); //打开定时器（轮询方式）
}
//定时器 2
void Timer2_Init(uint16_t arr, uint16_t psc)
{
tim2.Instance = TIM2;
tim2.Init.Period = arr;
tim2.Init.Prescaler = psc;
tim2.Init.CounterMode = TIM_COUNTERMODE_UP;
tim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim2);
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
/ 外部模式1 通道1 双边沿检测 重映射/
tim2_clock.ClockSource = TIM_CLOCKSOURCE_TI1ED; //通道1 边沿检测
HAL_TIM_ConfigClockSource(&tim2, &tim2_clock); //初始化定时器时钟配置
HAL_TIM_Base_Start(&tim2); //打开定时器（轮询方式）
}
//定时器 3
void Timer3_Init(uint16_t arr, uint16_t psc)
{
tim3.Instance = TIM3;
tim3.Init.Period = arr;
tim3.Init.Prescaler = psc;
tim3.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED1; //中央对齐模式
tim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim3);
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
/ 外部模式1 通道1 /
tim3_clock.ClockSource = TIM_CLOCKSOURCE_TI1; // 通道1
tim3_clock.ClockPolarity = TIM_CLOCKPOLARITY_RISING; // 上升沿
tim3_clock.ClockFilter = 0x03; // 滤波
HAL_TIM_ConfigClockSource(&tim3, &tim3_clock); //初始化定时器时钟配置
HAL_TIM_Base_Start(&tim3); //打开定时器（轮询方式）
}
//定时器 4
void Timer4_Init(uint16_t arr, uint16_t psc)
{
tim4.Instance = TIM4;
tim4.Init.Period = arr;
tim4.Init.Prescaler = psc;
tim4.Init.CounterMode = TIM_COUNTERMODE_UP;
tim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim4);
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
/ 外部模式1 通道2 /
tim4_clock.ClockSource = TIM_CLOCKSOURCE_TI2; // 通道2
tim4_clock.ClockPolarity = TIM_CLOCKPOLARITY_FALLING; // 下降沿
tim4_clock.ClockFilter = 0x03; // 滤波
HAL_TIM_ConfigClockSource(&tim4, &tim4_clock); //初始化定时器时钟配置
HAL_TIM_Base_Start(&tim4); //打开定时器（轮询方式）
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
GPIO_InitTypeDef GPIO_InitType;
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE(); //使能时钟
/ 定时器1 外部模式1 ETR通道IO /
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_12;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
//
// HAL_NVIC_SetPriority(TIM1_UP_IRQn, 3, 0); //配置、打开 更新中断
// HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
//
// / DMA配置 /
// tim1_dmaup.Instance = DMA1_Channel5;
// tim1_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
// tim1_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
// tim1_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
// tim1_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
// tim1_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim1_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim1_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim1, hdma[TIM_DMA_ID_UPDATE], tim1_dmaup);
// HAL_DMA_Init(&tim1_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
//
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_AFIO_REMAP_TIM2_ENABLE();
//__HAL_AFIO_REMAP_TIM2_PARTIAL_1(); //(同样的功能)
__HAL_AFIO_REMAP_SWJ_NOJTAG();
/ 定时器2 外部模式1 通道1 重映射/
//GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Pin = GPIO_PIN_15;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
// HAL_NVIC_SetPriority(TIM2_IRQn, 3, 0);
// HAL_NVIC_EnableIRQ(TIM2_IRQn);
//
// / DMA配置 /
// tim2_dmaup.Instance = DMA1_Channel2;
// tim2_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
// tim2_dmaup.Init.MemInc = DMA_MINC_ENABLE;
// tim2_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
// tim2_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
// tim2_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim2_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim2, hdma[TIM_DMA_ID_UPDATE], tim2_dmaup);
// HAL_DMA_Init(&tim2_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_ENABLE();
//__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_AFIO_REMAP_TIM3_PARTIAL(); //部分映射
__HAL_AFIO_REMAP_SWJ_NONJTRST(); //完全SW+JATG 但没有NJTRST
/ 定时器3 外部模式1 通道1 重映射/
//GPIO_InitType.Pin = GPIO_PIN_6;
GPIO_InitType.Pin = GPIO_PIN_4;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
// HAL_NVIC_SetPriority(TIM3_IRQn, 3, 0);
// HAL_NVIC_EnableIRQ(TIM3_IRQn);
//
// / DMA配置 /
// tim3_dmaup.Instance = DMA1_Channel3;
// tim3_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
// tim3_dmaup.Init.MemInc = DMA_MINC_ENABLE;
// tim3_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
// tim3_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
// tim3_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim3_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim3_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim3, hdma[TIM_DMA_ID_UPDATE], tim3_dmaup);
// HAL_DMA_Init(&tim3_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_ENABLE();
/ 定时器4 外部模式1 通道2 /
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_7;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOB, &GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
// HAL_NVIC_SetPriority(TIM4_IRQn, 3, 0);
// HAL_NVIC_EnableIRQ(TIM4_IRQn);
//
// / DMA配置 /
// tim4_dmaup.Instance = DMA1_Channel7;
// tim4_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
// tim4_dmaup.Init.MemInc = DMA_MINC_ENABLE;
// tim4_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
// tim4_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
// tim4_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim4_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim4_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim4, hdma[TIM_DMA_ID_UPDATE], tim4_dmaup);
// HAL_DMA_Init(&tim4_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
}
}
//定时器 硬件 De 回调函数
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_DISABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_DISABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_DISABLE();
}
}
//更新中断 回调函数(同时也是DMA完成的回调函数)
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
/ 判断TIM是否为Ready状态，如果是 则是DMA完成中断进入的回调函数 /
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA1 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 1 定时时间:%drn",time1++);
}
}else if(htim->Instance == TIM2){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA2 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 2 定时时间:%drn",time2++);
}
}else if(htim->Instance == TIM3){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA3 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 3 定时时间:%drn",time3++);
}
}else if(htim->Instance == TIM4){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA4 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 4 定时时间:%drn",time4++);
}
}
}
//DMA 半完成回调函数
void HAL_TIM_PeriodElapsedHalfCpltCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}
}

time.h

#ifndef __TIME_H
#define __TIME_H
#include "uart.h"
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
extern DMA_HandleTypeDef tim1_dmaup;
extern DMA_HandleTypeDef tim2_dmaup;
extern DMA_HandleTypeDef tim3_dmaup;
extern DMA_HandleTypeDef tim4_dmaup;
/ 初始化函数 /
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep);
void Timer2_Init(uint16_t arr, uint16_t psc);
void Timer3_Init(uint16_t arr, uint16_t psc);
void Timer4_Init(uint16_t arr, uint16_t psc);
#endif

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
#include "time.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
Timer1_Init(5 - 1, 0, 1 - 1); //5次有效边沿
Timer2_Init(5 - 1, 0); // 5次
Timer3_Init(5 - 1, 0); // 5次
Timer4_Init(5 - 1, 0); // 5次
// uint16_t time1 = 0;
// uint16_t time2 = 0;
// uint16_t time3 = 0;
// uint16_t time4 = 0;
while(1){
/ 获取更新标志位 /
/ TIM1 /
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); ///清除标志位
U1_Printf("定时器 1 更新事件rn");
}
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_TRIGGER)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_TRIGGER); ///清除标志位
U1_Printf("定时器 1 触发事件:%drn", __HAL_TIM_GET_COUNTER(&tim1)); //输出当前计数值
}
/ TIM2 /
if(__HAL_TIM_GET_FLAG(&tim2, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
U1_Printf("定时器 2 更新事件rn");
}
if(__HAL_TIM_GET_FLAG(&tim2, TIM_FLAG_TRIGGER)){
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_TRIGGER);
U1_Printf("定时器 2 触发事件:%drn", __HAL_TIM_GET_COUNTER(&tim2));
}
/ TIM3 /
if(__HAL_TIM_GET_FLAG(&tim3, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
U1_Printf("定时器 3 更新事件rn");
}
if(__HAL_TIM_GET_FLAG(&tim3, TIM_FLAG_TRIGGER)){
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_TRIGGER);
U1_Printf("定时器 3 触发事件:%drn", __HAL_TIM_GET_COUNTER(&tim3));
}
/ TIM4 /
if(__HAL_TIM_GET_FLAG(&tim4, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
U1_Printf("定时器 4 更新事件rn");
}
if(__HAL_TIM_GET_FLAG(&tim4, TIM_FLAG_TRIGGER)){
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_TRIGGER);
U1_Printf("定时器 4 触发事件:%drn", __HAL_TIM_GET_COUNTER(&tim4));
}
//
// if(__HAL_TIM_GET_FLAG(&tim2, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
// U1_Printf("定时器 2 定时时间:%drn",time2++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim3, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
// U1_Printf("定时器 3 定时时间:%drn",time3++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim4, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
// U1_Printf("定时器 4 定时时间:%drn",time4++);
// }
}
}

五、HAL库：TIM1234 外部模式1 中断方式 按键计数

1. 注意事项*

  1. HAL库只会打开Up中断，触发中断需要手动打开
  1. 注意定时器与别的外设 引脚冲突

2. 相关函数

  • __HAL_TIM_ENABLE_IT(&tim3, TIM_IT_TRIGGER); 手动打开触发中断
  • HAL_TIM_Base_Start_IT(&tim4); 打开定时器（中断方式）

3. 程序

time.c

#include "stm32f1xx_hal.h"
#include "time.h"
TIM_HandleTypeDef tim1; //定时器结构体
TIM_HandleTypeDef tim2;
TIM_HandleTypeDef tim3;
TIM_HandleTypeDef tim4;
DMA_HandleTypeDef tim1_dmaup; //DMA通道配置结构体
DMA_HandleTypeDef tim2_dmaup;
DMA_HandleTypeDef tim3_dmaup;
DMA_HandleTypeDef tim4_dmaup;
TIM_ClockConfigTypeDef tim1_clock; //时钟配置结构体
TIM_ClockConfigTypeDef tim2_clock;
TIM_ClockConfigTypeDef tim3_clock;
TIM_ClockConfigTypeDef tim4_clock;
uint16_t tim1_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim2_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim3_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim4_dmaBuff[4] = {20000, 30000, 40000, 50000};
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动 清除 定时器 更新事件
/ 外部模式1 ETR通道 / //PA12 下降沿 按下计数 上拉
tim1_clock.ClockSource = TIM_CLOCKSOURCE_ETRMODE1; //通道1 ETR
tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_INVERTED; //ETR反向 （低电平或下降沿有效）
//tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_NOINVERTED; //ETR不反向 （高电平或上升沿有效）
tim1_clock.ClockPrescaler = TIM_CLOCKPRESCALER_DIV1; //ETR的预分频器配置
tim1_clock.ClockFilter = 0x03; //滤波（注意是外部时钟的波）
HAL_TIM_ConfigClockSource(&tim1, &tim1_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim1, TIM_IT_TRIGGER); //手动打开触发中断
HAL_TIM_Base_Start_IT(&tim1); //打开定时器（中断方式）
}
//定时器 2
void Timer2_Init(uint16_t arr, uint16_t psc)
{
tim2.Instance = TIM2;
tim2.Init.Period = arr;
tim2.Init.Prescaler = psc;
tim2.Init.CounterMode = TIM_COUNTERMODE_UP;
tim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim2);
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
/ 外部模式1 通道1 双边沿检测 重映射/ //PA15 双边边沿 上拉
tim2_clock.ClockSource = TIM_CLOCKSOURCE_TI1ED; //通道1 边沿检测
HAL_TIM_ConfigClockSource(&tim2, &tim2_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim2, TIM_IT_TRIGGER); //手动打开触发中断
HAL_TIM_Base_Start_IT(&tim2); //打开定时器（中断方式）
}
//定时器 3
void Timer3_Init(uint16_t arr, uint16_t psc)
{
tim3.Instance = TIM3;
tim3.Init.Period = arr;
tim3.Init.Prescaler = psc;
tim3.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED1; //中央对齐模式
tim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim3);
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
/ 外部模式1 通道1 / //PB4 上升沿 上拉 抬起计数
tim3_clock.ClockSource = TIM_CLOCKSOURCE_TI1; // 通道1
tim3_clock.ClockPolarity = TIM_CLOCKPOLARITY_RISING; // 上升沿
tim3_clock.ClockFilter = 0x03; // 滤波
HAL_TIM_ConfigClockSource(&tim3, &tim3_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim3, TIM_IT_TRIGGER); //手动打开触发中断
HAL_TIM_Base_Start_IT(&tim3); //打开定时器（中断方式）
}
//定时器 4
void Timer4_Init(uint16_t arr, uint16_t psc)
{
tim4.Instance = TIM4;
tim4.Init.Period = arr;
tim4.Init.Prescaler = psc;
tim4.Init.CounterMode = TIM_COUNTERMODE_UP;
tim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim4);
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
/ 外部模式1 通道2 / //PB7 下降沿 上拉 按下计数
tim4_clock.ClockSource = TIM_CLOCKSOURCE_TI2; // 通道2
tim4_clock.ClockPolarity = TIM_CLOCKPOLARITY_FALLING; // 下降沿
tim4_clock.ClockFilter = 0x03; // 滤波
HAL_TIM_ConfigClockSource(&tim4, &tim4_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim4, TIM_IT_TRIGGER); //手动打开触发中断
HAL_TIM_Base_Start_IT(&tim4); //打开定时器（中断方式）
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
GPIO_InitTypeDef GPIO_InitType;
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE(); //使能时钟
/ 定时器1 外部模式1 ETR通道IO /
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_12;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
//
HAL_NVIC_SetPriority(TIM1_UP_IRQn, 3, 0); //配置、打开 更新中断
HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
HAL_NVIC_SetPriority(TIM1_TRG_COM_IRQn, 3, 0); //配置、打开 触发中断
HAL_NVIC_EnableIRQ(TIM1_TRG_COM_IRQn);
//
// / DMA配置 /
// tim1_dmaup.Instance = DMA1_Channel5;
// tim1_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
// tim1_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
// tim1_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
// tim1_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
// tim1_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim1_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim1_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim1, hdma[TIM_DMA_ID_UPDATE], tim1_dmaup);
// HAL_DMA_Init(&tim1_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
//
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_AFIO_REMAP_TIM2_ENABLE();
//__HAL_AFIO_REMAP_TIM2_PARTIAL_1(); //(同样的功能)
__HAL_AFIO_REMAP_SWJ_NOJTAG();
/ 定时器2 外部模式1 通道1 重映射/
//GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Pin = GPIO_PIN_15;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM2_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
//
// / DMA配置 /
// tim2_dmaup.Instance = DMA1_Channel2;
// tim2_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
// tim2_dmaup.Init.MemInc = DMA_MINC_ENABLE;
// tim2_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
// tim2_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
// tim2_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim2_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim2, hdma[TIM_DMA_ID_UPDATE], tim2_dmaup);
// HAL_DMA_Init(&tim2_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_ENABLE();
//__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_AFIO_REMAP_TIM3_PARTIAL(); //部分映射
__HAL_AFIO_REMAP_SWJ_NONJTRST(); //完全SW+JATG 但没有NJTRST
/ 定时器3 外部模式1 通道1 重映射/
//GPIO_InitType.Pin = GPIO_PIN_6;
GPIO_InitType.Pin = GPIO_PIN_4;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM3_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
//
// / DMA配置 /
// tim3_dmaup.Instance = DMA1_Channel3;
// tim3_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
// tim3_dmaup.Init.MemInc = DMA_MINC_ENABLE;
// tim3_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
// tim3_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
// tim3_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim3_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim3_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim3, hdma[TIM_DMA_ID_UPDATE], tim3_dmaup);
// HAL_DMA_Init(&tim3_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_ENABLE();
/ 定时器4 外部模式1 通道2 /
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_7;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOB, &GPIO_InitType);
// __HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM4_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
//
// / DMA配置 /
// tim4_dmaup.Instance = DMA1_Channel7;
// tim4_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
// tim4_dmaup.Init.MemInc = DMA_MINC_ENABLE;
// tim4_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
// tim4_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
// tim4_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
// tim4_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
// tim4_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
// __HAL_LINKDMA(&tim4, hdma[TIM_DMA_ID_UPDATE], tim4_dmaup);
// HAL_DMA_Init(&tim4_dmaup);
//
// HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 3, 0); //配置、打开 通道5的中断
// HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
}
}
//定时器 硬件 De 回调函数
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_DISABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_DISABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_DISABLE();
}
}
//更新中断 回调函数(同时也是DMA完成的回调函数)
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
// / 判断TIM是否为Ready状态，如果是 则是DMA完成中断进入的回调函数 /
// if(htim->State == HAL_DMA_STATE_READY){
// U1_Printf("DMA1 完成中断rn");
// htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
// }else{
// U1_Printf("定时器 1 定时时间:%drn",time1++);
// }
U1_Printf("定时器 1 更新事件rn");
}else if(htim->Instance == TIM2){
// if(htim->State == HAL_DMA_STATE_READY){
// U1_Printf("DMA2 完成中断rn");
// htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
// }else{
// U1_Printf("定时器 2 定时时间:%drn",time2++);
// }
U1_Printf("定时器 2 更新事件rn");
}else if(htim->Instance == TIM3){
// if(htim->State == HAL_DMA_STATE_READY){
// U1_Printf("DMA3 完成中断rn");
// htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
// }else{
// U1_Printf("定时器 3 定时时间:%drn",time3++);
// }
U1_Printf("定时器 3 更新事件rn");
}else if(htim->Instance == TIM4){
// if(htim->State == HAL_DMA_STATE_READY){
// U1_Printf("DMA4 完成中断rn");
// htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
// }else{
// U1_Printf("定时器 4 定时时间:%drn",time4++);
// }
U1_Printf("定时器 4 更新事件rn");
}
}
//触发中断 回调函数
void HAL_TIM_TriggerCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}
}
//DMA 半完成回调函数
void HAL_TIM_PeriodElapsedHalfCpltCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 DMA半完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}
}

time.h

#ifndef __TIME_H
#define __TIME_H
#include "uart.h"
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
extern DMA_HandleTypeDef tim1_dmaup;
extern DMA_HandleTypeDef tim2_dmaup;
extern DMA_HandleTypeDef tim3_dmaup;
extern DMA_HandleTypeDef tim4_dmaup;
/ 初始化函数 /
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep);
void Timer2_Init(uint16_t arr, uint16_t psc);
void Timer3_Init(uint16_t arr, uint16_t psc);
void Timer4_Init(uint16_t arr, uint16_t psc);
#endif

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
#include "time.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
Timer1_Init(5 - 1, 0, 1 - 1); //5次有效边沿
Timer2_Init(5 - 1, 0); // 5次
Timer3_Init(5 - 1, 0); // 5次
Timer4_Init(5 - 1, 0); // 5次
U1_Printf("初始化完成rn");
while(1){
}
}

stm32f1xx_it.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
#include "time.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
uart1.RxCounter += (U1_RX_MAX - __HAL_DMA_GET_COUNTER(&uart1.dmarx));
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx));
HAL_UART_AbortReceive_IT(&uart2.uart);
}
}
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx));
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}
void DMA1_Channel4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmatx);
}
//void DMA1_Channel5_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart1.dmarx);
//}
//void DMA1_Channel7_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart2.dmatx);
//}
void DMA1_Channel6_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmarx);
}
//void DMA1_Channel2_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmatx);
//}
//void DMA1_Channel3_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmarx);
//}
void DMA1_Channel5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim1_dmaup);
}
void DMA1_Channel2_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim2_dmaup);
}
void DMA1_Channel3_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim3_dmaup);
}
void DMA1_Channel7_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim4_dmaup);
}
void TIM1_UP_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim1);
}
void TIM1_TRG_COM_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim1);
}
void TIM2_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim2);
}
void TIM3_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim3);
}
void TIM4_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim4);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}

六、HAL库：TIM1234 外部模式1 DMA单次/循环模式 中断方式 按键计数

1. 注意事项*

  1. DMA方式，HAL库不会开启任何中断，需要自己开启更新和触发中断
  1. 注意定时器与别的外设 引脚冲突
  1. 普通的更新中断与DMA完成中断共用一个回调函数

2. 简单介绍

DMA方式，会在每次更新时，传递新的值到ARR重载值，我们初始 化的时候设置ARR为5，然后启动DMA 4次传输分别传输6,7,8,9。
对于单次DMA向上计数，第一次5+1个有效边沿，第二次6+1个有效 边沿，第三次7+1个有效边沿，第四次8+1个有效边沿，第五次9+1 个有效边沿，之后一直都是9+1个有效边沿。
对于循环DMA向上计数，第一次5+1个有效边沿，第二次6+1个有效 边沿，第三次7+1个有效边沿，第四次8+1个有效边沿，第五次9+1 个有效边沿，第六次6+1个有效边沿，第七次7+1个有效边沿，第八 次8+1个有效边沿，第九次9+1个有效边沿，第十次6+1个有效边 沿.......往复循环

2. 相关函数

  • __HAL_TIM_ENABLE_IT(&tim3, TIM_IT_TRIGGER); 手动打开中断
  • HAL_TIM_Base_Start_DMA(&tim4); 打开定时器（DMA方式）

3. 程序

time.c

#include "stm32f1xx_hal.h"
#include "time.h"
TIM_HandleTypeDef tim1; //定时器结构体
TIM_HandleTypeDef tim2;
TIM_HandleTypeDef tim3;
TIM_HandleTypeDef tim4;
DMA_HandleTypeDef tim1_dmaup; //DMA通道配置结构体
DMA_HandleTypeDef tim2_dmaup;
DMA_HandleTypeDef tim3_dmaup;
DMA_HandleTypeDef tim4_dmaup;
TIM_ClockConfigTypeDef tim1_clock; //时钟配置结构体
TIM_ClockConfigTypeDef tim2_clock;
TIM_ClockConfigTypeDef tim3_clock;
TIM_ClockConfigTypeDef tim4_clock;
uint16_t tim1_dmaBuff[4] = {6, 7, 8, 9};
uint16_t tim2_dmaBuff[4] = {6, 7, 8, 9};
uint16_t tim3_dmaBuff[4] = {6, 7, 8, 9};
uint16_t tim4_dmaBuff[4] = {6, 7, 8, 9};
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动 清除 定时器 更新事件
/ 外部模式1 ETR通道 / //PA12 下降沿 按下计数 上拉
tim1_clock.ClockSource = TIM_CLOCKSOURCE_ETRMODE1; //通道1 ETR
tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_INVERTED; //ETR反向 （低电平或下降沿有效）
//tim1_clock.ClockPolarity = TIM_CLOCKPOLARITY_NOINVERTED; //ETR不反向 （高电平或上升沿有效）
tim1_clock.ClockPrescaler = TIM_CLOCKPRESCALER_DIV1; //ETR的预分频器配置
tim1_clock.ClockFilter = 0x03; //滤波（注意是外部时钟的波）
HAL_TIM_ConfigClockSource(&tim1, &tim1_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim1, TIM_IT_TRIGGER | TIM_IT_UPDATE); //手动打开触发中断、更新中断
HAL_TIM_Base_Start_DMA(&tim1, (uint32_t* )tim1_dmaBuff, 4); //打开定时器（DMA方式）
}
//定时器 2
void Timer2_Init(uint16_t arr, uint16_t psc)
{
tim2.Instance = TIM2;
tim2.Init.Period = arr;
tim2.Init.Prescaler = psc;
tim2.Init.CounterMode = TIM_COUNTERMODE_UP;
tim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim2);
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
/ 外部模式1 通道1 双边沿检测 重映射/ //PA15 双边边沿 上拉
tim2_clock.ClockSource = TIM_CLOCKSOURCE_TI1ED; //通道1 边沿检测
HAL_TIM_ConfigClockSource(&tim2, &tim2_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim2, TIM_IT_TRIGGER | TIM_IT_UPDATE); //手动打开触发中断、更新中断
HAL_TIM_Base_Start_DMA(&tim2, (uint32_t* )tim2_dmaBuff, 4); //打开定时器（DMA方式）
}
//定时器 3
void Timer3_Init(uint16_t arr, uint16_t psc)
{
tim3.Instance = TIM3;
tim3.Init.Period = arr;
tim3.Init.Prescaler = psc;
tim3.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED1; //中央对齐模式
tim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim3);
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
/ 外部模式1 通道1 / //PB4 上升沿 上拉 抬起计数
tim3_clock.ClockSource = TIM_CLOCKSOURCE_TI1; // 通道1
tim3_clock.ClockPolarity = TIM_CLOCKPOLARITY_RISING; // 上升沿
tim3_clock.ClockFilter = 0x03; // 滤波
HAL_TIM_ConfigClockSource(&tim3, &tim3_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim3, TIM_IT_TRIGGER | TIM_IT_UPDATE); //手动打开触发中断、更新中断
HAL_TIM_Base_Start_DMA(&tim3, (uint32_t* )tim3_dmaBuff, 4); //打开定时器（DMA方式）
}
//定时器 4
void Timer4_Init(uint16_t arr, uint16_t psc)
{
tim4.Instance = TIM4;
tim4.Init.Period = arr;
tim4.Init.Prescaler = psc;
tim4.Init.CounterMode = TIM_COUNTERMODE_UP;
tim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim4);
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
/ 外部模式1 通道2 / //PB7 下降沿 上拉 按下计数
tim4_clock.ClockSource = TIM_CLOCKSOURCE_TI2; // 通道2
tim4_clock.ClockPolarity = TIM_CLOCKPOLARITY_FALLING; // 下降沿
tim4_clock.ClockFilter = 0x03; // 滤波
HAL_TIM_ConfigClockSource(&tim4, &tim4_clock); //初始化定时器时钟配置
__HAL_TIM_ENABLE_IT(&tim4, TIM_IT_TRIGGER | TIM_IT_UPDATE); //手动打开触发中断、更新中断
HAL_TIM_Base_Start_DMA(&tim4, (uint32_t* )tim4_dmaBuff, 4); //打开定时器（DMA方式）
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
GPIO_InitTypeDef GPIO_InitType;
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE(); //使能时钟
/ 定时器1 外部模式1 ETR通道IO /
__HAL_RCC_GPIOA_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_12;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(TIM1_UP_IRQn, 3, 0); //配置、打开 更新中断
HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
HAL_NVIC_SetPriority(TIM1_TRG_COM_IRQn, 3, 0); //配置、打开 触发中断
HAL_NVIC_EnableIRQ(TIM1_TRG_COM_IRQn);
/ DMA配置 /
__HAL_RCC_DMA1_CLK_ENABLE();
tim1_dmaup.Instance = DMA1_Channel5;
tim1_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
tim1_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
tim1_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
tim1_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
tim1_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim1_dmaup.Init.Mode = DMA_NORMAL; //单次模式
//tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim1_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim1, hdma[TIM_DMA_ID_UPDATE], tim1_dmaup);
HAL_DMA_Init(&tim1_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_AFIO_REMAP_TIM2_ENABLE();
//__HAL_AFIO_REMAP_TIM2_PARTIAL_1(); //(同样的功能)
__HAL_AFIO_REMAP_SWJ_NOJTAG();
/ 定时器2 外部模式1 通道1 重映射/
//GPIO_InitType.Pin = GPIO_PIN_0;
GPIO_InitType.Pin = GPIO_PIN_15;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOA,&GPIO_InitType);
HAL_NVIC_SetPriority(TIM2_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
/ DMA配置 /
__HAL_RCC_DMA1_CLK_ENABLE();
tim2_dmaup.Instance = DMA1_Channel2;
tim2_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim2_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim2_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim2_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim2_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim1_dmaup.Init.Mode = DMA_NORMAL; //单次模式
//tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim2_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim2, hdma[TIM_DMA_ID_UPDATE], tim2_dmaup);
HAL_DMA_Init(&tim2_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_ENABLE();
//__HAL_RCC_GPIOA_CLK_ENABLE();
__HAL_RCC_GPIOB_CLK_ENABLE();
__HAL_RCC_AFIO_CLK_ENABLE();
__HAL_AFIO_REMAP_TIM3_PARTIAL(); //部分映射
__HAL_AFIO_REMAP_SWJ_NONJTRST(); //完全SW+JATG 但没有NJTRST
/ 定时器3 外部模式1 通道1 重映射/
//GPIO_InitType.Pin = GPIO_PIN_6;
GPIO_InitType.Pin = GPIO_PIN_4;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOB,&GPIO_InitType);
HAL_NVIC_SetPriority(TIM3_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
/ DMA配置 /
__HAL_RCC_DMA1_CLK_ENABLE();
tim3_dmaup.Instance = DMA1_Channel3;
tim3_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim3_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim3_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim3_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim3_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim1_dmaup.Init.Mode = DMA_NORMAL; //单次模式
//tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim3_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim3, hdma[TIM_DMA_ID_UPDATE], tim3_dmaup);
HAL_DMA_Init(&tim3_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_ENABLE();
/ 定时器4 外部模式1 通道2 /
__HAL_RCC_GPIOB_CLK_ENABLE();
GPIO_InitType.Pin = GPIO_PIN_7;
GPIO_InitType.Mode = GPIO_MODE_AF_INPUT;
GPIO_InitType.Pull = GPIO_PULLUP; //低电平按下，上拉
HAL_GPIO_Init(GPIOB, &GPIO_InitType);
HAL_NVIC_SetPriority(TIM4_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
/ DMA配置 /
__HAL_RCC_DMA1_CLK_ENABLE();
tim4_dmaup.Instance = DMA1_Channel7;
tim4_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim4_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim4_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim4_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim4_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim1_dmaup.Init.Mode = DMA_NORMAL; //单次模式
//tim2_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim4_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim4, hdma[TIM_DMA_ID_UPDATE], tim4_dmaup);
HAL_DMA_Init(&tim4_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
}
}
//定时器 硬件 De 回调函数
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_DISABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_DISABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_DISABLE();
}
}
//更新中断 回调函数(同时也是DMA完成的回调函数)
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
/ 判断DMA的状态是否为Ready状态，如果是 则是DMA完成中断进入的回调函数 /
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA1 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 1 更新事件rn");
}
}else if(htim->Instance == TIM2){
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA2 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 2 更新事件rn");
}
}else if(htim->Instance == TIM3){
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA3 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 3 更新事件rn");
}
}else if(htim->Instance == TIM4){
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA4 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 4 更新事件rn");
}
}
}
//触发中断 回调函数
void HAL_TIM_TriggerCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 触发事件:%drn", __HAL_TIM_GET_COUNTER(htim)); //输出当前计数值
}
}
//DMA 半完成回调函数
void HAL_TIM_PeriodElapsedHalfCpltCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 DMA半完成中断rn");
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 DMA半完成中断rn");
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 DMA半完成中断rn");
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 DMA半完成中断rn");
}
}

time.h

#ifndef __TIME_H
#define __TIME_H
#include "uart.h"
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
extern DMA_HandleTypeDef tim1_dmaup;
extern DMA_HandleTypeDef tim2_dmaup;
extern DMA_HandleTypeDef tim3_dmaup;
extern DMA_HandleTypeDef tim4_dmaup;
/ 初始化函数 /
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep);
void Timer2_Init(uint16_t arr, uint16_t psc);
void Timer3_Init(uint16_t arr, uint16_t psc);
void Timer4_Init(uint16_t arr, uint16_t psc);
#endif

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
#include "time.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
Timer1_Init(5 - 1, 0, 1 - 1); //5次有效边沿
Timer2_Init(5 - 1, 0); // 5次
Timer3_Init(5 - 1, 0); // 5次
Timer4_Init(5 - 1, 0); // 5次
U1_Printf("初始化完成rn");
while(1){
}
}

stm32f1xx_it.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
#include "time.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
uart1.RxCounter += (U1_RX_MAX - __HAL_DMA_GET_COUNTER(&uart1.dmarx));
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx));
HAL_UART_AbortReceive_IT(&uart2.uart);
}
}
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx));
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}
void DMA1_Channel4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmatx);
}
//void DMA1_Channel5_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart1.dmarx);
//}
//void DMA1_Channel7_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart2.dmatx);
//}
void DMA1_Channel6_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmarx);
}
//void DMA1_Channel2_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmatx);
//}
//void DMA1_Channel3_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmarx);
//}
void TIM1_UP_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim1);
}
void TIM1_TRG_COM_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim1);
}
void DMA1_Channel5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim1_dmaup);
}
void TIM2_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim2);
}
void DMA1_Channel2_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim2_dmaup);
}
void TIM3_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim3);
}
void DMA1_Channel3_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim3_dmaup);
}
void TIM4_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim4);
}
void DMA1_Channel7_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim4_dmaup);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}

七、HAL库：TIM12 外部模式2 循环 中断 DMA方式 按键计数

具体方式与外模1类似，但是需要注意一下 两 点：
  1. 外部模式2并没有触发中断
      2. notion image
      可以看到外部模式1 有TIF触发事件的产生
      notion image
      但是外部模式2并没有
      notion image
  1. 外部模式2仅支持ETR通道
      • STMF103C8T6只有TIM 1 2 有ERT通道

定时器[基础定时]篇

一、资源介绍：STM32F103C8T6定时器资源介绍

高级定时器（TIM1）

  • 时基单元包含：
    • 计数器寄存器（TIMx_CNT）
    • 预分频器寄存器（TIMx_PSC）
    • 自动装载寄存器（TIMx_ARR）
    • 重复次数寄存器（TIMx_RCR）

通用定时器（TIM2、TIM3、TIM4）

  • 时基单元包含：
    • 计数器寄存器（TIMx_CNT）
    • 预分频器寄存器（TIMx_PSC）
    • 自动装载寄存器（TIMx_ARR）

定时器 1 通道

  • 通道 1：PA8、 DMA1_Channel2
  • 通道 2：PA9、 DMA1_Channel3
  • 通道 3：PA10、 DMA1_Channel6
  • 通道 4：PA11、 DMA1_Channel4
  • 通道 ETR：PA12
  • 刹车： PB12、PA6（重映射）
  • 通道 1 互补：PB13、PA7（重映射）
  • 通道 2 互补：PB14、PB0（重映射）
  • 通道 3 互补：PB15、PB1（重映射）

定时器 2 通道

  • 通道 1：PA0（重映射 PA15）、PA1（重映射 PB3）
  • 通道 2：PA2（重映射 PB10）
  • 通道 3：DMA1_Channel5、DMA1_Channel7、DMA1_Channel1、DMA1_Channel7
  • 通道 4：PA3（重映射 PB11）
  • 通道 ETR：PA0（重映射 PA15）

定时器 3 通道

  • 通道 1：PA6（重映射 PB4）、DMA1_Channel6、DMA1_Channel2、DMA1_Channel3
  • 通道 2：PA7（重映射 PB5）
  • 通道 3：PB0
  • 通道 4：PB1
  • 通道 ETR：无

定时器 4 通道

  • 通道1：PB6 DMA1 Channel1
  • 通道2：PB7 DMA1 Channel4
  • 通道3：PB8 DMA1 Channel5
  • 通道4：PB9
  • 通道ETR：无

二、HAL库：TIM1234轮询方式 基础定时

1. 相关函数

  • TIM_HandleTypeDef 定时器总控结构体
  • HAL_TIM_Base_Init(&tim3); 轮询 初始化定时器
  • __HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE); 清除更新标志位
  • HAL_TIM_Base_Start(&tim3); 开启定时器
  • void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim) 定时器DeInit回调函数
  • 基础的初始化
  • void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim) 定时器Init回调函数
  • 基础的初始化
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动清除更新事件
HAL_TIM_Base_Start(&tim1); //打开定时器（轮询方式）
}
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); ///清除标志位
U1_Printf("定时器 1 定时时间:%drn",time1++);
}
 

2. 程序

time.c

#include "stm32f1xx_hal.h"
#include "time.h"
TIM_HandleTypeDef tim1; //（高级）定时器1总控结构体
TIM_HandleTypeDef tim2;
TIM_HandleTypeDef tim3;
TIM_HandleTypeDef tim4;
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动清除更新事件
HAL_TIM_Base_Start(&tim1); //打开定时器（轮询方式）
}
//定时器 2
void Timer2_Init(uint16_t arr, uint16_t psc)
{
tim2.Instance = TIM2;
tim2.Init.Period = arr;
tim2.Init.Prescaler = psc;
tim2.Init.CounterMode = TIM_COUNTERMODE_UP;
tim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim2); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
HAL_TIM_Base_Start(&tim2); //打开定时器（轮询方式）
}
//定时器 3
void Timer3_Init(uint16_t arr, uint16_t psc)
{
tim3.Instance = TIM3;
tim3.Init.Period = arr;
tim3.Init.Prescaler = psc;
tim3.Init.CounterMode = TIM_COUNTERMODE_UP;
tim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim3);
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
HAL_TIM_Base_Start(&tim3);
}
//定时器 4
void Timer4_Init(uint16_t arr, uint16_t psc)
{
tim4.Instance = TIM4;
tim4.Init.Period = arr;
tim4.Init.Prescaler = psc;
tim4.Init.CounterMode = TIM_COUNTERMODE_UP;
tim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim4);
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
HAL_TIM_Base_Start(&tim4);
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_ENABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_ENABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_ENABLE();
}
}
//定时器 De回调函数
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM1_CLK_DISABLE();
}
}

time.h

#ifndef __TIME_H
#define __TIME_H
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
/ 初始化函数 /

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
#include "time.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
Timer1_Init(20000 - 1, 3600 - 1, 4 - 1); // 72000000/3600/20000 = 1 * 4 = 4s
Timer2_Init(30000 - 1, 7200 - 1); // 3s
Timer3_Init(20000 - 1, 7200 - 1); // 2s
Timer4_Init(10000 - 1, 7200 - 1); // 1s
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
while(1){
/ 获取更新标志位 /
if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); ///清除标志位
U1_Printf("定时器 1 定时时间:%drn",time1++);
if(time1 > 5){
U1_Printf("定时器 1 关闭rn");
HAL_TIM_Base_Stop(&tim1); //停止定时器
HAL_TIM_Base_DeInit(&tim1); //释放
}
}
if(__HAL_TIM_GET_FLAG(&tim2, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
U1_Printf("定时器 2 定时时间:%drn",time2++);
}
if(__HAL_TIM_GET_FLAG(&tim3, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
U1_Printf("定时器 3 定时时间:%drn",time3++);
}
if(__HAL_TIM_GET_FLAG(&tim4, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
U1_Printf("定时器 4 定时时间:%drn",time4++);
}
}
}

三、解释：定时器初始化后 立刻产生的更新事件 是哪里来的

哪里来的更新事件：

来源于HAL_TIM_Base_Init(&tim1); 初始化定时器基础配置函数中 TIM_Base_SetConfig 函数中的最后一行： TIMx->EGR = TIM_EGR_UG; 这里HAL库人为的 更新了一下EGR寄存器的Ug位，也就是事件产生寄存器为1。

为什么要在初始化的时候更新一下事件：

原因是因为 定时器中的 PSC 和重复计数器Rep（这个是高级定时器才有）
只有在一次更新事件之后才会彻底写入（影子寄存器）
ARR虽然也有影子寄存器。但是他不管是在关闭还是开启的状态下，只要设置就能直接转正（写入）。

如何避免复位后直接产生更新事件?

在Start之前，手动清除UIF位

四、HAL库：TIM1234中断方式 基础定时

在轮询基础上，配置和开启了中断。
这里需要大概知道 需要定义 定时器的更新回调函数
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
notion image
注意开启定时器使用挂it方式的就ok ..
然后在对应的中断函数中处理就ok

程序

time.c

五、HAL库：TIM1234 DMA单次方式 改变定时时间

1. 如何做到改变定时时间

更新DMA事件可以改变ARR重载值，从而改变基础定时时间

2. 实验现象

DMA单次方式，传输4次数据，改变定时时间：第一次定时1s，第二次定时2s，第三次定时3s，第四次定时4s第五次定时5s，然后以后一直都是5s

3. 注意

  1. DMA有半完成回调 和 完成回调
      • 其中完成回调，和定时器更新回调的函数是一个函数
      • 所以，如果要使用更新中断和DMA完成中断，则需要判断一下。
        • 方法：通过判断DMA的状态，如果为Busy，则说明是更新中断进入的 定时器更新回调函数
  1. DMA方式的定时器并不会开启更新中断，所以要手动打开更新中断
  1. DMA使用数 要注意通道的重复使用。避免重复。
  1. LinkDMA时，第二个参数的 外设句柄内的一个DMA句柄指针（可以理解为通道绑定），可以在这里直接看到他的所有成员。在用时，可以这样用
      • __HAL_LINKDMA(&tim1, hdma[TIM_DMA_ID_UPDATE], &tim1_dmaup);
      • / 判断DMA是否为Ready状态，如果是则是DMA完成中断进入的回调函数 / if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
      notion image
      notion image
  1. DMA在Link TIM和DMA的某通道之后，可以直接在TIM中找到通道的配置总控结构体

4. 相关函数

  • TIM_HandleTypeDef 定时器总控结构体
  • DMA_HandleTypeDef DMA总控结构体
  • __HAL_TIM_CLEAR_FLAG 清除标志位
  • __HAL_TIM_ENABLE_IT 使能中断
  • HAL_TIM_Base_Start_DMA DMA方式启动定时器
  • __HAL_LINKDMA DMA LINK

4. 程序

time.c

#include "stm32f1xx_hal.h"
#include "time.h"
TIM_HandleTypeDef tim1; //（高级）定时器1总控结构体
TIM_HandleTypeDef tim2;
TIM_HandleTypeDef tim3;
TIM_HandleTypeDef tim4;
DMA_HandleTypeDef tim1_dmaup;
DMA_HandleTypeDef tim2_dmaup;
DMA_HandleTypeDef tim3_dmaup;
DMA_HandleTypeDef tim4_dmaup;
uint16_t tim1_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim2_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim3_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim4_dmaBuff[4] = {20000, 30000, 40000, 50000};
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动 清除 定时器 更新事件
__HAL_TIM_ENABLE_IT(&tim1, TIM1_UP_IRQn); //手动 使能 定时器 更新中断
HAL_TIM_Base_Start_DMA(&tim1, (uint32_t*)tim1_dmaBuff, 4); //打开定时器（DMA方式）
}
//定时器 2
void Timer2_Init(uint16_t arr, uint16_t psc)
{
tim2.Instance = TIM2;
tim2.Init.Period = arr;
tim2.Init.Prescaler = psc;
tim2.Init.CounterMode = TIM_COUNTERMODE_UP;
tim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim2);
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim2, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim2, (uint32_t*)tim2_dmaBuff, 4);
}
//定时器 3
void Timer3_Init(uint16_t arr, uint16_t psc)
{
tim3.Instance = TIM3;
tim3.Init.Period = arr;
tim3.Init.Prescaler = psc;
tim3.Init.CounterMode = TIM_COUNTERMODE_UP;
tim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim3);
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim3, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim3, (uint32_t*)tim3_dmaBuff, 4);
}
//定时器 4
void Timer4_Init(uint16_t arr, uint16_t psc)
{
tim4.Instance = TIM4;
tim4.Init.Period = arr;
tim4.Init.Prescaler = psc;
tim4.Init.CounterMode = TIM_COUNTERMODE_UP;
tim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim4);
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim4, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim4, (uint32_t*)tim4_dmaBuff, 4);
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE(); //使能时钟
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM1_UP_IRQn, 3, 0); //配置、打开 更新中断
HAL_NVIC_EnableIRQ(TIM1_UP_IRQn);
/ DMA配置 /
tim1_dmaup.Instance = DMA1_Channel5;
tim1_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
tim1_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
tim1_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
tim1_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
tim1_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim1_dmaup.Init.Mode = DMA_NORMAL; //单次模式
tim1_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim1, hdma[TIM_DMA_ID_UPDATE], tim1_dmaup);
HAL_DMA_Init(&tim1_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM2_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM2_IRQn);
/ DMA配置 /
tim2_dmaup.Instance = DMA1_Channel2;
tim2_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
tim2_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
tim2_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
tim2_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
tim2_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim2_dmaup.Init.Mode = DMA_NORMAL; //单次模式
tim2_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim2, hdma[TIM_DMA_ID_UPDATE], tim2_dmaup);
HAL_DMA_Init(&tim2_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM3_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM3_IRQn);
/ DMA配置 /
tim3_dmaup.Instance = DMA1_Channel3;
tim3_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
tim3_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
tim3_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
tim3_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
tim3_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim3_dmaup.Init.Mode = DMA_NORMAL; //单次模式
tim3_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim3, hdma[TIM_DMA_ID_UPDATE], tim3_dmaup);
HAL_DMA_Init(&tim3_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_ENABLE();
__HAL_RCC_DMA1_CLK_ENABLE();
HAL_NVIC_SetPriority(TIM4_IRQn, 3, 0);
HAL_NVIC_EnableIRQ(TIM4_IRQn);
/ DMA配置 /
tim4_dmaup.Instance = DMA1_Channel7;
tim4_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH; //存储区到外设
tim4_dmaup.Init.MemInc = DMA_MINC_ENABLE; //存储区递增
tim4_dmaup.Init.PeriphInc = DMA_PINC_DISABLE; //外设不递增
tim4_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD; //半字 2字节
tim4_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim4_dmaup.Init.Mode = DMA_NORMAL; //单次模式
tim4_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim4, hdma[TIM_DMA_ID_UPDATE], tim4_dmaup);
HAL_DMA_Init(&tim4_dmaup);
HAL_NVIC_SetPriority(DMA1_Channel7_IRQn, 3, 0); //配置、打开 通道5的中断
HAL_NVIC_EnableIRQ(DMA1_Channel7_IRQn);
}
}
//定时器 硬件 De 回调函数
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_DISABLE();
}else if(htim->Instance == TIM2){
__HAL_RCC_TIM2_CLK_DISABLE();
}else if(htim->Instance == TIM3){
__HAL_RCC_TIM3_CLK_DISABLE();
}else if(htim->Instance == TIM4){
__HAL_RCC_TIM4_CLK_DISABLE();
}
}
//更新中断 回调函数(同时也是DMA完成的回调函数)
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
/ 判断DMA是否为Ready状态，如果是则是DMA完成中断进入的回调函数 /
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA1 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 1 定时时间:%drn",time1++);
if(time1 >= 6){ //大于等于6 则关闭
U1_Printf("定时器1 关闭rn");
HAL_TIM_Base_Stop_DMA(htim);
HAL_TIM_Base_DeInit(htim);
}
}
}else if(htim->Instance == TIM2){
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA2 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 2 定时时间:%drn",time2++);
if(time2 >= 6){ //大于等于6 则关闭
U1_Printf("定时器2 关闭rn");
HAL_TIM_Base_Stop_DMA(htim);
HAL_TIM_Base_DeInit(htim);
}
}
}else if(htim->Instance == TIM3){
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA3 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 3 定时时间:%drn",time3++);
if(time3 >= 6){ //大于等于6 则关闭
U1_Printf("定时器3 关闭rn");
HAL_TIM_Base_Stop_DMA(htim);
HAL_TIM_Base_DeInit(htim);
}
}
}else if(htim->Instance == TIM4){
if(htim->hdma[TIM_DMA_ID_UPDATE]->State == HAL_DMA_STATE_READY){
U1_Printf("DMA4 完成中断rn");
HAL_DMA_DeInit(htim->hdma[TIM_DMA_ID_UPDATE]); //关闭DMA
}else{
U1_Printf("定时器 4 定时时间:%drn",time4++);
if(time4 >= 6){ //大于等于6 则关闭
U1_Printf("定时器4 关闭rn");
HAL_TIM_Base_Stop_DMA(htim);
HAL_TIM_Base_DeInit(htim);
}
}
}
}
//DMA 半完成回调函数
void HAL_TIM_PeriodElapsedHalfCpltCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
U1_Printf("定时器 1 DMA半完成中断rn");
}else if(htim->Instance == TIM2){
U1_Printf("定时器 2 DMA半完成中断rn");
}else if(htim->Instance == TIM3){
U1_Printf("定时器 3 DMA半完成中断rn");
}else if(htim->Instance == TIM4){
U1_Printf("定时器 4 DMA半完成中断rn");
}
}

time.h

#ifndef __TIME_H
#define __TIME_H
#include "uart.h"
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
extern DMA_HandleTypeDef tim1_dmaup;
extern DMA_HandleTypeDef tim2_dmaup;
extern DMA_HandleTypeDef tim3_dmaup;
extern DMA_HandleTypeDef tim4_dmaup;
/ 初始化函数 /
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep);
void Timer2_Init(uint16_t arr, uint16_t psc);
void Timer3_Init(uint16_t arr, uint16_t psc);
void Timer4_Init(uint16_t arr, uint16_t psc);
#endif

stm32f1xx_it.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
#include "time.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
uart1.RxCounter += (U1_RX_MAX - __HAL_DMA_GET_COUNTER(&uart1.dmarx));
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx));
HAL_UART_AbortReceive_IT(&uart2.uart);
}
}
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx));
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}
void DMA1_Channel4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmatx);
}
//void DMA1_Channel5_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart1.dmarx);
//}
//void DMA1_Channel7_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart2.dmatx);
//}
void DMA1_Channel6_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmarx);
}
//void DMA1_Channel2_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmatx);
//}
//void DMA1_Channel3_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmarx);
//}
void DMA1_Channel5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim1_dmaup);
}
void DMA1_Channel2_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim2_dmaup);
}
void DMA1_Channel3_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim3_dmaup);
}
void DMA1_Channel7_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim4_dmaup);
}
void TIM1_UP_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim1);
}
void TIM2_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim2);
}
void TIM3_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim3);
}
void TIM4_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim4);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
#include "time.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
Timer1_Init(10000 - 1, 7200 - 1, 1 - 1); // 72000000/7200/10000 = 1s
Timer2_Init(10000 - 1, 7200 - 1); // 1s
Timer3_Init(10000 - 1, 7200 - 1); // 1s
Timer4_Init(10000 - 1, 7200 - 1); // 1s
// uint16_t time1 = 0;
// uint16_t time2 = 0;
// uint16_t time3 = 0;
// uint16_t time4 = 0;
while(1){
/ 获取更新标志位 /
// if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); ///清除标志位
// U1_Printf("定时器 1 定时时间:%drn",time1++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim2, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
// U1_Printf("定时器 2 定时时间:%drn",time2++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim3, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
// U1_Printf("定时器 3 定时时间:%drn",time3++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim4, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
// U1_Printf("定时器 4 定时时间:%drn",time4++);
// }
}
}

六、HAL库：TIM1234 DMA循环方式 改变定时时间

1. 实验现象

DMA循环方式，传输4次*n数据，改变定时时间：第一次定时1s（初始化），第二次定时2s，第三次定时3s，第四次定时4s第五次定时5s，然后第六次 2s，第七次3s，第八次4s，第、九次5s，第十次2s

2. 如何判断DMA中断还是更新中断*

  1. 上一小节所说：DMA有半完成回调 和 完成回调
      • 其中完成回调，和定时器更新回调的函数是一个函数
      • 所以，如果要使用更新中断和DMA完成中断，则需要判断一下。
        • 方法：通过判断DMA的状态，如果为Busy，则说明是更新中断进入的 定时器更新回调函数
  1. 那么在这一节是行不通的，因为DMA一直在循环模式，一直处于BUSY状态，所以不能判断了。但是 DMA的半完成中断和完成中断，在进入回调函数之前 就会把定时器设置成Ready状态，而定时器更新中断 并不会设置定时器的状态为Ready。
      • 所以，着急需要判断定时器的更新中断，就可以判断这次中断是更新中断还是 DMA的中断。
      • 并且，判断过后，需要把定时器状态重新赋值为 BUSY， 这样是为了防止更新中断在进入时，仍然进入DMA完成的分支
      代码节选
//更新中断 回调函数(同时也是DMA完成的回调函数)
uint16_t time1 = 1;
uint16_t time2 = 1;
uint16_t time3 = 1;
uint16_t time4 = 1;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
/ 判断TIM是否为Ready状态，如果是 则是DMA完成中断进入的回调函数 /
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA1 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 1 定时时间:%drn",time1++);
}
}else if(htim->Instance == TIM2){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA2 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 2 定时时间:%drn",time2++);
}
}else if(htim->Instance == TIM3){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA3 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 3 定时时间:%drn",time3++);
}
}else if(htim->Instance == TIM4){
if(htim->State == HAL_DMA_STATE_READY){
U1_Printf("DMA4 完成中断rn");
htim->State = HAL_TIM_STATE_BUSY; //设置定时器 BUSY状态
}else{
U1_Printf("定时器 4 定时时间:%drn",time4++);
}
}
}

4. 相关函数

  • TIM_HandleTypeDef 定时器总控结构体
  • DMA_HandleTypeDef DMA总控结构体
  • __HAL_TIM_CLEAR_FLAG 清除标志位
  • __HAL_TIM_ENABLE_IT 使能中断
  • HAL_TIM_Base_Start_DMA DMA方式启动定时器
  • __HAL_LINKDMA DMA LINK
/ DMA配置 /
tim4_dmaup.Instance = DMA1_Channel7;
tim4_dmaup.Init.Direction = DMA_MEMORY_TO_PERIPH;
tim4_dmaup.Init.MemInc = DMA_MINC_ENABLE;
tim4_dmaup.Init.PeriphInc = DMA_PINC_DISABLE;
tim4_dmaup.Init.MemDataAlignment = DMA_MDATAALIGN_HALFWORD;
tim4_dmaup.Init.PeriphDataAlignment = DMA_PDATAALIGN_HALFWORD;
tim4_dmaup.Init.Mode = DMA_CIRCULAR; //循环模式
tim4_dmaup.Init.Priority = DMA_PRIORITY_MEDIUM;
__HAL_LINKDMA(&tim4, hdma[TIM_DMA_ID_UPDATE], tim4_dmaup);
HAL_DMA_Init(&tim4_dmaup);

4. 程序

time.c

#include "stm32f1xx_hal.h"
#include "time.h"
TIM_HandleTypeDef tim1; //（高级）定时器1总控结构体
TIM_HandleTypeDef tim2;
TIM_HandleTypeDef tim3;
TIM_HandleTypeDef tim4;
DMA_HandleTypeDef tim1_dmaup;
DMA_HandleTypeDef tim2_dmaup;
DMA_HandleTypeDef tim3_dmaup;
DMA_HandleTypeDef tim4_dmaup;
uint16_t tim1_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim2_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim3_dmaBuff[4] = {20000, 30000, 40000, 50000};
uint16_t tim4_dmaBuff[4] = {20000, 30000, 40000, 50000};
//定时器 1
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep)
{
tim1.Instance = TIM1; // 实例
tim1.Init.Period = arr; // 重装载值
tim1.Init.Prescaler = psc; // 分频系数
tim1.Init.CounterMode = TIM_COUNTERMODE_UP; // 计数模式
tim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; // 分频因子
tim1.Init.RepetitionCounter = rep; // 重复计数值
tim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;// 自动重装载值 预装载使能位（影子寄存器）
HAL_TIM_Base_Init(&tim1); //初始化定时器
__HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); //手动 清除 定时器 更新事件
__HAL_TIM_ENABLE_IT(&tim1, TIM1_UP_IRQn); //手动 使能 定时器 更新中断
HAL_TIM_Base_Start_DMA(&tim1, (uint32_t*)tim1_dmaBuff, 4); //打开定时器（DMA方式）
}
//定时器 2
void Timer2_Init(uint16_t arr, uint16_t psc)
{
tim2.Instance = TIM2;
tim2.Init.Period = arr;
tim2.Init.Prescaler = psc;
tim2.Init.CounterMode = TIM_COUNTERMODE_UP;
tim2.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim2.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim2);
__HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim2, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim2, (uint32_t*)tim2_dmaBuff, 4);
}
//定时器 3
void Timer3_Init(uint16_t arr, uint16_t psc)
{
tim3.Instance = TIM3;
tim3.Init.Period = arr;
tim3.Init.Prescaler = psc;
tim3.Init.CounterMode = TIM_COUNTERMODE_UP;
tim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim3);
__HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim3, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim3, (uint32_t*)tim3_dmaBuff, 4);
}
//定时器 4
void Timer4_Init(uint16_t arr, uint16_t psc)
{
tim4.Instance = TIM4;
tim4.Init.Period = arr;
tim4.Init.Prescaler = psc;
tim4.Init.CounterMode = TIM_COUNTERMODE_UP;
tim4.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
tim4.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
HAL_TIM_Base_Init(&tim4);
__HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
__HAL_TIM_ENABLE_IT(&tim4, TIM1_UP_IRQn);
HAL_TIM_Base_Start_DMA(&tim4, (uint32_t*)tim4_dmaBuff, 4);
}
//定时器 硬件初始化回调函数
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM1){
__HAL_RCC_TIM1_CLK_ENABLE(); //使能时钟
__HAL_RCC_DMA1_CLK_ENABLE();

time.h

#ifndef __TIME_H
#define __TIME_H
#include "uart.h"
/ 对外声明总控结构体 /
extern TIM_HandleTypeDef tim1;
extern TIM_HandleTypeDef tim2;
extern TIM_HandleTypeDef tim3;
extern TIM_HandleTypeDef tim4;
extern DMA_HandleTypeDef tim1_dmaup;
extern DMA_HandleTypeDef tim2_dmaup;
extern DMA_HandleTypeDef tim3_dmaup;
extern DMA_HandleTypeDef tim4_dmaup;
/ 初始化函数 /
void Timer1_Init(uint16_t arr, uint16_t psc, uint8_t rep);
void Timer2_Init(uint16_t arr, uint16_t psc);
void Timer3_Init(uint16_t arr, uint16_t psc);
void Timer4_Init(uint16_t arr, uint16_t psc);
#endif

stm32f1xx_it.c

/-------------------------------------------------/
/ /
/ 实现各种中断服务函数的源文件 /
/ /
/-------------------------------------------------/
#include "stm32f1xx_hal.h"
#include "stm32f1xx_it.h"
#include "uart.h"
#include "time.h"
void EXTI15_10_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_14);
}
void EXTI0_IRQHandler(void)
{
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void USART1_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart1.uart);
if(__HAL_UART_GET_FLAG(&uart1.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart1.uart);
uart1.RxCounter += (U1_RX_MAX - __HAL_DMA_GET_COUNTER(&uart1.dmarx));
HAL_UART_AbortReceive_IT(&uart1.uart);
}
}
void USART2_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart2.uart);
if(__HAL_UART_GET_FLAG(&uart2.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart2.uart);
uart2.RxCounter += (U2_RX_MAX - __HAL_DMA_GET_COUNTER(&uart2.dmarx));
HAL_UART_AbortReceive_IT(&uart2.uart);
}
}
void USART3_IRQHandler(void)
{
HAL_UART_IRQHandler(&uart3.uart);
if(__HAL_UART_GET_FLAG(&uart3.uart, UART_FLAG_IDLE)){
__HAL_UART_CLEAR_IDLEFLAG(&uart3.uart);
uart3.RxCounter += (U3_RX_MAX - __HAL_DMA_GET_COUNTER(&uart3.dmarx));
HAL_UART_AbortReceive_IT(&uart3.uart);
}
}
void DMA1_Channel4_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart1.dmatx);
}
//void DMA1_Channel5_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart1.dmarx);
//}
//void DMA1_Channel7_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart2.dmatx);
//}
void DMA1_Channel6_IRQHandler(void)
{
HAL_DMA_IRQHandler(&uart2.dmarx);
}
//void DMA1_Channel2_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmatx);
//}
//void DMA1_Channel3_IRQHandler(void)
//{
// HAL_DMA_IRQHandler(&uart3.dmarx);
//}
void DMA1_Channel5_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim1_dmaup);
}
void DMA1_Channel2_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim2_dmaup);
}
void DMA1_Channel3_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim3_dmaup);
}
void DMA1_Channel7_IRQHandler(void)
{
HAL_DMA_IRQHandler(&tim4_dmaup);
}
void TIM1_UP_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim1);
}
void TIM2_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim2);
}
void TIM3_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim3);
}
void TIM4_IRQHandler(void)
{
HAL_TIM_IRQHandler(&tim4);
}
/-------------------------------------------------/
/函数名：不可屏蔽中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void NMI_Handler(void)
{
}
/-------------------------------------------------/
/函数名：硬件出错后进入的中断处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void HardFault_Handler(void)
{
}
/-------------------------------------------------/
/函数名：软中断，SWI 指令调用的处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SVC_Handler(void)
{
}
/-------------------------------------------------/
/函数名：可挂起的系统服务处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void PendSV_Handler(void)
{
}
/-------------------------------------------------/
/函数名：SysTic系统嘀嗒定时器处理函数 /
/参 数：无 /
/返回值：无 /
/-------------------------------------------------/
void SysTick_Handler(void)
{
HAL_IncTick();
}

main.c

#include "stm32f1xx_hal.h"
#include "rcc.h"
#include "led.h"
#include "sw.h"
#include "uart.h"
#include "time.h"
int main(void){
HAL_Init();
RccClock_Init();
U1_Init(921600);
Timer1_Init(10000 - 1, 7200 - 1, 1 - 1); // 72000000/7200/10000 = 1s
Timer2_Init(10000 - 1, 7200 - 1); // 1s
Timer3_Init(10000 - 1, 7200 - 1); // 1s
Timer4_Init(10000 - 1, 7200 - 1); // 1s
// uint16_t time1 = 0;
// uint16_t time2 = 0;
// uint16_t time3 = 0;
// uint16_t time4 = 0;
while(1){
/ 获取更新标志位 /
// if(__HAL_TIM_GET_FLAG(&tim1, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim1, TIM_FLAG_UPDATE); ///清除标志位
// U1_Printf("定时器 1 定时时间:%drn",time1++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim2, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim2, TIM_FLAG_UPDATE);
// U1_Printf("定时器 2 定时时间:%drn",time2++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim3, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim3, TIM_FLAG_UPDATE);
// U1_Printf("定时器 3 定时时间:%drn",time3++);
// }
//
// if(__HAL_TIM_GET_FLAG(&tim4, TIM_FLAG_UPDATE)){
// __HAL_TIM_CLEAR_FLAG(&tim4, TIM_FLAG_UPDATE);
// U1_Printf("定时器 4 定时时间:%drn",time4++);
// }
}
}
]]> <![CDATA[Python学习]]> https://www.mcoi.top/article/Post-Python-study https://www.mcoi.top/article/Post-Python-study Tue, 22 Oct 2024 00:00:00 GMT
😀
一个简单的开头,潜学一下，让我能看懂python

一、Python基础语法

在python中，变量是没有类型的，变量存储的数据是有类型的
可以把变量当做一个存放物品的盒子

一、字面量

字面量：在代码中，被写下来的 固定的值

python中常见的值的类型

notion image
)

二、注释

三、变量

变量：在程序运行时，能储存计算结果 或 能表示值的抽象概念简单的说，
变量就是在程序运行时，记录数据用的
  1. print
      • 可以通过 ， 输出多个变量
  1. type()
      • 返回 变量类型
  1. 数据类型转换
      • str()
      • float()
      • int()
      • 任何内容都可以转换为字符串
      • 字符串要转换为int或float类型，需要确保字符串中的内容只有数字

四、标识符

  1. 标识符命名：只能出现 英文中文数字下划线
      • 不推荐使用中文
      • 数字不能作为开头
  1. 标识符大小写敏感
  1. 不可占用关键字
      2. notion image

五、运算符

  1. 算数运算符
      2. notion image
  1. 赋值运算符
      2. =
  1. 复合赋值运算符
      2. notion image

六、字符串扩展

1. 字符串的定义

在Python中支持三种字符串的定义
  1. 单引号定义法: name = ‘你好’
  1. 双引号定义法: name = “”你好””
  1. 三引号定义法: name = “””你好”””
      • 三引号定义法，和多行注释的写法一样，同样支持换行操作.
      • 使用变量接收它，它就是字符串
      • 不使用变量接收它，就可以作为多行注释使用，
  1. 要定义的字符串本身，是包含:单引号、双引号自身
      • 单引号定义法，可以内含双引号
      • 双引号定义法，可以内含单引号
      • 可以使用转移字符()来将引号解除效用，变成普通字符串

2. 字符串的拼接

使用 +
但无法和非字符串类型拼接

3. 字符串格式化

  1. 占位型拼接
      2. 多个变量占位
      变量要用括号括起来
      并按照占位的顺序填入
      % 为占位符
      s 将变量变为字符串类型，放入占位的地方
  1. 通过语法：f"内容{变量}"的格式来快速格式化
      • 不关心精度问题，适合对精度没有要求的场合
      • 不会理会类型

4. 字符串格式化的精度控制

我们可以使用辅助符号"m.n"来控制数据的宽度和精度
  • m，控制宽度，要求是数字(很少使用),设置的宽度小于数字自身，不生效
  • .n，控制小数点精度，要求是数字，会进行小数的四舍五入
示例:
  • %5d： 表示将整数的宽度控制在5位，如数字1，被设置为5d，就会变成：[空格][空格][空格]111，用三个空格补足宽度。
  • %5.2f：表示将宽度控制为5，将小数点精度设置为2
      • 小数点和小数部分也算入宽度计算。如，对11.345设置了%7.2f后，结果是:[空格][空格]11.35。2个空格补足宽度，小数部分限制2位精度后，四舍五入为.35

5.表达式的格式化

以上四条都是对变量的格式化
下面是对表达式的格式化

七、数据输入

input()
input输入的数据，统统为字符串类型

八、布尔类型和比较运算符

  1. 布尔类型
      • xxx = True
      • xxx = Flase
  1. 比较运算符 返回值为布尔类型
      • ==
      • !=
        • <
            =
        • <=

    九、if语句

    基本格式

    if判断的注意事项：

    • 判断条件的结果一定要是布尔类型
    • 不要忘记判断条件后的:
    • 冒号归属于if语句的代码块，要需在前方填充4个空格缩进(python 通过缩进来判断代码块的归属关系)
    • elif可以写多个
    • 判断是互斥且有序的上一个满足后面的就不会判断了
    • 可以在条件判断中，直接写input语句，节省代码量
    • 判断语句是可以嵌套的

    十、while循环

    格式

    注意事项

    • 条件需提供布尔类型结果，True继续，False停止
    • 空格缩进不能忘
    • 请规划好循环终止条件，否则将无限循环3
    • While可嵌套

    十一、for循环

    把待处理的数据集按顺序赋给临时变量。然后执行代码。直到赋完，
    • 语法中的: 待处理数据集，严格来说，称之为: 序列类型
    • 序列类型指，其内容可以一个个依次取出的一种类型，包括:
      • 字符串
      • 列表
      • 元组
      • 等
    for循环语句，本质上是遍历: 序列类型。

    range语句

    1. 语法一
        • range（num）
        • 获取一个从0开始，到num结束的数字序列(不含num本身)
        • 如range(5)取得的数据是:[0,1,2,3,4]
    1. 语法二
        • range(num1，num2)
        • 获得一个从num1开始，到num2结束的数字序列(不含num2本身)
        • 如，range(5,10)取得的数据是:[5,6,7,8,9]
    1. 语法三:
        • range(num1,num2,step)
        • 获得一个从num1开始，到num2结束的数字序列(不含num2本身)
    数字之间的步长，以step为准(step默认为1)
    • 如，range(5,10,2)取得的数据是:[5,7,9]

    基础语法格式

    for循环的注意点

    • 无法定义循环条件，只能被动取出数据处理
    • 要注意，循环内的语句，需要有空格缩进
    • for循环也可以嵌套

    for循环临时变量作用域

    1. for循环中的临时变量，其作用域限定为循环内
    1. 这种限定是编程规范的限定，而非强制限定
        2. 不遵守也能正常运行，但是不建议这样做
        如需访问临时变量，可以预先在循环外定义它

    十二、continue和break

    continue，退出当前循环
    break退出循环
    他们可用在while 和 for中
    注意：只能在作用在当层，无法对上层循环作用

    十三、一些其他的小东西

    关键字：random
    用法：
    函数：len
    用法：

    二、Python的五种容器和函数

    一、函数介绍

    函数:是组织好的，可重复使用的，用来实现特定功能的代码段。
    好处：
    • 将功能封装在函数内，可供随时随地重复利用
    • 提高代码的复用性，减少重复代码，提高开发效率
     

    二、函数的定义

    • 参数 和 返回值可以 省略
    • 函数需要先定义后调用函数
    • 形参（函数声明时用的）和实参（传入的参数）
    • 函数不管写不写return ，本质都是有返回值的，若不写，则默认返回None
    • 函数可以嵌套调用
    • 函数中的变量为局部变量
    注意：
    • return后的代码部分不会执行
    • 注意加：号
     

    三、列表

    1. 数据容器介绍

    数据容器：一种可以容纳多份数据的数据类型，容纳的每一份数据称之为1个元素
    每一个元素，可以是任意类型的数据，如字符串、数字、布尔等，并且允许重复元素的存在，可以增删查改等…
    数据容器根据特点的不同：
    • 是否支持重复元素
    • 是否可以修改
    • 是否有序，等分为5类，
      • 分别是 : 列表(list)、
      • 元组(tuple)、
      • 字符串(str)、
      • 集合(set)、
      • 字典(dict)

    2. 列表的定义

    列表中的每个数据，都叫元素
    • 列表支持嵌套，如：
    列表的两个元素都是列表

    3. 列表可以通过下标索引

    索引可以是正向，也可以反向
    用法：
    对于嵌套了列表的列表：在后面再进行索引就行。name_list[1][2]
    • 列表的注意事项：
    注意下标索引的范围不要超出元素的最大值（- 1 ）
     

    4. 引入：方法

    1. 调用类中的方法
        2.  

    5. 列表的方法

    • 查找指定元素在列表的下标。如果找不到，报错ValueError!
    • 语法：列表.index(元素)
    1. 对某下标的元素重新赋值
        • 语法：列表[] = xxx
    1. 插入元素
        • 在指定的下标位置，插入指定的元素，后面的元素往后排
        • 语法：列表.insert(下标, xxx)
    1. 追加元素（1）
        • 将指定元素，追加到列表尾部
        • 语法：列表.append(元素)
    1. 追加元素（2）
        • 将其他容器的内容取出，依次 追加到列表尾部
        • 语法：列表.extend(其他数据容器)3
    1. 删除元素
        • 语法1： 列表.pop(下标)
        • 语法2：del 列表[下标]
    1. 删除元素
        • 删除某元素在列表中的第一个匹配项
        • 语法：列表.remove(元素)
    1. 清空列表
        • 语法：列表.clear(列表)
    1. 统计元素在列表中的数量
        • 语法：列表.count(元素)
    1. 统计元素的数量
        • 语法：len(列表)

    6. 列表的循环遍历

    遍历：把容器内的数据依次取出，并处理。又叫迭代
    while循环和for循环，都是循环语句，但细节不同:
    在循环控制上:
    • while循环可以自定循环条件，并自行控制
    • for循环不可以自定循环条件，只可以一个个从容器内取出数据
    在无限循环上:
    • while循环可以通过条件控制做到无限循环
    • for循环理论上不可以，因为被遍历的容器容量不是无限的
    在使用场景上:
    • while循环适用于任何想要循环的场景
    • for循环适用于，遍历数据容器的场景或简单的固定次数循环场景
     

    四、元组

    1. 介绍

    元组和列表的最大不同！
    元组一旦定义完成，就不可修改

    2.元组的定义

    元组定义: 定义元组使用小括号，且使用逗号隔开各个数据，数据可以是不同的数据类型。
    定义的注意事项：
    • 定义1个元素的元组必须带有逗号，否则不是元组类型

      3. 元组的常用操作方法

      1. index()
          • 查找某个数据，如果数据存在返回对应的下标，否则报错
          • 语法：元组.index（查找的元素）
          • 返回查找的元素的下标
      1. count()
          • 统计某个数据在当前元组出现的次数
          • 语法：元组.count（要统计的元素）
          • 返回这个元素的个数
      1. len(元组)
          • 统计元组内的元素个数
          • 语法：len(元组)
          • 返回元素个数
       

      4. 元组的特点

      • 可以容纳多个数据
      • 可以容纳不同类型的数据(混装)
      • 数据是有序存储的(下标索引)
      • 允许重复数据存在
      • 不可以修改(增加或删除元素等)
      • 支持for循环
      • 元素中如果有列表，可以修改元组的元素中的列表的内部元素

      五、字符串

      1. 介绍

      字符串时字符的容器，一个字符串可以存放任意数量的字符
      • 和其他容器一样，字符串也是支持下标的
      • 字符串不可以 修改 移出 或者追加
      • 字符串可以 查找、和替换

      2. 字符串的常用操作方法

      1. 字符串的替换
          • 语法：字符串.replace(字符串1，字符串2)
          • 功能：将字符串内的全部:字符串1替换为字符串2
          • 注意：是局部替换，但是要注意，这个返回值是一个新的字符串，不是在老字符串上进行修改
      1. 字符串的分割
          • 语法：字符串.split(分隔符字符串)
          • 功能：按照指定的分隔符字符串，将字符串划分为多个字符串，并存入列表对象中
          • 注意：字符串本身不变，而是得到了一个列表对象
          • 示例：
        1. 字符串的规整操作
          1. 去除前后空格
              • 语法：字符串.strip()
              • 示例：
            1. 去除前后指定字符串
                • 语法：字符串.strip(字符串)
                • 注意：传入“12”，的意思是，‘’1‘和‘’2’‘都会移出，是按照单个字符
                • 示例：
            1. 统计字符串中某个字符出现的次数
                • 统计某个数据在当前元组出现的次数
                • 语法：字符串.count（要统计的元素）
                • 返回这个元素的个数
            1. 统计字符串的长度
                • 统计元组内的元素个数
                • 语法：len(字符串)
                • 返回元素个数

            3. 字符串的特点

            • 只可以存储字符串
            • 长度任意(取决于内存大小)
            • 支持下标索引
            • 允许重复字符串存在
            • 不可以修改(增加或删除元素等)
            • 支持for循环

            六、数据容器（序列）的切片操作

            1. 什么是序列

            • 序列是指：内容连续、有序，可使用下标索引的一类数据容器
            • 列表、元组、字符串，均可以可以视为序列

            2. 序列的常用操作

            序列支持切片，即：列表、元组、字符串，均支持进行切片操作
            切片：从一个序列中，取出一个子序列
            语法：序列[起始下标:结束下标:步长]
            表示从序列中，从指定位置开始，依次取出元素，到指定位置结束，得到一个新序列：
            • 起始下标表示从何处开始，可以留空，留空视作从头开始
            • 结束下标(不含)表示何处结束，可以留空，留空视作截取到结尾
            • 步长表示，依次取元素的间隔
              • 步长1表示，一个个取元素
              • 步长2表示，每次跳过1个元素取
              • 步长N表示，每次跳过N-1个元素取
              • 步长为负数表示，反向取 (注意，起始下标和结束下标也要反向标记)
            切片不会影响序列本身，而是得到一个新的序列
            起始和结束的下标也能不写，默认为从头到尾。步长也可以不写，默认为1
            范围为 左闭右开
            可以这样用my_str[::-1][9:14]

            七、集合

            1. 集合的介绍：

            • 集合 set
            • 集合会去重，不能重复
            • 集合内容是无序的（所以不支持下标索引访问）

            2. 集合的定义

            集合 set

            3. 集合的一些方法

            1. 添加新元素
                • 语法：集合.add(元素)
            1. 移出元素
                • 语法：集合.remove(元素)
            1. 随机取出一个元素
                • 语法：集合.pop()
                • 注意：真 取出来了，原本的集合没了
              1. 清空集合
                  • 语法：集合.clear()
              2. 取出2个集合的差集
                  • 语法：集合1.difference(集合2)
                  • 功能：取出集合1和集合2的差集.，集合1有 而 集合2没有的
                  • 结果：得到一个新集合，集合1和集合2不变
              3. 消除2个集合的差集
                  • 语法：集合1.difference_update(集合2)
                  • 功能：对比集合1和集合2，在集合1内，删除和集合2相同的元素。
                  • 结果：集合1被修改，集合2不变
              4. 2个集合合并
                  • 语法：集合1.unior(集合2)
                  • 功能：将集合1和集合2组合成新集合
                  • 结果：得到新集合，集合1和集合2不变
              5. 统计集合元素的数量
                  • 语法：len(集合)
              6. 集合的遍历
                  • 集合不支持下标索引，所以不支持 while循环
                  • 集合支持for循环

            4. 集合的特点

            • 可以容纳多个数据
            • 可以容纳不同类型的数据(混装)
            • 数据是无序存储的(不支持下标索引)
            • 不允许重复数据存在
            • 可以修改(增加或删除元素等)
            • 支持for循环

            八、字典

            通过字典，可以实现用key 取出 value的操作

            1. 字典的定义

            字典中存储的元素 叫 ： 键值对
            • 字典不允许重复，新的会把老的覆盖掉
            • 字典不允许下标索引
            • 字典的key不允许为字典，value 不受限制，可以嵌套字典

            2. 字典的常用操作

            1. 新增元素
                • 语法：字典[Key] = Value
                • 结果：字典被修改，新增了元素
            1. 更新元素
                • 语法：字典[Key] = Value
                • 结果：字典被修改，元素被更新
                • 注意：字典key不可以重复，如果key已经有了，再执行就是更新元素
            1. 删除元素
                • 语法：字典.pop(key)
                • 结果：获得指定key的value，同时字典被修改，指定key的数据被删除
            1. 清空元素
                • 语法：字典.clear()
            1. 获取全部的Key
                • 语法：字典.keys()
            1. 统计字典内的元素数量
                • 语法：len(字典)
            1. 遍历字典
                • 通过获取全部的key来遍历字典
                  • 直接对字典进行for循环，每次循环都是直接得到key

                3.字典的特点

                • 可以容纳多个数据
                • 可以容纳不同类型的数据
                • 每一份数据是KeyValue键值对
                • 可以通过Key获取到Value，Ktv不可重复(重复会覆盖)
                • 不支持下标索引
                • 可以修改(增加或删除更新元素等)
                • 支持for循环，
                • 不支持while循环

                九、五种容器总结

                1. 容器的分类

                分类
                元组
                集合
                字典
                字符串
                列表
                元素数量
                支持多个
                支持多个
                支持多个
                支持多个
                支持多个
                元素类型
                任意
                任意
                Key: Value Key: 除字典外任意类型 Value: 任意类型
                仅字符
                任意
                下标索引
                支持
                不支持
                不支持
                支持
                支持
                重复元素
                支持
                不支持
                不支持
                支持
                支持
                可修改性
                不支持
                支持
                支持
                不支持
                支持
                数据有序
                是
                否
                否
                是
                是
                使用场景
                不可修改、可重复的一批数据记录场景
                不可重复的数据记录场景
                以 Key 检索 Value 的数据记录场景
                一串字符的记录场景
                可修改、可重复的一批数据记录场景
                • 五类容器都支持for循环
                • 集合和字典不支持while循环

                2. 容器的通用操作

                通用统计功能
                1. len(容器)
                    • 统计元素个数
                1. max(容器)
                    • 统计容器的最大元素
                1. min(容器)
                    • 统计容器的最小元素
                通用转换功能
                • 注意字典在转换为非字符串的时候，会丢失value
                1. list(容器)
                    • 将给定容器转换为列表
                1. str(容器)
                    • 将给定容器转换为字符串
                1. tuple(容器)
                    • 将给定容器转换为元组
                1. set(容器)
                    • 将给定容器转换为集合
                通用排序功能
                1. sorted(容器,[reverse=True])
                    • 将给定容器进行排序
                    • 注意：会放到列表中，字典在排序的时候会丢失value
                💡
                欢迎您在底部评论区留言，一起交流~
                ]]>                                 <![CDATA[ESP8266模块学习]]> https://www.mcoi.top/article/Post-ESP8266 https://www.mcoi.top/article/Post-ESP8266 Fri, 02 Aug 2024 00:00:00 GMT
                😀
                Hi，这是我学习绘制F1最小系统板的笔记。

                ESP8266烧录

                1. AT固件可重官网下载：http://wiki.ai-thinker.com/esp8266/sdk 
                1. 使用flash_download_tool软件烧录
                1. 选择AT固件，后面地址填0x00000 注意前面必须打上勾
                引脚－接法 GND－GND VCC－3v3 EN(CH-PD)－VCC GPIO0－GND RXD－TXD TXD－RXD
                选择40MHZ、QIO、其他默认
                选择端口号烧录
                测试：发送AT、回复OK就可

                ESP8266模块 AT指令学习笔记

                零、简介

                感谢百文网韦东山 老师对ESP8266模块的讲解
                笔记在CSDN也有文章备份
                大家可以在我的gitee仓库 中下载笔记源文件、ESP8266资料等
                笔记源文件可以在Notion中导入

                一、ESP8266-01S模块详细介绍

                1. 名字的由来

                • ESP8266 是方形的主控芯片
                • 旁边的长方形是一个Flash
                • -01S 是用来区分基于ESP8266芯片做成的型号（种类）
                • 也能称ESP8266-01S为ESP-01S
                 

                2. 引脚定义

                notion image
                单片机常用连接方式
                notion image

                3. 与ESP826601对比

                notion image
                1. ESP8266-01
                    • 两个灯，一个为电源，一个为串口信号灯（有串口发送会一闪一闪的）
                    • 在接线时还需要把4引脚拉高（官方建议再接个电阻）
                1. ESP8266-01S
                    • 一个灯，但为信号灯
                    • 正面有ESP-01S的丝印
                    • 背面有引脚名称的丝印
                    • 在接线时只需要RX、TX、GND和3V3接好就OK了

                二、AT指令简介

                全程AT command set，AT 是 Attention的缩写。
                出自Dennis Hayes，为海斯智能300所开发的一种命令语言。
                可以使用指令集 与 设备进行沟通

                三、AT指令注意事项

                注意事项
                • 不是每条 AT 指令都具备上述 4 种类型的命令。
                • 括号内为缺省值，不必填写或者可能不显示。
                • 使⽤双引号表示字符串数据 ”string”，例如：AT+CWSAP="ESP756290","21030826",1,4
                • 默认波特率为 115200。
                • AT 指令必须⼤写，并且以回⻋换⾏符结尾（CR LF）。
                • 对于认识的指令，他会作出处理并返回OK
                • 对于不认识的指令，他会返回ERROR！
                • 指令必须全部大写（其实AT可以小写），
                • 指令必须以\r\n结尾（否则ESP8266会认为是一条指令，直到\r\n换行）
                  • CR (Carriage Return) 表示回车
                  • LF (Line Feed) 表示换行
                  • Dos和Windows采用回车+换行(CR+LF)表示下一行
                  • 而UNIX/Linux采用换行符:(LF)表示下一行
                  • MAC OS系统采用回车符(CR)表示下一行
                  • 所以 Windows下编写的Shell脚本，直接放到linux/unix下执行会报错，就是因为行结束符不一样导致的。
                  • \r为回车 \n为换行
                • ESP8266默认的波特率为115200
                例如
                • 串口发送：AT ，那么会收到OK
                • 发送AT+RST ，ESP8266会重置，并打印日志，最后输出Ready
                AT指令详情参考《ESP8266 Non-OS SDK AT 指令集_V3.0.1.pdf》

                四、AT指令的分类和提示信息

                1. 四种类型

                AT指令可以细分为四种类型
                1. 测试指令
                    • 该命令用于该命令用于查询设置指令的参数以及取值范围
                    • 指令格式：AT+<x>=?
                1. 查询指令
                    • 该命令用于返回参数的当前值。
                    • 指令格式：AT+<x>?
                1. 设置指令
                    • 该命令用于设置用户自定义的参数值。
                    • 指令格式：AT+<x>=<…>
                1. 执行指令
                    • 该命令用于执行受模块内部程序控制的参数不可变的功能，
                    • 指令格式：AT+<x>

                2. 简单测试

                例如可以使用测试指令查看取值列表、查询指令查询当前模式是什么、设置指令设置当前模式。
                notion image
                串口工具测试发送如下
                notion image

                3. CUR与DEF

                附录A：
                AT指令有一部分分为保存到Flash和不保存到Flash 显然，保存到Flash的下次开机仍会保持，而临时的则在下次掉电 或 重启后恢复原状 保存到Falash的指令会在手册的附录中列出（大部分的指令都有后缀DEF，是definite 明确的 的缩写。） 那么临时改变的话，后缀就是CUR（是current 当前的 的缩写） 如果不加后缀，那么默认是保存在Flash中的，即带DEF后缀 例如AT+CWMODE=3（AT+CWMODE_DEF=3）

                4. 提示信息

                附录B：
                提示信息
                说明
                ready
                AT 固件成功启动
                ERROR
                指令输入错误，或者指令执行出错
                WIFI CONNECTED
                ESP8266 station 连接到 AP
                WIFI GOT IP
                ESP8266 station 获取到 IP 地址
                WIFI DISCONNECT
                ESP8266 station 的 WiFi 连接断开
                busy s...
                busy sending，表示系统正在发送数据的过程中，无法响应当前输入
                busy p...
                busy processing，表示系统正在处理前一条指令，无法响应当前输入
                <conn_id>,CONNECT
                建立了 <conn_id> 号网络连接
                <conn_id>,CLOSED
                <conn_id> 号网络连接断开
                +IPD
                接收到网络数据
                +STA_CONNECTED:<sta_mac>
                有 station 连入 ESP8266 softAP
                +DIST_STA_IP:<sta_mac>,<sta_ip>
                ESP8266 softAP 给连入的 station 分配 IP 地址
                +STA_DISCONNECTED:<sta_mac>
                station 从 ESP8266 softAP 断开连接

                五、使用AT指令的简单方法

                使用AT指令的大概步骤：
                • 打开AT文档
                • 找到指令所在的位置
                • 查看指令说明
                  • 指令类型
                  • 相应信息
                  • 注意事项
                  • 参数说明
                  • 指令示例

                六、AT指令应用示例

                以下示例，均来自乐鑫官方的《ESP8266 AT 指令使⽤示例.pdf》文档

                1. TCP 单连接 Client

                1. 配置 WiFi 模式：
                    • 使用命令 “AT+CWMODE=3”，设置为可连可被连模式。
                    • 响应：OK。
                1. 连接路由器（热点）：
                    • 使用命令 “AT+CWJAP="SSID","password"”（其中 SSID 是 wifi 名称，后者为密码）。
                    • 响应：OK。
                1. 查询 ESP8266 设备的 IP 地址：
                    • 使用命令 “AT+CIFSR”。
                    • 响应：
                  1. PC 与 ESP8266 设备连接同一路由器，在 PC 端使用网络调试工具，建立一个 TCP 服务器。
                      • 假设 PC 创建的服务器 IP 地址为 192.168.3.116，端口为 8080。
                        • 这里使用了网络调试工具，监听PC端所处的网关
                  1. ESP8266 设备作为 TCP client 连接到上述服务器：
                      • 使用命令 “AT+CIPSTART="TCP","192.168.3.116",8080” （protocol、server IP 和 port）（协议、IP地址、端口）。
                      • 响应：OK。
                  1. ESP8266 设备向服务器发送数据：
                      • 使用命令 “AT+CIPSEND=4”（设置要发送的数据长度，例如 4 字节）。
                      • 输入 1234”（输入数据，无回车符）。
                      • 响应：Recv 4 bytes  SEND OK。
                  1. 当 ESP8266 设备接收到服务器发来的数据，将提示如下信息：
                      • “+IPD,n:xxxxxxxxxx”
                      • n指接收到的字节，后面的xx为接收到的数据
                      • 例如 默认这里的3，指的是接收到3字节（因为发送时有\r\n换行回车，他们各占一个字节）（中文每个占2字节）

                    2. UDP 传输_固定远端的UDP通信

                    基础配置：
                    1. 配置 WiFi 模式： AT+CWMODE=1
                    1. 连接路由器（热点）：AT+CWJAP="SSID","password
                    1. 查询 ESP8266 设备的 IP 地址： AT+CIFSR
                    UDP 通信步骤：
                    UDP 通信远端固定规则：AT+CIPSTART 指令的最后一个参数设置为 0 决定UDP通信为远端固定 。系统会分配一个连接号给这个固定连接，UDP 通信双方不会被其他设备替代。
                    假设，PC 创建的 UDP ⾃身 IP 地址为 192.168.118.168，端⼝为 25563
                    1. 使能多连接：AT+CIPMUX=1。
                        • 多连接模式 (AT+CIPMUX=1) 时，设置指令： AT+CIPSTART=<link ID>,<type>,<remote IP>,<remote port>[,(<UDP local port>)，(<UDP mode>)]
                        • <link ID>：⽹络连接 ID (0 ~ 4)，⽤于多连接的情况 • <type>：字符串参数，连接类型，"TCP"，"UDP"或"SSL" • <remote IP>：远端 IP 地址，字符串参数 • <remote port>：远端端⼝号 • [<UDP local port>]：UDP 传输时，设置本地端⼝ • [<UDP mode>]：UDP 传输的属性，若透传，则必须为 0 ‣ 0：收到数据后，不更改远端⽬标，默认值为 0 ‣ 1：收到数据后，改变⼀次远端⽬标 ‣ 2：收到数据后，改变远端⽬标
                    1. 创建 UDP 传输，例如连接号为 4 的指令为 AT+CIPSTART=4,"UDP","192.168.118.168",25563,9090,0 响应为 4,CONNNECT 和 OK。
                        2. 参数说明如下：
                        • "192.168.118.168", 25563为 UDP 传输的远端 IP 和端⼝，即前⽂中 PC 建⽴的 UDP 端⼝；
                        • 9090为 ESP8266 本地的 UDP 端⼝，⽤户可⾃⾏设置，如不设置则为随机值；
                        • 0 表示当前 UDP 传输建⽴后，UDP 远端不会被其他设备更改；即使有其他设备通过 UDP 协议发数据到
                        ESP8266 UDP 端⼝ 1112，ESP8266 的第 4 号 UDP 传输的远端也不会被替换，使⽤指令
                        “AT+CIPSEND=4, X” 发送数据，仍然是当前固定的 PC 端收到。
                    1. 发送数据：AT+CIPSEND=4,7，输入 “UDPtest”，响应为 Recv 7 bytes 和 SEND OK。
                    1. 接收数据时，ESP8266 设备会提示 “+IPD,4,n:xxxxxxxxxx”
                    1. 断开 UDP 传输：AT+CIPCLOSE=4，响应为 4,CLOSED 和 OK。
                    notion image

                    3. UDP 传输_远端可变的UDP通信

                    基础配置：
                    1. 配置 WiFi 模式： AT+CWMODE=1
                    1. 连接路由器（热点）：AT+CWJAP="SSID","password
                    1. 查询 ESP8266 设备的 IP 地址： AT+CIFSR
                    UDP 通信远端可改变的情况：当使用 AT+CIPSTART 指令创建 UDP 通信，将最后一个参数设置为 2 时，UDP 通信的远端可改变。
                    UDP 通信步骤：
                    （这里不需要使能多连接）
                    1. 创建 UDP 传输：AT+CIPSTART="UDP","192.168.118.168",25563,9090,2，响应为 CONNNECT 和 OK。
                    1. 发送数据：AT+CIPSEND=7，输入 “UDPtest”，响应为 Recv 7 bytes 和 SEND OK。 （这里不需要再和AT+CIPSEND=4,7一样，指定网络连接ID）
                    1. 发送数据到其他指定远端，例如发数据到 192.168.118.168，端口25563：AT+CIPSEND=7," 192.168.118.168",25563，输入 “UDPtest”，响应为 Recv 7 bytes 和 SEND OK。
                    参数说明：192.168.118.168",25563为 UDP 传输的远端 IP 和端口；9090为 ESP8266 本地的 UDP 端口，用户可自行设置，如不设置则为随机值；2 表示当前 UDP 传输建立后，UDP 传输远端会自动更改为最近一个与 ESP8266 UDP 通信的远端。
                    注意事项：发送数据时，如果输入的字节数超过了设置长度（n），系统将提示 busy，并发送数据的前 n 个字节，发送完成后响应 SEND OK，超出长度的部分数据被认为是无效数据，不被接受。
                    接收数据时，ESP8266 设备会提示 “+IPD,n:xxxxxxxxxx”
                    1. 断开 UDP 传输：AT+CIPCLOSE，响应为 CLOSED 和 OK。

                    4. TCP 单连接 透传

                    • 透传 就是 透明传输就是在传输过程中，对外界透明，就是说你看不见他是传送网络，不管传输的业务如何，我只负责将需要传送的业务传送到目的节点，相当于一条数据线或者串口线，同时保证传输的质量即可，而不对传输的业务进行处理。
                    • ESP8266 AT 默认仅在 TCP client 单连接或 UDP 传输模式时，⽀持透传。
                    一、ESP8266 透传功能概述
                    • ESP8266 可作为 station 实现 TCP client 单连接透传，作为 softAP 也可同理实现透传。
                    二、配置步骤
                    1. 配置 WiFi 模式：
                        • 指令：AT+CWMODE=3，设置为 softAP+station 模式。
                        • 响应：OK。
                    1. 连接路由器：
                        • 指令：AT+CWJAP="SSID","password"，输入路由器的 SSID 和密码。
                        • 响应：OK。
                    1. 查询 IP 地址：
                        • 指令：AT+CIFSR。
                        • 响应：显示 APIP、APMAC、STAIP、STAMAC 等信息，如 +CIFSR:APIP,"192.168.4.1"、+CIFSR:APMAC,"1a:fe:34:a5:8d:c6"、+CIFSR:STAIP,"192.168.3.133"、+CIFSR:STAMAC,"18:fe:34:a5:8d:c6"。
                        • 响应：OK。
                    1. PC 端操作与连接：
                        • PC 与 ESP8266 设备连接同一路由器，在 PC 端使用网络调试工具，建立一个 TCP 服务器。假设 PC 创建的服务器 IP 地址为 192.168.3.116，端口为 8080。
                    1. ESP8266 作为 TCP client 连接服务器：
                        • 指令：AT+CIPSTART="TCP","192.168.3.116",8080，指定协议、服务器 IP 和端口。
                        • 响应：OK。
                    1. 使能透传模式：
                        • 指令：AT+CIPMODE=1。
                        • 响应：OK。
                        • 注意（此设置不保存到flash，透传模式传输时，如果连接断开，ESP8266 会不停尝试重连，此时单独输入 +++ 退出透传，则停止重连;普通传输模式则不会重连，提示连接断开。）
                    1. ESP8266 设备向服务器发送数据：
                        • 指令：AT+CIPSEND。
                        • 响应：>，表示从此时起，从 UART 接收的数据将自动传输到服务器。
                        • 注意：每次发送（每包）最大2048个字节，或者每包20ms间隔区分
                    1. 退出发送数据：
                        • 在透传发送数据过程中，若识别到单独的一包数据 “+++”，则退出透传发送。 建议使用串口工具一次性发送 “+++”，且不要携带空格或换行符等不可见字符。 之后，至少间隔 1 秒，再发下一条 AT 指令。
                    1. 退出透传模式：
                        • 指令：AT+CIPMODE=0。
                        • 响应：OK。
                    1. 断开 TCP 连接：
                    • 指令：AT+CIPCLOSE。
                    • 响应：CLOSED、OK。

                    5. UDP 透传

                    一、ESP8266 UDP 透传功能概述
                    • ESP8266 作为 softAP 可实现 UDP 透传，作为 station 同理可实现。
                    二、配置步骤
                    1. 配置 WiFi 模式：
                        • 指令：AT+CIMODE=3，设置为 softAP+station 模式。
                        • 响应：OK（假设此处应有 OK 响应）。
                    1. PC 连入 ESP8266 softAP：无特定指令，在 PC 上选择 ESP8266 的无线网络连接。
                        • 模块和PC接入同局域网也可
                    1. PC 端建立 UDP 传输：
                        • 在 PC 端使用网络调试工具，建立一个 UDP 传输。假设 PC 创建的 UDP 自身 IP 地址为 192.168.4.2，端口为 1001。
                    1. ESP8266 建立 UDP 传输：
                        • 指令：AT+CIPSTART="UDP", "192.168.4.2",1081,2233,0。
                        • 响应：OK（假设此处应有 OK 响应）。
                    1. 使能透传模式：
                        • 指令：AT+CIPMODE=1。
                        • 响应：OK。
                    1. ESP8266 设备向服务器发送数据：
                        • 指令：AT+CIPSEND。
                        • 响应：>，表示从此时起，从 UART 接收的数据将自动传输到服务器。
                        • 注意：发送数据时，如果输入的字节数超过了设置长度 (n)，系统将提示 busy，并发送数据的前 n 个字节，发送完成后响应 SEND OK。超出长度的部分数据被认为是无效数据，不被接受。
                    1. 退出发送数据：
                        • 在透传发送数据过程中，若识别到单独的一包数据 “+++”，则退出透传发送。建议使用串口工具一次性发送 “+++”，且不要携带空格或换行符等不可见字符。之后，至少间隔 1 秒，再发下一条 AT 指令。
                        • 注意：“+++” 退出透传发送数据，回到正常 AT 指令模式。此时，TCP 连接仍然是保持的，可以再发 AT+CIPSEND 指令，重新开始透传。
                    1. 退出透传模式：
                        • 指令：AT+CIPMODE=0。
                        • 响应：OK。
                    1. 断开 UTP 连接：
                        • 指令：AT+CIPCLOSE。
                        • 响应：CLOSED、OK。

                    6. 多连接 TCP Server

                    一、ESP8266 多连接 TCP Server 功能概述
                    • ESP8266 AT 仅支持建立一个 TCP 服务器，且必须使能多连接，允许连接多个 TCP client。ESP8266 作为 softAP 可建立 TCP 服务器，作为 station 在连接路由后同理可建立服务器。
                    二、配置步骤
                    1. 配置 WiFi 模式：
                        • 指令：AT+CWMODE=3，设置为 softAP+station 模式。
                        • 响应：OK（假设此处应有 OK 响应）。
                    1. 使能多连接：
                        • AT+CIPMUX=1
                        notion image
                        • 响应：OK。
                    1. 建立 TCP server：
                        • 指令：AT+CIPSERVER=1（默认端口为 333）。
                        • （AT+CIPSERVER=<mode>[,<port>]）
                        • 响应：OK。
                    1. PC 连入 ESP8266 softAP：无特定指令，在 PC 上选择 ESP8266 的无线网络连接。
                        • 模块和PC接入同局域网也可
                    1. PC 端建立多个 TCP client 连接 ESP8266 的 TCP server：在 PC 端使用网络调试工具建立一个 TCP client，连接 ESP8266 的 TCP server。
                    1. 如果要显示端口和IP可以使能这个
                        2. notion image
                    1. 断开链接
                        2. AT+CIPCLOSE=1
                        notion image
                    注意：
                    ESP8266 作为 TCP server 有超时机制，如果连接建⽴后，⼀段时间内⽆数据来往，ESP8266 TCP server 会将 TCP client 踢掉。因此，请在 PC TCP client 连上 ESP8266 TCP server 后建⽴⼀个 2s 的循环数据发送，⽤于保持连接。
                    notion image
                     
                    💡
                    其他的问题，欢迎在底部评论区留言，一起交流~
                     
                    ]]>                                         <![CDATA[在KickPi K2B开发板部署Sherpa-ONNX框架+关键词识别+语音识别+语音合成模型]]> https://www.mcoi.top/article/Post-KickPi2B-Sherpa-ONNX https://www.mcoi.top/article/Post-KickPi2B-Sherpa-ONNX Mon, 17 Nov 2025 00:00:00 GMT
                    😀
                    本文主要是记录在Arm64架构的KickPi K2B开发板上，Sherpa-ONNX离线语音处理框架的部署与语音识别、语音合成、关键词唤醒模型的测试。 目前仅实现了利用官方部署好的静态库实现 离线语音转文字。 后续会实现语音合成、关键词识别 并且用其开发工具和C语言来实现demo

                    目录

                    目录核心概念说明所需资料下载1. 语音处理框架（Sherpa-ONNX）2. 核心模型下载语音识别（语音转文字）简单部署与测试1. 框架解压与目录说明2. 语音识别模型解压3. 关键参数与设备配置4. 语音识别执行命令语音合成（文字转语音）简单部署与测试1.前置准备(工具与模型校验)2. 核心操作：从设备配置到语音合成步骤 1：查询音频输出设备（关键！）步骤 2：执行语音合成命令3、结果验证：确认合成成功关键词检测（KWS）的完整部署与测试1. 前置准备：工具与模型校验2. 自定义关键词配置3. 核心操作：从设备配置到实时检测4. 结果验证与解读基于C语言的Sherpa-ONNX框架集成与大模型调用1.置准备：依赖库安装与适配2.代码架构解析：模块化封装思路3.核心逻辑拆解：整个项目的运行逻辑代码参考（部分我已加注释）1. ALSA 音频设备驱动封装（录音核心）2. ALSA 音频重采样模块（格式适配核心）3. Sherpa-ONNX 模型调用asr模型（推理核心）4. 主程序（模块整合与业务流程）5. Makefile：编译脚本（嵌入式编译配置）6. Sherpa-ONNX 模型调用kws模型（推理核心）

                    核心概念说明

                    本次使用的是Sherpa-ONNX这一基于 ONNX 的离线语音处理框架，下面先理清几个核心概念，再详细说明在 KickPi K2B 开发板上的部署与测试流程。
                    1. 大模型与推理引擎的关系：若把大模型比作电影，推理引擎就是播放器。两者相辅相成，缺少任何一方都无法实现语音处理功能，Sherpa-ONNX 在此扮演的就是推理引擎的角色。
                    1. ONNX 格式：ONNX 是通用的大模型格式，除此之外，常见的大模型格式还有 PyTorch、TensorFlow 等，而 Sherpa-ONNX 正是依托 ONNX 运行时实现高效语音处理。
                    1. Sherpa-ONNX 核心介绍Sherpa-ONNX 是基于 ONNX 运行时的开源语音处理库，设计理念是提供灵活、易用且高性能的语音处理解决方案，其核心特性如下：
                      1. 多功能支持：涵盖语音识别、语音合成、说话人识别、语言识别、音频标签、语音活动检测（VAD）和关键词检测等多种语音任务。
                      2. 跨平台兼容：可运行于 Windows、macOS、Linux 等桌面系统，也适配 Android、iOS 移动平台，同时支持 Raspberry Pi、RISC-V 架构等嵌入式设备，完美匹配 KickPi K2B 的 Arm64 架构。
                      3. 多语言 API：提供 C++、C、Python 等十余种编程语言接口，本次实践选用 C 语言进行开发适配。
                      4. 离线运行：无需网络连接即可工作，契合嵌入式场景对隐私和安全性的需求。

                    所需资料下载

                     
                    本次开发针对 KickPi K2B（Arm64 架构），需下载框架程序库和对应语音模型，所有资源均来自 Sherpa-ONNX 官方 GitHub 仓库，具体清单如下：

                    1. 语音处理框架（Sherpa-ONNX）

                    从Sherpa-ONNX Github Releases下载适配 KickPi K2B（Arm64 架构）的预编译包，下载以下三个版本：
                    • 静态库版本（sherpa-onnx-v1.12.17-linux-aarch64-static.tar.bz2）：打包所有依赖，无需额外系统库，适合测试场景。
                    • 指令集优化版本（sherpa-onnx-v1.12.17-linux-aarch64-jni.tar.bz2）：支持 ARM NEON 指令集，推理速度更快，适配现代 Arm64 开发板。
                    • 动态链接版本（sherpa-onnx-v1.12.17-linux-aarch64-shared-cpu.tar.bz2）：文件体积小，适合动态链接到其他程序，需依赖系统预装 C++ 运行库。包含的是.so动态库和依赖动态库的可执行程序。

                    2. 核心模型下载

                    语音识别（语音转文字）简单部署与测试

                    1. 框架解压与目录说明

                    将下载的 Sherpa-ONNX 预编译包解压至开发板，进入解压后的bin目录，可看到各类可执行文件（如sherpa-onnx-offline-tts用于文本转语音、sherpa-onnx-alsa用于对接音频设备的语音识别）。

                    2. 语音识别模型解压

                    将下载的语音识别模型解压至开发板，进入解压后的目录，可看到encoder/decoder/joiner的模型核心组件，还有tokens指定词汇表文件。这些东西都与后期在框架中的参数输入有关。

                    3. 关键参数与设备配置

                    进入Sherpa框架的bin文件，核心就是使用sherpa-onnx-alsa工具实现语音识别，首先需要直到麦克风设备，通过命令查看麦克风设备：
                    输出结果中，例如我的 USB 麦克风对应设备号为card 2，设备标识为hw:2,0（可能随重启变化，需重新查询确认）。

                    4. 语音识别执行命令

                    在bin目录下输入./sherpa - onnx - alsa可查看工具帮助文档 这里我的目录结构是这个
                    notion image
                    各核心参数说明如下：
                    参数
                    tokens
                    encoder
                    decoder
                    joiner
                    provider
                    <td>指定推理硬件</td>
                    <td>因开发板硬件限制，此处选择cpu</td>
                    </tr>
                    <tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    <td>num-threads</td>
                    <td>设置线程数</td>
                    <td>配置为 2，平衡性能与资源占用</td>
                    </tr>
                    <tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    <td>decoding-method</td>
                    <td>指定解码方式</td>
                    <td>选用greedy_search（贪心搜索），兼顾效率与识别准确率</td>
                    </tr>
                    <tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    <td>device_name</td>
                    <td>指定音频输入设备</td>
                    <td>即麦克风设备标识，需通过指令查询确定例如我的参数为hw:2,0</td>
                    </tr>
                    </table>
                    经过一系列的加载，当看到开始录音，请说话时，就代表成功了。

                    语音合成（文字转语音）简单部署与测试

                    语音合成（TTS）功能可将文本直接转换为可听语音，本次基于 Sherpa-ONNX 框架的 sherpa-onnx-offline-tts-play-alsa 工具实现 —— 该工具支持直接对接开发板音频输出设备，无需额外播放软件，适配嵌入式场景的轻量化需求。

                    1.前置准备(工具与模型校验)

                    在执行操作前，需先确认工具可用性与模型完整性，避免后续因文件缺失或路径错误导致失败。
                    1. 确认 TTS 工具位置
                    Sherpa-ONNX 预编译包的 bin 目录中包含多个 TTS 相关工具，核心工具及用途如下：
                    工具名称
                    核心功能
                    适用场景
                    sherpa-onnx-offline-tts
                    仅将文本转换为 WAV 音频文件（需后续播放）
                    需保存语音文件的场景
                    sherpa-onnx-offline-tts-play-alsa
                    文本转语音后直接通过 ALSA 设备播放
                    实时听语音结果的测试场景
                    sherpa-onnx-offline-zeroshot-tts
                    零样本 TTS（支持自定义发音人）
                    需灵活切换发音风格的场景
                    本次选择 sherpa-onnx-offline-tts-play-alsa（实时播放），先通过以下命令确认工具可执行：
                    在执行操作前，需先确认工具可用性与模型完整性，避免后续因文件缺失或路径错误导致失败。
                    2. 校验 TTS 模型文件完整性
                    需确保已下载的 TTS 模型（vits-icefall-zh-aishell3.tar.bz2）解压后，核心文件齐全。进入模型解压目录，应包含以下文件：
                     
                    需存在的核心文件：
                    • model.onnx：VITS 架构的核心合成模型（必选）
                    • tokens.txt：文本字符映射表（定义模型可识别的汉字 / 符号，必选）
                    • lexicon.txt：词典文件（将汉字映射为拼音，解决多音字问题，必选）
                    • date.fst/number.fst 等：文本预处理规则文件（处理日期、数字的发音，如 “2025” 读作 “二千零二十五年”，必选）
                    若缺少上述文件，需重新下载并解压模型包，避免因文件缺失导致合成失败。

                    2. 核心操作：从设备配置到语音合成

                    步骤 1：查询音频输出设备（关键！）

                    语音合成需指定开发板的 “音频播放设备”，通过 aplay -l 命令查询硬件设备列表：
                    示例输出（需重点关注 card X 和 device Y）：
                     
                    • 若连接耳机 / 音箱到开发板的 3.5mm 接口，通常对应 card 0（如示例中的 audiocodec）
                    • 若通过 HDMI 输出音频，对应 card 1（ahubhdmi）
                    • 设备标识格式：hw:X,Y（X=card 编号，Y=device 编号），示例中 3.5mm 接口对应 hw:0,0

                    步骤 2：执行语音合成命令

                    在 Sherpa-ONNX 的 bin 目录下，执行以下命令（需根据自身路径和设备标识修改参数）：
                     
                    关键参数详解（修正原表述误差，补充实操细节）
                     
                    参数
                    核心作用
                    实操注意事项
                    --vits-model
                    指定 VITS 架构的核心合成模型
                    路径必须完整，若提示 “File not found”，检查路径是否包含空格（需用引号包裹）
                    --vits-tokens
                    定义模型可识别的字符（汉字、标点等）
                    不可省略，缺失会导致文本无法解析（如特殊符号可能被过滤）
                    --vits-lexicon
                    解决多音字问题（如 “行” 读 xíng 或 háng）
                    若合成语音出现读音错误，可检查此文件是否包含对应汉字的拼音映射
                    --tts-rule-fsts
                    处理特殊文本格式（日期、数字、符号）
                    例如 “2025” 会被转换为 “二千零二十五年”，缺失会导致数字读作 “二零二五”
                    <td>--vits-length-scale</td>
                    <td>控制语音速度</td>
                    <td>取值范围 0.1-3.0：0.5 = 快节奏，1.0 = 默认，1.5 = 慢节奏，根据需求调整</td>
                    </tr>
                    <tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    <td>--sid</td>
                    <td>指定发音人（音色切换）</td>
                    <td>模型支持 0-174 共 175 个发音人：0 = 男性，100 = 中性女声，150 = 儿童声（可多试 ID）</td>
                    </tr>
                    <tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    <td>--num-threads</td>
                    <td>分配的 CPU 线程数</td>
                    <td>KickPi K2B 建议 2-4 线程：线程过少会卡顿，过多会占用其他进程资源</td>
                    </tr>
                    <tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    </tr>
                    <td>--device</td>
                    <td>指定音频播放设备</td>
                    <td>必须与aplay -l查询的标识一致，否则无声音输出（常见错误：设备号填错）</td>
                    </tr>
                    </table>

                    3、结果验证：确认合成成功

                    执行命令后，通过以下现象判断是否成功：
                    1. 无报错提示：命令行未出现 “Model load failed”“Device not found” 等错误
                    1. 音频输出：连接的耳机 / 音箱能清晰听到文本对应的语音（如 “今天是 2025 年 11 月 18 日...”）
                    1. 临时文件：工具会在内存中生成临时 WAV 文件（无需手动保存），播放完成后自动清理
                    若未听到声音，按以下顺序排查：
                    1. 检查 --device 参数是否与 aplay -l 结果一致（如误填 hw:1,0 而实际用 3.5mm 接口）
                    1. 确认耳机 / 音箱已通电且音量正常（可通过 aplay test.wav 播放测试音频验证设备）
                    1. 检查模型文件是否完整（重新解压模型包，确认 model.onnx 大小是否正常，避免下载损坏）
                     

                    关键词检测（KWS）的完整部署与测试

                    关键词检测（Keyword Spotting，简称 KWS）是语音交互系统的重要组成部分，能够在持续监听的同时，快速识别特定唤醒词（如 "小爱同学"、"你好军哥"），是实现语音助手、智能设备唤醒的核心技术。本次基于 Sherpa-ONNX 框架的sherpa-onnx-keyword-spotter-alsa工具，实现在 KickPi K2B 开发板上的实时关键词检测功能。

                    1. 前置准备：工具与模型校验

                    在执行关键词检测前，需先确认工具可用性与模型完整性，确保所有依赖文件正确配置。
                    1.1 确认关键词检测工具位置
                    Sherpa-ONNX 预编译包的bin目录中包含多个 KWS 相关工具，核心工具及用途如下：
                    工具名称
                    核心功能
                    适用场景
                    sherpa-onnx-keyword-spotter
                    基础关键词检测工具（需手动输入音频文件）
                    离线批量检测场景
                    sherpa-onnx-keyword-spotter-alsa
                    对接 ALSA 音频设备的实时关键词检测
                    实时语音交互场景
                    sherpa-onnx-keyword-spotter-microphone
                    通用麦克风接口的关键词检测
                    跨平台兼容性需求场景
                    本次选择sherpa-onnx-keyword-spotter-alsa（实时 ALSA 设备支持），先通过以下命令确认工具可执行：
                    若工具正常，将显示完整的参数说明文档。
                    1.2 校验 KWS 模型文件完整性
                    需确保已下载的 KWS 模型（sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile.tar.bz2）解压后，核心文件齐全。进入模型解压目录，应包含以下文件：
                    需存在的核心文件：
                    • encoder-epoch-12-avg-2-chunk-16-left-64.onnx：编码器模型（处理音频特征提取）
                    • decoder-epoch-12-avg-2-chunk-16-left-64.onnx：解码器模型（关键词匹配）
                    • joiner-epoch-12-avg-2-chunk-16-left-64.int8.onnx：融合器模型（优化检测精度）
                    • tokens.txt：词汇表文件（定义模型可识别的语音单元）
                    • keywords.txt：关键词配置文件（定义需要检测的唤醒词）
                    • keywords_raw.txt：原始关键词文件（备用参考）
                    1.3 关键词配置文件详解
                    keywords.txt是 KWS 功能的核心配置文件，定义了系统需要识别的关键词。文件格式采用 "拼音序列 @ 关键词文本" 的结构：
                    默认配置示例：
                    格式说明：
                    • 拼音部分：每个音节用空格分隔（如 "x iǎo ài t óng x ué" 对应 "小爱同学"）
                    • @符号：分隔拼音序列和关键词文本
                    • 关键词文本：实际显示的唤醒词名称

                    2. 自定义关键词配置

                    根据实际需求，可以添加自定义关键词，扩展系统的唤醒词库。
                    2.1 添加自定义关键词
                    以添加 "小刘同学" 为例：
                    2.2 关键词配置原则
                    1. 发音清晰：选择发音清晰、不易混淆的词汇
                    1. 长度适中：建议 2-4 个汉字，过短易误触发，过长识别困难
                    1. 独特性强：避免与常用词汇过于相似
                    1. 拼音准确：确保拼音标注准确，特别是多音字

                    3. 核心操作：从设备配置到实时检测

                    3.1 查询音频输入设备
                    关键词检测需要指定麦克风设备，通过arecord -l命令查询：
                    arecord -l
                    示例输出：
                    设备标识规则：
                    • USB 麦克风通常对应card 2（如示例中的 "USB Composite Device"）
                    • 设备标识格式：hw:X,Y（X=card 编号，Y=device 编号）
                    • 示例中 USB 麦克风对应hw:2,0
                    3.2 执行关键词检测命令
                    在 Sherpa-ONNX 的bin目录下，执行以下完整命令：
                    --encoder="/root/shepa/1-关键词检测/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/encoder-epoch-12-avg-2-chunk-16-left-64.onnx" \
                    --decoder="/root/shepa/1-关键词检测/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/decoder-epoch-12-avg-2-chunk-16-left-64.onnx" \
                    --joiner="/root/shepa/1-关键词检测/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/joiner-epoch-12-avg-2-chunk-16-left-64.int8.onnx" \
                    --provider=cpu \
                    --num-threads=4 \
                    --keywords-file="/root/shepa/1-关键词检测/sherpa-onnx-kws-zipformer-wenetspeech-3.3M-2024-01-01-mobile/keywords.txt" \
                    --threshold=0.5 \
                    --min-active=0.5 \
                    hw:2,0
                    3.3 关键参数详解
                    参数
                    核心作用
                    取值建议
                    --tokens
                    指定词汇表文件
                    必须与模型配套，不可修改路径
                    --encoder
                    指定编码器模型
                    处理音频特征提取，核心组件
                    --decoder
                    指定解码器模型
                    负责关键词序列匹配
                    --joiner
                    指定融合器模型
                    优化检测精度，建议使用 int8 量化版本
                    --provider
                    指定推理硬件
                    嵌入式设备建议使用cpu
                    --num-threads
                    CPU 线程数配置
                    Arm64 架构建议 2-4 线程
                    --keywords-file
                    关键词配置文件
                    包含所有需要检测的唤醒词
                    --threshold
                    检测阈值
                    0.1-1.0，值越高误检率越低但漏检率越高
                    --min-active
                    最小激活时间
                    0.1-2.0 秒，过滤过短的检测结果
                    device_name
                    音频输入设备
                    通过arecord -l查询获取

                    4. 结果验证与解读

                    执行命令后，系统开始实时监听麦克风输入，当检测到关键词时会输出 JSON 格式的结果。
                    4.1 成功运行的标志
                    出现以上提示表示系统已开始正常监听。
                    4.2 检测结果示例
                    4.3 结果字段解读
                    字段
                    含义
                    示例说明
                    start_time
                    检测开始时间
                    相对于程序启动的时间戳
                    keyword
                    检测到的关键词
                    "小刘同学"（自定义添加的关键词）
                    timestamps
                    时间戳序列
                    每个音节的开始时间点
                    tokens
                    语音识别单元
                    对应的拼音音节序列

                    基于C语言的Sherpa-ONNX框架集成与大模型调用

                    前文已通过官方预编译工具实现了语音识别、合成与关键词检测的基础功能，但实际项目需将框架集成到自定义 C 语言程序中。本节重点讲解如何通过Sherpa-ONNX C API 封装 ALSA 录音、音频重采样与大模型调用流程，实现 “实时录音→模型推理→结果输出” 的端到端功能。

                    1.置准备：依赖库安装与适配

                    1. 前置需求
                    由于开发板麦克风采样率（如 44100Hz）与 ASR 大模型要求的16000Hz不匹配，需先安装音频重采样库libsamplerate下载指令：
                    其次就是之前下载的指令集优化版本（sherpa-onnx-v1.12.17-linux-aarch64-jni.tar.bz2），和动态链接版本（sherpa-onnx-v1.12.17-linux-aarch64-shared-cpu.tar.bz2）。这两个文件可以为我们提供所需的链接库.so和头文件include 。后续在开发和编译时，只需要将其放到/lib文件一起usr/include目录下，我们就可以完成开发（或在编译链接时-l -I -L下）。
                    1. 校验需求（路径记得换）

                    2.代码架构解析：模块化封装思路

                    代码流程参考的是这里的官方示例代码：
                    sherpa-onnx/c-api-examples/asr-microphone-example/c-api-alsa.cc at master · k2-fsa/sherpa-onnx
                    （模块对照表略）

                    3.核心逻辑拆解：整个项目的运行逻辑

                    1. 初始化ALSA（用于录音）、重采样器（用于将不同的采样频率转换为模型支持的16000HZ）、sherpa-onnx框架（用于运行模型）
                    1. 程序不断麦克风读取int16_t 格式、单声道的 PCM 数据，采样率按照实际麦克风参数不定（我的为48000HZ)
                    1. 数据输入到重采样器中，在采样器函数中，解决 “麦克风采样率≠模型要求采样率” 问题，同时将int16_t（ALSA 输出）转换为float（模型输入，范围 [-1.0, 1.0]）。然后将处理好的数据存入开辟的堆内存空间中。
                    1. 提交处理好的音频数据给sherp-onnx-C-API 加载的ASR模型等待并解码结果。
                    1. 上述过程不断循环，直到模型说明已到达端点（可以理解为断句阈值，后续有提）程序输出语音转文字结果。
                    1. 重置录音流、清除结果内存。。再开始新的一轮循环。

                    代码参考（部分我已加注释）

                    1. ALSA 音频设备驱动封装（录音核心）

                    alsa.c：
                    alsa.c说明
                    该文件是底层音频输入接口，基于 ALSA（Advanced Linux Sound Architecture）框架实现麦克风录音功能，核心解决 “嵌入式设备如何稳定获取符合格式的 PCM 音频数据” 问题。
                    • 核心定位：负责初始化录音设备、配置硬件参数（采样率、格式、声道数）、读取 int16_t 格式 PCM 数据、释放设备资源，为后续重采样和模型推理提供原始音频输入。
                    • 关键设计：
                        1. 硬件参数配置：强制使用 “单声道 + S16_LE（16 位有符号小端）” 格式，匹配 Sherpa-ONNX 模型对输入音频的要求；
                        1. 采样率适配：允许硬件返回 “最接近请求值” 的采样率（如请求 16000Hz，硬件实际支持 48000Hz），后续通过重采样统一格式；
                        1. 缓冲区周期优化：设置PERIOD_SIZE=1024（单次读取样本数），平衡嵌入式设备的 “低延迟”（实时识别需求）和 “资源占用”（避免频繁 IO）；
                        1. 错误处理：针对 ALSA 常见错误（如缓冲区过载EPIPE）做重置处理，保证录音稳定性。
                    alsa.h
                    alsa.h说明
                    该文件是ALSA 模块的对外接口契约，负责定义录音设备参数、暴露全局变量和函数声明，实现 “模块化解耦”—— 让重采样、主程序等外部模块无需关心 ALSA 内部实现，仅通过头文件调用功能。
                    • 核心定位：
                        1. 宏定义：固化录音设备关键参数（设备名RECORD_DEVICE、请求采样率RATE、周期大小PERIOD_SIZE、声道数CHANNELS），方便后续根据硬件修改；
                        1. 全局变量声明：暴露g_pcm_handle（PCM 设备句柄）和g_actual_rate（硬件实际采样率），供重采样模块获取真实采样率用于格式转换；
                        1. 函数声明：明确init_alsa()（初始化）和cleanup_alsa()（资源清理）的接口，确保外部模块调用规范。
                    • 嵌入式适配：强制CHANNELS=1（单声道），因为此嵌入式语音模型仅支持单声道输入，减少数据处理开销。

                    2. ALSA 音频重采样模块（格式适配核心）

                    mysamplerate.c
                    mysamplerate.c说明：
                    该文件是音频格式桥梁，解决 “嵌入式麦克风采样率≠模型要求采样率” 和 “数据格式不匹配” 两大问题 —— 麦克风输出 int16_t 格式（如 48000Hz），而 Sherpa-ONNX 模型需要 float 格式（16000Hz，范围 [-1.0,1.0]）。
                    • 核心定位：
                        1. 重采样初始化：基于libsamplerate库创建重采样器，计算 “目标采样率 / 实际采样率” 的转换比率，选择SRC_SINC_FASTEST模式（适合嵌入式实时场景，平衡速度与精度）；
                        1. 数据格式转换：将 ALSA 输出的 int16_t 数据归一化为 float（除以 32768，因 int16_t 最大值为 32767，避免溢出）；
                        1. 流式重采样：按帧处理音频数据，使用堆分配缓冲区（避免嵌入式栈空间不足），返回转换后的 float 数据供模型使用；
                    • 关键细节：设置MAX_OUTPUT_FRAMES=PERIOD_SIZE*3，应对 “实际采样率高于目标采样率” 时输出帧数增多的情况，避免缓冲区溢出。
                    mysamplerate.h
                    mysamplerate.h说明
                    该文件是重采样模块的对外接口，负责声明核心函数，隐藏模块内部状态（如src_state），确保外部模块（如 main.c）仅通过规范接口调用重采样功能，降低耦合度。
                    • 核心定位：
                        1. 依赖引入：包含samplerate.h（libsamplerate 库头文件）和alsa.h（获取 ALSA 配置参数）；
                        1. 函数声明：明确init_resampler()（初始化）、resample_audio()（格式转换）、cleanup_resampler()（资源清理）的参数和返回值，指导外部模块正确传参（如输入 int16_t 数据、输出 float 数据指针）；
                    • 嵌入式适配：通过alsa.h复用CHANNELS和MODEL_SAMPLE_RATE，避免参数重复定义，减少修改时的不一致风险。

                    3. Sherpa-ONNX 模型调用asr模型（推理核心）

                    sherpa-asr.c
                    sherpa-asr.c说明
                    该文件是Sherpa-ONNX 框架的 C API 封装，负责加载语音识别模型、创建推理流、配置推理参数，将 “模型调用” 封装为独立模块，让主程序无需关注 ONNX 底层细节。
                    • 核心定位：
                        1. 模型配置：设置模型路径（encoder/decoder/joiner）、线程数（num_threads=4，适配 Arm64 架构性能）、解码方法（greedy_search，嵌入式场景兼顾速度与准确率）；
                        1. 端点检测：开启enable_endpoint=1，通过三个规则（最小尾端静音、最小语音长度）判断语音结束，避免无意义推理；
                        1. 资源管理：创建g_asr_recognizer（识别器）和g_asr_stream（音频流），确保资源创建与释放顺序（先创建识别器，再创建流；释放时反之）；
                    • 关键细节：模型路径需与开发板实际路径一致（如/root/shepa/...），否则会导致模型加载失败。
                    asherpa-asr.h
                    asherpa-asr.h说明
                    该文件是Sherpa-ONNX 模块的对外接口，负责引入框架头文件、声明全局推理资源和核心函数，让主程序能获取g_asr_stream（音频流）和g_asr_recognizer（识别器），并调用初始化 / 清理函数。
                    • 核心定位：
                        1. 依赖引入：包含Sherpa-ONNX C API头文件（sherpa-onnx/c-api/c-api.h）和alsa.h（复用MODEL_SAMPLE_RATE）；
                        1. 资源暴露：声明全局变量g_asr_stream和g_asr_recognizer，供 main.c 提交音频数据和获取推理结果；
                        1. 函数声明：明确init_sherpa_asr()和cleanup_sherpa_asr()的接口，确保主程序按顺序初始化 / 清理资源。

                    4. 主程序（模块整合与业务流程）

                    main.c
                    main.c说明：
                    该文件是整个系统的入口，负责串联 ALSA 录音、音频重采样、Sherpa-ONNX 推理三大模块，实现 “实时录音→格式适配→模型推理→结果输出” 的端到端业务流程，同时处理嵌入式场景的优雅退出。
                    • 核心定位：
                        1. 模块初始化：按 “ALSA→重采样→Sherpa-ONNX” 顺序初始化（后模块依赖前模块的参数，如重采样依赖 ALSA 的实际采样率）；
                        1. 信号处理：捕获SIGINT（Ctrl+C）信号，设置running=0，实现 “触发退出后清理资源”，避免嵌入式设备因强制退出导致资源泄漏；
                        1. 主循环逻辑：
                            • 录音：从 ALSA 读取 int16_t 数据；
                            • 适配：调用重采样模块转换为 float 格式；
                            • 推理：提交数据到 Sherpa-ONNX 流，执行解码；
                            • 结果输出：检测到语音结束（端点）时，打印识别结果，重置流准备下一轮；

                    5. Makefile：编译脚本（嵌入式编译配置）

                    Makefile
                    Makefile说明
                    该文件是嵌入式编译的核心配置，负责指定编译器、头文件路径、链接库、编译规则，确保代码能在 KickPi K2B（Arm64 架构）上正确编译为可执行文件。
                    • 核心定位：
                        1. 编译选项：I指定 Sherpa-ONNX 头文件路径，Wall开启警告（便于调试），g生成调试信息（嵌入式调试用）；
                        1. 链接配置：L指定 Sherpa-ONNX 库路径，lasound（链接 ALSA 库）、lsamplerate（链接重采样库）、lsherpa-onnx-c-api（链接 Sherpa-ONNX C API 库）；
                        1. 清理规则：clean目标删除编译生成的.o文件和可执行文件，避免残留文件影响下次编译；
                      • 因为我是在嵌入式端直接编译，无需额外指定 Arm64 架构（若使用交叉编译，需添加CC=aarch64-linux-gnu-gcc），直接使用开发板自带的gcc编译，确保兼容性。
                    💡
                    有关Sherpa-ONNX在嵌入式开发板的部署或语音模型适配的问题，欢迎您在底部评论区留言，一起交流~
                    至此，我们就完成了 使用C语言 调用框架运行模型。后面的关键词识别和语音合成同理。 可以去github参考示例文件来编写程序。 关键词识别：sherpa-onnx/c-api-examples/kws-c-api.c at master · k2-fsa/sherpa-onnx 语音合成：sherpa-onnx/c-api-examples/offline-tts-c-api.c at master · k2-fsa/sherpa-onnx 思路是：先关键词唤醒，然后等待语音识别，如果识别成功则继续切换到关键词唤醒。 后续会对识别的内容进行处理（可能是接入deepseek大模型？然后tts合成语音后回复）这里我不放全部代码了。（其实稍微改改我上面的代码就能用了~ 步骤和 asr 基本一样)

                    6. Sherpa-ONNX 模型调用kws模型（推理核心）

                    sherpa-kws.c
                    asherpa-kws.h
                    现在已经可以输出结果了,我这里直接选用有名管道，来作为通信的方式，与其他的程序进行通信，就不详细演示啦~~
                    当多个进程同时对播放设备进行操作， 会导致没有权限（已打开、无法共享）的问题。 可以设置一下 混音插件，让多个设备共享。
                    ]]>                                         <![CDATA[LoRa学习]]> https://www.mcoi.top/article/Post-Lora https://www.mcoi.top/article/Post-Lora Tue, 01 Apr 2025 00:00:00 GMT
                    😀
                    之前做Lora一对多无线通信时记录的笔记，里面包含了Lora的简单配置寄存器和串口测试案例 。 不附带代码 其实Lora也支持AT指令。。。

                    LoRa学习

                    引脚定义

                    notion image
                    引脚序号
                    引脚名称
                    引脚方向
                    引脚用途
                    1
                    M0
                    输入（极弱上拉）
                    和 M1 配合， 决定模块的 4 种工作模式（不可悬空， 如不使用可接地）
                    2
                    M1
                    输入（极弱上拉）
                    和 M0 配合， 决定模块的 4 种工作模式（不可悬空， 如不使用可接地）
                    3
                    RXD
                    输入
                    TTL 串口输入， 连接到外部 TXD 输出引脚；
                    4
                    TXD
                    输出
                    TTL 串口输出， 连接到外部 RXD 输入引脚；
                    5
                    AUX
                    输出
                    用于指示模块工作状态；用户唤醒外部 MCU， 上电自检初始化期间输出低电平； （可以悬空）
                    6
                    VCC
                    电源
                    模块电源正参考， 电压范围： 2.3～5.5V DC
                    7
                    GND
                    电源
                    模块地线

                    工作模式

                    模块有四种工作模式， 由引脚 M1、 M0 设置； 详细情况如下表所示：
                    模式（0-3）
                    M1
                    M0
                    模式介绍
                    备注
                    0 传输模式
                    0
                    0
                    串口打开， 无线打开， 透明传输
                    支持特殊指令空中配置
                    1 WOR 模式
                    0
                    1
                    可以定义为 WOR 发送方和 WOR 接收方
                    支持空中唤醒
                    2 配置模式
                    1
                    0
                    用户可通过串口对寄存器进行访问， 从而控制模块工作状态
                    ㅤ
                    3 深度休眠
                    1
                    1
                    模块进入休眠
                    ㅤ

                    寄存器读写控制

                    指令格式

                    配置模式（模式 2： M1=1， M0=0） 下
                    支持的指令列表如下（设置时， 只支持 9600， 8N1 格式）
                    • 设置寄存器
                      • 指令： C0+起始地址+长度+参数
                      • 响应： C1+起始地址+长度+参数
                      • 例子： C0 05 01 09 即在 0x05 地址 依次写入一次数据 0x09
                      • 例子： C0 00 04 12 34 00 61 即在 0x00 地址 依次写入 四次数据，分别是 0x12 0x34 0x00 0x61
                    • 读取寄存器
                      • 指令： C1+起始地址+长度
                      • 响应： C1+起始地址+长度+参数
                    • 设置临时寄存器
                      • 指令： C2 +起始地址+长度+参数
                      • 响应： C1 +起始地址+长度+参数
                    • 无线配置
                      • 指令： CF CF + 常规指令
                      • 响应： CF CF + 常规响应
                      • 例 1： 无线配置信道为 0x09 无线指令头 + 指令 + 起始地址 + 长度 + 参数 发送： CF CF C0 05 01 09 返回： CF CF C1 05 01 09
                    • 格式错误
                      • 格式错误响应FF FF FF

                    寄存器地址

                    notion image

                    功能详解

                    定点发射

                    STM32 给 LoRa发送这种格式的数据
                    notion image

                    广播发射

                    notion image

                    测试

                    我们把这个LoRa模块 配置为
                    • 地址 0x00 0x01
                    • 网络地址 0x04
                    • 串口 9600 8N1
                    • 空中 2.4K
                    • 信道 0x17
                    • 定点传输
                    • 其他默认就行
                    • 那么只需要写入 C0 00 07 00 01 04 62 00 17 40
                    • C0 写入、00 起始地址、07 依次写入7次、后续为7次数据。需要根据2进制转为16进制。
                        • notion image
                    这样就代表成功了！
                    💡
                    有关Lora学习或者使用上的问题，欢迎您在底部评论区留言，一起交流~
                    ]]>                                         <![CDATA[MAX30102心率传感器]]> https://www.mcoi.top/article/Post-MAX30102 https://www.mcoi.top/article/Post-MAX30102 Thu, 06 Mar 2025 00:00:00 GMT
                    😀
                    一句简单的开头

                    模块简介

                    MAX30102是一个集成的脉搏血氧仪和心率监测仪生物传感器的模块。
                    它集成了一个红光LED和一个红外光LED、光电检测器、光器件，以及带环境光抑制的低噪声电子电路。
                    MAX30102采用一个1.8V电源和一个独立的5.0V用于内部LED的电源，应用于可穿戴设备进行心率和血氧采集检测，佩戴于手指点耳垂和手腕处。
                    标准的I2C兼容的通信接口可以将采集到的数值传输给Arduino、KL25Z、STM32、STC51等单片机进行心率和血氧计算。
                    此外，该芯片还可以通过软件关断模块，待机电流接近为零，实现电源始终维持供电状态。

                    主要参数:

                    产品名称
                    MAX30102 心率模块
                    LED峰值波长器
                    660nm/880nm
                    LED供电电压
                    3.3 ~ 5V
                    检测信号类型
                    光反射信号（PPG）
                    输出信号接口
                    I2C接口
                    通信接口电压
                    1.8 ~ 3.3V ~ 5V（可选）

                    产品尺寸：

                    notion image

                    工作原理

                    光电容积法的基本原理是利用人体组织在血管搏动时造成透光率不同来进行脉搏和血氧饱和度测量的。光源一般采用对动脉血中氧合血红蛋白(Hb02)和血红蛋自(Hb)有选择性的特定波长的发光二极管(一般选用660nm附近的红光和900nm附近的红外光)。当光束透过人体外周血管，由于动脉搏动充血容积变化导致这束光的透过光率发生改变，此时由光电变换器接收人体组织反射的光线，转变为电信号并将其放大和输出。由于脉搏是随心脏的搏动而周期性变化的信号，动脉血管容积也周期性变化，因此光电变换器的电信号变化周期就是脉搏率。同时根据血氧饱和度的定义，计算如下:
                    透光率转化为电信号：动脉搏动充血容积变化导致这束光的透光率发送改变，此时由光电变换接收经人体组织反射光线，转变为电信号并将其放大输出。
                    notion image

                    原理图及引脚说明

                    notion image
                    notion image
                    VIN
                    电源输入 1.6V-5.5V
                    3位焊盘
                    选择总线的上拉电平，取决于引脚主控电压可选1.8v或者3.3v
                    SDA
                    IIC-SDA
                    SCL
                    IIC-SCL
                    GND
                    地
                    INT
                    INT 低电平有效中断（漏极开路）MAX30102 的中断引脚
                    IRD
                    IR_DRV IR LED阴极和LED驱动器连接点 一般不接
                    RD
                    R_DRV 红色LED阴极和LED驱动器连接点 一般不接
                    芯片内部有3.3V-5.0V的LED电源和1.8V的逻辑电源，所以模块带有两路稳压电路，将5V电源分别转化为3.3V和1.8V；由于LED驱动电源的供电范围为3.3V-5.0V，3.3V稳压电路可省去。 由于MAX30102的逻辑电路的IIC通信电平为1.8V，这与我们常用的STM32单片机的引脚电平不匹配。 这里有个解决方法，因为MAX30102的SDA、SCL、INT引脚为开漏，如图
                    notion image
                    所以可以将模块上的R1、R2、R3电阻去掉，对于51单片机来说，在SDA、SCL、INT引脚上分别加一个4.7-10k电阻上拉至5V；对于STM32单片机，只需要将相应的控制引脚配置为上拉模式即可。

                    STM32软件驱动

                    官方驱动

                    IIC通信代码

                    #include "mbed.h"
                    #include "MAX30102.h"
                    I2C i2c(I2C_SDA, I2C_SCL);//SDA-PB9,SCL-PB8
                    bool maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data)
                    /
                    • brief Write a value to a MAX30102 register
                    • par Details
                    • This function writes a value to a MAX30102 register
                      • param[in] uch_addr - register address
                      • param[in] uch_data - register data
                        • retval true on success
                        */
                        {
                        char ach_i2c_data[2];
                        ach_i2c_data[0]=uch_addr;
                        ach_i2c_data[1]=uch_data;
                        if(i2c.write(I2C_WRITE_ADDR, ach_i2c_data, 2, false)==0)
                        return true;
                        else
                        return false;
                        }
                        bool maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data)
                        /
                        • brief Read a MAX30102 register
                        • par Details
                        • This function reads a MAX30102 register
                          • param[in] uch_addr - register address
                          • param[out] puch_data - pointer that stores the register data
                            • retval true on success
                            */
                            {
                            char ch_i2c_data;
                            ch_i2c_data=uch_addr;
                            if(i2c.write(I2C_WRITE_ADDR, &ch_i2c_data, 1, true)!=0)
                            return false;
                            if(i2c.read(I2C_READ_ADDR, &ch_i2c_data, 1, false)==0)
                            {
                            *puch_data=(uint8_t) ch_i2c_data;
                            return true;
                            }
                            else
                            return false;
                            }
                            bool maxim_max30102_init()
                            /
                            • brief Initialize the MAX30102
                            • par Details
                            • This function initializes the MAX30102
                              • param None
                                • retval true on success
                                */
                                {
                                if(!maxim_max30102_write_reg(REG_INTR_ENABLE_1,0xc0)) // INTR setting
                                return false;
                                if(!maxim_max30102_write_reg(REG_INTR_ENABLE_2,0x00))
                                return false;
                                if(!maxim_max30102_write_reg(REG_FIFO_WR_PTR,0x00)) //FIFO_WR_PTR[4:0]
                                return false;
                                if(!maxim_max30102_write_reg(REG_OVF_COUNTER,0x00)) //OVF_COUNTER[4:0]
                                return false;
                                if(!maxim_max30102_write_reg(REG_FIFO_RD_PTR,0x00)) //FIFO_RD_PTR[4:0]
                                return false;
                                if(!maxim_max30102_write_reg(REG_FIFO_CONFIG,0x0f)) //sample avg = 1, fifo rollover=false, fifo almost full = 17
                                return false;
                                if(!maxim_max30102_write_reg(REG_MODE_CONFIG,0x03)) //0x02 for Red only, 0x03 for SpO2 mode 0x07 multimode LED
                                return false;
                                if(!maxim_max30102_write_reg(REG_SPO2_CONFIG,0x27)) // SPO2_ADC range = 4096nA, SPO2 sample rate (100 Hz), LED pulseWidth (400uS)
                                return false;
                                if(!maxim_max30102_write_reg(REG_LED1_PA,0x24)) //Choose value for ~ 7mA for LED1
                                return false;
                                if(!maxim_max30102_write_reg(REG_LED2_PA,0x24)) // Choose value for ~ 7mA for LED2
                                return false;
                                if(!maxim_max30102_write_reg(REG_PILOT_PA,0x7f)) // Choose value for ~ 25mA for Pilot LED
                                return false;
                                return true;
                                }
                                bool maxim_max30102_read_fifo(uint32_t pun_red_led, uint32_t pun_ir_led)
                                /
                                • brief Read a set of samples from the MAX30102 FIFO register
                                • par Details
                                • This function reads a set of samples from the MAX30102 FIFO register
                                  • param[out] *pun_red_led - pointer that stores the red LED reading data
                                  • param[out] *pun_ir_led - pointer that stores the IR LED reading data
                                    • retval true on success
                                    */
                                    {
                                    uint32_t un_temp;
                                    unsigned char uch_temp;
                                    *pun_red_led=0;
                                    *pun_ir_led=0;
                                    char ach_i2c_data[6];
                                    //read and clear status register
                                    maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);
                                    maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);
                                    ach_i2c_data[0]=REG_FIFO_DATA;
                                    if(i2c.write(I2C_WRITE_ADDR, ach_i2c_data, 1, true)!=0)
                                    return false;
                                    if(i2c.read(I2C_READ_ADDR, ach_i2c_data, 6, false)!=0)
                                    {
                                    return false;
                                    }
                                    un_temp=(unsigned char) ach_i2c_data[0];
                                    un_temp<<=16;
                                    *pun_red_led+=un_temp;
                                    un_temp=(unsigned char) ach_i2c_data[1];
                                    un_temp<<=8;
                                    *pun_red_led+=un_temp;
                                    un_temp=(unsigned char) ach_i2c_data[2];
                                    *pun_red_led+=un_temp;
                                    un_temp=(unsigned char) ach_i2c_data[3];
                                    un_temp<<=16;
                                    *pun_ir_led+=un_temp;
                                    un_temp=(unsigned char) ach_i2c_data[4];
                                    un_temp<<=8;
                                    *pun_ir_led+=un_temp;
                                    un_temp=(unsigned char) ach_i2c_data[5];
                                    *pun_ir_led+=un_temp;
                                    *pun_red_led&=0x03FFFF; //Mask MSB [23:18]
                                    *pun_ir_led&=0x03FFFF; //Mask MSB [23:18]
                                    return true;
                                    }
                                    bool maxim_max30102_reset()
                                    /
                                    • brief Reset the MAX30102
                                    • par Details
                                    • This function resets the MAX30102
                                      • param None
                                        • retval true on success
                                        */
                                        {
                                        if(!maxim_max30102_write_reg(REG_MODE_CONFIG,0x40))
                                        return false;
                                        else
                                        return true;
                                        }
                                         

                                        数值转换代码

                                        #include "algorithm.h"
                                        #include "mbed.h"
                                        void maxim_heart_rate_and_oxygen_saturation(uint32_t pun_ir_buffer, int32_t n_ir_buffer_length, uint32_t pun_red_buffer, int32_t pn_spo2, int8_t pch_spo2_valid,
                                        int32_t pn_heart_rate, int8_t pch_hr_valid)
                                        /
                                        • brief Calculate the heart rate and SpO2 level
                                        • par Details
                                        • By detecting peaks of PPG cycle and corresponding AC/DC of red/infra-red signal, the ratio for the SPO2 is computed.
                                        • Since this algorithm is aiming for Arm M0/M3. formaula for SPO2 did not achieve the accuracy due to register overflow.
                                        • Thus, accurate SPO2 is precalculated and save longo uch_spo2_table[] per each ratio.
                                          • param[in] *pun_ir_buffer - IR sensor data buffer
                                          • param[in] n_ir_buffer_length - IR sensor data buffer length
                                          • param[in] *pun_red_buffer - Red sensor data buffer
                                          • param[out] *pn_spo2 - Calculated SpO2 value
                                          • param[out] *pch_spo2_valid - 1 if the calculated SpO2 value is valid
                                          • param[out] *pn_heart_rate - Calculated heart rate value
                                          • param[out] *pch_hr_valid - 1 if the calculated heart rate value is valid
                                            • retval None
                                            */
                                            {
                                            uint32_t un_ir_mean ,un_only_once ;
                                            int32_t k ,n_i_ratio_count;
                                            int32_t i, s, m, n_exact_ir_valley_locs_count ,n_middle_idx;
                                            int32_t n_th1, n_npks,n_c_min;
                                            int32_t an_ir_valley_locs[15] ;
                                            int32_t an_exact_ir_valley_locs[15] ;
                                            int32_t an_dx_peak_locs[15] ;
                                            int32_t n_peak_interval_sum;
                                            int32_t n_y_ac, n_x_ac;
                                            int32_t n_spo2_calc;
                                            int32_t n_y_dc_max, n_x_dc_max;
                                            int32_t n_y_dc_max_idx, n_x_dc_max_idx;
                                            int32_t an_ratio[5],n_ratio_average;
                                            int32_t n_nume, n_denom ;
                                            // remove DC of ir signal
                                            un_ir_mean =0;
                                            for (k=0 ; k<n_ir_buffer_length ; k++ ) un_ir_mean += pun_ir_buffer[k] ;
                                            un_ir_mean =un_ir_mean/n_ir_buffer_length ;
                                            for (k=0 ; k<n_ir_buffer_length ; k++ ) an_x[k] = pun_ir_buffer[k] - un_ir_mean ;
                                            // 4 pt Moving Average
                                            for(k=0; k< BUFFER_SIZE-MA4_SIZE; k++){
                                            n_denom= ( an_x[k]+an_x[k+1]+ an_x[k+2]+ an_x[k+3]);
                                            an_x[k]= n_denom/(int32_t)4;
                                            }
                                            // get difference of smoothed IR signal
                                            for( k=0; k<BUFFER_SIZE-MA4_SIZE-1; k++)
                                            an_dx[k]= (an_x[k+1]- an_x[k]);
                                            // 2-pt Moving Average to an_dx
                                            for(k=0; k< BUFFER_SIZE-MA4_SIZE-2; k++){
                                            an_dx[k] = ( an_dx[k]+an_dx[k+1])/2 ;
                                            }
                                            // hamming window
                                            // flip wave form so that we can detect valley with peak detector
                                            for ( i=0 ; i<BUFFER_SIZE-HAMMING_SIZE-MA4_SIZE-2 ;i++){
                                            s= 0;
                                            for( k=i; k<i+ HAMMING_SIZE ;k++){
                                            s -= an_dx[k] *auw_hamm[k-i] ;
                                            }
                                            an_dx[i]= s/ (int32_t)1146; // divide by sum of auw_hamm
                                            }
                                            n_th1=0; // threshold calculation
                                            for ( k=0 ; k<BUFFER_SIZE-HAMMING_SIZE ;k++){
                                            n_th1 += ((an_dx[k]>0)? an_dx[k] : ((int32_t)0-an_dx[k])) ;
                                            }
                                            n_th1= n_th1/ ( BUFFER_SIZE-HAMMING_SIZE);
                                            // peak location is acutally index for sharpest location of raw signal since we flipped the signal
                                            maxim_find_peaks( an_dx_peak_locs, &n_npks, an_dx, BUFFER_SIZE-HAMMING_SIZE, n_th1, 8, 5 );//peak_height, peak_distance, max_num_peaks
                                            n_peak_interval_sum =0;
                                            if (n_npks>=2){
                                            for (k=1; k<n_npks; k++)
                                            n_peak_interval_sum += (an_dx_peak_locs[k]-an_dx_peak_locs[k -1]);
                                            n_peak_interval_sum=n_peak_interval_sum/(n_npks-1);
                                            *pn_heart_rate=(int32_t)(6000/n_peak_interval_sum);// beats per minutes
                                            *pch_hr_valid = 1;
                                            }
                                            else {
                                            *pn_heart_rate = -999;
                                            *pch_hr_valid = 0;
                                            }
                                            for ( k=0 ; k<n_npks ;k++)
                                            an_ir_valley_locs[k]=an_dx_peak_locs[k]+HAMMING_SIZE/2;
                                            // raw value : RED(=y) and IR(=X)
                                            // we need to assess DC and AC value of ir and red PPG.
                                            for (k=0 ; k<n_ir_buffer_length ; k++ ) {
                                            an_x[k] = pun_ir_buffer[k] ;
                                            an_y[k] = pun_red_buffer[k] ;
                                            }
                                            // find precise min near an_ir_valley_locs
                                            n_exact_ir_valley_locs_count =0;
                                            for(k=0 ; k<n_npks ;k++){
                                            un_only_once =1;
                                            m=an_ir_valley_locs[k];
                                            n_c_min= 16777216;//2^24;
                                            if (m+5 < BUFFER_SIZE-HAMMING_SIZE && m-5 >0){
                                            for(i= m-5;i<m+5; i++)
                                            if (an_x[i]<n_c_min){
                                            if (un_only_once >0){
                                            un_only_once =0;
                                            }
                                            n_c_min= an_x[i] ;
                                            an_exact_ir_valley_locs[k]=i;
                                            }
                                            if (un_only_once ==0)
                                            n_exact_ir_valley_locs_count ++ ;
                                            }
                                            }
                                            if (n_exact_ir_valley_locs_count <2 ){
                                            *pn_spo2 = -999 ; // do not use SPO2 since signal ratio is out of range
                                            *pch_spo2_valid = 0;
                                            return;
                                            }
                                            // 4 pt MA
                                            for(k=0; k< BUFFER_SIZE-MA4_SIZE; k++){
                                            an_x[k]=( an_x[k]+an_x[k+1]+ an_x[k+2]+ an_x[k+3])/(int32_t)4;
                                            an_y[k]=( an_y[k]+an_y[k+1]+ an_y[k+2]+ an_y[k+3])/(int32_t)4;
                                            }
                                            //using an_exact_ir_valley_locs , find ir-red DC andir-red AC for SPO2 calibration ratio
                                            //finding AC/DC maximum of raw ir * red between two valley locations
                                            n_ratio_average =0;
                                            n_i_ratio_count =0;
                                            for(k=0; k< 5; k++) an_ratio[k]=0;
                                            for (k=0; k< n_exact_ir_valley_locs_count; k++){
                                            if (an_exact_ir_valley_locs[k] > BUFFER_SIZE ){
                                            *pn_spo2 = -999 ; // do not use SPO2 since valley loc is out of range
                                            *pch_spo2_valid = 0;
                                            return;
                                            }
                                            }
                                            // find max between two valley locations
                                            // and use ratio betwen AC compoent of Ir & Red and DC compoent of Ir & Red for SPO2
                                            for (k=0; k< n_exact_ir_valley_locs_count-1; k++){
                                            n_y_dc_max= -16777216 ;
                                            n_x_dc_max= - 16777216;
                                            if (an_exact_ir_valley_locs[k+1]-an_exact_ir_valley_locs[k] >10){
                                            for (i=an_exact_ir_valley_locs[k]; i< an_exact_ir_valley_locs[k+1]; i++){
                                            if (an_x[i]> n_x_dc_max) {n_x_dc_max =an_x[i];n_x_dc_max_idx =i; }
                                            if (an_y[i]> n_y_dc_max) {n_y_dc_max =an_y[i];n_y_dc_max_idx=i;}
                                            }
                                            n_y_ac= (an_y[an_exact_ir_valley_locs[k+1]] - an_y[an_exact_ir_valley_locs[k] ] )*(n_y_dc_max_idx -an_exact_ir_valley_locs[k]); //red
                                            n_y_ac= an_y[an_exact_ir_valley_locs[k]] + n_y_ac/ (an_exact_ir_valley_locs[k+1] - an_exact_ir_valley_locs[k]) ;
                                            n_y_ac= an_y[n_y_dc_max_idx] - n_y_ac; // subracting linear DC compoenents from raw
                                            n_x_ac= (an_x[an_exact_ir_valley_locs[k+1]] - an_x[an_exact_ir_valley_locs[k] ] )*(n_x_dc_max_idx -an_exact_ir_valley_locs[k]); // ir
                                            n_x_ac= an_x[an_exact_ir_valley_locs[k]] + n_x_ac/ (an_exact_ir_valley_locs[k+1] - an_exact_ir_valley_locs[k]);
                                            n_x_ac= an_x[n_y_dc_max_idx] - n_x_ac; // subracting linear DC compoenents from raw
                                            n_nume=( n_y_ac *n_x_dc_max)>>7 ; //prepare X100 to preserve floating value
                                            n_denom= ( n_x_ac *n_y_dc_max)>>7;
                                            if (n_denom>0 && n_i_ratio_count <5 && n_nume != 0)
                                            {
                                            an_ratio[n_i_ratio_count]= (n_nume100)/n_denom ; //formular is ( n_y_ac n_x_dc_max) / ( n_x_ac *n_y_dc_max) ;
                                            n_i_ratio_count++;
                                            }
                                            }
                                            }
                                            maxim_sort_ascend(an_ratio, n_i_ratio_count);
                                            n_middle_idx= n_i_ratio_count/2;
                                            if (n_middle_idx >1)
                                            n_ratio_average =( an_ratio[n_middle_idx-1] +an_ratio[n_middle_idx])/2; // use median
                                            else
                                            n_ratio_average = an_ratio[n_middle_idx ];
                                            if( n_ratio_average>2 && n_ratio_average <184){
                                            n_spo2_calc= uch_spo2_table[n_ratio_average] ;
                                            *pn_spo2 = n_spo2_calc ;
                                            pch_spo2_valid = 1;// float_SPO2 = -45.060n_ratio_average n_ratio_average/10000 + 30.354 n_ratio_average/100 + 94.845 ; // for comparison with table
                                            }
                                            else{
                                            *pn_spo2 = -999 ; // do not use SPO2 since signal ratio is out of range
                                            *pch_spo2_valid = 0;
                                            }
                                            }
                                            void maxim_find_peaks(int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num)
                                            /
                                            • brief Find peaks
                                            • par Details
                                            • Find at most MAX_NUM peaks above MIN_HEIGHT separated by at least MIN_DISTANCE
                                              • retval None
                                              */
                                              {
                                              maxim_peaks_above_min_height( pn_locs, pn_npks, pn_x, n_size, n_min_height );
                                              maxim_remove_close_peaks( pn_locs, pn_npks, pn_x, n_min_distance );
                                              pn_npks = min( pn_npks, n_max_num );
                                              }
                                              void maxim_peaks_above_min_height(int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height)
                                              /
                                              • brief Find peaks above n_min_height
                                              • par Details
                                              • Find all peaks above MIN_HEIGHT
                                                • retval None
                                                */
                                                {
                                                int32_t i = 1, n_width;
                                                *pn_npks = 0;
                                                while (i < n_size-1){
                                                if (pn_x[i] > n_min_height && pn_x[i] > pn_x[i-1]){ // find left edge of potential peaks
                                                n_width = 1;
                                                while (i+n_width < n_size && pn_x[i] == pn_x[i+n_width]) // find flat peaks
                                                n_width++;
                                                if (pn_x[i] > pn_x[i+n_width] && (*pn_npks) < 15 ){ // find right edge of peaks
                                                pn_locs[(*pn_npks)++] = i;
                                                // for flat peaks, peak location is left edge
                                                i += n_width+1;
                                                }
                                                else
                                                i += n_width;
                                                }
                                                else
                                                i++;
                                                }
                                                }
                                                void maxim_remove_close_peaks(int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_min_distance)
                                                /
                                                • brief Remove peaks
                                                • par Details
                                                • Remove peaks separated by less than MIN_DISTANCE
                                                  • retval None
                                                  */
                                                  {
                                                  int32_t i, j, n_old_npks, n_dist;
                                                  / Order peaks from large to small /
                                                  maxim_sort_indices_descend( pn_x, pn_locs, *pn_npks );
                                                  for ( i = -1; i < *pn_npks; i++ ){
                                                  n_old_npks = *pn_npks;
                                                  *pn_npks = i+1;
                                                  for ( j = i+1; j < n_old_npks; j++ ){
                                                  n_dist = pn_locs[j] - ( i == -1 ? -1 : pn_locs[i] ); // lag-zero peak of autocorr is at index -1
                                                  if ( n_dist > n_min_distance || n_dist < -n_min_distance )
                                                  pn_locs[(*pn_npks)++] = pn_locs[j];
                                                  }
                                                  }
                                                  // Resort indices longo ascending order
                                                  maxim_sort_ascend( pn_locs, *pn_npks );
                                                  }
                                                  void maxim_sort_ascend(int32_t *pn_x,int32_t n_size)
                                                  /
                                                  • brief Sort array
                                                  • par Details
                                                  • Sort array in ascending order (insertion sort algorithm)
                                                    • retval None
                                                    */
                                                    {
                                                    int32_t i, j, n_temp;
                                                    for (i = 1; i < n_size; i++) {
                                                    n_temp = pn_x[i];
                                                    for (j = i; j > 0 && n_temp < pn_x[j-1]; j--)
                                                    pn_x[j] = pn_x[j-1];
                                                    pn_x[j] = n_temp;
                                                    }
                                                    }
                                                    void maxim_sort_indices_descend(int32_t pn_x, int32_t pn_indx, int32_t n_size)
                                                    /
                                                    • brief Sort indices
                                                    • par Details
                                                    • Sort indices according to descending order (insertion sort algorithm)
                                                      • retval None
                                                      */
                                                      {
                                                      int32_t i, j, n_temp;
                                                      for (i = 1; i < n_size; i++) {
                                                      n_temp = pn_indx[i];
                                                      for (j = i; j > 0 && pn_x[n_temp] > pn_x[pn_indx[j-1]]; j--)
                                                      pn_indx[j] = pn_indx[j-1];
                                                      pn_indx[j] = n_temp;
                                                      }
                                                      }

                                                      main函数

                                                      #include "stm32f103c8t6.h"
                                                      #include "mbed.h"
                                                      #include "algorithm.h"
                                                      #include "MAX30102.h"
                                                      #define MAX_BRIGHTNESS 255
                                                      uint32_t aun_ir_buffer[500]; //IR LED sensor data
                                                      int32_t n_ir_buffer_length; //data length
                                                      uint32_t aun_red_buffer[500]; //Red LED sensor data
                                                      int32_t n_sp02; //SPO2 value
                                                      int8_t ch_spo2_valid; //indicator to show if the SP02 calculation is valid
                                                      int32_t n_heart_rate; //heart rate value
                                                      int8_t ch_hr_valid; //indicator to show if the heart rate calculation is valid
                                                      uint8_t uch_dummy;
                                                      Serial pc(SERIAL_TX, SERIAL_RX); //initializes the serial port, TX-PA2, RX-PA3
                                                      PwmOut pwmled(PB_3); //initializes the pwm output PB3 that connects to the LED
                                                      DigitalIn INT(PB_7); //pin PB7 connects to the interrupt output pin of the MAX30102
                                                      DigitalOut led(PC_13); //PC13 connects to the on board user LED
                                                      // the setup routine runs once when you press reset:
                                                      int main() {
                                                      uint32_t un_min, un_max, un_prev_data; //variables to calculate the on-board LED brightness that reflects the heartbeats
                                                      int i;
                                                      int32_t n_brightness;
                                                      float f_temp;
                                                      maxim_max30102_reset(); //resets the MAX30102
                                                      // initialize serial communication at 115200 bits per second:
                                                      pc.baud(115200);
                                                      pc.format(8,SerialBase::None,1);
                                                      wait(1);
                                                      //read and clear status register
                                                      maxim_max30102_read_reg(0,&uch_dummy);
                                                      //wait until the user presses a key
                                                      // while(pc.readable()==0)
                                                      // {
                                                      // pc.printf("x1B[2J"); //clear terminal program screen
                                                      // pc.printf("Press any key to start conversionnr");
                                                      // wait(1);
                                                      // }
                                                      // uch_dummy=getchar();
                                                      maxim_max30102_init(); //initializes the MAX30102
                                                      n_brightness=0;
                                                      un_min=0x3FFFF;
                                                      un_max=0;
                                                      n_ir_buffer_length=500; //buffer length of 100 stores 5 seconds of samples running at 100sps
                                                      //read the first 500 samples, and determine the signal range
                                                      for(i=0;i<n_ir_buffer_length;i++)
                                                      {
                                                      while(INT.read()==1); //wait until the interrupt pin asserts
                                                      maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i)); //read from MAX30102 FIFO
                                                      if(un_min>aun_red_buffer[i])
                                                      un_min=aun_red_buffer[i]; //update signal min
                                                      if(un_max<aun_red_buffer[i])
                                                      un_max=aun_red_buffer[i]; //update signal max
                                                      pc.printf("red=");
                                                      pc.printf("%i", aun_red_buffer[i]);
                                                      pc.printf(", ir=");
                                                      pc.printf("%inr", aun_ir_buffer[i]);
                                                      }
                                                      un_prev_data=aun_red_buffer[i];
                                                      //calculate heart rate and SpO2 after first 500 samples (first 5 seconds of samples)
                                                      maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);
                                                      //Continuously taking samples from MAX30102. Heart rate and SpO2 are calculated every 1 second
                                                      while(1)
                                                      {
                                                      i=0;
                                                      un_min=0x3FFFF;
                                                      un_max=0;
                                                      //dumping the first 100 sets of samples in the memory and shift the last 400 sets of samples to the top
                                                      for(i=100;i<500;i++)
                                                      {
                                                      aun_red_buffer[i-100]=aun_red_buffer[i];
                                                      aun_ir_buffer[i-100]=aun_ir_buffer[i];
                                                      //update the signal min and max
                                                      if(un_min>aun_red_buffer[i])
                                                      un_min=aun_red_buffer[i];
                                                      if(un_max<aun_red_buffer[i])
                                                      un_max=aun_red_buffer[i];
                                                      }
                                                      //take 100 sets of samples before calculating the heart rate.
                                                      for(i=400;i<500;i++)
                                                      {
                                                      un_prev_data=aun_red_buffer[i-1];
                                                      while(INT.read()==1);
                                                      maxim_max30102_read_fifo((aun_red_buffer+i), (aun_ir_buffer+i));
                                                      if(aun_red_buffer[i]>un_prev_data)//just to determine the brightness of LED according to the deviation of adjacent two AD data
                                                      {
                                                      f_temp=aun_red_buffer[i]-un_prev_data;
                                                      f_temp/=(un_max-un_min);
                                                      f_temp*=MAX_BRIGHTNESS;
                                                      n_brightness-=(int)f_temp;
                                                      if(n_brightness<0)
                                                      n_brightness=0;
                                                      }
                                                      else
                                                      {
                                                      f_temp=un_prev_data-aun_red_buffer[i];
                                                      f_temp/=(un_max-un_min);
                                                      f_temp*=MAX_BRIGHTNESS;
                                                      n_brightness+=(int)f_temp;
                                                      if(n_brightness>MAX_BRIGHTNESS)
                                                      n_brightness=MAX_BRIGHTNESS;
                                                      }
                                                      pwmled.write(1-(float)n_brightness/256);//pwm control led brightness
                                                      if(n_brightness<120)
                                                      led=1;
                                                      else
                                                      led=0;
                                                      //send samples and calculation result to terminal program through UART
                                                      pc.printf("red=");
                                                      pc.printf("%i", aun_red_buffer[i]);
                                                      pc.printf(", ir=");
                                                      pc.printf("%i", aun_ir_buffer[i]);
                                                      pc.printf(", HR=%i, ", n_heart_rate);
                                                      pc.printf("HRvalid=%i, ", ch_hr_valid);
                                                      pc.printf("SpO2=%i, ", n_sp02);
                                                      pc.printf("SPO2Valid=%inr", ch_spo2_valid);
                                                      }
                                                      maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);
                                                      }
                                                      }
                                                      将输出数据转成曲线
                                                      notion image

                                                      个人驱动

                                                      main函数

                                                      #include "stm32f10x.h"
                                                      #include "usart.h"
                                                      #include "delay.h"
                                                      #include "max30102.h"
                                                      #include "myiic.h"
                                                      #include "algorithm.h"
                                                      #include "oled_iic.h"
                                                      #define MAX_BRIGHTNESS 255
                                                      u32 aun_ir_buffer[500];//IR LED sensor data
                                                      int32_t n_ir_buffer_length; //数据长度
                                                      u32 aun_red_buffer[500]; //Red LED sensor data
                                                      int32_t n_sp02; //SPO2 value
                                                      int8_t ch_spo2_valid; //indicator to show if the SP02 calculation is valid
                                                      int32_t n_heart_rate; //heart rate value
                                                      int8_t ch_hr_valid; //indicator to show if the heart rate calculation is valid
                                                      int main(void)
                                                      {
                                                      u8 t = 0; // 初始化一个计数变量t，用于计数，初始值为0
                                                      u32 un_min, un_max, un_prev_data; // 初始化三个32位无符号整数，用于存储信号的最小值、最大值和上一个数据
                                                      int32_t n_brightness; // 初始化一个32位有符号整数，用于表示亮度调整
                                                      u16 i; // 初始化一个16位无符号整数i，用于循环计数
                                                      u8 temp[6]; // 初始化一个长度为6的无符号字符数组，用于存储传感器采样的数据
                                                      float f_temp; // 初始化一个单精度浮点数，用于存储临时的浮点型数据
                                                      u8 dis_hr = 0, dis_spo2 = 0; // 初始化两个8位无符号整数，用于表示心率和血氧饱和度的显示值
                                                      delay_init(); // 调用延时函数的初始化，初始化延时功能
                                                      HZ = GB16_NUM(); // 获取GB16字体的数量
                                                      delay_ms(50); // 进行短暂的延时，等待系统初始化
                                                      OLED_Init(); // 初始化OLED显示屏
                                                      delay_ms(50); // 进行短暂的延时，等待OLED初始化完成
                                                      OLED_Clear(); // 清除OLED屏幕上的内容
                                                      delay_ms(50); // 进行短暂的延时，等待清屏完成
                                                      OLED_ShowCH(16,2,"心率:000");
                                                      OLED_ShowCH(16,4,"血氧:000%");
                                                      uart_init(115200);
                                                      MX_GPIO_Init();
                                                      max30102_init();
                                                      un_min = 0x3FFFF; // 初始化信号最小值为一个较大的初始值
                                                      un_max = 0; // 初始化信号最大值为0
                                                      n_ir_buffer_length = 500; // 缓冲区长度为500，存储5秒运行时的100sps采样数据
                                                      // 读取前500个样本，确定信号范围
                                                      for(i = 0; i < n_ir_buffer_length; i++)
                                                      {
                                                      while(MAX30102_INT == 1); // 等待直到中断引脚触发中断
                                                      //读取心率血氧传感器（max30102）的FIFO（First In, First Out）数据，然后解析这些数据并将其存储在相应的缓冲区中。
                                                      //调用max30102_FIFO_ReadBytes函数从max30102的FIFO寄存器中读取6个字节的数据，存储在名为temp的数组中。
                                                      max30102_FIFO_ReadBytes(REG_FIFO_DATA, temp);
                                                      //将temp数组的前三个字节组合成一个32位的长整型，用于存储红光传感器的数据。这个数据的组合方式是:
                                                      //将temp[0]的低两位（temp[0] & 0x03）左移16位，然后与temp[1]左移8位的结果以及temp[2]的结果进行按位或运算。
                                                      aun_red_buffer[i] = (long)((long)((long)temp[0] & 0x03) << 16) | (long)temp[1] << 8 | (long)temp[2];
                                                      //将temp数组的后三个字节组合成一个32位的长整型，用于存储红外光传感器的数据。这个数据的组合方式与红光传感器类似。
                                                      aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03) << 16) | (long)temp[4] << 8 | (long)temp[5];
                                                      if(un_min > aun_red_buffer[i])
                                                      un_min = aun_red_buffer[i]; // 更新信号最小值
                                                      if(un_max < aun_red_buffer[i])
                                                      un_max = aun_red_buffer[i]; // 更新信号最大值
                                                      }
                                                      un_prev_data = aun_red_buffer[i]; // 记录最后一个样本值
                                                      // 在前500个样本（5秒的样本）之后，计算心率和血氧饱和度
                                                      maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);
                                                      while(1)
                                                      {
                                                      i = 0;
                                                      un_min = 0x3FFFF;
                                                      un_max = 0;
                                                      // 将内存中的前100组样本丢弃，将最后400组样本移动到数组的前面
                                                      for(i = 100; i < 500; i++)
                                                      {
                                                      aun_red_buffer[i - 100] = aun_red_buffer[i];
                                                      aun_ir_buffer[i - 100] = aun_ir_buffer[i];
                                                      // 更新信号的最小值和最大值
                                                      if(un_min > aun_red_buffer[i])
                                                      un_min = aun_red_buffer[i];
                                                      if(un_max < aun_red_buffer[i])
                                                      un_max = aun_red_buffer[i];
                                                      }
                                                      // 取得计算心率之前的100组样本
                                                      for(i = 400; i < 500; i++)
                                                      {
                                                      un_prev_data = aun_red_buffer[i - 1];
                                                      while(MAX30102_INT == 1);
                                                      max30102_FIFO_ReadBytes(REG_FIFO_DATA, temp);
                                                      aun_red_buffer[i] = (long)((long)((long)temp[0] & 0x03) << 16) | (long)temp[1] << 8 | (long)temp[2];
                                                      aun_ir_buffer[i] = (long)((long)((long)temp[3] & 0x03) << 16) | (long)temp[4] << 8 | (long)temp[5];
                                                      if(aun_red_buffer[i] > un_prev_data)
                                                      {
                                                      f_temp = aun_red_buffer[i] - un_prev_data;
                                                      f_temp /= (un_max - un_min);
                                                      f_temp *= MAX_BRIGHTNESS;
                                                      n_brightness -= (int)f_temp;
                                                      if(n_brightness < 0)
                                                      n_brightness = 0;
                                                      }
                                                      else
                                                      {
                                                      f_temp = un_prev_data - aun_red_buffer[i];
                                                      f_temp /= (un_max - un_min);
                                                      f_temp *= MAX_BRIGHTNESS;
                                                      n_brightness += (int)f_temp;
                                                      if(n_brightness > MAX_BRIGHTNESS)
                                                      n_brightness = MAX_BRIGHTNESS;
                                                      }
                                                      // 将样本和计算结果通过UART发送到终端程序
                                                      if((ch_hr_valid == 1)) // ch_hr_valid == 1 && ch_spo2_valid ==1 && n_heart_rate<120 && n_sp02<101
                                                      {
                                                      if(n_heart_rate < 120)
                                                      dis_hr = n_heart_rate;
                                                      else
                                                      dis_hr = 0;
                                                      dis_spo2 = n_sp02;
                                                      }
                                                      else
                                                      {
                                                      dis_hr = 0;
                                                      dis_spo2 = 0;
                                                      }
                                                      t++;
                                                      if(t > 10)
                                                      {
                                                      t = 0;
                                                      printf("HR=%i,SpO2=%irn ", dis_hr, dis_spo2);
                                                      }
                                                      OLED_ShowNum(56, 2, dis_hr, 3, 1);
                                                      OLED_ShowNum(56, 4, dis_spo2, 3, 1);
                                                      }
                                                      // 调用函数计算心率和血氧饱和度，并通过OLED显示
                                                      maxim_heart_rate_and_oxygen_saturation(aun_ir_buffer, n_ir_buffer_length, aun_red_buffer, &n_sp02, &ch_spo2_valid, &n_heart_rate, &ch_hr_valid);
                                                      delay_ms(200);
                                                      }
                                                      }

                                                      max30102.h

                                                      #ifndef __MAX30102_H
                                                      #define __MAX30102_H
                                                      #include "sys.h"
                                                      //
                                                      #define MAX30102_INT PBin(9)
                                                      #define I2C_WR 0 / 写控制bit /
                                                      #define I2C_RD 1 / 读控制bit /
                                                      #define max30102_WR_address 0xAE
                                                      #define I2C_WRITE_ADDR 0xAE
                                                      #define I2C_READ_ADDR 0xAF
                                                      //register addresses
                                                      #define REG_INTR_STATUS_1 0x00
                                                      #define REG_INTR_STATUS_2 0x01
                                                      #define REG_INTR_ENABLE_1 0x02
                                                      #define REG_INTR_ENABLE_2 0x03
                                                      #define REG_FIFO_WR_PTR 0x04
                                                      #define REG_OVF_COUNTER 0x05
                                                      #define REG_FIFO_RD_PTR 0x06
                                                      #define REG_FIFO_DATA 0x07
                                                      #define REG_FIFO_CONFIG 0x08
                                                      #define REG_MODE_CONFIG 0x09
                                                      #define REG_SPO2_CONFIG 0x0A
                                                      #define REG_LED1_PA 0x0C
                                                      #define REG_LED2_PA 0x0D
                                                      #define REG_PILOT_PA 0x10
                                                      #define REG_MULTI_LED_CTRL1 0x11
                                                      #define REG_MULTI_LED_CTRL2 0x12
                                                      #define REG_TEMP_INTR 0x1F
                                                      #define REG_TEMP_FRAC 0x20
                                                      #define REG_TEMP_CONFIG 0x21
                                                      #define REG_PROX_INT_THRESH 0x30
                                                      #define REG_REV_ID 0xFE
                                                      #define REG_PART_ID 0xFF
                                                      void MX_GPIO_Init(void);
                                                      void max30102_init(void);
                                                      void max30102_reset(void);
                                                      u8 max30102_Bus_Write(u8 Register_Address, u8 Word_Data);
                                                      u8 max30102_Bus_Read(u8 Register_Address);
                                                      void max30102_FIFO_ReadWords(u8 Register_Address,u16 Word_Data[][2],u8 count);
                                                      void max30102_FIFO_ReadBytes(u8 Register_Address,u8* Data);
                                                      void maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data);
                                                      void maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data);
                                                      void maxim_max30102_read_fifo(uint32_t pun_red_led, uint32_t pun_ir_led);
                                                      #endif

                                                      max30102.c

                                                      #include "max30102.h"
                                                      #include "myiic.h"
                                                      #include "delay.h"
                                                      // 初始化GPIO配置
                                                      void MX_GPIO_Init()
                                                      {
                                                      GPIO_InitTypeDef GPIO_InitStructure;
                                                      RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);//GPIOB
                                                      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
                                                      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_8;
                                                      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
                                                      GPIO_Init(GPIOB, &GPIO_InitStructure);
                                                      GPIO_ResetBits(GPIOB, GPIO_Pin_7|GPIO_Pin_8);
                                                      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
                                                      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
                                                      GPIO_Init(GPIOB, &GPIO_InitStructure);
                                                      }
                                                      // 通过I2C总线写入数据
                                                      u8 max30102_Bus_Write(u8 Register_Address, u8 Word_Data)
                                                      {
                                                      // 采用串行EEPROM随即读取指令序列，连续读取若干字节
                                                      // 第1步：发起I2C总线启动信号
                                                      iic_Start();
                                                      // 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读
                                                      iic_Send_Byte(max30102_WR_address | I2C_WR); // 此处是写指令
                                                      // 第3步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第4步：发送字节地址
                                                      iic_Send_Byte(Register_Address);
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第5步：开始写入数据
                                                      iic_Send_Byte(Word_Data);
                                                      // 第6步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      return 1; // 执行成功
                                                      cmd_fail: // 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      return 0;
                                                      }
                                                      // 通过I2C总线读取数据
                                                      u8 max30102_Bus_Read(u8 Register_Address)
                                                      {
                                                      u8 data;
                                                      // 第1步：发起I2C总线启动信号
                                                      iic_Start();
                                                      // 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读
                                                      iic_Send_Byte(max30102_WR_address | I2C_WR); // 此处是写指令
                                                      // 第3步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第4步：发送字节地址
                                                      iic_Send_Byte((uint8_t)Register_Address);
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第6步：重新启动I2C总线。下面开始读取数据
                                                      iic_Start();
                                                      // 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读
                                                      iic_Send_Byte(max30102_WR_address | I2C_RD); // 此处是读指令
                                                      // 第8步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第9步：读取数据
                                                      {
                                                      data = iic_Read_Byte(0); // 读1个字节
                                                      iic_NAck(); // 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1)
                                                      }
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      return data; // 执行成功 返回data值
                                                      cmd_fail: // 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      return 0;
                                                      }
                                                      // 通过I2C总线读取多个字节的数据
                                                      void max30102_FIFO_ReadWords(u8 Register_Address, u16 Word_Data[][2], u8 count)
                                                      {
                                                      u8 i = 0;
                                                      u8 no = count;
                                                      u8 data1, data2;
                                                      // 第1步：发起I2C总线启动信号
                                                      iic_Start();
                                                      // 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读
                                                      iic_Send_Byte(max30102_WR_address | I2C_WR); // 此处是写指令
                                                      // 第3步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第4步：发送字节地址
                                                      iic_Send_Byte((uint8_t)Register_Address);
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第6步：重新启动I2C总线。下面开始读取数据
                                                      iic_Start();
                                                      // 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读
                                                      iic_Send_Byte(max30102_WR_address | I2C_RD); // 此处是读指令
                                                      // 第8步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第9步：读取数据
                                                      while (no)
                                                      {
                                                      data1 = iic_Read_Byte(0);
                                                      iic_Ack();
                                                      data2 = iic_Read_Byte(0);
                                                      iic_Ack();
                                                      Word_Data[i][0] = (((u16)data1 << 8) | data2); //
                                                      data1 = iic_Read_Byte(0);
                                                      iic_Ack();
                                                      data2 = iic_Read_Byte(0);
                                                      if (1 == no)
                                                      iic_NAck(); // 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1)
                                                      else
                                                      iic_Ack();
                                                      Word_Data[i][1] = (((u16)data1 << 8) | data2);
                                                      no--;
                                                      i++;
                                                      }
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      cmd_fail: // 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      }
                                                      // 通过I2C总线读取字节数据
                                                      void max30102_FIFO_ReadBytes(u8 Register_Address, u8* Data)
                                                      {
                                                      max30102_Bus_Read(REG_INTR_STATUS_1);
                                                      max30102_Bus_Read(REG_INTR_STATUS_2);
                                                      // 第1步：发起I2C总线启动信号
                                                      iic_Start();
                                                      // 第2步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读
                                                      iic_Send_Byte(max30102_WR_address | I2C_WR); // 此处是写指令
                                                      // 第3步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第4步：发送字节地址
                                                      iic_Send_Byte((uint8_t)Register_Address);
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第6步：重新启动I2C总线。下面开始读取数据
                                                      iic_Start();
                                                      // 第7步：发起控制字节，高7bit是地址，bit0是读写控制位，0表示写，1表示读
                                                      iic_Send_Byte(max30102_WR_address | I2C_RD); // 此处是读指令
                                                      // 第8步：发送ACK
                                                      if (iic_Wait_Ack() != 0)
                                                      {
                                                      goto cmd_fail; // EEPROM器件无应答
                                                      }
                                                      // 第9步：读取数据
                                                      Data[0] = iic_Read_Byte(1);
                                                      Data[1] = iic_Read_Byte(1);
                                                      Data[2] = iic_Read_Byte(1);
                                                      Data[3] = iic_Read_Byte(1);
                                                      Data[4] = iic_Read_Byte(1);
                                                      Data[5] = iic_Read_Byte(0);
                                                      // 最后1个字节读完后，CPU产生NACK信号(驱动SDA = 1)
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      cmd_fail: // 命令执行失败后，切记发送停止信号，避免影响I2C总线上其他设备
                                                      // 发送I2C总线停止信号
                                                      iic_Stop();
                                                      }
                                                      // MAX30102传感器初始化配置
                                                      void max30102_init(void)
                                                      {
                                                      iic_Init(); // 初始化I2C总线
                                                      max30102_reset(); // 复位MAX30102传感器
                                                      // 下面是一些配置参数的设置
                                                      // max30102_Bus_Write(REG_INTR_ENABLE_1, 0xc0); // INTR setting
                                                      max30102_Bus_Write(REG_INTR_ENABLE_1, 0xc0); // 使能中断，开启PPG_RDY_EN
                                                      max30102_Bus_Write(REG_INTR_ENABLE_2, 0x00); // 关闭其他中断
                                                      // MAX30102配置参数设置
                                                      max30102_Bus_Write(REG_INTR_ENABLE_1, 0xc0); // INTR setting
                                                      max30102_Bus_Write(REG_INTR_ENABLE_2, 0x00);
                                                      max30102_Bus_Write(REG_FIFO_WR_PTR, 0x00); // 设置FIFO写指针，位[4:0]
                                                      max30102_Bus_Write(REG_OVF_COUNTER, 0x00); // 设置溢出计数器，位[4:0]
                                                      max30102_Bus_Write(REG_FIFO_RD_PTR, 0x00); // 设置FIFO读指针，位[4:0]
                                                      max30102_Bus_Write(REG_FIFO_CONFIG, 0x0f); // 配置FIFO，设置样本平均值为1，禁止FIFO循环，FIFO几乎满时触发中断
                                                      max30102_Bus_Write(REG_MODE_CONFIG, 0x03); // 配置工作模式，0x02表示仅红光模式，0x03表示SpO2模式，0x07表示多模式LED
                                                      max30102_Bus_Write(REG_SPO2_CONFIG, 0x27); // 配置SpO2，设置ADC范围为4096nA，SpO2采样率为100 Hz，LED脉冲宽度为400uS
                                                      max30102_Bus_Write(REG_LED1_PA, 0x24); // 设置LED1功率，选择值约为7mA
                                                      max30102_Bus_Write(REG_LED2_PA, 0x24); // 设置LED2功率，选择值约为7mA
                                                      max30102_Bus_Write(REG_PILOT_PA, 0x7f); // 设置Pilot LED功率，选择值约为25mA
                                                      }
                                                      // 下面是对其他函数的注释，与max30102_init函数相似
                                                      void max30102_reset(void)
                                                      {
                                                      max30102_Bus_Write(REG_MODE_CONFIG, 0x40);
                                                      max30102_Bus_Write(REG_MODE_CONFIG, 0x40);
                                                      }
                                                      void maxim_max30102_write_reg(uint8_t uch_addr, uint8_t uch_data)
                                                      {
                                                      iic_Write_One_Byte(I2C_WRITE_ADDR, uch_addr, uch_data);
                                                      }
                                                      void maxim_max30102_read_reg(uint8_t uch_addr, uint8_t *puch_data)
                                                      {
                                                      iic_Read_One_Byte(I2C_WRITE_ADDR, uch_addr, puch_data);
                                                      }
                                                      void maxim_max30102_read_fifo(uint32_t pun_red_led, uint32_t pun_ir_led)
                                                      {
                                                      uint32_t un_temp;
                                                      unsigned char uch_temp;
                                                      char ach_i2c_data[6];
                                                      *pun_red_led = 0;
                                                      *pun_ir_led = 0;
                                                      // 读取和清除状态寄存器
                                                      maxim_max30102_read_reg(REG_INTR_STATUS_1, &uch_temp);
                                                      maxim_max30102_read_reg(REG_INTR_STATUS_2, &uch_temp);
                                                      // 读取FIFO数据
                                                      iic_ReadBytes(I2C_WRITE_ADDR, REG_FIFO_DATA, (u8 *)ach_i2c_data, 6);
                                                      // 解析FIFO数据
                                                      un_temp = (unsigned char)ach_i2c_data[0]; // 读取FIFO数据的第一个字节
                                                      un_temp <<= 16; // 左移16位，将数据放入对应的高位
                                                      *pun_red_led += un_temp; // 累加到红光LED的数据中
                                                      un_temp = (unsigned char)ach_i2c_data[1]; // 读取FIFO数据的第二个字节
                                                      un_temp <<= 8; // 左移8位，将数据放入对应的高位
                                                      *pun_red_led += un_temp; // 累加到红光LED的数据中
                                                      un_temp = (unsigned char)ach_i2c_data[2]; // 读取FIFO数据的第三个字节
                                                      *pun_red_led += un_temp; // 累加到红光LED的数据中
                                                      un_temp = (unsigned char)ach_i2c_data[3]; // 读取FIFO数据的第四个字节
                                                      un_temp <<= 16; // 左移16位，将数据放入对应的高位
                                                      *pun_ir_led += un_temp; // 累加到红外LED的数据中
                                                      un_temp = (unsigned char)ach_i2c_data[4]; // 读取FIFO数据的第五个字节
                                                      un_temp <<= 8; // 左移8位，将数据放入对应的高位
                                                      *pun_ir_led += un_temp; // 累加到红外LED的数据中
                                                      un_temp = (unsigned char)ach_i2c_data[5]; // 读取FIFO数据的第六个字节
                                                      *pun_ir_led += un_temp; // 累加到红外LED的数据中
                                                      *pun_red_led &= 0x03FFFF; // 对红光LED的数据进行按位与操作，屏蔽掉高位 [23:18]
                                                      *pun_ir_led &= 0x03FFFF; // 对红外LED的数据进行按位与操作，屏蔽掉高位 [23:18]
                                                      }

                                                      algorithm.h

                                                      //Copyright (C) 2015 Maxim Integrated Products, Inc., All Rights Reserved.
                                                      #ifndef ALGORITHM_H_
                                                      #define ALGORITHM_H_
                                                      #include "sys.h"
                                                      #define true 1
                                                      #define false 0
                                                      #define FS 100
                                                      #define BUFFER_SIZE (FS* 5)
                                                      #define HR_FIFO_SIZE 7
                                                      #define MA4_SIZE 4 // DO NOT CHANGE
                                                      #define HAMMING_SIZE 5// DO NOT CHANGE
                                                      #define min(x,y) ((x) < (y) ? (x) : (y))
                                                      void maxim_heart_rate_and_oxygen_saturation(uint32_t pun_ir_buffer , int32_t n_ir_buffer_length, uint32_t pun_red_buffer , int32_t pn_spo2, int8_t pch_spo2_valid , int32_t pn_heart_rate , int8_t pch_hr_valid);
                                                      void maxim_find_peaks( int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num );
                                                      void maxim_peaks_above_min_height( int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height );
                                                      void maxim_remove_close_peaks( int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_min_distance );
                                                      void maxim_sort_ascend( int32_t *pn_x, int32_t n_size );
                                                      void maxim_sort_indices_descend( int32_t pn_x, int32_t pn_indx, int32_t n_size);
                                                      #endif

                                                      algorithm.c

                                                      #include "algorithm.h"
                                                      //汉明窗口，函数的目的是在时域内对信号进行平滑处理，以减小信号两端的幅度，防止频谱泄漏。
                                                      //计算公式：w(n)=0.54-0.46cos(2 pi n/N-1)，其中 N 是窗口的长度
                                                      const uint16_t auw_hamm[31]={ 41, 276, 512, 276, 41 }; //Hamm= long16(512* hamming(5)');
                                                      //uch_spo2_table is computed as -45.060ratioAverage ratioAverage + 30.354 *ratioAverage + 94.845 ;
                                                      //ratioAverage 是一个用于计算血氧饱和度的比值。这个比值与红外光和红光的交流和直流分量的比值有关
                                                      const uint8_t uch_spo2_table[184]={ 95, 95, 95, 96, 96, 96, 97, 97, 97, 97, 97, 98, 98, 98, 98, 98, 99, 99, 99, 99,
                                                      99, 99, 99, 99, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100,
                                                      100, 100, 100, 100, 99, 99, 99, 99, 99, 99, 99, 99, 98, 98, 98, 98, 98, 98, 97, 97,
                                                      97, 97, 96, 96, 96, 96, 95, 95, 95, 94, 94, 94, 93, 93, 93, 92, 92, 92, 91, 91,
                                                      90, 90, 89, 89, 89, 88, 88, 87, 87, 86, 86, 85, 85, 84, 84, 83, 82, 82, 81, 81,
                                                      80, 80, 79, 78, 78, 77, 76, 76, 75, 74, 74, 73, 72, 72, 71, 70, 69, 69, 68, 67,
                                                      66, 66, 65, 64, 63, 62, 62, 61, 60, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50,
                                                      49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33, 31, 30, 29,
                                                      28, 27, 26, 25, 23, 22, 21, 20, 19, 17, 16, 15, 14, 12, 11, 10, 9, 7, 6, 5,
                                                      3, 2, 1 } ;
                                                      static int32_t an_dx[ BUFFER_SIZE-MA4_SIZE]; // delta
                                                      static int32_t an_x[ BUFFER_SIZE]; //ir
                                                      static int32_t an_y[ BUFFER_SIZE]; //red
                                                      void maxim_heart_rate_and_oxygen_saturation(uint32_t pun_ir_buffer, int32_t n_ir_buffer_length, uint32_t pun_red_buffer, int32_t pn_spo2, int8_t pch_spo2_valid,
                                                      int32_t pn_heart_rate, int8_t pch_hr_valid)
                                                      /
                                                      • brief Calculate the heart rate and SpO2 level
                                                      • par Details
                                                      • 通过检测PPG周期的峰值和相应的红/红外信号的AC/DC，计算出SPO2的比值。
                                                      • 因为这个算法的目标是Arm M0/M3。由于寄存器溢出，SPO2的公式没有达到精度。
                                                      • 因此，准确的SPO2是预先计算出来的，并且每个比率都节省了很长的uch_spo2_table[]。
                                                        • param[in] *pun_ir_buffer -红外传感器数据缓冲区
                                                        • param[in] n_ir_buffer_length -红外传感器数据缓冲区长度
                                                        • param[in] *pun_red_buffer -红光传感器数据缓冲区
                                                        • param[out] *pn_spo2 -计算的SpO2值
                                                        • param[out] *pch_spo2_valid -如果计算的SpO2值有效，则为1
                                                        • param[out] *pn_heart_rate -计算心率值
                                                        • param[out] *pch_hr_valid - 1如果计算的心率值是有效的
                                                        • 存储计算结果的指针pn_spo2、pch_spo2_valid、pn_heart_rate和pch_hr_valid。
                                                        • retval None
                                                        • 实现步骤：
                                                            • 主要实现过程包括：
                                                            （1）去除IR信号的直流成分：
                                                            计算IR信号的平均值，然后从原始IR信号中减去平均值，得到去除直流成分的信号。
                                                            （2）平滑信号：
                                                            对去除直流成分的IR信号进行4点移动平均。
                                                            （3）计算信号差分：
                                                            计算平滑后的IR信号的差分。
                                                            （4）使用汉明窗口翻转波形：
                                                            对差分信号使用汉明窗口，以便在后续步骤中检测波谷。
                                                            （5）使用峰值检测找到波谷：
                                                            使用峰值检测算法找到波谷的位置，并保存在an_ir_valley_locs数组中。
                                                            （6）计算心率：
                                                            根据波谷的位置计算心率，单位为每分钟心跳数（BPM）。
                                                            （7）计算IR和红光信号的AC/DC比值：
                                                            在两个相邻波谷之间，找到IR和红光信号的AC（交流）和DC（直流）成分，并计算AC/DC比值。
                                                            在每个心跳周期内，计算红外和红光信号的AC分量和DC分量。
                                                            AC分量反映了血液的脉动变化，而DC分量反映了总体的血液吸收
                                                            （8）使用比值计算血氧饱和度：
                                                            使用IR和红光信号的AC/DC比值，查表计算血氧饱和度。结果存储在pn_spo2中。
                                                            红外和红光的AC/DC比值与血液的含氧量相关，因为含氧血液和脱氧血液对红外和红光的吸收比例不同
                                                            使用预先计算好的SPO2校准表，将红外和红光的AC/DC比值映射到实际的SPO2值。
                                                        */
                                                        {
                                                        uint32_t un_ir_mean, un_only_once; // IR信号的均值和标志位，用于去除直流（DC）成分
                                                        int32_t k, n_i_ratio_count; // 循环变量k，AC/DC比值计数器
                                                        int32_t i, s, m, n_exact_ir_valley_locs_count, n_middle_idx;
                                                        // 循环变量i，临时变量s，计数器m，精确IR谷点数目，中间索引
                                                        int32_t n_th1, n_npks, n_c_min; // 阈值n_th1，峰值计数n_npks，最小值n_c_min
                                                        int32_t an_ir_valley_locs[15]; // IR信号谷点的数组
                                                        int32_t an_exact_ir_valley_locs[15]; // 精确IR信号谷点的数组
                                                        int32_t an_dx_peak_locs[15]; // 微分信号峰点的数组
                                                        int32_t n_peak_interval_sum; // 峰值间隔总和
                                                        int32_t n_y_ac, n_x_ac; // 红光和红外光的AC（交流）分量
                                                        int32_t n_spo2_calc; // 计算得到的SPO2值
                                                        int32_t n_y_dc_max, n_x_dc_max; // 红光和红外光的DC（直流）最大值
                                                        int32_t n_y_dc_max_idx, n_x_dc_max_idx; // 红光和红外光的DC最大值索引
                                                        int32_t an_ratio[5], n_ratio_average; // AC/DC比值数组和比值平均值
                                                        int32_t n_nume, n_denom; // 分子和分母，用于计算AC/DC比值
                                                        // 去除IR信号的直流成分
                                                        un_ir_mean = 0;
                                                        for (k = 0; k < n_ir_buffer_length; k++) un_ir_mean += pun_ir_buffer[k];
                                                        un_ir_mean = un_ir_mean / n_ir_buffer_length;
                                                        for (k = 0; k < n_ir_buffer_length; k++) an_x[k] = pun_ir_buffer[k] - un_ir_mean;
                                                        // 4点移动平均
                                                        for (k = 0; k < BUFFER_SIZE - MA4_SIZE; k++)
                                                        {
                                                        // 计算4个点的和
                                                        n_denom = (an_x[k] + an_x[k + 1] + an_x[k + 2] + an_x[k + 3]);
                                                        // 计算移动平均值并替换原始值
                                                        an_x[k] = n_denom / (int32_t)4;
                                                        }
                                                        // 计算信号差分，计算信号an_x的差分，即相邻元素之间的差值。
                                                        //通过对原始信号进行差分运算，可以获取信号的变化率，有助于后续的信号处理和特征提取。
                                                        for (k = 0; k < BUFFER_SIZE - MA4_SIZE - 1; k++)
                                                        an_dx[k] = (an_x[k + 1] - an_x[k]);
                                                        // 2点移动平均
                                                        for (k = 0; k < BUFFER_SIZE - MA4_SIZE - 2; k++)
                                                        {
                                                        an_dx[k] = (an_dx[k] + an_dx[k + 1]) / 2;
                                                        }
                                                        // 汉明窗口
                                                        //汉明窗口是一种窗口函数，通常用于在信号处理中对信号进行平滑处理，以减少频谱泄漏。
                                                        //在这里，通过对差分信号应用汉明窗口，可以对信号进行加权，突出信号中的特定频率成分。
                                                        //这个加权后的信号被用于后续的信号处理步骤，以提取相关的特征或信息。
                                                        for (i = 0; i < BUFFER_SIZE - HAMMING_SIZE - MA4_SIZE - 2; i++)
                                                        {
                                                        s = 0;
                                                        // 应用汉明窗口对信号进行加权
                                                        for (k = i; k < i + HAMMING_SIZE; k++)
                                                        {
                                                        // 汉明窗口的权重数组为 auw_hamm
                                                        // 将差分信号 an_dx 与汉明窗口加权，并求和
                                                        s -= an_dx[k] * auw_hamm[k - i];
                                                        }
                                                        // 将加权和除以汉明窗口权重之和（1146）,归一化
                                                        an_dx[i] = s / (int32_t)1146;
                                                        }
                                                        // 阈值计算，计算差分信号数组 an_dx 的平均阈值 n_th1
                                                        n_th1 = 0; // 初始化阈值
                                                        // 遍历差分信号数组 an_dx，计算阈值
                                                        for (k = 0; k < BUFFER_SIZE - HAMMING_SIZE; k++)
                                                        {
                                                        // 阈值为正差分信号之和，如果差分信号为负值，则取绝对值累加
                                                        n_th1 += ((an_dx[k] > 0) ? an_dx[k] : ((int32_t)0 - an_dx[k]));
                                                        }
                                                        // 将阈值除以数组长度，得到平均阈值
                                                        n_th1 = n_th1 / (BUFFER_SIZE - HAMMING_SIZE);
                                                        // 使用峰值检测找到波谷，计算心率
                                                        /*
                                                        思路：
                                                        maxim_find_peaks 函数找到差分信号数组 an_dx 中的峰值位置，并将这些位置存储在 an_dx_peak_locs 数组中
                                                        然后，通过计算峰值之间的平均间隔，利用心率计算公式计算心率值。
                                                        最后，根据检测到的峰值位置，计算波谷位置，并将波谷位置存储在 an_ir_valley_locs 数组中。
                                                        */
                                                        maxim_find_peaks(an_dx_peak_locs, &n_npks, an_dx, BUFFER_SIZE - HAMMING_SIZE, n_th1, 8, 5);
                                                        n_peak_interval_sum = 0;
                                                        // 如果检测到至少两个峰值
                                                        if (n_npks >= 2)
                                                        {
                                                        // 计算峰值之间的平均间隔
                                                        for (k = 1; k < n_npks; k++)
                                                        n_peak_interval_sum += (an_dx_peak_locs[k] - an_dx_peak_locs[k - 1]);
                                                        // 计算心率（每分钟心跳数）
                                                        n_peak_interval_sum = n_peak_interval_sum / (n_npks - 1);
                                                        *pn_heart_rate = (int32_t)(6000 / n_peak_interval_sum);
                                                        // 设置心率有效标志为1
                                                        *pch_hr_valid = 1;
                                                        }
                                                        else
                                                        {
                                                        // 如果未检测到足够的峰值，设置心率为无效值-999
                                                        *pn_heart_rate = -999;
                                                        // 设置心率有效标志为0
                                                        *pch_hr_valid = 0;
                                                        }
                                                        // 将峰值位置加上 HAMMING_SIZE / 2 作为波谷位置，为后面寻找准确的波谷做准备
                                                        for (k = 0; k < n_npks; k++)
                                                        an_ir_valley_locs[k] = an_dx_peak_locs[k] + HAMMING_SIZE / 2;
                                                        // 计算AC/DC比值，从原始的红外和红光信号中提取出用于计算的实际波谷位置
                                                        /*
                                                        首先，将原始的红外信号存储在 an_x 数组中，红光信号存储在 an_y 数组中。
                                                        然后，遍历波谷位置数组，寻找每个波谷的实际位置。通过在波谷位置的前后寻找最小值，确定波谷的确切位置，
                                                        并将这些位置存储在 an_exact_ir_valley_locs 数组中。
                                                        */
                                                        for (k = 0; k < n_ir_buffer_length; k++)
                                                        {
                                                        an_x[k] = pun_ir_buffer[k]; // 将红外信号存储在 an_x 数组中
                                                        an_y[k] = pun_red_buffer[k]; // 将红光信号存储在 an_y 数组中
                                                        }
                                                        n_exact_ir_valley_locs_count = 0;
                                                        // 遍历波谷位置数组，找到每个波谷的实际位置
                                                        for (k = 0; k < n_npks; k++)
                                                        {
                                                        un_only_once = 1;
                                                        m = an_ir_valley_locs[k];
                                                        n_c_min = 16777216; // 设置一个较大的初始值，2^24
                                                        // 在波谷位置的前后寻找最小值，以确定波谷的实际位置
                                                        if (m + 5 < BUFFER_SIZE - HAMMING_SIZE && m - 5 > 0)
                                                        //检查实际红外信号谷值位置 m 前后是否有足够的空间，以防数组越界。
                                                        {
                                                        for (i = m - 5; i < m + 5; i++)
                                                        //循环遍历从当前谷值位置向前后各取5个点的范围。
                                                        {
                                                        if (an_x[i] < n_c_min)
                                                        {
                                                        if (un_only_once > 0)
                                                        {
                                                        //第一次找到最小值，将其设为0以标记已经找到最小值。
                                                        un_only_once = 0;
                                                        }
                                                        n_c_min = an_x[i];
                                                        an_exact_ir_valley_locs[k] = i;
                                                        }
                                                        }
                                                        // 如果找到了最小值，增加实际波谷位置的计数
                                                        if (un_only_once == 0)
                                                        n_exact_ir_valley_locs_count++;
                                                        }
                                                        }
                                                        // 波谷是信号的极小值，用于确定每个心跳周期的起始点。如果确切波谷位置的数量小于2，说明信号比值超出范围，设置SPO2为无效值-999
                                                        if (n_exact_ir_valley_locs_count < 2)
                                                        {
                                                        *pn_spo2 = -999;
                                                        *pch_spo2_valid = 0;
                                                        return;
                                                        }
                                                        // 4点移动平均，平滑信号并降低高频噪声的影响
                                                        for (k = 0; k < BUFFER_SIZE - MA4_SIZE; k++)
                                                        {
                                                        an_x[k] = (an_x[k] + an_x[k + 1] + an_x[k + 2] + an_x[k + 3]) / (int32_t)4;
                                                        an_y[k] = (an_y[k] + an_y[k + 1] + an_y[k + 2] + an_y[k + 3]) / (int32_t)4;
                                                        }
                                                        // 使用an_exact_ir_valley_locs，找到IR-RED DC和IR-RED AC进行SPO2校准比率
                                                        //使用先前找到的红外信号的谷位置（an_exact_ir_valley_locs），来计算IR-RED DC和IR-RED AC的比率。用于SPO2（血氧饱和度）的校准。
                                                        n_ratio_average = 0;
                                                        n_i_ratio_count = 0;
                                                        for (k = 0; k < 5; k++)
                                                        an_ratio[k] = 0;
                                                        for (k = 0; k < n_exact_ir_valley_locs_count; k++)
                                                        {
                                                        if (an_exact_ir_valley_locs[k] > BUFFER_SIZE)
                                                        {
                                                        *pn_spo2 = -999; // 因为谷位置超出范围，不是正确的SPO2
                                                        *pch_spo2_valid = 0;
                                                        return;
                                                        }
                                                        }
                                                        /*
                                                        计算红光和红外信号的交流分量的乘积，并将计算得到的AC/DC比值保存到数组中。
                                                        其中，通过找到两个谷值之间的最大值来估算直流分量，然后计算交流分量，并最终得到AC/DC比值。
                                                        整个过程旨在对信号进行预处理，为后续的SPO2（血氧饱和度）计算提供必要的信息。
                                                        */
                                                        for (k = 0; k < n_exact_ir_valley_locs_count - 1; k++)
                                                        {
                                                        n_y_dc_max = -16777216; // 初始化红光信号的最大直流分量为一个较小的负数
                                                        n_x_dc_max = -16777216; // 初始化红外信号的最大直流分量为一个较小的负数
                                                        // 判断两个谷值之间的距离是否大于10个样本点，确保两谷之间有足够的数据进行计算
                                                        if (an_exact_ir_valley_locs[k + 1] - an_exact_ir_valley_locs[k] > 10)
                                                        {
                                                        // 遍历两个谷值之间的数据
                                                        for (i = an_exact_ir_valley_locs[k]; i < an_exact_ir_valley_locs[k + 1]; i++)
                                                        {
                                                        // 找到红外信号的最大值及对应索引
                                                        if (an_x[i] > n_x_dc_max)
                                                        {
                                                        n_x_dc_max = an_x[i];
                                                        n_x_dc_max_idx = i;
                                                        }
                                                        // 找到红光信号的最大值及对应索引
                                                        if (an_y[i] > n_y_dc_max)
                                                        {
                                                        n_y_dc_max = an_y[i];
                                                        n_y_dc_max_idx = i;
                                                        }
                                                        }
                                                        // 计算红光的交流分量
                                                        //计算红光信号在两个相邻谷值之间的交流成分，使用两个谷值之间的光强差值乘以相邻两个峰谷之间的距离。
                                                        //an_y: 这是存储红光信号光强数据的数组
                                                        //an_exact_ir_valley_locs: 这是存储实际红外信号波谷位置的数组
                                                        //n_y_dc_max_idx，红光信号的最大峰值位置的索引
                                                        n_y_ac = (an_y[an_exact_ir_valley_locs[k + 1]] - an_y[an_exact_ir_valley_locs[k]]) * (n_y_dc_max_idx - an_exact_ir_valley_locs[k]);
                                                        //将得到的红光的交流分量加到红光信号在前一个谷值位置的基线值上
                                                        n_y_ac = an_y[an_exact_ir_valley_locs[k]] + n_y_ac / (an_exact_ir_valley_locs[k + 1] - an_exact_ir_valley_locs[k]);
                                                        // 消除红光信号的直流分量
                                                        n_y_ac = an_y[n_y_dc_max_idx] - n_y_ac;
                                                        //写成abs(n_y_ac - an_y[n_y_dc_max_idx])是否可以？
                                                        // 计算红外光的交流分量
                                                        n_x_ac = (an_x[an_exact_ir_valley_locs[k + 1]] - an_x[an_exact_ir_valley_locs[k]]) * (n_x_dc_max_idx - an_exact_ir_valley_locs[k]);
                                                        n_x_ac = an_x[an_exact_ir_valley_locs[k]] + n_x_ac / (an_exact_ir_valley_locs[k + 1] - an_exact_ir_valley_locs[k]);
                                                        // 消除红外信号的直流分量
                                                        n_x_ac = an_x[an_exact_ir_valley_locs[k + 1]] - n_x_ac;
                                                        // 将红光信号的AC分量与红外信号最大峰值位置的直流分量相乘，作为计算SPO2的分子
                                                        n_nume = (n_y_ac * n_x_dc_max) >> 7;
                                                        // 将红外信号的AC分量与红光信号最大峰值位置的直流分量相乘，作为计算SPO2的分母
                                                        n_denom = (n_x_ac * n_y_dc_max) >> 7;
                                                        // 判断分母是否大于0，避免除零错误，并判断是否满足条件，满足则进行下一步计算
                                                        if (n_denom > 0 && n_i_ratio_count < 5 && n_nume != 0)
                                                        {
                                                        // 计算AC/DC比值并保存到数组中
                                                        an_ratio[n_i_ratio_count] = (n_nume * 20) / n_denom;
                                                        n_i_ratio_count++;
                                                        }
                                                        }
                                                        }
                                                        /*
                                                        对排序后的AC/DC比值数组进行处理，计算得到中值平均（或直接取中值），并通过判断得到的AC/DC比值
                                                        是否在有效范围内，确定最终的SPO2值。如果AC/DC比值有效，通过查表获取对应的SPO2值，否则将SPO2
                                                        值设为无效。在实际应用中，通过对AC/DC比值的处理，结合预先计算的SPO2表格，可以更准确地估算血氧饱和度。
                                                        */
                                                        // 将存储AC/DC比值的数组按升序排列
                                                        maxim_sort_ascend(an_ratio, n_i_ratio_count);
                                                        // 计算中间值的索引
                                                        n_middle_idx = n_i_ratio_count / 2;
                                                        // 如果中间索引大于1，使用中值平均计算AC/DC比值
                                                        if (n_middle_idx > 1)
                                                        n_ratio_average = (an_ratio[n_middle_idx - 1] + an_ratio[n_middle_idx]) / 2;
                                                        else
                                                        n_ratio_average = an_ratio[n_middle_idx];
                                                        // 判断计算得到的AC/DC比值是否在有效范围内
                                                        if (n_ratio_average > 2 && n_ratio_average < 184)
                                                        {
                                                        // 通过查表获取对应的SPO2值
                                                        n_spo2_calc = uch_spo2_table[n_ratio_average];
                                                        *pn_spo2 = n_spo2_calc;
                                                        *pch_spo2_valid = 1; // 设置SPO2有效标志
                                                        // 可选：用以下公式计算浮点数SPO2，与查表结果进行比较
                                                        // float_SPO2 = -45.060 n_ratio_average n_ratio_average / 10000 + 30.354 * n_ratio_average / 100 + 94.845;
                                                        }
                                                        else
                                                        {
                                                        // 如果计算得到的AC/DC比值不在有效范围内，设置SPO2为无效值
                                                        *pn_spo2 = -999;
                                                        *pch_spo2_valid = 0;
                                                        }
                                                        }
                                                        void maxim_find_peaks(int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height, int32_t n_min_distance, int32_t n_max_num)
                                                        /
                                                        • brief Find peaks
                                                        • par Details
                                                        • Find at most MAX_NUM peaks above MIN_HEIGHT separated by at least MIN_DISTANCE
                                                          • retval None
                                                          */
                                                          {
                                                          maxim_peaks_above_min_height( pn_locs, pn_npks, pn_x, n_size, n_min_height );
                                                          maxim_remove_close_peaks( pn_locs, pn_npks, pn_x, n_min_distance );
                                                          pn_npks = min( pn_npks, n_max_num );
                                                          }
                                                          void maxim_peaks_above_min_height(int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_size, int32_t n_min_height)
                                                          /
                                                          • brief Find peaks above n_min_height
                                                          • par Details
                                                          • Find all peaks above MIN_HEIGHT
                                                            • retval None
                                                            */
                                                            {
                                                            int32_t i = 1, n_width;
                                                            *pn_npks = 0;
                                                            while (i < n_size-1){
                                                            if (pn_x[i] > n_min_height && pn_x[i] > pn_x[i-1]){ // find left edge of potential peaks
                                                            n_width = 1;
                                                            while (i+n_width < n_size && pn_x[i] == pn_x[i+n_width]) // find flat peaks
                                                            n_width++;
                                                            if (pn_x[i] > pn_x[i+n_width] && (*pn_npks) < 15 ){ // find right edge of peaks
                                                            pn_locs[(*pn_npks)++] = i;
                                                            // for flat peaks, peak location is left edge
                                                            i += n_width+1;
                                                            }
                                                            else
                                                            i += n_width;
                                                            }
                                                            else
                                                            i++;
                                                            }
                                                            }
                                                            void maxim_remove_close_peaks(int32_t pn_locs, int32_t pn_npks, int32_t *pn_x, int32_t n_min_distance)
                                                            /
                                                            • brief Remove peaks
                                                            • par Details
                                                            • Remove peaks separated by less than MIN_DISTANCE
                                                              • retval None
                                                              */
                                                              {
                                                              int32_t i, j, n_old_npks, n_dist;
                                                              / Order peaks from large to small /
                                                              maxim_sort_indices_descend( pn_x, pn_locs, *pn_npks );
                                                              for ( i = -1; i < *pn_npks; i++ ){
                                                              n_old_npks = *pn_npks;
                                                              *pn_npks = i+1;
                                                              for ( j = i+1; j < n_old_npks; j++ ){
                                                              n_dist = pn_locs[j] - ( i == -1 ? -1 : pn_locs[i] ); // lag-zero peak of autocorr is at index -1
                                                              if ( n_dist > n_min_distance || n_dist < -n_min_distance )
                                                              pn_locs[(*pn_npks)++] = pn_locs[j];
                                                              }
                                                              }
                                                              // Resort indices longo ascending order
                                                              maxim_sort_ascend( pn_locs, *pn_npks );
                                                              }
                                                              void maxim_sort_ascend(int32_t *pn_x,int32_t n_size)
                                                              /
                                                              • brief Sort array
                                                              • par Details
                                                              • Sort array in ascending order (insertion sort algorithm)
                                                                • retval None
                                                                */
                                                                {
                                                                int32_t i, j, n_temp;
                                                                for (i = 1; i < n_size; i++) {
                                                                n_temp = pn_x[i];
                                                                for (j = i; j > 0 && n_temp < pn_x[j-1]; j--)
                                                                pn_x[j] = pn_x[j-1];
                                                                pn_x[j] = n_temp;
                                                                }
                                                                }
                                                                void maxim_sort_indices_descend(int32_t pn_x, int32_t pn_indx, int32_t n_size)
                                                                /
                                                                • brief Sort indices
                                                                • par Details
                                                                • Sort indices according to descending order (insertion sort algorithm)
                                                                  • retval None
                                                                  */
                                                                  {
                                                                  int32_t i, j, n_temp;
                                                                  for (i = 1; i < n_size; i++) {
                                                                  n_temp = pn_indx[i];
                                                                  for (j = i; j > 0 && pn_x[n_temp] > pn_x[pn_indx[j-1]]; j--)
                                                                  pn_indx[j] = pn_indx[j-1];
                                                                  pn_indx[j] = n_temp;
                                                                  }
                                                                  }
                                                                  💡
                                                                  有关MAX30102学习或者使用上的问题，欢迎您在底部评论区留言，一起交流~
                                                                  ]]>