Smart Fusion Micrium Webinar

Rapid product development with Actel's ARM-based SmartFusion and Micrium's µC/OS-III

Matt Gordon, Micrium

Wendy Lockhart, Actel

Actel Corporation Confidential © 2010 2

What is SmartFusion?


SmartFusion: Innovative, Intelligent, Integration

Proven FPGA fabric

Complete ARM® Cortex™-M3 MCU subsystem...& it’s ‘hard’

Programmable analog

In a flash-based device

In production now!


No-Compromise Microcontroller Subsystem (MSS)

100 MHz 32-bit ARM Cortex-M3 processor

Bus matrix with up to 16 Gbpsthroughput

10/100 Ethernet MAC SPI, I2C, UART, 32-bit Timers Up to 512 KB flash and 64 KB of

SRAM External memory controller 8-channel DMA controller Up to 41 MSS I/Os


Programmable Analog

Analog compute engine (ACE) offloads CPU from analog tasks

Voltage, current and temp monitors 12-bit (SAR) ADCs @ up to 600 Ksps Sigma-Delta DACs Up to ten 50 ns high-speed comparators Up to 32 analog inputs and 3 outputs


No-Compromise FPGA Fabric

Proven flash-based FPGA fabric 60,000 to 500,000 system gates 350 MHz system performance Embedded SRAMs and FIFOs Up to 128 FPGA I/Os


Innovative Intelligent Integration


SmartFusion Design Environment

Full-featured traditional FPGA design flow

Industry-leading software IDEs for embedded design

Simulation, timing and power analysis reduce debug time

Debug through FlashPro or standard RealView® header


MSS Configurator

Configure the MSS peripherals and I/Os

Create or import hardware configuration

Automatically generate drivers for peripherals

Configure programmable analog components

Enables connection of FPGA fabric designs and IP to MSS

MSS configurator enables co-design between multiple users

© 2009, Micriµm, All Rights Reservedwww.Micrium.com

An Introduction to Real-Time Kernels

Real-Time Operating Systems


A real-time operating system, or RTOS, is a collection of software that provides useful services to application code

Application

RTOS

Hardware

File SystemGUI

TCP/IP

USBBluetooth

RS-232

Kernel

Real-Time Kernels


A kernel is a key RTOS component– Essentially a task scheduler – The glue that holds the other components together

Application developers can use a real-time kernel to achieve deterministic performance

Most common alternative is the foreground/background system

A Foreground/Background Example


Background

int main (void)

{

Perform initializations;

while (1) {

ADC_Read();

SPI_Read();

USB_Packet();

LCD_Update();

Audio_Decode();

File_Write();

}

}

Foreground

void App_ISRUSB (void)

{

Clear interrupt;

Read packet;

}

A Kernel-Based Example


Tasks

void App_TaskADC (void *p_arg)

{

while (1) {

ADC_Read();

Sleep for 1 ms;

}

}

void App_TaskUSB (void *p_arg)

{

while (1) {

Wait for signal from ISR;

USB_Packet();

}

}

ISRs


{

Clear interrupt;

Signal USB Task;

}

Tasks


C functions

Usually periodic

Can be treated almost as if they are separate programs

Managed by the kernel

Tasks (Cont.)


static void App_TaskExample (void *p_arg){


while (1) {Work toward task’s goals;

}}

Data StructuresAssociated with Tasks


Task Control Block (TCB)

Allows the kernel to keep track of a task’s state



StkLimitPtr

StkPtr

ExtPtr

NextPtr

PrevPtr



StkLimitPtr

StkPtr

ExtPtr

NextPtr

PrevPtr

Used to save register values during context switches

Stack



StkLimitPtr

StkPtr

ExtPtr

NextPtr

PrevPtr

R4 = 0x04040404

R5 = 0x05050505

R6 = 0x06060606

R7 = 0x07070707

R8 = 0x08080808

R9 = 0x09090909

R10 = 0x10101010

R11 = 0x11111111

R0 = p_arg

R1 = 0x01010101

R2 = 0x02020202

R3 = 0x03030303

R12 = 0x12121212

LR = OS_TaskReturn

PC = task

xPSR = 0x01000000

Task Creation


void OSTaskCreate (OS_TCB *p_tcb,CPU_CHAR *p_name, OS_TASK_PTR *p_task,void *p_arg,OS_PRIO prio,CPU_STK *p_stk_base,CPU_STK *p_stk_limit,OS_STK_SIZE stk_size,OS_MSG_QTY q_size,OS_TICK time_quanta,void *p_ext,OS_OPT opt,OS_ERR *p_err);

The task’s priority

The actual task

The task’s stack

The task’s TCB

Understanding Kernel Services


Foreground/Background Scheduling


while (1) {ADC_Read();LCD_Update();SPI_Read();USB_Packet();LCD_Update();Audio_Decode();File_Write();LCD_Update();

}

Functions must be called repeatedly in order to produce expected behavior

Kernel Scheduling

The kernel is responsible for running tasks

There are two common schemes– Cooperative scheduling– Preemptive scheduling


Cooperative Scheduling


ADC Task

USB Task

ISR

Time

Interrupt signals the availability of the USB Task’s data

The USB task cannot run until the ADC task completes

Preemptive Scheduling


ADC Task(Low Priority)

USB Task(High Priority)

ISR

Time

Interrupt signals the availability of the high-priority task’s data

The high-priority task is scheduled by the kernel

Setting Execution Rates in a Foreground/Background System


