STM32HAL库 环形队列实现串口接收中断

最新推荐文章于 2025-04-22 16:05:30 发布
最新推荐文章于 2025-04-22 16:05:30 发布
阅读量898 收藏 10
点赞数 11
文章标签： stm32 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_74785680/article/details/144401975
版权

        在我们需要使用串口接收中断去解析大量指令或数据时，为了避免直接在串口中断函数中进行解析，可以使用环形队列作为缓冲区。

一、初始化结构体

        将环形缓冲区的head（队列头）和tail（队列尾）都初始化为0，表示缓冲区是空的，头和尾指向同一个位置。

typedef struct {
    uint8_t buffer[128];   
    uint16_t head;                    
    uint16_t tail;                   
} CircularBuffer;

CircularBuffer rxBuffer;

void CircularBuffer_Init(CircularBuffer* cb) {
    cb->head = 0;
    cb->tail = 0;
}

二、写数据到队列

  • 计算出下一个head位置 next = (cb->head + 1) % RX_BUFFER_SIZE，通过模运算确保head位置在缓冲区大小范围内。
  • 如果 next != cb->tail，意味着缓冲区未满，可以写入数据。
  • 将数据写入当前位置 cb->buffer[cb->head]，然后更新head为next。
  • 如果缓冲区已满（即next == cb->tail），则返回0，表示写入失败。
  • 否则返回1，表示写入成功。
int CircularBuffer_Write(CircularBuffer* cb, uint8_t data) {
    uint16_t next = (cb->head + 1) % RX_BUFFER_SIZE;
    if (next != cb->tail) {  
        cb->buffer[cb->head] = data;
        cb->head = next;
        return 1;  
    }
    return 0;  
}

 三、从队列读取数据

  • 如果head和tail不相等，表示缓冲区中有数据可以读取。
  • 将数据从cb->buffer[cb->tail]中读取出来，并将其存储到data指向的内存中。
  • 更新tail为下一个位置 (cb->tail + 1) % RX_BUFFER_SIZE，确保尾指针循环回到缓冲区的起始位置。
  • 如果缓冲区为空（head == tail），则返回0，表示读取失败。
  • 否则返回1，表示读取成功。
int CircularBuffer_Read(CircularBuffer* cb, uint8_t* data) {
    if (cb->head != cb->tail) {  
        *data = cb->buffer[cb->tail];
        cb->tail = (cb->tail + 1) % RX_BUFFER_SIZE;
        return 1;  
    }
    return 0;  
}

四、获取缓冲区长度

        获取缓冲区中可用的数据字节数（即从tail到head之间的距离）。        

uint16_t CircularBuffer_Available(CircularBuffer* cb) {
    return (cb->head - cb->tail + RX_BUFFER_SIZE) % RX_BUFFER_SIZE;
}

代码示例 
 

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file    usart.c
  * @brief   This file provides code for the configuration
  *          of the USART instances.
  ******************************************************************************
  * @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 "usart.h"

/* USER CODE BEGIN 0 */
#define RX_BUFFER_SIZE 128 
uint8_t receivedByte;
CircularBuffer rxBuffer;
/* USER CODE END 0 */

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;

/* USART1 init function */

void MX_USART1_UART_Init(void)
{

  /* USER CODE BEGIN USART1_Init 0 */

  /* USER CODE END USART1_Init 0 */

  /* USER CODE BEGIN USART1_Init 1 */

  /* USER CODE END USART1_Init 1 */
  huart1.Instance = USART1;
  huart1.Init.BaudRate = 9600;
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART1_Init 2 */
	HAL_UART_Receive_IT(&huart1, &receivedByte, 1);
  /* USER CODE END USART1_Init 2 */

}
/* USART3 init function */

void MX_USART3_UART_Init(void)
{

  /* USER CODE BEGIN USART3_Init 0 */

  /* USER CODE END USART3_Init 0 */

  /* USER CODE BEGIN USART3_Init 1 */

  /* USER CODE END USART3_Init 1 */
  huart3.Instance = USART3;
  huart3.Init.BaudRate = 9600;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_16;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }
  /* USER CODE BEGIN USART3_Init 2 */

  /* USER CODE END USART3_Init 2 */

}

