STM32上使用的环形FIFO队列，用于缓存待发送数据_stm32 循环fifo(1)

于 2024-05-16 15:09:31 发布
阅读量414 收藏 5
点赞数 4
文章标签： c语言 c++ 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_84976662/article/details/138962317
版权

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

  • 功能: 实时数据发送缓冲区
  • 作者: cp1300@139.com
  • 创建时间: 2015-08-09
  • 最后修改时间: 2017-08-26
  • 详细: 用于数据发送缓冲区
    2017-08-26:增加溢出回调函数，可以对溢出的数据进行处理，用于FIFO嵌套
    *************************************************************************************************************/
    #include “system.h”
    #include “usart.h”
    #include “led.h”
    #include “main.h”
    #include “SendDataFIFO.h”
    #include “SYSMalloc.h”

#define FIFO_INIT_STATUS_ID 0x354789d //用于标示是否初始化

//初始化缓冲区
bool FIFO_Init(FIFO_HANDLE *pHandle,u16 OneSize, u16 MaxCnt, void (*FullCallBack)(void *pData), bool isExtSRAM)
{

if(pHandle == NULL) return FALSE;
if(isExtSRAM == TRUE)	//是否使用外部缓冲区
{
	pHandle->pFifoBuff = (u8 *)mymalloc(SRAMEX, OneSize*MaxCnt);			//缓冲区指针,申请内存
	pHandle->pByteCntBuff = (u16 *)mymalloc(SRAMEX, sizeof(u16)*MaxCnt);	//数据大小记录缓冲区，申请内存
}
else
{
	pHandle->pFifoBuff = (u8 *)mymalloc(SRAMIN, OneSize*MaxCnt);			//缓冲区指针,申请内存
	pHandle->pByteCntBuff = (u16 *)mymalloc(SRAMIN, sizeof(u16)*MaxCnt);	//数据大小记录缓冲区，申请内存
}

//uart_printf("pHandle->pFifoBuff=0x%X\r\n", (u32)pHandle->pFifoBuff);
//uart_printf("pHandle->pByteCntBuff=0x%X\r\n", (u32)pHandle->pByteCntBuff);
if(pHandle->pFifoBuff==NULL)
{
	DEBUG("pHandle->pFifoBuff申请内存出错\r\n");
}
if(pHandle->pByteCntBuff==NULL)
{
	DEBUG("pHandle->pByteCntBuff申请内存出错\r\n");
}
pHandle->InitStatus = 0;		//初始化成功状态无效
if((pHandle->pFifoBuff==NULL)||(pHandle->pByteCntBuff==NULL)) return FALSE;
pHandle->OneSize = OneSize;		//单条数据大小
pHandle->Cnt = MaxCnt;			//缓冲区总数据容量(条数)
pHandle->ReadCnt = 0;			//读取位置
pHandle->WriteCnt = 0;			//写位置
pHandle->NotReadCnt = 0;		//未读取数量
pHandle->FullCallBack = FullCallBack;			//溢出回调函数
pHandle->InitStatus = FIFO_INIT_STATUS_ID;		//初始化成功状态有效


return TRUE;

}

//写入一条数据
//当缓冲区满了后，缓存最新的数据，丢掉最早的数据
bool FIFO_Write(FIFO_HANDLE *pHandle,u8 *pBuff, u16 ByteCnt)
{
u16 cnt;
#ifdef UCOS_II
OS_CPU_SR cpu_sr;
#endif

if(pHandle == NULL) return FALSE;
if(pHandle->InitStatus != FIFO_INIT_STATUS_ID) return FALSE;						//没有初始化
if (pHandle->NotReadCnt >= pHandle->Cnt)											//发送溢出										
{
	cnt = pHandle->WriteCnt;														//先将写指针后移，占位，防止多线程写冲突
	
	if(pHandle->FullCallBack!=NULL) pHandle->FullCallBack(&pHandle->pFifoBuff[cnt * pHandle->OneSize]);
	if (ByteCnt > pHandle->OneSize) ByteCnt = pHandle->OneSize;						//限制单条数据大小
	
	pHandle->WriteCnt++;
	if (pHandle->WriteCnt >= pHandle->Cnt) pHandle->WriteCnt = 0;					//环形FIFO
	pHandle->ReadCnt++;																//读取数量增加
	if (pHandle->ReadCnt >= pHandle->Cnt) pHandle->ReadCnt = 0;						//环形FIFO，把读写指针都增加，但是剩余数据数量不变
	pHandle->pByteCntBuff[cnt] = ByteCnt;											//记录数据大小
	memcpy(&pHandle->pFifoBuff[cnt * pHandle->OneSize], pBuff, ByteCnt);			//拷贝数据到缓冲区
	
	return FALSE;																	//数据已经满了
}
else
{
	if (ByteCnt > pHandle->OneSize) ByteCnt = pHandle->OneSize;						//限制单条数据大小
	//先将写指针后移，占位，防止多线程写冲突
	cnt = pHandle->WriteCnt;
	pHandle->WriteCnt++;
	if (pHandle->WriteCnt >= pHandle->Cnt) pHandle->WriteCnt = 0;					//环形FIFO
	pHandle->pByteCntBuff[cnt] = ByteCnt;											//记录数据大小
	
	memcpy(&pHandle->pFifoBuff[cnt * pHandle->OneSize], pBuff, ByteCnt);			//拷贝数据到缓冲区
	/*{
		u16 i;
		printf("\r\n写入的数据测试[读%d/写:%d]:\r\n",pHandle->ReadCnt,pHandle->WriteCnt);
		for(i = 0;i < ByteCnt;i ++)
		{
			pHandle->pFifoBuff[cnt * pHandle->OneSize+i] = pBuff[i];
			printf("%02X\t",pBuff[i]);
			if(pHandle->pFifoBuff[cnt * pHandle->OneSize+i] != pBuff[i])
			{
				printf("拷贝检测错误,数据丢失了\r\n");
			}
		}
		printf("\r\n检测写入的数据测试:\r\n");
		for(i = 0;i < ByteCnt;i ++)
		{
			printf("%02X\t",pHandle->pFifoBuff[cnt * pHandle->OneSize+i]);
		}
		printf("\r\n");
	}*/

#ifdef UCOS_II
OS_ENTER_CRITICAL(); //关闭系统中断
#endif

	pHandle->NotReadCnt ++;															//没有读取的数量增加

#ifdef UCOS_II
OS_EXIT_CRITICAL(); //开启系统中断
#endif

	return TRUE;
}

}

