STM32理论 —— μCOS-Ⅲ(2/2)：时间管理、消息队列、信号量、任务内嵌信号量/队列、事件标志、软件定时器

news2025/1/14 0:58:55

文章目录

  • 9. 时间管理
    • 9.1 `OSTimeDly()`
    • 9.2 `OSTimeDlyHMSM()`
    • 9.3 `OSTimeDlyResume()`
    • 9.4 延时函数实验
  • 10. 消息队列
    • 10.1 创建消息队列函数`OSQCreate()`
    • 10.2 发送消息到消息队列函数(写入队列)`OSQPost()`
    • 10.3 获取消息队列中的消息函数(读出队列)`OSQPend()`
    • 10.4 消息队列操作实验
  • 11. 信号量
    • 11.1 二值信号量
      • 11.1.1 创建信号量函数`OSSemCreate()`
      • 11.1.2 释放信号量函数`OSSemPost()`
      • 11.1.3 获取信号量函数`OSSemPend ()`
      • 11.1.4 二值信号量实验
    • 11.2 计数型信号量
      • 11.2.1 计数型信号量实验
    • 11.3 优先级翻转问题
      • 11.3.1 优先级翻转实验
    • 11.4 互斥信号量
      • 11.4.1 创建互斥信号量`OSMutexCreate()`
      • 11.4.2 获取互斥信号量`OSMutexPend()`
      • 11.4.3 释放互斥信号量`OSMutexPost()`
      • 11.4.4 互斥信号量实验
  • 12. 任务内嵌信号量/队列
    • 12.1 任务内嵌信号量
      • 12.1.1 获取任务信号量函数`OSTaskSemPend()`
      • 12.1.2 释放信号量函数`OSTaskSemPost()`
      • 12.1.3 强制设置指定的任务信号量为指定值函数`OSTaskSemSet()`
      • 12.1.4 任务内嵌信号量实验
    • 12.2 任务内嵌消息队列
      • 12.2.1 获取任务消息队列函数(读出队列)`OSTaskQPend()`
      • 12.2.2 发送任务消息队列函数(写入队列)`OSTaskQPost()`
      • 12.2.3 任务消息队列实验
  • 13. 事件标志
    • 13.1 创建事件标志组函数`OSFlagCreate()`
    • 13.2 设置事件标注组的事件函数`OSFlagPost()`
    • 13.3 等待事件标注组中的事件函数`OSFlagPend()`
    • 13.4 事件标注组实验
  • 14. 软件定时器

9. 时间管理

时间管理是一种建立在时钟节拍上，对任务运行时间管理的一种系统内核机制；

时间管理相关API 函数：

函数描述
OSTimeDly()以系统时钟节拍为单位进行任务延时
OSTimeDlyHMSM()以时、分、秒、毫秒为单位进行任务延时
OSTimeDlyResume()恢复被延时的任务

实际延时时间取决于系统时钟节拍的频率：OS_CFG_TICK_RATE_HZ，它默认为1000；

如：task1 被延时1分钟，在1分钟的延时等待过程中，可调用OSTimeDlyResume()来及时恢复被延时的task1；

9.1 OSTimeDly()

函数原型输入形参：

void  OSTimeDly (OS_TICK   dly,
                 OS_OPT    opt,
                 OS_ERR   *p_err)
  1. dly：任务延时的系统时钟节拍数；
  2. opt：延时选项；
opt描述
OS_OPT_TIME_DLY任务延时的结束时刻为 OSTickCtr = OSTickCtr +dly，相对延时，OSTickCtr 每进入一次滴答定时器中断加一次1
OS_OPT_TIME_TIMEOUT任务延时的结束时刻为 OSTickCtr = OSTickCtr +dly，功能与上面一样
OS_OPT_TIME_MATCH任务延时的结束时刻为 OSTickCtr = dly，绝对时间，一般不用
OS_OPT_TIME_PERIODIC任务延时的结束时刻为 OSTickCtr = OSTCBCurPtr -> TickCtrPrev + dly
  • OS_OPT_TIME_DLY ：如dly 设置为1，OSTimeDly 在OSTickCtr 等于12时被调用，则任务延时的结束时刻为OSTickCtr 等于13时；
  • OS_OPT_TIME_MATCH ：如dly 设置为100，OSTimeDly 在OSTickCtr 等于0时被调用，则任务延时的结束时刻为OSTickCtr 等于100时，即总延时时刻为100；若OSTimeDly 在OSTickCtr 等于101时被调用，则任务延时的结束时刻同样为OSTickCtr 等于100时，即总延时时刻为4,294,967,296+100=4,294,967,396(系统时钟节拍为32位，即2^32=4,294,967,296，OSTickCtr 在等于4,294,967,296时，溢出回零)，在延时期间，该任务进入阻塞态；
  • OS_OPT_TIME_PERIODIC ：控制当前任务运行的总时间为dly；注意任务运行时间不能超过dly；
  1. p_err：指向接收错误代码变量的指针；

9.2 OSTimeDlyHMSM()

使用该函数前，先把宏OS_CFG_TIME_DLY_HMSM_EN 置1；

函数原型输入形参：

void  OSTimeDlyHMSM (CPU_INT16U   hours,
                     CPU_INT16U   minutes,
                     CPU_INT16U   seconds,
                     CPU_INT32U   milli,
                     OS_OPT       opt,
                     OS_ERR      *p_err)
  1. hours：任务延时的小时数；
  2. minutes：任务延时的分钟数；
  3. seconds：任务延时的秒数；
  4. milli：任务延时的毫秒数；
  5. opt：延时选项；
    在这里插入图片描述

9.3 OSTimeDlyResume()

使用该函数前，先把宏OS_CFG_TIME_DLY_RESUME_EN 置1；

函数原型输入形参：

void  OSTimeDlyResume (OS_TCB  *p_tcb,
                       OS_ERR  *p_err)

在这里插入图片描述

9.4 延时函数实验

  • 实验目的：完成以下3个任务：
  1. start_task：初始化CPU，配置Systick 中断及优先级，创建其他2个任务
  2. task1：展示延时函数OSTimeDly() 的使用；
  3. task2：展示延时函数OSTimeDlyHMSM() 的使用；
  • 实验过程：
  1. 拿一个实验例程，修改task1、task2 的任务函数：
/* task1 展示延时函数`OSTimeDly()` 的使用 */
void task1(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		LED0_TOGGLE();
		OSTimeDly(500,OS_OPT_TIME_DLY,&err); // 延时500ms，相对延时
	}
				
}

/* task2 展示延时函数`OSTimeDlyHMSM()` 的使用 */
void task2(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		LED1_TOGGLE();
		OSTimeDlyHMSM (0,0,0,500,OS_OPT_TIME_HMSM_NON_STRICT|OS_OPT_TIME_DLY,&err); // 延时500ms，相对延时
	}
}

代码运行结果：LED0、LED1每0.5秒翻转一次；

  1. 修改task1的延时选项为OS_OPT_TIME_MATCH：
/* task1 展示延时函数`OSTimeDly()` 的使用 */
void task1(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		LED0_TOGGLE();
		OSTimeDly(500,OS_OPT_TIME_MATCH,&err); // 延时500ms，绝对延时
	}
				
}

/* task2 展示延时函数`OSTimeDlyHMSM()` 的使用 */
void task2(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		LED1_TOGGLE();
		OSTimeDlyHMSM (0,0,0,500,OS_OPT_TIME_HMSM_NON_STRICT|OS_OPT_TIME_DLY,&err);
	}
}

代码运行结果：LED0 翻转的时间间隔非常长；

  1. 修改task1的延时选项为OS_OPT_TIME_PERIODIC：
