Notificaciones (II)
En la lección anterior vimos la forma de pasar un dato de hasta 32 bits utilizando las notificaciones directas a las tareas que FreeRTOS provée como un mecanismo incorporado “de fábrica” (todas las tareas incluyen un campo de 32 bits). En la lección de hoy veremos cómo utilizar este mismo mecanismo pero para pasar notificaciones (banderas, avisos) de una tarea a otra.
Tabla de contenidos
- ¿Qué es y qué necesito?
- Operaciones a nivel de bit
- Notificaciones de 1 bit
- Codificando bits y datos
- ¿Qué sigue?
¿Qué es y qué necesito?
Este tipo de notificaciones son a nivel de bit; un bit puesto a 1 podría indicar que un sensor se activó, o que una lectura del ADC ya está lista para ser leída, o que un botón se presionó. La tarea productora pondría uno o varios bits a 1 y después la tarea receptora, esperará por el evento, liberando la CPU hasta que le lleguen una o varias notificaciones.
El caso más simple es el de las notificaciones de un sólo bit: la conversión terminó, llegó un byte por el puerto serial (sólo avisa que el byte llegó, no el valor propio de la información), un botón fue presionado (no el valor del botón presionado).
Casos más complejos podrían ser que, además de indicar que el eventó sucedió, pasar la información relacionada a éste. En el ejemplo de una conversión podemos pasar, además, el canal del ADC y el valor de la lectura. En el caso del byte del puerto serial podemos pasar, también, el valor del byte. Y finalmente, para el ejemplo del botón podemos indicar el botón que fue presionado. En todos y cada uno de estos escenarios estaremos utilizando el campo de 32 bits asociado a las notificaciones.
Operaciones a nivel de bit
Máscaras de bits
Antes de entrar en los detalles para usar las notificaciones debemos recordar las máscaras de bits, o simplemente máscaras. Una máscara es una secuencia de bits que indican cuáles bits nos interesan y cuáles no tienen importancia. Para la siguiente explicación usaremos 8 bits, por simplicidad, pero la idea se traslada directamente a los 32 bits disponibles.
Entonces, tenemos 8 bits cuyas posiciones van de la 0 a la 7, contando de derecha a izquierda:
dibujo
Y supongamos que de estos bits nos interesan aquellos en las posiciones 1, 3 y 6. Por lo tanto, debemos descartar los bits en las posiciones 0, 2, 4, 5, 7. Para esto deberemos crear una máscara con 1s en los bits que nos interesan, y con 0s en los bits que no:
dibujo
Este valor lo podemos expresar ya sea en binario o en hexadecimal, siendo esta última la manera más común
#define MASK 0x4A
Una vez que tenemos a la máscara debemos aplicársela al dato del cual queremos discriminar los bits, es decir, quedarnos con los bits que nos interesan. Para ello utilizaremos la operación AND a nivel de bit de C, &. Digamos que nuestro dato tiene el valor 0xFD (en binario, 1111 1101), entonces, de forma gráfica, la aplicación de la máscara es así:
Y en código en C nos queda así:
uint8_t dato = 0xFD; uint8_t res = dato & MASK; // res <- 0x48
El resultado es 0x48 (en binario, 0100 1000). Esto significa que de nuestro dato el bit 1 vale 0, el bit 3 vale 1, y el bit 6 vale 1. Ya dependerá de nuestra aplicación qué haremos con esta información, lo cual por supuesto estará en los ejemplos que veremos más adelante.
(Si quieres profundizar en las operaciones a nivel de bit, de las cuales hay muchas, puedes ir aquí; y para revisar las operaciones a nivel de bit en C, puedes ir aquí (en inglés)).
Notificaciones de 1 bit
El caso más simple es cuando tienes una sola notificación, la cual puedes codificar con un sólo bit. Si el bit está a 0, el evento no ha sucedido, y si el bit está a 1, entonces el eventó sucedió.
También tenemos el caso en que metemos varios bits independientes en el mismo campo de 32 bits. Esto es útil cuando una misma tarea debe notificar a otra tarea de diversas situaciones, donde cada situación requiere un bit. En el ejemplo a continuación utilizaremos varios bits individuales.
NOTA: Las notificaciones de un sólo bit se parecen más a un mecanismo de sincronización llamado semáforo binario. Éstos no incluyen ningún tipo de información, solamente avisan que un evento sucedió (o que no ha sucedido). Por lo tanto, y como el propio FreeRTOS lo menciona, una forma rápida y barata de implementar semáforos binarios es a través de las notificaciones. Debo señalar, sin embargo, que FreeRTOS incluye semáforos (binarios y contadores) con más características (entre otras, un productor puede notificar a varios receptores), pero que, naturalmente, consumen más recursos.
Ejemplo
En este ejemplo haremos lecturas analógicas para la temperatura ambiente (utilizando al sensor LM35), y avisaremos a la tarea receptora si la temperatura cae en uno de 4 estados: menor a 17 grados centígrados, entre 17 y 24.99 grados, entre 25 y 28.99 grados, y mayor o igual a 29 grados. Cada estado está representado por un bit. Escogí los bits 0-3 del campo de notificación, pero por supuesto tú puedes utilizar la distribución que desees:
#include <FreeRTOS.h>
#include <task.h>
TaskHandle_t consumidor_h;
void Productor1_task( void* pvParameters )
{
TickType_t last_wake_time = xTaskGetTickCount();
while( 1 )
{
vTaskDelayUntil( &last_wake_time, pdMS_TO_TICKS( pdMS_TO_TICKS( 1000 ) ) );
float temp = ( analogRead( A0 ) * 5.0 * 100.0 ) / 1024;
uint32_t flags = 0;
if( temp < 17.0 ) flags = 0x00000001;
else if( temp < 25.0 ) flags = 0x00000002;
else if( temp < 29.0 ) flags = 0x00000004;
else flags = 0x00000008;
xTaskNotify( consumidor_h, flags, eSetValueWithOverwrite );
}
}
void Consumidor_task( void* pvParameters )
{
while( 1 )
{
uint32_t res;
if( xTaskNotifyWait( 0xfffffff0, 0xffffffff, &res, pdMS_TO_TICKS( 2000 ) ) != pdFALSE ){
if( res & 0x01 ){
Serial.println( "Hace un poco de frío.\n" );
} else if( res & 0x02 ){
Serial.println( "El tiempo es agradable." );
} else if( res & 0x04 ){
Serial.println( "Hace algo de calor." );
} else{
Serial.println( "Hace mucho calor." );
}
} else{
Serial.println( "ERR: No se recibió la notificación." );
}
}
}
void setup()
{
Serial.begin( 115200 );
xTaskCreate( Productor1_task, "PRD1", 256, NULL, tskIDLE_PRIORITY + 1, NULL );
xTaskCreate( Consumidor_task, "CONS", 256, NULL, tskIDLE_PRIORITY, &consumidor_h );
vTaskStartScheduler();
}
void loop()
{
}
En la tarea consumidora, Consumidor_task(), podrás notar 2 cosas en la llamada a la función xTaskNotifyWait():
- Utilicé las máscaras de entrada y salida (primero y segundo parámetro, respectivamente) para el campo de notificaciones.
- Establecí un tiempo de guarda de 2000 ms.
Recordemos la firma de dicha función:
El parámetro ulBitsToClearOnEntry es una máscara que pone a 0 los bits indicados del campo de notificación cuando se entra a la función. Lo podemos utilizar para descartar los bits que no nos interesen. Un bit a 1 significa que el bit en esa posición del campo de notificaciones será puesto a 0. En el ejemplo observarás que descarté los bits 4-31, ya que en la tarea productora solamente utilicé del 0-3.
El parámetro ulBitsToClearOnExit es una máscara que pone a 0 los bits indicados del campo de notificación cuando se sale de la función. Lo podemos utilizar para avisar que ya leímos el campo de notificación. Recuerda que la función xTaskNotify() tiene un parámetro de control, eAction (de tipo eNotifyAction), con el cual la tarea productora podría fallar si pretendieras escribir una nueva notificación sin que la tarea consumida haya leído la anterior (cuando eAction es eSetValueWithoutOverwrite). En el ejemplo establecí que los 32 bits se pusieran a 0 a la salida de la función.
Finalmente, establecí un tiempo de guarda de 2000 ms. La tarea productora realiza una lectura cada 1000 ms, pero si por alguna razón no hiciera la notificación dentro de esa ventana de 2000 ms, entonces la tarea consumidora imprimiría un mensaje de error.
A continuación tienes un fragmento de la salida de este ejemplo:
Ejercicio: Comenta la línea
xTaskNotify( consumidor_h, flags, eSetValueWithOverwrite );
en la tarea productora y observa el resultado.
Codificando bits y datos
Otra cosa interesante que podemos hacer con el campo de notificaciones es codificar en el mismo tanto datos como bits. Al ejemplo anterior podríamos agregarle que, además de indicar con bits el rango de temperatura, notifique la temperatura (para esto deberemos haremos algunos cambios en el código).
Para lograr lo anterior necesitaremos revisar dos cosas antes: poner bits a 1 y desplazamientos.
Poniendo bits a 1
En la sección anterior vimos cómo poner a 0 bits de una máscara usando al operador a nivel de bits de C ‘and’, &. Lo que necesitamos ahora es poner bits a 1; para ello necesitamos al operador ‘or’ a nivel de bits de C, | (una barra). Requeriremos una máscara que indique los bits a poner a 1, y por supuesto el dato (variable) en el cual pondremos a 1 dichos bits.
Por ejemplo, supón que nuestro dato tiene el valor 0x28 y queremos poner sus bits en las posiciones 0, 1, 4, 5 a 1. Entonces creamos una máscara con 1’s en dichas posiciones, y 0’s en el resto: 0x33 (en binario 0011 0011). Después de aplicarle esta máscara a nuestro dato, éste queda con el valor 0x3B:
Los bits que en el dato original ya estaban a 1 y le tocó ponerse a 1, no cambian de valor. Así mismo, los bits que tenían 1 y le aplicas un 0, quedan con 1; es decir, una máscara OR con 0 no afecta el valor del bit.
La operación anterior en C queda como
uint8_t dato = 0x28; uint8_t res = dato | 0x33; // res <- 0x3B
Desplazando bits
La siguiente operación a nivel de bit es el desplazamiento: mover uno o más bits una o más posiciones a la izquierda o a la derecha. C cuenta con los operadores << y >>, respectivamente. De paso debo comentar que el desplazamiento de un bit a la izquierda equivale a multiplicar al dato por 2; mientras que el desplazamiento de un bit a la derecha equivale a dividir al dato por 2. Dos desplazamientos a la derecha es como multiplicar por 4, y así sucesivamente.
Por ejemplo, si tienes el dato 0x03 (en decimal, 3) y lo desplazas 3 bits a la izquierda, tendrás al final el valor 0x18 (en decimal, 24). Desplazar 3 bits a la izquierda es como multiplicar 2^3=8, y 3*8=24:
La operación anterior en C queda así:
uint8_t dato = 0x03; uint8_t res = dato << 3; res <- 0x18
Es muy común que el desplazamiento se haga sobre el propio dato; es decir, lo aplicas al dato y lo guardas en el propio dato. Esta operación en C queda así:
uint8_t dato = 0x03; // 0000 0011 dato <<= 3; // dato <- 0x18, es decir, 0001 1000 // la operación "larga" es: dato = dato << 3; dato >>= 1; // dato <- 0x0C, es decir, 0000 1100, en decimal, 12
Ejemplo
Ahora sí, equipados con las herramientas adecuadas es momento de ver cómo podemos codificar en el campo de notificaciones tanto datos como bits. El ejemplo consta de realizar lecturas en 3 canales del convertidor ADC, una lectura por segundo. La tarea productora notificará a la tarea consumidora el canal del cuál se realizó la lectura (con bits individuales, como el ejemplo pasado) y el valor de la lectura correspondiente (sin procesar). Es decir, un canal del ADC será 0x01, otro canal será 0x02, y otro canal será 0x04. Por otro lado, el dato de 10 bits de la lectura lo insertaremos a partir del bit 16 (este valor no tiene nada de especial, solamente quise abarcar la mayor cantidad posible de bits en el campo de notificación).
NOTA: Mientras trabajaba en el siguiente ejemplo noté un error del compilador de C que Arduino utiliza (avr-gcc): Los desplazamientos a la izquierda NO FUNCIONAN con variables de más de 8 bits. Los desplazamientos a la derecha, sí. En el código notarás que realicé una multiplicación por 65536, lo cual es equivalente a un desplazamiento de 16 bits a la izquierda. Este es un problema de Arduino y su compilador, no de FreeRTOS.
(“No funcionan” significa que sí compilan, pero los resultados son incorrectos, por lo cual no son confiables y no deberías utilizarlos. Una solución es lo que yo hice, multiplicar por 2^n.)
Recuerda que debes activar el uso de las notificaciones en el archivo de configuración FreeRTOSConfig.h. Lo hicimos en el post anterior, pero en caso de que no lo hayas hecho, entra a dicho archivo y escribe la siguiente línea al final del mismo:
#define configUSE_TASK_NOTIFICATIONS 1
Veamos el ejemplo:
#include <FreeRTOS.h>
#include <task.h>
TaskHandle_t consumidor_h;
void Productor1_task( void* pvParameters )
{
TickType_t last_wake_time = xTaskGetTickCount();
uint8_t channel;
uint16_t read;
while( 1 )
{
for( uint8_t cont = 0; cont < 3; ++cont ){
vTaskDelayUntil( &last_wake_time, pdMS_TO_TICKS( pdMS_TO_TICKS( 1000 ) ) );
switch( cont ){
case 0:
read = analogRead( A0 );
channel = 0x01; // 1
break;
case 1:
read = analogRead( A2 );
channel = 0x02; // 10
break;
case 2:
read = analogRead( A3 );
channel = 0x04; // 100
break;
default:
while( 1 );
break;
}
uint32_t notif = channel | ( read * 65536 );
// aquí realizamos la codificación de la lectura y el canal
//
// NOTA: El compilador avr-gcc emite código erróneo con los desplazamientos
// a la izquierda en variables de más de 8 bits. Sin embargo, desplazar a la
// izquierda n bits equivale a multiplicar el valor por 2^n:
// 2^16 = 65536
xTaskNotify( consumidor_h, notif, eSetValueWithOverwrite );
} // for cont
} // while 1
}
void Consumidor_task( void* pvParameters )
{
while( 1 )
{
uint32_t res;
if( xTaskNotifyWait( 0xfc00fff8, 0xffffffff, &res, pdMS_TO_TICKS( 2000 ) ) != pdFALSE ){
uint8_t channel = res & 0x00000007;
// aislamos y obtenemos los bits que codifican al canal del ADC
uint16_t read = ( res & 0x03ff0000 ) >> 16;
// aislamos y obtenemos los bits que codifican a la lectura
if( res & 0x01 ){
Serial.print( "A0: " );
} else if( res & 0x02 ){
Serial.print( "A1: " );
} else if( res & 0x04 ){
Serial.print( "A2: " );
} else{
Serial.println( "Error! " );
}
Serial.println( read );
} else{
Serial.println( "ERR: No se recibió la notificación." );
}
}
}
void setup()
{
Serial.begin( 115200 );
xTaskCreate( Productor1_task, "PRD1", 256, NULL, tskIDLE_PRIORITY + 1, NULL );
xTaskCreate( Consumidor_task, "CONS", 256, NULL, tskIDLE_PRIORITY, &consumidor_h );
vTaskStartScheduler();
}
void loop()
{
}
Escogí los canales del ADC A0, A2 y A3 sólo para complicar un poco el código (están “salteados”).
Nota que en primer parámetro de la función xTaskNotifyWait(), en la función consumidora, utilicé la máscara 0xfc00fff8, la cual descarta los bits que no usamos. Te dejo de tarea que lo compruebes (recuerda que el ADC es de 10 bits y que los bits a 1 en la máscara ponen a 0 los bits del campo de notificación).
¿Qué sigue?
Hoy vimos mucha información. Comenzamos con las operaciones a nivel de bit de C, las cuales deben estar en la caja de herramientas de cualquier programador en este lenguaje; sin embargo, hice un pequeño resumen para acordarnos de los temas que utilizaríamos. Vimos también dos usos del campo de notificaciones de las tareas: bits individuales y bits individuales más datos. Mencioné además que descubrí un error (bug) en el compilador que utiliza Arduino. Finalmente, hice mención de un tema que trataremos más adelante, el de los semáforos. Sin embargo, las notificaciones directas se pueden utilizar como semáforos binarios y semáforos contadores “ligeros”, es decir, rápidos y que no consumen muchos recursos (a expensas de estar más limitados).
En la siguiente lección exploraremos el tema de los temporizadores por software. Muchas de las tareas que realizan nuestros sistemas están basadas, de una forma u otra, en temporizaciones; y FreeRTOS incluye un mecanismo que nos facilitará la vida.
Espero que esta entrada haya sido de tu interés. Si fue así podrías suscribirte a mi blog, o escríbeme a fjrg76 dot hotmail dot com, o comparte esta entrada con alguien que consideres que puede serle de ayuda.
Mi perfil completo lo puede encontrar en: https://www.linkedin.com/in/fjrg76-dot-com/
- Is your code asking too many questions? Learn how the “Tell, Don’t Ask” principle can make your objects do the talking - enero 6, 2024
- A Beginner’s Step-by-step Guide to Custom Power Symbols in KiCAD - enero 6, 2024
- ¡Hazlo, no preguntes! O sobre cómo dejar de abusar de los getters - diciembre 9, 2023
2 COMENTARIOS