Freertos Proj

FreeRTOS
A Brief Overview
Christopher Kenna
Avionics
October 1, 2010
FreeRTOS
N
1 / 34
Introduction
Outline
1
Introduction
About FreeRTOS
Kernel Overview
Tasks
Tasks versus Co-Routines
Task Details
IPC and Synchronization

Queues
Semaphores and Mutexes
Scheduler
Scheduler Background
Scheduler Code
FreeRTOS
N
2 / 34
Introduction About FreeRTOS
Background Information
The FreeRTOS Project supports 25 official architecture ports, with many
more community developed ports.
The FreeRTOS RT kernel is portable, open source, royalty free, and very
small.
OpenRTOS is a commercialized version by the sister company High
Integrity Systems.
Richard Barry: I know FreeRTOS has been used in some rockets and other
aircraft, but nothing too commercial.
We have customers that use it on ship systems, and WITTENSTEIN sell
SafeRTOS which has been certified to various standards, but not
DO-178B.
FreeRTOS
N
3 / 34
Licensing Information (0/2)

The license is a modified GNU GPL according to the table below.
FreeRTOS
Modified GPL
Free?
Use it in a commercial application?
Royalty free?
Must open source code that makes
use of FreeRTOS services?
Must open source kernel changes?
1 As
!
!
!
#
!
OpenRTOS
Commercial
#
!
!
#
#
long as code provides functionality that is distinct from that provided by FreeRTOS.
FreeRTOS
4 / 34
Licensing Information (1/2)

The license is a modified GNU GPL according to the table below.
FreeRTOS
Modified GPL
Must document that the product uses
FreeRTOS?
Required to offer FreeRTOS code to
application users?
Technical support for OS?
Warranty?
2 Web
!
!
#
#
OpenRTOS
Commercial
#
#
!
!
link to FreeRTOS.org is sufficient.

is an on-line community, though.
3 There
FreeRTOS
N
5 / 34
Introduction Kernel Overview
FreeRTOS Configuration
The operation of FreeRTOS is governed by FreeRTOS.h, with application
specific configuration appearing in FreeRTOSConfg.h.
Obviously, these are static configuration options.
Some examples:
configUSE_PREEMPTION
configCPU_CLOCK_HZ CPU clock frequency, not necessarily the
bus frequency.
configTICK_RATE_HZ RTOS tick frequency that dictates interrupt
frequency.
configMAX_PRIORITIES Total number of priority levels. Each level
creates a new list, so memory sensitive machines should keep this to
a minimum.
And more. . .
FreeRTOS
N
6 / 34
Tasks
Outline
1
Introduction
About FreeRTOS
Kernel Overview
Tasks
Task Details

Queues
Scheduler
Scheduler Code
FreeRTOS
N
7 / 34
Tasks Tasks versus Co-Routines
Tasks in FreeRTOS
Tasks have their own context. No dependency on other tasks unless

defined.
One task executes at a time.
Tasks have no knowledge of scheduler activity. The scheduler handles
context switching.
Thus, tasks each have their own stack upon which execution context can be
saved.
Prioritized and preemptable.
FreeRTOS
N
8 / 34
Tasks Tasks versus Co-Routines
Co-Routines
Co-routines are intended for use on small processors that have severe
RAM constraints. Co-Routines share a single stack.
Co-routines are implemented through macros.
Prioritized relative to other co-routines, but preempted by tasks.
The structure of co-routines is rigid due to the unconventional
implementation.
Lack of stack requires special consideration.
Restrictions on where API calls can be made.
Cannot communicate with tasks.
Will examine tasks in more detail, but not co-routines.
FreeRTOS
N
9 / 34
Tasks Task Details
Task States
Running Actively executing and
using the processor.
Ready Able to execute, but not
because a task of equal or higher
priority is in the Running state.
Blocked Waiting for a temporal
or external event. E.g., queue and
semaphore events, or calling
vTaskDelay() to block until delay
period has expired. Always have a
timeout period, after which the
task is unblocked.
Suspended Only enter via
vTaskSuspend(), depart via
xTaskResume() API calls.
FreeRTOS
N
10 / 34
Tasks Task Details
Task Priorities
Each task gets a priority from 0 to configMAX_PRIORITIES 1

