1. Toy模板网首页
  2. > Toy博客

空闲任务与阻塞延时(笔记)

9月前 作者：Asita_c 分类：Toy博客 阅读(72) 违法举报

这篇具有很好参考价值的文章主要介绍了空闲任务与阻塞延时(笔记)。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

前言

软件延时是让CPU等待达到延时效果。
而RTOS的优势是可以充分发挥CPU的性能，永远不会让CPU闲着。
RTOS中的延时叫做阻塞延时

空闲任务

当没有其他任务可以运行时，RTOS会为CPU创建一个空闲任务，然后CPU去执行。
在RTOS中，空闲任务是系统在调度器创建的优先级最低的任务，空闲任务主体是主要做一些系统内存的清理工作。

实现空闲任务

1、定义空闲任务栈

在min.c 中定义：

/* 获取空闲任务的内存 */
StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
TCB_t IdleTaskTCB;

在FeeRTOSConfig.h中定义的宏

#define configMINIMAL_STACK_SIZE	( ( unsigned short ) 128 )//（字，即512个字节）

2、定义空闲任务的任务控制块

定义空闲任务的任务控制块

TCB_t IdleTaskTCB;

3## 3、定义空闲函数主体
在mask.c 中定义：

#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )//在protmacro.h
static portTASK_FUNCTION( prvIdleTask, pvParameters ) //prvIdleTask( void *pvParameters )
{
	/* 防止编译器的警告 */
	( void ) pvParameters;
    
    for(;;)
    {
        /* 空闲任务暂时什么都不做 */
    }
}

4、定义空闲任务主体

extern TCB_t IdleTaskTCB;
void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
                                    StackType_t **ppxIdleTaskStackBuffer, 
                                    uint32_t *pulIdleTaskStackSize );
void vTaskStartScheduler( void )
{
/*======================================创建空闲任务start==============================================*/     
    TCB_t *pxIdleTaskTCBBuffer = NULL;               /* 用于指向空闲任务控制块 */
    StackType_t *pxIdleTaskStackBuffer = NULL;       /* 用于空闲任务栈起始地址 */
    uint32_t ulIdleTaskStackSize;
    
    /* 获取空闲任务的内存：任务栈和任务TCB */
    vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, 
                                   &pxIdleTaskStackBuffer, 
                                   &ulIdleTaskStackSize );    
    
    xIdleTaskHandle = xTaskCreateStatic( (TaskFunction_t)prvIdleTask,              /* 任务入口 */
					                     (char *)"IDLE",                           /* 任务名称，字符串形式 */
					                     (uint32_t)ulIdleTaskStackSize ,           /* 任务栈大小，单位为字 */
					                     (void *) NULL,                            /* 任务形参 */
					                     (StackType_t *)pxIdleTaskStackBuffer,     /* 任务栈起始地址 */
					                     (TCB_t *)pxIdleTaskTCBBuffer );           /* 任务控制块 */
    /* 将任务添加到就绪列表 */                                 
    vListInsertEnd( &( pxReadyTasksLists[0] ), &( ((TCB_t *)pxIdleTaskTCBBuffer)->xStateListItem ) );
/*======================================创建空闲任务end================================================*/
                                         
    /* 手动指定第一个运行的任务 */
    pxCurrentTCB = &Task1TCB;
                                         
    /* 初始化系统时基计数器 */
    xTickCount = ( TickType_t ) 0U;
    
    /* 启动调度器 */
    if( xPortStartScheduler() != pdFALSE )
    {
        /* 调度器启动成功，则不会返回，即不会来到这里 */
    }
}

vApplicationGetIdleTaskMemory()函数需要用户自己实现：
在main.c中

void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
                                    StackType_t **ppxIdleTaskStackBuffer, 
                                    uint32_t *pulIdleTaskStackSize )
{
		*ppxIdleTaskTCBBuffer=&IdleTaskTCB;//任务控制块
		*ppxIdleTaskStackBuffer=IdleTaskStack; //任务栈的起始地址
		*pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;//任务栈的大小
}

其中，prvIdleTask在task.c中定义的空闲任务的任务句柄

