RTOS use in microcontrollers

canolaokahumpkaElectronics - Devices

Nov 2, 2013 (3 years and 10 months ago)

93 views

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
m
C interrupts can be enabled or
disabled.


Globally


Individually


Those interrupts that cannot be disabled are called Non
-
Maskable 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


The current program instruction
completes execution.

Main()

{





some code




turn_on_led1;


0x08A2


turn_off_led1;


0x08A3




}


__interrupt void port1_ISR(void)

{


disable_interrupts


0x0FE0


...


reti

}




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.

PC = 0x08A2

SR = 0xFE

PC = 0x0FE0

SR = 0x7E

PC = 0x8A3

SR = 0xFE

XXX

XXX

0x08A3

0xFE

STACK

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

Collection of Tasks…

Single Task

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;


}

}

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();

}

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.

Application

Example Implementation


Example of RTOS application that
requires wireless communication.


CC1100 HAL

Radio Operation Layer

Protocol

Application


Hardware abstraction layer for
the radio. Performs low
-
level
interaction between
m
C 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

Demonstration

Questions?