PONTIFICIA UNIVERSIDAD CATÓLICA DEL PERÚ

ESCUELA DE POSGRADO

“PROYECTO DE SISTEMAS EN TIEMPO REAL

Implementación de programa en C de tiempo real

AUTOR:

HUBERT HUGO VENTURA HINOSTROZA

PROFESOR:

Msc. EDDIE SOBRADO MALPARTIDA

LIMA - PERÚ

2020
PROYECTO SISTEMAS EN TIEMPO REAL

0.1. Introducción

El presente proyecto trata sobre la ejecución de dos programas que emplean técnicas
de procesamiento en multitarea, esto es el uso de hilos y asignación de prioridades a los
hilos.
Se hace uso de un sistema operativo en tiempo real denominado Zephyr en la que se
prueban los dos programas y se simulan sobre dos arquitecturas x86 y cortex a53.
Los resultados demuestran que Zephyr es un sistema operativo de tiempo real con
prestaciones avanzadas de simulación.

0.2. Sistema operativo Tephyr

En noviembre de 2015, que fue desarrollado originalmente como Rocket kernel por
Wind River Systems para dispositivos y aplicaciones referentes a internet de las cosas (IOT).
En febrero de 2016, Zephyr se convirtió en un proyecto de la Fundación Linux .
Desde entonces, los primeros miembros y partidarios del Zephyr incluyen Intel , NXP
Semiconductors , Synopsys , Linaro , runtime.io, DeviceTone, Nordic Semiconductor y Oti-
con . Zephyr es un pequeño sistema operativo en tiempo real para los dispositivos conecta-
dos, con recursos limitados que soporta múltiples arquitecturas y liberados bajo la licencia
Apache 2.0 .
El núcleo Zephyr es pequeño y diseñado para el uso en sistemas de recursos limitados:
de sensores simples incrustadas ambientales y diodo emisor de luz (LED) WEARABLES a
relojes inteligentes sofisticados y puertas de enlace inalámbricos IO.
El kernel ofrece varias caracterı́sticas que lo distinguen de otros sistemas operativos
pequeños:

0.2.1. Seguridad

0.2.1.1. Un solo espacio de direcciones

Combina código especı́fico de la aplicación con un kernel personalizado para crear

una imagen monolı́tica que se carga y se ejecuta en el hardware de un sistema. Tanto el

1
código de la aplicación y el código del núcleo se ejecutan en un solo espacio de direcciones
compartido.

0.2.1.2. altamente configurable

Permite que una aplicación para incorporar sólo las habilidades que necesita, según
sea necesario, y para especificar su cantidad y tamaño.

0.2.2. Recursos definidos en tiempo de compilación

Requiere ser definidos todos los recursos del sistema en tiempo de compilación, lo que
reduce el tamaño del código y aumenta el rendimiento.

0.2.2.1. La comprobación de errores mı́nimos

Proporciona un mı́nimo error de tiempo de ejecución comprobación para reducir el

tamaño del código y aumentar el rendimiento. Se proporciona una infraestructura de com-
probación de errores opcional para ayudar en la depuración durante el desarrollo de aplica-
ciones.

0.2.2.2. Servicios de desarrollo

Los servicios de desarrollo ofrecen varios servicios familiares para el desarrollo, inclu-
yendo:

• Servicios de multi-threading, clasifica los hilos en dos tipos; hilos cooperativos y los
hilos preferentes ambos pueden tener una planificación basada en prioridad fija o
variable, además aplican planificación FIFO y round robin.

• Servicios de interrupción, tanto para el registro en tiempo de compilación y tiempo de

ejecución del controlador de interrupciones.

• Servicios de sincronización entre hilos para los semáforos binarios, semáforos de con-
teo, y semáforos mutex.

• Datos entre hilos que pasan los servicios para las colas básicas de los mensajes,
colas de mensajes mejorados, y flujos de bytes.

• Servicios de asignación de memoria para la asignación dinámica y la liberación de

tamaño fijo o variable de memoria del tamaño de los bloques.

• Servicios de administración de energı́a, tales como inactivo tickless y una infraestruc-

