Rtos Sase

ELKO Componentes Electrnicos S.A.
Constitucin 3040 C1254AAZ - CABA
Tratando de entender
porqu ahora y no antes
Operating Systems
SASE
La mayor parte de los desarrollos tecnolgicos son ms fcilmente

comprensibles si se los ubica en una lnea de tiempo
Realizando este anlisis algunas creaciones vistas como geniales

pueden pasar a ser catalogadas como creativas y razonables
Esto no disminuye su mrito, slo facilita comprender sus virtudes y

defectos
Y entender que muchas de las decisiones involucradas no fueron

consecuencia de un momento creativo sino de un profundo conocimiento
de las restricciones tecnolgicas y las costumbres de uso del momento de
la creacin.
Es decir, la sinergia de capacidad de creacin + conocimiento
Facultad de Ingeniera
Universidad de Buenos Aires
Copyright Guillermo Jaquenod/ELKO - 2010
Justificacin
La aparicin del microprocesador (4004, 8008), hace ms de 35 aos

mayores expectativas en cuanto a su real potencialidad.
utilizables por programadores expertos, en lenguajes primitivos (Fortran I,

por ejemplo) y con tcnicas de programacin y entrada/salida que hoy
Los grandes sistemas de cmputo se hicieron ms accesibles
causan risa (tarjetas perforadas, cintas perforadas).
Aparecieron las mini-computadoras (PDP-11, VAX) con lo que los centros de

cmputo se democratizaron
Comenzaron a investigarse conceptos de conectividad (ARPANet)
yri
gh
tG
Y los conceptos de conectividad eran casi inexistentes
uil
cmputo slo era tema de grandes corporaciones o universidades, slo
Con mejores procesadores (6800, 8080, Z80) y memorias ms baratas se pas

a su uso masivo en instrumentacin y control. Las aplicaciones eran simples,
monousuario y monotarea, y el lenguaje el Assembler.
Las investigaciones en lenguajes se orientaron a mejoras en el uso de los
grandes sistemas centralizados de cmputo (multitarea, multiusuario) y
derivaron en lenguajes ms estructurados, ms seguros, y cada vez con mayor
abstraccin (C, Pascal, C++), y en las bases de los sistemas de administracin
de recursos (sistemas operativos).
Entonces, la limitacin de densidad y costo de memorias RAM y ROM
restringa las aplicaciones de estos componentes, y el uso de sistemas de
Justificacin
ler
(1972-1975), fue en bsqueda de un controlador programable verstil, sin
mo
Ja
qu
Simposio Argentino de Sistemas Embebidos
en
od
RTOS: Real Time
Co
p
Justificacin
Surgieron procesadores de 16 y 32 bits, como las familias 68000 y x86, la

memoria RAM masiva, y como consecuencia inmediata la PC, diluyendo la
frontera entre microcontrolador y sistema de cmputo.
El diseo y programacin de estos sistemas se abri a una enorme cantidad

de personas.
Los lenguajes de programacin invadieron estos productos, e influenciaron

en la nuevas arquitecturas
El concepto de sistema operativo sali del mbito cientfico, apareciendo el

CP/M, MSDOS, y otros.
Aparecieron las redes locales abiertas (gracias a Ethernet/Xerox) y

facilidades y protocolos de conexin entre redes (X25, ISDN)
Justificacin
La necesidad de realizar aplicaciones de micro-cmputo cada vez ms

complejas comenz a complicar la programacin, donde an con el uso de
lenguajes como C++ se generaba una compleja red de inter-dependencias,
efectos de borde, latencias, y falta de confiabilidad.
Conceptos de sistemas operativos, limitados a ambientes mono-usuario pero

multitarea, pero con requerimientos de latencia mxima, dieron origen a los
RTOS, como capa de abstraccin de mayor nivel
En la ltima dcada fue accesible pasar de simples uC de 8 bits a

procesadores de 16/32 bits estndar (como ARM7, ARM9, Cortex) u
optimizados para FPGAs (como NIOS II)
Y en los ltimos 6 o 7 aos esos RTOS fueron portados a los procesadores

empotrados en FPGAs
Justificacin
E Internet explot a nivel mundial, y su uso pas a ser algo comn a todas las
personas, tanto tcnicas como no
Se llaman sistemas Foreground / Background a aquellos sistemas donde

un programa de nivel base (en general en forma de un lazo infinito) que
atiende los eventos y decisiones
Y esta capacidad de comunicacin introdujo el concepto de monitoreo y

control remotos, y al estudio de las interfases hombre-mquina
Y estas facilidades de comunicacin pasaron de sistemas de cmputo

multipropsito (PC) a sistemas dedicados
en
od
Niveles del software
Y donde el programa es interrumpido por rutinas (ISR, por Interrupt Service

Routine), que atienden las necesidades ms urgentes
Y la necesidad de incorporar los protocolos de manejo de este tipo de

comunicaciones pas a los microcontroladores y luego a los procesadores
empotrados.
Las distintas prioridades asignadas a las distintas fuentes de interrupcin

determinan su jerarqua y el tiempo que pasa entre que sucede un evento y
que ste es atendido (latencia de servicio).
En este caso no existe un administrador de tareas sino que todas las tareas
interactan entre si, a veces en forma compleja y poco estructurada
ESTAS SON LAS RAZONES DE SER DE ESTA CONFERENCIA
Sistemas sin administrador de tareas
Sistemas sin administrador de tareas
(Foreground/Background Systems)
Prioridad
Foreground #2
Task #1
ISR #1
/* Background */
void main (void)
{
Initialization;
FOREVER { // while (1)..for (;;)
Read analog inputs;
Read discrete inputs;
Perform monitoring functions;
Perform control functions;
Update analog outputs;
Update discrete outputs;
Scan keyboard;
Handle user interface;
Update display;
Handle communication requests;
Other...
}
uil
Background
ISR #1
Task #2
Task #3
Lazo Infinito
Labrosse
/* Foreground */
ISRa (void) // prioridad media
{
Enable higher interrupts;
Handle asynchronous event;
}
ISRb (void) // prioridad alta
{
Handle asynchronous event;
}
Un lazo infinito que atiende

las tareas de soporte, donde
las tareas prioritarias son
atendidas por interrupciones
}
10
Labrosse
yri
gh
tG
Tiempo
(Foreground/Background Systems)
ler
ISR #2
Foreground #1
mo
Ja
qu
(soluciones ad-hoc).
Sistemas sin administrador de tareas:

desventajas
Co
p

ventajas
Usados en aplicaciones de bajo costo
El uso de memoria slo depende de la aplicacin
El uso de la pila (stack) se dedica a:
Apilado de funciones (Function nesting)
Dado que el software es casi totalmente re-escrito para cada aplicacin el

costo y el tiempo de debug puede ser alto
La verificacin de interdependencias es azarosa
Las tareas atendidas en forma secuencial por el nivel base (Background)

tienen una previsibilidad temporal limitada. En general el tiempo de atencin
es No-determinstico (lo que puede ser limitante en aplicaciones de control de
tiempo real). Por ejemplo, lazos o sentencias del tipo if, for, while ... tienen
distinta duracin en cada caso
Variables voltiles (en ciertos casos, si la CPU lo permite). Esto es

importante, porque no todos los microcontroladores permiten fcil
manejo de variables en el stack.
Ese tiempo cambia si cambia el cdigo de cualquiera de las tareas
Apilado de Interrupciones (ISR nesting)
Las interrupciones se atienden de inmediato (Minimal interrupt latency)
Permiten el menor costo en concepto de pago de licencias a terceros,

dado que el software es totalmente escrito por el programador
La duracin de la tarea
#2 es afectada por una
interrupcin
Task #1
ISR
Afectados por if, for, while

Task #2
Task #3
Task #4
Lazo Infinito
11
Labrosse
12
Labrosse