int main (void) {unsigned short i;

i = 0;

while (1) {ADC_Read();if ((i % 8192) == 0) {

SPI_Read();}USB_Packet();LCD_Update();if ((i % 1024) == 0) {

Audio_Decode();}File_Write();i++;

}}

All rates are based on the total execution time of the loop

Setting Execution Rates with a Kernel


static void App_TaskStart (void *p_arg){

OS_ERR err;


while (1) {

Toggle LED;OSTimeDlyHMSM(0, 0, 0, 100,

OS_OPT_TIME_HMSM_STRICT,

&err);}

}

Kernel delays task for 100 ms

Round-Robin Scheduling

Multiple tasks are assigned the same priority– Kernel runs each task for a period of time set by the application developer


Task C

Task B

Task A

TimeTime Quantum

Synchronization in a Foreground/Background System


int main (void)

{


while (1) {

ADC_Rd();

SPI_Rd();

USB_Pkt();

LCD_Update();

}

}


{

Clear interrupt;

App_PktRxd++;

}

void USB_Pkt (void)

{

while (App_PktRxd > 0) {

Read packet;

Send response;

App_PktRxd--;

}

}

A global variable is used to signal packet reception

Synchronization in a Kernel


void App_TaskUSB (void *p_arg)

{


while (1) {

Pend on semaphore;

Read packet;

Send response;

}

}


{

Clear interrupt;

Post semaphore;

}

Signaling is accomplished with a kernel primitive called a semaphore

Semaphores

Essentially counters– A zero value indicates no activity– A non-zero value indicates that events have taken place

Two primary operations– Pend: Wait for events to occur– Post: Signal occurrence of events

While one task is waiting, the kernel runs other tasks


Event Flags

Another means of synchronization

Implemented with 8-, 16-, or 32-bit variables– Each bit corresponds to an event

Pend and post operations– Tasks can wait for multiple events to take place


Resource Protection in a Foreground/Background System


int main (void)

{


while (1) {

ADC_Rd();

SPI_Rd();

UART_Write();

LCD_Update();

}

}

void App_ISRUART (void)

{

Clear interrupt;

Read received character;

}

void UART_Write (void)

{

Disable interrupts;

Write message;

Re-enable interrupts;

}

Interrupts must be disabled while the shared resource (the UART) is accessed

Resource Protection in a Kernel


void App_TaskUART (void *p_arg)

{


while (1) {

Acquire mutex;

Write message;

Release mutex;

Delay for 1s;

}

}

void App_TaskFS (void *p_arg)

{


while (1) {

Read file;

Acquire mutex;

Write status to UART;

Release mutex;

}

}A kernel primitive called a mutex is used to protect shared resources

Mutexes

Implemented much like semaphores– Counter is normally initialized to a value of one

Only effective when used every time a shared resource is accessed

May offer protection against priority inversion


Additional Means of Resource Protection

Locking and Unlocking the scheduler

Disabling and Re-enabling interrupts– The only effective technique for resources that are accessed by ISRs

Semaphores– Use for resource protection is discouraged due to potential for priority

inversion


Summary of Kernels and Kernel Services

A kernel facilitates development of multi-task applications

Most kernels are either cooperative are preemptive– In a preemptive kernel, high priority tasks run as soon as they are made ready

Task management is not the only service provided by a typical kernel– Other services include synchronization and resource protection


µC/OS-III Example #1


Required Tools and Software

Libero IDE and SoftConsole– Available from http://www.actel.com/download/software/libero/files.aspx

µC/OS-III example projects and µC/Probe– Available from http://micrium.com/page/downloads/ports/actel


Hardware


Programming the Board


1. Extract contents of uCOS-III-Actel-SmartFusionEvalKit.zip

2. Jumper JP7 to USB PROG and JP10 to FPGA

3. Connect board to PC– Two USB connections

4. Run FlashPro

5. Create New Project

6. Specify PDB file and program– MICRIUM\Software\EvalBoards\Actel\SmartFusionEvalKit\Hardware\SmartFusion.pdb

Building and Running the Example


1. Start SoftConsole– Choose workspace location

2. Import examples

3. Set path and environment variables

4. Build first project, Ex1_OS

5. Open Debug Dialog– Jumper JP10 should be in M3 position

6. Run code

app.c, main()

OSInit(&os_err);

OSTaskCreate((OS_TCB *)&App_TaskStartTCB,

(CPU_CHAR *)"Start",

(OS_TASK_PTR )App_TaskStart,

(void *)0,

(OS_PRIO )APP_CFG_TASK_START_PRIO,

(CPU_STK *)&App_TaskStartStk[0],

(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE_LIMIT,

(CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE,

(OS_MSG_QTY )0u,

(OS_TICK )0u,

(void *)0,

(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),

(OS_ERR *)&os_err);

OSStart(&os_err);


app.c, App_TaskStart()

/* Initializations */

App_TaskCreate();

App_ObjCreate();

while (DEF_TRUE) {

BSP_LED_Toggle(1);

OSTimeDlyHMSM(0u, 0u, 0, 100u,

OS_OPT_TIME_HMSM_STRICT,

&err);

}


µC/OS-III Example #2


µC/Probe


Contact Information


Sales questions:Robert Langley, Sales RepresentativePhone: +1 954 217 2036 Ext. 104E-mail: [email protected]

Other inquiries:Matt Gordon, Sr. Applications EngineerPhone: +1 954 217 2036 Ext. 102E-mail: [email protected]

Documents

Smart Fusion Micrium Webinar