tura avanzada ralentı́.

2
0.3. Board que soporta

Las que se muestran son las arquitecturas que soporta Zephyr si desea ver las boards
que componen cada arquitectura ir al enlace https://docs.zephyrproject.org/latest/boards/index.html

• x86 Boards

• ARM Boards

• ARC Boards

• NIOS II Boards

• XTENSA Boards

• POSIX/NATIVE Boards

• RISCV Boards

• Shields

Cane señalar que para algunas boards existe simuladores la lista adjunta las muestra.

• X86 Emulation (QEMU)

• ARM Cortex-A53 Emulation (QEMU)

• ARM Cortex-M0 Emulation (QEMU)

• ARM Cortex-M3 Emulation (QEMU)

• ARM Cortex-R5 Emulation (QEMU)

• ARC EM & HS Emulation (QEMU)

• Altera Nios-II Emulation (QEMU)

• Xtensa Emulation (QEMU)

• RISCV32 Emulation (QEMU)

• RISCV64 Emulation (QEMU)

0.4. Desarrollo del proyecto

0.4.1. Objetivos

• Desarrollar programas en lenguaje C aplicando ejecución multitarea en el sistema

operativo de tiempo real Tephyr.

3
 • Simular los programas desarrollados utilizando lo simuladores QUEMU de Tephyr.

• Flashear los boards con los programas correctamente simulados.

• Verificar que los programas realizan las tareas que deberı́an realizar.

0.4.2. Descripción del desarrollo

0.4.2.1. Programa 0

En el programa 0 se crea un hilo A y este crea a un hilo hijo, el hilo B, ambos invocan
a la misma subrutina con una alternancia al estilo ping pong, es decir, si empieza el hilo A,
ejecuta la subrutina luego de terminar de ejecutarla cede su ocupación para que el hilo B la
ejecute y al terminar su ocupación cede al hilo A para que la ejecute y ası́ sucesivamente.
El programa creado para esta actividad se describe en el anexo con el nombre de
pucp.c. Además lo puede encontrar en la carpeta adjunta pucproject/src/pucp.c
Se simuló el programa en X86 Emulation (QEMU) y ARM Cortex-M0 Emulation (QE-
MU). Los comandos en lı́nea que se emplearon para obtener los archivos compilados son:
// Simular programa 0 con el simulador qemu_x86
// Posicionarse en la carpeta \textit{\textbf{/home/.../zephyrproject/zephyr}}
west build -p auto -b qemu_x86 samples/pucproject
west build -t run

// Simular programa 0 con el simulador qemu_cortex_a53

// Posicionarse en la carpeta \textit{\textbf{/home/.../zephyrproject/zephyr}}
west build -p auto -b qemu_cortex_a53 samples/pucproject
west build -t run

Si la simulación es exitosa, entonces se procede a flashear el board, es decir, el dispo-

sitivo fı́sico, el comando en lı́nea usando para lograr esto es:
// \textit{Flashear} programa 0 en el cortex_a53
west flash

Se verificó en la simulación que el programa lograba su cometido para el que fue creado.
En caso la simulación no fuera exitosa, se tendrı́a que modificar el programa, luego
grabarlo y antes de volverlo a simular se debe borrar la construcción de la simulación no
exitosa con el comando en lı́nea:
// Borrar las construcciones no exitosas antes de proceder a la simulación
west build -t pristine

0.4.2.2. Programa 1

