5 Operating Systems

 La informatica industrial a menudo trata de la

Topic 5
ARM Cortex M3(i)
MMR1

programacion de pequeños sistemas informáticos sin

Operating Systems in Industrial muchos recursos.
Applications  Si aumentamos la complejidad del hardware o de los
algoritmos a emplear, necesitaremos de otra aplicación
que nos ofrezca las funciones del sistema
 Sistema Operativo
Aplicación
 Aplicación industrial industrial
• se ejecuta en modo usuario
Sistema Operativo
 Sistema Operativo
• en modo supervisor Hardware

5 Operating Systems 5 Operating Systems

 Tarea o Proceso  Programa en ejecucion  Multitarea

 Tarea es cualquier programa que se encuentre cargado en  Monotarea.

Sistema informatico que solo puede mantener simultaneamente un
memoria desde la que es procesado por la CPU.

programa de aplicación cargado en memoria
Multitarea.
 Caracteristicas de las tareas

 Permite a varios programas simultaneamente
 Deben ser lo mas independientes posibles del resto de tareas.  Paralelismo de grano gordo. ->Dan la sensacion de que varios
No deben compartir datos con otras tareas trabajos independientes se ejecutan en paralelo

Tendrá sistemas para intercambiar informacion con es exterior (E/S)



 Se aprovecha los tiempos de espera de una tarea para que
y con el resto de tareas (sincronizacion) ejecuten instrucciones otras tareas
 Dispondrá de areas de memoria propias

3 4

5 Operating Systems 5 Operating Systems

 Procesos
El Sistema Operativo se encarga de administrar el tiempo,
Tarea de
 tiempo real
Planific

sincronizar y comunicar entre si a los procesos ador

 Permite a tareas trabajar mientras otras esperan otros eventos Tiempo de

espera a
Tarea de

En un mismo sistema pueden existir tareas de tiempo real con

eventos
tiempo real
 Despac
CPU
tareas sin requerimientos temporales estrictos
hador
Tarea en

El Sistema Operativo es el encargado de asegurar que se

ejecución
Tarea con
 operaciones de

cumplen los tiempos de las tareas de TR

E/S

Tiempo Tiempo de
de acceso a Tarea de
cómputo E/S cómputo
intensivo
STOP

5 6
Figura -. Colaboración entre planificador y despachador.
Diapositiva 1

MMR1 ver ptos 2.4 y 2.5 en los ejemplos de CLuna

Ver tb cuales son ocultas en ese docu (ahi y fuera)

Ver cap 34 de UM10360 User Manual, pues es el user guide

Marta Marron Romera; 28/10/2013
 5 Operating Systems 5 Operating Systems

 Procesos  Si una aplicación necesita realizar más de un

trabajo,¿Cómo lo estructuramos?
 Proceso Se pueden ver como contenedores de recursos  Solucion 1
 Tareas que ejecutan codigo  Realizar una aplicación que vaya ejecutando en orden todos los trabajos
que hay que realizar.
 Memoria
 Ventajas
 Descriptores de archivos Sencillo
Objetos que indican elementos software o hardware que se tienen en uso



 Inconveniente
 No es eficiente. Si en uno de los trabajos se accede a hardware, toda la
aplicación debe esperar a que el hardware responda

7 8

5 Operating Systems 5 Operating Systems

 Si una aplicación necesita realizar más de un  Si una aplicación necesita realizar más de un
trabajo,¿Cómo lo estructuramos?
 Solucion 2
trabajo,¿Cómo lo estructuramos?
 Dividir toda la aplicación en trabajos, y asignar cada uno de ellos a un  Solucion 3
procesos.
Permitir una ejecucion paralela de los diferentes trabajos en el mismo
Si necesito comunicar datos entre ellos, utilizar metodos de comunicación


proceso
entre procesos (pipes, sockets, buffers de memoria,…)
No necesito comunicar datos entre los flujos, ya que estos pueden acceder
Ventajas


 a todos los recursos

Puede incrementar el rendimiento de la aplicación

 Surgen para poder obtener esta solucion los subprocesos (o procesos
Disminuye el tiempo de respuesta por la ejec. paralelo

ligeros o hilos)
 Inconveniente
 Se duplican los recursos
 La comunicación entre procesos puede llegar a ser lenta

9 10

5 Operating Systems 5 Operating Systems

 El proceso es un contenedor de los recursos que utilice la  Hilos

