FreeRTOS笔记（四）：任务创建/删除，挂起/解挂详解

最新推荐文章于 2024-09-03 17:09:21 发布
最新推荐文章于 2024-09-03 17:09:21 发布
阅读量1k 收藏 4
点赞数
分类专栏： freeRTOS 文章标签： 堆栈 操作系统 嵌入式 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43952192/article/details/106824308
版权

FreeRTOS笔记（四）：任务创建/删除，挂起/解挂详解

在第二篇笔记中介绍了任务创建的API，并且简单使用了相关API，本文将详细介绍任务创建的过程。

一、任务创建

任务创建步骤为：
1.创建任务；
2.初始化任务；
3.任务堆栈初始化；
4.任务添加到就绪列表。
下面将详细介绍这四个部分。

1.1任务创建函数分析

任务创建函数为xTaskCreate(),函数的具体实现如下：

BaseType_t xTaskCreate(	TaskFunction_t pxTaskCode,
							const char * const pcName,
							const uint16_t usStackDepth,
							void * const pvParameters,
							UBaseType_t uxPriority,
							TaskHandle_t * const pxCreatedTask ) 
{
	TCB_t *pxNewTCB;
	BaseType_t xReturn;

	
	
	StackType_t *pxStack;

	
	pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth )   \
											* sizeof( StackType_t ) ) );   //---------------(1)
	if( pxStack != NULL )
	{
		pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );			  //---------------(2)

		if( pxNewTCB != NULL )
		{
			
			pxNewTCB->pxStack = pxStack;								//---------------(3)
		}
		else
		{
	
			vPortFree( pxStack );										//---------------(4)
		}	
	}
	else
	{
		pxNewTCB = NULL;
	}

	if( pxNewTCB != NULL )
	{
		#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
		{
			
			pxNewTCB->ucStaticallyAllocated = \
			tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;   //---------------(5)
		}
		#endif /* configSUPPORT_STATIC_ALLOCATION */

		prvInitialiseNewTask( pxTaskCode, pcName, \
		( uint32_t ) usStackDepth, pvParameters, uxPriority,\
		pxCreatedTask, pxNewTCB, NULL );			 //---------------(6)
		
		prvAddNewTaskToReadyList( pxNewTCB );        //---------------(7)
		xReturn = pdPASS;
	}
	else
	{
		xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
	}

	return xReturn;
}

（1）申请任务堆栈内存；

（2）如果堆栈申请成功，则申请任务控制块内存；

（3）初始化任务控制块中的堆栈指针；

（4）任务控制块申请失败，就释放申请到的任务堆栈内存；

（5）标记任务控制块内存、任务堆栈内存由动态申请得到；

（6）初始化任务控制块，后面详述prvInitialiseNewTask()；

（7）新建的任务添加到就绪列表中，后面详述prvAddNewTaskToReadyList()。

1.2任务初始化函数

任务创建函数中，需要对任务进行初始化，函数详解如下：

