PDF de programación - Práctica 5 - Sistemas Operativos de Tiempo Real

. . . . . .. . . .

Práctica 5



Página Web: https://web08.uah.es/
e-mail: [email protected]

Despacho: N-245

Departamento de Automática

Sistemas Operativos de
Tiempo Real

.

.

.

.

.

.

.

.



Laboratorio de Informática Industrial



.
.



Sistemas Operativos de Tiempo
Real



Introducción

A menudo la Informática Industrial trata de la programación de pequeños sistemas informáticos en los
que realizando un código con un conjunto moderado de sentencias se da solución a los requisitos que se
solicitaban. Debido al éxito de los microcontroladores, en la actualidad se busca resolver mediante ellos
problemas que precisan una algoritmia más complicada, o incluso que estos dispositivos sean capaces de
gestionar un hardware más complejo.


Para dar solución a estos requerimientos, el desarrollador se enfrenta a la problemática de realizar la
aplicación, incluyendo elementos de alto y bajo nivel. Frecuentemente la máquina no dispone de más
software que el que escriba el propio programador; en otras ocasiones, se puede disponer de un conjunto de
bibliotecas de funciones específicas suministradas por el fabricante de alguno de los dispositivos. Si la
aplicación es demasiado compleja, necesitaremos con casi toda seguridad la ayuda de otro programa que nos
ofrezca ciertas funciones que facilite el desarrollo de la aplicación. Estas funciones son realizadas por un
programa llamado Sistema Operativo.


Un sistema Operativo es un conjunto de programas que dan soporte para la ejecución de aplicaciones.
Dentro de los Sistemas Operativos se encuentran los Sistemas Operativos de Tiempo Real (RTOS), que
añaden a los Sistemas Operativos de propósito general una restricción temporal. Así, un RTOS debe
garantizar la respuesta en un estricto margen de tiempo.


Un RTOS permite separar las funciones del programa de usuario en tareas auto-contenidas e
implementar una planificación bajo demanda de la ejecución de cada una de ellas. Un RTOS avanzado ofrece
muchos beneficios, como:



 Planificación de tareas. Las tareas son llamadas cuando se necesitan, asegurando así un mejor

flujo de programa y una mejor respuesta a eventos.

 Multitarea. La planificación de tareas ofrece la ilusión de que se están ejecutando un número de

tareas simultáneamente.

 Comportamiento determinístico. Los eventos y las interrupciones se manejan en un tiempo

definido
ISR más cortas. Lo que permite un comportamiento de las interrupciones más determinístico


 Comunicación entre tareas. Gestiona la compartición de datos, memoria y recursos hardware

entre distintas tareas.

 Uso definido de la pila. Cada tarea posee un espacio de pila definido, permitiendo un uso de

memoria predecible.

 Gestión del sistema. Permite al programador poner toda su atención en el desarrollo de la

aplicación más que en la gestión de recursos.


En la presente práctica vamos a utilizar el RTOS llamado Keil RTX. Este es un RTOS libre y determinístico
diseñado para dispositivos ARM y Cortex-M. En concreto, nosotros vamos a utilizar una versión de RTX
que es compatible con el estándar CMSIS, con lo que podremos utilizar sus funciones, asegurando
portabilidad entre distintos procesadores Cortex-M.

Práctica 4

2

Interrupciones



. . . . . . . . .



RTX permite la creación de programas que simultáneamente llevan a cabo múltiples funciones (o tareas) y
ayuda a crear aplicaciones que están mejor estructurados y se puedan mantener de manera más sencilla. Se
pueden asignar distintas prioridades a las tareas. El núcleo RTX utiliza esas prioridades a la hora de
seleccionar la siguiente tarea a ejecutar (planificación por preferencia). Además proporciona funciones
adicionales para la comunicación entre tareas, la gestión de memoria y de periféricos.



Configuración de un proyecto con RTX

B

A

Antes de crear un proyecto nuevo, se debe obtener el Sistema Operativo. Keil ofrece el sistema operativo a
través del enlace https://www.keil.com/demo/eval/rtx.htm.

Una vez descargado e instalado en una carpeta (nosotros, en el desarrollo de la práctica vamos a referirnos a
que la localización del sistema operativo se encuentra en la carpeta C:\Keil\cmsis_rtos_rtx_v4p70\), se crea
un proyecto nuevo.



D

C

Figura 1. Ventanas para crear un nuevo proyecto, seleccionar el fabricante y el dispositivo.


