Fase 4: FreeRTOS y Conectividad IoT

📖 Teoría a Estudiar

El Dictador Preemptivo: Regla #1 del RTOS

La regla fundamental de FreeRTOS (y cualquier RTOS moderno) es matemáticamente simple pero brutal: El procesador SIEMPRE ejecutará la tarea con la prioridad más alta que esté en estado READY (Lista).

Esto significa que si tienes una tarea de prioridad Alta, una Normal y una Baja, el RTOS *nunca* repartirá el tiempo equitativamente. La tarea de prioridad Alta se adueñará del 100% de la CPU indefinidamente.

El Peligro de la Inanición (Starvation)

Si escribes tu tarea de prioridad Alta así:

void Tarea_Valvula() { 
    while(1) { 
        Leer_Presion(); // Cuidado, ¡no hay osDelay()!
    } 
}

Has creado un agujero negro. Como esta tarea siempre está ejecutando código y nunca cede voluntariamente la CPU pasando al estado BLOCKED, las tareas Normal y Baja jamás recibirán ni un solo microsegundo de CPU. A este fenómeno fatal se le conoce como Inanición (Starvation). La pantalla de tu máquina se quedará congelada para siempre y el WiFi jamás enviará un paquete.

El Equilibrio del Ecosistema

Para evitar la Inanición, las tareas de Prioridad Alta deben ser diseñadas como Francotiradores: Se despiertan por un evento (o por un osDelay), ejecutan su trabajo en 50 microsegundos de manera ultrarrápida, y se vuelven a dormir (BLOCKED) inmediatamente. Al dormir, la CPU automáticamente cae en cascada hacia las tareas de menor prioridad.

⚙️ Ejercicios Prácticos

Ejercicio 1: Vamos a crear nuestro ensamble en C asignando prioridades CMSIS-OS v2. Utilizaremos osPriorityRealtime para la Tarea de Válvula, asegurando que si ocurre un evento de cierre, el RTOS acribille inmediatamente cualquier otra tarea (incluso si la pantalla está dibujando) para apagar la salida física.

/**
 * @file priority_test.c
 * @brief Implementación de Jerarquía Estricta en Despachador de Gas LP
 */

#include "stm32f401xe.h"
#include "cmsis_os2.h"

// =======================================================
// TAREA 3: VÁLVULA Y SEGURIDAD (Prioridad MÁXIMA / Realtime)
// Diseño de Francotirador: Ejecución rápida y a dormir.
// =======================================================
void Thread_Seguridad_Valvula(void *argument) {
    for (;;) {
        // [1. DESPIERTA]
        // Lee hardware instantáneamente
        float presion_actual = Leer_Sensor_Presion_ADC();
        float litros = Metro_GetLitros();
        
        // [2. ACCIÓN DE CIRUJANO]
        if (presion_actual > LIMITE_PRESION_PELIGRO || litros >= LIMITE_VENTA) {
            // ¡CIERRE INMEDIATO! Como tiene prioridad Realtime, 
            // esta línea se ejecuta a los pocos microsegundos de despertarse.
            Valvula_SetApertura(0.0f);
        }
        
        // [3. CEDE EL CONTROL (Evita Starvation)]
        // Duerme por 10ms. La CPU automáticamente "cae" al Hilo de Pantalla.
        osDelay(10); 
    }
}

// =======================================================
// TAREA 2: INTERFAZ LCD (Prioridad NORMAL)
// =======================================================
void Thread_Pantalla_LCD(void *argument) {
    for (;;) {
        // Actualizar la pantalla por SPI toma como 20ms.
        // Mientras esto ocurre, el RTOS nos interrumpirá internamente 
        // 2 veces para darle paso rápido a la Tarea de la Válvula.
        UI_Dibujar_Pantalla_Completa();
        
        // Cede el control por 50ms (Refresco a 20 FPS).
        // Al dormir, la CPU "cae" al Hilo WiFi.
        osDelay(50); 
    }
}

// =======================================================
// TAREA 1: IOT WIFI (Prioridad BAJA)
// =======================================================
void Thread_WiFi_Cloud(void *argument) {
    for (;;) {
        // Tarea monstruosamente lenta (Tarda varios segundos).
        // Si usamos polling o enviamos cadenas inmensas de JSON, no nos importa.
        // Debido a que tiene prioridad LOW, el RTOS la pausará sin piedad
        // cada vez que la Pantalla o la Válvula necesiten trabajar.
        Conectar_A_Red_Y_Enviar_Ticket();
        
        // Intenta enviar datos 1 vez por segundo
        osDelay(1000);
    }
}

// =======================================================
// CONFIGURACIÓN E INICIO DEL RTOS
// =======================================================
int main(void) {
    SystemClock_Config();
    osKernelInitialize();
    
    // ATRIBUTOS (¡Notar el cambio radical de prioridades!)
    const osThreadAttr_t attr_valvula = {
        .name = "ValveTask",
        .stack_size = 512,
        .priority = osPriorityRealtime, // MÁXIMA AUTORIDAD (Solo reservado para la vida y la muerte)
    };
    
    const osThreadAttr_t attr_pantalla = {
        .name = "LCDTask",
        .stack_size = 1024,
        .priority = osPriorityNormal,   // Tarea estándar de rutina
    };
    
    const osThreadAttr_t attr_wifi = {
        .name = "WiFiTask",
        .stack_size = 2048,
        .priority = osPriorityLow,      // Esclavo del sistema. Solo come las sobras de la CPU.
    };
    
    // CREACIÓN
    osThreadNew(Thread_Seguridad_Valvula, NULL, &attr_valvula);
    osThreadNew(Thread_Pantalla_LCD, NULL, &attr_pantalla);
    osThreadNew(Thread_WiFi_Cloud, NULL, &attr_wifi);
    
    osKernelStart();
    while (1);
}
        

📝 Resumen del Día

• En un sistema operativo de tiempo real (RTOS), la CPU jamás se comparte de manera "democrática" (Round-Robin absoluto). **La tarea con la prioridad más alta que esté lista para ejecutarse monopolizará el procesador.**
• La **Inanición (Starvation)** ocurre cuando una tarea de alta prioridad monopoliza el procesador de forma permanente (ej. con un bucle infinito continuo), impidiendo que tareas de menor prioridad se ejecuten jamás.
• Para evitar la inanición y lograr armonía, las tareas de alta prioridad deben ser diseñadas para ejecutarse brevemente y pasar al estado **BLOCKED** inmediatamente (mediante osDelay o esperando interrupciones de hardware).
• CMSIS-OS v2 ofrece un enumerador de prioridades claro: osPriorityLow (para red, logs, o tareas pesadas no críticas), osPriorityNormal (rutinas de aplicación de UI o teclado), osPriorityHigh o osPriorityRealtime (exclusivo para seguridad humana, motores, válvulas y algoritmos PID hipercríticos).