Priority can be set on a per application basis.
Tasks can change their own priority, as well as the priority of other tasks.
tskIDLE_PRIORITY = 0
FreeRTOS
N
11 / 34
Tasks Task Details
The Idle Task
The idle task is created automatically when the scheduler is started.
FreeRTOS
N
12 / 34
Tasks Task Details
The Idle Task

It frees memory allocated by the RTOS to tasks that have since been
deleted.
Thus, applications that use vTaskDelete() to remove tasks should ensure
the idle task is not starved.
FreeRTOS
N
12 / 34
Tasks Task Details
The Idle Task

deleted.
The idle task has no other function, so cases when the idle task need never
run exist.
FreeRTOS
N
12 / 34
Tasks Task Details
The Idle Task

deleted.
The idle task has no other function, so cases when the idle task need never
run exist.
There is an idle task hook, which can do some work at each idle interval
without the RAM usage overhead associated with running a task at the
idle priority.
FreeRTOS
N
12 / 34
Tasks Task Details
Task Control Block (TCB) (0/2)

A TCB is allocated to each task. It stores the tasks context.
Source/tasks.c
typedef struct t s k T a s kC o n t r o l B l o c k
{
: : Top o f t a s k s s t a c k . Must be f i r s t member b/ c o f c o n t e x t s w i t c h
volatile portSTACK_TYPE * pxTopOfStack ; : : code ( l a t e r s l i d e s ) .
# if ( p o r t U S I N G _ M P U _ W R A P P E R S == 1 )
: : The MPU s e t t i n g s a r e d e f i n e d a s p a r t o f t h e p o r t l a y e r .
xMPU_SETTINGS xMPUSettings ; : : Must be 2nd member o f s t r u c t .
# endif
: : L i s t i t e m used t o p l a c e t h e TCB i n r e a d y and b l o c k e d q u e u e s .
xListItem
xGene r i c L i s t I t e m ;
: : Used t o p l a c e t h e TCB i n e v e n t l i s t s .
xListItem
xEventLi stItem ;
: : The p r i o r i t y o f t h e t a s k where 0 i s t h e l o w e s t p r i o r i t y .
unsigned portBASE_TYPE uxPriority ;
: : Points to the s t a r t of the stack .
por tSTACK_TYPE
* pxStack ;
: : D e s c r i p t i v e name g i v e n t o t h e t a s k when c r e a t e d .
: : F a c i l i t a t e s debugging only .
signed char
pcTaskName [ c o n f i g M A X _ T A S K _ N A M E _ L E N ];
FreeRTOS
N
13 / 34
Tasks Task Details
Task Control Block (TCB) (1/2)

Source/tasks.c
# if ( portSTACK_GROWT H > 0 )
: : Used f o r s t a c k o v e r f l o w c h e c k i n g on a r c h i t e c t u r e s where t h e
: : s t a c k grows up from low memory .
por tSTACK_TYPE * pxEndOfStack ;
# endif
...
# if ( c o n f i g U S E _ T R A C E _ F A C I L I T Y == 1 )
: : Used o n l y f o r t r a c i n g t h e s c h e d u l e r , making d e b u g g i n g e a s i e r .
unsigned portBASE_TYPE uxTCBNumber ;
# endif
# if ( co nfi gUS E_M UT EX E S == 1 )
: : The p r i o r i t y l a s t a s s i g n e d t o t h e t a s k , used by t h e p r i o r i t y
: : i n h e r i t a n c e mechanism .
unsigned portBASE_TYPE uxBas ePrior ity ;
# endif
...
# if ( c o n f i g G E N E R A T E _ R U N _ T I M E _ S T A T S == 1 )
: : Used f o r c a l c u l a t i n g how much CPU t i m e each t a s k i s u t i l i z i n g .
unsigned long ulRun T i m e C o u n t e r ;
# endif
} tskTCB ;
FreeRTOS
N
14 / 34
Tasks Task Details
Implementing a Task
Source/include/projdefs.h
/* Defines the prototype to which task functions must conform . */
typedef void (* pdTASK_CODE )( void * );
void vATaskFunction ( void * pvParameters ){

for ( ;; ){
: : Task a p p l i c a t i o n code h e r e .
}
}
Tasks are always a function that returns void and takes a void pointer.
Tasks should never return (loop forever).
Not much to it, really.
FreeRTOS
N
15 / 34
Tasks Task Details
Creating a Task (0/3)

