RTOS Fundamentals

1326 RTF 

RTOS Fundamentals 

© 2009 Microchip Technology Incorporated. All Rights Reserved. 1326 RTF Slide 1

Objectives 

When you finish this class you will 

know: 

- The terminology used in the RTOS world 

- What functions an RTOS provides and 

how it affects your programming style 

- What factors to consider when choosing 

an RTOS for your next project 


Agenda 

When is an RTOS appropriate? 

RTOS Introduction 

- Concepts 

Terminology 

- Operation 

- Terminology 

Techniques 

Demonstrations 

- Demonstrations 

Current Support 

How to choose 

- Factors influencing your decision 


When is an RTOS appropriate? 


Why an RTOS? 

Efficient Resource Management 

- 4 UARTs, 3 SPI, 3 I 2C, , CTMU, USB 

(Device/Host/OTG), Ethernet, CAN…. CAN 

Deterministic behavior 

- Provable real-time real time response 

Rapid application development 

- Commercial RTOS provides well tested platform 

- Popular RTOS provides large pool of knowledge 

Structured Design and System Management 

- Software re-use re use 

- CASE Tools 

- System Profiling 


Software Management 

- Stacks 

Why an RTOS? 

Stacks 

- USB ~40k 

- ZigBee ® ~40k 

- Ethernet ~85k 

- QVGA ~50k 

- Timing 

- Liberating time for multiple tasks 

Interoperability 

- Third party software 

- lwIP 

- Compliance Testing 

- OSEK, AutoSAR 


Concepts and Terminology 

Pre-emption 

Pre emption 

Multitasking 

Hard Real-Time 

Real Time 

Priority Inversion 

Re-entrancy 

Re entrancy 

Task 

Soft Real-Time 

Real Time 

Co-operative Co operative Multitasking 

Deterministic 

Mailbox 

Priority Inheritance 

Round-Robin 

Round Robin 

Livelock 

Thread 

Mutex 

Context Switch 

Deadlock 

Queue 

Semaphore 


Concepts 


Task 

A group of instructions that execute to solve a 

portion of a problem 

A “problem problem” could be: 

- Design of a dishwasher system 

A “task task” for such system can be: 

- Manage water level 

- Manage motor speed 

A single task ‘thinks thinks’ that it has the CPU available 

all the time 


Water 

Level 

Manager 

Door 

Manager 

Dishwasher System 

Button 

Manager 

Cycle 

Selection 

Manager 

Manage 

Motor 

Speed 


What is it? 

Multitasking 

- Ability to do many things at once 

- Drink coffee, talk on cell-phone, cell phone, drive, switch lane 

- ‘Manage Manage water level’ level and ‘Manage Manage motor speed’ speed 

Tasks can be created and deleted at run-time run 

time 

- Typically fixed number of tasks at compile time 

Typically fixed number of tasks at compile time 

- Sometimes extra tasks automatically created 

User Issues: 

- Resource sharing 

- CPU, Memory, I/O, etc. 

- Synchronization 

- Inter-task Inter task communication 


RTOS Related Task Calls 

Create – to create a new task 

Start – some RTOS require starting a task after creation 

- Start 

Delete – to delete a task 

- RTOS may not release some system memory 

- Less common in embedded systems 

Suspend – to wait execution 

Resume – to resume execution 

Change Priority – to dynamically change task 

priority 


What is it? 

- Multi 

Scheduling 

Multi-tasking tasking requires all tasks get scheduled to run on 

CPU according to some pre-determined pre determined scheme 

Types of Scheduling: 

- Co-operative, Co operative, Pre-emptive 

Pre emptive 

- Typical Real Time System Uses Pre-emptive 

Pre emptive 

- Round-robin, Round robin, Deadline Monotonic, Least Slack-Time 

Slack Time 

etc. 

Issues: 

- Task Dead-lines Dead lines 

- Missed dead-lines dead lines may have severe consequences 

- Context Switch Time 


Real-time Real time 

Scheduling Tasks 

- Does not always mean ‘fast fast’ 

- Tasks must be written to obtain best 

predictable response 

Soft Real-time Real time 

- Tasks will generally run on-time on time 

- Little effect if tasks are delayed 

Hard Real-time Real time 

- Tasks must be allowed to run on-time on time 

- Serious problems if task execution is 

delayed 


Co-Operative Co Operative Multitasking 

Tasks execute until they pause or yield 

- Must be written to explicitly yield 

System performance can be optimised 

Tasks can be given priorities 