void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
{

  GPIO_InitTypeDef GPIO_InitStruct = {0};
  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspInit 0 */

  /* USER CODE END USART1_MspInit 0 */
    /* USART1 clock enable */
    __HAL_RCC_USART1_CLK_ENABLE();

    __HAL_RCC_GPIOA_CLK_ENABLE();
    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    /* USART1 interrupt Init */
    HAL_NVIC_SetPriority(USART1_IRQn, 3, 0);
    HAL_NVIC_EnableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspInit 1 */

  /* USER CODE END USART1_MspInit 1 */
  }
  else if(uartHandle->Instance==USART3)
  {
  /* USER CODE BEGIN USART3_MspInit 0 */

  /* USER CODE END USART3_MspInit 0 */
    /* USART3 clock enable */
    __HAL_RCC_USART3_CLK_ENABLE();

    __HAL_RCC_GPIOB_CLK_ENABLE();
    /**USART3 GPIO Configuration
    PB10     ------> USART3_TX
    PB11     ------> USART3_RX
    */
    GPIO_InitStruct.Pin = GPIO_PIN_10;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    GPIO_InitStruct.Pin = GPIO_PIN_11;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    /* USART3 interrupt Init */
    HAL_NVIC_SetPriority(USART3_IRQn, 4, 0);
    HAL_NVIC_EnableIRQ(USART3_IRQn);
  /* USER CODE BEGIN USART3_MspInit 1 */

  /* USER CODE END USART3_MspInit 1 */
  }
}

void HAL_UART_MspDeInit(UART_HandleTypeDef* uartHandle)
{

  if(uartHandle->Instance==USART1)
  {
  /* USER CODE BEGIN USART1_MspDeInit 0 */

  /* USER CODE END USART1_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART1_CLK_DISABLE();

    /**USART1 GPIO Configuration
    PA9     ------> USART1_TX
    PA10     ------> USART1_RX
    */
    HAL_GPIO_DeInit(GPIOA, GPIO_PIN_9|GPIO_PIN_10);

    /* USART1 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART1_IRQn);
  /* USER CODE BEGIN USART1_MspDeInit 1 */

  /* USER CODE END USART1_MspDeInit 1 */
  }
  else if(uartHandle->Instance==USART3)
  {
  /* USER CODE BEGIN USART3_MspDeInit 0 */

  /* USER CODE END USART3_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_USART3_CLK_DISABLE();

    /**USART3 GPIO Configuration
    PB10     ------> USART3_TX
    PB11     ------> USART3_RX
    */
    HAL_GPIO_DeInit(GPIOB, GPIO_PIN_10|GPIO_PIN_11);

    /* USART3 interrupt Deinit */
    HAL_NVIC_DisableIRQ(USART3_IRQn);
  /* USER CODE BEGIN USART3_MspDeInit 1 */

  /* USER CODE END USART3_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */



int fputc(int ch, FILE *f)//printf
{
	HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1,0xffff);  //发送一个字节的数据到指定的串口
	return (ch);
}
 
int fgetc(FILE * f)
{
  uint8_t ch = 0;
  HAL_UART_Receive(&huart1,&ch, 1, 0xffff);
  return ch;

}

//初始化环形队列
void CircularBuffer_Init(CircularBuffer* cb) {
    cb->head = 0;
    cb->tail = 0;
}
//将数据添加到环形缓冲区
int CircularBuffer_Write(CircularBuffer* cb, uint8_t data) {
    uint16_t next = (cb->head + 1) % RX_BUFFER_SIZE;
    if (next != cb->tail) {  
        cb->buffer[cb->head] = data;
        cb->head = next;
        return 1;  
    }
    return 0;  
}

//从环形缓冲区读取数据
int CircularBuffer_Read(CircularBuffer* cb, uint8_t* data) {
    if (cb->head != cb->tail) {  
        *data = cb->buffer[cb->tail];
        cb->tail = (cb->tail + 1) % RX_BUFFER_SIZE;
        return 1;  
    }
    return 0;  
}

//获取环形缓冲区中的字节
uint16_t CircularBuffer_Available(CircularBuffer* cb) {
    return (cb->head - cb->tail + RX_BUFFER_SIZE) % RX_BUFFER_SIZE;
}


// USART1 中断回调函数
void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if (huart->Instance == USART1)
    {
        CircularBuffer_Write(&rxBuffer, receivedByte);
        HAL_UART_Receive_IT(&huart1, (uint8_t*) &receivedByte, 1);
    }
}













/* USER CODE END 1 */