/* task1 展示延时函数`OSTimeDly()` 的使用，任务总延时时间为1s */
void task1(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		LED0_TOGGLE();
		delay_ms(200); // 模拟任务运行时间
		OSTimeDly(1000,OS_OPT_TIME_PERIODIC,&err); // 整个任务的总延时为1s
	}
				
}

/* task2 展示延时函数`OSTimeDlyHMSM()` 的使用，总延时时间为700ms */
void task2(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		LED1_TOGGLE();
		delay_ms(200); // 模拟任务运行时间
		OSTimeDlyHMSM (0,0,0,500,OS_OPT_TIME_HMSM_NON_STRICT|OS_OPT_TIME_DLY,&err);
	}
}

代码运行结果：
在这里插入图片描述

代码备份位置：百度网盘 - 知识资源 - 电子工程 - 正点原子stm32f103精英开发板V2资料 - 资料备份 - UCOSIII 时间管理实验.rar

10. 消息队列

队列：任务到任务、中断到任务的一种数据交流机制；

队列与全局变量类似都用于数据传递，但在实时系统中使用全局变量进行数据交流，会导致数据不安全，当多个任务同时对同一变量操作时，数据易受损，故在操作系统中，数据交流一般使用队列的方式；

在读写队列函数中，会先进入临界区，从而屏蔽中断与任务打断，完成数据交流后，再退出临界区；

在中断中，只可写入消息队列，不可读出消息；
在这里插入图片描述
在这里插入图片描述

UCOS-III 队列特点：

  1. 数据入队出队方式：一般采用FIFO(先进先出)的数据存储缓冲机制，即先入的数据先从队列中被读取；也可以通过配置，配置成LIFO(后进先出)方式；
  2. 数据传输方式：UCOS-III 的队列数据是一种“万能指针”，可以指向任何数据，甚至是函数；
  3. 多任务访问：任何任务、中断都可以向队列发送消息，但中断不能从队列中读消息；
  4. 出队阻塞：但任务向一个队列读取消息时，可指定一个阻塞时间，用于读取等待；注意，入队(写入消息队列)不会阻塞；

使用队列的流程：创建队列 --> 写入队列(发送消息到队列) --> 读出队列(从队列中督促消息)

队列相关API 函数介绍：
在这里插入图片描述

更多关于队列相关API 函数介绍，详见《UCOS-III开发指南_V1.5》第十三章；

10.1 创建消息队列函数OSQCreate()

该函数用于创建一个消息队列；

函数原型输入形参：

void  OSQCreate (OS_Q        *p_q,
                 CPU_CHAR    *p_name,
                 OS_MSG_QTY   max_qty,
                 OS_ERR      *p_err)
  1. p_q：指向消息队列结构体的指针，类似于一个句柄；
  2. p_name：指向作为消息队列名的ASCII 字符串的指针；
  3. max_qty：消息队列的大小，即该消息队列可包含多少个消息成员；
  4. p_err：指向接收错误代码变量的指针；

10.2 发送消息到消息队列函数(写入队列)OSQPost()

函数原型输入形参：

void  OSQPost (OS_Q         *p_q,
               void         *p_void,
               OS_MSG_SIZE   msg_size,
               OS_OPT        opt,
               OS_ERR       *p_err)
  1. p_q：指向消息队列结构体的指针，类似于一个句柄；
  2. p_void：指向消息的指针；
  3. msg_size：消息的大小，单位：字节；
  4. opt：函数操作选项，可组合使用；
opt描述
OS_OPT_POST_FIFO将发送的消息保存在队列的末尾
OS_OPT_POST_LIFO将发送的消息保存在队列的开头
OS_OPT_POST_ALL将消息发送给所有等待消息的任务
OS_OPT_POST_NO_SCHED禁止在本函数内执行任务调度
  1. p_err：指向接收错误代码变量的指针；

10.3 获取消息队列中的消息函数(读出队列)OSQPend()

函数原型输入形参：

void  *OSQPend (OS_Q         *p_q,
                OS_TICK       timeout,
                OS_OPT        opt,
                OS_MSG_SIZE  *p_msg_size,
                CPU_TS       *p_ts,
                OS_ERR       *p_err)
  1. p_q：指向消息队列结构体的指针，类似于一个句柄；
  2. timeout：任务挂起等待消息队列的最大允许时间，为0时，表示一直等待，知道接收到消息；
  3. opt：函数操作选项，该参数配合timeout 使用；
opt描述
OS_OPT_PEND_BLOCKING若没有任何消息存在于消息队列，则阻塞任务
OS_OPT_PEND_NON_BLOCKING若没有任何消息存在于消息队列，则直接返回
  1. p_msg_size：指向一个变量，用于表示接收到的消息长度(字节数)；
  2. p_ts：指向接收消息队列接收时时间戳的变量的指针，为NULL 则表示没有使用时间戳；
  3. p_err：指向接收错误代码变量的指针；

函数的返回值：从上述函数原型可知，该函数的返回值类型为void *，即“万能指针”(任意类型数据都能指向)，故消息的读与写必须保持数据类型相同，否则会导致消息读写错乱；

10.4 消息队列操作实验

  • 实验目的：完成以下4个任务：
  1. start_task：创建2个队列，并创建另外3个任务；
  2. task1：当按键key0或key1按下，将键值的地址写入到队列key_queue中(入队)；当按键key_up 按下，将传输大数据，将大数据的地址写入队列big_date_queue 中(入队)；
  3. task2：读取队列key_queue 中的消息(出队)，打印出接收到的键值；
  4. task3：从队列big_date_queue 读取大数据地址，打印出接收到的数据；
  • 实验过程：
  1. 定义消息队列句柄：
 OS_Q key_queue;
 OS_Q big_date_queue;
  1. 创建2个消息队列：
	OSQCreate (&key_queue,"key_queue",1,&err); // 创建消息队列
	OSQCreate (&big_date_queue,"big_date_queue",1,&err); // 创建消息队列
  1. 定义大数据数组：
char buf[] = {"我是一个大数据 abc 123456789"};
  1. 编写3个任务函数
/* task1 写入队列 */
void task1(void *p_arg)
{
	OS_ERR err;
	uint8_t key=0;
	
	while(1)
	{
		key = key_scan(0);
		if(key == KEY0_PRES || key == KEY1_PRES)
		{
			printf("发送键值！\r\n");
			OSQPost (&key_queue,&key,sizeof(key),OS_OPT_POST_FIFO,&err); // 写入消息队列
		}
		else if(key == WKUP_PRES)
		{
			printf("发送大数据！\r\n");
			OSQPost (&big_date_queue,&buf[0],sizeof(buf),OS_OPT_POST_FIFO,&err); // 写入消息队列
		}
			
		OSTimeDly(10,OS_OPT_TIME_DLY,&err);
	}
}

/* task2 读出队列key_queue */
void task2(void *p_arg)
{
	OS_ERR err;
	uint8_t *key; // 读出的消息队列要跟写入的消息队列的类型相同
	OS_MSG_SIZE size = 0;
	
	while(1)
	{
		key = OSQPend (&key_queue,0,OS_OPT_PEND_BLOCKING,&size,NULL,&err);
		printf("接收到的键值为：%d\r\n",*key);
		printf("接收到的数据长度为：%d字节\r\n",size);
	}
}

/* task3 读出队列big_date_queue */
void task3(void *p_arg)
{
	OS_ERR err;
	char *buf2; // 读出的消息队列要跟写入的消息队列的类型相同
	OS_MSG_SIZE size = 0;
	
	while(1)
	{
		buf2 = OSQPend (&big_date_queue,0,OS_OPT_PEND_BLOCKING,&size,NULL,&err);
		printf("接收到的大数据为：%s\r\n",buf2);
		printf("接收到的数据长度为：%d字节\r\n",size);
	}
}

