接收发送循环队列C语言版

已于 2023-12-12 10:48:10 修改
阅读量727 收藏 6
点赞数 1
分类专栏： 嵌入式 文章标签： c语言 开发语言 数据结构 算法 单片机
于 2023-08-25 14:09:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_53828053/article/details/132494480
版权

1.适用于任何通信方式，主要是定时发送场景，已经线程之间的数据交互，可自定义数据类型，不局限于基本数据类型。

2.接口完善，实用性强，已分享给一部分人使用，反响非常好。

3.关注作者不迷路，更多使用的C实用库待你挖掘。

4.无需移植可直接使用。

/*********************************************************************************
  *Copyright(C) -
  *FileName: queue.c
  *Author: 我不是阿沸
  *Version: 6.1.0
  *Date: 2023.08.20
  *Description:  循环数据队列，用于带操作系统的串口发送与接收，或者线程间数据量很大的通信。  
  *Others:  使用接口前一定调用初始化接口，这里适配了rt_thread与FreeRTOS数据安全接口，如需要使用可以打开相关
  			宏定义，其他操作系统数据安全需自行实现  
  *History:  
  	 1.Date:2023/04/03
       Author:我不是阿沸 
       Modification:增加数据安全保护，适配RT-Thread与FreeRTOS 
     2.Date:2023/05/16
       Author:我不是阿沸 
       Modification:修改相关接口实现方式 
     3.Date:2023/07/18
       Author:我不是阿沸 
       Modification:增加超时机制 
     4.Date:2023/08/20
       Author:我不是阿沸 
       Modification:修改原有固定数据类型为自定义数据类型 
	 5.其他修改 
**********************************************************************************/


#include <stdio.h> 
#include <string.h>


#define FREERTOSLOCK 0
#define RTTHREADLOCK 0
#define QUEUEDELAY(x) ;//SYSTEMDELAY(x)

#if FREERTOSLOCK
typedef struct{
	void * queue;
	int size;
	int number;
	StaticSemaphore_t xMutexBuffer;
  	SemaphoreHandle_t xSemaphore;
	int rear;  //队尾
	int front; //对头 
}LzQueue; //队列结构体 

#elif RTTHREADLOCK

/**
  * @brief  队列管理类 
  * @param  队列数据缓存首地址.
  * @param  队列中元素的大小 
  * @param  队列中元素的个数 
  * @param  队列保护信号量 
  * @param  队列头 
  * @param  队列尾 
  */
typedef struct{
	void * queue;
	int size;
	int number;
	struct rt_mutex rt_mutex_t;
	int rear;  //队尾
	int front; //对头 
}LzQueue; //队列结构体 


#else


typedef struct{
	void * queue;
	int size;
	int number;
	int rear;  //队尾
	int front; //对头 
}LzQueue; //队列结构体

#endif

#if FREERTOSLOCK
#define QUEUEDELAY(x) vTaskDelay(x)
#endif


void queueInitiate(LzQueue *Q, void * buffer, int number, int size);
int isFull(LzQueue * Q);
int isEmpty(LzQueue * Q);
int putQueue(LzQueue * Q, void * d);
int putQueueBt(LzQueue * Q, void * d, int outtime);
int getQueue(LzQueue *Q, void * d);
void clearQueue(LzQueue *Q);
int putQueueNoWait(LzQueue * Q, void * d);


/**
  * @brief  初始化队列
  * @param  队列管理者地址.
  * @param  队列数据缓存地址 
  * @param  队列元素数量 
  * @param  队列元素大小
  * @retval None
  */ 
