FreeRTOS入门与模块详解

5星 · 超过95%的资源需积分: 10 101 浏览量更新于2024-07-20 收藏 757KB PDF 举报

FreeRTOS_manual 是一个专门为小型嵌入式系统设计的实时操作系统(RTOS)的手册，旨在提供全面的指导和支持。该手册由主页引导，如果浏览器不支持框架，用户可以点击顶部链接访问完整内容。FreeRTOS包含多个核心模块，涵盖了从基础概念到高级功能的深入理解。 1. **Fundamentals**：这部分介绍了FreeRTOS的基本原理和设计理念，让开发者了解操作系统如何在嵌入式环境中管理任务、优先级和资源。 2. **Design**：涉及系统架构和设计原则，包括任务调度策略，确保高效能和稳定性。 3. **Tasks & Priorities**：详细讲解了任务的创建、执行以及优先级设置，这是决定系统性能的关键要素。 4. **Trace Utility**：提供了用于调试和性能分析的工具，帮助开发人员追踪任务执行过程，找出潜在问题。 5. **Kernel Utilities**：涵盖内核相关的实用工具和服务，如中断处理、同步机制等。 6. **Source Organization**：讨论了代码组织结构，使得源码易于维护和扩展。 7. **RTOS Ports**：介绍不同硬件平台的支持情况，包括各种微控制器（如LPC2129 ARM7、AT91SAM7S64等）、编程环境（如Keil、IAR、GCC等）及其对应的应用示例。 8. **Demo Application**： - **Introduction**: 提供入门级别的示例应用程序，展示如何在实际项目中应用FreeRTOS。 - **Standard Files**: 包含标准的配置文件和示例程序，便于用户快速上手。 - **Embedded TCP/IP**: 针对网络通信的嵌入式解决方案，可能包括网络栈的集成和配置。 9. **API**：详述了FreeRTOS的核心函数和接口，如`xTaskCreate`和`vTaskDelete`，这些是编写任务代码的基础。 10. **Upgrading to V3.0.0**：针对升级至最新版本的指导，帮助开发者了解新特性及迁移策略。 11. **Configuration**：涉及构建配置和内存管理，确保系统的定制化适应性和优化。 FreeRTOS_manual 是一个全面的资源库，无论你是初学者还是经验丰富的嵌入式开发者，都能从中找到所需的信息来构建和优化基于FreeRTOS的嵌入式系统。通过阅读和实践手册中的内容，开发者能够更好地理解和利用FreeRTOS的强大功能，提高项目的效率和可靠性。

configIDLE_SHOULD_YIELD

This parameter controls the behaviour of tasks at the idle priority. It only has an effect if:

1. The preemptive scheduler is being used.

2. The users application creates tasks that run at the idle priority.

Tasks that share the same priority will time slice. Assuming none of the tasks get preempted, it might be

assumed that each task of at a given priority will be allocated an equal amount of processing time - and if the

shared priority is above the idle priority then this is indeed the case.

When tasks share the idle priority the behaviour can be slightly different. When configIDLE_SHOULD_YIELD

is set to 1 the idle task will yield immediately should any other task at the idle priority be ready to run. This

ensures the minimum amount of time is spent in the idle task when application tasks are available for

scheduling. This behaviour can however have undesirable effects (depending on the needs of your

application) as depicted below:

This diagram shows the execution pattern of four tasks at the idle priority. Tasks A, B and C are application

tasks. Task I is the idle task. A context switch occurs with regular period at times T0, T1, ..., T6. When the idle

task yields task A starts to execute -

but the idle task has already taken up some of the current time slice. This

results in task I and task A effectively sharing a time slice. The application tasks B and C therefore get more

processing time than the application task A.

This situation can be avoided by:

If appropriate, using an idle hook in place of separate tasks at the idle priority.

Creating all application tasks at a priority greater than the idle priority.

Setting configIDLE_SHOULD_YIELD to 0.

Setting configIDLE_SHOULD_YIELD prevents the idle task from yielding processing time until the end of its

time slice. This ensure all tasks at the idle priority are allocated an equal amount of processing time - but at

the cost of a greater proportion of the total processing time being allocated to the idle task.

INCLUDE Parameters

The macros starting 'INCLUDE' allow those components of the real time kernel not utilized by your application

to be excluded from your build. This ensures the RTOS does not use any more ROM or RAM than necessary

for your particular embedded application.

Each macro takes the form ...

INCLUDE_FunctionName

... where FunctionName indicates the API function (or set of functions) that can optionally be excluded. To

include the API function set the macro to 1, to exclude the function set the macro to 0. For example, to include

the vTaskDelete() API function use:

#define INCLUDE_vTaskDelete 1

To exclude vTaskDelete() from your build use:

#define INCLUDE_vTaskDelete 0

Page

FreeRTOS

A FREE Open Source RTOS for small real time embedded systems

26.11.2005

http://127.0.0.1:800/Default/www.freertos.org/a00110.html

Homepage