aplicación  Cada proceso tendrá por lo menos un hilo
 Memoria  Los hilos son entes de ejecución de código, tareas que
 Descriptores de archivos comparten recursos
 Objetos que indican elementos software o hardware que se tienen en uso
 Y................ Los hilos de los que haga uso  Estado de un hilo lo define
 Su propia pila
 Los registros del procesador a nivel de usuario
 Una estructura interna del núcleo con informacion adicional del estado del
hilo
 En la pila es donde se almacena la parte fundamental de su
estado, que incluye fundamentalmente su estado

11 12
 5 Operating Systems 5 Operating Systems
 Hilos
 Hilos
Todos los recursos son compartidos por todos los hilos del proceso
Estados de un hilo


 Las variables globales y la memoria dinámica (como vimos está en la zona de
memoria asignada a la parte de código) será compartida por todos los
procesos Problema de concurrencia Lista Bloqueada

Corriendo

Terminada

13 14

5 Operating Systems 5 Operating Systems

 Creacion de Hilos.  Creacion de Hilos.

 Los sistemas operativos multihilados ofrecen a los usuarios la  El CMSIS-RTOS es una API (Interfaz de programación de aplicaciones)
común para RTOS. Proporciona una interfaz de programación estándar que
forma de crear hilos.
es portátil para muchos RTOS y por lo tanto permite que las plantillas de
 Nosotros en esta asignatura nos vamos a basar en un Sistema Software, middleware, bibliotecas y otros componentes soportados por RTOS
Operativo soportado por Cortex-M3: RTX.  El RTX CMSIS-RTOS gestiona los recursos del micro implementa el
concepto de hilos paralelos que se ejecutan simultáneamente.
 RTX es un sistema operativo de tiempo real creado para
dispositivos basados en el procesador Cortex-M. El Kernel de
RTX se puede utilizar para crear aplicaciones que realizan varias
tareas al mismo tiempo. Permite la programacion de aplicaciones
de usuario usando el estándar de C y C++ y compilados con
ARMCC, GCC o IAR compilator.

15 16

5 Operating Systems 5 Operating Systems

 Creacion de Hilos.  Creacion de Hilos.

 osThreadId osThreadCreate (const osThreadDef_t *thread_def, void *argument)  La definicion de un hilo se realiza en dos fases:
Crea un hilo y lo añadie a la lista de Hilos Activos en el estado de READY

 Primero se define la funcion que va a ejecutar
 void FuncionHilo(void const *arg);
Parameters:
A continuacion se define el tipo de hilo


[entrada] thread_def Puntero a una definicion de hilo realizada mediante osThreadDef y referenciada con 
osThread.


 osThreadDef (funtion_name,priority,instancias,stacksize)
[entrada] argument Puntero a una variable que se pasa a la funcion del hilo como un argumento de
La prioridad del hilo tendra los valores


entrada. t. 
osPriorityIdle = -3,
returns: ID del hilo para referenciar por otras funciones o NULL en caso de error.


osPriorityLow = -2,
osPriorityBelowNormal = -1,
 Inicia hilo asignado a una funcion y lo añade a la lista hilos activos, estableciendo su estado como osPriorityNormal = 0,
osPriorityAboveNormal = +1,
READY. La función del hilo recibe el argumento como argumento de la función cuando se ésta se osPriorityHigh = +2,
inicia. Cuando la prioridad de la función del hilo creado es superior al hilo RUNNING, el hilo creado osPriorityRealtime = +3,
comienza inmediatamente y se convierte en el nuevo hilo RUNNING . osPriorityError = 0x84

 Instancias: numero maximo de hilos con esta definicion que se crearan.

17  StackSize. Tamaño de la pila del hilo (en bytes). 0->Tamaño
18 standar.
 5 Operating Systems 5 Operating Systems

 Creacion de Hilos.
 Example
#include "cmsis_os.h“

void Thread_1 (void const *arg); // function prototype for Thread_1

osThreadDef (Thread_1, osPriorityNormal, 1, 0); // define Thread_1

void ThreadCreate_example (void) {

osThreadId id;
id = osThreadCreate (osThread (Thread_1), NULL); // create the thread
if (id == NULL)
{ // handle thread creation
// Failed to create a thread
}
osThreadTerminate (id); // stop the thread
}

19 20

5 Operating Systems 5 Operating Systems

 Creacion de Hilos.  Concurrencia

 osThreadId osThreadGetId (void)  Si dos sistemas pretenden usar simultaneamente un mismo
 Retorna el identificador osThreadId del hilo que la llama recurso se dice que lo usan concurrentemente