void queueInitiate(LzQueue *Q, void * buffer, int number, int size){
   
	#if FREERTOSLOCK
    Q->xSemaphore = xSemaphoreCreateMutexStatic(&(Q->xMutexBuffer));
    if(Q->xSemaphore == NULL) while(1);
    if ( xSemaphoreGive( Q->xSemaphore ) != pdTRUE ) {
        /* 如果要释放一个互斥量，必须先有第一次的获取*/
    }
	
    xSemaphoreTake(Q->xSemaphore, portMAX_DELAY); 
	#elif RTTHREADLOCK
	if(RT_EOK != rt_mutex_init( &(Q->rt_mutex_t), "linze Q lock", RT_IPC_FLAG_FIFO)){
		//while(1);
		return;
	}
	
	#endif
		Q->queue = buffer;
		Q->number = number;
		Q->size = size;
		Q->front = 0;  //初始化对头 ，指向队列头部的前一个位置 
		Q->rear = 0;  //初始化队尾 ，指向队列尾部的具体数据
	
	#if FREERTOSLOCK
    xSemaphoreGive(Q->xSemaphore );
	#elif RTTHREADLOCK
		rt_mutex_release(&(Q->rt_mutex_t));
	#endif
}

/**
  * @brief  判断队列是否为满 
  * @param  队列管理者地址.
  * @retval 队列满返回 1，否则返回 0 
  */ 
int isFull(LzQueue * Q){
	#if FREERTOSLOCK
    xSemaphoreTake(Q->xSemaphore, portMAX_DELAY); 
	#elif RTTHREADLOCK
		rt_mutex_take(&(Q->rt_mutex_t), RT_WAITING_FOREVER);
  #endif
	if(((Q->rear+1)%Q->number) == Q->front)
    {
			#if FREERTOSLOCK
        xSemaphoreGive(Q->xSemaphore ); 
			#elif RTTHREADLOCK
				rt_mutex_release(&(Q->rt_mutex_t));
			#endif
        return 1;  //队列满返回1 
    }
	#if FREERTOSLOCK
		xSemaphoreGive(Q->xSemaphore );
	#elif RTTHREADLOCK
		rt_mutex_release(&(Q->rt_mutex_t));
	#endif
	return 0;  //队列没满返回0 	
} 

/**
  * @brief  判断队列是否空  
  * @param  队列管理者地址.
  * @retval 队列空返回 1，否则返回 0 
  */ 
int isEmpty(LzQueue *Q){
	#if FREERTOSLOCK
		BaseType_t xReturn = pdPASS;
		xSemaphoreTake(Q->xSemaphore, portMAX_DELAY);
	#elif RTTHREADLOCK
		rt_mutex_take(&(Q->rt_mutex_t), RT_WAITING_FOREVER);
	#endif
	if(Q->rear == Q->front){
		#if FREERTOSLOCK
				xSemaphoreGive(Q->xSemaphore );
		#elif RTTHREADLOCK
			rt_mutex_release(&(Q->rt_mutex_t));
		#endif
				return 1;  //队列空返回1
	}
	#if FREERTOSLOCK
    xSemaphoreGive(Q->xSemaphore );
	#elif RTTHREADLOCK
			rt_mutex_release(&(Q->rt_mutex_t));
	#endif
    return 0;  //队列空返回1
}


/**
  * @brief  添加数据到队列  
  * @param  队列管理者地址， 需要添加的数据 
  * @retval 添加成功返回 1，失败返回 0 
  */ 
int putQueue(LzQueue * Q, void * d) {
	while( isFull(Q) ) {  //判断队列是否满，满了就无法添加数据
		QUEUEDELAY(1);
	}
	#if FREERTOSLOCK
		xSemaphoreTake(Q->xSemaphore, portMAX_DELAY);
	#elif RTTHREADLOCK
		rt_mutex_take(&(Q->rt_mutex_t), RT_WAITING_FOREVER);
	#endif
	memcpy((unsigned char *)(Q->queue)+(Q->rear*Q->size), d, Q->size);
    
	Q->rear = (Q->rear+1)% (Q->number);
	#if FREERTOSLOCK
		xSemaphoreGive(Q->xSemaphore );
	#elif RTTHREADLOCK
			rt_mutex_release(&(Q->rt_mutex_t));
	#endif
	return 1;
}

/**
  * @brief  添加数据到队列,不带等待  
  * @param  队列管理者地址
  * @param  需要添加的数据 
  * @retval 添加成功返回 1，失败返回 0 
  */ 