Memory Management

[Configuration]

The RTOS kernel has to allocate RAM each time a task, queue or semaphore is created. The malloc() and

free() functions can sometimes be used for this purpose, but ...

1. they are not always available on embedded systems,

2. take up valuable code space,

3. are not thread safe, and

4. are not deterministic (the amount of time taken to execute the function will differ from call to call)

... so more often than not an alternative scheme is required.

One embedded / real time system can have very different RAM and timing requirements to another - so a

single RAM allocation algorithm will only ever be appropriate for a subset of applications.

To get around this problem the memory allocation API is included in the RTOS portable layer - where an

application specific implementation appropriate for the real time system being developed can be provided.

When the real time kernel requires RAM, instead of calling malloc() it makes a call to pvPortMalloc(). When

RAM is being freed, instead of calling free() the real time kernel makes a call to vPortFree().

Schemes included in the source code download

Three sample RAM allocation schemes are included in the FreeRTOS source code download (V2.5.0

onwards). These are used by the various demo applications as appropriate. The following subsections

describe the available schemes, when they should be used, and highlight the demo applications that

demonstrate their use.

Each scheme is contained in a separate source file (heap_1.c, heap_2.c and heap_3.c respectively) which

can be located in the

Source/Portable/MemMang

directory. Other schemes can be added if required.

Scheme 1 - heap_1.c

This is the simplest scheme of all. It does

not

permit memory to be freed once it has been allocated, but

despite this is suitable for a surprisingly large number of applications.

The algorithm simply subdivides a single array into smaller blocks as requests for RAM are made. The total

size of the array is set by the definition configTOTAL_HEAP_SIZE - which is defined in FreeRTOSConfig.h.

This scheme:

Can be used if your application never deletes a task or queue (no calls to vTaskDelete() or

vQueueDelete() are ever made).

Is always deterministic (always takes the same amount of time to return a block).

Is used by the PIC, AVR and 8051 demo applications - as these do not dynamically create or delete

tasks after vTaskStartScheduler() has been called.

heap_1.c is suitable for a lot of small real time systems provided that all tasks and queues are created

before the kernel is started.

Page

FreeRTOS

A FREE Open Source RTOS for small real time embedded systems

26.11.2005

http://127.0.0.1:800/Default/www.freertos.org/a00111.html

Scheme 2 - heap_2.c

This scheme uses a best fit algorithm and, unlike scheme 1, allows previously allocated blocks to be freed. It

does

not

however combine adjacent free blocks into a single large block.

Again the total amount of available RAM is set by the definition configTOTAL_HEAP_SIZE - which is defined

in FreeRTOSConfig.h.

This scheme:

Can be used even when the application repeatedly calls vTaskCreate()/vTaskDelete() or

vQueueCreate()/vQueueDelete() (causing multiple calls to pvPortMalloc() and vPortFree()).

Should

not

be used if the memory being allocated and freed is of a random size -

this would only be the

case if tasks being deleted each had a different stack depth, or queues being deleted were of different

lengths.

Could possible result in memory fragmentation problems should your application create blocks of

queues and tasks in an unpredictable order. This would be unlikely for nearly all applications but

should be kept in mind.

Is not deterministic - but is also not particularly inefficient.

Is used by the ARM7, and Flashlite demo applications - as these dynamically create and delete tasks.

heap_2.c is suitable for most small real time systems that have to dynamically create tasks.

Scheme 3 - heap_3.c

This is just a wrapper for the standard malloc() and free() functions. It makes them thread safe.

This scheme:

Requires the linker to setup a heap, and the compiler library to provide malloc() and free()

implementations.

Is not deterministic.

Will probably considerably increase the kernel code size.

Is used by the PC (x86 single board computer) demo application.

Any and all data, files, source code, html content and documentation included in the FreeRTOS distribution or available on this site are the exclusive property

of Richard Barry. See the files license.txt (included in the distribution) and this copyright notice for more information. FreeRTOS

and FreeRTOS.org

are

trade marks of Richard Barry.

Page

FreeRTOS

A FREE Open Source RTOS for small real time embedded systems

26.11.2005

http://127.0.0.1:800/Default/www.freertos.org/a00111.html

剩余111页未读，继续阅读

COM115200

粉丝: 13
资源: 9

FreeRTOS入门与模块详解

掌握FreeRTOS源码与官方文档的完整指南

FreeRTOS 实战：队列创建与管理-ri5cy_user_manual

Freertos Reference Manual: 内置方法与对象属性详解

FreeRTOS_manual.rar_freertos_freertos manual_it

FreeRTOS_manual.zip_FreeRTOS pdf_Organization Design_freertos_fr

FreeRTOS_Reference_Manual

FreeRTOS_Reference_Manual_V10.0.0.pdf_freertos_

FreeRTOS_Reference_Manual_V10.0.0

FreeRTOS_Reference_Manual_V9.0.0

FreeRTOS_Reference_Manual_V10.0.0.pdf

最新资源