static TaskHandle_t xIdleTaskHandle					= NULL;//实现空闲任务的任务句柄
  1. 空闲任务只有在CPU空闲时才会执行。
  2. 空闲任务优先级最低是不能被阻塞的。
  3. 空闲任务主要做内存清理等辅助性工作如检查变量等。

实现阻塞延时

阻塞延时是指任务调用该延时函数后，任务会被剥夺CPU的使用权，然后进入阻塞状态，直到延时结束，任务重新获得CPU使用权才继续执行任务。

在FreeRTOS.h中的任务控制块定义中，增加了一个成员，用于记录需要延时的时间

typedef struct tskTaskControlBlock
{
	volatile StackType_t    *pxTopOfStack;    /* 栈顶 */

	ListItem_t			    xStateListItem;   /* 任务节点 */
    
    StackType_t             *pxStack;         /* 任务栈起始地址 */
	                                          /* 任务名称，字符串形式 */
	char                    pcTaskName[ configMAX_TASK_NAME_LEN ];

    TickType_t xTicksToDelay; /* 用于延时 */    
} tskTCB;
typedef tskTCB TCB_t;

vTaskDelay()函数

void vTaskDelay( const TickType_t xTicksToDelay )
{
    TCB_t *pxTCB = NULL;
    
    /* 获取当前任务的TCB */
    pxTCB = pxCurrentTCB;
    
    /* 设置延时时间 */
    pxTCB->xTicksToDelay = xTicksToDelay;
    
    /* 任务切换 */
    taskYIELD();
}

任务与空闲任务切换的例子：vTaskSwitchContext()函数

思路：
如果当前是执行的任务是空闲任务就去尝试执行任务1和任务2，看看这两个任务的延时时间是否结束，如果没有到期，返回继续执行空闲函数。
如果当前是执行的任务是任务1或者任务2，检查一下下一个任务，如果另一个任务不在延时中，就切换到该任务。否则，判断当前任务是否应该进入延时状态，如果是就切换到空闲任务，否则就不做任务切换。

void vTaskSwitchContext( void )
{
	/* 如果当前线程是空闲线程，那么就去尝试执行线程1或者线程2，
       看看他们的延时时间是否结束，如果线程的延时时间均没有到期，
       那就返回继续执行空闲线程 */
	if( pxCurrentTCB == &IdleTaskTCB )
	{
		if(Task1TCB.xTicksToDelay == 0)
		{            
            pxCurrentTCB =&Task1TCB;
		}
		else if(Task2TCB.xTicksToDelay == 0)
		{
            pxCurrentTCB =&Task2TCB;
		}
		else
		{
			return;		/* 线程延时均没有到期则返回，继续执行空闲线程 */
		} 
	}
	else
	{
		/*如果当前线程是线程1或者线程2的话，检查下另外一个线程,如果另外的线程不在延时中，就切换到该线程
        否则，判断下当前线程是否应该进入延时状态，如果是的话，就切换到空闲线程。否则就不进行任何切换 */
		if(pxCurrentTCB == &Task1TCB)
		{
			if(Task2TCB.xTicksToDelay == 0)
			{
                pxCurrentTCB =&Task2TCB;
			}
			else if(pxCurrentTCB->xTicksToDelay != 0)
			{
                pxCurrentTCB = &IdleTaskTCB;
			}
			else 
			{
				return;		/* 返回，不进行切换，因为两个线程都处于延时中 */
			}
		}
		else if(pxCurrentTCB == &Task2TCB)
		{
			if(Task1TCB.xTicksToDelay == 0)
			{
                pxCurrentTCB =&Task1TCB;
			}
			else if(pxCurrentTCB->xTicksToDelay != 0)
			{
                pxCurrentTCB = &IdleTaskTCB;
			}
			else 
			{
				return;		/* 返回，不进行切换，因为两个线程都处于延时中 */
			}
		}
	}
}

SysTick中断服务函数

如果一个任务需要延时，一开始xTicksToDelay肯定不为0，当xTicksToDelay变为0时，表示延时结束。
但是，存在一个问题，xTicksToDelay是以什么周期递减，在哪里递减的。

在FreeRTOS中，这个周期由SysTick中断提供，操作系统中最小的时间单位就是SysTick的中断周期，我们称之为一个tick。
SysTick中断服务函数在port.c中实现。

