μC/OS-II---Task管理2（os_task.c）

news2025/1/12 1:41:12

目录

    • 改变Task优先级
    • Task挂起
    • Task恢复
    • Task信息获取
    • Task调度器上锁（os_core.c）
    • Task调度器开锁（os_core.c）

在这里插入图片描述

改变Task优先级

#if OS_TASK_CHANGE_PRIO_EN > 0u
INT8U  OSTaskChangePrio (INT8U  oldprio,
												 INT8U  newprio)
{
#if (OS_EVENT_EN)
	OS_EVENT  *pevent;
#if (OS_EVENT_MULTI_EN > 0u)
	OS_EVENT **pevents;
#endif
#endif
	OS_TCB    *ptcb;
	INT8U      y_new;
	INT8U      x_new;
	INT8U      y_old;
	OS_PRIO    bity_new;
	OS_PRIO    bitx_new;
	OS_PRIO    bity_old;
	OS_PRIO    bitx_old;
#if OS_CRITICAL_METHOD == 3u
	OS_CPU_SR  cpu_sr = 0u;                                 /* Storage for CPU status register         */
#endif
	/*$PAGE*/
#if OS_ARG_CHK_EN > 0u
	
	if (oldprio >= OS_LOWEST_PRIO)
	{
		if (oldprio != OS_PRIO_SELF)
		{
			return (OS_ERR_PRIO_INVALID);
		}
	}
	
	if (newprio >= OS_LOWEST_PRIO)
	{
		return (OS_ERR_PRIO_INVALID);
	}
	
#endif
	OS_ENTER_CRITICAL();
	
	if (OSTCBPrioTbl[newprio] != (OS_TCB *)0)               /* New priority must not already exist     */
	{
		OS_EXIT_CRITICAL();
		return (OS_ERR_PRIO_EXIST);
	}
	
	if (oldprio == OS_PRIO_SELF)                            /* See if changing self                    */
	{
		oldprio = OSTCBCur->OSTCBPrio;                      /* Yes, get priority                       */
	}
	
	ptcb = OSTCBPrioTbl[oldprio];
	
	if (ptcb == (OS_TCB *)0)                                /* Does task to change exist?              */
	{
		OS_EXIT_CRITICAL();                                 /* No, can't change its priority!          */
		return (OS_ERR_PRIO);
	}
	
	if (ptcb == OS_TCB_RESERVED)                            /* Is task assigned to Mutex               */
	{
		OS_EXIT_CRITICAL();                                 /* No, can't change its priority!          */
		return (OS_ERR_TASK_NOT_EXIST);
	}
	
#if OS_LOWEST_PRIO <= 63u
	y_new                 = (INT8U) (newprio >> 3u);        /* Yes, compute new TCB fields             */
	x_new                 = (INT8U) (newprio & 0x07u);
#else
	y_new                 = (INT8U) ((INT8U) (newprio >> 4u) & 0x0Fu);
	x_new                 = (INT8U) (newprio & 0x0Fu);
#endif
	bity_new              = (OS_PRIO) (1uL << y_new);
	bitx_new              = (OS_PRIO) (1uL << x_new);
	OSTCBPrioTbl[oldprio] = (OS_TCB *)0;                    /* Remove TCB from old priority            */
	OSTCBPrioTbl[newprio] =  ptcb;                          /* Place pointer to TCB @ new priority     */
	y_old                 =  ptcb->OSTCBY;
	bity_old              =  ptcb->OSTCBBitY;
	bitx_old              =  ptcb->OSTCBBitX;
	
	if ((OSRdyTbl[y_old] &   bitx_old) != 0u)               /* If task is ready make it not            */
	{
		OSRdyTbl[y_old] &= (OS_PRIO)~bitx_old;
		
		if (OSRdyTbl[y_old] == 0u)
		{
			OSRdyGrp &= (OS_PRIO)~bity_old;
		}
		
		OSRdyGrp        |= bity_new;                       /* Make new priority ready to run          */
		OSRdyTbl[y_new] |= bitx_new;
	}
	
#if (OS_EVENT_EN)
	pevent = ptcb->OSTCBEventPtr;
	
	if (pevent != (OS_EVENT *)0)
	{
		pevent->OSEventTbl[y_old] &= (OS_PRIO)~bitx_old;    /* Remove old task prio from wait list     */
		
		if (pevent->OSEventTbl[y_old] == 0u)
		{
			pevent->OSEventGrp    &= (OS_PRIO)~bity_old;
		}
		
		pevent->OSEventGrp        |= bity_new;              /* Add    new task prio to   wait list     */
		pevent->OSEventTbl[y_new] |= bitx_new;
	}
	
#if (OS_EVENT_MULTI_EN > 0u)
	
	if (ptcb->OSTCBEventMultiPtr != (OS_EVENT **)0)
	{
		pevents =  ptcb->OSTCBEventMultiPtr;
		pevent  = *pevents;
		
		while (pevent != (OS_EVENT *)0)
		{
			pevent->OSEventTbl[y_old] &= (OS_PRIO)~bitx_old;   /* Remove old task prio from wait lists */
			
			if (pevent->OSEventTbl[y_old] == 0u)
			{
				pevent->OSEventGrp    &= (OS_PRIO)~bity_old;
			}
			
			pevent->OSEventGrp        |= bity_new;          /* Add    new task prio to   wait lists    */
			pevent->OSEventTbl[y_new] |= bitx_new;
			pevents++;
			pevent                     = *pevents;
		}
	}
	
#endif
#endif
	ptcb->OSTCBPrio = newprio;                              /* Set new task priority                   */
	ptcb->OSTCBY    = y_new;
	ptcb->OSTCBX    = x_new;
	ptcb->OSTCBBitY = bity_new;
	ptcb->OSTCBBitX = bitx_new;
	OS_EXIT_CRITICAL();
	
	if (OSRunning == OS_TRUE)
	{
		OS_Sched();                                         /* Find new highest priority task          */
	}
	
	return (OS_ERR_NONE);
}
#endif