The kernel creates a task by instantiating and populating a TCB. New
tasks are placed in the Ready state and added to the Ready list.
If the task is the highest priority task, then it is set as the currently
running task.
Created by calling xTaskCreate() and deleted by calling
vTaskDelete().
xTaskCreate() takes the following parameters.
A pointer to the function that implements the task (type pdTASK_CODE from
earlier).
A name for the task.
The depth of the tasks stack.
The tasks priority.
A pointer to any parameters needed by the tasks function.
FreeRTOS
N
16 / 34
Tasks Task Details
An interesting step in task creation is preparing the task for its first
context switch.
The TCB stack is initialized 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 with pxPortInitialiseStack.
See code on next slide.
FreeRTOS
N
17 / 34
Tasks Task Details

Source/portable/GCC/ATMega323.c (edited)
port STACK_TYPE * p x P o r t I n i t i a l i s e S t a c k ( por tSTACK _TYPE * pxTopOfStack ,
pdTASK_CODE pxCode , void * pvParameters )
{
: : P l a c e some known v a l u e s on bottom o f s t a c k , f o r d e b u g g i n g .
* pxTopOfStack = 0 x11 ;
pxTopOfStack - -;
* pxTopOfStack = 0 x22 ;
pxTopOfStack - -;
...
: : S t a r t o f t a s k code w i l l be popped o f f l a s t , so push i t on f i r s t .
unsigned short usAddress = ( unsigned short ) pxCode ;
* pxTopOfStack =
( portSTACK_TYPE ) ( usAddress & ( unsigned short ) 0 x00ff );
pxTopOfStack - -;
usAddress > >= 8;
* pxTopOfStack =
( portSTACK_TYPE ) ( usAddress & ( unsigned short ) 0 x00ff );
pxTopOfStack - -;
: : And t h e n push v a l u e s f o r CPU r e g i s t e r s , t a k i n g i n t o a c c o u n t
: : what t h e c o m p i l e r e x p e c t s f o r t h i s a r c h i t e c t u r e .
...
FreeRTOS
N
18 / 34
Outline
1
Introduction
About FreeRTOS
Kernel Overview
Tasks
Task Details

Queues
Scheduler
Scheduler Code
FreeRTOS
N
19 / 34
IPC and Synchronization Queues
Queue Overview
Queues are the primary form of inter-task communications.

They can send messages between tasks as well as between interrupts and
tasks.
Supports appending data to the back of a queue, or sending data to the
head of a queue.
Queues can hold arbitrary items of a fixed size.
The size of each item and the capacity of the queue are defined when the
queue is created.
Items are enqueued by copy, not reference.
FreeRTOS
N
20 / 34
IPC and Synchronization Queues
Queues and Blocking
Access to queues is either blocking or non-blocking.

The scheduler blocks tasks when they attempt to read from or write to a
queue that is either empty of full, respectively.
If the xTicksToWait variable is zero and the queue is empty (full), the
task does not block. Otherwise, the task will block for xTicksToWait
scheduler ticks or until an event on the queue frees up the resource.
This includes attempts to obtain semaphores, since they are special cases
of queues.
FreeRTOS
N
21 / 34
IPC and Synchronization Semaphores and Mutexes
Binary Semaphores
Used for both mutual exclusion and synchronization.
Commonly used by Interrupt Service Routines (ISRs) to wake tasks and
avoid polling. Consider the following example.
Example: waking a task from an ISR
FreeRTOS
N
22 / 34
Binary Semaphores

1
A binary semaphore is created along with a task that blocks on this

semaphore.
FreeRTOS
N
22 / 34
Binary Semaphores

1

semaphore.
An ISR is written for a peripheral that sets the semaphore when the
peripheral requires servicing using xSemaphoreGiveFromISR().
FreeRTOS
N
22 / 34
Binary Semaphores

1

semaphore.
An ISR is written for a peripheral that sets the semaphore when the
peripheral requires servicing using xSemaphoreGiveFromISR().
This awakens the task waiting on this semaphore. The task resets the
semaphore, does some work, and then blocks again.
FreeRTOS
N
22 / 34
Counting Semaphores and Mutexes

Counting Semaphores
FreeRTOS has support for counting semaphores, the standard down
and up (wait and signal) operations.
Semaphores are macros defined over the queue API. Therefore,
semaphores use the same API calls as queues do.
FreeRTOS
N
23 / 34

Counting Semaphores
Mutexes
FreeRTOS supports mutexes (binary semaphores with priority
inheritance).
As mutexes use the semaphore API, they also support the blocking
timeout mechanism. Moreover, they are implemented using the queue
API calls.
FreeRTOS
N
23 / 34

Counting Semaphores
Mutexes
FreeRTOS supports mutexes (binary semaphores with priority
inheritance).
As mutexes use the semaphore API, they also support the blocking
timeout mechanism. Moreover, they are implemented using the queue
API calls.
The queue data strictures are protected from corruption by disabling
interrupts in some places and disabling the scheduler in others where
it would be okay for an interrupt to occur, but not for another task to
preempt the queuing task.
FreeRTOS
N
23 / 34
Scheduler
Outline
1
Introduction
About FreeRTOS
Kernel Overview
Tasks
Task Details

Queues
Scheduler
Scheduler Code
FreeRTOS
N
24 / 34
Scheduler Scheduler Background
General Scheduler Operation
As mentioned, the scheduler can be co-operative or preemptive.

The scheduler is an interrupt handler activated on each tick of hardware
clock. Therefore, it contains hardware specific code.
The ready list is arranged in order of priority with tasks of equal priority
being served on a round-robin basis.
The scheduler starts with the highest priority list and works its way
downward.
There is no explicit Running list or state. The kernel maintains
pxCurrentTCB to identify the process in the Ready list that is currently
running.
FreeRTOS
N
25 / 34
Performing a Context Switch (0/2)

The scheduler first resets the
counter timer.
vPortTickInterupt()
Stack GCC Soft Registers
Without preemption enabled, the

timer interrupt simply increments
the tick count and returns.
Reset Timer
Preemption or Co-op?
Preemption
Save Context
Co-op
Increment Tick Count

vTaskIncrementTick()
Check for Context

Switch
Restore Context
Un-Stack GCC Soft Registers
Return
FreeRTOS
N
26 / 34
Performing a Context Switch (1/2)

If the scheduler is preemptive, the
scheduler pushes the current task
context on the stack.
vPortTickInterupt()
Stack GCC Soft Registers
Then it increments the tick count

and checks to see if this action has
caused a blocked task to unblock.
If a task of higher priority
unblocked, then a context switch is
executed.
Context is restored.
The scheduler returns, potentially
starting the execution of a different
task than the one that was
interrupted.
Reset Timer
Preemption or Co-op?
Preemption
Save Context
Co-op

Check for Context

Switch
Restore Context
Un-Stack GCC Soft Registers
Return
FreeRTOS
N
27 / 34
Scheduler Scheduler Code
ISR for Ticks (0/2)

Source/portable/GCC/ATMega323/port.c (edited)
# if c o n f i g U S E _ P R E E M P T I O N == 1
void S I G _ O U T P U T _ C O M P A R E 1 A ( void
v P o r tY i el d Fr o mT i ck ();
asm volatile ( " reti " );
}
# else
v T a s kI n cr e me n tT i ck ();
}
) __attribute__ (( signal , naked ));

){
) __attribute__ ( ( signal ) );
) {
Explanation on next slide.
FreeRTOS
N
28 / 34
ISR for Ticks (1/2)

# if c o n f i g U S E _ P R E E M P T I O N == 1
void S I G _ O U T P U T _ C O M P A R E 1 A ( void ) __attribute__ (( signal , naked ));
...
The signal attribute informs GCC the function is an ISR, which means
GCC saves and restores every register the ISR modifies and the return
uses reti instead of ret. The AVR microcontroller disables interrupts
upon entering an ISR, and reti is required to re-enable them.
But FreeRTOS saves registers, so naked is used so that GCC wont
generate any function entry or exit code. Macros portSAVE_CONTEXT()
and portRESTORE_CONTEXT() save and restore the execution context.
FreeRTOS
N
29 / 34
The Context Saving Macro (0/2)

# define portSAVE_CONTEX T ()
\
asm volatile ( " push r0
\n\t" \
: : Save r e g i s t e r r 0 .
" in
r0 , __SREG__
\ n \ t " \ : : See ( 1 ) below .
" cli
\n\t" \
: : Disable interrupts .
" push r0
\n\t" \
: : Save p r o c e s s o r s t a t u s .
" push r1
\n\t" \
: : Save o r i g i n a l r 1 v a l u e .
" clr r1
\n\t" \
: : See ( 2 ) below .
" push r2
\n\t" \
: : Save r 3 t h r o u g h r 3 0 .
...
" push r31
\n\t" \
...
Before the microcontroller jumps to an ISR, it pushes the PC onto the

stack, which is why this is not done here.
Move processor status register to r0.
The instruction clr r1 sets r1 to zero, because the GCC generated ISR
expects it to be zero.
Continued on next slide.

FreeRTOS
N
30 / 34
The Context Saving Macro (1/2)

...
" push
" lds
" lds
" in
" st
" in
" st
r31
\n\t" \
r26 , pxCurrentTCB
\n\t" \
: : See ( 1 ) .
r27 , pxCurrentTCB + 1 \ n \ t " \
r0 , 0 x3d
\n\t" \
: : (2)
x + , r0
\n\t" \
r0 , 0 x3e
\n\t" \
: : (3)
x + , r0
\n\t" \
);
The X register allows data indirect addressing with pre-decrement. r26 is

X low byte, 27 the high byte. The X processor register is loaded with the
address to which the stack pointer is to be saved.
Save stack pointer low byte.
Save stack pointer high nibble.
This is the reason struct tskTCBs first member must be

portSTACK_TYPE *pxTopOfStack.
FreeRTOS
N
31 / 34
Incrementing the Tick (0/2)

Source/task.c (edited)
void v T a s kI n cr e me n tT i ck ( void ){
if ( u x S c h e d u l e r S u s p e n d e d == ( unsigned portBASE_TYPE ) pdFALSE ){
: : I n t h i s c a s e , t h e s c h e d u l e r not s u s p e n d e d .
++ xTickCount ; : : I n c r e m e n t t i c k s .
if ( xTickCount == ( portTickType ) 0 ) {
xList * pxTemp ;
/*
Tick count has overflowed so we need to swap the delay lists .
If there are any items in p x D e l a y e d T a s k L i s t here then there is
an error !
*/
pxTemp = pxD el aye d T a s k L i s t ;
p x Del aye dTa sk Lis t = p x O v e r f l o w D e l a y e d T a s k L i s t ;
p x O v e r f l o w D e l a y e d T a s k L i s t = pxTemp ;
x NumOfOverflows ++;
}
p r v C h e c k D e l a y e d T a s k s (); : : Has t i c k made a t i m e o u t e x p i r e ?
} else {
...
FreeRTOS
N
32 / 34
Incrementing the Tick (1/2)

Source/task.c (edited)
...
} else {
++ uxMissedTicks ; : : S c h e d u l e r i s suspended , so we m i s s e d a t i c k .
: : The t i c k hook g e t s c a l l e d a t r e g u l a r i n t e r v a l s , even i f t h e
: : scheduler i s locked .
# if ( co n f i g U S E _ T I C K _ H O O K == 1 ){
extern void v A p p l i c a t i o n T i c k H o o k ( void );
v A p p l i c a t i o n T i c k H o o k ();
}
# endif
}
# if ( c on f i g U S E _ T I C K _ H O O K == 1 ){
extern void v A p p l i c a t i o n T i c k H o o k ( void );
/* Guard against the tick hook being called when the missed tick
count is being unwound ( scheduler is being unlocked ). */
if ( uxMissedTicks == 0 )
v A p p l i c a t i o n T i c k H o o k ();
}
# endif
...
FreeRTOS
N
33 / 34
References
FreeRTOS website: www.FreeRTOS.org

Atmel AVR Instruction Set Guide
www.Atmel.com/ateml/acrobat/doc0856.pdf
FreeRTOS
34 / 34
N

Freertos Proj

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Freertos Proj

Uploaded by

Copyright:

Available Formats

FreeRTOS

IPC and Synchronization

Introduction About FreeRTOS

Introduction About FreeRTOS

Licensing Information (0/2)

Introduction About FreeRTOS

Licensing Information (1/2)

link to FreeRTOS.org is sufficient.

Introduction Kernel Overview

IPC and Synchronization

Tasks Tasks versus Co-Routines

Tasks have their own context. No dependency on other tasks unless

Tasks Tasks versus Co-Routines

Will examine tasks in more detail, but not co-routines.

Tasks Task Details

Tasks Task Details

Each task gets a priority from 0 to configMAX_PRIORITIES 1

Tasks Task Details

The Idle Task

The idle task is created automatically when the scheduler is started.

Tasks Task Details

The Idle Task

The idle task is created automatically when the scheduler is started.

Tasks Task Details

The Idle Task

The idle task is created automatically when the scheduler is started.

Tasks Task Details

The Idle Task

The idle task is created automatically when the scheduler is started.

Tasks Task Details

Task Control Block (TCB) (0/2)

Tasks Task Details

Task Control Block (TCB) (1/2)

Tasks Task Details

void vATaskFunction ( void * pvParameters ){

Tasks Task Details

Creating a Task (0/3)

Tasks Task Details

Creating a Task (1/3)

Tasks Task Details

Creating a Task (2/3)

IPC and Synchronization

IPC and Synchronization

IPC and Synchronization Queues

Queues are the primary form of inter-task communications.

IPC and Synchronization Queues

Queues and Blocking

Access to queues is either blocking or non-blocking.

IPC and Synchronization Semaphores and Mutexes

Example: waking a task from an ISR

IPC and Synchronization Semaphores and Mutexes

Example: waking a task from an ISR

A binary semaphore is created along with a task that blocks on this

IPC and Synchronization Semaphores and Mutexes

Example: waking a task from an ISR

A binary semaphore is created along with a task that blocks on this

IPC and Synchronization Semaphores and Mutexes

Example: waking a task from an ISR

A binary semaphore is created along with a task that blocks on this

IPC and Synchronization Semaphores and Mutexes

Counting Semaphores and Mutexes

IPC and Synchronization Semaphores and Mutexes

Counting Semaphores and Mutexes

) attribute (( signal , naked ));