static void prvInitialiseNewTask( 	TaskFunction_t pxTaskCode,
									const char * const pcName,
									const uint32_t ulStackDepth,
									void * const pvParameters,
									UBaseType_t uxPriority,
									TaskHandle_t * const pxCreatedTask,
									TCB_t *pxNewTCB,
									const MemoryRegion_t * const xRegions )
{
	StackType_t *pxTopOfStack;
	UBaseType_t x;

	
	#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 )\
			|| ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )
	{
		
		( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE,\
						( size_t ) ulStackDepth * sizeof( StackType_t ) );   //-------------------(1)
	}
	#endif 
	
	pxTopOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );	//-------------------(2)
	pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) &\
					( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );  

	for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
	{
		pxNewTCB->pcTaskName[ x ] = pcName[ x ];       //-------------------(3)

		if( pcName[ x ] == 0x00 )
		{
			break;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}

	pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0'; //-------------------(4)

	if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )   //-------------------(5)
	{
		uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}

	pxNewTCB->uxPriority = uxPriority;        //-------------------(6)
	#if ( configUSE_MUTEXES == 1 )			//-------------------(7)
	{
		pxNewTCB->uxBasePriority = uxPriority;   
		pxNewTCB->uxMutexesHeld = 0;
	}
	#endif /* configUSE_MUTEXES */

	vListInitialiseItem( &( pxNewTCB->xStateListItem ) ); 	//-------------------(8)
	vListInitialiseItem( &( pxNewTCB->xEventListItem ) );	//-------------------(9)

	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );//-------------------(10)


	listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), \
			( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority );  //-------------------(11)
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );    //-------------------(12)

	#if ( portCRITICAL_NESTING_IN_TCB == 1 )   //使能临界区
	{
		pxNewTCB->uxCriticalNesting = ( UBaseType_t ) 0U;
	}
	#endif /* portCRITICAL_NESTING_IN_TCB */

	#if ( configUSE_APPLICATION_TASK_TAG == 1 )  //使能任务标签
	{
		pxNewTCB->pxTaskTag = NULL;
	}
	#endif /* configUSE_APPLICATION_TASK_TAG */

	#if ( configGENERATE_RUN_TIME_STATS == 1 )   //使能实践统计
	{
		pxNewTCB->ulRunTimeCounter = 0UL;
	}
	#endif /* configGENERATE_RUN_TIME_STATS */


	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )
	{
		for( x = 0; x < ( UBaseType_t ) configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )
		{
			pxNewTCB->pvThreadLocalStoragePointers[ x ] = NULL;  //-------------------(13)
		}
	}
	#endif

	#if ( configUSE_TASK_NOTIFICATIONS == 1 )   //使能任务通知
	{
		pxNewTCB->ulNotifiedValue = 0;
		pxNewTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
	}
	#endif

	#if ( configUSE_NEWLIB_REENTRANT == 1 )   //使能NEWLIB
	{
		_REENT_INIT_PTR( ( &( pxNewTCB->xNewLib_reent ) ) );
	}
	#endif

	#if( INCLUDE_xTaskAbortDelay == 1 )  //使能xTaskAbortDelay
	{
		pxNewTCB->ucDelayAborted = pdFALSE;
	}
	#endif

	
	pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, \
							 pxTaskCode, pvParameters, xRunPrivileged );//-------------------(14)

	if( ( void * ) pxCreatedTask != NULL )
	{
		
		*pxCreatedTask = ( TaskHandle_t ) pxNewTCB;   //-------------------(15)
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

（1）初始化堆栈元素为0xa5U，用于检测堆栈溢出；

（2）获取栈顶，保存到栈顶指针pxTopOfStack；

（3）保存任务名字到 pxNewTCB->pcTaskName；

（4）保存任务优先级 pxNewTCB->uxPriority 范围0-31；

（5）判断优先级是否合法；

（6）初始化优先级；

（7）如果使用了互斥量，初始化相应字段，主要实现优先级继承；

（8）、（9）初始化状态和事件列表项；

（10）、（12）设置xEventListItem、xStateListItem属于当前任务控制块；

（11）设置xEventListItem中的xItemValue为 configMAX_PRIORITIES - uxPriority，实现高优先级任务列表前面，低优先级在后面；

（13）初始化线程本地存储指针；

（14）初始化任务堆栈pxPortInitialiseStack，后面详述；

（15）生成任务句柄，任务句柄就是任务控制块。

1.3任务堆栈初始化

在任务初始函数要对任务堆栈进行初始化。堆栈是用来在任务进行切换时保存现场的，一般在新创建好一个堆栈以后对其初始化，对寄存器赋初值。这些初值保存在任务堆栈中，保存顺序按照如下：

xPSR、R15(PC)、R14(LR)、R12、R3-R0、R11-R4

函数详解如下：

StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, \
									TaskFunction_t pxCode, void *pvParameters )
{
	
	pxTopOfStack--; 
	*pxTopOfStack = portINITIAL_XPSR;					 //--------------------(1)
		
	pxTopOfStack--;
	*pxTopOfStack = ( ( StackType_t ) pxCode ) &\
					portSTART_ADDRESS_MASK;				 //--------------------(2)
					
	pxTopOfStack--; 
	*pxTopOfStack = ( StackType_t ) prvTaskExitError;	 //--------------------(3)

	pxTopOfStack -= 5;	           						//--------------------(4)
	*pxTopOfStack = ( StackType_t ) pvParameters;		//--------------------(5)
	
	pxTopOfStack -= 8;	 								//--------------------(6)

	return pxTopOfStack;
}

