Freertos多线程实战：降低嵌入式系统编程难度

操作系统

需积分: 48 179 浏览量更新于2024-07-21 1 收藏 1.74MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源推荐

http://www.FreeRTOS.org

FreeRTOS

Designed For Microcontrollers;

Scope

This chapter aims to give readers a good understanding of:

• How FreeRTOS allocates processing time to each task within an application.

• How FreeRTOS chooses which task should execute at any given time.

• How the relative priority of each task affects system behavior.

• The states that a task can exist in.

In addition readers will hopefully gain a good understanding of:

• How to implement tasks.

• How to create one or more instances of a task.

• How to use the task parameter.

• How to change the priority of a task that has already been created.

• How to delete a task.

• How to implement periodic processing.

• When the idle task will execute and how it can be used.

The concepts presented in this chapter are fundamental to understanding how to use FreeRTOS and

how FreeRTOS applications behave – this is therefore the most detailed chapter in the book.

http://www.FreeRTOS.org

FreeRTOS

Designed For Microcontrollers;

1.2 T

ASK

UNCTIONS

Tasks are implemented as C functions. The only thing special about them is their prototype, which

must return void and take a void pointer parameter. The prototype is demonstrated by Listing 1.

void ATaskFunction( void *pvParameters );

Listing 1 The task function prototype

Each task is a small program in its own right. It has an entry point, will normally run forever within an

infinite loop, and will not exit. The structure of a typical task is shown in Listing 2.

FreeRTOS tasks must not be allowed to return from their implementing function in any way – they

must not contain a ‘return’ statement and must not be allowed to execute past the end of the function.

If a task is no longer required it should instead be explicitly deleted. This is also demonstrated in

Listing 2.

A single task function definition can be used to create any number of tasks – each created task being

a separate execution instance with its own stack and its own copy of any automatic (stack) variables

defined within the task itself.

void ATaskFunction( void *pvParameters )

{

/* Variables can be declared just as per a normal function. Each instance

of a task created using this function will have its own copy of the

iVariableExample variable. This would not be true if the variable was

declared static – in which case only one copy of the variable would exist

and this copy would be shared by each created instance of the task. */

int iVariableExample = 0;

/* A task will normally be implemented as in infinite loop. */

for( ;; )

{

/* The code to implement the task functionality will go here. */

}

/* Should the task implementation ever break out of the above loop

then the task must be deleted before reaching the end of this function.

The NULL parameter passed to the vTaskDelete() function indicates that

the task to be deleted is the calling (this) task. */

vTaskDelete( NULL );

}

Listing 2 The structure of a typical task function

http://www.FreeRTOS.org

FreeRTOS

Designed For Microcontrollers;

Table 1 xTaskCreate() parameters and return value

Parameter

Name/Returned

Value

Description

usStackDepth Each task has its own unique state that is allocated by the kernel to the task when

the task is created. The usStackDepth value tells the kernel how big to make the

stack.

The value specifies the number of words the stack can hold, not the number of

bytes. For example, if the stack is 32 bits wide and usStackDepth is passed in as

100, then 400 bytes of stack space will be allocated (100 * 4bytes). The stack

depth multiplied by the stack width must not exceed the maximum value that can

be contained in a variable of type size_t.

The size of the stack used by the idle task is defined by the application defined

constant configMINIMAL_STACK_SIZE . The value assigned to this constant in

the FreeRTOS demo application for the microcontroller architecture being used is

the minimum recommended for any task. If your task uses a lot of stack space

then you will need to assign a larger value.

There is no easy way of determining the stack space required by a task. It is

possible to calculate, but most users will simply assign what they think is a

reasonable value, then use the features provided by FreeRTOS to ensure both

that the space allocated is indeed adequate, and that RAM is not being

unnecessarily wasted. CHAPTER 6 contains information on how to query the

stack space being used by a task.

pvParameters Task functions accept a parameter of type pointer to void ( void* ). The value

assigned to pvParameters will be the value passed into the task. Some examples

within this document demonstrate how the parameter can be used.

uxPriority Defines the priority at which the task will execute. Priorities can be assigned from

0, which is the lowest priority, to (configMAX_PRIORITIES – 1), which is the

highest priority.

configMAX_PRIORITIES is a user defined constant. There is no upper limit on the

number of priorities that can be available (other than the limit of the data types

used and the RAM available in your microcontroller), but you should use the

lowest number of priorities actually required in order to avoid wasting RAM.

Passing a uxPriority value above (configMAX_PRIORITIES – 1) will result in the

actual priority assigned to the task being silently capped to the maximum

legitimate value.

剩余162页未读，继续阅读

qq_26302861

粉丝: 0
资源: 1

Freertos多线程实战：降低嵌入式系统编程难度

stm32f407_freertos源码工程实例

FreeRTOS 线程守护看门狗

FreeRTOS内核使用指南（中文版）

STM32单片机实时操作系统入门：FreeRTOS实战，解锁多任务处理

STM32单片机基于FreeRTOS的实时操作系统应用：从基础到实战，打造高性能嵌入式系统

单片机实验嵌入式操作系统入门：FreeRTOS和μC_OS揭秘

STM32单片机嵌入式操作系统实战：FreeRTOS、μC_OS详解

STM32单片机FreeRTOS编程：深入理解实时操作系统，打造嵌入式系统新高度

freertos多线程

FreeRTOS多线程

freertos中多线程和linux中多线程的区别

freertos线程管理

stm32与app通信需要使用FreeRTOS实时操作系统吗

freertos 协程和线程

freeRTOS实时操作系统原理

freertos创建多个线程和linux中创建多个线程的区别

freertos的线程

支持多线程的实时操作系统有哪些

freertos线程

freertos线程间数据保护

最新资源