void xPortSysTickHandler( void )
{
	/* 关中断 */
    vPortRaiseBASEPRI();
    
    /* 更新系统时基 */
    xTaskIncrementTick();

	/* 开中断 */
    vPortClearBASEPRIFromISR();
}

更新系统时基

void xTaskIncrementTick( void )
{
    TCB_t *pxTCB = NULL;
    BaseType_t i = 0;
    
    /* 更新系统时基计数器xTickCount，xTickCount是一个在port.c中定义的全局变量 */
    const TickType_t xConstTickCount = xTickCount + 1;
    xTickCount = xConstTickCount;

    
    /* 扫描就绪列表中所有线程的xTicksToDelay，如果不为0，则减1 */
	for(i=0; i<configMAX_PRIORITIES; i++)
	{
        pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &pxReadyTasksLists[i] ) );
		if(pxTCB->xTicksToDelay > 0)
		{
			pxTCB->xTicksToDelay --;
		}
	}
    
    /* 任务切换 */
    portYIELD();
}

SysTick初始化函数

SysTick的中断服务函数想要被顺利执行，则SysTick必须先初始化。SysTick的初始化函数vPortSetupTimerInterrupt()在port.c中定义

void vPortSetupTimerInterrupt( void )
{
     /* 设置重装载寄存器的值 */
    portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;
    
    /* 设置系统定时器的时钟等于内核时钟
       使能SysTick 定时器中断
       使能SysTick 定时器 */
    portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | 
                                  portNVIC_SYSTICK_INT_BIT |
                                  portNVIC_SYSTICK_ENABLE_BIT ); 
}

configSYSTICK_CLOCK_HZ 为系统时钟，port.c中被重定义

#ifndef configSYSTICK_CLOCK_HZ
	#define configSYSTICK_CLOCK_HZ configCPU_CLOCK_HZ
	/* 确保SysTick的时钟与内核时钟一致 */
	#define portNVIC_SYSTICK_CLK_BIT	( 1UL << 2UL )
#else
	#define portNVIC_SYSTICK_CLK_BIT	( 0 )
#endif

其中，configCPU_CLOCK_HZ的原始定义在FreeRTOSconfig.h中定义

#define configCPU_CLOCK_HZ			( ( unsigned long ) 25000000 )

configTICK_RATE_HZ 为系统时基，在FreeRTOSconfig.h中定义

#define configTICK_RATE_HZ			( ( TickType_t ) 100 )

这里系统时钟频率为25Mhz，即1s有25000000Tick，那么1ms就有25000Tick。而每个周期中断100次，中断周期为25Mhz/100=250000Tick，因此中断一次为250000Tick/25000Tick=10ms.

可以参考《STM32F10xxx Cortex-M3 programming manual》手册，在port.c中定义为偏移：

#define portNVIC_SYSTICK_INT_BIT			( 1UL << 1UL )
#define portNVIC_SYSTICK_ENABLE_BIT			( 1UL << 0UL )

实验

把软件延时替换时钟延时

#include "FreeRTOS.h"
#include "task.h"

extern List_t pxReadyTasksLists[ configMAX_PRIORITIES ];

TaskHandle_t Task1_Handle;
#define TASK1_STACK_SIZE                    128
StackType_t Task1Stack[TASK1_STACK_SIZE];
TCB_t Task1TCB;

TaskHandle_t Task2_Handle;
#define TASK2_STACK_SIZE                    128
StackType_t Task2Stack[TASK2_STACK_SIZE];
TCB_t Task2TCB;

void delay (uint32_t count);
void Task1_Entry( void *p_arg );
void Task2_Entry( void *p_arg );

