VII JAR 2012 - UNICEN, Olavarría

MaRTE OS - Sistema operativo de tiempo real

aplicado al codiseño hardware-software
Marcelo Zabaljauregui (1), Hugo H. Mazzeo (1),(2), José A. Rapallini (1), (2)
(1)
CODAPLI (Proyecto Codiseño Harware Software para Aplicaciones en Tiempo Real) – Departamento de Ingeniería en Sistemas de Información.
Universidad Tecnológica Nacional. Facultad Regional La Plata, Calle 60 y 124, La Plata 1900, Argentina.
(2)
CeTAD (Centro de Técnicas Analógico-Digitales). Facultad de Ingeniería, Universidad Nacional de La Plata, Calle 48 y 116, La Plata 1900, Argentina
josrap@gmail.com.ar

Resumen - Se presenta una aplicación que combina la
utilización de un sistema operativo de tiempo real duro
(MaRTE OS) y un lenguaje de tiempo real (Ada) en el
control de posicionamiento de una antena de
comunicaciones a fin de captar la máxima intensidad de
señal. Para la simulación funcional del sistema se construyó
un prototipo con motores paso a paso controlados a través
del puerto paralelo de una PC. Como drivers para los
actuadores se utilizaron las señales generadas por una
placa de entrada/salida usada normalmente con fines
didácticos en la materia de grado.
Palabras clave: MaRTE OS, POSIX, Ada, steppers, puerto
paralelo.
facilidad de uso y un entorno controlado para el
desarrollo de aplicaciones de tiempo real multihiladas,
proveyendo también soporte para lenguajes como C y
Ada.
II. MaRTE OS Y EL ESTÁNDAR POSIX
El sistema operativo MaRTE fue desarrollado
para una tesis doctoral en el Departamento de
Electrónica y Computadores de la Universidad de
Cantabria.

Esta tesis doctoral “Planificación de Tareas en

I. INTRODUCCIÓN
El sistema de control de posición de una antena
de comunicaciones para detectar automáticamente la
máxima intensidad de radiación de señal, constituye en
sí mismo un sistema de tiempo real. Como tal, es tan
importante llevar a cabo la tarea para la cual fue
diseñado, como cumplirla en un tiempo acotado.
Con el objeto de desarrollar el sistema de
control, se construyó un prototipo a escala del sistema,
con dos motores paso a paso, uno para simular el
movimiento de giro de la base y otro para el variar la
inclinación vertical. Como se disponía de steppers
bipolares con cuatro terminales de control,
aprovecharon las ocho salidas de datos del puerto
paralelo de una PC para su manejo. Para aumentar la
salida de corriente se agregó una placa de prueba y
experimentación didáctica que permite manejar cada
línea mediante la programación del registro
correspondiente. Un programa permite seleccionar varias
opciones de control: posicionamiento manual, búsqueda
automática de señal, reseteo a una posición inicial, etc.
Como punto destacado del proyecto se debe
mencionar el hecho de utilizar un sistema operativo de
tiempo real -MaRTE OS- corriendo en la PC pero que
por haber sido diseñado específicamente para su
utilización en sistemas embebidos, puede ser empotrado
en el hardware mismo del sistema de tiempo real. Por ser
un sistema operativo que sigue los lineamientos de un
“Sistema de Tiempo Real Mínimo”, soporta unos
servicios POSIX mínimos para reducir el tamaño de las
aplicaciones desarrolladas bajo este perfil. Esto genera
Sistemas Operativos de Tiempo Real Estricto para
Aplicaciones Empotradas” [1] propone una interfaz para
sistemas empotrados bajo la cual sea posible desarrollar
aplicaciones en las que se puedan definir internamente
algoritmos de planificación de tareas, utilizando para su
implementación las bases establecidas en el estándar
POSIX de sistemas operativos de tiempo real.
El estándar POSIX se desarrolló en un principio
para unificar criterios en cuanto a los diferentes sistemas
operativos, y con ello lograr la portabilidad de las
aplicaciones a nivel de código fuente entre los distintos
sistemas operativos, facilitándose así la adaptación de los
programadores a nuevos entornos de trabajo.
El POSIX 1003.1b (extensiones de tiempo real)
se
aportó al estándar dos tipos de servicios con los cuales
ya se podían ejecutar en un sistema POSIX aplicaciones
que fueran capaces de cumplir requisitos temporales:
 Servicios para facilitar la programación concurrente.
 Servicios necesarios para obtener un tiempo de
