嵌入式学习（3）-FreeRTOS的创建任务过程

最新推荐文章于 2023-02-07 15:13:46 发布
最新推荐文章于 2023-02-07 15:13:46 发布
阅读量390 收藏
点赞数
分类专栏： 嵌入式学习日程 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36907523/article/details/126494126
版权

创建任务过程理解

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;
		#if( portSTACK_GROWTH > 0 )
		{
			pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );
			if( pxNewTCB != NULL )
			{
				pxNewTCB->pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) );
				if( pxNewTCB->pxStack == NULL )
				{
					vPortFree( pxNewTCB );
					pxNewTCB = NULL;
				}
			}
		}
		#else 
		{
		StackType_t *pxStack;
			pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); 
			if( pxStack != NULL )
			{
				/* Allocate space for the TCB. */
				pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */

				if( pxNewTCB != NULL )
				{
					/* Store the stack location in the TCB. */
					pxNewTCB->pxStack = pxStack;
				}
				else
				{
					/* The stack cannot be used as the TCB was not created.  Free
					it again. */
					vPortFree( pxStack );
				}
			}
			else
			{
				pxNewTCB = NULL;
			}
		}
		#endif /* portSTACK_GROWTH */

		if( pxNewTCB != NULL )
		{
			#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
			{
				/* Tasks can be created statically or dynamically, so note this
				task was created dynamically in case it is later deleted. */
				pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;
			}
			#endif /* configSUPPORT_STATIC_ALLOCATION */

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

		return xReturn;
	}

首先判断堆栈增长方向，通过堆栈增长方向来设置堆栈。
然后给任务快申请内存，申请成功就初始化堆栈字段pxStack 。
再标记一下这是使用动态创建任务函数。
然后初始化任务。
将新创建的任务加入到就绪列表中。