代码运行结果：
按下key0：
在这里插入图片描述
按下key1：
在这里插入图片描述
按下key up：
在这里插入图片描述

代码备份位置：百度网盘 - 知识资源 - 电子工程 - 正点原子stm32f103精英开发板V2资料 - 资料备份 - UCOSIII 消息队列操作实验.rar

11. 信号量

上节的消息队列用于传递数据，而本节的信号量用于传递状态；若该信号只有2种状态，则该信号又叫做二值信号量；若该信号有多种状态，则该信号又叫做计数型信号量；

信号量是一种解决任务间同步问题的机制，可实现对共享资源的有序访问，即在多任务访问统一资源时的资源管理；

11.1 二值信号量

二值信号量只有空和非空两种状态；通常用于互斥访问或信号同步，尤其是后者；

二值信号量的使用过程：创建二值信号量 -> 释放二值信号量 -> 获取二值信号量

二值信号量相关API 函数：
在这里插入图片描述

更多关于二值信号量相关API 函数的介绍，详见《UCOSIII开发指南》第十一章

11.1.1 创建信号量函数OSSemCreate()

函数原型输入形参：

void OSSemCreate( OS_SEM *p_sem,
				 CPU_CHAR *p_name,
				 OS_SEM_CTR cnt,
				 OS_ERR *p_err)
  1. p_sem：指向信号量结构体的指针；
  2. p_name：指向作为信号量名的 ASCII 字符串的指针；
  3. cnt：信号量资源数的初始值，0或1，0表示二值信号量初始无资源，反之同理；
  4. p_err：指向接收错误代码变量的指针；

11.1.2 释放信号量函数OSSemPost()

函数原型输入形参：

OS_SEM_CTR  OSSemPost (OS_SEM  *p_sem,
                       OS_OPT   opt,
                       OS_ERR  *p_err)
  1. p_sem：指向信号量结构体的指针；
  2. opt：函数操作选项；
    • OS_OPT_POST_1：只给最高优先级的那一个任务发信号；即该信号量释放后，优先分配给到最高优先级的那一个任务，其他同样等待该信号量的任务继续保持阻塞状态；
    • OS_OPT_POST_ALL：给所有等待该信号量的任务发信号量；即该信号量释放后，所有等待该信号量的任务都解除阻塞状态；
    • OS_OPT_POST_NO_SCHED：禁止在本函数内执行任务调度；该宏可与上述两个宏组合使用
  3. p_err：指向接收错误代码变量的指针；

返回值：信号量资源数更新后的值；

11.1.3 获取信号量函数OSSemPend ()

函数原型输入形参：

OS_SEM_CTR  OSSemPend (OS_SEM   *p_sem,
                       OS_TICK   timeout,
                       OS_OPT    opt,
                       CPU_TS   *p_ts,
                       OS_ERR   *p_err)
  1. p_sem：指向信号量结构体的指针；
  2. timeout：任务挂起等待信号量的最大允许时间，当为0时，表示一直等待，直到接收到信号；
  3. opt：函数操作选项；
    • OS_OPT_PEND_BLOCKING：若信号量没有资源，则阻塞任务，阻塞时间却决于参数timeout；
    • OS_OPT_PEND_NON_BLOCKING：若信号量没有资源，则任务直接返回；
  4. p_ts：指向接收信号量接收时的时间戳的变量的指针，没有则写0；
  5. p_err：指向接收错误代码变量的指针；

返回值：信号量资源数更新后的值；

11.1.4 二值信号量实验

  • 实验目的：完成以下2个任务：
  1. start_task：初始化CPU，配置Systick 中断及优先级，创建1个二值信号量，创建task1任务；
  2. task1：获取二值信号量，当获取成功后打印提示信息；
  • 实验过程：
  1. 定义二值信号量句柄：
 OS_SEM binnary_sem;
  1. 创建二值信号量：
	OSSemCreate (&binnary_sem,"binnary_sem",1,&err);
  1. 编写task1 函数：
/* task1 二值信号量测试 */
void task1(void *p_arg)
{
	OS_ERR err;
	OS_SEM_CTR ctr=0;
	
	while(1)
	{
		/* 获取二值信号量 */
		ctr = OSSemPend (&binnary_sem,0,OS_OPT_PEND_BLOCKING,0,&err);
		printf("task1获取信号量成功！\r\n");
		printf("ctr 获取信号量成功后的资源数的计数值：%d\r\n",ctr);
		/* 释放二值信号量 */
		ctr = OSSemPost (&binnary_sem,OS_OPT_POST_1,&err);
		printf("task1释放信号量成功！\r\n");
		printf("ctr 释放信号量成功后的资源数的计数值：%d\r\n",ctr);
	}
}

11.2 计数型信号量

计数型信号量与二值信号量类似，但二值信号量的资源数只能是0和1，而计数型信号量只要有任务释放信号量，信号量的资源数就会被加1，直到溢出，只要有任务获取信号量，那么信号量的资源数就会被减 1，直到 0；

计数型信号量适用场合：

  1. 事件计数：当事件发生，在事件处理函数中释放计数型信号量(计数值+1)，其他任务会获取计数型信号量(计数值-1)，这种场合一般在创建时将初始计数值设置为0；
  2. 资源管理：信号量表示有效的资源数目；任务必须先获取信号量(计数值-1)才能获取资源控制权，当计数值减到为0时，表示没有资源；当任务使用完资源后，必须释放信号量(计数值+1)；信号量创建时计数值应等于最大资源数；

计数型信号量与二值信号量的API 函数是公用的；

11.2.1 计数型信号量实验

  • 实验目的：完成以下3个任务：
  1. start_task：初始化CPU，配置Systick 中断及优先级，创建一个计数型信号量，创建task1、task2任务；
  2. task1：用于按键扫描，当检测到按键KEY0被按下时，释放计数型信号量；
  3. task2：每过1秒获取一次计数型信号量，当成功获取后打印信号量计数值；
  • 实验过程：
  1. 定义计数型信号量句柄：
 OS_SEM count_sem; // 计数型信号量句柄
  1. 编写taks1、task2函数：
/* task1 计数型信号量释放 */
void task1(void *p_arg)
{
	OS_ERR err;
	uint8_t key = 0;
	
	while(1)
	{
		key = key_scan(0);
		if(key == KEY0_PRES)
		{
			printf("释放计数型信号量！\r\n");
			OSSemPost (&count_sem,OS_OPT_POST_1,&err);
		}
		OSTimeDly(10,OS_OPT_TIME_DLY,&err);
	}
}

/* task2 计数型信号量获取 */
void task2(void *p_arg)
{
	OS_ERR err;
	OS_SEM_CTR cnt = 0;
	
	while(1)
	{
		cnt = OSSemPend (&count_sem,0,OS_OPT_PEND_BLOCKING,0,&err);
		printf("获取计数型信号量成功，cnt 的值为%d\r\n",cnt);
		OSTimeDly(1000,OS_OPT_TIME_DLY,&err);
	}
}

代码运行结果：
按下Key0：
在这里插入图片描述
连续按下时，信号量释放，信号量增加，不按后信号量依次获取，信号量减少：
在这里插入图片描述

11.3 优先级翻转问题

优先级翻转即让高优先级的任务慢执行，低优先级的任务反而优先执行；

  • 背景：
    优先级翻转在抢占式内核中非常常见，但在实时操作系统中不允许使用，因为优先级翻转会破坏任务的预期顺序，可能导致未知后果；
    在使用二值信号量时，经常会遇到优先级翻转问题；