Task挂起

#if OS_TASK_SUSPEND_EN > 0u
INT8U  OSTaskSuspend (INT8U prio)
{
	BOOLEAN    self;
	OS_TCB    *ptcb;
	INT8U      y;
	#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */
		OS_CPU_SR  cpu_sr = 0u;
	#endif
	#if OS_ARG_CHK_EN > 0u
		
		if (prio == OS_TASK_IDLE_PRIO)                              /* Not allowed to suspend idle task    */
		{
			return (OS_ERR_TASK_SUSPEND_IDLE);
		}
		
		if (prio >= OS_LOWEST_PRIO)                                 /* Task priority valid ?               */
		{
			if (prio != OS_PRIO_SELF)
			{
				return (OS_ERR_PRIO_INVALID);
			}
		}
		
	#endif
		OS_ENTER_CRITICAL();
		
		if (prio == OS_PRIO_SELF)                                   /* See if suspend SELF                 */
		{
			prio = OSTCBCur->OSTCBPrio;
			self = OS_TRUE;
		}
		
		else if (prio == OSTCBCur->OSTCBPrio)                       /* See if suspending self              */
		{
			self = OS_TRUE;
		}
		
		else
		{
			self = OS_FALSE;                                        /* No suspending another task          */
		}
		
		ptcb = OSTCBPrioTbl[prio];
		
		if (ptcb == (OS_TCB *)0)                                    /* Task to suspend must exist          */
		{
			OS_EXIT_CRITICAL();
			return (OS_ERR_TASK_SUSPEND_PRIO);
		}
		
		if (ptcb == OS_TCB_RESERVED)                                /* See if assigned to Mutex            */
		{
			OS_EXIT_CRITICAL();
			return (OS_ERR_TASK_NOT_EXIST);
		}
		
		y            = ptcb->OSTCBY;
		OSRdyTbl[y] &= (OS_PRIO)~ptcb->OSTCBBitX;                   /* Make task not ready                 */
		
		if (OSRdyTbl[y] == 0u)
		{
			OSRdyGrp &= (OS_PRIO)~ptcb->OSTCBBitY;
		}
		
		ptcb->OSTCBStat |= OS_STAT_SUSPEND;                         /* Status of task is 'SUSPENDED'       */
		OS_EXIT_CRITICAL();
		
		if (self == OS_TRUE)                                        /* Context switch only if SELF         */
		{
			OS_Sched();                                             /* Find new highest priority task      */
		}
		
		return (OS_ERR_NONE);
}
#endif