prvInitialiseNewTask（）函数分析

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 ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
{
StackType_t *pxTopOfStack;
UBaseType_t x;

	#if( portUSING_MPU_WRAPPERS == 1 )
		/* Should the task be created in privileged mode? */
		BaseType_t xRunPrivileged;
		if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )
		{
			xRunPrivileged = pdTRUE;
		}
		else
		{
			xRunPrivileged = pdFALSE;
		}
		uxPriority &= ~portPRIVILEGE_BIT;
	#endif /* portUSING_MPU_WRAPPERS == 1 */

	/* Avoid dependency on memset() if it is not required. */
	#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )
	{
		/* Fill the stack with a known value to assist debugging. */
		( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );
	}
	#endif /* ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ) ) */

	/* Calculate the top of stack address.  This depends on whether the stack
	grows from high memory to low (as per the 80x86) or vice versa.
	portSTACK_GROWTH is used to make the result positive or negative as required
	by the port. */
	#if( portSTACK_GROWTH < 0 )
	{
		pxTopOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
		pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 MISRA exception.  Avoiding casts between pointers and integers is not practical.  Size differences accounted for using portPOINTER_SIZE_TYPE type. */

		/* Check the alignment of the calculated top of stack is correct. */
		configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );
	}
	#else /* portSTACK_GROWTH */
	{
		pxTopOfStack = pxNewTCB->pxStack;

		/* Check the alignment of the stack buffer is correct. */
		configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxNewTCB->pxStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

		/* The other extreme of the stack space is required if stack checking is
		performed. */
		pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );
	}
	#endif /* portSTACK_GROWTH */

	/* Store the task name in the TCB. */
	for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
	{
		pxNewTCB->pcTaskName[ x ] = pcName[ x ];

		/* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than
		configMAX_TASK_NAME_LEN characters just in case the memory after the
		string is not accessible (extremely unlikely). */
		if( pcName[ x ] == 0x00 )
		{
			break;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}

	/* Ensure the name string is terminated in the case that the string length
	was greater or equal to configMAX_TASK_NAME_LEN. */
	pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';

	/* This is used as an array index so must ensure it's not too large.  First
	remove the privilege bit if one is present. */
	if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
	{
		uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}

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

	vListInitialiseItem( &( pxNewTCB->xStateListItem ) );
	vListInitialiseItem( &( pxNewTCB->xEventListItem ) );

	/* Set the pxNewTCB as a link back from the ListItem_t.  This is so we can get
	back to	the containing TCB from a generic item in a list. */
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );

	/* Event lists are always in priority order. */
	listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xEventListItem ), pxNewTCB );

	#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 ( portUSING_MPU_WRAPPERS == 1 )
	{
		vPortStoreTaskMPUSettings( &( pxNewTCB->xMPUSettings ), xRegions, pxNewTCB->pxStack, ulStackDepth );
	}
	#else
	{
		/* Avoid compiler warning about unreferenced parameter. */
		( void ) xRegions;
	}
	#endif

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

	#if ( configUSE_TASK_NOTIFICATIONS == 1 )
	{
		pxNewTCB->ulNotifiedValue = 0;
		pxNewTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
	}
	#endif

	#if ( configUSE_NEWLIB_REENTRANT == 1 )
	{
		/* Initialise this task's Newlib reent structure. */
		_REENT_INIT_PTR( ( &( pxNewTCB->xNewLib_reent ) ) );
	}
	#endif

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

	/* Initialize the TCB stack to look as if the task was already running,
	but had been interrupted by the scheduler.  The return address is set
	to the start of the task function. Once the stack has been initialised
	the	top of stack variable is updated. */
	#if( portUSING_MPU_WRAPPERS == 1 )
	{
		pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged );
	}
	#else /* portUSING_MPU_WRAPPERS */
	{
		pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );
	}
	#endif /* portUSING_MPU_WRAPPERS */

	if( ( void * ) pxCreatedTask != NULL )
	{
		/* Pass the handle out in an anonymous way.  The handle can be used to
		change the created task's priority, delete the created task, etc.*/
		*pxCreatedTask = ( TaskHandle_t ) pxNewTCB;
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

这段代码比较长，一点一点分析，首先

#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )
	{
		/* Fill the stack with a known value to assist debugging. */
		( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );
	}

这里是判断是否使能了堆栈溢出检测功能和追踪功能，如果使能了，就用0XA5U来填充堆栈。tskSTACK_FILL_BYTE的值为0xA5U.
然后根据堆栈增长方向，计算栈顶的地址。
然后将任务的名字的字符串保存起来，添加结束符’\0’。
判断当前任务的优先级是否超过了FreeRTOS系统的最大优先级。超过了就将优先级设置为最大优先级减一。
初始化任务控制块的优先级字段uxPriority。
如果使能了互斥信号量，就初始化相应的字段。
使用vListInitialiseItem（）函数初始化列表项。
设置状态列表项和事件列表项为当前任务的控制块。
后面有一些条件编译，根据自己使用情况来开启，这里是在开启后进行了一些初始化字段。
后面初始化了任务堆栈，使用pxPortInitialiseStack（）。
最后生成任务句柄，可以看出，任务句柄就是任务控制块。

vListInitialiseItem（）函数分析

void vListInitialiseItem( ListItem_t * const pxItem )
{
	/* Make sure the list item is not recorded as being on a list. */
	pxItem->pvContainer = NULL;

	/* Write known values into the list item if
	configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */
	listSET_FIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
	listSET_SECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE( pxItem );
}

这里的函数都没有实现，说明这里只是将列表进行了初始化，对pvContainer 给了0。

prvAddNewTaskToReadyList()函数分析

static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )
{
	/* Ensure interrupts don't access the task lists while the lists are being
	updated. */
	taskENTER_CRITICAL();
	{
		uxCurrentNumberOfTasks++;
		if( pxCurrentTCB == NULL )
		{
			/* There are no other tasks, or all the other tasks are in
			the suspended state - make this the current task. */
			pxCurrentTCB = pxNewTCB;

			if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )
			{
				/* This is the first task to be created so do the preliminary
				initialisation required.  We will not recover if this call
				fails, but we will report the failure. */
				prvInitialiseTaskLists();
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		else
		{
			/* If the scheduler is not already running, make this task the
			current task if it is the highest priority task to be created
			so far. */
			if( xSchedulerRunning == pdFALSE )
			{
				if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )
				{
					pxCurrentTCB = pxNewTCB;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}

		uxTaskNumber++;

		#if ( configUSE_TRACE_FACILITY == 1 )
		{
			/* Add a counter into the TCB for tracing only. */
			pxNewTCB->uxTCBNumber = uxTaskNumber;
		}
		#endif /* configUSE_TRACE_FACILITY */
		traceTASK_CREATE( pxNewTCB );

		prvAddTaskToReadyList( pxNewTCB );

		portSETUP_TCB( pxNewTCB );
	}
	taskEXIT_CRITICAL();

	if( xSchedulerRunning != pdFALSE )
	{
		/* If the created task is of a higher priority than the current task
		then it should run now. */
		if( pxCurrentTCB->uxPriority < pxNewTCB->uxPriority )
		{
			taskYIELD_IF_USING_PREEMPTION();
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	else
	{
		mtCOVERAGE_TEST_MARKER();
	}
}

先进入临界区。uxCurrentNumberOfTasks（）函数用来记录任务数量。
如果任务控制块为空，说明当前没有任务，或者其他任务都处于挂起态，那就将此做为当前任务。初始化任务列表。
如果当前有任务，那就判断当前是否开启任务调度。如果当前调度任务还未运行，那就判断优先级，将pxCurrentTCB设置为高优先级任务的任务控制块。
任务数量加一。
traceTASK_CREATE( pxNewTCB );函数未实现
添加任务到就绪列表中，
退出临界区。
如果当前任务调度器已经开启。而且新任务的优先级最高，那就进行一次任务切换。

prvAddTaskToReadyList()函数分析

#define prvAddTaskToReadyList( pxTCB )																\
	traceMOVED_TASK_TO_READY_STATE( pxTCB );														\
	taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );												\
	vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) ); \
	tracePOST_MOVED_TASK_TO_READY_STATE( pxTCB )

添加任务到就绪列表函数是一个宏，其中traceMOVED_TASK_TO_READY_STATE( pxTCB ); 未实现
taskRECORD_READY_PRIORITY函数用于硬件设置优先级。
在就将任务添加到就绪列表结尾。

pxPortInitialiseStack（）函数分析

StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters )
{
	/* Simulate the stack frame as it would be created by a context switch
	interrupt. */
	pxTopOfStack--; /* Offset added to account for the way the MCU uses the stack on entry/exit of interrupts. */
	*pxTopOfStack = portINITIAL_XPSR;	/* xPSR */
	pxTopOfStack--;
	*pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK;	/* PC */
	pxTopOfStack--;
	*pxTopOfStack = ( StackType_t ) prvTaskExitError;	/* LR */

	pxTopOfStack -= 5;	/* R12, R3, R2 and R1. */
	*pxTopOfStack = ( StackType_t ) pvParameters;	/* R0 */
	pxTopOfStack -= 8;	/* R11, R10, R9, R8, R7, R6, R5 and R4. */

	return pxTopOfStack;
}