如：任务 H 为优先级最高的任务，任务 L 为优先级最低的任务，任务 M 为优先级介于任务 H 与任务 L 之间的任务；假设任务 H与任务L 都获取同一个二值信号量；

  1. 开始时任务 H 和任务 M 为挂起状态，等待某一事件发生，而任务 L 正常运行；
  2. 任务 L 要访问共享资源，因此需要获取信号量；
  3. 任务 L 成功获取信号量，并且此时二值信号量已无资源，任务 L 开始访问共享资源；
  4. 此时任务 H 就绪，抢占任务 L 运行；
  5. 任务 H 开始运行；
  6. 此时任务 H 要访问共享资源，因此需要获取二值信号量，但二值信号量已无资源，因此任务 H挂起等待信号量资源；
  7. 任务 L 继续运行；
  8. 此时任务 M 就绪，抢占任务 L 运行；
  9. 任务 M 正在运行；
  10. 任务 M 运行完毕，继续挂起；
  11. 任务 L 继续运行；
  12. 此时任务 L 对共享资源的访问操作完成，释放信号量，虽有任务 H 因成功获取二值信号量，解除挂起状态并抢占任务 L 运行。
  13. 任务 H 得以运行；

从上面优先级翻转的示例中，可知，任务 H 为最高优先级的任务，因此任务 H 执行的操作需要有较高的实时性，但是由于优先级翻转的问题，导致了任务 H 需要等到任务 L 释放信号量才能够运行，并且，任务 L 还会被其他介于任务 H 与任务 L 任务优先级之间的任务 M 抢占，因此任务 H 还需等待任务 M 运行完毕，这显然不符合任务 H 需要的高实时性要求；

11.3.1 优先级翻转实验

  • 实验目的：完成以下4个任务：
  1. start_task：创建一个二值信号量，并创建其他任务；
  2. high_task：高优先级任务，获取二值信号量，获取成功后打印提示信息，处理完后释放信号量；
  3. middle_task：中优先级任务，简单的引用任务；
  4. low_task：低优先级任务，与高优先级任务一样的操作，但占用信号量的时间更久一点；
  • 实验过程：
    以11.1.4 二值信号量实验代码为基础：
  1. 修改任务1函数名为low_task：
/* 低优先级任务 配置
 * 包括: 任务优先级 任务栈大小 任务控制块 任务栈 任务函数
 */
 #define 	TASK1_PRIO       4
 #define 	TASK1_STACK_SIZE 256
 CPU_STK* task1_stack; // 申请一个内存给task1 的任务堆栈
 OS_TCB 	task1_tcb;
 void low_task(void *p_arg);
  1. 创建middle_task 和high_task：
/* 中优先级任务 配置
 * 包括: 任务优先级 任务栈大小 任务控制块 任务栈 任务函数
 */
 #define 	TASK2_PRIO       3
 #define 	TASK2_STACK_SIZE 256
 CPU_STK* task2_stack; // 申请一个内存给task1 的任务堆栈
 OS_TCB 	task2_tcb;
 void middle_task(void *p_arg);
 
/* 高优先级任务 配置
 * 包括: 任务优先级 任务栈大小 任务控制块 任务栈 任务函数
 */
 #define 	TASK3_PRIO       2
 #define 	TASK3_STACK_SIZE 256
 CPU_STK* task3_stack; // 申请一个内存给task1 的任务堆栈
 OS_TCB 	task3_tcb;
 void high_task(void *p_arg);

	/* 创建低优先级任务 */
	task1_stack = (CPU_STK *)mymalloc(SRAMIN,TASK1_STACK_SIZE*sizeof(CPU_STK)); // 向系统申请内存
	OSTaskCreate ((OS_TCB*)        &task1_tcb,
								(CPU_CHAR*)      "low_task",
								(OS_TASK_PTR)    low_task,
								(void*)          0,
								(OS_PRIO)        TASK1_PRIO,
								(CPU_STK*)       task1_stack,// 以申请内存方式提供任务堆栈
								(CPU_STK_SIZE)   TASK1_STACK_SIZE/10,
								(CPU_STK_SIZE)   TASK1_STACK_SIZE,
								(OS_MSG_QTY)     0,
								(OS_TICK)        0, // 若设置为0，则使用前面所设置的时间片长度
								(void*)          0,
								(OS_OPT)         (OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR),
								(OS_ERR*)        &err);
				
	/* 创建中优先级任务 */
	task1_stack = (CPU_STK *)mymalloc(SRAMIN,TASK2_STACK_SIZE*sizeof(CPU_STK)); // 向系统申请内存
	OSTaskCreate ((OS_TCB*)        &task2_tcb,
								(CPU_CHAR*)      "middle_task",
								(OS_TASK_PTR)    middle_task,
								(void*)          0,
								(OS_PRIO)        TASK2_PRIO,
								(CPU_STK*)       task2_stack,// 以申请内存方式提供任务堆栈
								(CPU_STK_SIZE)   TASK2_STACK_SIZE/10,
								(CPU_STK_SIZE)   TASK2_STACK_SIZE,
								(OS_MSG_QTY)     0,
								(OS_TICK)        0, // 若设置为0，则使用前面所设置的时间片长度
								(void*)          0,
								(OS_OPT)         (OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR),
								(OS_ERR*)        &err);
								
	/* 创建高优先级任务 */
	task1_stack = (CPU_STK *)mymalloc(SRAMIN,TASK3_STACK_SIZE*sizeof(CPU_STK)); // 向系统申请内存
	OSTaskCreate ((OS_TCB*)        &task3_tcb,
								(CPU_CHAR*)      "high_task",
								(OS_TASK_PTR)    high_task,
								(void*)          0,
								(OS_PRIO)        TASK3_PRIO,
								(CPU_STK*)       task3_stack,// 以申请内存方式提供任务堆栈
								(CPU_STK_SIZE)   TASK3_STACK_SIZE/10,
								(CPU_STK_SIZE)   TASK3_STACK_SIZE,
								(OS_MSG_QTY)     0,
								(OS_TICK)        0, // 若设置为0，则使用前面所设置的时间片长度
								(void*)          0,
								(OS_OPT)         (OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR),
								(OS_ERR*)        &err);
  1. 编写任务函数：
/* 低优先级任务函数 */
void low_task(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		printf("low_task 获取二值信号量！");
		OSSemPend (&binnary_sem,0,OS_OPT_PEND_BLOCKING,0,&err);
		printf("low_task 正在运行！");
		delay_ms(3000); // 模拟任务运行时间
		printf("low_task 释放二值信号量！");
		OSSemPost (&binnary_sem,OS_OPT_POST_1,&err);
		OSTimeDly(1000,OS_OPT_TIME_DLY,&err);
	}
}

/* 中优先级任务函数 */
void middle_task(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		printf("middle_task 正在运行！");
		OSTimeDly(1000,OS_OPT_TIME_DLY,&err);
	}
}

/* 高优先级任务函数 */
void high_task(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		printf("high_task 获取二值信号量！");
		OSSemPend (&binnary_sem,0,OS_OPT_PEND_BLOCKING,0,&err);
		printf("high_task 正在运行！");
		delay_ms(1000); // 模拟任务运行时间
		printf("high_task 释放二值信号量！");
		OSSemPost (&binnary_sem,OS_OPT_POST_1,&err);
		OSTimeDly(1000,OS_OPT_TIME_DLY,&err);
	}
}

代码运行结果：代码开始运行 - 高优先级任务先运行(获取&释放二值信号量) - 高优先级任务运行结束后中优先级任务运行 - 低优先级任务运行(获取&释放二值信号量) - 在低优先级任务释放二值信号量之前，中优先级任务抢占运行，高优先级任务抢占运行，但由于二值信号量未被释放，故高优先级任务阻塞，直到二值信号量被释放；
在这里插入图片描述

