Freertos任务管理

最新推荐文章于 2024-10-05 12:07:50 发布
最新推荐文章于 2024-10-05 12:07:50 发布
阅读量248 收藏 1
点赞数 9
分类专栏： freeRTOS 文章标签： java 算法 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lovesjj_1011/article/details/134819226
版权
本文介绍了嵌入式实时操作系统(RTOS)中任务状态管理、vTaskDelay和vTaskDelayUntil函数的使用，探讨了任务优先级、空闲任务与用户任务的关系，以及不同任务调度算法（如时间片轮转）的应用。
摘要由CSDN通过智能技术生成

一.任务状态理论讲解

正在执行的任务状态是running，其他执行的等待执行的任务状态是ready 

1.修改间隔时间

2.任务状态 

  

处于各个状态的任务是怎样被管理起来的：链表 

3.代码

TaskHandle_t xHandleTask1;
TaskHandle_t xHandleTask3;

static int task1flagrun = 0;
static int task2flagrun = 0;
static int task3flagrun = 0;

void Task1Function(void * param)
{
	TickType_t tStart = xTaskGetTickCount();
	TickType_t t;
	int flag = 0;
	
	while (1)
	{
		t = xTaskGetTickCount();
		
		task1flagrun = 1;
		task2flagrun = 0;
		task3flagrun = 0;
		printf("1");

		if (!flag && (t > tStart + 10))
		{
			vTaskSuspend(xHandleTask3);
			flag = 1;
		}

		if (t > tStart + 20)
		{
			vTaskResume(xHandleTask3);
		}
	}
}

void Task2Function(void * param)
{
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 1;
		task3flagrun = 0;
		printf("2");

		vTaskDelay(10);
	}
}

void Task3Function(void * param)
{
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 0; 
		task3flagrun = 1;
		printf("3");
	}
}


/*-----------------------------------------------------------*/

StackType_t xTask3Stack[100];
StaticTask_t xTask3TCB;

StackType_t xIdleTaskStack[100];
StaticTask_t xIdleTaskTCB;


/*
 * The buffers used here have been successfully allocated before (global variables)
 */
void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
                                    StackType_t ** ppxIdleTaskStackBuffer,
                                    uint32_t * pulIdleTaskStackSize )
{
    *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
    *ppxIdleTaskStackBuffer = xIdleTaskStack;
    *pulIdleTaskStackSize = 100;
}


int main( void )
{
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");

	xTaskCreate(Task1Function, "Task1", 100, NULL, 1, &xHandleTask1);
	xTaskCreate(Task2Function, "Task2", 100, NULL, 1, NULL);
	xHandleTask3 = xTaskCreateStatic(Task3Function, "Task3", 100, NULL, 1, xTask3Stack, &xTask3TCB);

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

 

 二.vTaskDelay和vTaskDelayUntil

vTaskDelay：至少等待指定个数的Tick Interrupt才能变为就绪状态

xTaskDelayUntil

  • 返回pdTRUE表示确实延迟了，返回pdFALSE表示没有发生延迟(因为延迟的时间点早就过了)

  • 等待到指定的绝对时刻，才能变为就绪态。

代码1 vTaskDelay

TaskHandle_t xHandleTask1;
TaskHandle_t xHandleTask3;

static int task1flagrun = 0;
static int task2flagrun = 0;
static int task3flagrun = 0;

static int rands[]={3,56,23,5,59};

void Task1Function(void * param)
{
	TickType_t tStart = xTaskGetTickCount();
	int i=0;
	int j=0;
	
	while (1)
	{		
		task1flagrun = 1;
		task2flagrun = 0;
		task3flagrun = 0;

		for( i= 0; i < rands[j] ; i++)
			printf("1");
		
		j++;
		if ( j == 5)j = 0;
		
		vTaskDelay(20);
	}
}

void Task2Function(void * param)
{
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 1;
		task3flagrun = 0;
		printf("2");
	}
}

void Task3Function(void * param)
{
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 0; 
		task3flagrun = 1;
		printf("3");
	}
}


/*-----------------------------------------------------------*/

StackType_t xTask3Stack[100];
StaticTask_t xTask3TCB;

StackType_t xIdleTaskStack[100];
StaticTask_t xIdleTaskTCB;


/*
 * The buffers used here have been successfully allocated before (global variables)
 */
void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
                                    StackType_t ** ppxIdleTaskStackBuffer,
                                    uint32_t * pulIdleTaskStackSize )
{
    *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
    *ppxIdleTaskStackBuffer = xIdleTaskStack;
    *pulIdleTaskStackSize = 100;
}