int putQueueNoWait(LzQueue * Q, void * d) {
	if( isFull(Q) ) {  //判断队列是否满，满了就无法添加数据
		return 0;
	}
	#if FREERTOSLOCK
		xSemaphoreTake(Q->xSemaphore, portMAX_DELAY);
	#elif RTTHREADLOCK
		rt_mutex_take(&(Q->rt_mutex_t), RT_WAITING_FOREVER);
	#endif
	memcpy((unsigned char *)(Q->queue)+(Q->rear*Q->size), d, Q->size);
    
	Q->rear = (Q->rear+1)% (Q->number);
	#if FREERTOSLOCK
		xSemaphoreGive(Q->xSemaphore );
	#elif RTTHREADLOCK
			rt_mutex_release(&(Q->rt_mutex_t));
	#endif
	return 1;
}


/**
  * @brief  添加数据到队列，带等待超时机制 
  * @param  队列管理者地址， 
  * @param  需要添加的数据 
  * @param  等待时间 
  * @retval 成功返回 1，失败返回 0 
  */ 
int putQueueBt(LzQueue * Q, void * d, int outtime) {
	while(isFull(Q))
    {
        outtime--;
        QUEUEDELAY(1);
        if(outtime < 1) return 0;
    }
	#if FREERTOSLOCK
    xSemaphoreTake(Q->xSemaphore, portMAX_DELAY);
	#elif RTTHREADLOCK
		rt_mutex_take(&(Q->rt_mutex_t), RT_WAITING_FOREVER);
	#endif
    memcpy((unsigned char *)(Q->queue)+(Q->rear*Q->size), d, Q->size);
	Q->rear = (Q->rear+1)% (Q->number);
    #if FREERTOSLOCK
	xSemaphoreGive(Q->xSemaphore );
	#elif RTTHREADLOCK
			rt_mutex_release(&(Q->rt_mutex_t));
	#endif
	return 1;
}

/**
  * @brief  从队列获取数据 
  * @param  队列管理者地址， 
  * @param  数据目标存放地址 
  * @retval 成功返回 1，失败返回 0 
  */ 
int getQueue(LzQueue *Q, void * d){

	if(isEmpty(Q)){
		return 0;
	} 
	#if FREERTOSLOCK
		xSemaphoreTake(Q->xSemaphore, portMAX_DELAY);
	#elif RTTHREADLOCK
		rt_mutex_take(&(Q->rt_mutex_t), RT_WAITING_FOREVER);
	#endif
    memcpy(d, (unsigned char *)(Q->queue)+(Q->front*Q->size), Q->size);
	Q->front = (Q->front+1)%(Q->number);
	#if FREERTOSLOCK
		xSemaphoreGive(Q->xSemaphore );
	#elif RTTHREADLOCK
		rt_mutex_release(&(Q->rt_mutex_t));
	#endif
	return 1;
} 

/**
  * @brief  清空队列所有数据 
  * @param  队列管理者地址 
  * @retval None
  */ 
void clearQueue(LzQueue *Q)
{
	#if FREERTOSLOCK
		xSemaphoreTake(Q->xSemaphore, portMAX_DELAY);
	#elif RTTHREADLOCK
		rt_mutex_take(&(Q->rt_mutex_t), RT_WAITING_FOREVER);
	#endif
	Q->front =0;
    Q->rear = 0;
	#if FREERTOSLOCK
		xSemaphoreGive(Q->xSemaphore);
	#elif RTTHREADLOCK
		rt_mutex_release(&(Q->rt_mutex_t));
	#endif
}



/****演示示例****/
typedef struct{
	int age;
	int high;
	double xg;
	char name[40];
}test;

typedef struct{
	char buffer[20];
	int len;
}test1;

LzQueue lz;
test t1[20];


//添加数据到队列，模拟串口发送数据，但不直接调用硬件接口，这样就可以提高效率
//应为串口发送需要一定的时间，有可能会阻碍当前线程的运行,可搭配任务栈使用 
//在开一个线程专门获取这个队列的数据进行发送（多个串口一样的），提高了效率以及通信的可靠性 
int fun1(void){
	test t;
	if(!isEmpty(&lz)){
		getQueue(&lz, (void*)&t);
		printf("name:%s, age:%d...\n", t.name, t.age);
	}
	
} 