11.4 互斥信号量

互斥信号量又叫互斥锁，是一种特殊的二值信号量，互斥信号量拥有优先级继承的机制使得互斥信号量能够在一定的程度上解决优先级翻转的问题；

优先级继承：当一个互斥信号量正被一个低优先级的任务持有时，此时有一个高优先级的任务也尝试获取这个互斥信号量，那么这个高优先级的任务就会因为获取不到互斥信号量而被挂起，不过接下来，高优先级的任务会将该低优先级任务的任务优先级提到与高优先级任务的任务优先级相同的任务优先级，那么高与低优先级任务之间的任务，就不能被执行，直至低优先级任务被执行完毕；此时高优先级任务的阻塞时间仅仅是低优先级任务的执行时间，将优先级翻转带来的影响降到最低；
在这里插入图片描述

注：互斥信号量不能用于中断服务函数中，原因如下：

  1. 互斥信号量有任务优先级继承的机制，但中断不是任务，没有任务优先级；
  2. 中断服务函数中不能因为要等待互斥信号量而设置阻塞时间进入阻塞态；

在同步的应用中适合使用二值信号量，而那些需要互斥访问的应用中使用互斥信号量；

互斥信号量的API 函数：
在这里插入图片描述

11.4.1 创建互斥信号量OSMutexCreate()

创建互斥信号量时，默认信号量有效，即可被获取；

函数原型输入形参：

void  OSMutexCreate (OS_MUTEX  *p_mutex,
                     CPU_CHAR  *p_name,
                     OS_ERR    *p_err)
  1. p_mutex：指向互斥信号量结构体的指针；
  2. p_name：指向作为信号量名的 ASCII 字符串的指针；
  3. p_err：指向接收错误代码变量的指针；

11.4.2 获取互斥信号量OSMutexPend()

函数原型输入形参：

void  OSMutexPend (OS_MUTEX  *p_mutex,
                   OS_TICK    timeout,
                   OS_OPT     opt,
                   CPU_TS    *p_ts,
                   OS_ERR    *p_err)
  1. p_mutex：指向互斥信号量结构体的指针；
  2. timeout：任务挂起等待信号量的最大允许时间，当为0时，表示一直等待，直到接收到信号；
  3. opt：函数操作选项；
    • OS_OPT_PEND_BLOCKING：若信号量没有资源，则阻塞任务，阻塞时间却决于参数timeout；
    • OS_OPT_PEND_NON_BLOCKING：若信号量没有资源，则任务直接返回；
  4. p_ts：指向接收信号量接收时的时间戳的变量的指针，没有则写0；
  5. p_err：指向接收错误代码变量的指针；

11.4.3 释放互斥信号量OSMutexPost()

函数原型输入形参：

void  OSMutexPost (OS_MUTEX  *p_mutex,
                   OS_OPT     opt,
                   OS_ERR    *p_err)
  1. p_mutex：指向互斥信号量结构体的指针；
  2. timeout：任务挂起等待信号量的最大允许时间，当为0时，表示一直等待，直到接收到信号；
  3. opt：函数操作选项；
    • OS_OPT_POST_NONE：不指定特定的选项；
    • OS_OPT_POST_NO_SCHED：禁止在本函数内执行任务调度；
  4. p_err：指向接收错误代码变量的指针；

11.4.4 互斥信号量实验

  • 实验过程：在优先级翻转实验的基础上，将二值信号量更改为互斥信号量：
 OS_MUTEX mutex_sem; // 互斥信号量句柄

	/* 创建互斥信号量 */
	OSMutexCreate(&mutex_sem,"mu_sem",&err);

OSMutexPend (&mutex_sem,0,OS_OPT_PEND_BLOCKING,0,&err);
OSMutexPost(&mutex_sem,OS_OPT_POST_NONE,&err);

代码运行结果：
在这里插入图片描述

12. 任务内嵌信号量/队列

12.1 任务内嵌信号量

任务内嵌信号量(下称任务信号量)本质上就是一个信号量，与前面11. 信号量中的信号量是类似的，但任务信号量是分配于每一个任务的任务控制块结构体中的，因此每一个任务都有独自的任务信号量，任务信号量只能被该任务获取，但可以由其他任务或者中断释放；
在这里插入图片描述

任务信号量的优点是使用内存更小，效率更高；缺点是无法共享给多个任务；

任务信号量的API 函数：
在这里插入图片描述

12.1.1 获取任务信号量函数OSTaskSemPend()

获取任务信号量函数只能被当前任务调用；

函数原型输入形参：

OS_SEM_CTR  OSTaskSemPend (OS_TICK   timeout,
                           OS_OPT    opt,
                           CPU_TS   *p_ts,
                           OS_ERR   *p_err)
  1. timeout：任务挂起等待信号量的最大允许时间，当为0时，表示一直等待，直到接收到信号；
  2. opt：函数操作选项；
    • OS_OPT_PEND_BLOCKING：若信号量没有资源，则阻塞任务，阻塞时间却决于参数timeout；
    • OS_OPT_PEND_NON_BLOCKING：若信号量没有资源，则任务直接返回；
  3. p_ts：指向接收信号量接收时的时间戳的变量的指针，没有则写0；
  4. p_err：指向接收错误代码变量的指针；

返回值：任务信号量资源数更新后的值；

12.1.2 释放信号量函数OSTaskSemPost()

函数原型输入形参：

OS_SEM_CTR  OSTaskSemPost (OS_TCB  *p_tcb,
                           OS_OPT   opt,
                           OS_ERR  *p_err)
  1. p_tcb：指向任务控制块的指针；
  2. opt：函数操作选项；
    • OS_OPT_POST_NONE：不指定特定的选项；
    • OS_OPT_POST_NO_SCHED：禁止在本函数内执行任务调度；
  3. p_err：指向接收错误代码变量的指针；

返回值：任务信号量资源数更新后的值；

12.1.3 强制设置指定的任务信号量为指定值函数OSTaskSemSet()

函数原型输入形参：

OS_SEM_CTR  OSTaskSemSet (OS_TCB      *p_tcb,
                          OS_SEM_CTR   cnt,
                          OS_ERR      *p_err)
  1. p_tcb：指向任务控制块的指针；
  2. cnt：指定的信号量资源数；
  3. p_err：指向接收错误代码变量的指针；

返回值：任务信号量设置前的资源数；

12.1.4 任务内嵌信号量实验

  • 实验目的：完成以下3个任务：
  1. start_task：创建task1、task2任务；
  2. task1：按键扫描，当检测到按键KEY0 被按下，释放task2任务内嵌信号量；
  3. task2：获取任务信号量，并打印相关提示信息；
  • 实验过程：以11.2.1 计数型信号量实验为基础：
  1. 删除计数型信号量相关代码；
  2. 编写task1、task2任务函数：
/* task1 往task2释放任务内嵌信号 */
void task1(void *p_arg)
{
	OS_ERR err;
	uint8_t key = 0;
	
	while(1)
	{
		key = key_scan(0);
		if(key == KEY0_PRES)
		{
			printf("释放任务信号量！\r\n");
			OSTaskSemPost(&task2_tcb,OS_OPT_POST_NONE,&err);
		}
		OSTimeDly(10,OS_OPT_TIME_DLY,&err);
	}
}

/* task2  获取任务信号量，并打印相关提示信息 */
void task2(void *p_arg)
{
	OS_ERR err;
	OS_SEM_CTR cnt = 0;
	
	while(1)
	{
		cnt = OSTaskSemPend (0,OS_OPT_PEND_BLOCKING,0,&err);
		printf("获取任务信号量成功，cnt 的值为%d\r\n",cnt);
		OSTimeDly(1000,OS_OPT_TIME_DLY,&err);
	}
}