while (1) { 

x = x + 1; 

for(i=0;i

Pre-emptive Pre emptive Multitasking 

Tasks are swapped either voluntarily or 

automatically by the RTOS 

Tasks normally selected based upon priority 

while (1) { 

for(i=0;i

Priority 

Real-time Real time systems are hierarchical 

Each task gets to execute according to 

pre-determined 

pre determined-priority priority 

- Priority determines right to run on CPU 

Priorities can be dynamically changed 

Truly deterministic real-time real time systems assign 

different priority to each task 

Round-robin robin for equal priorities 

- Round 


Round-Robin Round Robin Scheduling 

Each task is given a fixed time to execute 

- Must be written accordingly 

The scheduler runs each task in turn 

while(1) { 

} 

switch(x) { 

} 

case 0: … 

break; 

case 1: … 

break; 

Task 1 

Scheduler 

while(1) { 

} 

switch(x) { 

} 

case 0: … 

© 2009 Microchip Technology Incorporated. All Rights Reserved. 1326 RTF Slide 18 

break; 

case 1: … 

break; 

Task 2 

while(1) { 

} 

switch(x) { 

} 

case 0: … 

break; 

case 1: … 

break; 

Task 3

Priority 

t0 

Multi-tasking 

Starts 

Priority Based Pre-Emptive 

Pre Emptive 

Multi-Tasking 

Multi Tasking 

HP, MP and LP are READY at time t0 

HP Runs 

MP Ready 

HP Wait 

MP Runs 

LP Ready LP Ready 

t1 

HP Waits for 

Event 

HP Wait HP Runs HP Wait 

MP Dormant MP Dormant MP Dormant 

LP Runs 

t2 

MP Finishes 

LP Runs 

LP Pre-empted 

& Ready 

t3 

Event HP 

was waiting 

for occurs 

LP Runs 

HP = Highest Priority Task, MP = Medium Priority Task, LP = Lowest Priority Task 

t4 

HP waits for Resource 

LP Runs 


Time

Life of a Task 

Interrupt 

Running 

Dormant 

Interrupt 

Return 

Scheduler Pend 

Delete 

Scheduler 

TCB and Stack Allocated 

Create 


Post 

Delete 

Delete 

RTOS

Context Switches 

During a yield or pre-emption pre emption the task pushes the processor 

state 

The RTOS determines the next task to run 

The processor state is popped 

The next task runs 

PC 

PSVPAG 

w0-w15 

SR 

char buff[2]; 

double y; 

int x; 

Task 1 

? 

PC 

PSVPAG 

w0-w15 

SR 

char ledState; 

int count; 

Task 2 


#define portSAVE_CONTEXT() \ 

asm volatile( "PUSH SR \n“ \ 

"PUSH W0 \n“ \ 

"MOV #32, W0 \n“ \ /*disable INTs*/ 

"MOV W0, SR \n“ \ 


"PUSH.D W2 \n“ \ 




"PUSH.D W10 \n“ \ 

"PUSH.D W12 \n“ \ 

"PUSH W14 \n“ \ 

"PUSH RCOUNT \n“ \ 

"PUSH TBLPAG \n“ \ 

"PUSH CORCON \n“ \ 

"PUSH PSVPAG \n“ \ 

"MOV _uxCriticalNesting, W0 \n“ \ 


"MOV _pxCurrentTCB, W0 \n“ \ 

"MOV W15, [W0] "); 

Example PIC24F 

#define portRESTORE_CONTEXT() \ 

asm volatile("MOV _pxCurrentTCB, W0 \n“ \ 

"MOV [W0], W15 \n“ \ 

"POP W0 \n“ \ 

"MOV W0, _uxCriticalNesting \n“ \ 

"POP PSVPAG \n“ \ 

"POP CORCON \n“ \ 

"POP TBLPAG \n“ \ 

"POP RCOUNT \n“ \ 

"POP W14 \n“ \ 

"POP.D W12 \n“ \ 

"POP.D W10 \n“ \ 

"POP.D W8 \n“ \ 

"POP.D W6 \n“ \ 

"POP.D W4 \n“ \ 

"POP.D W2 \n“ \ 

"POP.D W0 \n“ \ 

"POP SR " ); 


Demo concepts: 

- Task Creation 

- Multi-tasking 

Multi tasking 

Demo 1 


Terminology 


Memory Management 

Typical RTOSs provide memory allocation 

facilities 

- Frequently fixed block scheme 

- Deterministic service calls 

- Avoid memory fragmentation 

RTOS System Calls for Memory Allocation 

- Allocate –allocate allocate a block from memory 

- Free –release release a block of memory 

- Query –query query fixed block size, number of 

available blocks, etc. in a memory area 


Events are signals to a task 

Events 

- That effect the execution of a task 

- Typically come from outside the task 

- Can be combinatorial 

External hardware events 

- Water level full in dishwasher 

- Hardware pushbutton pressed 

Software events 

- Another task has completed its operation 

- Signal from an ISR 


Message Queue 

Standard method for inter-task inter task 

communication 

- Queue is allocated storage 

- Definable size and number of entries 

- May contain data or pointers 

Tasks can add messages 

- Many tasks can write 

Tasks can pend on the queue 


What is it? 

Mailbox 

- Method to send ‘pointer pointer’ sized asynchronous data 

between tasks 

- Often implemented as a simple queue 

Tasks must agree on what ‘pointer pointer’ points to 

Multiple tasks can wait on a message to be posted 

- Highest priority task wins in retrieving message 

Multiple tasks can post a message 

- Only one message can be present in the mailbox at any 

time 


Semaphore 

Semaphores are used for synchronization 

- A flag that can only be modified atomically 

- Protect Critical Section, Resource Management, Synchronization 

Two types of Semaphores: 

- Binary – A value of 0 or 1 

- Counting – non-negative non negative integer value 

- Zero 

- Another task is in specific critical section 

- Resource is busy 

- Non-zero Non zero 

- You can enter critical section of code 

- Resource is available 

Issues: ssues: 

- Priority Inversion 


Mutex 

Prevents conflicting access to common resource 

- Hardware Registers 

- Peripherals 

- Data structures 

The same as binary semaphore 

Mutexes can lead to deadlocks occurring 

RTOS provide priority inheritance to overcome 

problem of priority inversion 

- Mutex may have inheritance 


Deadlocks 

Each task waits for the other to release the 

mutex 

- Neither completes 

Thread A 

Owns Mutex X 

Waits on Mutex Y 

Mutex X 

Mutex Y 

Thread B 

Waits on Mutex X 

Owns Mutex Y 


What is it? 


- When a lower priority task holds a resource that a 

higher priority task needs, the higher priority task must 

wait (as if it were a lower priority task) until the lower 

priority task releases the resource. 

- In such scenario, the lower priority task executes as if it 

has higher priority. 

Problem typically encountered in dealing with 

RTOS service like Semaphore 

Can be solved by Priority Inheritance 

- Not always the best solution, design it out! 


Priority 

LP Running at t0 

LP Runs 

t0 

LP 

gets 

Sem1 

HP Runs 

LP Ready 

t1 

HP 

created, 

LP ready 


HP Wait 

LP Runs 

t2 

HP waits 

for Sem1, 

LP runs 

HP Wait 

MP Runs 

LP Ready 

t3 

MP 

created, 

LP ready 

HP Wait 

MP Dormant 

LP Runs 

t4 

MP 

finishes, 

LP runs 

HP Runs 

MP Dormant 

LP Ready 

t5 

LP puts 

Sem1, 

HP runs 

HP = Highest Priority Task, MP = Medium Priority Task, LP = Lowest Priority Task 


Time

Examples 


Compile Time: 

RTOS Configuration 

- Configuration header file 

- Enable or disable OS services 

- Maximums: semaphores, mutex, message queues 

- Enable OS debug and statistic gathering facilities 

Run Time: 

- Hardware specific initialization (BSP) 

- Data structure initialization 

- Initialization of resource managers 

- Task creation, Memory allocations, Link-List Link List creations 

- Initialization of inter-task inter task messaging 

- Enter Multi-tasking 

Multi tasking 


Example Configuration 

#define configUSE_PREEMPTION 1 

#define configUSE_IDLE_HOOK 0 

#define configUSE_TICK_HOOK 0 

#define configTICK_RATE_HZ ( 1000 ) 

#define configCPU_CLOCK_HZ ( 80000000UL 80000000UL ) 

#define configPERIPHERAL_CLOCK_HZ ( 40000000UL 40000000UL ) 

#define configMAX_PRIORITIES ( 5 ) 

#define configMINIMAL_STACK_SIZE ( 200 ) 

#define configTOTAL_HEAP_SIZE ( 28000 ) 

#define configMAX_TASK_NAME_LEN ( 8 ) 

#define configUSE_TRACE_FACILITY 0 

#define configUSE_16_BIT_TICKS 0 

#define configIDLE_SHOULD_YIELD 1 

#define configUSE_MUTEXES 1 

/* Set the following definitions to 1 to include the API function, function, 

or zero to exclude the API function. */ 

#define INCLUDE_vTaskPrioritySet 1 

#define INCLUDE_uxTaskPriorityGet 1 

#define INCLUDE_vTaskDelete 0 

#define INCLUDE_vTaskCleanUpResources 0 

#define INCLUDE_vTaskSuspend 1 

#define INCLUDE_vTaskDelayUntil 1 

#define INCLUDE_vTaskDelay 1 

#define INCLUDE_uxTaskGetStackHighWaterMark 1 

/* The priority at which the tick interrupt runs. This should probably probably 

be kept at 1. */ 

#define configKERNEL_INTERRUPT_PRIORITY 0x01 


Inter-task Inter task 

Communication 

Information passed between tasks; and 

between tasks and ISRs 

Two ways to perform inter-task inter task 

communication: 

- Global memory and semaphore or mutex 

- Mail-box Mail box and Message Queues 


Demo Concepts 

- Inter-task Inter task 

Communication 

- Message Queues 

Demo 2 


What is it? 

Critical Sections 

- A sequence of code that must execute 

atomically 

- E.g. update system data-structures 

data structures 

Semaphores and Mutexes used to guard 

Critical Sections 

Locking interrupts (or scheduler) may be 

desirable 

- If manipulating only one variable or so 

- Less OS overhead 

- This may degenerate Interrupt Response 


Demo Concepts 

- Critical Sections 

- Semaphore 

- Note Critical Section in 

task creation code 

- Note atomic action in 

parallel port code 

- PIC32 version does not 

use critical section 

Demo 3 


Current 3 rd Party Support 


Vendor/RTOS 

AVIX-RT 2.5 

CMX 5.30 

DSPNano 

Unison 

embOS V3.52 

Product 

ThreadX G5.1.5.0 

FreeRTOS v5.2.0 

µC/OS-II v2.84 

Salvo 4 Pro and 

Salvo 4 LE 

RTOS Vendors 

MPLAB® 

Plug-in 

Yes 

Yes 

Yes 

Yes 

Yes 

No 

No 

Yes 

16/32 

8/16/32 

16/32 

16/32 

8/16/32 

8/16/32 

16/32 

DSP, TCP/IP, POSIX 

GUI, TCP/IP 


16 

32 

Microchip 

16/32 Ports 

TCP/IP 

TCP/IP 

Modules/ Support

RTOS Vendor Websites 

AVIX: http://www.avix-rt.com 

http://www.avix rt.com/ 

CMX: http://www.cmx.com/ 

Express Logic: http://www.rtos.com/ 

FreeRTOS: http://www.freertos.org/ 

Micrium: http://www.micrium.com/ 

Pumpkin: http://www.pumpkininc.com/ 

RoweBots: RoweBots: 

http://www.rowebots.com/ 

Segger: http://www.segger.com/ 


How to Choose 


Many factors: 

Factors influencing 

- Context Switch Time 

- RTOS Service Call Performance 

- Interrupt Response Time 

- Highest Priority Interrupt Response Time 

- Scheduling Algorithms 

Tools and Middleware Integration 

- Additional libraries for TCP/IP, DSP, Graphics 

Business Model 

- Freeware, Open source, Support, License, Royalties 

- Reliability and user base 


The Numbers Game 

Some RTOS vendors have done testing on 

Context switch time, Size, Interrupt response 

time, etc. 

However, few numbers are officially released 

Like-for for-like like comparisons can be difficult 

- Like 

It is very difficult to recommend one product 

- Much depends on the application 

- Users should expect to perform some tests 


We discussed: 

Summary 

- Where an RTOS is useful 

- The basic concepts behind an RTOS 

- The terminology used 

- Several demonstrations 

What to think about when selecting an RTOS 

Please attend classes 1327 MRT, 1328 THR and 

1329 CAR for a more detailed and hands-on hands on look 


Questions ? 


Trademarks 

The Microchip name and logo, the Microchip logo, dsPIC, KeeLoq, KeeLoq logo, MPLAB, 

PIC, PICmicro, PICSTART, rfPIC and UNI/O are registered trademarks of Microchip 

Technology Incorporated in the U.S.A. and other countries. 

FilterLab, Hampshire, HI-TECH C, Linear Active Thermistor, MXDEV, MXLAB, SEEVAL 

and The Embedded Control Solutions Company are registered trademarks of Microchip 

Technology Incorporated in the U.S.A. 

Analog-for-the-Digital Age, Application Maestro, CodeGuard, dsPICDEM, dsPICDEM.net, 

dsPICworks, dsSPEAK, ECAN, ECONOMONITOR, FanSense, HI-TIDE, In-Circuit Serial 

Programming, ICSP, ICEPIC, Mindi, MiWi, MPASM, MPLAB Certified logo, MPLIB, 

MPLINK, mTouch, nanoWatt XLP, Omniscient Code Generation, PICC, PICC-18, PICkit, 

PICDEM, PICDEM.net, PICtail, PIC32 logo, REAL ICE, rfLAB, Select Mode, Total 

Endurance, TSHARC, WiperLock and ZENA are trademarks of Microchip Technology 

Incorporated in the U.S.A. and other countries. 

SQTP is a service mark of Microchip Technology Incorporated in the U.S.A. 

All other trademarks mentioned herein are property of their respective companies. 

© 2009, Microchip Technology Incorporated, Printed in the U.S.A., All Rights Reserved.

RTOS Fundamentals

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?