//读取一条数据,返回指针，无需复制数据
bool FIFO_ReadNotCopy(FIFO_HANDLE *pHandle,u8 **pBuff, u16 *pByteCnt)
{
u16 cnt;

printf("\r\n读取数据[读%d/写:%d]:\r\n",pHandle->ReadCnt,pHandle->WriteCnt);
if(pHandle == NULL) return FALSE;
if(pHandle->InitStatus != FIFO_INIT_STATUS_ID) return FALSE;					//没有初始化
if (pHandle->NotReadCnt == 0)  return FALSE;									//数据为空
cnt = pHandle->pByteCntBuff[pHandle->ReadCnt];									//获取数据大小
if (cnt > pHandle->OneSize) cnt = pHandle->OneSize;								//限制单条数据大小
*pBuff = &pHandle->pFifoBuff[pHandle->ReadCnt * pHandle->OneSize];				//数据缓冲区指针
*pByteCnt = cnt;


return TRUE;

}

//未读取数据减少一次，用于读取数据返回指针后调用
u16 FIFO_ReduceOne(FIFO_HANDLE *pHandle)
{
#ifdef UCOS_II
OS_CPU_SR cpu_sr;
#endif

if(pHandle == NULL) return FALSE;
if(pHandle->InitStatus != FIFO_INIT_STATUS_ID) return FALSE;					//没有初始化
if (pHandle->NotReadCnt == 0) return FALSE;
pHandle->ReadCnt++;																//读取数量增加
if (pHandle->ReadCnt >= pHandle->Cnt) pHandle->ReadCnt = 0;						//环形FIFO

#ifdef UCOS_II
OS_ENTER_CRITICAL(); //关闭系统中断
#endif

pHandle->NotReadCnt--;															//没有读取的数量减少

#ifdef UCOS_II
OS_EXIT_CRITICAL(); //开启系统中断
#endif

return pHandle->NotReadCnt;														//返回没有读取的数据数量

}

