μC/OS-II---消息队列管理1（os_q.c）

news2024/10/7 4:24:49

目录

  • 消息队列的主要优点
  • 消息队列和消息邮箱
  • 消息队列相关操作
    • 消息队列创建
    • 消息队列删除
    • 在消息队列等待消息

在这里插入图片描述

消息队列的主要优点

  • 消息队列的主要优点是解耦和异步通信。发送者和接收者之间不需要直接建立连接，它们只需要知道消息队列的名称或标识符即可。发送者将消息发送到队列中后，可以继续执行其他任务，而不需要等待接收者处理消息。接收者可以在合适的时候从队列中获取消息进行处理，这样可以实现异步通信，提高系统的并发性和响应性。
  • 通常会在消息队列中引入消息标识符或者消息类型。发送者在发送消息时，会附带一个标识符或类型，接收者在接收消息时，会根据标识符或类型来判断是否是自己需要处理的消息。这样可以确保每个进程只处理属于自己的消息，避免了拿错信息的问题。
  • 此外，还可以使用互斥锁或其他同步机制来保证在读取和写入消息队列时的原子性操作，避免多个进程同时对消息队列进行读写操作而导致的竞争条件。

消息队列和消息邮箱

  • 消息队列是一个独立的数据结构，多个进程可以共享同一个消息队列，而消息邮箱是与进程关联的，每个进程都有自己的邮箱。此外，消息队列通常是先进先出（FIFO）的，而消息邮箱可以根据实现方式不同具有不同的特性，比如可以是先进先出或者按优先级处理消息。
  • Task也可以设计有“私有”消息队列模式。
  • 总的来说，消息队列更适合实现多个进程之间的解耦和异步通信，而消息邮箱更适合实现单个进程内的消息传递。

消息队列相关操作

消息队列创建

OS_EVENT  *OSQCreate (void    **start,
											INT16U    size)
{
	OS_EVENT  *pevent;
	OS_Q      *pq;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */
	OS_CPU_SR  cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL_IEC61508
	
	if (OSSafetyCriticalStartFlag == OS_TRUE)
	{
		OS_SAFETY_CRITICAL_EXCEPTION();
		return ((OS_EVENT *)0);
	}
	
#endif
	
	if (OSIntNesting > 0u)                       /* See if called from ISR ...                         */
	{
		return ((OS_EVENT *)0);                  /* ... can't CREATE from an ISR                       */
	}
	
	OS_ENTER_CRITICAL();
	pevent = OSEventFreeList;                    /* Get next free event control block                  */
	
	if (OSEventFreeList != (OS_EVENT *)0)        /* See if pool of free ECB pool was empty             */
	{
		OSEventFreeList = (OS_EVENT *)OSEventFreeList->OSEventPtr;
	}
	
	OS_EXIT_CRITICAL();
	
	if (pevent != (OS_EVENT *)0)                 /* See if we have an event control block              */
	{
		OS_ENTER_CRITICAL();
		pq = OSQFreeList;                        /* Get a free queue control block                     */
		
		if (pq != (OS_Q *)0)                     /* Were we able to get a queue control block ?        */
		{
			OSQFreeList            = OSQFreeList->OSQPtr; /* Yes, Adjust free list pointer to next free*/
			OS_EXIT_CRITICAL();
			pq->OSQStart           = start;               /*      Initialize the queue                 */
			pq->OSQEnd             = &start[size];
			pq->OSQIn              = start;
			pq->OSQOut             = start;
			pq->OSQSize            = size;
			pq->OSQEntries         = 0u;
			pevent->OSEventType    = OS_EVENT_TYPE_Q;
			pevent->OSEventCnt     = 0u;
			pevent->OSEventPtr     = pq;
#if OS_EVENT_NAME_EN > 0u
			pevent->OSEventName    = (INT8U *) (void *)"?";
#endif
			OS_EventWaitListInit (pevent);                /*      Initialize the wait list             */
		}
		
		else
		{
			pevent->OSEventPtr = (void *)OSEventFreeList; /* No,  Return event control block on error  */
			OSEventFreeList    = pevent;
			OS_EXIT_CRITICAL();
			pevent = (OS_EVENT *)0;
		}
	}
	
	return (pevent);
}