osStatus osThreadTerminate (osThreadId thread_id)
Eso puede provocar errores


 Finaliza la ejecucion del hilo que la llama y lo borra de la lista de Hilos Activos.
 osStatus osThreadSetPriority (osThreadId thread_id, osPriority priority)  de codigo modificaciones de la memoria compartida.
 Dispositivo hardwarecorrupcion de datos
 Cambia la prioridad del hilo thread_id a la prioridad priority.

21 22

5 Operating Systems 5 Operating Systems

Código en lenguaje C

int main(int argc, char** argv) int CompruebaNumero(int num)

{ { Código en lenguaje C
int iNum, iCubo, iCont; if(num > 1000)
printf(“Introduzca un nº:”); return 0; int main(int argc, char** argv)
scanf(“%d”, &iNum); return 1; {
iCubo = iNum; } int iNum, iCubo, iCont; int CompruebaNumero(int num)
if(!CompruebaNumero(iNum)) printf(“Introduzca un nº:”); {
{ scanf(“%d”, &iNum); if(num > 1000)
printf(“Número no válido”); iCubo = iNum; return 0;
return -1; if(!CompruebaNumero(iNum)) return 1;
} { }
for(iCont = 0; iCont < 2; ++iCont) printf(“Número no válido”); void __attribute__((interrupt))
iCubo *= iNum; return -1; timer_interrupt (void)
printf( “\nEl cubo de %d es %d\n”, } {
iNum, iCubo); for(iCont = 0; iCont < 2; ++iCont) int num = GetVal();
return 0; iCubo *= iNum; if(!CompruebaNumero(num))
} printf( “\nEl cubo de %d es %d\n”, return;
iNum, iCubo); PutVal(num >> 2);
return 0; }
}

23 24
 5 Operating Systems 5 Operating Systems

g_num=gnum+num  Concurrencia
 En las zonas de código que usan variables globales o recursos
MOV D0,Mem(g_num)

compartidos, para evitar problemas se puede hacer el acceso
MOV D1,Mem(num)
indivisible o atómico deshabilitar interrupciones (no permitido

ADD D0,D1
en modo usuario)

 MOV Mem(g_num),D0

25 26

5 Operating Systems 5 Operating Systems

 Hilos

 Las variables locales de un hilo no se comparten con otros hilos, aunque son
Código en lenguaje C