代码运行结果：

  1. 按下key0，释放task2任务内嵌信号量，task2获取任务信号量：
    在这里插入图片描述

  2. 连续按下key0，连续释放task2任务内嵌信号量，task2依次获取任务信号量：
    在这里插入图片描述

  3. 在上述基础上，强制设置task2任务信号量为指定值：

OSTaskSemSet (&task2_tcb,1,&err); // 强制设置task2的任务信号量为指定值1

代码运行结果：上电后，不需要按下key0释放task2任务信号量，因为其资源数指定为1；
在这里插入图片描述

12.2 任务内嵌消息队列

任务内嵌消息队列(下称任务消息队列)本质上就是一个消息队列，与10. 消息队列 中介绍的消息队列是类似的，任务内嵌消息队列是分配于每一个任务的任务控制块结构体中的，因此每一个任务都有独自的任务内嵌消息队列，任务内嵌消息队列只能被该任务获取(读出)，但是可以由其他任务或中断释放(写入)，如下图所示：
在这里插入图片描述

任务消息队列的API 函数：
在这里插入图片描述

12.2.1 获取任务消息队列函数(读出队列)OSTaskQPend()

函数原型输入形参：

void  *OSTaskQPend (OS_TICK       timeout,
                    OS_OPT        opt,
                    OS_MSG_SIZE  *p_msg_size,
                    CPU_TS       *p_ts,
                    OS_ERR       *p_err)
  1. timeout：任务挂起等待消息队列的最大允许时间，为0时，表示一直等待，知道接收到消息；
  2. opt：函数操作选项，该参数配合timeout 使用；
opt描述
OS_OPT_PEND_BLOCKING若没有任何消息存在于消息队列，则阻塞任务
OS_OPT_PEND_NON_BLOCKING若没有任何消息存在于消息队列，则直接返回
  1. p_msg_size：指向一个变量，用于表示接收到的消息长度(字节数)；
  2. p_ts：指向接收消息队列接收时时间戳的变量的指针，为NULL 则表示没有使用时间戳；
  3. p_err：指向接收错误代码变量的指针；

函数的返回值：从上述函数原型可知，该函数的返回值类型为void *，即“万能指针”(任意类型数据都能指向)，故消息的读与写必须保持数据类型相同，否则会导致消息读写错乱；

12.2.2 发送任务消息队列函数(写入队列)OSTaskQPost()

函数原型输入形参：

void  OSTaskQPost (OS_TCB       *p_tcb,
                   void         *p_void,
                   OS_MSG_SIZE   msg_size,
                   OS_OPT        opt,
                   OS_ERR       *p_err)
  1. p_tcb：指向任务控制块的指针，类似于一个句柄；
  2. p_void：指向消息的指针；
  3. msg_size：消息的大小，单位：字节；
  4. opt：函数操作选项，可组合使用；
opt描述
OS_OPT_POST_FIFO将发送的消息保存在队列的末尾
OS_OPT_POST_LIFO将发送的消息保存在队列的开头
OS_OPT_POST_NO_SCHED禁止在本函数内执行任务调度
  1. p_err：指向接收错误代码变量的指针；

12.2.3 任务消息队列实验

  • 实验目的：完成以下3个任务：
  1. start_task：创建task1、task2任务；
  2. task1：按键扫描，将键值发送到task2任务消息队列；
  3. task2：获取任务消息队列，并打印相关提示信息；
  • 实验过程：以10.4 消息队列操作实验 为基础：
  1. 删除task3与消息队列相关代码；
  2. 编写task1、task2任务函数：
/* task1 写入任务消息队列 */
void task1(void *p_arg)
{
	OS_ERR err;
	uint8_t key=0;
	
	while(1)
	{
		key = key_scan(0);
		if(key == KEY0_PRES || key == KEY1_PRES|| key == WKUP_PRES)
		{
			printf("发送键值！\r\n");
			OSTaskQPost (&task2_tcb,&key,sizeof(key),OS_OPT_POST_FIFO,&err);
		}
		OSTimeDly(10,OS_OPT_TIME_DLY,&err);
	}
}

/* task2 读出任务消息队列key_queue */
void task2(void *p_arg)
{
	OS_ERR err;
	uint8_t *key; // 读出的消息队列要跟写入的消息队列的类型相同
	OS_MSG_SIZE size = 0;
	
	while(1)
	{
		OSTaskQPend (0,OS_OPT_PEND_BLOCKING,&size,NULL,&err);
		printf("接收到的数据长度为：%d字节\r\n",size);
	}
}

代码运行结果：
按下key0，task1发送键值1，task2接收到键值1；按下key1，task1发送键值2，task2接收到键值2；

在这里插入图片描述

13. 事件标志

事件标志与信号量一样属于任务间同步的一种机制，但是信号量一般用于任务间的单事件同步；

事件标志是一个用于指示事件是否发生的比特位，µC/OS-III 用 1表示事件发生，用 0 表示事件未发生；

事件标志组即是多个事件标志的集合；

事件标志组的特点：

  1. 其每个位表示一个事件，最多可表示32个事件标志；
  2. 每一位事件的含义，由用户自己决定；
  3. 任意任务或中断都可以写这些位，但读这些位只能由任务读；
  4. 可以等待某一位成立，或等待多位同时成立；(或操作、与操作)
  5. 支持读取阻塞；

事件标志组的逻辑关系图：
在这里插入图片描述
事件标志组的API 函数：更多详见《UCOS-III 开发指南》第十六章
在这里插入图片描述

使用事件标志组的流程：创建事件标志组 --> 设置事件标志 --> 获取事件标志；

13.1 创建事件标志组函数OSFlagCreate()

函数原型输入形参：

void  OSFlagCreate (OS_FLAG_GRP  *p_grp,
                    CPU_CHAR     *p_name,
                    OS_FLAGS      flags,
                    OS_ERR       *p_err)
  1. p_grp：指向事件标注组结构体的指针；
  2. p_name：指向作为事件标志组名的ASCII 字符串的指针；
  3. flags：事件标志组的初始值，一般设置为0，表示初始无任务发生；
  4. p_err：指向接收错误代码变量的指针；

13.2 设置事件标注组的事件函数OSFlagPost()

函数原型输入形参：

OS_FLAGS  OSFlagPost (OS_FLAG_GRP  *p_grp,
                      OS_FLAGS      flags,
                      OS_OPT        opt,
                      OS_ERR       *p_err)
  1. p_grp：指向事件标注组结构体的指针；
  2. flags：等待的事件标志；
  3. opt：OS_OPT_POST_FLAG_SET置1，OS_OPT_POST_FLAG_CLR清0；
  4. p_err：指向接收错误代码变量的指针；

函数的返回值：事件标志组更新后的事件标志值；

13.3 等待事件标注组中的事件函数OSFlagPend()

函数原型输入形参：

OS_FLAGS  OSFlagPend (OS_FLAG_GRP  *p_grp,
                      OS_FLAGS      flags,
                      OS_TICK       timeout,
                      OS_OPT        opt,
                      CPU_TS       *p_ts,
                      OS_ERR       *p_err)
  1. p_grp：指向事件标注组结构体的指针；
  2. flags：等待的事件标志；
  3. timeout：任务挂起等待事件标志组的最大允许时间当为0时，表示一直等待，直到接收到信号；
  4. opt：函数操作选项；
