Interrupciones en FreeRTOS y funciones FromISR

Una interrupción es un evento de hardware que detiene temporalmente la ejecución normal para atender algo urgente mediante una ISR.

Inauguramos el último bloque del curso entrando en una zona delicada. Hasta ahora, todo lo que hemos programado (Tareas, Colas, Timers) ocurría dentro del mundo gestionado por el Kernel de FreeRTOS.

El mundo real es asíncrono. Un botón se pulsa, un paquete WiFi llega, un sensor I2C termina de leer. Estos eventos disparan interrupciones (ISRs - Interrupt Service Routines).

Una interrupción hace que el núcleo pause la tarea actual y ejecute una rutina específica. Según la arquitectura y las prioridades configuradas, otra interrupción más prioritaria todavía puede interrumpir esa ISR.

En un RTOS, las interrupciones son delicadas: son necesarias para la reactividad, pero si no seguimos unas reglas básicas, podemos provocar reinicios aleatorios (Guru Meditation Error en ESP32).

Hoy vamos a aprender a domar las ISRs.

API desde tarea e ISR

Para qué sirve portYIELD_FROM_ISR

Muchas funciones FromISR reciben un parámetro llamado pxHigherPriorityTaskWoken.

¿Para qué sirve? Entendamos el flujo:

1. El sistema está ejecutando una tarea de Baja Prioridad.
2. Salta la Interrupción.
3. La ISR le da un Semáforo a una tarea de Alta Prioridad que estaba esperando.
4. Ahora la tarea de Alta Prioridad está Ready.

Si la ISR termina sin hacer nada más, el Scheduler no se entera inmediatamente. La CPU volverá a la tarea de Baja Prioridad y la tarea Alta no se ejecutará hasta el próximo Tick del sistema (que puede tardar 1ms). ¡Hemos perdido reactividad!

Para evitar esto, las funciones FromISR nos “chivan” si hemos despertado a alguien importante.

// Variable booleana (BaseType_t en FreeRTOS)
BaseType_t xHigherPriorityTaskWoken = pdFALSE;

// La función modifica esta variable a pdTRUE si despertó a una tarea importante
xSemaphoreGiveFromISR(miSemaforo, &xHigherPriorityTaskWoken);

// Si es TRUE, solicitamos un cambio de contexto VOLUNTARIO e INMEDIATO
if(xHigherPriorityTaskWoken == pdTRUE) {
    portYIELD_FROM_ISR(); 
}

Al llamar a portYIELD_FROM_ISR, pedimos al Scheduler que decida de nuevo al salir de la interrupción. Si corresponde, la CPU continúa con la tarea recién desbloqueada. La latencia sigue dependiendo de la ISR, de interrupciones más prioritarias y de las secciones críticas activas.

Ejemplo completo

Vamos a implementar el patrón de procesamiento diferido usando un botón y un semáforo binario, aplicando todo lo aprendido.

En ESP32, IRAM_ATTR coloca la función en RAM. Es necesario cuando la ISR debe seguir disponible con la caché de Flash deshabilitada, pero no basta por sí solo: todas las funciones y los datos a los que acceda también deben ser seguros para ese contexto.

#include <Arduino.h>

// Recursos globales
SemaphoreHandle_t semaforoBoton;
#define PIN_BOTON 0

// --- ISR (Interrupción) ---
// Regla 1: Corta. Regla 2: No bloqueante. Regla 3: API FromISR.
void IRAM_ATTR isrBoton() {
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    // Enviamos la señal
    xSemaphoreGiveFromISR(semaforoBoton, &xHigherPriorityTaskWoken);

    // Solicitamos cambio de contexto si es necesario
    if(xHigherPriorityTaskWoken) {
        portYIELD_FROM_ISR();
    }
}

// --- Tarea Diferida (Procesamiento) ---
void TareaManejadora(void *pvParameters) {
    for(;;) {
        // Aquí SÍ podemos bloquearnos esperando
        if(xSemaphoreTake(semaforoBoton, portMAX_DELAY) == pdTRUE) {
            
            // Trabajo pesado (ej. escribir en SD, Serial, Network)
            Serial.println("Interrupción recibida. Procesando...");
            
            // Simulamos carga
            for(int i=0; i<5; i++) {
                digitalWrite(LED_BUILTIN, HIGH);
                vTaskDelay(pdMS_TO_TICKS(50));
                digitalWrite(LED_BUILTIN, LOW);
                vTaskDelay(pdMS_TO_TICKS(50));
            }
        }
    }
}

void setup() {
    Serial.begin(115200);
    pinMode(LED_BUILTIN, OUTPUT);
    pinMode(PIN_BOTON, INPUT_PULLUP);

    // Crear semáforo binario
    semaforoBoton = xSemaphoreCreateBinary();

    if (semaforoBoton == NULL) {
        Serial.println("No se pudo crear el semáforo");
        return;
    }

    // Crear tarea con prioridad ALTA
    // Queremos que en cuanto pulse el botón, esta tarea interrumpa al resto
    xTaskCreate(TareaManejadora, "Handler", 2048, NULL, 3, NULL);

    // Configurar interrupción
    attachInterrupt(digitalPinToInterrupt(PIN_BOTON), isrBoton, FALLING);
}

void loop() {
    // Tarea de fondo de baja prioridad
    Serial.println("Loop haciendo cosas irrelevantes...");
    vTaskDelay(pdMS_TO_TICKS(1000));
}

Secciones críticas

A veces, la ISR y una Tarea comparten una variable simple (ej. un contador volatile int contador) y no queremos usar la sobrecarga de un semáforo o cola.

Si la Tarea está leyendo la variable y la ISR salta justo en medio y la modifica, tendremos corrupción de datos.

Para evitar que una ISR interrumpa un trozo de código sensible, usamos Secciones Críticas.

portMUX_TYPE mux = portMUX_INITIALIZER_UNLOCKED;

// Dentro de una tarea: toma el spinlock y enmascara
// las interrupciones gestionadas por este mecanismo en el núcleo actual.
portENTER_CRITICAL(&mux);

// --- Código atómico y muy rápido ---
contadorGlobal++; 
// ----------------------------------

// 2. Salir de sección crítica (Rehabilita interrupciones)
portEXIT_CRITICAL(&mux);

En un ESP32 de dos núcleos, el spinlock evita que el otro núcleo entre en una sección protegida por el mismo portMUX_TYPE. Desde una ISR se usan las variantes portENTER_CRITICAL_ISR y portEXIT_CRITICAL_ISR.