μC/OS-II---互斥信号量管理1（os_mutex.c）

news2024/11/20 0:48:40

目录

  • 背景：优先级反转问题
  • 互斥信号量管理
    • 互斥信号量创建
    • 互斥信号量删除
    • 互斥信号量获取/等待

在这里插入图片描述

背景：优先级反转问题

  • 在高优先级任务等待低优先级任务释放资源时，第三个中等优先级任务抢占了低优先级任务。阻塞时间是无法预测的，可能导致高优先级任务无法满足deadline。这是需要解决的问题。μC/OS-II采用的办法：优先级继承协议。【实际采用的方法是由互斥信号量先预占一个优先级】

互斥信号量管理

互斥信号量创建

OS_EVENT  *OSMutexCreate (INT8U   prio,
													INT8U  *perr)
{
	OS_EVENT  *pevent;
#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
#ifdef OS_SAFETY_CRITICAL_IEC61508
	
	if (OSSafetyCriticalStartFlag == OS_TRUE)
	{
		OS_SAFETY_CRITICAL_EXCEPTION();
		return ((OS_EVENT *)0);
	}
	
#endif
#if OS_ARG_CHK_EN > 0u
	
	if (prio != OS_PRIO_MUTEX_CEIL_DIS)
	{
		if (prio >= OS_LOWEST_PRIO)                        /* Validate PCP                             */
		{
			*perr = OS_ERR_PRIO_INVALID;
			return ((OS_EVENT *)0);
		}
	}
	
#endif
	
	if (OSIntNesting > 0u)                                 /* See if called from ISR ...               */
	{
		*perr = OS_ERR_CREATE_ISR;                         /* ... can't CREATE mutex from an ISR       */
		return ((OS_EVENT *)0);
	}
	
	OS_ENTER_CRITICAL();
	
	if (prio != OS_PRIO_MUTEX_CEIL_DIS)
	{
		if (OSTCBPrioTbl[prio] != (OS_TCB *)0)             /* Mutex priority must not already exist    */
		{
			OS_EXIT_CRITICAL();                            /* Task already exist at priority ...       */
			*perr = OS_ERR_PRIO_EXIST;                      /* ... ceiling priority                     */
			return ((OS_EVENT *)0);
		}
		
		OSTCBPrioTbl[prio] = OS_TCB_RESERVED;              /* Reserve the table entry                  */
	}
	
	pevent = OSEventFreeList;                              /* Get next free event control block        */
	
	if (pevent == (OS_EVENT *)0)                           /* See if an ECB was available              */
	{
		if (prio != OS_PRIO_MUTEX_CEIL_DIS)
		{
			OSTCBPrioTbl[prio] = (OS_TCB *)0;              /* No, Release the table entry              */
		}
		
		OS_EXIT_CRITICAL();
		*perr = OS_ERR_PEVENT_NULL;                         /* No more event control blocks             */
		return (pevent);
	}
	
	OSEventFreeList     = (OS_EVENT *)OSEventFreeList->OSEventPtr; /* Adjust the free list             */
	OS_EXIT_CRITICAL();
	pevent->OSEventType = OS_EVENT_TYPE_MUTEX;
	pevent->OSEventCnt  = (INT16U) ((INT16U)prio << 8u) | OS_MUTEX_AVAILABLE; /* Resource is avail.     */
	pevent->OSEventPtr  = (void *)0;                       /* No task owning the mutex                 */
#if OS_EVENT_NAME_EN > 0u
	pevent->OSEventName = (INT8U *) (void *)"?";
#endif
	OS_EventWaitListInit (pevent);
	*perr = OS_ERR_NONE;
	return (pevent);
}

互斥信号量删除