消息队列删除

#if OS_Q_DEL_EN > 0u
OS_EVENT  *OSQDel (OS_EVENT  *pevent,
									 INT8U      opt,
									 INT8U     *perr)
{
	BOOLEAN    tasks_waiting;
	OS_EVENT  *pevent_return;
	OS_Q      *pq;
#if OS_CRITICAL_METHOD == 3u                               /* Allocate storage for CPU status register */
	OS_CPU_SR  cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
	
	if (perr == (INT8U *)0)
	{
		OS_SAFETY_CRITICAL_EXCEPTION();
		return ((OS_EVENT *)0);
	}
	
#endif
#if OS_ARG_CHK_EN > 0u
	
	if (pevent == (OS_EVENT *)0)                           /* Validate 'pevent'                        */
	{
		*perr = OS_ERR_PEVENT_NULL;
		return (pevent);
	}
	
#endif
	
	if (pevent->OSEventType != OS_EVENT_TYPE_Q)            /* Validate event block type                */
	{
		*perr = OS_ERR_EVENT_TYPE;
		return (pevent);
	}
	
	if (OSIntNesting > 0u)                                 /* See if called from ISR ...               */
	{
		*perr = OS_ERR_DEL_ISR;                            /* ... can't DELETE from an ISR             */
		return (pevent);
	}
	
	OS_ENTER_CRITICAL();
	
	if (pevent->OSEventGrp != 0u)                          /* See if any tasks waiting on queue        */
	{
		tasks_waiting = OS_TRUE;                           /* Yes                                      */
	}
	
	else
	{
		tasks_waiting = OS_FALSE;                          /* No                                       */
	}
	
	switch (opt)
	{
		case OS_DEL_NO_PEND:                               /* Delete queue only if no task waiting     */
			if (tasks_waiting == OS_FALSE)
			{
#if OS_EVENT_NAME_EN > 0u
				pevent->OSEventName    = (INT8U *) (void *)"?";
#endif
				pq                     = (OS_Q *)pevent->OSEventPtr;  /* Return OS_Q to free list     */
				pq->OSQPtr             = OSQFreeList;
				OSQFreeList            = pq;
				pevent->OSEventType    = OS_EVENT_TYPE_UNUSED;
				pevent->OSEventPtr     = OSEventFreeList; /* Return Event Control Block to free list  */
				pevent->OSEventCnt     = 0u;
				OSEventFreeList        = pevent;          /* Get next free event control block        */
				OS_EXIT_CRITICAL();
				*perr                  = OS_ERR_NONE;
				pevent_return          = (OS_EVENT *)0;   /* Queue has been deleted                   */
			}
			
			else
			{
				OS_EXIT_CRITICAL();
				*perr                  = OS_ERR_TASK_WAITING;
				pevent_return          = pevent;
			}
			
			break;
			
		case OS_DEL_ALWAYS:                                /* Always delete the queue                  */
			while (pevent->OSEventGrp != 0u)              /* Ready ALL tasks waiting for queue        */
			{
				(void)OS_EventTaskRdy (pevent, (void *)0, OS_STAT_Q, OS_STAT_PEND_ABORT);
			}
			
#if OS_EVENT_NAME_EN > 0u
			pevent->OSEventName    = (INT8U *) (void *)"?";
#endif
			pq                     = (OS_Q *)pevent->OSEventPtr;   /* Return OS_Q to free list        */
			pq->OSQPtr             = OSQFreeList;
			OSQFreeList            = pq;
			pevent->OSEventType    = OS_EVENT_TYPE_UNUSED;
			pevent->OSEventPtr     = OSEventFreeList;     /* Return Event Control Block to free list  */
			pevent->OSEventCnt     = 0u;
			OSEventFreeList        = pevent;              /* Get next free event control block        */
			OS_EXIT_CRITICAL();
			
			if (tasks_waiting == OS_TRUE)                 /* Reschedule only if task(s) were waiting  */
			{
				OS_Sched();                               /* Find highest priority task ready to run  */
			}
			
			*perr                  = OS_ERR_NONE;
			pevent_return          = (OS_EVENT *)0;       /* Queue has been deleted                   */
			break;
			
		default:
			OS_EXIT_CRITICAL();
			*perr                  = OS_ERR_INVALID_OPT;
			pevent_return          = pevent;
			break;
	}
	
	return (pevent_return);
}
#endif

