Un Super-Loop es el clásico while(1) donde ejecutas leer_sensores(), luego actualizar_pantalla() y luego enviar_wifi(). Es secuencial. Si el envío de Wi-Fi se atora por mala señal, la pantalla se congela y los sensores dejan de leerse. Para tareas triviales es suficiente; para maquinaria industrial de riesgo, es inaceptable.
Un RTOS no hace que tu procesador sea más rápido, lo hace Determinista. "Tiempo Real" no significa "inmediato", significa que se garantiza una respuesta dentro de una ventana de tiempo predecible y estricta (Deadline). En lugar de un gran while(1), divides tu código en Tareas (Tasks) independientes. El componente mágico del RTOS se llama el Scheduler (Planificador).
El procesador ARM Cortex-M4 tiene un hardware especial (Timer SysTick y manejador de interrupciones PendSV) diseñado para el RTOS. Cada 1 milisegundo (Tick), el Scheduler interrumpe violentamente a la tarea actual. Si una Tarea de Alta Prioridad (Ej. Cortar Válvula) necesita correr, el RTOS hace un Context Switch: guarda los registros de la CPU de la tarea actual en la memoria RAM (Stack), carga los registros de la tarea prioritaria y le cede el procesador de inmediato. Esto se llama Preemptive Multitasking (Multitarea Apropiativa).
En FreeRTOS, en lugar de invocar funciones desde main(), creamos Tareas. Cada Tarea es un bucle while(1) infinito con su propia área de memoria RAM dedicada, llamada Pila (Stack). El Scheduler del RTOS decide qué bucle infinito se ejecuta en la CPU en cada instante, basándose estrictamente en un nivel de Prioridad que tú, como Arquitecto, debes asignar.
Regla de oro: Jamás uses HAL_Delay() dentro de un RTOS. Un delay tradicional bloquea la CPU entera quemando ciclos de reloj en un bucle vacío. En FreeRTOS, debes usar vTaskDelay() o osDelay(). Al llamar esta función, la tarea le dice al Scheduler: "Ponme a dormir por 100ms. Quítame el procesador y dáselo a otra tarea que lo necesite".
Observa el contraste. En un Super-Loop, el hardware está a merced del código más lento. En RTOS, el código está a merced del núcleo planificador que crearemos.
/**
* @file rtos_transition_concept.c
* @brief Estructura conceptual para la creación de Tareas (Preparación Fase 6)
*/
#include "FreeRTOS.h"
#include "task.h"
// =========================================================================
// DEFINICIÓN DE TAREAS INFINTAS (Cada una parece adueñarse de la CPU entera)
// =========================================================================
// Tarea 1: Metrología y Seguridad (Prioridad: ALTA)
void Task_Metrology_Safety(void *pvParameters) {
while(1) {
// 1. Monitorea sensores críticos y límites de presión
if (Check_Emergency_Conditions()) {
Valve_Close_Instantly();
}
// 2. Cede el procesador por 10 ms exactos (El Scheduler se lo da a otra tarea)
vTaskDelay(pdMS_TO_TICKS(10));
}
}
// Tarea 2: Interfaz HMI LCD (Prioridad: MEDIA)
void Task_LCD_Display(void *pvParameters) {
while(1) {
// 1. Actualiza la pantalla con el volumen actual
LCD_Update_Screen();
// 2. El ojo humano no percibe cambios más rápidos que 50ms. Cedemos la CPU.
vTaskDelay(pdMS_TO_TICKS(50));
}
}
// Tarea 3: Comunicación IoT a la Nube (Prioridad: BAJA)
void Task_WiFi_Cloud(void *pvParameters) {
while(1) {
// 1. Envía paquete MQTT. Si el Wi-Fi tarda 2000ms, esta tarea se bloquea.
// PERO EL SISTEMA NO SE CUELGA. El Scheduler nota que esta tarea está
// bloqueada y le devuelve el control a la Metrología (Prioridad Alta)
ESP32_Send_Telemetry();
// 2. Enviar datos cada 5 segundos.
vTaskDelay(pdMS_TO_TICKS(5000));
}
}
// =========================================================================
// PUNTO DE ENTRADA MAIN (ARRANQUE DEL UNIVERSO RTOS)
// =========================================================================
int main(void) {
Hardware_Init(); // Inicializa Clocks, GPIO, I2C, SPI (Bare-Metal)
// El Arquitecto crea el Universo. Se asigna Stack y Prioridad a cada tarea.
xTaskCreate(Task_Metrology_Safety, "Safety", 512, NULL, configMAX_PRIORITIES - 1, NULL);
xTaskCreate(Task_LCD_Display, "Display", 256, NULL, 2, NULL);
xTaskCreate(Task_WiFi_Cloud, "WiFi", 512, NULL, 1, NULL);
// Se cede el control absoluto del procesador al Scheduler del RTOS.
// La función main() jamás pasará de esta línea.
vTaskStartScheduler();
while(1); // Dead code. Si llegamos aquí, el RTOS colapsó (Falta de RAM).
}
Objetivo del día: Consolidación del Paradigma de Concurrencia y Fundamentos RTOS.
El hardware industrial que terminaste en la Fase 5 es un portento físico, pero su verdadero potencial intelectual estaba reprimido. Tu Despachador de Gas LP requiere comunicarse con un servidor en AWS para procesar pagos (ESP32), leer un sensor I2C en la pantalla, gestionar los pulsos metrológicos al microsegundo y verificar la válvula de cierre cada 10 milisegundos. Ejecutar todo esto en un Super-Loop es jugar a la ruleta rusa; tarde o temprano, una colisión de tiempos de ejecución causará que la máquina ignore un comando crítico.
Al entender la mecánica de **Preemption y Context Switching** del FreeRTOS, te has preparado para gobernar el tiempo de tu procesador. En lugar de escribir un código lineal que espera pasivamente a que un periférico responda, vas a fragmentar la lógica de la máquina en compartimentos estancos (Tasks). Si la tarea encargada del Wi-Fi enloquece o el servidor de AWS cae, el Scheduler simplemente la pondrá a dormir, asegurando que la tarea de Seguridad y Válvulas mantenga siempre el control primario del procesador ARM Cortex-M4. Has pasado de ser un programador que escribe rutinas, a un Director de Orquesta que gestiona recursos.
HAL_Delay(). En su lugar, se utilizan bloqueos del RTOS (vTaskDelay), los cuales informan al Scheduler que la tarea actual no necesita el procesador, maximizando la eficiencia energética y operativa del sistema.