环形缓冲区（Ring Buffer）在STM32 HAL库中的应用：防止按键丢失

于 2024-10-06 22:19:34 发布
阅读量853 收藏 24
点赞数 29
分类专栏： stm32 文章标签： 单片机 嵌入式硬件 stm32 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37371085/article/details/139974990
版权

环形缓冲区（Ring Buffer）又称为循环缓冲区或圆形队列，是一种数据结构，它用于管理固定大小的数据存储空间。环形缓冲区本质是一个一维数组，不过是收尾相连的，类比一条蛇咬自己尾巴。

环形缓冲区重要性：避免数据被覆盖。比如，使用中断函数或者定时器函数记录按键，如果只能记录一个键值的话，如果不能及时读走出来，再次发生中断时新值就会覆盖旧值。使用环形缓冲区可以避免数据被覆盖。

本文将详细介绍环形缓冲区的概念、工作原理，并以STM32F407微控制器结合HAL库为例，探讨如何利用环形缓冲区有效防止按键输入丢失。可参考定时器处理按键抖动

 一、开发环境

硬件：正点原子探索者 V3 STM32F407开发板

单片机：STM32F407ZGT6

Keil版本：5.32

STM32CubeMX版本：6.9.2

STM32Cube MCU Packges版本：STM32F4xx_DFP.2.14.0

按键引脚：PE2
串口：USART1(PA9,PA10)

  二、配置STM32CubeMX

  1. 启动STM32CubeMX，新建STM32CubeMX项目：​
  2. 选择MCU：在软件中选择你的STM32型号-STM32F407ZGT6。​

  3. 选择时钟源：

  4. 配置时钟：
  5. ​使能Debug功能：Serial Wire
  6. ​HAL库时基选择：SysTick
  7. USART1配置：选择异步模式。

8.配置工程参数：在Project标签页中，配置项目名称和位置，选择工具链MDK-ARM。​ 9.生成代码：在Code Generator标签页中，配置工程外设文件与HAL库，勾选头文件.c和.h文件分开，然后点击Project > Generate Code生成代码。 

三、代码实现与部署

  1.   添加circle_buffer.c,circle_buffer.h：

    #ifndef _CIRCLE_BUF_H
#define _CIRCLE_BUF_H

#include <stdint.h>

typedef struct circle_buf {
	uint32_t r;
	uint32_t w;
	uint32_t len;
	uint8_t *buf;
}circle_buf, *p_circle_buf;

void circle_buf_init(p_circle_buf pCircleBuf, uint32_t len, uint8_t *buf);

int circle_buf_read(p_circle_buf pCircleBuf, uint8_t *pVal);

int circle_buf_write(p_circle_buf pCircleBuf, uint8_t val);

#endif /* _CIRCLE_BUF_H */

    #include <stdint.h>
#include "circle_buffer.h"

void circle_buf_init(p_circle_buf pCircleBuf, uint32_t len, uint8_t *buf)
{
	pCircleBuf->r = pCircleBuf->w = 0;
	pCircleBuf->len = len;
	pCircleBuf->buf = buf;
}

int circle_buf_read(p_circle_buf pCircleBuf, uint8_t *pVal)
{
	if (pCircleBuf->r != pCircleBuf->w)
	{
		*pVal = pCircleBuf->buf[pCircleBuf->r];
		
		pCircleBuf->r++;
		
		if (pCircleBuf->r == pCircleBuf->len)
			pCircleBuf->r = 0;
		return 0;
	}
	else
	{
		return -1;
	}
}

int circle_buf_write(p_circle_buf pCircleBuf, uint8_t val)
{
	uint32_t next_w;
	
	next_w = pCircleBuf->w + 1;
	if (next_w == pCircleBuf->len)
		next_w = 0;
	
	if (next_w != pCircleBuf->r)
	{
		pCircleBuf->buf[pCircleBuf->w] = val;
		pCircleBuf->w = next_w;
		return 0;
	}
	else
	{
		return -1;
	}
}

  2. main.c增加代码：

    /* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include <stdio.h>
#include "circle_buffer.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */
struct soft_timer {
	uint32_t timeout;
	void * args;
	void (*func)(void *);
};
/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

int g_key_cnt = 0;

void key_timeout_func(void *args);

struct soft_timer key_timer = {~0, NULL, key_timeout_func};

static uint8_t g_data_buf[100];
static circle_buf g_key_bufs;

void key_timeout_func(void *args)
{
	uint8_t key_val; /* 按下是0x1, 松开 0x2 */
	g_key_cnt++;
	key_timer.timeout = ~0;
	/* read gpio */
		if (HAL_GPIO_ReadPin(GPIOE,GPIO_PIN_2 ) == GPIO_PIN_RESET)
    key_val = 0x1;
		else
		key_val = 0x2;
	/* put key val into circle buf */
	circle_buf_write(&g_key_bufs, key_val);
}

void mod_timer(struct soft_timer *pTimer, uint32_t timeout)
{
	pTimer->timeout = HAL_GetTick() + timeout;
}