在消息队列等待消息

void  *OSQPend (OS_EVENT  *pevent,
								INT32U     timeout,
								INT8U     *perr)
{
	void      *pmsg;
	OS_Q      *pq;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */
	OS_CPU_SR  cpu_sr = 0u;
#endif
#ifdef OS_SAFETY_CRITICAL
	
	if (perr == (INT8U *)0)
	{
		OS_SAFETY_CRITICAL_EXCEPTION();
		return ((void *)0);
	}
	
#endif
#if OS_ARG_CHK_EN > 0u
	
	if (pevent == (OS_EVENT *)0)                 /* Validate 'pevent'                                  */
	{
		*perr = OS_ERR_PEVENT_NULL;
		return ((void *)0);
	}
	
#endif
	
	if (pevent->OSEventType != OS_EVENT_TYPE_Q)  /* Validate event block type                          */
	{
		*perr = OS_ERR_EVENT_TYPE;
		return ((void *)0);
	}
	
	if (OSIntNesting > 0u)                       /* See if called from ISR ...                         */
	{
		*perr = OS_ERR_PEND_ISR;                 /* ... can't PEND from an ISR                         */
		return ((void *)0);
	}
	
	if (OSLockNesting > 0u)                      /* See if called with scheduler locked ...            */
	{
		*perr = OS_ERR_PEND_LOCKED;              /* ... can't PEND when locked                         */
		return ((void *)0);
	}
	
	OS_ENTER_CRITICAL();
	pq = (OS_Q *)pevent->OSEventPtr;             /* Point at queue control block                       */
	
	if (pq->OSQEntries > 0u)                     /* See if any messages in the queue                   */
	{
		pmsg = *pq->OSQOut++;                    /* Yes, extract oldest message from the queue         */
		pq->OSQEntries--;                        /* Update the number of entries in the queue          */
		
		if (pq->OSQOut == pq->OSQEnd)            /* Wrap OUT pointer if we are at the end of the queue */
		{
			pq->OSQOut = pq->OSQStart;
		}
		
		OS_EXIT_CRITICAL();
		*perr = OS_ERR_NONE;
		return (pmsg);                           /* Return message received                            */
	}
	
	OSTCBCur->OSTCBStat     |= OS_STAT_Q;        /* Task will have to pend for a message to be posted  */
	OSTCBCur->OSTCBStatPend  = OS_STAT_PEND_OK;
	OSTCBCur->OSTCBDly       = timeout;          /* Load timeout into TCB                              */
	OS_EventTaskWait (pevent);                   /* Suspend task until event or timeout occurs         */
	OS_EXIT_CRITICAL();
	OS_Sched();                                  /* Find next highest priority task ready to run       */
	OS_ENTER_CRITICAL();
	
	switch (OSTCBCur->OSTCBStatPend)                  /* See if we timed-out or aborted                */
	{
		case OS_STAT_PEND_OK:                         /* Extract message from TCB (Put there by QPost) */
			pmsg =  OSTCBCur->OSTCBMsg;
			*perr =  OS_ERR_NONE;
			break;
			
		case OS_STAT_PEND_ABORT:
			pmsg = (void *)0;
			*perr =  OS_ERR_PEND_ABORT;               /* Indicate that we aborted                      */
			break;
			
		case OS_STAT_PEND_TO:
		default:
			OS_EventTaskRemove (OSTCBCur, pevent);
			pmsg = (void *)0;
			*perr =  OS_ERR_TIMEOUT;                  /* Indicate that we didn't get event within TO   */
			break;
	}
	
	OSTCBCur->OSTCBStat          =  OS_STAT_RDY;      /* Set   task  status to ready                   */
	OSTCBCur->OSTCBStatPend      =  OS_STAT_PEND_OK;  /* Clear pend  status                            */
	OSTCBCur->OSTCBEventPtr      = (OS_EVENT  *)0;    /* Clear event pointers                          */
#if (OS_EVENT_MULTI_EN > 0u)
	OSTCBCur->OSTCBEventMultiPtr = (OS_EVENT **)0;
#endif
	OSTCBCur->OSTCBMsg           = (void      *)0;    /* Clear  received message                       */
	OS_EXIT_CRITICAL();
	return (pmsg);                                    /* Return received message                       */
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1211678.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Springboot项目中打印SQL语句日志

Springboot项目中打印SQL语句日志

在项目中我想查看自己的SQL语句是什么，就是如下图的内容： 方法一：（我常用的） 可以在项目中的.yml配置文件中添加如下内容： logging:level:com.uyun.bankbranchalert.mapper: debug其中com.uyun.bankbran…
阅读更多...
Postman+Newman+Jenkins实现接口测试持续集成

Postman+Newman+Jenkins实现接口测试持续集成

近期在复习Postman的基础知识，在小破站上跟着百里老师系统复习了一遍，也做了一些笔记，希望可以给大家一点点启发。 1.新建一个项目 2.设置自定义工作空间 3.执行windows的批处理命令 4.执行系统的Groovy脚本 5.生成的HTML的报告集成到Jenkin…
阅读更多...
测试用例的书写方式以及测试模板大全

测试用例的书写方式以及测试模板大全

一个优秀的测试用例，应该包含以下信息： 1 ） 软件或项目的名称 2 ） 软件或项目的版本（内部版本号） 3 ） 功能模块名 4 ） 测试用例的简单描述，即该用例执行的目的或方法…
阅读更多...
【nlp】2.3 LSTM模型

【nlp】2.3 LSTM模型

LSTM模型 1 LSTM介绍2 LSTM的内部结构图2.1 LSTM结构分析2.2 Bi-LSTM介绍2.3 使用Pytorch构建LSTM模型2.4 LSTM优缺点1 LSTM介绍 LSTM（Long Short-Term Memory）也称长短时记忆结构， 它是传统RNN的变体，与经典RNN相比能够有效捕捉长序列之间的语义关联，缓解梯度消失或爆炸…
阅读更多...
立仪科技光谱共焦在半导体领域的应用

立仪科技光谱共焦在半导体领域的应用

半导体技术在近年来以极快的速度发展，对质量和精密度的要求也不断提升。在这样的背景下，用于材料与设备研究的先进检测技术如光谱共焦成像将自然地找到一席之地。下面我们将详细探讨一下光谱共焦在半导体领域中的应用。 光谱共焦技术，通过在细…
阅读更多...
互斥量保护资源

互斥量保护资源

一、概念 在多数情况下，互斥型信号量和二值型信号量非常相似，但是从功能上二值型信号量用于同步， 而互斥型信号量用于资源保护。 互斥型信号量和二值型信号量还有一个最大的区别，互斥型信号量可以有效解决优先级反转现 象。 …
阅读更多...
Spring Cloud Netflix微服务组件-Eureka

Spring Cloud Netflix微服务组件-Eureka

CAP理论 分区容忍是能容忍一个或一部分节点挂掉后，整体系统也能正常工作（就是别的节点还是活着的），所以分布式系统中P是必须要有的。比如数据库主从架构，主从两个节点之间需要数据同步，主挂了，…
阅读更多...
Mybatis中limit用法补充

Mybatis中limit用法补充

limit a,b a是从第a1条数据开始，b是指读取几条数据 例如：select * from table limit 0,10 这句sql语句是说从表中获取第1条开始的10条记录 前端将page:页码 　　　pageSize:每页多少条 　　　这两个参数，传到后台。 　　 通过这两个参数&am…
阅读更多...
火焰图：链路追踪分析的可视化利器

火焰图：链路追踪分析的可视化利器

什么是火焰图？ 火焰图用于可视化分布式链路追踪，通过使用持续时间和不同颜色的水平条形来表示请求执行路径中的每个服务调用。分布式跟踪的火焰图包括错误、延迟数据等详情，帮助开发人员识别和解决应用程序中的瓶颈问题。 链路追踪与 Span …
阅读更多...
易货：一种古老而有效的商业模式

易货：一种古老而有效的商业模式

在当今的商业世界中，我们常常听到关于电子商务、互联网和社交媒体等新技术的讨论。然而，尽管这些新技术为我们的日常生活带来了许多便利，但它们并没有完全取代传统的商业模式。其中，易货模式是一种古老而有效的商业模式&#xff0…
阅读更多...
AI绘画工具汇总

AI绘画工具汇总

目前市面上的AI绘画工具十分繁杂，以下工具可供参考： 1. Midjourney 添加图片注释，不超过 140 字（可选） Midjourney：最主流的AI绘图工具之一，出图效果好，简单学习就可上手。需要在di…
阅读更多...
Golang获取月份的第一天和最后一天

Golang获取月份的第一天和最后一天

package mainimport ("fmt""strconv""strings""time" )func main() {month : "2023-11"result : GetMonthStartAndEnd(month)fmt.Println(result["start"] " - " result["end"]) }// 获取月…
阅读更多...
Stable Diffusion WebUI使用AnimateDiff插件生成动画

Stable Diffusion WebUI使用AnimateDiff插件生成动画

AnimateDiff 可以针对各个模型生成的图片，一键生成对应的动图。 配置要求 GPU显存建议12G以上，在xformers或者sdp优化下显存要求至少6G以上。 要开启sdp优化，在启动参数加上--sdp-no-mem-attention 实际的显存使用量取决于图像大小&#…
阅读更多...
StatSVN统计svn项目中每人代码提交量

StatSVN统计svn项目中每人代码提交量

一.JDK配置 StatSVN是java语言开发的，要运行必须先安装jdk并配置环境变量。 1.jdk下载地址https://www.oracle.com/ 2.jdk环境变量配置，路径为jdk安装位置 二.下载StatSVN 1.下载地址 http://sourceforge.net/projects/statsvn/ 2.解压到本地目录&a…
阅读更多...
【Oracle 客户端连接数据库过程解析】

【Oracle 客户端连接数据库过程解析】

文章目录 一、开篇二、Oracle客户端简介三、连接过程解析 一、开篇 Oracle数据库以其卓越的性能和稳定性赢得了众多企业的信赖。作为开发者或数据库管理员，理解Oracle客户端如何与数据库建立连接，是确保系统正常运行的关键。 二、Oracle客户端简介 首…
阅读更多...
Facebook游戏出海营销指南

Facebook游戏出海营销指南

当谈到Facebook游戏出海营销时，有一些关键的策略和指南可以帮助你在国际市场上取得成功。下面是一个详细的指南，帮助你了解如何有效地推广和推出你的游戏。 1、了解目标市场 在开始出海营销之前，你需要对你的目标市场进行深入的研究。了解该…
阅读更多...
【功能栏】基于session的模拟短信注册功能

【功能栏】基于session的模拟短信注册功能

框架： spring boot mybatis-plus 目录 1.创建user表 ​编辑2. mybatis-plus插件 3.导入相关依赖 4.配置文件 5.前端代码 register.html style.css 6.后端代码 entity层 mapper层 sevice层 业务层接口 业务层实现类 controller层 7.调试 1. 未输…
阅读更多...
【python】Django——连接mysql数据库

【python】Django——连接mysql数据库

笔记为自我总结整理的学习笔记，若有错误欢迎指出哟~ 【Django专栏】 Django——django简介、django安装、创建项目、快速上手 Django——templates模板、静态文件、django模板语法、请求和响应 Django——连接mysql数据库 Django——连接mysql数据库 连接MySQL数据库…
阅读更多...
免费开源客服机器人tiledesk 实现一个查询天气机器人

免费开源客服机器人tiledesk 实现一个查询天气机器人

第一步,槽位收集: 第二步:天气api接口调用: 效果展示:
阅读更多...
基于电力需求侧能效管理平台的建设及应用

基于电力需求侧能效管理平台的建设及应用

贾丽丽 安科瑞电气股份有限公司 上海嘉定 201801 摘要：电力是国民经济和居民生活的命脉，为贯彻落实国家对于节能减排工作的总体部署，深入推进电力需求侧管理工作、本文从电力需求侧能效管理平台所要实现的功能与应用信息技术两个方面&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023