//清除FIFO
bool FIFO_Clear(FIFO_HANDLE *pHandle)
{
if(pHandle == NULL) return FALSE;
if(pHandle->InitStatus != FIFO_INIT_STATUS_ID) return FALSE; //没有初始化

img
img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上C C++开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以戳这里获取

2401_84976662
关注
stm32串口通信--使用环形队列缓冲区接收字符串
qq_21708039的博客
10-27 2797
stm32使用环形队列接收数据
STM32串口环形缓冲--使用队列实现（开放源码）
weixin_44418619的博客
07-01 4420
串口队列环形缓冲区队列串口环形缓冲的好处代码实现 队列   要实现队列环形缓冲，还需要一定的数据结构知识。队列是一种重要的数据结构，特点是FIFO（先进先出）的形式，在队首（front）出队，在队尾（rear）入队；   队列的实现可以用数组（顺序存储结构）和链表（链式存储结构）实现，但使用链表会产生额外的开销（存在指针域），对于单片机这类存储容量有限的微处理器，不是很实用。所以我们一般使用数组来实现队列。但是一般的队列也会存在溢出，无法重复利用空间。因为rear一直在增加，直到数组的容量最大值就无法使用了
STM32串口环形队列程序
04-15
该程序为大数据量吞吐的串口收发例程，中断接收，边收边发，采用大数据环形队列，处理过程超快不丢包，接收buffer可以定义成2K,4K,8K均可。也可以用到其余单片机上
STM32上使用的环形FIFO队列，用于缓存待发送数据
热门推荐
与其用泪水悔恨昨天，不如用汗水拼搏今天
04-04 1万+
C语言实现的环形FIFO队列，用于线程异步通信，数据发送非常方便，比如GPRS发送数据，一个线程将数据写入到FIFO，发送线程不停的从FIFO中读取数据，然后发送，又比如上位机中，数据接收线程不停的接收数据，写入到FIFO，另一个异步的处理线程不停的读取数据，进行处理。/****************************************************************...
环形队列FIFO
leolian
06-21 1590
建立自己的缓存区，可以有序的发送接收数据，不担心数据丢失，可以有序地处理。// ----------------------------------------------------------------------------- // File Name : fifo.h // Title : General FIFO template // Author :
九九乘法表
qq_40406144的博客
09-27 262
package zhang; public class ke{ public static void main(String[] args) { // TODO 自动生成的方法存根 int a,b; //定义数据类型 for(a=1;a<=9;a++){ //
stm32环形队列
06-17
stm32环形队列
基于stm32f407的串口环形队列及DMA收发中断数据处理
03-27
在串口通信中，环形队列可以用来存储接收或待发送的数据，确保数据不会因处理速度跟不上而丢失。当接收到中断信号时，DMA会将接收到的数据放入环形队列；同样，发送中断触发时，会从队列中取出数据进行发送。 在...
STM32进阶之串口环形缓冲区实现
10-01
- **环形队列**是队列的一种特殊形式，它利用了循环数组的思想，通过将数组尾部与头部相连，形成了一个逻辑上的环形结构。这样做的目的是为了提高队列的空间利用率，减少内存碎片，同时简化队列的操作。 #### 三、...
FIFO环形队列.rar
10-14
同样，在发送端，环形队列可预先填充待发送数据，等待合适的时机由串口发送出去，从而平滑通信过程。 具体到这个"FIFO环形队列.rar"压缩包，它可能包含以下内容：关于FIFO环形队列的理论介绍、STM32串口配置示例、...
STM32串口环形队列
07-13
STM32最大劣势：串口只有一个16bit，这样的话，串口接收时数据会丢失，本历程良好的解决这个存在的问题
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) ;
STM32进阶之串口环形缓冲区实现 FIFO
01-26
STM32进阶之串口环形缓冲区实现 FIFO，代码精简，易实现。
基于STM32F407的FIFO队列示例程序
05-18
基于STM32F407的FIFO队列示例程序，内存管理方式参照正点原子，注释详细，可以直接用。
环形（循环）队列在串口通信中的使用、代码-STM32-篇2
yuyan7045的博客
09-29 1272
这里以stm32为硬件平台，其他硬件平台可能就串口中断服务函数不一样，其它处理适用 1.串口接收 2.数据存入 3.数据读出
环形队列FIFO实现方法
DanielLee_ustb的专栏
01-06 7701
有的单片机串口没有FIFO，或者可分配的FIFO大小是非常有限的，如果在程序中需要向外设发送一个很大的数据包，需要很长的时间，为了解决应用程序与外设硬件读写同步的问题，很有必要自己实现环形FIFO。 #include "stdafx.h" #include #include using namespace std; #define  ERROR_FULL_W  -1 #define
FIFO队列二（静态环形队列实现）
hewenhu1989的博客
05-05 612
系列文章目录 FIFO队列一（原理） FIFO队列二（静态环形队列实现） 文章目录前言一、初始化队列二、队列是否为空三、队列 入队四、队列 出队五、队列是否为满六、测试 前言 硬件：百问网100ASK_STM32F103_MINI开发板（STM32F103C8T6） IDE：KEIL 5 按键GPIO口为：PA0 串口为：PA10（USART1_RX）、PA9（USART1_TX） 原理图如下： 提示：以下是本篇文章正文内容，下面案例可供参考 一、初始化队列 初始化就是Read = Write =0
[STM32]关于环形队列的实现
guanlizhongxintishi的博客
10-08 796
在程序中使用环形队列判断接收数据格式，避免在中断中处理造成程序响应速度慢的问题。 直接贴代码： LoopRxCommu.h #ifndef __LOOPRXCOMMU_H #define __LOOPRXCOMMU_H #include "hal_types.h" typedef struct{ volatile u16 out;//环形队列头 volatile u16 in;//环形队列尾(输入数据位置) volatile u8 *rbuf;//环形队列指针 volatile u16
DPDK（二）：准备知识4 --- 无锁FIFO环形队列
weixin_30274627的博客
03-16 765
原文：https://www.linuxidc.com/Linux/2016-12/137936.htm一、简介1、环形队列是一种特殊的队列结构，保证了元素也是先进先出的，但与一般队列的区别是，他们是环形的，即队列头部的上个元素是队列尾部，通常是容纳元素数固定的一个闭环。采用环形缓冲区的好处为，当一个数据元素被用掉后，其余数据元素不需要移动其存储位置，从而减少拷贝提高效率2、优点：保证元...
stm32fifo数据缓存
最新发布
08-15
- *2* *3* [STM32上使用的环形FIFO队列，用于缓存待发送数据](https://blog.csdn.net/cp1300/article/details/79822476)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值