Descarga este documento en formato PDF - Ucontrol

18 de 22
utilice en las técnicas de programación anterior porque la ejecución secuencial del código presupone que no se
requiera de un mecanismo como este.
Lo más cercano al método descrito en el poner datos en algún lugar para que una función lo procese es el uso
de las interrupciones, éstas deben procesar rápidamente el evento de interrupción y pude que pongamos el
dato en algún lugar y levantemos una bandera para que cuando a la función encargada de procesar los datos
le toque ejecutarse lea la bandera, procese los datos y coloque la bandera en el estado que notifica que ya se
procesó, no para notificar a otra función sino para notificárselo a ella misma, no vaya a ser que cuando le
toque ejecutarse nuevamente procese los mismos resultados nuevamente o haga algo indebido.
Un ejemplo de lo anterior puede se el uso del conversor AD, en algún lugar del programa lo mandamos a
convertir; una vez hecha la conversión se produce una interrupción que es atendida en la correspondiente
subrutina de atención a esa interrupción; leemos el dato lo ponemos en una variable e incrementamos un
contador. Posteriormente le toca ejecutarse a la función que promedia los resultados, ésta comprueba si hay,
digamos 200 muestras, si las hay hace el cálculo que pone en otra variable y deja el contador en cero. Este
mecanismo es eficaz porque se ha utilizado durante mucho tiempo, pero los RTOS brindan una solución
elegante para hacer esto en el contexto de la ejecución de tareas.
Estos mecanismos pueden funcionar también entre funciones pero tendremos el problema de tratar con un montón de
estructuras de datos, banderas y contadores, complejas expresiones lógicas a procesar… ¿se acuerdan de eso?
Ahora imagínense hacer todo lo anterior cuando, en vez de llamadas a funciones metidas dentro de un código
que se ejecuta más o menos estructuradamente, lo que tenemos es unas cuantas tareas de las que no
tenemos un control de cuando ni como se ejecutarán. Realmente puede ser una verdadera pesadilla hacer un
programa productivo, y es por ello que los RTOS nos ofrecen un poderoso mecanismo para hacer eso, y como
siempre, este mecanismo también es relativamente simple.
Para hacer lo anterior los RTOS implementan un mecanismo de mensajes. Sí, amigos míos, un RTOS
implementa una función similar a la de los correos.
El funcionamiento de ese mecanismo es simple, cuando una tarea o subrutina de atención a interrupciones
necesita notificarle algo a otra tarea llama a una función que pone el dato en la cola de la tarea en cuestión,
cuando a la tarea que recibió el mensaje le toca ejecutarse debe, en algún lugar consultar su cola de
mensajes, si hay mensajes debe leerlos y procesarlos, como pueden ver este mecanismo es bastante parecido
a lo que hacemos habitualmente.
Si yo quiero pasarles un mensaje, por ejemplo un post, hago lo siguiente:
- lo escribo, este es el equivalente a realizar una tarea
- lo mando al foro, este es el equivalente a ponerlo en la cola de mensajes del hilo sobre RTOS
- ustedes llegan y consultan si hay mensajes nuevos en el hilo, por supuesto llegan cuando su tarea de leer el
foro está activa
- si hay un mensaje nuevo, normalmente tratarán de leerlo y poner en práctica los nuevos conocimientos
- si se sienten impresionados, me escribirán un mensaje a mi correo privado, dándome un acuse de recibo (no
hagan esto si no es estrictamente necesario, no vaya a ser que me vuelvan loco)
Aquí se ha puesto de manifiesto un ejemplo del sistema de mensajes más simple utilizado por un SO: elaborar
y enviar de una parte y consultar si hay un mensaje, procesar y enviar acuse de recibo si es necesario de la
otra parte.
(Todo esto está muy bien. Pero yo quiero código y ejemplos de verdad.)
Vale, no nos ofusquemos, primero entender bien el concepto, luego ponerlo en práctica.
Lo primero que tenemos que hacer es decirle al compilador que le cree una cola de mensajes a aquella tarea a
la cual queremos pasarle mensajes, para eso tenemos el parámetro queue, dentro de la directiva #task, con
este parámetro le indicamos al RTOS que reserve memoria y cree una cola de mensajes para la tarea, la
declaración de una tarea con cola de mensajes sería como sigue:
El código:
#task(rate = 1s, max=20ms, queue=5)
void Tarea1(void);
En la declaración de la tarea el parámetro queue = 5, le dice al compilador que cree una cola de 5 bytes para
la Tarea1.
Para el envío y recepción de mensajes tenemos las siguientes funciones:
RTOS_MSG_SEND( )
RTOS_MSG_POLL( )
RTOS_MSG_READ( )