05(1)

UBC104 Embedded Systems

Review: Introduction to Microcontrollers

UBC 104 Embedded Systems 2

Processors General purpose

processors: 80386 Pentium Core Duo

Large number of pins External memory External peripherals

* Figure from Intel 386 DX Datasheet


General Purpose Registers Registers are dedicated for

moving data EAX, EBX, ECX, EDX: general

purpose registers EBP: Base pointer ESP: Stack pointer ESI, EDI: Index register


Microcontrollers Support for peripherals inside uController Limited number of pins Dedicated purpose

Controlling devices, taking measurements

Controller families: 68H12: Motorola 68H11, 68HC12, … 8051: Intel 8051, 8052, 80251,… PIC: Microchip PIC16F628, 18F452, 16F877, … AVR: Atmel ATmega128, ATtiny28L, AT90S8515,…


Rita51J 8051

128K of SRAM 128K FLASH ROM

Serial port Digital I/O lines

* Figure from www.rigelcorp.com


Motes

Sensor nodes based on Atmel ATMega128

* Figures from CrossbowMPR-MIBUser Manual


Microcontroller Families 68H12: Motorola 68H11, 68HC12, … 8051: Intel 8051, 8052, 80251,… PIC: Microchip PIC16F628, 18F452, 16F877, … AVR: Atmel ATmega128, ATtiny28L, AT90S8515,…

We are going to look at 8051s


Typical 8051s 32 input / output lines. Internal data (RAM) memory - 256 bytes. Up to 64 kbytes of ROM memory (usually flash) Three 16-bit timers / counters 9 interrupts (2 external) with two priority levels. Low-power Idle- and Power-down modes


Datasheets – Your New Friends!

* Figure from Atmel AT89C51RD2 Datasheet


Pin-Out of an 8051


8051 Components

Ports RAM Interrupt Controller Timer SPI Controller



8051 Internal RAM & SFRs



Special Function Registers (SFR)



Special Function Registers (SFR)





Ports

Driving low-power peripherals ie. LEDs, relays


Accessing Ports in Cvoid main (void) { unsigned int i; /* Delay var */ unsigned char j; /* LED var */

while (1) { /* Loop forever */ for (j=0x01; j< 0x80; j<<=1) { /* Blink LED 0, 1, 2, 3, 4, 5, 6 */ P1 = j; /* Output to LED Port */ for (i = 0; i < 10000; i++) { /* Delay for 10000 Counts */ wait (); /* call wait function */ } }

for (j=0x80; j> 0x01; j>>=1) { /* Blink LED 6, 5, 4, 3, 2, 1 */ P1 = j; /* Output to LED Port */ for (i = 0; i < 10000; i++) { /* Delay for 10000 Counts */ wait (); /* call wait function */ } } }}


Summary General information about 8051

Special Function Registers (SFRs) Control of functionality of uController

Ports Input/Output of uController


Motivation for Next Topics


Tasks for Microcontroller Controlling of processes (autonomic)

e.g. speed of vehicles, chemical processes

Control of devices through human operator e.g. remote control, etc


Example: Controller Engineering


Topics for the Following Lectures Interrupts & Timers Communication Analog to digital (A/D) conversation Pulse Width Modulation


Interrupts & Timers


Today’s Topics Interrupts Timers


InterruptsDefinition of ‘Interrupt’

Event that disrupts the normal execution of a program and causes the execution of special

instructions


Interrupts

Program

time t


Interrupts

Interrupt

Program

time t


Interrupts

Program

Interrupt Service Routine

Interrupt

Program

time t


Interrupt Handling Code that deals with interrupts:

Interrupt Handler or Interrupt Service Routines (ISRs)

Address space in code space


Interrupt Handling Code that deals with interrupts:

Interrupt Handler or Interrupt Service Routines (ISRs)

Possible code:

void ISR(void) interrupt 1 {++interruptcnt;

}

Interrupt number


Interrupts

Interrupt

Program

time t

mov R1, cent mul R1, 9 div R1, 5 add R1, 32 mov fahr, R1

fahr= (cent * ) +3295


Interrupts

Program

Interrupt Service Routine

Interrupt

Program

time t

mov R1, cent mul R1, 9

mov R1, 0x90 mov sensor, R1 ret


Interrupts

ProgramSave

Context Interrupt Service Routine

Restore Context

Interrupt

Program

time t



Interrupts

ProgramSave

Context Interrupt Service Routine

Restore Context

Interrupt

Program

time t


eg push R1 eg pop R1


Interrupt Overheads Interrupt arrivesComplete current instructionSave essential register informationVector to ISRSave additional register information

Execute body of ISR

Restore other register informationReturn from interrupt and restore essential

registersResume task

InterruptLatency

InterruptTermination


Interrupt Response Time

Interrupt Latency

Interrupt Response Time= Interrupt Latency + Time in Interrupt Routine


Interrupts Internal or External Handling can be enabled/disabled Prioritized

General 8051: 3x timer interrupts, 2x external interrupts 1x serial port interrupt


Interrupt Priorities Each interrupt source has an

inherent priority associated with it


Interrupt Priorities Priorities can be adapted

by programs Original 8051 provides 1-

bit per interrupt to set the priority


2-bit Interrupt Priorities The 89C52RD2 provides 2bit-interrupt priorities


2-bit Interrupt Priorities (continued)


2-bit Interrupt Priorities (continued)


External Interrupts

Pins for external interrupts