desventajas
En estos sistemas todas las tareas del nivel base tienen la misma prioridad,
pues se ejecutan en forma secuencial
Si no se pueden asignar interrupciones, el ciertos casos el mismo cdigo
puede tener que ser repetido varias veces para evitar perder algn evento
Task #1
Task #2
Task #1
Real time in operating systems:

The ability of the operating system to provide
a required level of service in a bounded
response time.
en
od
Cul es la diferencia entre un RTOS y un

OS convencional?
Task #3
Lazo infinito
El programador debe implementar distintos servicios:

Retardos y timeouts
Timers
Estructuras de datos para pasar informacin de una tarea a otra
Manejo de recursos comunes (teclado, displays, I/O en general)
Cada caso es un caso especial
El mantenimiento es complejo
14
Labrosse
QoS: Sistemas de tiempo real relajados y

estrictos
mo
Ja
13
- POSIX Standard 1003.1
QoS: calidad de
servicio..
qu
Componentes de un sistema de tiempo real
Redes de datos o de telefona celular
Servicios web
Juegos de computadora.
Un sistema de tiempo real estricto requiere la garanta del cumplimiento de

los parmetros temporales, para evitar efectos catastroficos potenciales
uil
Control de trfico areo
Subsistemas de control de movimiento de un vehculo o mquina
16
yri
gh
tG
Sistemas de control de procesos (plantas nucleares, por ejemplo)
15
Administrador de tareas (task management)

Asignacin de recursos de procesamiento
Sincronizacin
Manejo de memoria
Pedido
Asignacin
Liberacin y consolidacin (garbage collection)
Manejo de interrupciones
Manejo de entrada/salida: Hardware Abstraction Layer (HAL)
Recursos de comunicaciones: stacks Ethernet, USB, ZigBee, etc..
Otros:
Ambiente de desarrollo
Soporte de subsistemas existentes (BSP: Board Support Packages)
ler
Un sistema de tiempo real relajado acepta que ocasionalmente no se

cumplan pautas temporales (llamados best effort systems).
Porqu usar un Kernel de tiempo real?
Co
p
Qu es un Kernel de tiempo real?
Es un bloque de software que administra el uso del tiempo de

procesamiento de un procesador, asegurando que la tarea ms importante
sea atendida primero.
Permite atender mltiples tareas (Multitasking):
GUI (Graphic User Interface)

Sistema de archivos
Hacer ms que una cosa al mismo tiempo (macroscpicamente).
Protocolos de comunicaciones
Dividir una aplicacin en varias tareas que atienden distintos aspectos

(clculo, comunicaciones, interfase al usuario,)
Aplicacin
Entrada/salida
Compartir recurso
Comunicacin entre tareas
I/Os
Aplicacin
Debug?
Estadsticas?
Stacks
Sincronizacin de acciones y eventos

Interfase con
el usuario
RTOS
Provee una plataforma de servicios usables por las tareas:

Manejo del tiempo, retardos
17
Para facilitar el desarrrollo y

consistencia de una aplicacin:
Net
Labrosse
18
Sistema de archivos
Labrosse
Recursos implicados en el uso de

un kernel de tiempo real
Porqu usar un Kernel de tiempo real?

Para ofrecer mejor respuesta a eventos de tiempo real
Procesador con capacidad de manejo de datos en stacks
Para administrar la jerarqua de prioridades de las distintas tareas
Memoria de programa extra: de 4Kb a 250Kb
Para simplificar la expansin del sistema, pues el agregado de tareas

adicionales de menor jerarqua no afecta la performance de las tareas
existentes de jerarqua mayor
Memoria de datos extra:
Para incorporar fcilmente nuevos servicios pre-existentes (IP) y adaptados

al RTOS
Tiempo de procesamiento extra, para atender al Kernel
Para disminuir el tiempo de desarrollo, y simplificar la depuracin de errores

y puesta en marcha (debug)
Para poder distribuir la tarea del diseo entre programadores de modo

consistente
La consistencia y coherencia de estilo de los servicios en distintas

aplicaciones facilita el mantenimiento
en
od
Task stacks: Cada tarea requiere su propio stack

Aprendizaje del uso de los servicios del sistema
El uso de un kernel de tiempo real suele ser posible en uC de al menos 8 bits,

es sugerido en uC de 16 bits y altamente recomendable en el caso de 32 bits)
qu
Kernel RAM: 20 a 350 bytes por cada tarea
20
Labrosse
Labrosse
Algunas caractersticas de C/OS-II (Micrium)
Portable: prcticamente todo est escrito en ANSI C, nicamente se

escribe en Assembler la interfase al hardware especfico
Actualmente operativo en un gran nmero de procesadores de 8, 16 y 32

bits, en incluso DSPs
uil
ROMable: es posible generar cdigo a guardar en ROM con el sistema

includo, pues ha sido pensado para aplicaciones empotradas
C/OS-II puede administrar hasta 255 tareas, y provee los siguientes

servicios:
tG
Semforos
Semforos de exclusin mutua (MUTEX)
Banderas de eventos (Flags)
Administracin de tareas (Crear, Quitar, Cambiar prioridad,
Suspender, Continuar, etc.)
Bloques de manejo de tareas de dimensin prefijada
Manejo del tiempo y de temporizadores
22
Labrosse
yri
gh
En el RTOS C/OS-II las tareas son activadas y desactivadas por

interrupciones (preemptive):
Administracin de mensajes
Escalable: incorpora slo los servicios necesarios a cada aplicacin, dado

al uso de sentencias de compilacin condicional, que reduce el gasto intil
de recursos de RAM y ROM. A travs de sentencias #define se definen las
constantes que especifican las necesidades de cada aplicacin
21
El caso C-OS II
ler
Provisto en cdigo fuente (Source Code), y documentado a travs de un

extenso libro que detalla el porqu de cada sentencia
mo
Ja
19
Co
p
Niveles de abstraccin entre el hardware y

la aplicacin
El grfico muestra la
abstraccin que permite el
empleo de un RTOS (C-OS II
en este caso), entre la
aplicacin y la CPU
Se observan las secciones

estndar y aquellas propias de
cada CPU, as como la seccin
dedicada a informar de las
caractersticas propias de la
tarjeta (BSP, por Board Support
Package)
Software de Aplicacin (SUS programas)
MicroC/OS-II
(Cdigo Independente del
procesador)
OS_CORE.C
OS_FLAG.C
OS_MBOX.C
OS_MEM.C
OS_MUTEX.C
OS_Q.C
OS_SEM.C
OS_TASK.C
OS_TIME.C
uCOS_II.C
uCOS_II.H
C/OS-II
MicroC/OS-II
Configuracin
(Propio de la
aplicacin)
User Program
Newlib C Standard
Library
OS_CFG.H
INCLUDES.H
HAL API
Device
Driver
MicroC/OS-II Port (Cdigo propio de la CPU)

OS_CPU.H , OS_CPU_A.ASM, OS_CPU_C.C
CPU
23
C/OS-II es operacional junto al HAL
Timer
Device
Driver
Device
Driver
Device
Driver
Processor System Hardware

SW
Device
Driver
Se ubica ac
Y queda disponible
como parte de las
bibliotecas del
sistema
HW
24
Labrosse
Qu es un kernel Non-Preemptive?
Qu es un kernel Preemptive?
Las interrupciones tienen la

mayor prioridad
ISR
Kernel - ISR
La ocurrencia de una
interrupcin activa la ISR
La ISR termina y retorna a la

tarea interrumpida
Kernel - ISR
La ISR termina y retorna a la tarea

de mayor prioridad pendiente
ISR
Tarea de mayor prioridad (HPT)
Tarea de mayor prioridad
Tarea de menor
prioridad(LPT)
Termina la tarea de baja

prioridad y conmuta a la
de mayor prioridad
Tarea de menor
prioridad
Cuando la HPT termina recin

devuelve el control a la LPT
26
Labrosse
Estilo de diseo de una aplicacin