opt描述
OS_OPT_PEND_FLAG_CLR_ALL等待“flags” 中的所有指定位被清0
OS_OPT_PEND_FLAG_CLR_ANY等待“flags” 中的任意指定位被清0
OS_OPT_PEND_FLAG_SET_ALL等待“flags” 中的所有指定位被置1
OS_OPT_PEND_FLAG_SET_ANY等待“flags” 中的任意指定位被置1
调用上述四个选项时，还可以搭配下面三个选项
OS_OPT_PEND_FLAG_CONSUME当等待到指定位后，清0对应位
OS_OPT_PEND_BLOCKING标志组不满足条件时挂起任务
OS_OPT_PEND_NON_BLOCKING标志组不满足条件时不挂起任务
  1. p_ts：指向接收等待到事件时的时间戳的变量的指针，一般设置为NULL；
  2. p_err：指向接收错误代码变量的指针；

函数的返回值：任务实际等待到的事件标志，如果没有则返回0；

13.4 事件标注组实验

  • 实验目的：完成以下3个任务：
  1. start_task：创建task1、task2任务，创建事件标志组；
  2. task1：按键扫描，根据不同键值将事件标志组相应事件位置1，模拟事件发生；
  3. task2：同时等待事件标志组中的多个事件位，当这些事件位都置1，就打印提示信息；
  • 实验过程：以10.4 消息队列操作实验 为基础：
  1. 删除task3与消息队列相关代码；
  2. 定义定义事件标志组指针与事件标志组bit0、bit1
 OS_FLAG_GRP flag; // 定义事件标志组指针
 #define FLAG_BIT0 (1<<0) // 定义事件标志组bit0，0x01
 #define FLAG_BIT1 (1<<1) // 定义事件标志组bit1，0x02
  1. 创建一个事件标志组：
OSFlagCreate (&flag,"flag",0,&err);/* 创建一个事件标志组 */
  1. 编写task1、task2任务函数：
/* task1 设置事件标志 */
void task1(void *p_arg)
{
	OS_ERR err;
	uint8_t key=0;
	
	while(1)
	{
		key = key_scan(0);
		if(key == KEY0_PRES)
		{
			printf("KEY0按下，bit0置1！\r\n");
			OSFlagPost (&flag,FLAG_BIT0,OS_OPT_POST_FLAG_SET,&err); // bit0置1

		}
		else if(key == KEY1_PRES)
		{
			printf("KEY1按下，bit1置1！\r\n");
			OSFlagPost (&flag,FLAG_BIT1,OS_OPT_POST_FLAG_SET,&err);// bit1置1
		}
			
		OSTimeDly(10,OS_OPT_TIME_DLY,&err);
	}
}

/* task2 等待事件标志 */
void task2(void *p_arg)
{
	OS_ERR err;
	
	while(1)
	{
		OSFlagPend (&flag,
					FLAG_BIT0|FLAG_BIT1,
					0,
					OS_OPT_PEND_FLAG_SET_ALL|OS_OPT_PEND_FLAG_CONSUME|OS_OPT_PEND_BLOCKING,
					NULL,
					&err);
		printf("等待到指定事件成立！\r\n");
	}
}

代码运行结果：

  1. 按下key0和key1：
    在这里插入图片描述
  2. 若把task2 任务函数中的OS_OPT_PEND_FLAG_SET_ALL|OS_OPT_PEND_FLAG_CONSUME|OS_OPT_PEND_BLOCKING,改为S_OPT_PEND_FLAG_SET_ALL|OS_OPT_PEND_BLOCKING,，即去掉“当等待到指定位后，清0对应位”功能，则在按下key0和key1后，由于对应位一直为1，故一直不阻塞task2：
    在这里插入图片描述
  3. 若把task2 任务函数中的OS_OPT_PEND_FLAG_SET_ALL|OS_OPT_PEND_FLAG_CONSUME|OS_OPT_PEND_BLOCKING,改为OS_OPT_PEND_FLAG_SET_ANY|OS_OPT_PEND_FLAG_CONSUME|OS_OPT_PEND_BLOCKING,，即将“等待“flags” 中的所有指定位被置1”更改为“等待“flags” 中的任意指定位被置1”，则在按下key0或key1任意一个后，即可触发“等待到指定事件”：
    在这里插入图片描述

14. 软件定时器

定时器：从指定时刻开始，经过一个指定时间，然后触发一个超时事件，用户可自定义定时器的周期；

硬件定时器：芯片本身自带的定时器模块，硬件定时器的精度一般很高，每次在定时时间到达后就会自动触发一个定时器中断，用户在中断服务函数中处理信息；

软件定时器：指具有定时功能的软件，可设置定时周期，当指定时间到达后调用回调函数(又叫超时函数)，用户在回调函数中处理信息；

软件定时器的优缺点：

  1. 硬件定时器数量有限，而软件定时器理论上只需有足够多的内存，就可创建多个；
  2. 使用简单，成本低；
  3. 软件定时器相对硬件定时器，精度不高，对于需要高精度场合不适用；

单次定时器：一旦定时超时，只会执行一次其软件定时器回调函数，并且不会自动重新开启定时，只能手动重新开始；
周期定时器：一旦启动软件定时器后，就会在执行完回调函数后自动重新开始定时，从而周期地执行其软件定时器的回调函数；

软件定时器的状态：

  1. 未使用态：软件定时器被定义但未被创建或软件定时器被删除时；
  2. 停止态：软件定时器被创建但未开启定时器或被停止时；新创建的软件定时器默认处于停止状态；
  3. 运行态：运行态的定时器，当指定时间到达后，其回调函数会被调用；
  4. 完成态：当单次定时器定时超时后，软件定时器处于完成态；

软件定时器的特点：

  1. 支持裁剪：如需使能软件定时器，需将OS_CFG_TMR_EN 配置项置1；

注：软件定时器的超时回调函数由 软件定时器服务任务 调用，软件定时器的超时回调函数本身不是任务，因此不能在该回调函数中使用可能会导致任务阻塞的API 函数(如系统延时、等待信号量、读取队列等)；

  1. 软件定时器的频率由宏OS_CFG_TMR_TASK_RATE_HZ (默认为10)决定，要注意软件定时器的定时器频率并不等于系统时钟节拍的频率，但软件定时器是依靠系统节拍实现定时的，故需要进行换算；

软件定时器时间分辨率 ： OSTmrToTicksMult = OSCfg_TickRate_Hz / OSCfg_TmrTaskRate_Hz;；
*
如：在本教程的实验例程中将宏 OSCfg_TmrTaskRate_Hz 配置为 10，将宏OSCfg_TickRate_Hz配置为 1000，这代表着软件定时器的定时器频率为 10Hz，那么当开启了一个定时器时长为 10 的软件定时器后，软件定时器将会在大约 1000 毫秒后超时（因为频率为 10Hz，所以周期为 100ms，那么总的定时器周期就为 10*100ms=1000ms）；
*
详见《UCOS-III开发指南》17.1.6 软件定时器定时频率

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

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

相关文章

【因果推断python】32_合成控制2

【因果推断python】32_合成控制2

目录 合成控制作为线性回归的一种实现​编辑 合成控制作为线性回归的一种实现 为了估计综合控制的治疗效果&#xff0c;我们将尝试构建一个类似于干预期之前的治疗单元的“假单元”。然后&#xff0c;我们将看到这个“假单位”在干预后的表现。合成控制和它所模仿的单位之间的…
阅读更多...
Apollo配置中心最佳实践

Apollo配置中心最佳实践

携程配置中心地址&#xff1a;GitCode - 全球开发者的开源社区,开源代码托管平台 1.1 Apollo配置中心介绍 Apollo&#xff08;阿波罗&#xff09;是开源配置管理中心&#xff0c;能够集中化管理应用不同环境、不同集群的配置&#xff0c;配置修改后能够实时推送到应用端…
阅读更多...
【课程总结】Day9：机器学习主要知识点梳理