respuesta predecible.
El POSIX 1003.1c (extensiones de “threads”)
supuso el comienzo del uso de “threads”, a los que
también se les podría calificar con el término “procesos
ligeros”, como unidades de concurrencia del POSIX,
además de los ya existentes procesos. Con ello se mejoró
la eficacia, ya que los “threads” suponen un uso de
espacio de direcciones compartido, teniendo a la vez
diversos flujos de control concurrentes dentro de un
único proceso.
Pero realizar un sistema que implemente el
estándar POSIX de manera completa haría que el sistema

-1-
 VII JAR 2012 - UNICEN, Olavarría

sea demasiado grande para su uso en pequeños sistemas ambas se tiene la diferencia de la capa intermedia que
empotrados y por ello MaRTE OS [2] (“Minimal Real- hace de interfaz entre la aplicación y la parte más interna
Time Operating System for Embedded Applications”), del núcleo del sistema operativo.
usado en aplicaciones empotradas pequeñas, soporta
unos servicios POSIX mínimos para reducir el tamaño
de las aplicaciones desarrolladas ya que no requiere el
soporte para múltiples procesos ni tampoco un complejo
sistema de ficheros jerárquico, eliminándose así la mayor
parte del tamaño y la complejidad del POSIX completo.

El código de MaRTE se ha realizado bajo las

condiciones de libre distribución de GPL (“GNU's
Public License”) [3] lo que lo hace de código abierto,
con gran utilidad para docencia y futuras investigaciones
en sistemas de tiempo real.

Está desarrollado bajo el perfil “Sistemas de
Tiempo Real Mínimo” del POSIX.13 [4] y se ha
implementado utilizando el lenguaje Ada95 que se
caracteriza por proporcionar una gran fiabilidad y
además, sencilla legibilidad y capacidad de generar
código reutilizable.
La fiabilidad que aporta Ada viene dada por la
posibilidad de corregir numerosos errores en tiempo de
compilación, debido al estricto uso de los tipos de datos
que se debe hacer, e incluso en tiempo de ejecución, con
el uso de excepciones, que tienen la capacidad de
ejecutar acciones correctoras para subsanar el error
cometido. La sencilla legibilidad y la posibilidad de
generar código reutilizable de manera cómoda vienen
dadas por el uso de los paquetes, módulos compactos de
código que permiten un alto nivel de abstracción y el
ocultamiento de la información a usuarios que no
necesiten saber del contenido del código.
III. CARACTERÍSTICAS DE MARTE OS
Los sistemas operativos tradicionales no son
apropiados para tiempo real ya que su comportamiento
no es determinista y tampoco permiten garantizar los
tiempos de respuesta.
Fig. 1. Arquitectura de las aplicaciones ejecutándose sobre MaRTE OS
Para realizar el entorno de creación, carga y
desarrollo de las aplicaciones del sistema MaRTE OS se
utiliza un equipo con Linux bajo un entorno cruzado
específico, con los compiladores GNAT y GCC y una
serie de archivos de órdenes (scripts) desarrollados en
lenguaje Perl que facilitan la generación y ejecución de
dichas aplicaciones [5].
En este equipo con Linux se encuentra el núcleo
del sistema MaRTE además de una serie de librerías que
son enlazadas de manera conjunta con el código de la
aplicación que pretende crearse, tras haberse hecho la
compilación correcta del código.
Las aplicaciones se generan en el equipo Linux,
pero han de ser cargadas de modo remoto desde el
sistema empotrado, y para ello se usa una utilidad
especial que carga la aplicación a través de la red de
comunicaciones. Esta utilidad se conoce como ‘NetBoot’
y se caracteriza por realizar un arranque remoto de una
aplicación dentro de una red Ethernet, configurándose
para ello diferentes parámetros de manera inicial.

El sistema operativo MaRTE sigue las