usando un kernel RTOS
Cada tarea
Evento
uil
Loop infinito
Tarea
Tarea
til para las tareas de

mantenimiento
Labrosse
28
Qu es una tarea?
Es una seccin de programa que se disea como si tuviera a la CPU

exclusivamente para s
Cada tarea tiene:
Un rea propia de almacenamiento de contexto (stack space)
Una prioridad basada en su importancia
Compuesta por una seccin de inicializacin seguida de un lazo infinito
Puede estar en los estados:
Dormida
Lista
En ejecucin
En suspenso, a la espera de un evento
Interrumpida
Labrosse
yri
gh
27
Tarea
tG
Importancia
Tarea de prioridad inferior

(Idle task)
(nmero ms alto)
Tarea
Evento
Tarea
Numeracin
La aplicacin es
dividida en tareas a las
que se asigna
prioridad en base a
sus requerimientos
temporales
ler
Tarea
Tarea de mxima prioridad

(nmero ms bajo)
mo
Ja
Labrosse
La tarea de mayor prioridad es atendida

de inmediato (salvo la latencia del kernel)
qu
La tarea de mayor prioridad debe esperar que la de menor prioridad se desactive

25
La ISR habilita a la tarea de mayor prioridad
en
od
La ocurrencia de una
interrupcin activa la ISR
Criterios para identificar las tareas en las

que dividir una aplicacin
Co
p
Cmo es una tarea?
Tratar de detectar actividades que sean atendidas en paralelo

Identificar tareas cclicas
Discriminar las distintas funcionalidades a atender:
Interfase con el operador
Barrido de teclado y actualizacin de display
Manejo de mecanismos (impresor, por ejemplo)
Medicin y procesamiento de datos analgicos (ej: linealizacin o filtrado)
Monitoreo y procesamiento de datos discretos (ej: antirebote de contactos)
Manejo de errores
Contabilizacin del tiempo (RTC, por caso)
Control
Comunicaciones, etc.
void Task(void *p_data) {
Do something with argument p_data;

Task initialization;
for (;;) { /* lazo infinito */
/* Processing (Your Code)
*/
...
...
Wait for event; /* Time to expire ...
*/
/* Signal from ISR ... */
/* Signal from task ... */
/* Processing (Your Code)
*/
...
}
}
29
Labrosse
30
Labrosse


Minimizar la interaccin entre tareas
Una interdependencia intensa entre tareas suele indicar un mal diseo
Task
A
ISR
Sensores
Qu
ventajas
tendr?
en
od
Considerar que un Device Driver puede necesitar ms de una tarea

Modelar tareas que brinden servicios Servidor/Cliente. Por ejemplo,
recursos de almacenamiento masivo.
Aprovechar los mecanismos de comunicacin que brinda el RTOS
Tarea de
captura
de Datos
Message
Queue
Tarea de
almacenar
datos
Recurso de
almacenaje
Task
ABC
ISR
Server
qu
Datos
32
Labrosse
Labrosse

No mezquinar la identificacin de distintas tareas
Cmo definir las prioridades de las tareas?
Es una decisin no trivial, que depende de cada aplicacin

En general, es importante identificar:
Cules deben cumplir necesariamente exigencias temporales
Lazos de Control
Ciertos tipos de comunicaciones
Alarmas y acciones de emergencia
I/O (analgica, discreta...)
Cules requieren pautas temporales pero toleran ocasionales excesos
Cules no son crticas en el aspecto temporal, y toleran latencias de
atencin importante.
Keyboard scanning
Operator interface
Display updates
etc.
ler
Disear tareas complejas y multifuncionales quitan la razn de ser y

utilidad de usar un kernel
mo
Ja
31
Task
C
VS
Comando
Client
Task
B
No exagerar en el fraccionamiento de la aplicacin
Aumenta el overhead generado por el kernel para la conmutacin de

tareas, el uso de RAM, y disminuye la reduccin de detalles y grado de
abstraccin obtenible mediante el RTOS
uil
Aprovechar la estructura jerrquica que permite el lenguaje C y realizar

descripciones simples de cada tarea
Una tarea puede invocar mltiples funciones para hacer su trabajo
Labrosse
34
Labrosse
yri
gh
33
tG
Como regla inicial, una tarea debe requerir mucho ms tiempo que el tiempo
del cambio de contexto
Estados de una tarea
35
Co
p
Cmo asignar prioridades a las tareas?

Un criterio general puede ser el llamado RMS (por Rate Monotonic
Scheduling): las tareas que se ejecutan ms a menudo son a las que
debe drseles mayor prioridad (nmero menor )
Y ante tareas de prioridad similar, parece razonable dar igual prioridad a
aquellas de menor tiempo de ejecucin
Sin embargo, sta es slo una regla general, porque puede haber tareas
que se ejecutan ocasionalmente que requieren de una atencin urgente
El libro de uC-OS II sugiere seguir las propuestas de: A Practitioners
Handbook for Real-Time Analysis, Guide to RMA for Real-Time Systems,
Mark H. Klein, Kluwer Academic Publishers, ISBN 0-7923-9361-9
Ciertos RTOS pueden tolerar tareas de igual prioridad y usar otros
esquemas (Round Robin, por ejemplos) para la asignacin de timepo de
CPU (uC-OS II no tolera tareas de idntica prioridad, pero uC-OS III ya
incorpora Round Robin)
Labrosse
Resident in ROM
(Non-active)
Waiting
For
Execution
Delete
Task
Dormant
Create
Task
Ready
Event Occurs
Or Timeout
Wait for time to expire
Wait for a message
Wait for a signal
Waiting
For
Context
Switch
Wait For
Event
Running
Task
Interrupted
ISR
Event
36
Labrosse
Creacin de una tarea: OSTaskCreate ()
Creacin de una tarea: OSTaskCreateExt ()

La funcin OSTaskCreateExt() agrega opciones
a OSTaskCreate(). A los cuatro argumentos
previos, adiciona otros cinco:
1. Un task ID pensado para futura ampliacin
de la cantidad mxima de tareas
2. Un puntero al final del rea de stack
3. La cantidad de elementos que puede
almacenar el stack
4. Un puntero a una zona de RAM para
expansin futura del Task Control Block
(TCB)
5. una variable para especificar opciones (en
este momento el chequeo del stack).
qu
Una tarea puede ser creada:

Durante la inicializacin global (init time)
Mientras se est administrando otras
tareas (run-time).
Crear una tarea es un servicio del RTOS
38
Labrosse
Labrosse
Descriptores de tareas
Un TCB (Task Control Block) es una estructura de datos usada por el
kernel para la administracin de las tareas
Cuando una tarea es creada, el kernel le asigna un TCB propio.
El TCB contiene:
La prioridad de la tarea
Un puntero al stack de la tarea (TOS: Top-Of-Stack)
Otros datos relacionados con la tarea
Labrosse
Prioridad
de la tarea
40
Labrosse
yri
gh
39
Direccin del
Tope del Stack
ERR_CODE
OSTaskCreate (p_task, p_arg, p_tos, prio)
{
if (a TCB is available) Initialize the TCB;
else
Return an error code;
Initialize the tasks stack;
Increment the number of tasks counter;
Make task ready-to-run;
if (OS is running) {
Call the scheduler;
}
}
Los TCB ocupan un reducido espacio en memoria RAM. Por ejemplo:

slo 45 bytes para C/OS-II con una CPU 80x86, usando el modelo de
memoria Large
tG
Direccin en
memoria de la tarea
uil
El estado de la tarea (Ready, Waiting ...)
Pseudo-cdigo del proceso de

creacin de una tarea
ler
mo
Ja
37
INT8U OSTaskCreateExt (
void (*task) (void *pd),
void *pdata,
OS_STK *ptos,
INT8U prio,
INT16U id,
OS_STK *pbos,
INT32U stk_size,
void *pext,
INT16U opt)
en
od
Las tareas deben ser creadas informando al

