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

目录

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

在这里插入图片描述

消息队列的主要优点

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

消息队列和消息邮箱

  • 消息队列是一个独立的数据结构，多个进程可以共享同一个消息队列，而消息邮箱是与进程关联的，每个进程都有自己的邮箱。此外，消息队列通常是先进先出（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                       */
}

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

分布式教程从0到1【1】分布式基础

分布式教程从0到1【1】分布式基础

1 分布式基础概念 1.1 微服务 微服务架构风格，就像是把一个单独的应用程序开发为一套小服务，每个小服务运行在自己的进程中，并使用轻量级机制通信，通常是 HTTP API。这些服务围绕业务能力来构建，并通过完全自动化部署…
阅读更多...
全链路压测：确保系统稳定性的关键一环

全链路压测：确保系统稳定性的关键一环

在当今高度数字化的业务环境中，系统的稳定性和性能至关重要。全链路压测作为确保系统在各种负载下依然可靠运行的关键工具，越来越受到企业的关注。本文将深入探讨全链路压测的概念及目的。 一、全链路压测概念 全链路压测是一种模拟真实用户行为、模拟全…
阅读更多...
Python与ArcGIS系列（八）通过python执行地理处理工具

Python与ArcGIS系列（八）通过python执行地理处理工具

目录 0 简述1 脚本执行地理处理工具2 在地理处理工具间建立联系0 简述 arcgis包含数百种可以通过python脚本执行的地理处理工具，这样就通过python可以处理复杂的工作和批处理。本篇将介绍如何利用arcpy实现执行地理处理工具以及在地理处理工具间建立联系。 1 脚本执行地理处理…
阅读更多...
ai剪辑矩阵系统源码+无人直播系统源码技术开发

ai剪辑矩阵系统源码+无人直播系统源码技术开发

开发AI剪辑矩阵系统和无人直播系统源码，需要以下步骤： 1. 市场调研：了解市场需求和竞品情况，明确系统的功能和特点。 2. 系统设计：设计系统的整体架构和功能模块，包括视频剪辑、直播推流、实时互动、数据分…
阅读更多...
亚马逊EC2服务器搭建Linux系统宝塔环境

亚马逊EC2服务器搭建Linux系统宝塔环境

目录 📝摘要 💡引言 一. 购买亚马逊服务器EC2 二. 安装Linux系统 三. 在终端安装宝塔 3.1 安装宝塔 3.2安装成功 四. 配置宝塔 五 应用场景 六 代码案例演示 七 为什么选择亚马逊EC2服务器部署？ 💪 可靠性和高可用性 灵…
阅读更多...
Django部署时静态文件配置的坑

Django部署时静态文件配置的坑

Django部署时静态文件配置配置的坑 近期有个需求是用django进行开发部署，结果发现静态文件配置的坑是真的多，另外网上很多的内容也讲不清楚原理，就是这样这样，又那样那样，进了不少坑，这里记录一下关于css,…
阅读更多...
软件工程理论与实践 (吕云翔) 第六章 面向对象分析课后习题及其解析

软件工程理论与实践 (吕云翔) 第六章 面向对象分析课后习题及其解析

第六章 面向对象分析 知识点: 一个典型的软件系统通常包括的内容为：它使用数据结构（对象模型），执行操作（动态模型），并且完成数据值的变化（功能模型）。 3种模型之间的关…
阅读更多...
python科研绘图：面积图

python科研绘图：面积图

目录 1、面积图 2、堆积面积图 1、面积图 面积图是一种数据可视化图表，用于展示数据随时间或其他有序类别的变化趋势。它与折线图相似，但在展示数据变化的同时，面积图还强调了各个数据点之间的累积关系。这种图表通常通过在折线下方填充颜…
阅读更多...
二叉树（进阶）

二叉树（进阶）

文章目录 1.内容安排说明2. 二叉搜索树2.1二叉搜索树的概念2.2二叉搜索树的实现2.3二叉树的性能： 搜索二叉树的应用k 模型kv模型 1.内容安排说明 二叉树在前面c数据结构阶段；已经讲过了；本节取名二叉树进阶的原因是： 1.map和set特…
阅读更多...
04-学成在线之系统管理服务模块之查询数据字典表中的内容,前后端联调测试

04-学成在线之系统管理服务模块之查询数据字典表中的内容,前后端联调测试