En el programa 1 se crean tres hilos con diferente prioridad el primero con prioridad 0, el
segundo con prioridad 7 y el tercero con prioridad 2. El sentido común nos puede jugar una
mala pasada pues de lo expuesto se deducirı́a que el segundo hilo es de mayor (prioridad

4
7), lo cual es incorrecto, pues en el sistema operativo Zephyr, el de mayor prioridad es el
hilo 1 (prioridad 0).
En el programa 1 los tres hilos compiten por apoderarse de un semáforo y luego de
adquirirlo ejecutan una labor básica de impresión. Debido a que ellos tienen prioridades
asignadas al ejecutarse primero lo hace el hilo 1, realiza su labor de impresión y luego se
le duerme, con la finalidad de dejar libre el semáforo y permitir que los dos hilos restantes
compitan por apoderarse del semaforo. Se observa, siempre, que el kernel atiende al de
mayor prioridad.
El programa creado para esta actividad se describe en el anexo con el nombre de
pucp1.c. Además lo puede encontrar en la carpeta adjunta pucproject1/src/pucp1.c
Se simuló el programa en X86 Emulation (QEMU) y ARM Cortex-M0 Emulation (QE-
MU). Los comandos en lı́nea que se emplearon para obtener los archivos compilados son:
// Simular programa 1 con el simulador qemu_x86
// Posicionarse en la carpeta \textit{\textbf{/home/.../zephyrproject/zephyr}}
west build -p auto -b qemu_x86 samples/pucproject1
west build -t run

// Simular programa 1 con el simulador qemu_cortex_a53

// Posicionarse en la carpeta \textit{\textbf{/home/.../zephyrproject/zephyr}}
west build -p auto -b qemu_cortex_a53 samples/pucproject1
west build -t run

Si la simulación es exitosa, entonces se procede a flashear el board, es decir, el dispo-

sitivo fı́sico, el comando en lı́nea usando para lograr esto es:
// \textit{Flashear} programa 0 en el cortex_a53
west flash

Se verificó en la simulación que el programa lograba su cometido para el que fue creado.
En caso la simulación no fuera exitosa, se tendrı́a que modificar el programa, luego
grabarlo y antes de volverlo a simular se debe borrar la construcción de la simulación no
exitosa con el comando en lı́nea:
// Borrar las construcciones no exitosas antes de proceder a la simulación
west build -t pristine

0.5. Conclusiones

• Se desarrolló dos programas, pucp.c y pucp1.c en lenguaje C que aplican ejecución

multitarea en el sistema operativo de tiempo real Tephyr.

• Se simuló los programas desarrollados utilizando lo simuladores X86 Emulation (QE-

MU) y ARM Cortex-M0 Emulation (QEMU) de Tephyr.

• Se verificó que los programas, pucp.c y pucp1.c, realizan las tareas que deberı́an
realizar.

5
 APÉNDICE A

LISTADO DE PROGRAMAS DE SIMULACIÓN

A.1. Simulación empleo de semáforos

/* Elaborado por: Hubert Hugo Ventura Hinostroza */

/**********************************************************************************/
/* pucp.c - Programa con prioridad de hilos */
/*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* La demostración hace uso de semáforos para turnarse uno y otro para ejecutar
* un hola.
*/
/**********************************************************************************/
#include <zephyr.h>
#include <sys/printk.h>
/* tama~no del area de la pila para cada hilo */
#define STACKSIZE 1024
/* planificación de la prioridad usada para cada hilo */
#define PRIORITY 7
/* retardo entre saludos (en ms) */
#define SLEEPTIME 2000
/**********************************************************************************/
/* se define los semáforos */
K_SEM_DEFINE(sem_hiloA, 1, 1); /* "disponible" */
K_SEM_DEFINE(sem_hiloB, 0, 1); /* "no disponible" */
/* Se define la pila del hilo B */
K_THREAD_STACK_DEFINE(philoB, STACKSIZE); //Pila del hilo B = philoB
static struct k_thread hiloB;
/**********************************************************************************/
/* Esta es la función que reliza tanto el hilo A como el hilo B */
void helloLoop(const char *nombre, struct k_sem *sem_mio, struct k_sem *sem_otro)
{
const char *tname;
tname = k_thread_name_get(k_current_get());
while (1) {
/* tomo el semáforo A */
k_sem_take(sem_mio, K_FOREVER);
if (tname == NULL) {
printk("%s: Hola yo soy %s!\n", nombre, CONFIG_BOARD);
} else {
printk("%s: Hola mundo de %s!\n", tname, CONFIG_BOARD);
}
/* espera hasta que el otro hilo tenga su turno */
k_msleep(SLEEPTIME);
k_sem_give(sem_otro);
}
}

/* El hilo B es un hilo generado por el hilo A */