void check_timer(void)
{
	if (key_timer.timeout <= HAL_GetTick())
	{
		key_timer.func(key_timer.args);
	}
}

void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
	if (GPIO_Pin == GPIO_PIN_2)
	{		
		mod_timer(&key_timer, 10);
	}
}
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */
  circle_buf_init(&g_key_bufs, 100, g_data_buf);
  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
  HAL_Delay(5000);

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
		uint8_t key_val = 0;  
	  if (0 == circle_buf_read(&g_key_bufs, &key_val))
	  {	 
				printf("key_cnt:%d\r\n",g_key_cnt); //按下和松开累计次数
				if(key_val == 0x1)
					 printf("The key is pressed\r\n"); //按键按下
				else if (key_val == 0x2)
					 printf("Key is released\r\n");//按键松开
	  }
		
  }
  /* USER CODE END 3 */
}
  3. stm32f4xx_it.c增加代码： 
    /**
  * @brief This function handles System tick timer.
  */
void SysTick_Handler(void)
{
  /* USER CODE BEGIN SysTick_IRQn 0 */

  /* USER CODE END SysTick_IRQn 0 */
  HAL_IncTick();
  /* USER CODE BEGIN SysTick_IRQn 1 */
	extern void check_timer(void);
  check_timer();
  /* USER CODE END SysTick_IRQn 1 */
}
  4.  usart.c增加代码：usart.c的第1行添加头文件#include <stdio.h>
    #include <string.h>，在末尾用户代码区增加如下代码。printf调用“fputc()”,“fgetc()”，该函数会使用HAL_UART_Transmit发送数据。     
    /*
* 添加如下代码，可不在工程设置中勾选Use MicroLIB
*/
#pragma import(__use_no_semihosting)

struct __FILE
{
	int a;
};

FILE __stdout;
FILE __stdin;

void _sys_exit(int x)
{
}


/*****************************************************
*function: 写字符文件函数
*param1: 输出的字符
*param2: 文件指针
*return: 输出字符的ASCII码
******************************************************/
int fputc(int ch, FILE *f)
{
	HAL_UART_Transmit(&huart1, (uint8_t*)&ch, 1, 10);
	return ch;
}
/*****************************************************
*function: 读字符文件函数
*param1: 文件指针
*return: 读取字符的ASCII码
******************************************************/
int fgetc(FILE *f)
{
	uint8_t ch = 0;
	HAL_UART_Receive(&huart1, (uint8_t*)&ch, 1, 10);
	return (int)ch;
}
  5. 连接USART1：用USB转TTL工具连接当前硬件USART1的PA9、PA10，GND。​​
  6. 打开串口助手：​​
  7. 编译代码：Keil编译生成的代码。

  8. 烧录程序：将编译好的程序用ST-LINK烧录到STM32微控制器中。

四、运行结果

观察结果：一旦程序烧录完成并运行，复位3秒后，按下4次，按下的4次（8次按下松开）每次都被记录下来。

复位3秒内，按下4次，按下的4次（8次按下松开）也被记录下来了，说明按下的键值被环形缓冲区记录下来了。

​五、注意事项

1.确保你的开发环境和工具已经正确安装和配置。

2.如果没有打印电压值，按一下复位键，检查连接和电源是否正确，注意根据你所用的硬件来接线，不要接错线。
3.在串口打印数据时，要确保波特率等参数与串口助手设置一致。

通过上述步骤，你就可以在STM32F407 HAL库利用环形缓冲区有效防止按键输入丢失。

jmlinux
关注
专栏目录
STM32 CubeMX FreeRtos系统 基于lwRB通用环形缓冲区的串口非阻塞发送
qq_43175613的博客
04-28 423
FreeRtos实时系统基于LWRB 一种通用环形FIFO，中断调用printf
STM32 环形缓冲
09-01
环形缓冲 串口自发自收 STM32 C程序 可用于上位机与下位机通信.
环形缓冲区在stm32上的使用
weixin_44317448的博客
03-10 654
环形缓冲区是一种数据结构，它允许在缓冲区中存储和检索数据，而不需要进行复杂的索引管理。这在嵌入式系统中非常有用，尤其是在处理串行通信时，如使用 USART。以下是一个简单的指南，可以帮助初学者开始使用环形缓冲区首先，您需要定义环形缓冲区的数据结构和初始化函数。1024/* 环形缓冲区的大小 *//* 缓冲区空间 *//* 写地址 *//* 读地址 */
ring_buffer
10-09
webrtc的 ring_buffer 环形队列 C/C++ 实现 环形缓冲区
STM32 开发之环形缓冲的应用
weixin_48503637的博客
02-21 932
STM32 开发之环形缓冲的应用，用于串口数据传输时，接收数据长度未知，频率未知，不要求实时处理的场景。
stm32 环形缓冲区
jinchengzhou的专栏
11-22 1543
  /*========================ringbuff.H========================================*/ #ifndef __RingBuff__H #define USER_RINGBUFF 1 //使用环形缓冲区形式接收数据 #if USER_RINGBUFF /**如果使用环形缓冲形式接收串口数据***/ #define...