Task恢复

#if OS_TASK_SUSPEND_EN > 0u
INT8U  OSTaskResume (INT8U prio)
{
	OS_TCB    *ptcb;
#if OS_CRITICAL_METHOD == 3u                                  /* Storage for CPU status register       */
	OS_CPU_SR  cpu_sr = 0u;
#endif
#if OS_ARG_CHK_EN > 0u
	
	if (prio >= OS_LOWEST_PRIO)                               /* Make sure task priority is valid      */
	{
		return (OS_ERR_PRIO_INVALID);
	}
	
#endif
	OS_ENTER_CRITICAL();
	ptcb = OSTCBPrioTbl[prio];
	
	if (ptcb == (OS_TCB *)0)                                  /* Task to suspend must exist            */
	{
		OS_EXIT_CRITICAL();
		return (OS_ERR_TASK_RESUME_PRIO);
	}
	
	if (ptcb == OS_TCB_RESERVED)                              /* See if assigned to Mutex              */
	{
		OS_EXIT_CRITICAL();
		return (OS_ERR_TASK_NOT_EXIST);
	}
	
	if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) != OS_STAT_RDY)   /* Task must be suspended                */
	{
		ptcb->OSTCBStat &= (INT8U)~ (INT8U)OS_STAT_SUSPEND;   /* Remove suspension                     */
		
		if (ptcb->OSTCBStat == OS_STAT_RDY)                   /* See if task is now ready              */
		{
			if (ptcb->OSTCBDly == 0u)
			{
				OSRdyGrp               |= ptcb->OSTCBBitY;    /* Yes, Make task ready to run           */
				OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
				OS_EXIT_CRITICAL();
				
				if (OSRunning == OS_TRUE)
				{
					OS_Sched();                               /* Find new highest priority task        */
				}
			}
			
			else
			{
				OS_EXIT_CRITICAL();
			}
		}
		
		else                                                  /* Must be pending on event              */
		{
			OS_EXIT_CRITICAL();
		}
		
		return (OS_ERR_NONE);
	}
	
	OS_EXIT_CRITICAL();
	return (OS_ERR_TASK_NOT_SUSPENDED);
}
#endif

Task信息获取

#if OS_TASK_QUERY_EN > 0u
INT8U  OSTaskQuery (INT8U    prio,
										OS_TCB  *p_task_data)
{
	OS_TCB    *ptcb;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */
	OS_CPU_SR  cpu_sr = 0u;
#endif
#if OS_ARG_CHK_EN > 0u
	
	if (prio > OS_LOWEST_PRIO)                   /* Task priority valid ?                              */
	{
		if (prio != OS_PRIO_SELF)
		{
			return (OS_ERR_PRIO_INVALID);
		}
	}
	
	if (p_task_data == (OS_TCB *)0)              /* Validate 'p_task_data'                             */
	{
		return (OS_ERR_PDATA_NULL);
	}
	
#endif
	OS_ENTER_CRITICAL();
	
	if (prio == OS_PRIO_SELF)                    /* See if suspend SELF                                */
	{
		prio = OSTCBCur->OSTCBPrio;
	}
	
	ptcb = OSTCBPrioTbl[prio];
	
	if (ptcb == (OS_TCB *)0)                     /* Task to query must exist                           */
	{
		OS_EXIT_CRITICAL();
		return (OS_ERR_PRIO);
	}
	
	if (ptcb == OS_TCB_RESERVED)                 /* Task to query must not be assigned to a Mutex      */
	{
		OS_EXIT_CRITICAL();
		return (OS_ERR_TASK_NOT_EXIST);
	}
	
	/* Copy TCB into user storage area                    */
	OS_MemCopy ((INT8U *)p_task_data, (INT8U *)ptcb, sizeof (OS_TCB));
	OS_EXIT_CRITICAL();
	return (OS_ERR_NONE);
}
#endif