kernel ciertas caractersticas de dicha tarea:
Dnde comienza
OSTaskCreate
Los argumentos que necesita al ser
(void (*p_task)(void *p_arg),
invocada
void *p_arg,
Dnde almacenar su contexto (stack)
void *p_stk,
Su prioridad
INT8U prio);
Co
p
Estructuras de datos con varias tareas

(Task Stacks y Task List)
Eliminacin de una tarea
Task Stacks
Priority
Priority
Ready
Ready
Una tarea puede ser eliminada (pasada al estado dormant) en cualquier

momento
El cdigo no tiene que ser eliminado (de hecho, en una aplicacin

embedded usualmente est en memoria fija, ROM, FLASH o similar)
Es la manera de abortar (o kill) una tarea
La RAM puede ser reusada, liberando al TCB y al stack
Una tarea eliminada no puede ser nuevamente activada

Contexto de
cada tarea
rea de
salvado de
registros
Priority
Priority
Priority
Ready
Ready
Ready
Notar la diferencia entre el re-uso de RAM y la permanencia

del cdigo en memoria fija. Estimar qu pasar con los
procesadores basados en FRAM.
TCBs
NULL
Task List
41
Labrosse
42
Labrosse
Las tareas listas para ejecucin

Conmutacin de contexto / tarea
Qu es el Scheduling?
Es la accin realizada por el Kernel de decidir cul es la tarea ms

importante a atender y asignarle el uso de la CPU
Cundo es invocada?
En base a las prioridades definidas, el Kernel organiza una lista de las

tareas listas para ejecucin, donde la tarea de mayor prioridad encabeza
la lista
Cuando C/OS-II encuentra una tarea lista de mayor prioridad realiza un
cambio de tarea intercambiando los contextos.
Cuando una rutina de servicio de interrupcin enva un mensaje o

seal a otra tarea
El contexto identifica el estado de la CPU en una tarea saliente, y en

general se refiere al estado de sus registros internos
Una interrupcin disparada por el administrador genera este cambio
Cul es su resultado?
Si una tarea ms importante est lista para ser ejecutada (ready)
conmutar de contexto y pasar a estado running dicha tarea. Sin,
retornar al control a la tarea pre-existente
TCB
TCB
TCB
Highest
Priority
Task
44
Labrosse
TCB
NULL
Lowest
Priority
Task
Interrupciones
Las interrupciones conforman un tipo de tarea de mayor jerarqua que las
tareas convencionales
Quitan el control de la CPU a la tarea convencional activa en ese momento,

con lo que pueden afectar la previsibilidad temporal, y destruir todos los
beneficios de un RTOS en tareas crticas
Las interrupciones en general son siempre aceptadas, aunque pueden ser

bloqueadas por C/OS-II o por la aplicacin; en este caso no deben afectar
la latencia de servicio del kernel
Una rutina de servicio de interrupcion debe ser lo ms breve posible
void User_ISR (void)

{
/* Informa a uC/OS-II que se atiende una ISR */
OSIntEnter();
/* Tareas tpicas:
*/
/*
Se atiende al dispositivo
*/
/*
Se salvan los datos
*/
/*
Se borra el pedido de interrupcin
*/
/*
Se avisa a uan tarea de la novedad
*/
/* Se informa a uC/OS-II que termina una ISR */
OSIntExit();
}
uil
Aceptar la interrupcin y leer o escribir en el recurso
46
yri
gh
tG
Y enviar una seal a una tarea convencional avisando la novedad
45
Estructura de una ISR
ler
mo
Ja
43
Ready List Ptr
qu
en
od
Cuando una tarea enva un mensaje o seal a otra tarea
Cuando una tarea decide pasar a estado de espera
Conmutacin de contexto disparado por

interrupciones
Co
p
Estructura de una ISR usando HAL
Rutina de atencin de
interrupciones: Interrupt Service
Routine (ISR)
int alt_irq_register (alt_u32 id, void* context, void (*isr)(void*, alt_u32))