STM32的串口空闲中断接收不定长数据
jiangmaple的专栏
10-25 8333
最近想尝试STM32 通过DMA收发数据，网上找了不少参考文章，最后参考https://blog.youkuaiyun.com/youmeichifan/article/details/51750435?utm_source=dlogxgwz2 博文中的方法。 按照此文的方法实现了串口的收发，但是实际使用中发现： 接收空闲中断的产生是在数据接收停止一个字节时产生的，但是有时由于上位机编写问题或硬件问题（本...
STM32串口环形队列
07-13
STM32最大劣势：串口只有一个16bit，这样的话，串口接收时数据会丢失，本历程良好的解决这个存在的问题
HAL库--串口DMA接收中断的三种方式
最新发布
qq_44386182的博客
04-22 1455
最常见的方法就是使用这个库函数，其使用方法类似于，初始化时需要调用一次，然后每次在中断服务函数里面处理完数据后重新调用一次。使用只需要打开串口接收中断，即;使用空闲中断需要在初始化时打开串口空闲中断使能，调用方式为：。此时DMA中断可开可不开，开了也不用管，因为数据处理是在串口空闲中断中进行的。1. 串口初始化代码： 初始化中调用开启空闲中断，启动DMA串口接收，是接收缓冲区，是定义的DMA接收缓冲区长度，接收的数据不能超过这个长度。2. 中断处理：中断处理有两种方式，第一种是直接定义在中，第二种是自定
STM32串口环形队列程序
04-15
该程序为大数据量吞吐的串口收发例程，中断接收，边收边发，采用大数据环形队列，处理过程超快不丢包，接收buffer可以定义成2K,4K,8K均可。也可以用到其余单片机上
stm32环形队列
06-17
stm32环形队列
STM32 串口环形队列
02-21
环形缓冲区，适用于接收外部数据时用作缓冲 STM32 QUEUE_DATA_TYPE* cbWrite(QueueBuffer *cb); QUEUE_DATA_TYPE* cbRead(QueueBuffer *cb); void cbReadFinish(QueueBuffer *cb); void cbWriteFinish(QueueBuffer *cb); //void cbPrint(QueueBuffer *cb); QUEUE_DATA_TYPE* cbWriteUsing(QueueBuffer *cb) ; int cbIsFull(QueueBuffer *cb) ; int cbIsEmpty(QueueBuffer *cb) ;
基于stm32f407的串口环形队列及DMA收发中断数据处理
03-27
在本文中，我们将深入探讨如何在STM32F407微控制器上实现串口通信的环形队列和DMA（直接存储器访问）收发中断数据处理。STM32F407是一款基于ARM Cortex-M4内核的高性能单片机，广泛应用于嵌入式硬件设计。 首先，...
基于STM32串口环形队列
06-05
总结来说，“基于STM32串口环形队列”的设计旨在提升串口通信的效率和可靠性，通过合理利用内存资源和中断处理机制，实现高效的数据收发。byte_queue-master项目提供了一个实用的模板，开发者可以在此基础上根据具体...
HAL库STM32f0串口DMA空闲中断接收fifo数据处理
09-03
本文将深入探讨如何在STM32F0芯片上利用HAL库实现串口的DMA（直接存储器访问）和空闲中断来处理FIFO（先进先出）数据。这个程序设计适用于需要高效、可靠地接收串行数据的应用场景。 首先，STM32F0是意法半导体...
STM32 HAL库USART串口中断编程：环形缓冲区防止数据丢失
02-18
总体而言，利用STM32 HAL库实现USART串口中断编程时，通过环形缓冲区的设计可以有效防止数据丢失。这需要深入理解STM32的HAL库函数，合理设计中断优先级和处理流程，以及编写高效的数据处理算法。此外，还需要进行...
STM32串口环形队列,stm32串口程序,C,C++
09-10
串口FIFO环形收发程序，应用于大批量的数据，希望帮助大家学习
STM32 串口实验 --环形队列.zip
05-17
基于STM32F103芯片串口通信例程，主要是串口1接收到数据后，再发送出去。通过环形队列来接收串口数据，可以边收边解析，达到缓冲作用，可以做较大数据接收。目前的例程没有通信协议，只是在接收时，以判断数据串有回车信号，就认为该数据串接收完成。
STM32HAL库 串口使用循环队列（FIFO）接收数据 （单字节）
03-02
STM32HAL库是STMicroelectronics为STM32微控制器系列提供的一种高级抽象层，它简化了硬件访问，使得开发者可以更加专注于应用层的代码编写。在这个特定的案例中，我们关注的是如何利用HAL库来实现串口通信，并结合...
STM32串口之环形队列接收数据
热门推荐
欲盖弥彰1314
01-04 1万+
文章目录废话说在前面代码实现环形队列数据结构写一字节数据到队列判断队列是否写满读一字节的数据判断队列是否为空写多个字节到队列到STM32上测试 废话说在前面 码代码的应该学数据结构都学过队列。环形队列是队列的一种特殊形式，应用挺广泛的。 因为有太多文章关于这方面的内容，理论知识可以看别人的，下面写得挺好的： STM32进阶之串口环形缓冲区实现 代码实现 环形队列数据结构 typedef s...
stm32 打造自己环形队列
hbwang的博客
01-12 2074
本环形队列实现以数组形式批量写入和读取队列中数据。 写入数据时，对于队列剩余空间不足时，可以选择强制覆盖写入（会有覆盖部分原队列数据，请根据自己实现需要操作）；不覆盖，则不会写入； 读取数据时，如果超过队列中已存数据长度，则读取实际大小；没有超过，则正常读取。 本环形队列可用作串口数据缓存接收，尤为适用于有具体协议格式数据，方便查找TAG标识进行定位。但对于串口采用DMA方式，接收大量无协议格式的数据，暂不适用。
STM32开发 数据包环形队列
qq_36365231的博客
08-16 1717
C语言版环形队列实现、数据包队列
基于STM32裸机开发的环形队列
TLY983074808的博客
09-07 1428
在嵌入式系统中，高效的消息传递和任务调度至关重要。本文将介绍如何通过**环形队列（Circular Queue）**实现消息传递，并根据接收到的消息类型进行任务处理。本文以STM32为例，展示环形队列的基本实现以及如何处理不同的任务请求。提示：以下是本篇文章正文内容，下面案例可供参考环形队列是一种**先进先出（FIFO）**的数据结构，它的读写指针会在队列末尾环绕返回到队列的起始位置，确保有效利用存储空间。环形队列的主要优势在于可以连续存储和处理消息，而不会因为队列末尾的空闲空间而浪费资源。
STM32F4串口环形缓冲区，接收多字节数据，HAL库中断接收
05-26
在使用 HAL 库进行串口接收时，可以使用 HAL_UART_Receive_IT() 函数来启动中断接收。接收到的数据会存储在串口的硬件缓冲区中，我们可以在 HAL_UART_RxCpltCallback() 回调函数中实现对数据的处理。 为了实现接收多字节数据，我们可以使用一个环形缓冲区来存储接收到的数据。具体实现步骤如下： 1. 定义环形缓冲区结构体 ```c typedef struct { uint8_t* buffer; // 缓冲区指针 uint32_t size; // 缓冲区大小 uint32_t head; // 缓冲区头指针 uint32_t tail; // 缓冲区尾指针 } RingBuffer; ``` 2. 初始化环形缓冲区 ```c void RingBuffer_Init(RingBuffer* buffer, uint8_t* data, uint32_t size) { buffer->buffer = data; buffer->size = size; buffer->head = 0; buffer->tail = 0; } ``` 3. 缓冲区写入数据 ```c void RingBuffer_Write(RingBuffer* buffer, uint8_t* data, uint32_t size) { uint32_t i; for (i = 0; i < size; i++) { uint32_t next = (buffer->head + 1) % buffer->size; if (next != buffer->tail) { buffer->buffer[buffer->head] = data[i]; buffer->head = next; } else { // 缓冲区已满 break; } } } ``` 4. 缓冲区读取数据 ```c uint32_t RingBuffer_Read(RingBuffer* buffer, uint8_t* data, uint32_t size) { uint32_t i; for (i = 0; i < size; i++) { if (buffer->tail != buffer->head) { data[i] = buffer->buffer[buffer->tail]; buffer->tail = (buffer->tail + 1) % buffer->size; } else { // 缓冲区已空 break; } } return i; } ``` 5. 在 HAL_UART_RxCpltCallback() 回调函数中实现数据的存储 ```c void HAL_UART_RxCpltCallback(UART_HandleTypeDef* huart) { static uint8_t data[64]; static uint32_t count = 0; uint32_t size = 0; if (huart->Instance == USARTx) { // 读取接收到的数据 data[count++] = huart->Instance->DR & 0xFF; if (count >= sizeof(data)) { // 缓冲区已满，存储数据并清空计数器 RingBuffer_Write(&rx_buffer, data, count); count = 0; } // 继续启动中断接收 HAL_UART_Receive_IT(huart, &data[count], 1); } } ``` 6. 在主程序中读取缓冲区中的数据 ```c uint8_t data[64]; uint32_t size = RingBuffer_Read(&rx_buffer, data, sizeof(data)); if (size > 0) { // 处理接收到的数据 } ``` 通过以上步骤，我们就可以实现在 STM32F4 中使用 HAL 库进行串口接收，并使用环形缓冲区来存储多字节数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值