directrices marcadas por el estándar POSIX.13 para
“Sistemas de Tiempo Real Mínimo” referido a pequeños
sistemas empotrados, y es por ello que se tienen que
soportar una serie de servicios para cumplir con las
necesidades impuestas por el estándar como
planificación y sincronización de threads, soporte para
ejecución concurrente, señales y acceso a dispositivos.

El sistema así engendrado, ofrece un núcleo

(“kernel”) que da soporte a dos interfaces POSIX, la
original, para el POSIX-C y también para POSIX-Ada,
pudiéndose ejecutar aplicaciones empotradas desarro-
lladas tanto con “threads” en C como con tareas en Ada.
En la figura 1 se puede observar la arquitectura
con la cual se trabaja cuando se ejecuta una aplicación en
el sistema operativo MaRTE, tanto para las aplicaciones
en Ada como para las desarrolladas en lenguaje C. Entre
Fig. 2. Conexionado para la carga y ejecución de aplicaciones
Como se observa en la figura 2, la máquina
empotrada recibe la aplicación a través de la red
Ethernet, a la cual están unidos tanto dicho terminal
remoto como el sistema que da el soporte para permitir
el desarrollo de la aplicación. Con el tiempo, cuando la
aplicación quede completamente desarrollada y probada,
el sistema empotrado puede aislarse y realizar la carga

-2-
 VII JAR 2012 - UNICEN, Olavarría

de la aplicación a través de un arranque propio (por

memoria Flash, CD, etc.).

Además se tiene una comunicación entre ambos

equipos establecida a través del puerto serie, utilizada
para realizar la depuración de la aplicación en tiempo de
ejecución a través de la utilidad GDB, cargada desde el
equipo Linux sobre el que se ha desarrollado la
aplicación en primera instancia.

Actualmente MaRTE OS es un producto

perfectamente útil para el desarrollo de aplicaciones
industriales empotradas y también es una gran
herramienta para el estudio e investigación de los
sistemas operativos de tiempo real.

Es posible encontrar sistemas empotrados que Fig. 3. Vista del motor p.a p. de control de inclinación de la antena.
basan su funcionamiento en algún tipo de SO de tiempo
real realizando multitud de aplicaciones en aviones,
trenes, coches, teléfonos móviles, etc. Pueden
encontrarse varios proyectos realizados con este sistema
operativo en [6].

IV. INSTALACIÓN DE MaRTE OS

Para poder instalar el sistema operativo MaRTE

OS se requiere un compilador de Ada como GNAT 2005
para compilar el kernel. Descargar el paquete [7] y
seguir las instrucciones del script de instalación. La
versión más actualizada de MaRTE OS se puede
obtener de su website [2]. Fig. 4. Vista del motor p.a p. usado para la rotación de la base

Dependiendo de la plataforma a utilizar se

puede optar por instalarlo bajo tres condiciones:
 x86: para ejecutarse en maquinas basadas en x86 eso
se puede hacer booteando la maquina con el binario
generado.
 linux: compila a MaRTE OS como un proceso de
Linux
 linux_lib: es igual al anterior pero con acceso total al
filesystem.
Como los motores son bipolares y para evitar
construir un driver tipo puente H para cada uno, se
utilizó una placa comercial de testeo del puerto paralelo
a fin de aumentar la capacidad de tensión y corriente
entregada y lograr la potencia suficiente para el
movimiento de los motores (fig. 5). Las ocho salidas
controladas por el registro de datos son suficientes para
comandar ambos motores.

III. DETALLES DEL SISTEMA DE CONTROL DE

UNA ANTENA REALIZADO A ESCALA.

La aplicación consiste en la simulación del

control de movimiento de una antena para captar la
máxima intensidad de señal.

El objetivo realizar una aplicación en Ada

compilada sobre MaRTE OS para el control de dos
motores paso a paso que simulan los movimientos de
una antena.

Se utilizaron motores paso a paso comunes de

impresoras en desuso y algunas piezas metálicas tipo Fig. 5. Placa didáctica para prueba de puerto paralelo con posibilidad
mecano para construir un pequeño prototipo que de manejo de dispositivos de baja potencia.
permitiera simular el funcionamiento del sistema (figs. 3
y 4).

-3-
 VII JAR 2012 - UNICEN, Olavarría

IV. LA APLICACIÓN grados");new_line;