Task调度器上锁（os_core.c）

#if OS_SCHED_LOCK_EN > 0u
void  OSSchedLock (void)
{
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */
	OS_CPU_SR  cpu_sr = 0u;
#endif
	
	if (OSRunning == OS_TRUE)                    /* Make sure multitasking is running                  */
	{
		OS_ENTER_CRITICAL();
		
		if (OSIntNesting == 0u)                  /* Can't call from an ISR                             */
		{
			if (OSLockNesting < 255u)            /* Prevent OSLockNesting from wrapping back to 0      */
			{
				OSLockNesting++;                 /* Increment lock nesting level                       */
			}
		}
		
		OS_EXIT_CRITICAL();
	}
}
#endif

Task调度器开锁（os_core.c）

#if OS_SCHED_LOCK_EN > 0u
void  OSSchedUnlock (void)
{
#if OS_CRITICAL_METHOD == 3u                               /* Allocate storage for CPU status register */
	OS_CPU_SR  cpu_sr = 0u;
#endif
	
	if (OSRunning == OS_TRUE)                              /* Make sure multitasking is running        */
	{
		OS_ENTER_CRITICAL();
		
		if (OSIntNesting == 0u)                            /* Can't call from an ISR                   */
		{
			if (OSLockNesting > 0u)                        /* Do not decrement if already 0            */
			{
				OSLockNesting--;                           /* Decrement lock nesting level             */
				
				if (OSLockNesting == 0u)                   /* See if scheduler is enabled              */
				{
					OS_EXIT_CRITICAL();
					OS_Sched();                            /* See if a HPT is ready                    */
				}
				
				else
				{
					OS_EXIT_CRITICAL();
				}
			}
			
			else
			{
				OS_EXIT_CRITICAL();
			}
		}
		
		else
		{
			OS_EXIT_CRITICAL();
		}
	}
}
#endif

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

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

相关文章

Hazelcast系列(九)：Map（一）加载和存储

Hazelcast系列(九)：Map（一）加载和存储

系列文章 Hazelcast系列(一)&#xff1a;初识hazelcast Hazelcast系列(二)&#xff1a;hazelcast集成&#xff08;嵌入式&#xff09; Hazelcast系列(三)&#xff1a;hazelcast集成&#xff08;服务器/客户端&#xff09; Hazelcast系列(四)&#xff1a;hazelcast管理中心 …
阅读更多...
3. 【自动驾驶和机器人中的SLAM技术】实现基于预积分和图优化的GNSS+IMU+Odom的融合定位系统

3. 【自动驾驶和机器人中的SLAM技术】实现基于预积分和图优化的GNSS+IMU+Odom的融合定位系统

目录 1. 公式推导2. GNSSIMUOdom融合定位3. 利用数值求导工具&#xff0c;验证本书实验中的雅可比矩阵的正确性4. 也欢迎大家来我公众号读书--“过千帆” 1. 公式推导 2. GNSSIMUOdom融合定位 程序实现以及运行效果&#xff1a; ①首先是在预积分程序中记录了预积分积累的IMU数…
阅读更多...
竞赛 题目：基于python的验证码识别 - 机器视觉 验证码识别

竞赛 题目：基于python的验证码识别 - 机器视觉 验证码识别

文章目录 0 前言1 项目简介2 验证码识别步骤2.1 灰度处理&二值化2.2 去除边框2.3 图像降噪2.4 字符切割2.5 识别 3 基于tensorflow的验证码识别3.1 数据集3.2 基于tf的神经网络训练代码 4 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 基于pyt…
阅读更多...
超详细！必看！！STM32--时钟树原理

超详细！必看！！STM32--时钟树原理