Renombramos la entrada Target 1 como RTX-LPC1768 (haciendo click sobre ella, tras estar previamente
seleccionada). Cambiamos también la entrada del árbol de proyecto Source Group 1 como StartUp. En esta
entrada de proyecto, además de contener el fichero startup_LPC17xx.s, incluiremos otro fichero llamado
system_LPC17xx.c necesario para la configuración inicial del microcontrolador. Este fichero se encuentra en
la ruta C:\Keil\ARM\Startup\NXP\LPC17xx\, pero es muy importante copiar este fichero desde este
directorio hacia el mismo directorio en que se encuentre nuestro proyecto e incluirlo desde ahí, para así no

3



correr el riesgo de modificar el original. Una vez copiado, lo incluiremos situándonos sobre la carpeta
StartUp, pulsando el botón derecho y seleccionando la opción Add Existing Files To Group.

A continuación vamos a crear los grupos de objetos relacionados con el Sistema Operativo. Para eso, nos
situamos sobre la entrada RTX-LPC1768 del árbol del proyecto, hacemos click con el botón derecho y
seleccionamos Add Group…. Se creará una entrada llamada New Group que renombraremos como RTX
Configuration. A continuación realizamos una copia del fichero RTX_Conf_CM.c, que se encuentra en la
carpeta C:\Keil\cmsis_rtos_rtx_v4p70\Templates\ al directorio donde se encuentra nuestro proyecto, y lo
incluimos dentro del grupo RTX Configuration. Este fichero contiene los parámetros configurables del RTOS.
Se recomienda visualizar el contenido de este fichero con el objetivo de conocer las posibilidades de
configuración que nos ofrece, o bien consultar su edición en el manual del Sistema Operativo.

Otro elemento relacionado con el Sistema Operativo es la librería RTX_CM3.lib, que se encuentra en el
directorio C:\Keil\cmsis_rtos_rtx_v4p70\lib\ARM. Este fichero contiene el código compilado del Sistema
Operativo, es decir, el código que se ejecutara cuando solicitemos algún servicio del RTOS. Para añadir esta
librería crearemos un nuevo grupo llamado RTX Library.

Finalmente, se creará una entrada llamada New Group que renombraremos como SourceFiles. En este grupo
incluiremos nuestros ficheros fuente.

Figura 2. Configuración de los grupos del proyecto



Una vez creados los grupos, deberemos configurar el proyecto para indicarle que vamos a utilizar
como Sistema Operativo el sistema RTX. Para eso, nos situamos sobre el nombre del proyecto en el árbol
del proyecto y haciendo click con el botón derecho, pulsamos las Opciones del proyecto

Práctica 4

4

Interrupciones



. . . . . . . . .



En la pestaña Target, en la lista desplegable de Operating System, seleccionar la Opción RTX

Kernel. Asimismo, se debe seleccionar la opción Use Microlib.

Figura 3. Menú de Opciones



Figura 4. Configuracion de la pestaña Target



A continuación, se introduce en la pestaña C/C++, en el cuadro de dialogo Include PATHs, la ruta
caso,

encuentran

inclusión

ficheros

nuestro

de

donde
C:\Keil\cmsis_rtos_rtx_v4p70\INC)

los

se

d

RTX

(En



5



Figura 5. Configuracion de la pestaña C/C++



Con la selección de estas opciones, ya el proyecto se encuentra preparado para trabajar con el
Sistema Operativo RTX. Según el resto de opciones que se quiera dotar al proyecto, se realiza la
configuración pertinente.



Ejemplo de Proyecto con RTX

A continuación se muestra un ejemplo de una aplicación que se ejecuta con el Sistema Operativo
RTX. En este ejemplo, se crean dos tareas, que se encargan de encender y apagar dos diodos D7 y D8 de la
placa Blueboard con una frecuencia distinta. Estos diodos se encuentran conectados a los pines 1.28 y 1.29
del dispositivo LPC1768, con lo que actuando sobre ellos se consigue el parpadeo de los diodos.


El código desarrollado es el que se muestra a continuación. En él se observa que se crea de forma
explícita un thread, que se encarga de gestionar el pin 1.29, mientras que el thread main gestiona el pin 1.18.
La conmutación entre ambos threads la lleva a cabo el Sistema Operativo RTX.


Para añadir este código al proyecto, se debe crear un archivo nuevo main.c dentro del grupo

Source Files, donde insertar las sentencias que se muestran.



Práctica 4

6

Interrupciones







. . . . . . . . .



#include "cmsis_os.h"
#include "lpc17xx.h"



/* Forward reference */

void threadX (void const *argument);


/* T hread IDs */

osT hreadId main_id;
osT hreadId threadX_id;



/* T hread definitions */
osT hreadDef(threadX, osPriorityNormal, 1, 0);



/*----------------------------------------------------------------------------
* Funcion Delay

*---------------------------------------------------------------------------*/

void delay(uint32_t n)
{

int32_t i;

for(i=0;i<n;i++);
}



/*----------------------------------------------------------------------------
* T hread X

*---------------------------------------------------------------------------*/

void threadX (void const *argument) {