put("Inclinacion: ");put(integer(gradosMotorVertical));put("
grados");new_line;
Como se puede ver en la Fig. 6, el programa put("-----------------------------------------------------------------------
presenta seis opciones de control del estado de la antena. ");new_line;
mostrarVectorSeniales(Seniales);
put("-----------------------------------------------------------------------
");new_line;
put("Selecciones una opcion: ");new_line;
new_line;
put("1 - Movimiento manual");new_line;
put("2 - Usar Mando Remoto");new_line;
put("3 - Busqueda Automatica");new_line;
put("4 - Eliminacion de seniales");new_line;
put("5 - Volver a la senial encontrada");new_line;new_line;
put("6 - Resetear Valores de programa");new_line;
new_line;
put("Cualquier otra tecla para volver a seleecionar");new_line;
new_line;
put(" Eleccion: ");get(seleccion);new_line;
new_line;
end PantallaInicial;

Fig. 6. Pantalla principal de la aplicación

Fig. 7. Extracto del código del procedimiento principal “Pantalla
Inicial” del programa
Sin importar la opción seleccionada, la antena
no perderá su estado o condición. Las opciones son:
Cada opción de selección del procedimiento
1) Movimiento manual: el sistema pregunta principal hace uso de algunas funciones básicas que
cuantos grados desea mover la antena, tanto están asociadas ya sea con el movimiento de los motores
para la rotación de la base como la inclinación paso a paso o con la detección y obtención de la
de la antena. intensidad de las señales por la antena.
2) Usar mando remoto: para posicionar la antena
mediante el uso de un joystick. A modo de ejemplo, en la fig. 8 se detalla el
3) Búsqueda automática: es el modo de código de la función que permite posicionar un motor:
funcionamiento principal en el que se produce
la búsqueda de señales. Se emula por medio de
los botones de un joystick, cada vez que se procedure PosicionarMotor (p:integer;m:motor) is
presiona el botón el sistema almacena posi: integer;
begin
automáticamente la señal y le pregunta al posi:=1;
usuario si desea seguir buscando señales o se for I in 1 .. abs(p) loop
detiene allí. begin
4) Eliminación de señales: permite eliminar una IO_Interface.Outb_P (m.escribir, m.arraypasos(posi));
señal del vector de señales para poder buscar delay(m.pausa);
if (p>=0) then
otra.
if (posi+1=5) then
5) Volver a la señal encontrada: hace que la posi:=1;
antena vuelva a una de las 4 señales ya else
encontradas. posi:=posi+1;
6) Resetear valores de programa: vuelve a cero end if;
todos los vectores y registros del sistema. else
if (posi-1=0) then
posi:=4;
Un archivo principal antena.adb se encarga de else
armar la pantalla y llamar a los demás módulos del posi:=posi-1;
programa (Fig. 7). end if;
end if;
end;
end loop;
procedure PantallaInicial is end PosicionarMotor;
begin

gradosMotorBase:=pasostogrados(motorHorizontal.pospaso,motorHori
zontal); Fig. 8: procedimiento que permite posicionar un motor de pasos