在任务初始化函数里会对任务的堆栈初始化，首先将寄存器xPSRd的值设置为portINITIAL_XPSR，然后将PC的值设置为pxCode ，然后将LR的值设置为prvTaskExitError。跳过R12,R3,R2,R1.将R0设置为pvParameters。跳过八个寄存器。这里的寄存器顺序是芯片内设置好的。最后的堆栈如图所示。
在这里插入图片描述

冰茶丿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
FreeRTOS笔记（三）调度机制
m0_58575472的博客
11-21 1906
在单处理系统中，任何时间里只能有一个任务处于运行状态。。就绪态的任务，可以被调度器挑选出来切换为运行状态，调度器永远都是挑选最高优先级的就绪态任务并让它进入运行状态。阻塞状态的任务，它在等待"事件"，当事件发生时任务就会进入就绪状态。事件分为两类：时间相关的事件、同步事件。所谓时间相关的事件，就是设置超时时间：在指定时间内阻塞，时间到了就进入就绪状态。
FreeRTOS任务创建
Zach_z的博客
09-10 4493
FreeRTOS 任务创建
FreeRTOS任务切换分析
诗筱涵的博客
09-23 530
摘自：https://blog.csdn.net/qingzhuyuxian/article/details/80604129 FreeRTOS任务相关的代码大约占总代码的一半左右，这些代码都在为一件事情而努力，即找到优先级最高的就绪任务，并使之获得CPU运行权。任务切换是这一过程的直接实施者，为了更快的找到优先级最高的就绪任务，任务切换的代码通常都是精心设计的，甚至会用到汇编指令或者与硬件相关的特性，比如Cortex-M3的CLZ指令。因此任务切换的大部分代码是由硬件移植层提供的，不同的平台，实现.
FreeRTOS 任务管理
weixin_49947521的博客
03-25 1505
1. 任务概念介绍 2. 任务创建 3. 任务启动 4. 任务切换 5. 任务状态迁移 6. 任务相关API
FreeRTOS（基于STM32）——任务创建
vizio.blog.csdn.net
10-28 1548
FreeRTOS笔记，任务的创建。
嵌入式FreeRTOS学习资料FreeRTOS系列教程基础篇文档资料合集（20个）.zip
最新发布
06-04
嵌入式FreeRTOS学习资料FreeRTOS系列教程基础篇文档资料合集（20个）： 10、 FreeRTOS系列第10篇---FreeRTOS任务创建和删除.docx 11、 FreeRTOS系列第11篇---FreeRTOS任务控制.docx 12、 FreeRTOS系列第12篇---...
GD32-FreeRTOS-TCP
10-10
FreeRTOS是一个实时操作系统（RTOS），适用于嵌入式系统，它提供了调度、任务管理、内存管理和中断处理等核心功能。TCP/IP协议栈则是用于网络通信的一组标准协议，包括传输控制协议TCP和Internet协议IP，用于在不同...
ARM.CMSIS-FreeRTOS.10.2.0.rar
03-18
例如，使用`xTaskCreate()`函数创建任务，`vTaskStartScheduler()`函数启动调度器。 5. 在任务函数中实现具体的业务逻辑，利用FreeRTOS提供的同步和通信机制，如信号量、互斥锁或消息队列。 在实际应用中，FreeRTOS...
物联网嵌入式ESP32开发例程02-FreeRTOS操作系统之任务创建与静态删除C程序代码.rar
04-18
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code + ESP-IDF开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请...
物联网嵌入式ESP32开发例程01-FreeRTOS操作系统之任务创建与动态删除C程序代码.rar
04-18
1、嵌入式物联网ESP32项目实战开发。例程经过精心编写，简单好用。 2、代码使用Visual Studio Code + ESP-IDF开发，C语言编程。例程在ESP32-S3上运行。若在其他型号上运行，请自行调整。 3、如果接入其他传感器，请...
FreeRTOS的任务创建和删除
weixin_58038211的博客
02-07 374
会负责释放被删除任务中由系统分配的内存，但是由用户在任务删除前申请的内存， 则需要由用户在任务被删除前提前释放，否则将导致内存泄露。4、更新下个任务的阻塞时间：更新下一个任务的阻塞超时时间，以防被删除的任务就是下一个阻塞超时的任务。1、获取所要删除任务的控制块：通过传入的任务句柄，判断所需要删除哪个任务，NULL代表删除自身。2、将被删除任务，移除所在列表：将该任务在所在列表中移除，包括：就绪、阻塞、挂起、事件等列表。2、实验设计：将设计四个任务：start_task、task1、task2、task3。
嵌入式FreeRTOS学习二，FreeRTOS任务的创建和删除
weixin_44651073的博客
10-09 1361
任务的创建和删除
FreeRTOS学习（临界区的保护）
weixin_52589726的博客
09-12 1001
临界区是因为
一篇讲透嵌入式操作系统任务调度
机械猿的博客
06-20 4147
进互联网公司操作系统和网络库是基础技能，面试过不去的看，这里基于嵌入式操作系统分几章来总结一下任务调度、内存分配和网络协议栈的基础原理和代码实现。处理器上电时会产生一个复位中断，接下来会...
三、FreeRTOS学习之 freertos的任务创建
m0_72750024的博客
08-23 1498
任务创建
FreeRTOS中的堆栈设置”与“系统启动文件中堆栈”的关系
lighthear的博客
04-07 6022
本文由之前系统堆空间分配所引发，简要分析了“FreeRTOS中的堆栈设置”与“系统启动文件中堆栈”的关系 ，并进行了初步测试。证明了二者在系统内存空间上互不影响的结论。
【FreeRTOS】小白进阶之如何创建FreeRTOS任务（一）
产品线负责人
09-06 5391
创建了两个单独的任务并打印不同的信息。 1、头文件声明 #include "FreeRTOS.h" #include "task.h" #include "supporting_functions.h" // 延时 #define mainDELAY_LOOP_COUNT        ( 0xffffff ) 2、任务函数声明 void vTask1( void *pvParame...
FreeRTOS系列第10篇---FreeRTOS任务创建和删除
热门推荐
朱工的专栏
12-21 4万+
在FreeRTOS移植到Cortex-M3硬件平台的文章中，我们已经见过任务创建API，但那篇文章的重点在于如何移植FreeRTOS，本文将重点放在任务的创建和删除API函数上面。      任务创建和删除API函数位于文件task.c中，需要包含task.h头文件。1.任务创建1.1函数描述 BaseType_txTaskCreate(
FreeRTOS源代码分析 - List.c 学习笔记
weixin_39344546的博客
02-06 669
FreeRTOS中list.c包含4个函数， 其中功能如下： void vListInitialise( List_t * const pxList ) PRIVILEGED_FUNCTION; 链表根节点初始化 void vListInitialiseItem( ListItem_t * const pxItem ) PRIVILEGED_FUNCTION; 链表节点初始化 void vList...
freertos任务创建和使用
07-28
FreeRTOS是一个用于嵌入式系统的实时操作系统。在FreeRTOS中，任务是系统中最基本的执行单位。下面是关于FreeRTOS任务创建和使用的一些基本信息： 1. 在FreeRTOS中创建任务的步骤如下： - 使用xTaskCreate()函数创建任务，指定任务函数、任务名称、堆栈大小和优先级等参数。 - 在任务函数中定义任务的行为和逻辑。 - 使用vTaskStartScheduler()函数启动调度器，开始任务调度。 2. 任务函数的定义： - 任务函数是一个无返回值、无参数的函数，它将在任务创建后立即执行。 - 任务函数应该包含一个无限循环，以便任务能够不断地执行。 3. 任务的优先级： - FreeRTOS使用优先级来确定任务的执行顺序。具有较高优先级的任务将在具有较低优先级的任务之前执行。 - 可以使用宏定义configMAX_PRIORITIES来定义系统支持的最大优先级数。 4. 任务挂起和恢复： - 可以使用vTaskSuspend()函数将任务挂起，使其暂停执行。 - 可以使用vTaskResume()函数恢复被挂起的任务，使其继续执行。 5. 任务删除： - 可以使用vTaskDelete()函数删除一个已经创建的任务。 这些是FreeRTOS中任务创建和使用的基本知识。在实际应用中，还可以使用其他FreeRTOS提供的功能和API来管理和控制任务的执行。请注意，具体的实现细节可能会因为不同的系统和编译器而有所差异，建议参考FreeRTOS官方文档和示例代码进行更详细的学习和了解。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

冰茶丿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值