External Interrupts External Interrupts:

Level- or edge-triggered




threshold

Level-triggered

trigger point t




threshold

Level-triggered

Edge-triggered

trigger point

trigger point

t

t


Timer A timer is a counter that is

increased with every time an instruction is executed e.g. 8051 with 12MHz increases a counter every 1.000 µs

General 8051 has 3 timer: 2 16-bit timer 1 16-bit timer with extra-

functionality (introduced with the 8052)

Timer/Counter Mode Control Register TMOD

Timer/Counter Control Register TCON


Timer High- & Low-Registers


SFR Map – Timer Registers


Timer ControlTimer/Counter Mode Control Register TMOD

Timer/Counter Control Register TCON


SFR Map – Timer Control


SFR Map – Timer 2


Timer Codevoid TimerInit(void) {

// Timer 2 is configured as a 16-bit timer, // which is automatically reloaded when it overflows // This code (generic 8051/52) assumes a 12 MHz system osc. // The Timer 2 resolution is then 1.000 µs // Reload value is FC18 (hex) = 64536 (decimal) // Timer (16-bit) overflows when it reaches 65536 (decimal) // Thus, with these setting, timer will overflow every 1 ms

T2CON = 0x04; // Load Timer 2 control register TH2 = 0xFC; // Load Timer 2 high byte RCAP2H = 0xFC; // Load Timer 2 reload capt. reg. high byte TL2 = 0x18; // Load Timer 2 low byte RCAP2L = 0x18; // Load Timer 2 reload capt. reg. low byte

ET2 = 1; // Enable interrupt TR2 = 1; // Start Timer 2 running}


Interrupt Code for Timer 2void handleTimer2 (void) interrupt 5 {

/* execute interrupt code */

}


Interrupt Flags Bits that are set if the

interrupt occurs


Code for Interrupt Flags/* Configure Timer 0 as a 16-bit timer */TMOD &= 0xF0; /* Clear all T0 bits (T1 left unchanged) */TMOD |= 0x01; /* Set required T0 bits (T1 left unchanged) */ET0 = 0; /* No interrupts */

/* Values for 50 ms delay */TH0 = 0x3C; /* Timer 0 initial value (High Byte) */TL0 = 0xB0; /* Timer 0 initial value (Low Byte) */TF0 = 0; /* Clear overflow flag */TR0 = 1; /* Start Timer 0 */

while (TF0 == 0); /* Loop until Timer 0 overflows (TF0 == 1) */

TR0 = 0; /* Stop Timer 0 */


Summary: Interrupts Definition of ‘Interrupt’:

Event that disrupts the normal execution of a program and causes the execution of special instructions

Handling can be enabled/disabled Prioritized Internal or External External Interrupts:

Level-triggered Edge-triggered

8051: 3 timer interrupts, 2 external interrupts & a serial port interrupt

threshold

Level-triggered

Edge-triggered

trigger point

trigger point

t

t


Real-Time Systems Definition:

A real-time system needs to be

predictable in terms of values and time

Correctness of an RT system depends on functionality as well as temporal behaviour


Start

Invoke Scheduler

Set timer

Pick & dispatch a job

Block waiting for timerinterrupt

No

inte

rrup

t

Tim

er In

terru

pt S

ervi

ce R

outim

e

Clock Driven Scheduling Decision on what job execute

are made at specific time instants chosen a priori before the system starts operation

A schedule of jobs is created off-line and used at run time

The scheduler dispatches jobs according to the stored schedule at each scheduling decision time

Clock-driven scheduling has minimal overhead during run time


Cyclic Executive#define TASK_MAX 4typedef void (func_ref)(void);

int delay[TASK_MAX];func_ref task_ref[TASK_MAX];

void cyclic_executive() {int task= 0;

while(1) {settimer(delay[task]);taskref[task]();task= (task==TASK_MAX) ? task+1 : 0;clear(time_flag); while (time_flag) enterIdleMode();

}


Cyclic Executive (continued)void timer(void) interrupt 5 {

set(time_flag);}

void EnterIdleMode(void) {PCON |= 0x01;

}

T1 T2

Tdelay,1

T3 T1 T2 T3

IdleModet

Frame


Problems with Cyclic Executives Timing Accuracy Actually constructing the cyclic executive

(Typical realistic problem: 40 minor cycles and 400 entries) Inflexibility

must reconstruct schedule even for minor changes Incorporating Aperiodic/Sporadic Tasks, or very

long period tasks I/O only by polling


General Embedded Programming Endless loops Idle mode for 8051 Generic main() function


Endless Loops Two types of tasks:

Run-To-Completion tasks Endless-Loop tasks




Interrupt handler are run-to-completion tasks The majority of generic tasks are endless loops




Interrupt handler are run-to-completion tasks The majority of generic tasks are endless loops Example Code:

void ExampleTask(void) {

while(1) {waitForActivation;doTask;

}}


Idle Mode 8051s implement an “idle” mode

which consumes less power







from Pont: Atmel 89S53 normal mode 11mA idle mode 2mA




from Pont: Atmel 89S53 normal mode 11mA idle mode 2mA

Example Code:void EnterIdleMode(void)

{ PCON |= 0x01;}


Generic main() Functionvoid main(void) {

/* initialize system *//* initialize tasks */

while (1) { /* loop forever */EnterIdleMode(); /* PCON |= 0x01*/

}}


Summary Cyclic executives

Endless loops

Idle mode

Documents

05(1)