【课程总结】Day9：机器学习主要知识点梳理

阅读更多...
又一个对标Sora的AI视频工具，Dream Machine，开始免费试用

又一个对标Sora的AI视频工具，Dream Machine，开始免费试用

新的AI视频工具又又来了-Dream Machine&#xff0c;开始免费试用。 地址&#xff1a;https://lumalabs.ai/dream-machine 该工具需要科学上网 先看一下官网的宣传视频 luma AI 发布 Dream Machine 我生成了几个视频&#xff0c;效果还可以 生成视频很简单 只需要输入描述就可…
阅读更多...
高等数学笔记（一）：映射与函数

高等数学笔记（一）：映射与函数

一、映射 1.1 映射的概念 存在一个法则 f &#xff0c;使得对 X 中每个元素 x &#xff0c;在 Y 中有唯一确定的元素 y 与之对应&#xff08;X、Y 非空集&#xff09; 称 f 为从 X 到 Y 的映射&#xff0c;如图所示 其中 y 称为元素 x&#xff08;在映射 f 下&#xff09;的…
阅读更多...
高交会专题展—2024BTE第8届国际生物技术大会暨展览会

高交会专题展—2024BTE第8届国际生物技术大会暨展览会

第二十六届中国国际高新技术成果交易会 THE 26th CHINA HI-TECH FAIR BTE第8届国际生物技术大会暨展览会 The 8th International Bio-technology Conference & Expo 2024年11月14-16日 深圳国际会展中心 展位预定&#xff1a;137交易会1016交易会3299 龚经理 组织机构…
阅读更多...
企业商家如何精明选择软件开发公司

企业商家如何精明选择软件开发公司

在当今信息化社会&#xff0c;企业的运营和发展已经离不开软件系统的支持。而选择一个合适的软件开发公司&#xff0c;则成为了企业商家在信息化道路上的一大挑战。那么&#xff0c;究竟如何挑选出既符合业务需求&#xff0c;又能保障项目成功的软件开发公司呢&#xff1f; 明…
阅读更多...
【第5章】Vue之API风格

【第5章】Vue之API风格

文章目录 前言一、选项式 API&#xff08;Options API&#xff09;1. 代码2. 效果 二、组合式 API&#xff08;Composition API&#xff09;1. 代码2. 效果 三、两者之间的区别总结 前言 Vue.js 提供了两种主要的 API 风格来组织组件的代码&#xff1a;选项式 API&#xff08;…
阅读更多...
SAP MMRV/MMPV 物料账期月结月底月初开关

SAP MMRV/MMPV 物料账期月结月底月初开关

公告&#xff1a;周一至周五每日一更&#xff0c;周六日存稿&#xff0c;请您点“关注”和“在看”&#xff0c;后续推送的时候不至于看不到每日更新内容&#xff0c;感谢。 这是一条刮刮乐&#xff0c;按住全部选中&#xff1a;点关注的人最帅最美&#xff0c;欢迎&#xff1…
阅读更多...
码农学点儿经济学-博傻理论

码农学点儿经济学-博傻理论

博傻理论 一位石油大佬去天堂开会&#xff0c;他兴冲冲地跑进会议室&#xff0c;却发现座无虚席&#xff0c;早已经没了他的座位。于是他灵机一动&#xff0c;大喊一声&#xff1a;大家注意啦&#xff01;听说&#xff0c;有人在地狱发现了石油&#xff01;此言一出&#xff0c…
阅读更多...
(财务应用程序:计算利息)

(财务应用程序:计算利息)

(财务应用程序:计算利息)如果知道收支余额和年利率的百分比&#xff0c;就可以使用下面的 公式计算&#xff1a; 编写程序&#xff0c;读取收支余额和年百分利率&#xff0c;显示下月利息。下面是一个运行示例: package myjava; import java.math.*; import java.util.Scanner;…
阅读更多...
10.4 Go 并发模式

10.4 Go 并发模式

&#x1f49d;&#x1f49d;&#x1f49d;欢迎莅临我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:「stormsha的主页」…
阅读更多...
使用Arthas查看方法的参数信息情况

使用Arthas查看方法的参数信息情况

使用Arthas查看方法的参数信息情况 前言 最近在排查一个bug&#xff0c;需要看看一个接口方法的传参&#xff0c;但是方法里并没有打印传参&#xff0c;而且还是生产环境&#xff0c;更新包也麻烦&#xff0c;所以&#xff0c;准备安装一下Arthas&#xff0c;通过Arthas可以做…
阅读更多...
iText7——画发票PDF（完整）

iText7——画发票PDF（完整）

显示描述&#xff1a; 1、每页显示必须带有发票头、“销售方和购买方信息” 2、明细填充为&#xff1a;当n≤8 行时&#xff0c;发票总高度140mm&#xff0c;每条发票明细行款高度4.375mm&#xff1b; 当8<n≤12行时&#xff0c;发票高度增加17.5mm&#xff0c;不换页&#…
阅读更多...
Flink任务如何跑起来之 2.算子 StreamOperator

Flink任务如何跑起来之 2.算子 StreamOperator

Flink任务如何跑起来之 2.算子 StreamOperator 前文介绍了Transformation创建过程&#xff0c;大多数情况下通过UDF完成DataStream转换中&#xff0c;生成的Transformation实例中&#xff0c;核心逻辑是封装了SimpleOperatorFactory实例。 UDF场景下&#xff0c;DataStream到…
阅读更多...
python怎么显示行号

python怎么显示行号

我们如果想让Python IDLE显示行号&#xff0c;我们可以通过扩展IDLE功能来做到。 1.我们需要下载一个LineNumber.py扩展。 2.我们打开Python安装目录&#xff0c;找到安装目录下的Lib\idlelib目录&#xff0c;复制LineNumber到这个目录。 3.然后启动扩展。 4.配置扩展的方式…
阅读更多...
CCF 矩阵重塑

CCF 矩阵重塑

第一题&#xff1a;矩阵重塑&#xff08;一&#xff09; 本题有两种思路 第一种 &#xff08;不确定是否正确 但是100分&#xff09; #include<iostream> using namespace std; int main(){int n,m,p,q,i,j;cin>>n>>m>>p>>q;int a[n][m];for(i…
阅读更多...
英语学习笔记34——What are they doing?

英语学习笔记34——What are they doing?

What are they doing? 他们在做什么&#xff1f; 词汇 Vocabulary sleep v. 睡觉 ing形式&#xff1a;sleeping 例句&#xff1a;那个男孩正在睡觉。 　　　That boy is sleeping. 相关&#xff1a;sleepy 困的 例句&#xff1a;我太困了。 　　　I’m so sleepy. shave v.…
阅读更多...
实时数据的处理一致性如何保证？

实时数据的处理一致性如何保证？

实时数据一致性的定义以及面临的挑战 数据一致性通常指的是数据在整个系统或多个系统中保持准确、可靠和同步的状态。在实时数据处理中&#xff0c;一致性包括但不限于数据的准确性、完整性、时效性和顺序性。 下图是典型的实时/流式数据处理的流程&#xff1a; 流式数据以各…
阅读更多...
技术速递｜Java on Azure Tooling 5月更新 - Java 对 Azure 容器应用程序的入门指南支持

技术速递｜Java on Azure Tooling 5月更新 - Java 对 Azure 容器应用程序的入门指南支持

作者&#xff1a;Jialuo Gan 排版&#xff1a;Alan Wang 大家好&#xff0c;欢迎阅读 Java on Azure 工具 5 月份更新。在本次更新中&#xff0c;我们将介绍 Java 在 Azure 上的容器应用程序的入门指南。希望您喜欢这些更新&#xff0c;并享受使用 Azure 工具包的流畅体验。请下…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023