Transcript RTOS use in microcontrollers

Evolution of
Microcontroller
Firmware Development
David Benjamin
Overview
 Traditional microcontroller firmware


Polling
Interrupts
 Real-time Operating Systems
 Demonstration
Polling
 Polling is when a process continually
evaluates the status of a register in an
effort to synchronize program execution.
 Polling is not widely used because it is
an inefficient use of microcontroller
resources.
Polling Example
void main ( void )
{
while(1)
{
while (!button1_pressed);
turn_on_led;
while (!button1_pressed);
turn_off_led;
}
}
Interrupts
 Interrupt as defined by Merriam Webster

to break in upon an action
 Interrupt

An event that causes the Program Counter (PC) to
change. These events can be internal or external.
 Interrupt Service Routine (ISR)

Set of instructions that is executed when an
interrupt occurs
 Interrupt Vector

Memory address of the first instruction in the ISR.
Interrupts
 Why should one use interrupts?


Provides more efficient use of
microcontroller resources.
Provides a means to create firmware that
can “multi-task”.
Interrupts
 Interrupts are often prioritized within the system and are
associated with a variety of on-chip and off-chip
peripherals

Timers, A/D D/A converters, UART, GP I/O
 A majority of the mC interrupts can be enabled or
disabled.



Globally
Individually
Those interrupts that cannot be disabled are called NonMaskable Interrupts (NMI).
 Interrupts can be nested.
 Interrupts can occur at anyplace, at anytime.

ISRs should be kept short and fast.
What happens when
an interrupt occurs?
Interrupts
PC = 0x8A3
0x08A2
0x0FE0
XXX
0x08A3
SR = 0xFE
0x7E
XXX
0xFE
STACK

The current program instruction
completes execution.

The PC and status register values
are placed on the stack.

The interrupt vector is loaded into
the PC and SR is updated.

Program execution resumes with the
first step of the ISR.

When the ISR has completed
execution, the values of the PC and
status registers are restored.

Program execution resumes with
next instruction that would have
occurred had the interrupt not taken
place.
Main()
{
…
some code
turn_on_led1;
turn_off_led1;
…
}
__interrupt void port1_ISR(void)
{
disable_interrupts
...
reti
}
0x08A2
0x08A3
0x0FE0
Interrupts vs. Polling
 Allowed for more efficient use of the
microcontroller.


Faster program execution
Multi-tasking
 Facilitated the development of complex
firmware.

Supports a modular approach to firmware
design.
Real-time Operating
Systems
Real-time Operating System
 A real-time operating system (RTOS) is a
multi-tasking operating system intended
for real-time applications.




Mainly used in embedded applications.
Facilitates the creation of a real-time
system.
Tool for the real-time software developer.
Provides a layer abstraction between the
hardware and software.
Real-time Operating System
 State

A unique operating condition of the system.
 Task

A single thread of execution through a group of
related states.
 Task Manager


Responsible for maintaining the current state of
each task.
Responsible for providing each task with execution
time.
Real-time Operating System
Initial State
Collection of Tasks…
Idle State
Single Task
Work State 1
Work State 3
Work State 2
Work State 4
Completion
State
Real-time Operating System
 A more detailed explanation state

A function
void idleState ( void );


Should be kept short and fast
Should represent a logical step in the task
 i.e.
Evaluating different parts of an incoming
message.
Real-time Operating System
void idleState( void )
{
if (rx_buffer_full)
{
read_rxBuffer;
if (syncByte_received)
{
transition_to_workState1;
}
else
{
stay_in_idleState;
}
}
else
{
stay_in_idleState;
}
}
Initial State
Idle State
Work State 1
Work State 3
Work State 2
Work State 4
Completion
State
Real-time Operating System
 Event-driven


Tasks are granted
execution time, based on
an event (interrupt).
Tasks of higher priority are
executed first (interrupt
priorities).
 Time sharing




Each task is granted a given
amount of time to execute.
Tasks may also be granted
execution time based on
events.
“Round-robin” approach
Creates a more deterministic
multi-tasking system.
Real-time Operating Systems
void main ( void )
{
initSystem();
while (1)
{
work();
sleep();
}
}
void work (void)
{
doTask(RecieveMsg);
doTask(Process);
doTask(TransmittResponse);
}
__interrupt void Timer_A (void)
{
wakeUp();
}
Receive Msg
Process
Transmitt Response
Initial State
Initial State
Initial State
State2
State2
State2
State2
State2
State2
State2
State2
State2
State2
State2
State2
Real-time Operating System
 Available commercially




TinyOS -an open source component-based
operating system and platform targeting wireless
sensor networks (WSNs).
Salvo - an RTOS developed by Pumpkin Inc.
FreeRTOS - free RTOS that runs on several
architectures.
DrRTOS - works with ARM 7
 Implement a custom RTOS

Can be highly optimized to suit your application
Real-time Operating Systems
 A tool for real-time software developers.
 Allows increasingly complex systems to
be developed in less time.
 Provides a level abstraction between
software and hardware.
 Continues the evolution microcontroller
system design.
Example Implementation

Example of RTOS application that
requires wireless communication.

Hardware abstraction layer for
the radio. Performs low-level
interaction between mC and
radio.

Groups low-level interactions
from the HAL into higher-level
functions.



Sending a packet
Middle-ware that provides a
gateway between the application
and RTOS.
Application
Application
Application
Protocol
Radio Operation Layer
CC1100 HAL
Demonstration
Questions?