int fun2(test * t){
	if(!isFull(&lz)){
		putQueueNoWait(&lz, (void*)t);
	}
}

int main(void){
	queueInitiate(&lz, (void *)&t1, 20, sizeof(test));
	test t2 = {22, 180, 120, "I'm not Ah Fei"};
	printf("name:%s, age:%d...\n", t2.name, t2.age);
	while(1){
		fun2(&t2);
		fun1();
		
	}
	return 0;	
}

基于FAST的TSN交换（3）TSN循环队列转发（CQF）原理
m0_37537704的博客
02-02 7863
基于FAST的TSN交换（3）TSN循环队列转发（CQF）原理     为了支持确定性的交换，TSN对802.1Q-2014标准进行了扩充。其中单流过滤和管控机制（PSFP）中的时间门控逻辑控制了时间敏感分组进入缓存队列的时间，而时间敏感流增强调度（EST）机制中的输出门控机制控制了分组离开输出队列的时间。基于对PSFP和EST机制的不同配置，TSN交换机可以实现多样的确定性转发，满足不同场景...
c语言串口接收队列,队列方法接收串口的数据
weixin_39602579的博客
05-19 2008
通常在接收串口数据时，往往由于发送端发送数据量太快导致接收端无法完全接收发送过来的数据。原因是还没有来得急处理数据，后面的数据已将前面数据覆盖。所以在处理此问题时，必须用队列的方式处理串口的数据。。即把接收数据和处理数据分开处理。用缓冲的方法，如下。。typedef struct{unsigned int UsartRxbuf[1000]; //接收串口bufunsigned int *Usar...
C语言实现消息队列（附带源码）
最新发布
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
02-06 1095
本文详细介绍了如何使用C语言实现消息队列，从项目背景、需求分析、设计思路、完整代码实现、代码详细解读到项目总结与扩展思考，层层深入讲解了消息队列的实现原理和关键技术。通过本项目，读者不仅可以掌握基于链表实现消息队列的基本方法，还能体会到模块化设计、动态内存管理、错误处理以及数据结构选择对系统性能和扩展性的影响。
转发:c/c++循环队列
weixin_43266021的博客
05-23 1236
if ((Q.rear + 1) % MaxSize == Q.front)//尾指针的下一个存储单元就是头指针，这个状态。原文链接：https://blog.youkuaiyun.com/m0_63112274/article/details/135789321。cout << "元素个数为：" << len << endl;cout << "出队元素为：" << e << endl;cout << "队头元素为：" << e << endl;
循环队列(数组实现)
weixin_34168700的博客
09-30 322
1 #include <stdio.h> 2 #include <stdlib.h> 3 4 #define false 0 5 #define true 1 6 7 typedef int ElementType; 8 typedef int Position; 9 typedef int bool; 10...
【队列之循环队列】
edwer93的博客
12-09 659
循环队列： 循环队列是 队列的一种特殊形式 队列又称为“先进先出”线性表 限定插入操作只能在队尾进行，而删除操作只能在队首进行 队列可以采用顺序存储结构（数组实现） 主要是利用%来实现循环` 代码实现如下： public class Queue { public static void main(String[] args) { Queue queue=new Queue(); queue.add(1); queue.get(); } public int[] arr= n
一个串口循环队列，可以制作协议收发，非常好用
06-15
结合上述知识点，这个“标准版串口循环队列”项目很可能是实现了一个高效的数据收发解决方案，它利用循环队列来存储485通信接收到的数据，并且可能包含了自定义的协议解析功能，以处理这些数据。在实际应用中，这样...
array_串口队列_循环队列_
10-01
2. **发送数据**：同样，待发送的数据可以先放入循环队列，当串口准备好时，再从队列中取出数据发送，避免了等待数据准备的时间，提高了效率。 3. **流量控制**：循环队列可以作为简单的流量控制机制，当队列满时，...
51单片机的FIFO（先入先出）循环队列实现
07-25
在串口通信中，如果需要对发送或接收的数据进行缓存，可以利用循环队列将接收到的数据存起来，当有数据处理函数需要这些数据时，可以按顺序一个一个地取出数据进行处理。 为了更好地理解51单片机实现FIFO循环队列的...
串口缓冲区 循环队列
09-12
在Keil for ARM 5.10开发环境中，开发者可以利用C语言编写串口接收中断服务程序，当串口接收到数据时，中断会被触发，此时在中断处理函数中，将接收到的数据插入到循环队列中。同时，需要在主循环或其他合适的地方...
Unity C# 基于SerialPort类实现串口通信并循环读写
qq_34772760的博客
04-06 4021
Unity C# 基于SerialPort类实现串口通信并循环读写
循环队列的实现
Hpsyche的博客
11-03 495
一、实验目的 1、   熟练掌栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。 2、   学会使用栈和队列解决实际问题。   二、实验内容 确定结点的具体数据类型和问题规模： 建立一个循环队列，实现队列的入队和出队操作。   三、源代码 #CirQueue.h文件   const int QueueSize = 100; template&lt;class ...
瞬解 队列 -- 循环队列问题（超超超详解）
qq_61344207的博客
03-29 1534
详解 队列 -- 循环队列的构造方法 让你对于这道题直接瞬间干掉！！！
常用单片机编程思想及例程5——循环队列（fifo+串口）
陈大本事的博客
09-23 2448
串口+循环队列实现数据收发
IEEE 802.1 Qch 协议的详细总结（循环排队和转发CQF）
qq_53273581的博客
11-15 6940
循环排队转发(CQF)是一种流量整形方法，可以为时间敏感流提供确定的、易于计算的延迟。顾名思义，CQF的基本原理是流-流量以循环的方式沿着网络路径进行传输和排队传输。时间被划分为有编号的时间间隔 i， i+1， i+2，…，i+N，每个持续时间为 d。桥 Alice 在时间间隔 i 期间传输的帧被下游桥Bob在时间间隔 i 期间接收，并由 Bob 在时间间隔 i+1 期间向桥 Charlie 转发，依此类推。
C语言使用pthread实现udp接受/发送消息，并读写循环队列
weixin_43940483的博客
11-06 372
/ 目标主机的IP地址。// 目标主机的端口号。// 发送目标主机地址。// 接收服务器主机地址。// 接收Socket 描述符。} // 设置目标主机的地址信息。
rt-thread队列使用
hgfjv的博客
05-09 525
线程读写消息队列时，如果读写不成功，可以即刻返回错误，也可以阻塞。消息是一种遵循先进先出的原则，比如装酒的漏斗，先倒进去的先流出来，是一个道理的。哪个线程先放数据，那么其他线程在读的时候，一定是先读到最早放入的那个数据，看下面的示意图就明白了。 多个线程都想写队列，但是队列已经满了，这些线程可以进入阻塞状态：它们都在等待队列有空间。 多个线程都想读队列，但是队列已经空了，这些线程可以进入阻塞状态：它们都在等待队列有数据。 在指定的时间内，别的线程或者中断服务程序写了队列，会把它唤醒。
串口通信——接收串口数据并处理（C语言）_c语言串口接收数据存入数组
2401_85013211的博客
05-15 763
/根据实际情况选择串口。if(set_Parity(fd,8,1,‘N’)==FALSE) //设置校验位。switch (stopbits)/*设置停止位*/
循环队列
James_bobo的博客
09-18 3470
循环队列是 队列的一种特殊形式。首先介绍队列，然后引申出循环队列。 队列又称为“先进先出”(FIFO)线性表 限定插入操作只能在队尾进行，而删除操作只能在队首进行 队列也可以采用顺序存储结构或链表结构来实现，分别称为顺序队列和链队列 队列的顺序表示—顺序队列 用一组连续的存储单元依次存放从队首到队尾的元素，附设两个指针head和tail分别指向队首元素和队尾元素的位置， (有的地方用front 和 rear 表示) 当head = tail = 0时表示空队列 当插入新元素到队尾时，tail加1 当删
C语言实现高效循环队列Ringbuffer
环形缓冲区可以在接收和发送数据时提供临时存储，以应对通信速率不匹配的情况，保证数据的完整性和顺序性。 2. 实时数据采集：在需要对传感器数据进行实时采集的系统中，环形缓冲区可以用来临时存储采样数据，直到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值