int main( void )
{
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");

	xTaskCreate(Task1Function, "Task1", 100, NULL, 2, &xHandleTask1);
	xTaskCreate(Task2Function, "Task2", 100, NULL, 1, NULL);
	xHandleTask3 = xTaskCreateStatic(Task3Function, "Task3", 100, NULL, 1, xTask3Stack, &xTask3TCB);

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

 可以看到任务1执行的时间不一样，但是进入delay休眠的时间是一样的，都是20ms。

 

代码2 vTaskDelayUntil

BaseType_t xTaskDelayUntil( TickType_t * const pxPreviousWakeTime,
                            const TickType_t xTimeIncrement ) ;
// 1  延迟直到 *pxPre+xTime
// 2  *pxPre=*pxPre+xTime
TaskHandle_t xHandleTask1;
TaskHandle_t xHandleTask3;

static int task1flagrun = 0;
static int task2flagrun = 0;
static int task3flagrun = 0;

static int rands[]={3,56,23,5,59};

void Task1Function(void * param)
{
	TickType_t tStart = xTaskGetTickCount();
	int i=0;
	int j=0;
	
	while (1)
	{		
		task1flagrun = 1;
		task2flagrun = 0;
		task3flagrun = 0;

		for( i= 0; i < rands[j] ; i++)
			printf("1");
		
		j++;
		if ( j == 5)j = 0;
#if 0
		vTaskDelay(20);
#else
		xTaskDelayUntil(&tStart,20);
#endif
	}
}

void Task2Function(void * param)
{
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 1;
		task3flagrun = 0;
		printf("2");
	}
}

void Task3Function(void * param)
{
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 0; 
		task3flagrun = 1;
		printf("3");
	}
}


/*-----------------------------------------------------------*/

StackType_t xTask3Stack[100];
StaticTask_t xTask3TCB;

StackType_t xIdleTaskStack[100];
StaticTask_t xIdleTaskTCB;


/*
 * The buffers used here have been successfully allocated before (global variables)
 */
void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
                                    StackType_t ** ppxIdleTaskStackBuffer,
                                    uint32_t * pulIdleTaskStackSize )
{
    *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;
    *ppxIdleTaskStackBuffer = xIdleTaskStack;
    *pulIdleTaskStackSize = 100;
}