ringbuffer
chongzong1056的博客
08-27 1776
什么是ringbuffer 嗯，正如名字所说的一样，它是一个环（首尾相接的环），你可以把它用做在不同上下文（线程、协程）间传递数据的buffer。 基本来说，ringbuffer拥有一个固定长度，且每个位置有一个序号，并且是连续的。 随着你不停地填充这个buffer（可能也会有相应的读取），...
环形缓冲区（Ring Buffer）在STM32F407 HAL库中的应用：防止按键丢失
最新发布
10-06
​ 环形缓冲区（Ring Buffer）又称为循环缓冲区或圆形队列，是一种数据结构，它...本文将详细介绍环形缓冲区的概念、工作原理，并以STM32F407微控制器结合HAL库为例，探讨如何利用环形缓冲区有效防止按键输入丢失 ​
基于STM32串口环形队列
06-05
在嵌入式开发领域，STM32是一款广泛应用的微控制器，尤其在通信、工业控制以及物联网设备中。本文将深入探讨“基于STM32串口环形队列”的设计与实现，结合已调试OK的byte_queue-master项目，帮助开发者更好地理解和...
STM32F4串口环形缓冲区，接收多字节数据，HAL库中断接收
05-26
在使用 HAL 库进行串口接收时，可以使用 HAL_UART_Receive_IT() 函数来启动中断接收。...通过以上步骤，我们就可以实现在 STM32F4 中使用 HAL 库进行串口接收，并使用环形缓冲区来存储多字节数据。
STM32进阶之串口环形缓冲区实现
10-01
我们知道的串口收发都是：接收一个数据，触发中断，然后把数据发回来。 这种处理方式是没有缓冲区的，当数量太大的时候，亦或者当数据接收太快的时候，我们来不及处理已经收到的数据， 那么，当再次收到数据的时候，就会将之前还未处理的数据覆盖掉。那么就会出现丢包的现象了，对我们的程序是一个致命的创伤。
STM32进阶之串口环形缓冲区实现 FIFO
01-26
STM32进阶之串口环形缓冲区实现 FIFO，代码精简，易实现。
stm32h7-dual-core-inter-cpu-async-communication:STM32H7双核设备上Cortex-M7和Cortex-M4内核之间的CPU间异步通信
04-10
它使用共享RAM和2单独的环形缓冲区，在两个方向上的作用类似于管道（单输入，单输出）。 第一个缓冲区从CPU1到CPU2，第二个缓冲区从CPU2到CPU1。 SRAM4用作D3域中的共享RAM。 此RAM是首选的，建议将其用于双核STM...
STM32串口开发之环形缓冲区
人生一路，点滴记录
07-07 6347
01、简介 在之前的文章《stm32 串口详解》中，我们讲解了串口的基本应用，使用串口中断接收数据，串口中断发送回包（一般可以使用非中断形式发送回包，在数据接收不频繁的应用中。串口接收中断保证串口数据及时响应，使用非中断方式发送回包即可）。 后面的文章《STM32使用DMA接收串口数据》和《STM32使用DMA发送串口数据》讲解了如何使用DMA辅助串口收发数据，使用DMA的好处在于不用CPU即可完成串口收发数据，减轻CPU负担，在串口通信频繁且不想频繁中断的应用中非常有用。 除了上述两种场景，还有一种
Disruptor 全解析(1)：Ring Buffer 有什么特别?
in355hz
06-08 669
原文地址: http://mechanitis.blogspot.com/2011/06/dissecting-disruptor-whats-so-special.html​  作者是 Trisha Gee, LMAX 公司的一位女工程师。   最近我们开源了 LMAX Disruptor​，它是让我们的交易流程变得如此之快的关键。为什么要开源它？因为我们意识到大家对高性能编程的传统认知...
【STM32 CubeMX】学STM必会的数据结构——环形缓冲区
m0_62599305的博客
02-15 2249
在嵌入式系统开发中，经常需要处理数据的缓存和传输，而环形缓冲区是一种常见且有效的数据结构，特别适用于处理实时数据流或者在有限的内存资源下高效地管理数据。在STM32微控制器的开发中，使用CubeMX工具可以方便地配置和生成环形缓冲区的代码，从而加速开发过程并提高代码的可维护性。本文将介绍STM32 CubeMX中环形缓冲区的使用方法以及其在嵌入式系统开发中的重要性。环形缓冲区是嵌入式系统开发中常用的数据结构之一，具有高效、可靠的特性。
STM32 HAL库入门指南：快速上手与节省开发时间
该库在STM32 Cube生态系统中扮演着核心角色，它是STM32 Cube Version 1.x的一部分，专为STM32 F1系列等特定产品线设计。 首先，STM32 Cube MX是一个图形化配置工具，它通过图形化的向导帮助用户快速生成C语言初始化...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值