05.FreeRTOS任务挂起与恢复

已于 2024-08-16 15:37:06 修改
阅读量683 收藏 10
点赞数 8
分类专栏： 嵌入式 # 嵌入式操作系统 文章标签： stm32 freeRTOS 嵌入式软件开发
于 2024-07-31 15:27:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lshuangye/article/details/140823335
版权

01.初识freeRTOS
02.FreeRTOS的移植
03.FreeRTOS系统配置
04.FreeRTOS任务创建与删除
05.FreeRTOS任务挂起与恢复
06.FreeRTOS中断管理
07.FreeRTOS列表与列表项
08.FreeRTOS任务调度与任务切换
09.FreeRTOS时间片调度与任务相关函数
10.FreeRTOS队列操作
11.FreeRTOS信号量操作
12.FreeRTOS队列集和事件标志组
13.FreeRTOS任务通知
14.FreeRTOS软件定时器
15.FreeRTOS低功耗
16.FreeRTOS内存管理

文章目录

05. FreeRTOS任务挂起与任务恢复

1. FreeRTOS 挂起和恢复任务相关 API 函数

函数描述
vTaskSuspend()挂起任务
vTaskResume()恢复被挂起的任务
xTaskResumeFromISR()在中断中恢复被挂起的任务

  1. 函数vTaskSuspend()

    此函数用于挂起任务，若使用此函数，需要在FreeRTOSConfig.h文件中将宏 NCLUDE_vTaskSuspend配置为1。无论优先级如何，被挂起的任务都将不再被执行，直到任务被恢复。此函数并不支持嵌套，不论使用此函数重复挂起任务多少次，只需调用一次恢复任务的函数，那么任务就不再被挂起。函数原型如下所示：

    在这里插入图片描述

  2. 函数vTaskResume()

    此函数用于在任务中恢复被挂起的任务，若使用此函数，需要在FreeRTOSConfig.h文件中将宏INCLUDE_VTaskSuspend配置为1。不论一个任务被函数vTaskSuspend()挂起多少次，只需要使用函数vTaskResume()恢复一次，就可以继续运行。函数原型如下所示：

    在这里插入图片描述

  3. 函数xTaskResumeFromISR()

    此函数用于在中断中恢复被挂起的任务，若使用此函数，需要在FreeRTOSConfig.h文件中将宏INCLUDE_xTaskResumeFromISR配置为1。不论一个任务被函数vTaskSuspend()挂起多少次，只需要使用函数vTaskResumeFromISR()恢复一次，就可以继续运行。函数原型如下所示：

    在这里插入图片描述

2. vTaskSuspend源码分析

在这里插入图片描述

  1. 需将宏INCLUDE_vTaskSuspend 配置为 1

    // 使能挂起任务 
#define INCLUDE_vTaskSuspend                            1

  2. 根据任务句柄获取任务控制块，如果任务句柄为NULL，表示挂起任务自身

    pxTCB = prvGetTCBFromHandle( xTaskToSuspend );

  3. 将要挂起的任务从状态列表中移除

    //3.将要挂起的任务从状态列表中移除
if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
{
	taskRESET_READY_PRIORITY( pxTCB->uxPriority );
}
else
{
	mtCOVERAGE_TEST_MARKER();
}

//3.将要挂起的任务从事件列表中移除
if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
{
	( void ) uxListRemove( &( pxTCB->xEventListItem ) );
}
else
{
	mtCOVERAGE_TEST_MARKER();
}

  4. 将待挂起任务的任务状态列表插入挂起任务列表末尾

    vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );

#if ( configUSE_TASK_NOTIFICATIONS == 1 )
{
     BaseType_t x;

     for( x = 0; x < configTASK_NOTIFICATION_ARRAY_ENTRIES; x++ )
     {
			//如果待挂起任务在等待，停止等待，直接赋值为0
            if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION )
             {  
                  pxTCB->ucNotifyState[ x ] = taskNOT_WAITING_NOTIFICATION;
             }
     }
}
#endif

  5. 判断任务调度器是否在运行

    //如果在运行，则更新下一次阻塞时间，防止被挂起任务为下一次阻塞超时任务