前后端联调 配置前端环境 实际开发中先由后端工程师将接口设计好并编写接口文档并交给前端工程师，前后端的工程师就开始并行开发 前端开发人员先自己mock数据即使用假数据进行开发,当后端代码完成后前端工程师尝试请求后端接口获取数据然后渲染到页面 第一步: 首…
阅读更多...
k8s-部署Redis-cluster(TLS)

k8s-部署Redis-cluster(TLS)

helm pull bitnami/redis-cluster v8.3.8拉取源码生成证书 git clone https://github.com/redis/redis.git #文档 https://redis.io/docs/management/security/encryption/#getting-started生成你的TLS证书用官网的工具生成 1 Run ./utils/gen-test-certs.sh 生成根CA和服务…
阅读更多...
java 工程管理系统源码+项目说明+功能描述+前后端分离 + 二次开发

java 工程管理系统源码+项目说明+功能描述+前后端分离 + 二次开发

工程项目管理软件（工程项目管理系统）对建设工程项目管理组织建设、项目策划决策、规划设计、施工建设到竣工交付、总结评估、运维运营，全过程、全方位的对项目进行综合管理 工程项目各模块及其功能点清单 一、系统管理 1、数据字典&am…
阅读更多...
latex简单使用

latex简单使用

​​文章目录 公式详解 普通公式公式居中带标号公式上标下标根号分式括号运算符列表 无序列表有序列表插入图片 单图多图排版表格脚注与定理子标题目录与附录 目录附录参考文献字体设置 字体样式 加粗斜体字母大写等线自定义字体字体大小 第一种设置第二种设置第三种设置 页面…
阅读更多...
使用Spring Boot实现大文件断点续传及文件校验

使用Spring Boot实现大文件断点续传及文件校验

一、简介 随着互联网的快速发展，大文件的传输成为了互联网应用的重要组成部分。然而，由于网络不稳定等因素的影响，大文件的传输经常会出现中断的情况，这时需要重新传输，导致传输效率低下。 为了解决这个问题&#xff…
阅读更多...
第四代智能井盖传感器：万宾科技助力城市安全

第四代智能井盖传感器：万宾科技助力城市安全

在繁华喧嚣的城市里人来人往，井盖作为基础设施的一个组成部分在路面上分布范围广。然而这些看似普通的井盖却存在着位移、水浸的风险，可能给我们的生活带来诸多不便，更会威胁到我们的人身安全。如何有效监测和管理井盖的状态，成为…
阅读更多...
leetcode刷题日记:160. Intersection of Two Linked Lists（相交链表）

leetcode刷题日记:160. Intersection of Two Linked Lists（相交链表）

给出两个单链表的头结点headA与headB，让我们找出两个链表相接的起始节点，如果两个链表不存在相交结点返回null。 我们就先假设存在这样两个链表，链表1与链表2，假设链表1的长度为 L 1 L_1 L1​和 L 2 L_2 L2​,假设对于两个链表&am…
阅读更多...
MatrixOne完成与欧拉、麒麟信安的兼容互认

MatrixOne完成与欧拉、麒麟信安的兼容互认

近日，超融合异构云原生数据库MatrixOne企业版软件V1.0完成了与欧拉开源操作系统（openEuler简称“欧拉”）、麒麟信安操作系统系列产品和虚拟化平台的相互兼容认证，通过了欧拉兼容性测评，获得了《openEuler技术测评证书》…
阅读更多...
JS进阶——作用域、解构、箭头函数

JS进阶——作用域、解构、箭头函数

1、作用域 作用域（scope）规定了变量能够被访问的“范围”，离开了这个“范围”变量便不能被访问。 1.1 局部作用域 局部作用域可分为函数作用域和块作用域。 1.1.1 函数作用域 在函数内部声明的变量只能在函数内部被访问，外部无…
阅读更多...
Linux C 线程

Linux C 线程

线程 概述线程和进程的异同如何选择使用进程还是线程 函数获取进程自身ID  pthread_self创建线程  pthread_create退出线程  pthread_exit线程等待  pthread_join 四种线程模型1 ）单线程2 ）单线程3 ）双线程4 ）三线程 概述…
阅读更多...
【实习】modbus

【实习】modbus

介绍 详解Modbus通信协议—清晰易懂 Modbus协议是一个master/slave架构的协议。有一个节点是master节点，其他使用Modbus协议参与通信的节点是slave节点。每一个slave设备都有一个唯一的地址。在串行和MB网络中，只有被指定为主节点的节点可以启动一个命令…
阅读更多...
最新文章

Copyright @ 2022~2023