#if OS_MUTEX_DEL_EN > 0u
OS_EVENT  *OSMutexDel (OS_EVENT  *pevent,
											 INT8U      opt,
											 INT8U     *perr)
{
	BOOLEAN    tasks_waiting;
	OS_EVENT  *pevent_return;
	INT8U      pcp;                                        /* Priority ceiling priority                */
	INT8U      prio;
	OS_TCB    *ptcb;
#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_MUTEX)        /* 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 mutex        */
	{
		tasks_waiting = OS_TRUE;                           /* Yes                                      */
	}
	
	else
	{
		tasks_waiting = OS_FALSE;                          /* No                                       */
	}
	
	switch (opt)
	{
		case OS_DEL_NO_PEND:                               /* DELETE MUTEX ONLY IF NO TASK WAITING --- */
			if (tasks_waiting == OS_FALSE)
			{
#if OS_EVENT_NAME_EN > 0u
				pevent->OSEventName   = (INT8U *) (void *)"?";
#endif
				pcp                   = (INT8U) (pevent->OSEventCnt >> 8u);
				
				if (pcp != OS_PRIO_MUTEX_CEIL_DIS)
				{
					OSTCBPrioTbl[pcp] = (OS_TCB *)0;      /* Free up the PCP                          */
				}
				
				pevent->OSEventType   = OS_EVENT_TYPE_UNUSED;
				pevent->OSEventPtr    = OSEventFreeList;  /* Return Event Control Block to free list  */
				pevent->OSEventCnt    = 0u;
				OSEventFreeList       = pevent;
				OS_EXIT_CRITICAL();
				*perr                 = OS_ERR_NONE;
				pevent_return         = (OS_EVENT *)0;    /* Mutex has been deleted                   */
			}
			
			else
			{
				OS_EXIT_CRITICAL();
				*perr                 = OS_ERR_TASK_WAITING;
				pevent_return         = pevent;
			}
			
			break;
			
		case OS_DEL_ALWAYS:                                /* ALWAYS DELETE THE MUTEX ---------------- */
			pcp  = (INT8U) (pevent->OSEventCnt >> 8u);                      /* Get PCP of mutex       */
			
			if (pcp != OS_PRIO_MUTEX_CEIL_DIS)
			{
				prio = (INT8U) (pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /* Get owner's orig prio  */
				ptcb = (OS_TCB *)pevent->OSEventPtr;
				
				if (ptcb != (OS_TCB *)0)                  /* See if any task owns the mutex           */
				{
					if (ptcb->OSTCBPrio == pcp)           /* See if original prio was changed         */
					{
						OSMutex_RdyAtPrio (ptcb, prio);   /* Yes, Restore the task's original prio    */
					}
				}
			}
			
			while (pevent->OSEventGrp != 0u)              /* Ready ALL tasks waiting for mutex        */
			{
				(void)OS_EventTaskRdy (pevent, (void *)0, OS_STAT_MUTEX, OS_STAT_PEND_ABORT);
			}
			
#if OS_EVENT_NAME_EN > 0u
			pevent->OSEventName   = (INT8U *) (void *)"?";
#endif
			pcp                   = (INT8U) (pevent->OSEventCnt >> 8u);
			
			if (pcp != OS_PRIO_MUTEX_CEIL_DIS)
			{
				OSTCBPrioTbl[pcp] = (OS_TCB *)0;          /* Free up the PCP                          */
			}
			
			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;                /* Mutex has been deleted                   */
			break;
			
		default:
			OS_EXIT_CRITICAL();
			*perr         = OS_ERR_INVALID_OPT;
			pevent_return = pevent;
			break;
	}
	
	return (pevent_return);
}
#endif

互斥信号量获取/等待

void  OSMutexPend (OS_EVENT  *pevent,
									 INT32U     timeout,
									 INT8U     *perr)
{
	INT8U      pcp;                                        /* Priority Ceiling Priority (PCP)          */
	INT8U      mprio;                                      /* Mutex owner priority                     */
	BOOLEAN    rdy;                                        /* Flag indicating task was ready           */
	OS_TCB    *ptcb;
	OS_EVENT  *pevent2;
	INT8U      y;
#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;
	}
	
#endif
#if OS_ARG_CHK_EN > 0u
	
	if (pevent == (OS_EVENT *)0)                           /* Validate 'pevent'                        */
	{
		*perr = OS_ERR_PEVENT_NULL;
		return;
	}
	
#endif
	
	if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX)        /* Validate event block type                */
	{
		*perr = OS_ERR_EVENT_TYPE;
		return;
	}
	
	if (OSIntNesting > 0u)                                 /* See if called from ISR ...               */
	{
		*perr = OS_ERR_PEND_ISR;                           /* ... can't PEND from an ISR               */
		return;
	}
	
	if (OSLockNesting > 0u)                                /* See if called with scheduler locked ...  */
	{
		*perr = OS_ERR_PEND_LOCKED;                        /* ... can't PEND when locked               */
		return;
	}
	
	/*$PAGE*/
	OS_ENTER_CRITICAL();
	pcp = (INT8U) (pevent->OSEventCnt >> 8u);              /* Get PCP from mutex                       */
	
	/* Is Mutex available?                      */
	if ((INT8U) (pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8) == OS_MUTEX_AVAILABLE)
	{
		pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;       /* Yes, Acquire the resource                */
		pevent->OSEventCnt |= OSTCBCur->OSTCBPrio;         /*      Save priority of owning task        */
		pevent->OSEventPtr  = (void *)OSTCBCur;            /*      Point to owning task's OS_TCB       */
		
		if ((pcp != OS_PRIO_MUTEX_CEIL_DIS) &&
				(OSTCBCur->OSTCBPrio <= pcp))                  /*      PCP 'must' have a SMALLER prio ...  */
		{
			OS_EXIT_CRITICAL();                           /*      ... than current task!              */
			*perr = OS_ERR_PCP_LOWER;
		}
		
		else
		{
			OS_EXIT_CRITICAL();
			*perr = OS_ERR_NONE;
		}
		
		return;
	}
	
	if (pcp != OS_PRIO_MUTEX_CEIL_DIS)
	{
		mprio = (INT8U) (pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); /*  Get priority of mutex owner   */
		ptcb  = (OS_TCB *) (pevent->OSEventPtr);                  /*     Point to TCB of mutex owner   */
		
		if (ptcb->OSTCBPrio > pcp)                                /*     Need to promote prio of owner?*/
		{
			if (mprio > OSTCBCur->OSTCBPrio)
			{
				y = ptcb->OSTCBY;
				
				if ((OSRdyTbl[y] & ptcb->OSTCBBitX) != 0u)        /*     See if mutex owner is ready   */
				{
					OSRdyTbl[y] &= (OS_PRIO)~ptcb->OSTCBBitX;     /*     Yes, Remove owner from Rdy ...*/
					
					if (OSRdyTbl[y] == 0u)                        /*          ... list at current prio */
					{
						OSRdyGrp &= (OS_PRIO)~ptcb->OSTCBBitY;
					}
					
					rdy = OS_TRUE;
				}
				
				else
				{
					pevent2 = ptcb->OSTCBEventPtr;
					
					if (pevent2 != (OS_EVENT *)0)                 /* Remove from event wait list       */
					{
						y = ptcb->OSTCBY;
						pevent2->OSEventTbl[y] &= (OS_PRIO)~ptcb->OSTCBBitX;
						
						if (pevent2->OSEventTbl[y] == 0u)
						{
							pevent2->OSEventGrp &= (OS_PRIO)~ptcb->OSTCBBitY;
						}
					}
					
					rdy = OS_FALSE;                        /* No                                       */
				}
				
				ptcb->OSTCBPrio = pcp;                     /* Change owner task prio to PCP            */
#if OS_LOWEST_PRIO <= 63u
				ptcb->OSTCBY    = (INT8U) ( ptcb->OSTCBPrio >> 3u);
				ptcb->OSTCBX    = (INT8U) ( ptcb->OSTCBPrio & 0x07u);
#else
				ptcb->OSTCBY    = (INT8U) ((INT8U) (ptcb->OSTCBPrio >> 4u) & 0xFFu);
				ptcb->OSTCBX    = (INT8U) ( ptcb->OSTCBPrio & 0x0Fu);
#endif
				ptcb->OSTCBBitY = (OS_PRIO) (1uL << ptcb->OSTCBY);
				ptcb->OSTCBBitX = (OS_PRIO) (1uL << ptcb->OSTCBX);
				
				if (rdy == OS_TRUE)                        /* If task was ready at owner's priority ...*/
				{
					OSRdyGrp               |= ptcb->OSTCBBitY; /* ... make it ready at new priority.   */
					OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
				}
				
				else
				{
					pevent2 = ptcb->OSTCBEventPtr;
					
					if (pevent2 != (OS_EVENT *)0)          /* Add to event wait list                   */
					{
						pevent2->OSEventGrp               |= ptcb->OSTCBBitY;
						pevent2->OSEventTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
					}
				}
				
				OSTCBPrioTbl[pcp] = ptcb;
			}
		}
	}
	
	OSTCBCur->OSTCBStat     |= OS_STAT_MUTEX;         /* Mutex not available, pend current task        */
	OSTCBCur->OSTCBStatPend  = OS_STAT_PEND_OK;
	OSTCBCur->OSTCBDly       = timeout;               /* Store timeout in current task's TCB           */
	OS_EventTaskWait (pevent);                        /* Suspend task until event or timeout occurs    */
	OS_EXIT_CRITICAL();
	OS_Sched();                                       /* Find next highest priority task ready         */
	OS_ENTER_CRITICAL();
	
	switch (OSTCBCur->OSTCBStatPend)                  /* See if we timed-out or aborted                */
	{
		case OS_STAT_PEND_OK:
			*perr = OS_ERR_NONE;
			break;
			
		case OS_STAT_PEND_ABORT:
			*perr = OS_ERR_PEND_ABORT;               /* Indicate that we aborted getting mutex        */
			break;
			
		case OS_STAT_PEND_TO:
		default:
			OS_EventTaskRemove (OSTCBCur, pevent);
			*perr = OS_ERR_TIMEOUT;                  /* Indicate that we didn't get mutex 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
	OS_EXIT_CRITICAL();
}

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

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

相关文章

基于springboot实现学生选课平台管理系统项目【项目源码】计算机毕业设计

基于springboot实现学生选课平台管理系统项目【项目源码】计算机毕业设计

基于springboot实现学生选课平台管理系统演示 系统开发平台 在该地方废物回收机构管理系统中&#xff0c;Eclipse能给用户提供更多的方便&#xff0c;其特点一是方便学习&#xff0c;方便快捷&#xff1b;二是有非常大的信息储存量&#xff0c;主要功能是用在对数据库中查询和…
阅读更多...
μC/OS-II---互斥信号量管理2（os_mutex.c）

μC/OS-II---互斥信号量管理2（os_mutex.c）

目录 背景&#xff1a;优先级反转问题互斥信号量管理互斥信号量发出&#xff08;释放&#xff09;互斥信号量获取/无等待互斥信号量状态查询 背景&#xff1a;优先级反转问题 在高优先级任务等待低优先级任务释放资源时&#xff0c;第三个中等优先级任务抢占了低优先级任务。阻…
阅读更多...
【JY】ANSYS Workbench在减隔震应用分析中的单元积分技术笔记

【JY】ANSYS Workbench在减隔震应用分析中的单元积分技术笔记

写在前文 尽管减隔震技术与有限元结合取得了众多成果&#xff0c;但仍面临诸多挑战&#xff0c;如材料非线性、模型不确定性等等。减隔震设计除了常规的宏观结构设计采用SAP2000、Etabs、Midas、SSG、Paco-SAP 或 YJK\PKPM等。 【JY】各类有限元软件计算功能赏析与探讨 我们需要…
阅读更多...
解析数据洁净之道：BI中数据清理对见解的深远影响

解析数据洁净之道：BI中数据清理对见解的深远影响

本文由葡萄城技术团队发布。转载请注明出处&#xff1a;葡萄城官网&#xff0c;葡萄城为开发者提供专业的开发工具、解决方案和服务&#xff0c;赋能开发者。 前言 随着数字化和信息化进程的不断发展&#xff0c;数据已经成为企业的一项不可或缺的重要资源。然而&#xff0c;这…
阅读更多...
Linux常用命令——bzgrep命令

Linux常用命令——bzgrep命令

在线Linux命令查询工具 bzgrep 使用正则表达式搜索.bz2压缩包中文件 补充说明 bzgrep命令使用正则表达式搜索“.bz2”压缩包中文件&#xff0c;将匹配的行显示到标注输出。 语法 bzgrep(参数)参数 搜索模式&#xff1a;指定要搜索的模式&#xff1b;.bz2文件&#xff1a…
阅读更多...
Linux系统简介与开源精神

Linux系统简介与开源精神

&#x1f3a5; 屿小夏 &#xff1a; 个人主页 &#x1f525;个人专栏 &#xff1a; Linux系统理论 &#x1f304; 莫道桑榆晚&#xff0c;为霞尚满天&#xff01; 文章目录 &#x1f4d1;前言&#x1f324;️Linux系统背景☁️UNIX发展史☁️Linux发展史☁️Linux系统企业应用现…
阅读更多...
基于springboot实现校园医疗保险管理系统【项目源码】

基于springboot实现校园医疗保险管理系统【项目源码】

基于springboot实现校园医疗保险管理系统演示 系统开发平台 在线校园医疗保险系统中&#xff0c;Eclipse能给用户提供更多的方便&#xff0c;其特点一是方便学习&#xff0c;方便快捷&#xff1b;二是有非常大的信息储存量&#xff0c;主要功能是用在对数据库中查询和编程。其…
阅读更多...
2.6 Windows驱动开发：使用IO与DPC定时器

2.6 Windows驱动开发：使用IO与DPC定时器

本章将继续探索驱动开发中的基础部分&#xff0c;定时器在内核中同样很常用&#xff0c;在内核中定时器可以使用两种&#xff0c;即IO定时器&#xff0c;以及DPC定时器&#xff0c;一般来说IO定时器是DDK中提供的一种&#xff0c;该定时器可以为间隔为N秒做定时&#xff0c;但如…
阅读更多...
vue-组件通信(动态组件)

vue-组件通信(动态组件)

​&#x1f308;个人主页&#xff1a;前端青山 &#x1f525;系列专栏&#xff1a;Vue篇 &#x1f516;人终将被年少不可得之物困其一生 依旧青山,本期给大家带来vue篇专栏内容:vue-组件通信|动态组件 目录 组件通信 1.父传子 2.子传父 3.ref 4.兄弟组件 5.跨层级 provid…
阅读更多...
【ROS导航Navigation】二 | 坐标系 | 定位 | 导航约束

【ROS导航Navigation】二 | 坐标系 | 定位 | 导航约束

目录 致谢&#xff1a;ROS赵虚左老师 一、通过里程计定位 二、通过传感器定位 三、坐标系变换 四、导航约束条件 1.硬件 2.软件 致谢&#xff1a;ROS赵虚左老师 Introduction Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 参考赵虚左老师的实战教程 一、…
阅读更多...
算不上最全，但都是必备——Redis这些不会不行啊

算不上最全，但都是必备——Redis这些不会不行啊

Redis篇 数据类型及其业务场景 字符串&#xff08;String&#xff09; 字符串类型是最基本的数据类型&#xff0c;value 最多可以容纳的数据长度是 512M。 存储任意类型的数据&#xff0c;包括数字、文本等。适用于缓存、计数器、分布式锁等场景。共享 Session 信息 哈希&am…
阅读更多...
基于springboot实现学生选课平台管理系统项目【项目源码】

基于springboot实现学生选课平台管理系统项目【项目源码】

系统开发平台 在该地方废物回收机构管理系统中&#xff0c;Eclipse能给用户提供更多的方便&#xff0c;其特点一是方便学习&#xff0c;方便快捷&#xff1b;二是有非常大的信息储存量&#xff0c;主要功能是用在对数据库中查询和编程。其功能有比较灵活的数据应用&#xff0c…
阅读更多...
基于springboot实现校园医疗保险管理系统【项目源码】计算机毕业设计

基于springboot实现校园医疗保险管理系统【项目源码】计算机毕业设计

基于springboot实现校园医疗保险管理系统演示 系统开发平台 在线校园医疗保险系统中&#xff0c;Eclipse能给用户提供更多的方便&#xff0c;其特点一是方便学习&#xff0c;方便快捷&#xff1b;二是有非常大的信息储存量&#xff0c;主要功能是用在对数据库中查询和编程。其…
阅读更多...
IDEA-git commit log 线

IDEA-git commit log 线

一、本地代码颜色标识 红色&#xff1a;新建的文件&#xff0c;没有add到git本地仓库蓝色&#xff1a;修改的文件&#xff0c;没有提交到git远程仓库绿色&#xff1a;已添加到git本地仓库&#xff0c;没有提交到git远程仓库灰色&#xff1a;删除的文件&#xff0c;没有提交到g…
阅读更多...
Linux Docker 图形化工具 Portainer远程访问

Linux Docker 图形化工具 Portainer远程访问

文章目录 前言1. 部署Portainer2. 本地访问Portainer3. Linux 安装cpolar4. 配置Portainer 公网访问地址5. 公网远程访问Portainer6. 固定Portainer公网地址 前言 Portainer 是一个轻量级的容器管理工具&#xff0c;可以通过 Web 界面对 Docker 容器进行管理和监控。它提供了可…
阅读更多...
Python武器库开发-flask篇之路由和视图函数(二十二)

Python武器库开发-flask篇之路由和视图函数(二十二)

flask篇之路由和视图函数(二十二) 通过创建路由并关联函数&#xff0c;实现一个基本的网页&#xff1a; #!/usr/bin/env python3 from flask import Flask# 用当前脚本名称实例化Flask对象&#xff0c;方便flask从该脚本文件中获取需要的内容 app Flask(__name__)#程序实例需…
阅读更多...
【移远QuecPython】EC800M物联网开发板的SIM卡初始化和网络状态检测

【移远QuecPython】EC800M物联网开发板的SIM卡初始化和网络状态检测

【移远QuecPython】EC800M物联网开发板的SIM卡初始化和网络状态检测 文章目录 SIM卡初始化导入库获取SIM状态 网络检测导入库等待网络就绪 函数打包附录&#xff1a;列表的赋值类型和py打包列表赋值BUG复现代码改进优化总结 py打包 SIM卡初始化 导入库 import sim获取SIM状态…
阅读更多...
java入门， 记录检测网络

java入门， 记录检测网络

一、需求 在开发中&#xff0c;我们经常需要本地连接服务器&#xff0c;或者数据库这些机器或者组件&#xff0c;但是有时候网络不通&#xff0c;我们怎样检测&#xff0c;除了ping 和 telnet 还需要那些常用的技能。 二、检测网络 1、一般我们先ping一些需要连接的网络ip 或…
阅读更多...
msys2 + MSVC(VS2019)编译ffmpeg6.0源码

msys2 + MSVC(VS2019)编译ffmpeg6.0源码

以前使用的v1.2版&#xff0c;很多功能和使用方法发生了变化&#xff0c;需要重新编译新的ffmpeg版。 编译环境: windows 10 , VS2019, MSYS2 1. msys2 下载安装 MSYS2 , https://www.msys2.org/ 2. msys2 环境配置打开 msys2 2.1 安装相关软件 然后输入以下命令安装&…
阅读更多...
C++命名空间，函数重载

C++命名空间，函数重载

一、C命名空间 使用过C的人都知道在引入<iostream>头文件后需要加上这样一行代码 using namespace std; 但是对于初学者来说不仔细研究一下可能都不知道为什么需要这样一行代码&#xff0c;接下来将对其进行解释&#xff0c;引入命名空间的概念 C在C的基础上增加了命…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023