gradosMotorVertical:=pasostogrados(motorVertical.pospaso,motorVer
tical); Como se dijo anteriormente, para simular la
put("----------------------------------------------------------------------- aplicación se utilizó una placa de entrada/salida para la
");new_line;
put(" Estado de los motores");new_line;
transferencia de señales hacia los motores. Esta placa
put(" Base: ");put(integer(gradosMotorBase));put(" utiliza el puerto paralelo standard de una PC, por lo cual

-4-
 VII JAR 2012 - UNICEN, Olavarría

hay que direccionar los tres registros del mismo (datos,
estado y control) generalmente establecidos a partir de la
dirección base 378 (hexadecimal).
El siguiente procedimiento (fig. 9) carga los
registros del puerto paralelo con las direcciones
correspondientes e inicializa las variables y arreglos de
datos que se utilizan para el manejo de los motores:
forma la detección de la máxima intensidad de señal en
el menor tiempo posible.
Si bien este sistema de tiempo real es de los
considerados blandos, ya que una demora en la búsqueda
de la mayor intensidad de señal no genera un daño o
degradación del sistema, sirve como ejemplo de
utilización de este sistema operativo y su validez para el
caso de sistemas de tiempo real estrictos.

procedure InicializaMotor(a:character; b:in out motor;s:in out float) is

---------------------------- V . CONCLUSIONES
-- Parallel Port Registers --
-----------------------------
PP_BASE_REG : constant IO_Port := 16#378#; Se investigó y experimentó con el uso de una
PP_DATA_REG : constant IO_Port := 0; -- Data port offset herramienta innovadora en el desarrollo de sistemas de
PP_STATUS_REG : constant IO_Port := 1; -- Status port offset tiempo real como es el MaRTE OS, un kernel escrito en
PP_CONTROL_REG : constant IO_Port := 2; -- Control port offset Ada para el desarrollo de aplicaciones embebidas.
begin Aunque no se completó la transferencia de la aplicación
s:=0.0; a un sistema empotrado, el trabajo realizado sienta las
s:=0.0; bases para su continuación y ampliación al desarrollo del
if (a='h') then hardware con un sistema microprocesado e
b.tipo:=a;
b.arraypasos(1):=2#00000011#; independiente del control de la PC.
b.arraypasos(2):=2#00000110#;
b.arraypasos(3):=2#00001100#;
b.arraypasos(4):=2#00001001#; VI. TRABAJOS FUTUROS
b.pospaso:=0;
b.pasoacumulado:=0.0;
b.totalpasos:=192; Realización de otros proyectos que, tomando
b.gradoxpaso:=1.875; como base esta aplicación, permitan profundizar el
b.pausa:=0.02; manejo y conocimiento de estas herramientas de
b.escribir:=PP_BASE_REG+PP_DATA_REG;
else programación y desarrollo de sistemas de tiempo real
if (a='v') then duro, centralizadas o empotradas; utilizando MaRTE OS
b.tipo:=a; como plataforma.
b.arraypasos(1):=2#0000#;
b.arraypasos(2):=2#0011#;
b.arraypasos(3):=2#0101#;
b.arraypasos(4):=2#1001#; REFERENCIAS
b.pospaso:=0;
b.pasoacumulado:=0.0; [1] Mario Aldea, “Planificación de Tareas en Sistemas Operativos de
b.totalpasos:=200; Tiempo Real Estricto para Aplicaciones Empotradas”, Tesis
b.gradoxpaso:=1.8; doctoral, Dpto. Electrónica y Computadores, Grupo de Tiempo
b.pausa:=0.02; Real, Universidad de Cantabria, Mar.2003

b.escribir:=PP_BASE_REG+PP_CONTROL_REG; [2] “MaRTE OS home page, (Minimal Real-Time Operating System for
Embedded Applications)”, Mario Aldea y Michael González,
end if; Dic.2001 http://marte.unican.es/
end if;
end InicializaMotor; [3] “GNU General Public License - GNU Project - Free Software
Foundation (FSF)” http://www.gnu.org/copyleft/gpl.html

[4] IEEE Standard 1003.13: 1997 “Standard for Information

Fig. 9: procedimiento que inicializa el puerto paralelo Technology –Standardized Application Enviroment Profile- POSIX
Realtime Application Support (AEP)” The Institute of Electrical
and Electronics Engineers, 1997.
A fin de utilizar las propiedades de tiempo real
de MaRTE OS, se definieron tareas tanto para realizar el [5] “The Big Book of Linux Ada Programming”
http://www.pegasoft.ca/resources/boblap/book.html
control de los motores como para la búsqueda de la
máxima intensidad de la señal captada por la antena. [6] “Marte OS. Finished projects”
http://marte.unican.es/projects.htm
Por definición, una tarea en Ada hace uso de un
[7] “Free Software and Open-Source Development with Ada”,
thread o hilo, lo que permite el manejo de actividades http://libre.adacore.com,
concurrentes, en este caso el control simultáneo del
movimiento de ambos motores de pasos y la búsqueda
de la máxima intensidad de señal. Así, una tarea realiza
el control del movimiento de rotación de la antena, otra
tarea controla la inclinación y una tercera la búsqueda de
la señal de máxima intensidad. Estas tres tareas, al
ejecutarse en forma concurrente, optimizando de esta

-5-