int main( void )
{
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");

	xTaskCreate(Task1Function, "Task1", 100, NULL, 2, &xHandleTask1);
	xTaskCreate(Task2Function, "Task2", 100, NULL, 1, NULL);
	xHandleTask3 = xTaskCreateStatic(Task3Function, "Task3", 100, NULL, 1, xTask3Stack, &xTask3TCB);

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

以每20ms周期性的执行 

三.空闲任务及钩子函数 

实验1

执行任务1，任务1的任务是创建任务2，当任务2创建成功，任务2的优先级更高，直接执行任务2。任务2的任务是打印一个2，然后进入阻塞，任务1运行删除任务。

extern void Task2Function(void * param);

void Task1Function(void * param)
{
	TaskHandle_t xHandleTask2;
	BaseType_t xReturn;
	while (1)
	{
		printf("1");
		xReturn=xTaskCreate(Task2Function, "Task2", 1024, NULL, 2, &xHandleTask2);
		if(xReturn!=pdPASS)
		{
			printf("xTaskCreate err\r\n");
		}
		vTaskDelete(xHandleTask2);
	}
}

void Task2Function(void * param)
{
	while (1)
	{
		printf("2");
		vTaskDelay(2);
	}
}


/*-----------------------------------------------------------*/

int main( void )
{
	TaskHandle_t xHandleTask1;
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");

	xTaskCreate(Task1Function, "Task1", 100, NULL, 1, &xHandleTask1);

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

并没有执行我们想要的清理工作。

我们进行的清理工作(内存回收工作)是放在空闲任务里面的。

实验2 

执行自杀操作

extern void Task2Function(void * param);

void Task1Function(void * param)
{
	TaskHandle_t xHandleTask2;
	BaseType_t xReturn;
	while (1)
	{
		printf("1");
		xReturn=xTaskCreate(Task2Function, "Task2", 1024, NULL, 2, &xHandleTask2);
		if(xReturn!=pdPASS)
		{
			printf("xTaskCreate err\r\n");
		}
		//vTaskDelete(xHandleTask2);
	}
}

void Task2Function(void * param)
{
	while (1)
	{
		printf("2");
		vTaskDelay(2);
		vTaskDelete(NULL);//执行自杀操作
	}
}


/*-----------------------------------------------------------*/

int main( void )
{
	TaskHandle_t xHandleTask1;
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");

	xTaskCreate(Task1Function, "Task1", 100, NULL, 1, &xHandleTask1);

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

执行自杀操作应该由空闲任务帮你执行清理工作

配置钩子函数

在main函数里面创建任务1，优先级是0，任务1里面创建任务2，任务2优先级更高执行完之后就自杀。之后任务1和任务0可以交替执行

 

四.任务调度算法

static int task1flagrun = 0;
static int task2flagrun = 0;
static int task3flagrun = 0;
static int taskidleflagrun = 0;

void Task1Function(void * param)
{
	//volatile char buf[500];
	//int i;
	
	while (1)
	{
		task1flagrun = 1;
		task2flagrun = 0;
		task3flagrun = 0;
		taskidleflagrun = 0;
		printf("1");
	}
}

void Task2Function(void * param)
{
	int i = 0;
	
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 1;
		task3flagrun = 0;
		taskidleflagrun = 0;
		printf("2");
	}
}

void Task3Function(void * param)
{
	const TickType_t xDelay5ms=pdMS_TO_TICKS(5UL);
	while (1)
	{
		task1flagrun = 0;
		task2flagrun = 0; 
		task3flagrun = 1;
		taskidleflagrun=0;
		printf("3");

		//如果不休眠的化，其他任务无法得到执行
		vTaskDelay(xDelay5ms);
	}
}

void vApplicationIdleHook()
{
	task1flagrun = 0;
	task2flagrun = 0; 
	task3flagrun = 0;
	taskidleflagrun=1;
}


int main( void )
{
		
#ifdef DEBUG
  debug();
#endif

	prvSetupHardware();

	printf("Hello, world!\r\n");

	xTaskCreate(Task1Function, "Task1", 1000, NULL, 0, NULL);
	xTaskCreate(Task2Function, "Task2", 1000, NULL, 0, NULL);
	xTaskCreate(Task3Function, "Task3", 1000, NULL, 2, NULL);
	//优先级最高的任务3先执行

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

1.可以抢占

这个宏定义是否可以抢占

 任务3优先级最高，先执行执行完阻塞5ms，其他任务执行。执行任务1，任务2，任务1，任务2，任务0，任务1。5ms到了立刻执行任务3...

A.时间片轮转

  任务3优先级最高，先执行执行完阻塞5ms，其他任务执行。执行任务1，任务2，任务1，任务2，任务0，任务1。5ms到了立刻执行任务3...

B.时间片不轮转

 任务3优先级最高先执行，执行完进入休眠，任务1执行直到任务3休眠结束，任务3执行结束，就接着让任务2执行....

 

2.不可以抢占

 

任务3执行完了进入阻塞，任务1一直执行。如果需要让出CPU资源还是需要自己去主动进入休眠。 

3.空闲任务是否让步于用户任务

 

 

爱花的程序员
关注
专栏目录
FreeRTOS任务管理_FreeRTOS任务管理_freertos_freertos任务_任务管理_野火freertos_
10-04
FreeRTOS 是一个实时操作系统（RTOS）内核，广泛应用于嵌入式系统中，尤其是那些对时间响应要求严格的设备。在FreeRTOS中，任务管理是其...通过学习和实践这些代码，开发者可以深入理解FreeRTOS任务管理的原理和应用。
stm32 freeRTOS 任务管理实验 （HAL版）
08-15
STM32 FreeRTOS任务管理实验（HAL版）是嵌入式系统开发中一个重要的实践环节，它涉及到微控制器（MCU）STM32、实时操作系统FreeRTOS以及STM32的HAL（Hardware Abstraction Layer，硬件抽象层）库的使用。FreeRTOS是...
FreeRTOS-任务管理
11-17
以下是一些关于FreeRTOS任务管理的关键知识点： 1. **任务创建**：开发者可以通过`xTaskCreate()`函数来创建一个新的任务。这个函数需要提供任务的入口函数、参数、堆栈大小、任务优先级等信息。 2. **优先级**：...
freeRTOS任务管理分析
02-19
### freeRTOS任务管理分析 #### 一、FreeRTOS概述 FreeRTOS（Free Real-Time Operating System）是一款免费开源的实时操作系统内核，适用于嵌入式系统。由于其轻量级、可移植性强等特点，在嵌入式领域得到了广泛的...
FreeRTOS任务通知
12-25
FreeRTOS是一种广泛使用的实时操作系统...通过这样的学习和实践，开发者可以更好地理解和掌握FreeRTOS任务通知的功能，提高其在实际开发中的效率，尤其在需要简单快速任务间通信的场合，任务通知是一个非常有效的工具。
C语言 | 第十章 | 函数 作用域
最新发布
ZJC744575的博客
10-05 920
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 442
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Spring Cloud全解析：服务调用之OpenFeign集成OkHttp
Lxn2zh的博客
09-30 840
HTTP连接需要进行TCP三次握手，是一个比较耗时的操作，一般我们不直接使用HttpURLConnection，而是使用HttpClient/okHttp等支持连接池的客户端工具，以Feign集成OkHttp为例。OpenFeign本质是HTTP来进行服务调用的，也就是需要集成一个Http客户端。默认是HttpURLConnection方式，也就是jdk中提供的最原始的那个。要开启OkHttp ,还需要在YML 中添加开启配置项，默认是关闭的。使用的是Client接口来进行请求的。
spring-boot 整合 mybatis
m0_72168501的博客
09-29 548
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 802
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 340
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
进程管理工具：非daemon进程管理工具supervisor
happy_king_zi的博客
09-29 1113
supervisor是一个 Client/Server模式的系统，允许用户在类unix操作系统上监视和控制多个进程，或者可以说是多个程序。supervisor与launchd，daemontools，runit等程序有着相同的功能，与其中某些程序不同的是，它并不作为“id 为 1的进程”而替代init。相反，它用于控制应用程序，像启动其它程序一样，通俗理解就是，把Supervisor服务管理的进程程序，它们作为supervisor的子进程来运行，而supervisor是父进程。
【RocketMQ】RocketMQ应用难点
记录一名在读研究生的学习笔记、感悟、开发产物
09-30 885
本文探讨了RocketMQ中消息重复消费的问题及其解决方案，尤其是在CLUSTERING模式下的扩容影响。文章分析了重复消费的原因，如广播模式、负载均衡模式下的多consumerGroup消费、消费者组内的动态变化及网络延迟等，并提出了利用唯一标识进行去重的方法。此外，还讨论了如何选择合适的存储机制以高效处理大量消息标识，如HashMap、MySQL、Redis以及推荐的布隆过滤器等方案。对于防止消息堆积与确保消息不丢失，也给出了相应的策略和技术措施。
第十三届蓝桥杯真题Java 斐波那契与7(持续更新)
音符犹如代码的博客
09-29 329
这是一道结果填空的题, 你只需要算出结果后提交即可。本题的结果为一 个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。斐波那契数列的递推公式为: Fn=Fn−1+Fn−2Fn​=Fn−1​+Fn−2​, 其中 F1=F2=1F1​=F2​=1。请问, 斐波那契数列的第 1 至 202202011200 项（含）中, 有多少项的个位 是 7。
JAVA开源项目 旅游管理系统 计算机毕业设计
as230627的博客
10-03 1243
旅游管理系统基于Springboot框架、JAVA编程语言、MYSQL数据库开发完成，“操作简单，功能实用”这是本软件设计的核心理念，本系统力求创造最好的用户体验。
【hot100-java】【合并两个有序链表】
m0_73629042的博客
09-30 387
记忆中，两个指针合并即可。
Java中ResultSet接口的详细介绍
2301_77032029的博客
09-28 461
ResultSet接口是Java JDBC API中的一个核心接口，用于表示从数据库查询返回的结果集。它允许用户遍历查询结果，并从中提取数据。ResultSet接口代表从数据库查询返回的结果集，它提供了以下功能：遍历结果集：允许用户向前或向后移动指针，以便访问结果集中的每一行。
古典舞在线交流：SpringBoot平台实现与优化
2401_85341950的博客
10-04 569
在这段时期里，我查找了很多相关的资料，查阅了很多Java的相关文献，结合自己的经验，设计了这个古典舞在线交流平台，虽然每个学期学校都会针对动手练习进行相应的课程设计，但是在古典舞在线交流平台的具体设计中还是遇到了一些小问题，但在不断的学习、研究中都将问题一一解决，在一一克服的过程中，我也得到了成长，知识和经验也得到了丰富，这对我来说是一笔巨大的财富。这次设计也大大提高了我的动手的能力，让我在学习中充分体会到了探索的乐趣，享受成功的创作过程，在本次设计过程中汲取的东西，是一笔宝贵的财富，让我受益匪浅。
[C++][程序退出]详细讲解
SnowK博客
09-30 3207
[C++][程序退出]详细讲解
freertos任务管理
04-05
FreeRTOS是一个用于嵌入式系统的实时操作系统内核，它提供了一套简单而又强大的任务管理机制。 在FreeRTOS中，任务是一个独立的执行单元，每个任务都有自己的堆栈和上下文。任务可以通过创建、删除、暂停、恢复、挂...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值