一、什么是时钟&#xff1f; 时钟是单片机的脉搏&#xff0c;是系统工作的同步节拍。单片机上至CPU&#xff0c;下至总线外设&#xff0c;它们工作时序的配合&#xff0c;都需要一个同步的时钟信号来统一指挥。时钟信号是周期性的脉冲信号。 二、什么是时钟树&#xff1f; S…
阅读更多...
Pikachu（皮卡丘靶场）初识XSS（常见标签事件及payload总结）

Pikachu（皮卡丘靶场）初识XSS（常见标签事件及payload总结）

目录 1、反射型xss(get) 2、反射性xss(post) 3、存储型xss 4、DOM型xss 5、DOM型xss-x XSS又叫跨站脚本攻击&#xff0c;是HTML代码注入&#xff0c;通过对网页注入浏览器可执行代码&#xff0c;从而实现攻击。 ​ 1、反射型xss(get) Which NBA player do you like? 由…
阅读更多...
【Mycat2实战】一、Mycat简介

【Mycat2实战】一、Mycat简介

1. 什么是Mycat 什么是Mycat Mycat是数据库中间件&#xff0c;所谓中间件数据库中间件是连接Java应用程序和数据库中间的软件。 为什么要用Mycat 遇到问题&#xff1a; Java与数据库的紧耦合高访问量高并发对数据库的压力读写请求数据不一致 2. Mycat与其他中间件区别 目前的…
阅读更多...
全面解读Asana项目管理软件：功能、成本与顶级国内替代方案

全面解读Asana项目管理软件：功能、成本与顶级国内替代方案

Asana好用吗&#xff1f;Asana作为一款办公软件的话&#xff0c;其应用范围和受众范围是极为有限。支持这款软件的人把它夸上天&#xff0c;认为其他同类型产品根本不值一提&#xff1b;不支持这款软件的人又把它“束之高阁”&#xff0c;根本不想再用它。 Asana正是近些年具有…
阅读更多...
玩转ChatGPT：ARIMA模型定制GPT-1.0

玩转ChatGPT：ARIMA模型定制GPT-1.0

一、写在前面 好久不更新咯&#xff01; OpenAI又推出了GPT的一系列重大更新&#xff0c;其中GPTs深得我心啊。 GPTs允许用户创建自定义的ChatGPT版本&#xff0c;以满足自己各种特定需求。其核心理念在于&#xff0c;用户可以为不同的场景和任务创建定制化的ChatGPT。这意味…
阅读更多...
为什么数据安全很重要？哪些措施保护数据安全？

为什么数据安全很重要？哪些措施保护数据安全？

数据安全很重要的原因是因为数据是现代社会的重要财产之一。很多组织和企业依赖数据来做出商业决策&#xff0c;管理客户关系&#xff0c;进行财务规划等等。如果这些数据泄露或遭到黑客攻击&#xff0c;那么就会影响企业的经济利益&#xff0c;甚至影响到个人的隐私和安全。此…
阅读更多...
接口测试需要验证数据库么？

接口测试需要验证数据库么？

&#x1f4e2;专注于分享软件测试干货内容&#xff0c;欢迎点赞 &#x1f44d; 收藏 ⭐留言 &#x1f4dd; 如有错误敬请指正&#xff01;&#x1f4e2;交流讨论&#xff1a;欢迎加入我们一起学习&#xff01;&#x1f4e2;资源分享&#xff1a;耗时200小时精选的「软件测试」资…
阅读更多...
Git用pull命令后再直接push有问题

Git用pull命令后再直接push有问题

在gitlab新建一个项目&#xff0c;然后拉取到本地&#xff0c;用&#xff1a; git init git pull <远程主机名> 然后就是在本地工作区增加所有文件及文件夹。再添加、提交&#xff0c;都没问题&#xff1a; 但是&#xff0c;git push出问题&#xff1a; 说明本地仓库和…
阅读更多...
解密图像处理中的利器——直方图与均衡化

解密图像处理中的利器——直方图与均衡化