if(xSchedulerRunning != pdFALSE)
{
     taskENTER_CRITICAL();
     {
          prvResetNextTaskUnblockTime();
     }
     taskEXIT_CRITICAL();
}
else
{
     mtCOVERAGE_TEST_MARKER();
}

  6. 如果挂起的是当前任务，且调度器正在运行，需要进行一次任务切换，否则判断挂起任务数

    if( pxTCB == pxCurrentTCB )
{
	//且调度器正在运行，需要进行一次任务切换
	if( xSchedulerRunning != pdFALSE )
	{
		configASSERT( uxSchedulerSuspended == 0 );
		portYIELD_WITHIN_API();
	}
	//若没有运行，判断挂起任务数是否等于任务总数
	//若相等，当前控制块赋值为NULL
	//若不相等，寻找下一个最高优先级任务
	else
	{
		if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) 
		{
			pxCurrentTCB = NULL;
		}
		else
		{
			vTaskSwitchContext();
		}
	}
}
else
{
	mtCOVERAGE_TEST_MARKER();
}

具体实现：

#if ( INCLUDE_vTaskSuspend == 1 )

    void vTaskSuspend( TaskHandle_t xTaskToSuspend )
    {
        TCB_t * pxTCB;

        taskENTER_CRITICAL();
        {
            /* If null is passed in here then it is the running task that is
             * being suspended. */
			//2.根据任务句柄获取任务控制块，如果任务句柄为NULL，表示挂起任务自身
            pxTCB = prvGetTCBFromHandle( xTaskToSuspend );

            traceTASK_SUSPEND( pxTCB );

            /* Remove task from the ready/delayed list and place in the
             * suspended list. */
			//3.将要挂起的任务从状态列表中移除
            if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )
            {
                taskRESET_READY_PRIORITY( pxTCB->uxPriority );
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }

            /* Is the task waiting on an event also? */
			//3.将要挂起的任务从事件列表中移除
            if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
            {
                ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
			
			//4.将待挂起任务的任务状态列表插入挂起任务列表末尾
            vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );

            #if ( configUSE_TASK_NOTIFICATIONS == 1 )
                {
                    BaseType_t x;

                    for( x = 0; x < configTASK_NOTIFICATION_ARRAY_ENTRIES; x++ )
                    {
						//如果待挂起任务在等待，停止等待，直接赋值为0
                        if( pxTCB->ucNotifyState[ x ] == taskWAITING_NOTIFICATION )
                        {
                            /* The task was blocked to wait for a notification, but is
                             * now suspended, so no notification was received. */
                            pxTCB->ucNotifyState[ x ] = taskNOT_WAITING_NOTIFICATION;
                        }
                    }
                }
            #endif /* if ( configUSE_TASK_NOTIFICATIONS == 1 ) */
        }
        taskEXIT_CRITICAL();
		
		//5.判断任务调度器是否在运行
		//如果在运行，则更新下一次阻塞时间，防止被挂起任务为下一次阻塞超时任务
        if( xSchedulerRunning != pdFALSE )
        {
            /* Reset the next expected unblock time in case it referred to the
             * task that is now in the Suspended state. */
            taskENTER_CRITICAL();
            {
                prvResetNextTaskUnblockTime();
            }
            taskEXIT_CRITICAL();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
		
		//6.如果挂起的是当前任务，
        if( pxTCB == pxCurrentTCB )
        {
			//且调度器正在运行，需要进行一次任务切换
            if( xSchedulerRunning != pdFALSE )
            {
                /* The current task has just been suspended. */
                configASSERT( uxSchedulerSuspended == 0 );
                portYIELD_WITHIN_API();
            }
			//若没有运行，判断挂起任务数是否等于任务总数
			//若相等，当前控制块赋值为NULL
			//若不相等，寻找下一个最高优先级任务
            else
            {
                /* The scheduler is not running, but the task that was pointed
                 * to by pxCurrentTCB has just been suspended and pxCurrentTCB
                 * must be adjusted to point to a different task. */
                if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) /*lint !e931 Right has no side effect, just volatile. */
                {
                    /* No other tasks are ready, so set pxCurrentTCB back to
                     * NULL so when the next task is created pxCurrentTCB will
                     * be set to point to it no matter what its relative priority
                     * is. */
                    pxCurrentTCB = NULL;
                }
                else
                {
                    vTaskSwitchContext();
                }
            }
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }

#endif

3. vTaskResume源码分析

在这里插入图片描述

  1. 需将宏INCLUDE_vTaskSuspend配置为1

    #if ( INCLUDE_vTaskSuspend == 1 )

  2. 恢复任务不能是正在运行的任务

    if( ( pxTCB != pxCurrentTCB ) && ( pxTCB != NULL ) )

  3. 判断任务是否被挂起

    //若被挂起，就会将该任务从挂起列表中移除，将该任务添加到就绪列表中
if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )

  4. 判断恢复任务优先级是否大于当前正在运行的任务优先级

    //若是，要进行任务切换
if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
{
     taskYIELD_IF_USING_PREEMPTION();
}

具体实现：

//1.需将宏INCLUDE_vTaskSuspend配置为1
#if ( INCLUDE_vTaskSuspend == 1 )

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

        /* It does not make sense to resume the calling task. */
        configASSERT( xTaskToResume );

        /* The parameter cannot be NULL as it is impossible to resume the
         * currently executing task. */
		//2.恢复任务不能是正在运行的任务
        if( ( pxTCB != pxCurrentTCB ) && ( pxTCB != NULL ) )
        {
            taskENTER_CRITICAL();
            {
				//3.判断任务是否被挂起
				//若被挂起，就会将该任务从挂起列表中移除，将该任务添加到就绪列表中
                if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )
                {
                    traceTASK_RESUME( pxTCB );

                    /* The ready list can be accessed even if the scheduler is
                     * suspended because this is inside a critical section. */
                    ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
                    prvAddTaskToReadyList( pxTCB );

                    /* A higher priority task may have just been resumed. */
					//4.判断恢复任务优先级是否大于当前正在运行的任务优先级
					//若是，要进行任务切换
                    if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
                    {
                        /* This yield may not cause the task just resumed to run,
                         * but will leave the lists in the correct state for the
                         * next yield. */
                        taskYIELD_IF_USING_PREEMPTION();
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            taskEXIT_CRITICAL();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }

#endif

4. xTaskResumeFromISR源码分析

在这里插入图片描述

  1. 用于检测调用freertos的API函数的中断优先级是否在管理范围内，以及是否全部设置为抢占式优先级位

    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

  2. 关闭freertos可管理中断，防止被其他的中断打断，并返回关闭前basepri寄存器的值

    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

  3. 判断是否有挂起任务

    if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )
{
	traceTASK_RESUME_FROM_ISR( pxTCB );

	/* Check the ready lists can be accessed. */
	//检测调度器是否被挂起
	//判断恢复的这个任务优先级是否大于正在执行的任务是的话将xYieldRequired标记
	//为pdTRUE，表示需要进行一次任务切换
	//将被恢复的任务从挂起列表中移除
	//插入到就绪列表
	if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
	{
		if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
		{
			xYieldRequired = pdTRUE;
			xYieldPending = pdTRUE;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		( void ) uxListRemove( &( pxTCB->xStateListItem ) );
		prvAddTaskToReadyList( pxTCB );
	}
	//如果调度器被挂起了，就将恢复的任务插入等待就绪列表，直到调度器被恢复再进行任务的处理
	else
	{
		vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
	}
}
else
{
	mtCOVERAGE_TEST_MARKER();
}

  4. 将前面保存的basepri的值，恢复回来

    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

  5. 返回xYieldRequired的值 用于决定是否需要进行任务切换

    return xYieldRequired;

具体实现：

#if ( ( INCLUDE_xTaskResumeFromISR == 1 ) && ( INCLUDE_vTaskSuspend == 1 ) )

    BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume )
    {
        BaseType_t xYieldRequired = pdFALSE;
        TCB_t * const pxTCB = xTaskToResume;
        UBaseType_t uxSavedInterruptStatus;

        configASSERT( xTaskToResume );

        /* RTOS ports that support interrupt nesting have the concept of a
         * maximum  system call (or maximum API call) interrupt priority.
         * Interrupts that are  above the maximum system call priority are keep
         * permanently enabled, even when the RTOS kernel is in a critical section,
         * but cannot make any calls to FreeRTOS API functions.  If configASSERT()
         * is defined in FreeRTOSConfig.h then
         * portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
         * failure if a FreeRTOS API function is called from an interrupt that has
         * been assigned a priority above the configured maximum system call
         * priority.  Only FreeRTOS functions that end in FromISR can be called
         * from interrupts  that have been assigned a priority at or (logically)
         * below the maximum system call interrupt priority.  FreeRTOS maintains a
         * separate interrupt safe API to ensure interrupt entry is as fast and as
         * simple as possible.  More information (albeit Cortex-M specific) is
         * provided on the following link:
         * https://www.FreeRTOS.org/RTOS-Cortex-M3-M4.html */
		//1.用于检测调用freertos的API函数的中断优先级是否在管理范围内，以及是否全部设置为抢占式优先级位
        portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

		//2.关闭freertos可管理中断，防止被其他的中断打断，并返回关闭前basepri寄存器的值
        uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
        {
			//3.判断是否有挂起任务
            if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )
            {
                traceTASK_RESUME_FROM_ISR( pxTCB );

                /* Check the ready lists can be accessed. */
				//检测调度器是否被挂起
				//判断恢复的这个任务优先级是否大于正在执行的任务是的话将xYieldRequired标记
				//为pdTRUE，表示需要进行一次任务切换
				//将被恢复的任务从挂起列表中移除
				//插入到就绪列表
                if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
                {
                    /* Ready lists can be accessed so move the task from the
                     * suspended list to the ready list directly. */
                    if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
                    {
                        xYieldRequired = pdTRUE;

                        /* Mark that a yield is pending in case the user is not
                         * using the return value to initiate a context switch
                         * from the ISR using portYIELD_FROM_ISR. */
                        xYieldPending = pdTRUE;
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }

                    ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
                    prvAddTaskToReadyList( pxTCB );
                }
				//如果调度器被挂起了，就将恢复的任务插入等待就绪列表，直到调度器被恢复再进行任务的处理
                else
                {
                    /* The delayed or ready lists cannot be accessed so the task
                     * is held in the pending ready list until the scheduler is
                     * unsuspended. */
                    vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
                }
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
		//4.将前面保存的basepri的值，恢复回来
        portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
		
		//5.返回xYieldRequired的值 用于决定是否需要进行任务切换
        return xYieldRequired;
    }

#endif

5. 实验验证

实验目的：
在这里插入图片描述

任务函数：

  • 开始任务：

    /*开始任务*/
void start_task(void* pvParamter)
{
	taskENTER_CRITICAL();   // 进入临界区 
	
	xTaskCreate((TaskFunction_t        )   task1,                 //指向任务函数的指针
				(char *                )   "task1",               //任务名称
				(configSTACK_DEPTH_TYPE)   TASK1_TASK_STACK_SIZE, //任务堆栈大小,字节为单位
				(void *                )   NULL,                  //传递给任务函数的参数
				(UBaseType_t           )   TASK1_TASK_PRIO,       //任务优先级
				(TaskHandle_t *        )   &task1_task_handler    //任务句柄：任务控制块
	);
				
	xTaskCreate((TaskFunction_t        )   task2,                 //指向任务函数的指针
				(char *                )   "task2",               //任务名称
				(configSTACK_DEPTH_TYPE)   TASK2_TASK_STACK_SIZE, //任务堆栈大小,字节为单位
				(void *                )   NULL,                  //传递给任务函数的参数
				(UBaseType_t           )   TASK2_TASK_PRIO,       //任务优先级
				(TaskHandle_t *        )   &task2_task_handler    //任务句柄：任务控制块
	);	

	xTaskCreate((TaskFunction_t        )   task3,                  //指向任务函数的指针
				(char *                )   "task3",                //任务名称
				(configSTACK_DEPTH_TYPE)   TASK3_TASK_STACK_SIZE,  //任务堆栈大小,字节为单位
				(void *                )   NULL,                   //传递给任务函数的参数
				(UBaseType_t           )   TASK3_TASK_PRIO,        //任务优先级
				(TaskHandle_t *        )   &task3_task_handler     //任务句柄：任务控制块
	);

	vTaskDelete(NULL);
				
	taskEXIT_CRITICAL();    // 退出临界区 
}

  • 任务一：实现LED0每500ms翻转一次

    void task1(void* pvParamter)
{
	uint32_t task1_num = 0;
	
	while(1)
	{
		printf("task1正在运行!!!\r\n");
		lcd_show_xnum(71, 80, ++task1_num, 3, 16, 0x80, GREEN);
		LED0_TOGGLE();
		vTaskDelay(500);
	}
}

  • 任务二：实现LED1每500ms翻转一次

    void task2(void* pvParamter)
{
	uint32_t task2_num = 0;
	
	while(1)
	{
		printf("task2正在运行!!!\r\n");
		lcd_show_xnum(191, 80, ++task2_num, 3, 16, 0x80, GREEN);
		LED1_TOGGLE();
		vTaskDelay(500);
	}
}

  • 任务三：挂起和恢复任务一

    void task3(void* pvParamter)
{
	uint8_t key = 0;
	while(1)
	{
		printf("task3正在运行!!!\r\n");
		key = key_scan(0);
		
		switch(key)
		{
			case KEY0_PRES:
				vTaskSuspend(task1_task_handler);	
				break;
			case KEY1_PRES:
				vTaskResume(task1_task_handler);
			    break;
			default:
				break;		
		}		
		vTaskDelay(10);
	}
}

  • 初始任务的创建与开启任务调度

    	xTaskCreate((TaskFunction_t        )   start_task,           //指向任务函数的指针
				(char *                )   "start_task",         //任务名称
				(configSTACK_DEPTH_TYPE)   START_TASK_STACK_SIZE,//任务堆栈大小,字节为单位
				(void *                )   NULL,                 //传递给任务函数的参数
				(UBaseType_t           )   START_TASK_PRIO,      //任务优先级
				(TaskHandle_t *        )   &start_task_handler    //任务句柄：任务控制块
	);
				
    vTaskStartScheduler();  //开启任务调度

实验结果：
LCD显示屏与LED灯同时工作，LCD显示运行的次数，当按下按键，运行次数暂停，LED灯不再闪烁。当按下KEY1恢复任务后，任务1继续运行，LED灯与LCD显示屏计数开始工作。

mseeding
关注
专栏目录
基于 FreeRTOS任务挂起和恢复程序设计_freertos_FreeRTOS任务挂起与恢复_
10-02
在提供的压缩包文件"基于 FreeRTOS任务挂起和恢复程序设计"中，可能包含了一个示例工程，演示了如何在STM32F407上实现这些操作。这个工程可能包括配置FreeRTOS的头文件、定义任务函数、初始化任务、设置调度器，以及...
FreeRTOS实时操作系统（三）任务挂起与恢复
贾saisai的博客
06-18 1966
继续跟着正点原子学习FreeRTOS之任务挂起与恢复。
FreeRTOS学习笔记—任务挂起和恢复
qq_45217381的博客
07-04 2684
本文学习了FreeRTOS任务挂起和解挂的内容。编程实现了任务挂起和解挂。对于编程实现中的问题进行了分析总结。
FreeRTOS-任务挂起和恢复
最新发布
m0_51319492的博客
09-11 426
任务挂起是指将某个任务从就绪态或运行态中移除，并将其置于挂起态，让它暂时不再参与调度，不分配CPU时间片，直到它被恢复挂起任务时，它会立即停止运行，直到该任务被显式恢复。挂起任务用于节省CPU资源或防止某些任务在特定条件下继续执行挂起任务可以恢复，而删除任务无法恢复任务恢复是指将挂起的任务从挂起态恢复到就绪态，使其可以再次参与调度，并根据其优先级来决定何时运行任务恢复通常是在外部条件发生变化、或另一个条件ISR(中断服务程序)通知当前任务可以继续工作时使用下面是任务挂起和恢复的API函数。
FreeRTOS任务的挂起和恢复 | FreeRTOS四
qq_57663276的博客
02-01 2623
FreeRTOS任务的挂起和恢复
【04】FreeRTOS的任务挂起与恢复
小浪宝宝的博客
01-18 1733
参数介绍：待挂起任务的任务句柄（想挂起哪个任务，就传入哪个任务的任务句柄此函数用于挂起任务，使用时需要将FreeRTOSCofig.h中的宏配置为1。无论优先级多高，被挂起的任务都将不再执行，直到任务被恢复。注意：当传入的参数为NULL，则代表挂起任务自身（当前正在运行的任务），和删除任务类似。任务中恢复挂起函数如下所示（在任务函数中被调用：待恢复任务的任务句柄。使用此函数需要将FreeRTOSConfig.h中的宏配置为1，和挂起任务需要配置的宏是同一个。注意：任务无论被。
FreeRTOS：任务挂起和恢复
立于皓月之边，不弱星光之势
05-06 1965
FreeRTOS：任务挂起和恢复
07_FreeRTOS任务调度器的挂起和恢复
Yuanghxb的博客
01-22 3182
PendSV的触发是在SysTick定时器中断里面触发的, xPortSysTickHandler()。3.挂起调度器的方式,适合于临界区位于任务与任务之间;既不用去延时中断,又可以做临界区的安全。饿任务之间的资源争夺,中断照样可以直接响应;vTaskSuspendAll()任务调度器挂起函数详解。1.与临界区不一样的是,挂起任务调度器,未关闭中断;xTaskResumeAll()任务调度器挂起函数详解。挂起任务调度器,调用此函数不需要关闭中断。
26FreeRTOS任务挂起和恢复.rar
11-24
在FreeRTOS中，任务挂起和恢复是两个关键操作，它们对于合理分配处理器资源、优化任务执行流程至关重要。 任务挂起（Task Suspend）是指在运行中的任务自愿或被其他任务或系统服务暂停其执行，将其从就绪状态移出，...
FreeRTOS实验FreeRTOS任务挂起和恢复实验.zip
06-19
本实验“FreeRTOS任务挂起和恢复实验”着重于理解FreeRTOS中的两个关键操作：任务挂起与恢复，这对于优化系统资源管理和控制流程至关重要。本文将详细讲解这两个概念以及它们在STM32微控制器中的应用。 首先，我们...
FreeRTOS挂起与恢复任务
05-15
FreeRTOS，全称为"Free Real-Time Operating System...了解和掌握FreeRTOS的任务挂起与恢复机制，对于开发高效的实时嵌入式系统至关重要，它能够帮助我们构建更灵活、响应更快的系统，实现复杂的并发控制和任务协调。
stm32f103 FreeRTOS任务挂起和恢复实验.zip
03-07
本实验主要涉及FreeRTOS中的任务挂起和恢复功能，这是FreeRTOS任务管理的核心机制。任务挂起是指暂停一个正在执行的任务，以便其他就绪任务可以获取CPU并执行。而任务恢复则是重新激活之前挂起的任务，使其重新进入...
FreeRTOS的任务挂起与恢复
qq_55181792的博客
02-05 968
调度器没有运行，判断挂起任务数是否等于任务总数，是：当前控制块赋值为。在运行，更新下一次阻塞时间，防止被挂起任务为下一次阻塞超时任务。无论优先级如何，被挂起的任务都将不再被执行，直到任务被恢复。如果挂起的是任务自身，且调度器正在运行，需要进行一次任务切换。是：就会将该任务在挂起列表中移除， 将该任务添加到就绪列表中。挂起：挂起任务类似暂停，可恢复；删除任务，无法恢复。将待挂起任务的任务状态列表项插入到挂起态任务列表末尾。通过传入的任务句柄，判断所需要挂起哪个任务，，则代表挂起任务自身（当前正在运行的任务）
FreeRTOS任务的挂起和恢复
qq_45973003的博客
04-15 975
4：如果挂起的是任务自身 【调度器正在运行，强制进行一次任务切换】，调度器没有运行【是：代表任务均被挂起，则当前的控制块赋值为NULL】【否：通过函数vTaskSwitchContext寻找下一个最高优先级任务】3：判断任务调度器是否在运行，如果在运行，更新下一次阻塞时间，防止被挂起任务为下一次阻塞超时。1：根据任务句柄来挂起任务控制块，如果热虐句柄为NULL表示要挂起任务自身。2：将要挂起的任务从相应的状态列表中移除。
第五章 FreeRTOS的任务挂起与恢复
m0_66317799的博客
08-10 148
参数介绍待恢复任务的任务句柄。参数介绍待恢复任务的任务句柄。函数返回值描述pdTrue任务恢复后需要进行任务切换（恢复的任务优先级，大于当前正在执行的任务优先级）pdFALSE任务恢复后不需要进行任务切换。
六、FreeRTOS之FreeRTOS的任务挂起和恢复函数介绍
王同学
11-30 1402
()挂起任务()恢复被挂起的任务()在中断中恢复被挂起的任务那么问题来了，挂起和删除的区别是什么呢？挂起：挂起任务类似暂停，可恢复；删除任务，无法恢复恢复：恢复被挂起的任务FromISR：带FromISR后缀是在中断函数中专用的API函数1.1 任务挂起函数介绍void。
freeRTOS学习day3-任务的挂起和恢复
weixin_64975583的博客
10-26 238
实验：创建三个任务 任务一打印 任务二打印 任务三控制任务一的挂起和恢复。任务挂起后 进入就绪态 会停止运行。
FreeRTOS源码解析 -> vTaskResume（）
MrJang_的专栏
12-31 2412
#if ( INCLUDE_vTaskSuspend == 1 ) void vTaskResume( xTaskHandle pxTaskToResume ) { tskTCB *pxTCB; /* It does not make sense to resume the calling task. */ configASSERT( pxTaskToResume );
freeRTOS总结（三）任务挂起和恢复
Pretender_1205的博客
01-09 611
xTaskToSuspend 待挂起任务的任务句柄此函数用于挂起任务，使用时需将宏 INCLUDE_vTaskSuspend 配置为 1。无论优先级如何，被挂起的任务都将不再被执行，直到任务被恢复。注意：当传入的参数为NULL，则代表挂起任务自身（当前正在运行的任务）xTaskToResume 待恢复任务的任务句柄使用该函数注意宏：INCLUDE_vTaskSuspend必须定义为 1。
FreeRTOS任务挂起与恢复的实现机制
理解并能够熟练运用FreeRTOS的任务挂起与恢复功能，对于开发稳定、可靠的嵌入式系统来说是至关重要的。通过对任务的精细控制，开发者可以更好地管理任务的执行，优化系统的实时性能，并在必要时刻进行调试。此外，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值