Descripta en <sys/alt_irq.h> asocia una funcin a una interrupcin, para
que esa funcin sea llamada al atender la interrupcin, y si el registro es
correcto habilita esa interrupcin.
Sus argumentos son:
id es el nmero de interrupcin a habilitar (definida en systemh por el
SOPC Builder
isr es la funcin a ser llamada dentro de la interrupcin, con un
puntero uncasted (void *) y una palabra con eventuales opciones
como parmetros.
Tarea de mayor
prioridad: HPT =
High Priority Task
Labrosse
HPT
HPT
La tarea interrumpida an
es la de mayor prioridad
Cuando la tarea interrumpida es la de mayor prioridad al fin

de la ISR contina la misma tarea
Si el registro es exitoso, la interrupcin es habilitada y alt_irq_register

devuelve cero. Si hay error devuelve distinto a cero
47
La tarea HPT
contina lista
ISR
48
Conmutacin de contexto disparado por

interrupciones
PendSV
Tarea de mayor prioridad HPT

Tarea de menor
prioridad LPT
C/OS-II requiere una interrupcin peridica, que puede ser generada por un
timer de hardware (es tpico de 10 a 1000 ticks/seg) aunque tambin puede
ser la frecuencia de la red (50 or 60 Hz)
Es llamada Clock Tick o System Tick, y si bien a mayor frecuencia ello

genera mayor overhead, tambin agiliza los cambios de tareas
HPT
La ISR invoca un servicio del RTOS para procesar el tick, que:
HPT
LPT
Permite que una tarea pueda suspender su ejecucin un cierto lapso de

tiempo
LPT
Proporciona timeouts a otros servicios del RTOS (flags, semforos,

mensajes, etc), para impedir que ciertas tareas queden bloqueadas
eternamente a la espera de eventos que no ocurren, o sincronizaciones
fallidas, y de ese modo evitar bloqueos (deadlocks)
Cuando la tarea interrumpida es de menor prioridad y existe una

de mayor prioridad lista para ejecucin se conmuta de contexto
50
Interrupcin sincrnica:
uso del Clock Tick de C/OS-II
C/OS-II permite a una tarea suspender su ejecucin por cierto tiempo

Un cierto tiempo : OSTimeDlyHMSM(hr, min, sec, ms)
Esta accin siempre genera un cambio de contexto, porque la tarea queda en

estado de suspensin, en el que usa poco o nada de tiempo de CPU
Suponiendo un clock tick de 100 Hz (10 mS), una tarea que revise un teclado
cada 100ms podra tener el siguiente esquema:
uil
52
Timeout de 10 ticks.
void ADCTask (void *p_arg) {
void
*p_msg; OS_ERR err;
for (;;) {
Start ADC;
p_msg = OSMboxPend(.., .., 10, &err);
if (err == OS_NO_ERR) {
Read ADC and Scale; ... ; ... ; ... ;}
else { /* Problema con el ADC! */ }
}
}
yri
gh
tG
void Keyboard_Scan_Task (void *p_arg) {

for (;;) {
OSTimeDly(10); /* Cada 100 mS */
Scan keyboard;
}
}
51
C/OS-II Timeouts
Los servicios que quedan en suspenso a la espera de eventos permiten

definir timeouts, para no quedar esperando por siempre y evitar bloqueos
Por ejemplo, sea una tarea donde un conversor deja de generar su EOC en
el tiempo esperado:
ler
Un cierto nmero de ticks: OSTimeDly(ticks)
mo
Ja
49
en
od
Conmutacin de contexto
Context Switch (PendSV call)
Higher priority
task ready
ISR
qu
Rutina de Interrucin (ISR)
el Clock Tick del RTOS
Retardos en C/OS-II
Co
p
Retardos en C/OS-II
void OSTimeDly (INT16U ticks);
INT8U OSTimeDlyResume (INT8U prio);
Permite a una tarea esperar un cierto nmero (0 a 65535) de clock ticks. Si

ticks es mayor que 0 la tarea invoca al scheduler y si el valor es 0 regresa
de inmediato. El tiempo de espera efectivo depende del parmetro
OS_TICKS_PER_SEC definido en el archivo de configuracin OS_CFG.H.
OSTimeDlyResume() permite a una tarea cancelar el retardo en ejecucin

por otra tarea, iniciado mediante OSTimeDly() u OSTimeDlyHMSM().
INT32U OSTimeGet (void);
OSTimeGet() permite consultar el valor del reloj del sistema. Este reloj es
un registro contador de 32 bits que cuenta la cantidad de ticks pasados
desde el power-up (cuando es puesto a cero) o desde que fue seteado.
INT8U OSTimeDlyHMSM (INT8U horas,INT8U minutos,

INT8U segundos, INT16U milisegundos);
void OSTimeSet (INT32U ticks);
OSTimeDlyHMSM() permite a una tarea esperar un lapso de tiempo, con

una especificacin ms natural que los ticks.
53
OSTimeSet() permite alterar por software el valor del reloj del sistema
54
Administracin del uso de

recursos comunes
El uso de recursos comunes plantea el riesgo de conflicto cuando dos
tareas desean usar el mismo recurso, y se produce la conmutacin de
una a otra mientras la primera tiene dicho recurso a medio usar
La aplicacin debe tener en cuenta ese riesgo
Y el RTOS proporciona herramientas de proteccin
La prevencin de conflictos por uso de recursos comunes puede

efctuarse de distintas maneras:
La deshabilitacin de interrupciones es un mtodo vlido y eficaz

cuando el uso y liberacin del recurso es realizado en forma muy rpida
Debe ser ms breve que el tiempo de deshabilitacin de
interrupciones del kernel
en
od

recursos comunes
Algunos RTOS no permiten esta accin, por el riesgo que conlleva
rpm = 60.0 / time;

OS_ENTER_CRITICAL();
Global RPM = rpm;
OS_EXIT_CRITICAL();
Deshabilitando interrupciones, y con ello la activacin de cualquier

otra tarea
Deshabilitando al scheduler del RTOS
56

recursos comunes
Semforos
Los semforos se usan cuando se requiere el uso de un recurso durante un tiempo

prolongado. Si el recurso es nico, son semforos binarios, y si es mltiple es un
semforo contador, que indica cuntos recursos estn libres
Posibles aplicaciones:
Controlar el uso de un rea de memoria compartida para garantizar la coherencia de
datos
Administrar el permiso de acceso a un nico recurso comn de hardware (binario).
Por ejemplo, una tarjeta de memoria, una impresora
Administrar un pool limitado de recursos (binario). Por ejemplo, un conjunto de
buffers de memoria para almacenamiento temporario de datos
Sincronizar tareas. Ejemplo: una tarea base con tareas de teclado, display, y otras
Siempre es posible que un recurso pedido, por alguna razn no quede disponible (Ej: por
error quien lo tiene no lo libera) y que ello produzca bloqueos, por eso siempre que se
usa OSSemPend() conviene definir Timeouts y acciones de recuperacin de errores.
uil
ler
El scheduler puede congelarse (Lock) para frenar la conmutacin de tareas

Las interrupciones permanecen habilitadas
Puede servir cuando se usan funciones no-reentrantes
Puede disminuir el uso de inversin de prioridades, pues tiene el mismo
efecto que asignar a la tarea actual la mxima prioridad
Altera la idea del RTOS de atender primero a la tarea de mayor prioridad
La liberacin (Unlock) hace que el RTOS verifique si es necesario o no
realizar un cambio de tareas
mo
Ja
55
qu
Usando MUTEX (Mutual Exclusion Semaphores)
58
yri
gh
57
tG
OSSchedLock();
Codigo con el scheduler deshabilitado;
OSSchedUnlock();
Los semforos para uso de recursos con

exclusin mutua
Co
p
Semforos
OS_EVENT *pevent; declara un puntero a una estructura semforo

pevent = OSSemCreate (INT16U cnt): crea al semforo, inicializa una lista de las
tareas que esperan por el semforo y apunta pevent a esa estructura
void OSSemPend (OS_EVENT *pevent, INT16U timeout, INT8U *err): espera un
cierto tiempo (o por siempre) hasta que haya un recurso disponible
INT8U OSSemPost(OS_EVENT *pevent): libera un recurso en un semaforo, con un
posible cambio de contexto si una tarea de mayor prioridad estaba a la espera de
ese recurso
INT16U OSSemAccept (OS_EVENT *pevent): similar a void OSSemPend, solo que
si no hay ningun recurso el programa contina
INT8U OSSemQuery (OS_EVENT *pevent, OS_SEM_DATA *pdata): obtiene
informacin sobre el estado de un semforo
59
60
Tasks Waiting on Semaphore

10
Exclusin mutua usando semforos
El problema de la inversin de prioridades
Recurso compartido
Semforo
Variable(s)
Estructuras de datos
Dispositivos fsicos de I/O
Task 2
Medium
HPT
HPT interrumpe a LPT
HPT
LPT libera al recurso

MPT termina
Medium
Priority
Task
Task 3
Low
Wait for Semaphore;

Usar el recurso;
Release Semaphore;
HPT necesita el recurso,

pero LPT lo tiene
La tarea LPT adquiere el recurso
Low Priority Task
LPT
MPT
La tarea MPT
interrumpe a LPT
LPT
62
Latencia extra
Inversin de prioridades
Semforos de Exclusin Mutua (Mutex)
Los MUTEX sirven para simplificar el proceso de inversin de prioridades

Y que ese proceso sea administrado por el OS y no por el usuario
Para ello se reserva un nivel de prioridad mayor que la mxima prioridad de
las tareas que comparten el recurso (PIP: Priority Inheritance Priority).
Y el OS se encarga de realizar los procesos de inversin de prioridades, a
travs de los siguientes servicios
OS_EVENT *OSMutexCreate (INT8U prio,INT8U *err)
void OSMutexPend (OS_EVENT * pevent, INT16U timeout, INT8U *err)
INT8U OSMutexPost (OS_EVENT * pevent)
INT8U OSMutexAccept (OS_EVENT * pevent, INT8U *err)
OS_EVENT * OSMutexDel (OS_EVENT * pevent, INT8U opt, INT8U *err)
INT8U OSMutexQuery (OS_EVENT * pevent, OS_MUTEX_DATA *pdata)
Recordar: en C/OS-II mayor prioridad corresponde a un nmero prio`menor.
ler
En este caso la tarea de ms prioridad asigna a la de menor prioridad

una prioridad mxima temporal para que libere el recurso cuanto antes.
Esto es llamado priority inheritance.
A travs del Kernel, la HPT hace que
La tarea HPT toma el
control, suspende a la LPT
mo
Ja
61
High Priority Task
qu
Tasks
en
od
La espera de un recurso bajo control de una tarea de menos prioridad puede

demorar el tiempo de ejecucin de tareas de ms prioridad (lo que es correcto)
Pero la tarea de menor prioridad puede a su vez ser demorada por la
ejecucin de tareas de prioridad intermedia
Con lo que se desvirta el concepto de prioridad
Task 1
High
la LPT aumente momentneamente

su prioridad y se reactive
La tarea HPT
necesita el
semforo
La tarea HPT retoma el

control, suspende a las dems
HPT: High Priority Task
uil
HPT termina
LPT contina
MPT: Medium Priority Task

La tarea LPT adquiere
al semforo
LPT: Low Priority Task
La LPT libera al semforo

y es suspendida
64
yri
gh
63
tG
MPT termina
Un ejemplo del uso de flags

para activar tareas
Co
p
Banderas de eventos:
Event Flags
Permiten sincronizar las tareas con

la ocurrencia de ciertos eventos
ISRs
Abort ISR
Estos eventos pueden agruparse

de a 8, 16 o 32 bits por grupo
La sincronizacin puede ser:
Disyuntiva (OR): cuando algn

evento sucede
Tanto las tareas como las ISR

pueden poner un FLAG en 1 o 0,
pero slo las tareas pueden quedar
a la espera de un evento
65
RPM
Task
Set or Clear
RPM == 0
RPM > 3000
Events
(8, 16 or 32 bits)
Conjuntiva (AND): cuando todos los

eventos suceden
Abort
TASKs
AI
Task
OR
Wait
Wait
Temp < 200
OR
Wait
Abort
Task
AND
Wait
Start
Task
Fuel > 1%
TASKs
User
I/F
Task
AND
Event
Flag
Group
Start
Stop
TASKs
66
11
estructuras de datos y funciones
funciones de manejo de flags
Tipos de datos:
typedef INT8U (o INT16U o INT32U) OS_FLAGS; al definir un objeto
de este tipo se lo puede inicializar
struct {} OS_FLAG_GRP: define el estado de un grupo de flags y la
lista de tareas esperando sobre esos eventos
struct {} OS_FLAG_NODE: creado cuando una dada tarea decide
depender de los flags de un dado grupo
OS_FLAGS OSFlagPost (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U

opt, INT8U *perr): segn el valor de opt (OS_FLAG_CLR u OS_FLAG_SET)
pone en 0 o 1 los flags indicados por flags en el grupo de flags prgp.
en
od
OS_FLAGS OSFlagAccept (OS_FLAG_GRP *pgrp, OS_FLAGS flags,

INT8U wait_type, INT8U *perr): devuelve el estado de ciertos flags de un
dado grupo, usando perr para indicar si se cumple o no la condicin dada
por wait_type (OS_FLAG_WAIT_SET_ALL, OS_FLAG_WAIT_SET_ANY,
OS_FLAG_WAIT_CLR_ALL, u OS_FLAG_WAIT_CLR_ANY)
Funciones de creacin y destruccin de descriptores de flags:

OS_FLAG_GRP *OSFlagCreate (OS_FLAGS flags, INT8U *perr): crea
una estructura OS_FLAGS_GRP lista para su uso posterior
OS_FLAG_GRP *OSFlagDel (OS_FLAG_GRP *pgrp, INT8U opt,
INT8U *perr): elimina un objeto OS_FLAGS_GRP (conviene eliminar
todas las tareas que dependen de este objeto antes de eliminarlo)
qu
OS_FLAGS OSFlagQuery (OS_FLAG_GRP *pgrp, INT8U *perr): informa

del valor corriente de los flags en un dado grupo
68
mo
Ja
67
OS_FLAGS OSFlagPend (OS_FLAG_GRP *pgrp, OS_FLAGS flags, INT8U

wait_type, INT16U timeout, INT8U *perr): similar a OSFlagAccept, slo que
la tarea se suspende hasta que la condicin se cumple o llega el timeout
Buzn de mensajes (Message Mailbox)
ISR
OSMBoxCreate ( )
OSMBoxDel ( )
OSMBoxPost ( )
OSMBoxPostOpt ( )
Mensaje
OSMBoxAccept ( )
OSMBoxPend ( )
OSMBoxQuery ( )
MailBox
OSMBoxPost ( )
OSMBoxPostOpt ( )
OSMBoxAccept ( )
TAREA
ISR
tG
OS_EVENT *OSMboxCreate (void *msg)

OS_EVENT *OSMboxDel (OS_EVENT * pevent, INT8U opt, INT8U *err)
void * OSMboxPend (OS_EVENT * pevent, INT16U timeout, INT8U *err)
INT8U OSMboxPost (OS_EVENT * pevent, void *msg)
INT8U OSMboxPostOpt (OS_EVENT * pevent, void *msg, INT8U opt)
void *OSMboxAccept (OS_EVENT * pevent)
INT8U OSMboxQuery (OS_EVENT * pevent, OS_MBOX_DATA *pdata)
/* USO DEL MENSAJE */

void task1(void* pdata) {
INT8U return_code = OS_NO_ERR;
INT32U *mbox1_contents;
Notar el cast para convertir
while (1) {
el void* en el valor correcto
mbox1_contents =
(INT32U *) OSMboxPend(mailbox1, 0,&return_code);
alt_ucosii_check_return_code(return_code);
// Task1 recibe el mensaje en el mailbox 1
*mbox1_contents)++;
return_code =
OSMboxPost(mailbox2,(void *)mbox1_contents);
// Task1 incrementa el mensaje y lo manda a mailbox 2
}
}
70
/* DEFINICIN */
OS_EVENT *mailbox1;
OS_EVENT *mailbox2;
OS_EVENT *mailbox3;
/* CREACION E INICIALIZACION */
int initOSDataStructs (void) {
mailbox1 = OSMboxCreate((void *)NULL);
return 0;
}
yri
gh
69
uil
Un buzn de mensajes es un objeto que permite que una tarea o ISR enve
una variable tipo puntero a otra tarea, donde ese puntero tpicamente
apunta a una estructura propia de la aplicacin, que contiene un mensaje.
Para administrar estos objetos, uC/OS II brinda las siguientes funciones:
El manejo de mensajes
involucra 3 pasos
1.
Definirlos
2.
Crearlos e inicializarlos
3.
Usarlos
ler
TAREA
Uso de los Mailbox
Organizacin de colas de
mensajes y las tareas que las usan
71
Co
p
Colas de mensajes
Cuando es necesario transmitir ms de un mensaje sin esperar que

alguien lo lea se organiza una cola de mensajes
Los mensajes siguen siendo punteros a estructuras dependientes de

cada aplicacin
La cola se administra con un criterio FIFO (First-In-First-Out), donde el

tamao mximo de cada cola es definido al crearla
Tambin es posible usar esquemas LIFO (Last-In-First-Out)
Tanto las tareas como las ISR pueden enviar mensajes
Pero slo las tareas pueden recibirlos. En este caso existe la

posibilidad de timeouts para evitar bloqueos
Tareas esperando datos de la cola

NULL
Nombre de la cola
Maximo = 6
#Esperando = 4
TCB
TCB
TCB
pIn
pOut
NULL
Cola de
mensajes
Puntero
al
mensaje
72
Puntero
al
mensaje
Puntero
al
mensaje
Puntero
al
mensaje
12
Colas de mensajes y almacn de

bloques de memoria buffer
Message
Queue
OS_EVENT *OSQCreate (void **start, INT16U size): un puntero a un array

que mantiene las direcciones de los mensajes, y el tamao de ese array
Rx Task
OS_EVENT *OSQDel (OS_EVENT *pevent, INT8U opt, INT8U *perr):

permite eliminar una cola, es recomendable primero eliminar las tareas que
la usan. Con opt es posible decidir que si hay tareas esperando mensajes
esta eliminacin no se produzca, de modo de evitar bloqueos.
en
od
Rx ISR
Buffer Pool
NULL
Free List
RxISR(void)
{
Read character from UART
if (1st character of message)
Get a buffer from Buffer Manager
Put character in buffer
if (End of Packet character)
Send packet to RxTask for processing
}
RxTask(void)
{
PACKET *p_msg;
INT8U OSQPost (OS_EVENT *pevent, void *pmsg): deposita el mensaje

apuntado por pmsg en la cola definida por pevent, en modo FIFO
while (1)
p_msg = OSQPend(RxQ, timeout)
Process packet received
Return packet buffer to Buffer Manager
INT8U OSQPostFront (OS_EVENT *pevent, void *pmsg) : deposita el

mensaje apuntado por pmsg en la cola definida por pevent, en modo LIFO
74
Funciones de C/OS-II para

manejo de colas de mensajes
Una nueva visin de los estados de una

tarea
ler
INT8U OSQPostOpt (OS_EVENT *pevent, void *pmsg, INT8U opt): es una

funcin que unifica a OSQPost y OSQPostFront, agregando la posibilidad
de hacer un POST a todas las tareas que estn en espera, y no slo a la de
mayor prioridad (es decir, un broadcast)
mo
Ja
73
void *OSQPend (OS_EVENT *pevent, INT16U timeout, INT8U *perr):

espera que est algn mensaje disponible en la cola dada por pevent, con
la posibilidad de definir un timeout de espera
qu
UART
Rx
Interrupt
Funciones de C/OS-II para

manejo de colas de mensajes
uil
void *OSQAccept (OS_EVENT *pevent, INT8U *perr): permite a una tarea

verificar si hay un mensaje pendiente sin quedar suspendida; si no lo hay
recibe un puntero void a NULL
INT8U OSQFlush (OS_EVENT *pevent): permite reinicializar una cola de
mensajes, vacindola
76
yri
gh
75
tG
INT8U OSQQuery (OS_EVENT *pevent, OS_Q_DATA *p_q_data): permite

consultar el estado completo de una cola de mensajes
Co
p
Al definir el sistema se debe asignar

prioridades y stack
Stack Memory
#define
TASK_STACKSIZE
El esquema usual es crear una tarea inicial que

crea datos y dems tareas
2048
int main (int argc, char* argv[], char* envp[]) {

// OS_STK => tipo definido por el OS

// requiere un puntero (o inicio del array)
OS_STK initialize_task_stk[TASK_STACKSIZE];
OS_STK print_status_task_stk[TASK_STACKSIZE];
OS_STK getsem_task_stk[TASK_STACKSIZE];
OS_STK receive_task_stk[TASK_STACKSIZE];
.
.
OSInit(); /* inicializar al uC/OS II */

return_code = OSTaskCreate (initialize_task,
NULL,
(void *)&initialize_task_stk[TASK_STACKSIZE],
INITIALIZE_TASK_PRIORITY);
// Se definen las tareas (hasta 63 como mximo)

// y para cada una su prioridad
#define
#define
#define
#define
77
INITIALIZE_TASK_PRIORITY
PRINT_STATUS_TASK_PRIORITY
GETSEM_TASK_PRIORITY
RECEIVE_TASK_PRIORITY
.
.
6
7
8
9
OSStart(); /* activar el scheduler */

return 0;
}
78
13
Y que la tarea de inicializacin se auto

elimine
Inicializacin por OSInit()

A travs de OSInit () C/OS-II crea de 1 a 3 tareas internas:
OS_TaskIdle ()
Es creada siempre
Y es la tarea ejecutada cuando todas las dems estn
suspendidas
Es siempre la tarea de menor prioridad
Y NO puede ser eliminada
OS_TaskStat ()
Es creada si se habilita esa opcin
Realiza evaluaciones en tiempo de ejecucin del uso de CPU y
del uso de memoria stack por las dems tareas
OS_TmrTask ()
Es creada si se habilitaron las funciones tipo timer
Adems, inicializa las estructuras de datos necesarias para su propia
operacin
void initialize_task(void* pdata) {

/* Crear todas las dems tareas */

initCreateTasks();
/* Auto-eliminarse porque ya no es ms necesaria */
return_code = OSTaskDel(OS_PRIO_SELF);
while (1);
}
80
mo
Ja
79
qu
en
od
/* Crear todas las estructuras de datos necesarias */

initOSDataStructs();
Configuracin del microC/OS-II
A travs de varias sentencias #define determina qu servicios y con

qu prestaciones estarn includos en una dada aplicacin (es
especfico a cada aplicacin)
Adems, a travs de ciertos lmites, determina el uso de memoria que

requerir el manejo de las estructuras habilitadas en la aplicacin, que
depende de los objetos usados
En el caso de las aplicaciones de NIOS II, este archivo es generado

mediante ventanas de aplicacin
Y es necesario que en la aplicacin se incluya:

#include includes.h
El objetivo de este ejercicio es realizar una aplicacin muy simple que

involucre interrupciones, el uso de semforos y de colas, demodo de
mostrar el arbitraje de tareas y la comunicacin entre tareas.
Bsicamente:
Cada apretada de botn genera una interrupcin (definida en el
SOPC Builder) que invoca a una funcin handle_button_interrupt
que almacena el evento en un lugar de memoria y hace el Post de un
semforo
Una tarea host_rcv_task que monitorea las novedades del
semforo y las va almacenando en una cola
Una tarea main_task que en base a posibles novedades en la cola
de mensajes actualiza los LED de la tarjeta
Para todo ello es necesario definir los datos, crear los objetos (semforo y
cola), crear las tareas, e instalar la interrupcin. Y definir cmo manejar
eventuales errores.
tG
uil
ler
La configuracin del C/OS-II est definida en un archivo llamado

OS_CFG.H
82
ALTERA
yri
gh
81
Ejercicio
Ejercicio
reset
Co
p
Ejercicio: Diagrama de relaciones
initOSDataStructs();
OSTaskCreate (InitTask)
OSStart();
shared_resource_sem = OSSemCreate (1)
OSTaskCreate (host_rcv_task)
InitTask
OSTaskCreate (main_task)
int main ()
Atiendo INT
Escribo semforo
handle_button
interrupts
83
#include <stdio.h>
#include <io.h>
#include <unistd.h>
#include <string.h>
#include "includes.h"
#include "altera_avalon_pio_regs.h"
#include "alt_types.h"
#include "altera_avalon_jtag_uart_regs.h"
#include "alt_ucosii_simple_error_check.h"
msgqueue = OSQCreate (msgqueueTbl)
Habilito INT
Loop {
espero semforo,
cargo mensaje en cola}
host_rcv_task
OSTaskDel (OS_PRIO_SELF)
#define PATTERN1 0x03

#define PATTERN2 0x0C
#define PATTERN3 0x30
#define PATTERN4 0xC0
#define NULL_PATTERN 0x00 // clears LEDs
Loop {
espero mensaje en cola
activo led
delay 1/3 seg }
main_task
ALTERA
84
ALTERA
14
Ejercicio
Ejercicio
// Definition of Message Queue:
// Definition of Task Stacks:
#define MSG_QUEUE_SIZE 2
//Size of message queue
OS_EVENT *msgqueue;
//Message queue pointer
void *msgqueueTbl [MSG_QUEUE_SIZE]; // Storage for messages
en
od
#define TASK_STACKSIZE
1024
OS_STK init_task_stk [TASK_STACKSIZE];
OS_STK main_task_stk [TASK_STACKSIZE];
OS_STK host_rcv_task_stk [TASK_STACKSIZE];
// Definition of Semaphore:
OS_EVENT *shared_resource_sem;
// Definition of Task Priorities:
// Globals for Shared Memory:
#define INIT_TASK_PRIORITY 6
#define MAIN_TASK_PRIORITY 7
#define HOST_RCV_TASK_PRIORITY 8
int button_val;
int tabla_button[MSG_QUEUE_SIZE]; int postabla;
// Function prototypes
86
ALTERA
ALTERA
mo
Ja
85
qu
void my_print (char *stringIn);
Ejercicio: ISR Function Definition

void handle_button_interrupts (void* context, alt_u32 id) {
my_print (str);
void my_print (char *stringIn)

{
int i;
for (i=0;i<strlen(stringIn);i++) {
IOWR_ALTERA_AVALON_JTAG_UART_DATA
(JTAG_UART_BASE,stringIn[i]);
}
IOWR_ALTERA_AVALON_JTAG_UART_DATA
(JTAG_UART_BASE,0x0D); // New Line
}
uil
// Read the edge capture register & Store value

*edge_capture_ptr =
IORD_ALTERA_AVALON_PIO_EDGE_CAP (BUTTON_PIO_BASE);
ler
/* Low-level Print Function to print inside ISR (helps debugging): */
// Cast the context pointer to an integer pointer.

int *edge_capture_ptr = (int *) context; char str[8] = "In ISR";
// Write to the edge capture register to reset it.

IOWR_ALTERA_AVALON_PIO_EDGE_CAP(BUTTON_PIO_BASE, 0);
// reset interrupt capability for the Button PIO.

IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE, 0xf);
ALTERA
88
ALTERA
yri
gh
87
tG
OSSemPost (shared_resource_sem); // Post the semaphore:

}
Ejercicio
Ejercicio: Main_ Task:2nd priority = 7
Co
p
Ejercicio: Main_ Task:2nd priority = 7
if (*msg != 0) switch (*msg)

{
case 0x1: IOWR_ALTERA_AVALON_PIO_DATA (LED_PIO_BASE,PATTERN1);
printf("LED pattern 1\n\n");
break;
break;
break;
break;
}
OSTimeDlyHMSM (0, 0, 0, 333);
}}
void main_task (void* pdata)

{
INT8U return_code = OS_NO_ERR; INT32U *msg;

while (1) {
// Pend on a Message in the msgqueue:
msg = (INT32U *) OSQPend (msgqueue,0,&return_code);

my_print("In Main Task"); printf("msg=%d\n",(int)*msg);
89
ALTERA
90
ALTERA
15
Ejercicio: host_rcv_task: 3rd priority = 8
Ejercicio: host_rcv_task: 3rd priority = 8

// send info through the message queue
void host_rcv_task (void* pdata) {
/* Register the interrupt handler. */

alt_irq_register
(BUTTON_PIO_IRQ, (void*) &button_val, handle_button_interrupts);
IOWR_ALTERA_AVALON_PIO_IRQ_MASK(BUTTON_PIO_BASE,0xFFFFFFFF);
while (1) {
// Pend on the semaphore:
OSSemPend (shared_resource_sem, 0, &return_code);
else { // No place. Ignore the message. Delay by 1 second upon exit of task
OSTimeDlyHMSM (0, 0, 1, 0);
}
}
my_print("In RCV Task");

return_code = OSQQuery (msgqueue, &queue_data);
qu
}
92
ALTERA
ALTERA
mo
Ja
91
en
od
if (queue_data.OSNMsgs < MSG_QUEUE_SIZE) {

tabla_button[postabla] = button_val;
return_code = OSQPostOpt (msgqueue,
(void *)&tabla_button[postabla],
OS_POST_OPT_BROADCAST);
if (++postabla == MSG_QUEUE_SIZE) postabla = 0;
}
INT8U return_code = OS_NO_ERR; OS_Q_DATA queue_data;
Ejercicio: InitTask: 1st priority = 6

int InitTask (void) {
int initOSDataStructs (void)

{
// Create the Message Queue:
IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE,NULL_PATTERN);
return_code = OSTaskCreate (main_task, NULL,

(void *)&main_task_stk[TASK_STACKSIZE-1],
MAIN_TASK_PRIORITY);
while (1);
return 0;
return 0;
ALTERA
94
ALTERA
yri
gh
93
// Create the semaphore:
shared_resource_sem = OSSemCreate (1);
tG
return_code = OSTaskDel (OS_PRIO_SELF);

msgqueue = OSQCreate (&msgqueueTbl [0], MSG_QUEUE_SIZE);
uil
return_code = OSTaskCreate (host_rcv_task, NULL,

(void *)&host_rcv_task_stk[TASK_STACKSIZE-1],
HOST_RCV_TASK_PRIORITY);
ler
INT8U return_code = OS_NO_ERR; button_val = 0;
Ejercicio: initOSDataStructs
Co
p
Ejercicio: main ()
int main () {
IOWR_ALTERA_AVALON_PIO_DATA(LED_PIO_BASE,NULL_PATTERN);
printf ("Main program starts now! Press SW Buttons to control LEDs\n");
OSInit();
// Initialize RTOS
initOSDataStructs(); // Initialize Data Structures
// Create "InitTask" which will spawn the other tasks:

return_code = OSTaskCreate ((void *)InitTask,
NULL,
(void *)&init_task_stk[TASK_STACKSIZE-1],
INIT_TASK_PRIORITY);
OSStart(); // Start the OS
return 0;
}
95
ALTERA
16

Rtos Sase

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Rtos Sase

Hochgeladen von

Copyright:

Verfügbare Formate

ELKO Componentes Electrnicos S.A.

Constitucin 3040 C1254AAZ - CABA

La mayor parte de los desarrollos tecnolgicos son ms fcilmente

Realizando este anlisis algunas creaciones vistas como geniales

Esto no disminuye su mrito, slo facilita comprender sus virtudes y

Y entender que muchas de las decisiones involucradas no fueron

Es decir, la sinergia de capacidad de creacin + conocimiento

Copyright Guillermo Jaquenod/ELKO - 2010

Copyright Guillermo Jaquenod/ELKO - 2010

La aparicin del microprocesador (4004, 8008), hace ms de 35 aos

utilizables por programadores expertos, en lenguajes primitivos (Fortran I,

Los grandes sistemas de cmputo se hicieron ms accesibles

causan risa (tarjetas perforadas, cintas perforadas).

Aparecieron las mini-computadoras (PDP-11, VAX) con lo que los centros de

Copyright Guillermo Jaquenod/ELKO - 2010

Copyright Guillermo Jaquenod/ELKO - 2010

Y los conceptos de conectividad eran casi inexistentes

cmputo slo era tema de grandes corporaciones o universidades, slo

Con mejores procesadores (6800, 8080, Z80) y memorias ms baratas se pas

Entonces, la limitacin de densidad y costo de memorias RAM y ROM

restringa las aplicaciones de estos componentes, y el uso de sistemas de

(1972-1975), fue en bsqueda de un controlador programable verstil, sin

Simposio Argentino de Sistemas Embebidos

RTOS: Real Time

Surgieron procesadores de 16 y 32 bits, como las familias 68000 y x86, la

El diseo y programacin de estos sistemas se abri a una enorme cantidad

Los lenguajes de programacin invadieron estos productos, e influenciaron

El concepto de sistema operativo sali del mbito cientfico, apareciendo el

Aparecieron las redes locales abiertas (gracias a Ethernet/Xerox) y

Copyright Guillermo Jaquenod/ELKO - 2010

La necesidad de realizar aplicaciones de micro-cmputo cada vez ms

Conceptos de sistemas operativos, limitados a ambientes mono-usuario pero

En la ltima dcada fue accesible pasar de simples uC de 8 bits a

Y en los ltimos 6 o 7 aos esos RTOS fueron portados a los procesadores

Copyright Guillermo Jaquenod/ELKO - 2010

Se llaman sistemas Foreground / Background a aquellos sistemas donde

Y esta capacidad de comunicacin introdujo el concepto de monitoreo y

Y estas facilidades de comunicacin pasaron de sistemas de cmputo

Niveles del software

Y donde el programa es interrumpido por rutinas (ISR, por Interrupt Service

Y la necesidad de incorporar los protocolos de manejo de este tipo de

Las distintas prioridades asignadas a las distintas fuentes de interrupcin

ESTAS SON LAS RAZONES DE SER DE ESTA CONFERENCIA

Copyright Guillermo Jaquenod/ELKO - 2010

Copyright Guillermo Jaquenod/ELKO - 2010

Sistemas sin administrador de tareas

Sistemas sin administrador de tareas

Un lazo infinito que atiende

Copyright Guillermo Jaquenod/ELKO - 2010

Copyright Guillermo Jaquenod/ELKO - 2010

Sistemas sin administrador de tareas:

Sistemas sin administrador de tareas:

Usados en aplicaciones de bajo costo

El uso de memoria slo depende de la aplicacin

El uso de la pila (stack) se dedica a:

Apilado de funciones (Function nesting)

Dado que el software es casi totalmente re-escrito para cada aplicacin el

La verificacin de interdependencias es azarosa

Las tareas atendidas en forma secuencial por el nivel base (Background)

Variables voltiles (en ciertos casos, si la CPU lo permite). Esto es

Ese tiempo cambia si cambia el cdigo de cualquiera de las tareas

Apilado de Interrupciones (ISR nesting)

Las interrupciones se atienden de inmediato (Minimal interrupt latency)