/* Esta es la función que realiza el hilo B */
void fhiloB(void *dummy1, void *dummy2, void *dummy3) {
ARG_UNUSED(dummy1);

6
ARG_UNUSED(dummy2);
ARG_UNUSED(dummy3);
/* invoca a la rutina para ping-pong de mensages con el hilo A */
helloLoop("**** Soy el hilo B", &sem_hiloB, &sem_hiloA);
}

/* Esta es la función que realiza el hilo A */

void fhiloA(void *dummy1, void *dummy2, void *dummy3) {
ARG_UNUSED(dummy1);
ARG_UNUSED(dummy2);
ARG_UNUSED(dummy3);
/* el hilo A genera al hilo B */
k_tid_t idB = k_thread_create(&hiloB, philoB,
K_THREAD_STACK_SIZEOF(philoB), fhiloB, NULL, NULL, NULL,
PRIORITY, 0, K_NO_WAIT);
k_thread_name_set(idB, "id_hiloB");
/* invoca a la rutina para ping-pong de mensages con el hilo B */
helloLoop("____ Soy el hilo A", &sem_hiloA, &sem_hiloB);
}
/* El hilo A es generado automáticamente */
K_THREAD_DEFINE(id_hiloA, STACKSIZE, fhiloA, NULL, NULL, NULL,
-1, 0, 0);
/******************************* F I N *********************************/

A.2. Simulación prioridad en los hilos

/* Elaborado por: Hubert Hugo Ventura Hinostroza */

/**********************************************************************************/
/* pucp1.c - Programa con prioridad de hilos */
/*
* SPDX-License-Identifier: Apache-2.0
*/
/*
* Se hace uso de un semáforos y tres hilos.
* Los hilos compiten por apoderarse del semáforo.
* Los hilos tienen diferente prioridad, y en este programa se demuestra que
* el hilo de mayor prioridad es el que se ejecuta primero luego el que le precede
* y ası́ sucesivamente.
* La mas alta prioridad es el mas negativo (-) 0
* La mas baja prioridad es el mas positivo (+) 7
*/
/**********************************************************************************/
#include <zephyr.h>
#include <sys/printk.h>
#include <kernel.h>
/* retardo entre saludos (en ms) */
#define SLEEPTIME 5000
/**********************************************************************************/
/* se define el semáforo */
K_SEM_DEFINE(coop_sem1, 1, 1);
/**********************************************************************************/
/* Esta es la función del hilo que tiene la mayor prioridad */
void metairq_thread(void) {
while (1) {
k_sem_take(&coop_sem1, K_FOREVER);
printk("---> trabajando metairq\n");
k_sem_give(&coop_sem1);
k_msleep(SLEEPTIME);/* El hilo A es generado automáticamente */
}
}
/* Esta es la función del hilo que tiene intermedia prioridad */

7
void coop_thread1(void) {
while (1) {
k_sem_take(&coop_sem1, K_FOREVER);
printk("---> trabajando hilo 1\n");
k_busy_wait(100000);
k_sem_give(&coop_sem1);
}
}
/* Esta es la función del hilo que tiene la menor prioridad */
void coop_thread2(void) {
while (1) {
k_sem_take(&coop_sem1, K_FOREVER); // sem2
for (int i = 0; i < 5; i++) {
printk("---> trabajando hilo 2\n");
k_busy_wait(100000);
}
k_sem_give(&coop_sem1); // sem2
}
}

/* Los hilos son creados en el momento de la compilación */

K_THREAD_DEFINE(mtirq_id, 512, metairq_thread, 0, 0, 0, K_PRIO_COOP(0), 0, 0); // tiene prioridad 0
K_THREAD_DEFINE(co1_id, 512, coop_thread1, 0, 0, 0, K_PRIO_COOP(2), 0, 0); // tiene prioridad 2
K_THREAD_DEFINE(co2_id, 512, coop_thread2, 0, 0, 0, K_PRIO_COOP(7), 0, 0); // tiene prioridad 7
/*(De los tres 7 es de menor prioridad que el de 2 y este ultimo menor prioridad que el de 0)

/******************************* F I N *********************************/