#include <stdio.h>
volatile int g_num;
int CompruebaNumero(int num)
{
físicamente accesibles desde otro hilo dentro del proceso.El núcleo no las
int CompruebaNumero(int num);
int main()
if(num > 10)
{ protege porque pertenecen al mismo proceso
{ DeshabilitarInt();
int iNum, iCubo, iCont; g_num = g_num + num;
printf(“Introduzca un nº:”); HabilitarInt();
scanf(“%d”, &iNum); return 0;
iCubo = iNum; }
if(!CompruebaNumero(iNum)) return 1;
{ }
printf(“Número no válido”); void __attribute__((interrupt))
return -1; timer_interrupt (void)
} {
for(iCont = 0; iCont < 2; ++iCont) int num = GetVal();
iCubo *= iNum; if(!CompruebaNumero(num))
printf( “\nEl cubo de %d es %d\n”, return;
iNum, iCubo); PutVal(num >> 2);
return g_num; }

27 28

5 Operating Systems 5 Operating Systems

 Hilos
 Hilos
Ventajas
Inconveniente

 Comparticion de recursos dentro del proceso

 Rápidez de creación y destrucción de los hilos Se reserva espacio para una pila  Al compartir recursos, si no se programa con cuidado, la actuación de un
 Agil conmutacion entre los hilos que están dentro del mismo procesos. hilo sobre un recurso puede corromper el uso del recurso de otro hilo del
 Si un hilo dentro de un proceso se bloquea se puede pasar al siguiente hilo del mismo proceso mismo proceso.
y así no se bloquea toda la aplicación.
 Ejemplo, Si dos hilos del mismo proceso esperan un dato cada uno de un
 Se puede asignar prioridades a hilos del mismo proceso lugar comun (buffer), si no se hace esta espera con cuidado, puede ocurrir
 Se puede dedicar hilos a cálculos de larga duración sin tener que paralizar a todo el proceso que cada hilo se lleve el dato que espera el otro.
 Ejemplo2, Problema visto de concurrencia en variables globales

29 30
 5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion  Objetos de Sincronizacion

 Son los mecanismos que se ofrecen por el Sistema Operativo o  Clasicamente, se define tres objetos de sincronizacion.
por una biblioteca de funciones para permitir la sincronización Semaforos contadores
entre hilos.

 Mutex
 Obtención de resultados de forma ordenada
 Variables condicionales
Compartición de recursos.
El objeto mas habitual es el semaforo

 Excluir ejecuciones entre hilos. 
 Permiten detener y reiniciar hilos  Permite ejecucion en exclusion mutua
 Se puede usar a nivel de hilos y de procesos.

31 32

5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion  Objetos de Sincronizacion

 Semaforo  Semaforo
 Se trata de una variable entera sobre la cual se pueden realizar dos  Si el valor del semaforo es =0,
operaciones  El hilo que intentara hacer una operación P quedaría bloqueado
 Incrementar V  Para poder desbloquearse, otro hilo deberia hacer la operación V
 Decrementar P sobre ese semaforo. En este caso, el primer hilo de la cola se
 Si el valor del semaforo es >0, desbloquearia y continuaria su ejecucion.
 una operación V suma 1 ese valor
 una operación P resta 1 a ese valor

33 34

5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion  Objetos de Sincronizacion

 Semaforo  Semaforo
 Se usa mucho para limitar el numero máximo de hilos que pueden acceder
simultaneamente a un recurso compartido. semaforo sem = INICIA_SEMAFORO(3);
 Para esto, se inicializa el semaforo con el valor maximo de hilos que
pueden acceder simultaneamente.
// Función llamada asíncronamente desde distintos hilos
void *acceso_a_recurso(void * pArg)
{
decrementa(&sem);
// Accede al recurso durante un intervalo de tiempo prolongado
incrementa(&sem);
return 0;
}

35 36
 5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion  Objetos de Sincronizacion

 Semaforo  Mutex
 Dos tipos de semaforos  Se asimila a un semaforo binario
Semaforo binario (mutex) Solo un hilo puede acceder a un
Se usan para


recurso 
 Semaforo contador Permite el acceso de varios hilos al recurso.  proteger la entrada a una seccion critica
Se pueden construir utilizando mutex.  Suspender un hilo
 Sincronizar dos o mas hilos

 RTX ofrece funciones y estructuras para utilizar este objeto de

sincronizacion

37 38

5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion  Objetos de Sincronizacion

 Mutex  Mutex
 Definiciones  Las funciones de gestión Mutex no se pueden llamar desde
 osMutexDef (name) Define un Mutex. rutinas de servicio de interrupción (ISR).
 Funciones
 osMutexId osMutexCreate (const osMutexDef_t *mutex_def)
 Crea e inicializa un objeto mutex definido mediante osMutexDef.
 osStatus osMutexDelete (osMutexId mutex_id)
 Elimina un objeto Mutex creado previamente con osMutexCreate
 osStatus osMutexWait (osMutexId mutex_id, uint32_t millisec)
 Realiza la operación P sobre el mutex. En caso de suspenderse, el tiempo
maximo en el que permanecera suspedido sera millisec (si es osWaitForever, es
hasta que otro hilo haga la operación V)
 osStatus osMutexRelease (osMutexId mutex_id) 39 40
 Realiza la operacion V sobre el mutex.

5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion.  Objetos de Sincronizacion

 Example
 Señales
#include "cmsis_os.h"
osMutexDef (MutexDefin); // Mutex name definition  Es un objeto de sincronizacion que permite notificar sucesos entre hilos
main {  Funciones de espera a eventos
osMutexId mutex_id;  Funcion de notificacion de eventos
osStatus status  Un hilo se queda en el estado de WAITING hasta que otro hilo le
mutex_id = osMutexCreate (osMutex (MutexDefin)); notifica que ya debe salir de ese estado y pasar al estado de READY
if (mutex_id != NULL) { // Mutex object created  RTX ofrece funciones y estructuras para utilizar este objeto de
} sincronizacion
status=osMutexWait (mutex_id,osWaitForever);
// Accesss to the shared resource

//End of the access to the shared resource

status=osMutexRelease (mutex_id);

stauts= osMutexCreate (osMutex (mutex_id));

41 42
if(status != osOK) //Failure
}
 5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion  Objetos de Sincronizacion

 Señales  Señales
 Definiciones  RTX permite que las funciones de gestión de Señales puedan ser
 #define osFeature_Signals 16 llamadas desde rutinas de servicio de interrupción (ISR).
 número máximo de flags de señal disponibles por hilo.

 Funciones
 int32_t osSignalSet (osThreadId thread_id, int32_t signals)
 Señaliza al hilo thread_id los flags indicados en signals.
 int32_t osSignalClear (osThreadId thread_id, int32_t signals)
 Desactiva los flags de señal signals en el hilo thread_id.
 os_InRegs osEvent osSignalWait (int32_t signals, uint32_t millisecs)
 Suspende el hilo en ejecucién hasta que los flags indicados en la variable signals
sean señalizadas por otro hilo, o pasen mas de mas de millisec milisegundos
(osWaitForever ->espera hasta que sea señalizado sin limite de tiempo)
43 44

5 Operating Systems 5 Operating Systems

 Objetos de sincronizacion /*--------------------------------------------------------------------------  Objetos de Sincronizacion

* Main Thread

 Semaforos
 Example
*----------------------------------------------------------------------*/
#include "cmsis_os.h"
int main (void) {
void threadX (void const *argument);
 Es otro objeto de sincronizacion de hilos y procesos
osThreadId main_id;
/* Get main thread ID */  Se asimila a una variable que almacena valores no negativos, sobre la que
se pueden hacer dos operaciones
osThreadId threadX_id;
main_id = osThreadGetId();
osThreadDef(threadX, osPriorityNormal, 1, 0);
/* Create thread X */  Incrementar V
threadX_id = osThreadCreate(osThread(threadX), NULL);  Decrementar P
void threadX (void const *argument) {
for (;;) {
for (;;) { /* do-this */  Si el valor del semaforo es >0,
/* Indicate to thread X completion of do-this */ una operación V suma 1 ese valor
/* Wait for completion of do-this */


osSignalSet(threadX_id, 0x0004); una operación P resta 1 a ese valor

osSignalWait(0x0004, osWaitForever); /* do-that */


/* Pause for 20 ms until signaling event to main thread */

/* Wait for completion of do-that */
 Si el valor del semaforo es =0,
osSignalWait(0x0004, osWaitForever);
osDelay(20);  El hilo que intentara hacer una operación P quedaría bloqueado
/* Wait now for 50 ms */
/* Indicate to main thread completion of do-that */  Para poder desbloquearse, otro hilo deberia hacer la operación V sobre ese
osDelay(50); semaforo. En este caso, el primer hilo de la cola se desbloquearia y
osSignalSet(main_id, 0x0004);
} continuaria su ejecucion
}
45 46
}

5 Operating Systems 5 Operating Systems

 Objetos de Sincronizacion  Objetos de Sincronizacion

 Semaforos  Semaforos
 Definiciones  Funciones
 #define osFeature_Semaphore 65535
 osSemaphoreId osSemaphoreCreate (const osSemaphoreDef_t *semaphor
 Maximo valor que puede tener un determinado semaforo
e_def, int32_t count)
 #define osSemaphoreDef(name)
Define un objeto semaforo.
 Crea e inicializa un objeto semaforo.
osStatus osSemaphoreDelete (osSemaphoreId semaphore_id)


 #define osSemaphore(name) 
 Accede a una definicion de un objeto semaforo  Elimina un objeto semafor creado previamente con osSemaporeCreate
 osStatus osSemaphoreWait (osSemaphoreId semaphore_id, uint32_t
millisec)
 Realiza la operación P sobre el semaforo. En caso de suspenderse, el tiempo
maximo en el que permanecera suspedido sera millisec (si es osWaitForever, es
hasta que otro hilo haga la operación V)
 osStatus osSemaphoreRelease (osSemaphoreId semaphore_id)
47  Realiza la operacion V sobre el semaforo. 48
 5 Operating Systems

 Objetos de sincronizacion
 Example
#include "cmsis_os.h"
osSemaphohreDef (SemaphoreDefin); // Semaphore name definition
main {
osSemaphoreId semaphore_id;
osStatus status
semaphore_id = osSemaphoreCreate (osSemaphore (SemaphoreDefin),1);
if (semaphore_id != NULL) { // Semaphore object created
}
status=osSemaphoreWait (semaphore_id,osWaitForever);
// Accesss to the shared resource

//End of the access to the shared resource

status=osSemaphoreRelease (semaphore_id);

stauts= osSemaphoreCreate (osSemaphore (semaphore_id));

if(status != osOK) //Failure
}
49