int main(void)
{	
    /* 硬件初始化 */
	/* 将硬件相关的初始化放在这里，如果是软件仿真则没有相关初始化代码 */
    
    /* 初始化与任务相关的列表，如就绪列表 */
    prvInitialiseTaskLists();
    
    /* 创建任务 */
    Task1_Handle = xTaskCreateStatic( (TaskFunction_t)Task1_Entry,   /* 任务入口 */
					                  (char *)"Task1",               /* 任务名称，字符串形式 */
					                  (uint32_t)TASK1_STACK_SIZE ,   /* 任务栈大小，单位为字 */
					                  (void *) NULL,                 /* 任务形参 */
					                  (StackType_t *)Task1Stack,     /* 任务栈起始地址 */
					                  (TCB_t *)&Task1TCB );   /* 任务控制块 */
    /* 将任务添加到就绪列表 */                                 
    vListInsertEnd( &( pxReadyTasksLists[1] ), &( ((TCB_t *)(&Task1TCB))->xStateListItem ) );
                                
    Task2_Handle = xTaskCreateStatic( (TaskFunction_t)Task2_Entry,   /* 任务入口 */
					                  (char *)"Task2",               /* 任务名称，字符串形式 */
					                  (uint32_t)TASK2_STACK_SIZE ,   /* 任务栈大小，单位为字 */
					                  (void *) NULL,                 /* 任务形参 */
					                  (StackType_t *)Task2Stack,     /* 任务栈起始地址 */
					                  (TCB_t *)&Task2TCB );   /* 任务控制块 */
    /* 将任务添加到就绪列表 */                                 
    vListInsertEnd( &( pxReadyTasksLists[2] ), &( ((TCB_t *)(&Task2TCB))->xStateListItem ) );
                                      
    /* 启动调度器，开始多任务调度，启动成功则不返回 */
    vTaskStartScheduler();                                      
    
    for(;;)
	{
		/* 系统启动成功不会到达这里 */
	}
}

/* 软件延时 */
void delay (uint32_t count)
{
	for(; count!=0; count--);
}
/* 任务1 */
void Task1_Entry( void *p_arg )
{
	for( ;; )
	{
#if 0        
		flag1 = 1;
		delay( 100 );		
		flag1 = 0;
		delay( 100 );
		
		/* 线程切换，这里是手动切换 */
        portYIELD();
#else
		flag1 = 1;
        vTaskDelay( 2 ); //延时20ms
		flag1 = 0;
        vTaskDelay( 2 );
#endif        
	}
}

/* 任务2 */
void Task2_Entry( void *p_arg )
{
	for( ;; )
	{
#if 0        
		flag2 = 1;
		delay( 100 );		
		flag2 = 0;
		delay( 100 );
		
		/* 线程切换，这里是手动切换 */
        portYIELD();
#else
		flag2 = 1;
        vTaskDelay( 2 );		
		flag2 = 0;
        vTaskDelay( 2 );
#endif        
	}
}

/* 获取空闲任务的内存 */
StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
TCB_t IdleTaskTCB;
void vApplicationGetIdleTaskMemory( TCB_t **ppxIdleTaskTCBBuffer, 
                                    StackType_t **ppxIdleTaskStackBuffer, 
                                    uint32_t *pulIdleTaskStackSize )
{
		*ppxIdleTaskTCBBuffer=&IdleTaskTCB;
		*ppxIdleTaskStackBuffer=IdleTaskStack; 
		*pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
}

仿真

空闲任务与阻塞延时(笔记)
宏观上看几乎是同时运行的

从微观上看
空闲任务与阻塞延时(笔记)
空闲任务与阻塞延时(笔记)
高低电平是几近20ms的，实验结果与代码相符。

学习于《FreeRTOS内核实现与应用开发实战指南–基于stm32》
b站视频地址：https://www.bilibili.com/video/BV1Jx411X7NS/文章来源地址https://www.toymoban.com/news/detail-437430.html