直方图与均衡化是数字图像处理中常用的重要工具&#xff0c;它们能够帮助我们更好地理解和改善图像的亮度分布。本文将首先介绍直方图的基本概念以及其在图像处理中的意义&#xff0c;接着详细阐述直方图均衡化的原理和算法。同时&#xff0c;文章将探讨直方图均衡化在图像增强…
阅读更多...
在 Android 上简单安全地登录——使用凭证管理器和密钥

在 Android 上简单安全地登录——使用凭证管理器和密钥

我踏马很高兴地听说&#xff0c; Credential Manager的公开版本将于 11 月 1 日开始提供。Credential Manager 为 Android 带来了身份验证的未来&#xff0c;简化了用户登录应用程序和网站的方式&#xff0c;同时使其更加安全。 登录可能具有挑战性 - 密码经常使用&#xff0c…
阅读更多...
【无线网络技术】——无线传输技术基础（学习笔记）

【无线网络技术】——无线传输技术基础（学习笔记）

目录 &#x1f552; 1. 无线传输媒体&#x1f558; 1.1 地面微波&#x1f558; 1.2 卫星微波&#x1f558; 1.3 广播无线电波&#x1f558; 1.4 红外线&#x1f558; 1.5 光波 &#x1f552; 2. 天线&#x1f558; 2.1 辐射模式&#x1f558; 2.2 天线类型&#x1f564; 2.2.1 …
阅读更多...
react Antd3以下实现年份选择器 YearPicker

react Antd3以下实现年份选择器 YearPicker

项目antd版本低&#xff0c;没有直接可使用的年份选择器&#xff0c;参考此篇&#xff08;使用antd实现年份选择器控件 - 掘金&#xff09; 一开始在state里设置了time&#xff1a; this.state {isopen: false,time: null } 在类似onChange事件里this.setState({time: valu…
阅读更多...
Linux系统软件安装方式

Linux系统软件安装方式

Linux系统软件安装方式 1. 绿色安装2. yum安装3. rpm安装3.1 rpm常用命令 4. 源码安装4.1 安装依赖包4.2 执行configure脚本4.3 编译、安装4.4 安装4.5 操作nginx4.6 创建服务器 1. 绿色安装 Compressed Archive压缩文档包&#xff0c;如Java软件的压缩文档包&#xff0c;只需…
阅读更多...
图形学中的噪声

图形学中的噪声

1 value noise 四个点取随机数然后做插值。 float random (in vec2 st) {return fract(sin(dot(st.xy,vec2(12.9898,78.233)))* 43758.5453123); }float noise (in vec2 st) {vec2 i floor(st);vec2 f fract(st);float a random(i);float b random(i vec2(1.0, 0.0));fl…
阅读更多...
centralwidget 不能布局

centralwidget 不能布局

必须要在QT ui中添加一个任意的子控件&#xff08;比如添加了一个pushButton&#xff09;&#xff0c;然后在centralwidget 才能右键设置布局&#xff0c;成功去掉centralwidget 右下角的红色的标记。
阅读更多...
如何制作出高级感满满的的照片书

如何制作出高级感满满的的照片书

随着数码相机的普及&#xff0c;越来越多的人喜欢将生活中的点滴美好记录下来&#xff0c;其中照片书就是一种非常受欢迎的方式。但是&#xff0c;如何制作出高级感满满的“照片书”呢&#xff1f;今天&#xff0c;我们就来分享几个小技巧&#xff0c;帮助你轻松打造出令人惊艳…
阅读更多...
RT-DETR算法优化改进：Backbone改进｜RIFormer：无需TokenMixer也能达成SOTA性能的极简ViT架构 | CVPR2023

RT-DETR算法优化改进：Backbone改进｜RIFormer：无需TokenMixer也能达成SOTA性能的极简ViT架构 | CVPR2023

💡💡💡本文独家改进：RIFormer助力RT-DETR ，替换backbone， RIFormer-M36的吞吐量可达1185，同时精度高达82.6%；而PoolFormer-M36的吞吐量为109，精度为82.1%。 推荐指数：五星 RT-DETR魔术师专栏介绍： https://blog.csdn.net/m0_63774211/category_12497375.html …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023