（1）设置xPSR（程序状态寄存器），这个寄存器的bit24为1，表示处于Thumb状态；

（2）寄存器PC初始化为pxCode；

（3）寄存器LR初始化为prvTaskExitError；

（4）跳过4个寄存器R12,R3,R2,R1不初始化；

（5）寄存器R0初始化为pvParameters；

（6）跳过8个寄存器，R11,R10,R8,R7,R6,R5,R4。

初始化完后，堆栈情况如下图

在这里插入图片描述

1.4添加任务到就绪列表函数

在创建任务函数中，最后要把任务添加到就绪列表中，进行详解函数。

static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )
{
	taskENTER_CRITICAL();
	{
		uxCurrentNumberOfTasks++;    //---------------------(1)
		if( pxCurrentTCB == NULL )   //没有任务执行
		{
	
			pxCurrentTCB = pxNewTCB;  //新任务控制块赋值给当前任务控制块

			if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 ) //新任务是第一个任务
			{
		
				prvInitialiseTaskLists();  //---------------------(2)
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else   //当前有任务执行
		{
			
			if( xSchedulerRunning == pdFALSE )  //任务调度器没开启
			{
				if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )//新任务优先级高
				{
					pxCurrentTCB = pxNewTCB;    //---------------------(3)
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}

		uxTaskNumber++;  //任务控制块编号

		#if ( configUSE_TRACE_FACILITY == 1 )
		{
			pxNewTCB->uxTCBNumber = uxTaskNumber;
		}
		#endif /* configUSE_TRACE_FACILITY */
	
		prvAddTaskToReadyList( pxNewTCB );   //---------------------(4)

	}
	taskEXIT_CRITICAL();

	if( xSchedulerRunning != pdFALSE )
	{
		
		if( pxCurrentTCB->uxPriority < pxNewTCB->uxPriority ) //新任务优先级高
		{
			taskYIELD_IF_USING_PREEMPTION();    //---------------------(5)
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

二、任务删除

在笔记的第二篇中简单使用了任务删除，本节将详细介绍删除函数工作原理。

void vTaskDelete( TaskHandle_t xTaskToDelete )
{
	TCB_t *pxTCB;

	taskENTER_CRITICAL();
	{
		
		pxTCB = prvGetTCBFromHandle( xTaskToDelete ); //----------------------(1)

		if( uxListRemove( &( pxTCB->xStateListItem ) ) \
								== ( UBaseType_t ) 0 ) //----------------------(2)
		{
			taskRESET_READY_PRIORITY( pxTCB->uxPriority );
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		
		if( listLIST_ITEM_CONTAINER( &  \
					( pxTCB->xEventListItem ) ) != NULL )//----------------------(3)
		{
			( void ) uxListRemove( &( pxTCB->xEventListItem ) );
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		uxTaskNumber++;

		if( pxTCB == pxCurrentTCB )             //----------------------(4)
		{
			vListInsertEnd( &xTasksWaitingTermination, \ 
			              &( pxTCB->xStateListItem ) );  //----------------------(5)

			
			++uxDeletedTasksWaitingCleanUp;		//----------------------(6)

			portPRE_TASK_DELETE_HOOK( pxTCB, &xYieldPending );  //----------------------(7)
		}
		else
		{
			--uxCurrentNumberOfTasks;		//----------------------(8)
			prvDeleteTCB( pxTCB );			//----------------------(9)
			prvResetNextTaskUnblockTime();	//----------------------(10)
		}

		traceTASK_DELETE( pxTCB );
	}
	taskEXIT_CRITICAL();

	
	if( xSchedulerRunning != pdFALSE )  //删除的是正在运行的任务就进行任务切换
	{
		if( pxTCB == pxCurrentTCB )
		{
			configASSERT( uxSchedulerSuspended == 0 );
			portYIELD_WITHIN_API();      //----------------------(11)
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
}

（1）获取删除的任务控制块，如果删除自己，则返回NULL；

（2）将任务从就绪列表删除；

（3）查看任务是否在等待某个事件，如果是，就从相应的等待列表中删除；

（4）、（5）要删除的是正在运行的任务，由于要等到任务执行完才能释放资源，
所以先添加到xTasksWaitingTermination列表中，由空闲任务来释放资源；

（6）记录要释放任务的个数；

（7）调用任务删除钩子函数；

（8）、（9）删除的不是正在运行的任务，任务数量减一，删除任务控制块；

（10）调整下一个任务要解锁的时间；

（11） 删除的是正在运行的任务就进行任务切换。

三、任务挂起

挂起任务的源码如下：

void vTaskSuspend( TaskHandle_t xTaskToSuspend )
{
	TCB_t *pxTCB;

	taskENTER_CRITICAL();
	{
		pxTCB = prvGetTCBFromHandle( xTaskToSuspend );   //---------------------(1)

		traceTASK_SUSPEND( pxTCB );

		if( uxListRemove( &( pxTCB->xStateListItem ) ) \
								== ( UBaseType_t ) 0 )  //---------------------(2)
		{
			taskRESET_READY_PRIORITY( pxTCB->uxPriority );
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		
		if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) \
									!= NULL )     //---------------------(3)
		{
			( void ) uxListRemove( &( pxTCB->xEventListItem ) );
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		vListInsertEnd( &xSuspendedTaskList, \
				&( pxTCB->xStateListItem ) );    //---------------------(4)
	}
	taskEXIT_CRITICAL();

	if( xSchedulerRunning != pdFALSE )
	{
		taskENTER_CRITICAL();
		{
			prvResetNextTaskUnblockTime();    //---------------------(5)
		}
		taskEXIT_CRITICAL();
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}

	if( pxTCB == pxCurrentTCB )
	{
		if( xSchedulerRunning != pdFALSE )
		{
			
			configASSERT( uxSchedulerSuspended == 0 );
			portYIELD_WITHIN_API();        //---------------------(6)
		}
		else
		{
			
			if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) \
					== uxCurrentNumberOfTasks )   //---------------------(7)
			{
				
				pxCurrentTCB = NULL;     //---------------------(8)
			}
			else
			{
				vTaskSwitchContext();   //---------------------(9)
			}
		}
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

（1）获取挂起的任务控制块，如果删除自己，则返回NULL；

（2）将任务从就绪列表删除；

（3）查看任务是否在等待某个事件，如果是，就从相应的等待列表中删除；

（4）将任务添加到挂起列表尾部；

（5）调整下一个任务要解锁的时间；

（6）挂起的是正在运行的任务，且调度器开启，就进行任务切换；

（7）挂起的是正在运行的任务，由于调度器没开启，不能进行任务切换，listCURRENT_LIST_LENGTH()函数检查是否所有任务都挂起。

（8）所有任务挂起，pxCurrentTCB == NULL；

（9）有任务没有被挂起 ，获取下一个任务。

四、任务解挂

任务恢复函数有普通版和中断版，本节将介绍普通版，具体内容如下：

void vTaskResume( TaskHandle_t xTaskToResume )
{
	TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;  //-------------------(1)

	configASSERT( xTaskToResume );

	if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB ) ) //-------------------(2)
	{
		taskENTER_CRITICAL();               //-------------------(3)
		{
			if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE ) //-------------------(4)
			{
				traceTASK_RESUME( pxTCB );

				( void ) uxListRemove(  &( pxTCB->xStateListItem ) ); //-------------------(5)
				prvAddTaskToReadyList( pxTCB );			//-------------------(6)

				if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority ) //-------------------(7)
				{
					taskYIELD_IF_USING_PREEMPTION();    //-------------------(8)
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		taskEXIT_CRITICAL();              //-------------------(9)
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

（1）获取解挂的任务控制块；

（2）任务控制块不能为空，也不能是正在运行的任务；

（3）进入临界区；

（4）判断要恢复的任务是否已经挂起；

（5）将要恢复的任务从挂起列表移除；

（6）恢复的任务添加到就绪列表；

（7）、（8）恢复任务的优先级高于正在运行任务的优先级，进行任务切换；

（9）退出临界区。

CodeDog_wang
关注
专栏目录
详解FreeRTOS：FreeRTOS程序启动流程（基础篇—5）
不脱发的程序猿
07-31 6520
讲一讲FreeRTOS程序启动流程。
FreeRTOS笔记：堆内存管理
Libi_t的博客
04-01 2803
堆内存管理freeRTOS的内核对象全都采用运行时的动态内存分配。但不同设备内存的容量大小、地址映射、访问速度以及应用对实时性的要求都是不同的，因此freeRTOS 把堆内存管理放在可移植层，且提供了5套不同的管理管理，位于MemMang/heap_n.c 其中n为1-5。用户也可按照接口自己实现堆内存管理。接口堆内存管理接口是一组函数声明，位于portable.hvoid *pvPortMallo
FreeRTOS任务挂起和恢复实验
06-12
“FreeRTOS学习笔记——FreeRTOS任务挂起和恢复实验”博客所用代码
FreeRTOS任务的挂起和恢复
qq_45973003的博客
04-15 994
4：如果挂起的是任务自身 【调度器正在运行，强制进行一次任务切换】，调度器没有运行【是：代表任务均被挂起，则当前的控制块赋值为NULL】【否：通过函数vTaskSwitchContext寻找下一个最高优先级任务】3：判断任务调度器是否在运行，如果在运行，更新下一次阻塞时间，防止被挂起任务为下一次阻塞超时。1：根据任务句柄来挂起任务控制块，如果热虐句柄为NULL表示要挂起任务自身。2：将要挂起的任务从相应的状态列表中移除。
3-FreeRTOS原理剖析：任务挂起和恢复
最新发布
sycc512的博客
09-03 645
在禁止调度任务期间，若ISR导致了一个任务的就绪，这个任务就会放到xPendingReadyList列表中，一旦调度允许运行，则会把所有xPendingReadyList中的任务移动到一个合适的就绪列表中。该函数的参数为任务的句柄，如果任务处于挂起列表中、和不在挂起等待列表中和任务不等待任何事件，则返回pdTRUE，其它情况返回pdFALSE。此函数是vTaskResume()的中断版本，用于在中断服务函数中恢复一个任务，该函数的主要功能是从中断处理函数中，恢复挂起的某个任务。.h中默认定义为1。
【FreeRTOS】FreeRTOS 任务挂起与恢复（包括在中断中恢复）
FuckerGod的博客
06-28 2121
动态创建任务需要使用到函数，我们可以在 FreeRTOS 官网中查看此函数详细的文档，点击此处跳转根据上方的描述我们可以得知，必须将定义为 1 才能使用此函数。暂停任意任务，无论任务优先级如何，任务被暂停后将无法获取任何微控制器处理时间。对的调用不会累积次数，例如：若在同一任务上调用两次，将仍然仅需调用一次，即可恢复暂停的任务。
FreeRTOS之任务挂起和恢复函数
linuxweiyh的博客
10-10 3503
1.任务挂起和恢复相关的函数如下 vTaskSuspend()：挂起一个任务 vTaskResume()：恢复一个任务的运行 vTaskResumeFromISR()：中断服务函数中恢复一个任务的运行2.函数的详细描述 (1)函数vTaskSuspend() 该函数用于将某个任务设置为挂起态。 进入挂起态的任务永远都不会进入运行态，退出挂起态的唯一方法就是调用任务恢复函数vTaskRes
FreeRTOS任务的挂起和恢复 | FreeRTOS四
qq_57663276的博客
02-01 2634
FreeRTOS任务的挂起和恢复
FreeRTos学习笔记
03-17
### FreeRTOS 学习笔记：深入理解多任务调度与信号量使用 #### 一、FreeRTOS 多任务调度原理 FreeRTOS（Free Real Time Operating System）是一款免费且开源的实时操作系统，广泛应用于嵌入式系统中。其核心功能之...
【FreeRTOS】——中断优先级设置&中断相关寄存器&临界段代码保护&调度器挂起与恢复
weixin_51658186的博客
05-28 3591
博客笔记根据正点原子视频教程编辑，仅供学习交流使用！实时操作系统是嵌入式学习的进阶内容，掌握好在面试时会有巨大优势！电机应用控制——直流无刷电机OpenCV机器视觉系列专栏C语言进阶。
ESP8266定时器接口详解：RTOS SDK中的esp_timer使用与限制
这通过管理挂起事件列表和利用RTOS通知机制（如队列、信号量、事件组等）来实现，确保回调的可靠调度。 3. **API使用**： - `esp_timer_init` 和 `esp_timer_deinit`：初始化和销毁esp_timer结构。 - `esp_timer_...
FreeRTOS实时操作系统（三）任务挂起与恢复
贾saisai的博客
06-18 2013
继续跟着正点原子学习FreeRTOS之任务挂起与恢复。
FreeRTOS操作系统——任务挂起与恢复（二）
戚晨夕的博客
01-16 2330
FreeRTOS操作系统学习 文章目录FreeRTOS操作系统学习前言一、任务挂起与恢复二、任务挂起与恢复1.代码实战总结 前言 功能：有时候我们需要暂停某个任务的运行，过一段时间以后在重新运行。这个时候要是使用任 务删除和重建的方法的话那么任务中变量保存的值肯定丢失了！FreeRTOS 给我们提供了解决 这种问题的方法，那就是任务挂起和恢复，当某个任务要停止运行一段时间的话就将这个任务 挂起，当要重新运行这个任务的话就恢复这个任务的运行。 一、任务挂起与恢复 API函数： vTaskSuspend()
FreeRTOS学习笔记—任务挂起和恢复
qq_45217381的博客
07-04 2717
本文学习了FreeRTOS任务挂起和解挂的内容。编程实现了任务挂起和解挂。对于编程实现中的问题进行了分析总结。
freertos基础（任务挂起和任务删除）
weixin_70377335的博客
07-29 1860
任务恢复就是让挂起的任务重新进入就绪状态，恢复的任务会保留挂起前的状态信息，在恢复的时候根据挂起时的状态继续运行。无论通过调用一次或多次vTaskSuspend()函数而被挂起的任务，也只需调用一次恢复即可解挂。vTaskDelete()用于删除任务。当一个任务可以删除另外一个任务，形参为要删除任 务创建时返回的任务句柄，如果是删除自身， 则形参为 NULL。按键函数Key_Test()，完成按键WK_UP挂起led任务，KEY2删除按键任务，KEY1恢复LED任务，KEY0删除LED任务.
FreeRTOS个人笔记-挂起/解挂任务
weixin_47077788的博客
07-23 2869
根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。配套资料FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
FreeRTOS任务挂起和恢复
qq_23852045的博客
09-26 490
挂起和恢复函数： /* 功能：挂起一个任务; 参数：xTaskToSuspend xTaskToSuspend = xTaskCreate(); xTaskToSuspend = xTaskCreateStatic(); xTaskToSuspend = xTaskGetHandle(); 或通过xTaskCreate & xTaskCreateStatic两个函数的最后一个形参 这四种方式获得要挂起任务的句柄。 若xTaskToSuspend = NULL 挂起任务本身 */ vo
freeRTOS任务挂起和恢复
嵌入式之斋
04-01 550
在任务挂起期间，该任务所占用的CPU处理时间将被释放，以便其他任务能够获得更多的CPU时间。因此，在实际应用中，可以通过挂起一些低优先级的任务来让高优先级的任务优先执行，以提高系统的响应速度。类似地，FreeRTOS也提供了vTaskResume()函数来恢复一个被挂起的任务，该函数也接受一个参数，即要恢复的任务的句柄。FreeRTOS提供了vTaskSuspend()函数来挂起一个任务，该函数接受一个参数，即要挂起的任务的句柄。任务挂起指暂停一个任务的执行，任务恢复则是使一个被挂起的任务继续执行。
FreeRTOS 任务的挂起与恢复
上山的月的博客
07-22 1321
在FreeRTOS中，任务的挂起与恢复是控制任务执行状态的重要手段，通过这两个操作可以实现任务的灵活调度和管理。本篇内容关于任务挂起与恢复解释、使用、说明了其他博客未曾注意到的抢占优先级和中断优先级的详细说明
FreeRTOS API详解：任务创建与管理
- `xTaskHandle *pvCreatedTask`: 任务创建后返回的任务句柄，用于后续任务控制操作，如删除任务。 2. **任务控制** (TaskControl) - `vTaskDelete` 是删除任务的函数，它需要使用之前 `xTaskCreate` 返回的任务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值