到了这里，关于空闲任务与阻塞延时(笔记)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【HAL库】STM32CubeMX开发----非阻塞延时实验----SysTick(滴答定时器)中断

    【HAL库】STM32CubeMX开发----非阻塞延时实验----SysTick(滴答定时器)中断

    STM32CubeMX 下载和安装 详细教程 【HAL库】STM32CubeMX开发----STM32F103/F207/F407----目录 HAL库 有自带的 ms级 延时函数： HAL_Delay(); 缺点： 这是 阻塞延时 方式，就是延时期间，什么都不能干，这样很浪费资源。 这篇文章主要介绍，利用 SysTick(滴答定时器)中断 实现 非阻塞延时 的实验

    2024年02月16日
    浏览(51)

  • js------定时任务和延时任务

    取消定时任务  取消定时任务，有的时候需要将定时器定义成全局，这样就可以在别的函数或者用户点击别的按钮取消定时任务 setTimeout（）      延时任务 取消延时任务

    2024年02月15日
    浏览(45)
  • RabbitMQ高阶使用延时任务

    RabbitMQ高阶使用延时任务

    我们把滴滴打车的流程简化下 登录app后点击打车开始进行打车 打车服务开始为司机派单 司机接单后开始给来接驾 上车乘客后处于行程中 行程结束后完成本次打车服务 我们需要实现派单服务，用户发送打车订单后需要进行进行派单，如果在指定时间内没有找到司机就会收到

    2024年02月11日
    浏览(23)
  • 分布式、锁、延时任务

    分布式、锁、延时任务

    Redis分布式锁-这一篇全了解(Redission实现分布式锁完美方案) ls / / 下有哪些子节点 get /zookeeper 查看某个子节点内容 create /aa “test” delete /aa set /aa “test01” 模式 默认创建永久 create -e 创建临时 create -e /zz “hello zz” create -s 创建 有序节点 create -s -e 临时序列化节点 一次性的监

    2024年02月09日
    浏览(66)
  • 延时任务的解决方案

    延时任务的解决方案

    该方案通常是在小型项目中使用，即通过一个线程定时的去扫描数据库，通过订单时间来判断是否有超时的订单，然后进行update或delete等操作 代码示例： 1.优点：简单易行，支持集群操作 2.缺点： 对服务器内存消耗大 存在延迟，比如你每隔3分钟扫描一次，那最坏的延迟时间

    2024年01月24日
    浏览(42)
  • 如何实现延时任务（订单到期关闭）

    如何实现延时任务（订单到期关闭）

    目录 一、被动关闭 二、定时任务 三、JDK自带的DelayQueue 四、Netty的时间轮 五、Kafka的时间轮 六、RocketMQ延迟消息 七、RabbitMQ死信队列 八、RabbitMQ插件 九、Redis过期监听 十、Redis的zset 十一、Redisson + Redis 总结  在电商、支付等系统中，一般都是先创建订单（支付单），再给用

    2024年02月10日
    浏览(33)

  • 优雅实现延时任务之zookeeper篇

    前言 在《优雅实现延时任务之Redis篇》一文中提到，实现延时任务的关键点，是要存储任务的描述和任务的执行时间，还要能根据任务执行时间进行排序，那么我们可不可以使用zookeeper来实现延时任务呢？答案当然是肯定的。要知道，zookeeper的znode同样可以用来存储数据，那

    2024年01月16日
    浏览(31)
  • 浅析 FreeRTOS SysTick 和任务延时

    浅析 FreeRTOS SysTick 和任务延时

    FreeRTOS 提供的最小时间单元为一个 SysTick，举例： 假设配置 RTOS 的 SysTick 为 100Hz，则 RTOS 能提供的最小时间单位为 1/100 s，即 10ms. 即一个 RTOS 的系统时钟为 10ms. FreeRTOS 自带了一个 SysTick 计数器，任务调度器启用后，每个 SysTick 发生，该计数器就加一。可以通过下述函数获取任

    2024年02月14日
    浏览(30)

  • uniapp中延时执行任务的方法

    在 uniapp 中，可以使用 JavaScript 内置的 setTimeout 函数来延时执行任务。 具体用法如下： 上面的代码中，setTimeout 函数的第一个参数是一个匿名函数，表示要延时执行的代码。第二个参数是延时的时间，单位是毫秒。 使用 setTimeout 函数，就可以在 uniapp 中延时执行任务了。 注意

    2024年02月13日
    浏览(39)
  • stm32 freertos多任务状态迁移，中断临界段，任务延时

    stm32 freertos多任务状态迁移，中断临界段，任务延时

    arm中SP，LR，PC寄存器以及其它所有寄存器以及处理器运行模式介绍 特权级与用户级的区别主要是某些寄存器能不能访问与修改： cortex M3/M4内核 特权级与用户级详解 Cortex-M3双堆栈MSP和PSP Cortex-M3双堆栈MSP和PSP M3内核何时使用MSP何时使用PSP？ 特权级可以使用MSP 和PSP指针 用户级

    2024年02月12日
    浏览(52)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包