Fase 1: Fundamentos de C y Lógica de Software

📖 Teoría a Estudiar

El Fault Handler y la Rutina de Estado Seguro

En el software de escritorio, si un puntero accede a memoria inválida o divides entre cero, el programa se cierra (Crash) y ves un mensaje de error en Windows. En un microcontrolador bare-metal, no hay sistema operativo que cierre la aplicación. Cuando la CPU (como el ARM Cortex-M del STM32) detecta un error fatal, aborta la ejecución normal y salta a una interrupción especial de máxima prioridad llamada HardFault_Handler.

El código generado automáticamente por las herramientas (como STM32CubeIDE) implementa el HardFault_Handler como un bucle infinito vacío (while(1);). Esto es inaceptable en la industria. Si el microcontrolador se congela en ese bucle mientras los pines que controlan válvulas y motores estaban en estado ALTO (ON), el hardware físico se quedará encendido para siempre. La solución es inyectar una Rutina de Estado Seguro (Safe State Routine) dentro del manejador de fallos.

Los Pasos del Diseño Seguro

1. Sobrescribir el Handler: Localizar la función HardFault_Handler en tu archivo de interrupciones (ej. stm32_it.c) y modificar su contenido.
2. Acceso Bare-Metal (Sin Librerías): Dentro de un estado de fallo, no debes confiar en librerías complejas como la HAL de ST ni en funciones del RTOS, ya que sus estructuras en RAM podrían estar corruptas. Debes escribir 0 lógicos directamente en los registros de memoria de los puertos GPIO.
3. Bloqueo y Rescate: Una vez aseguradas las salidas físicas, atrapas la CPU en un bucle while(1). Esto impide que el código errático siga ejecutándose. Un temporizador independiente por hardware (Watchdog) detectará el congelamiento y forzará un reinicio eléctrico completo del chip.

⚙️ Ejercicios Prácticos

Ejercicio 1: Implementa una rutina de estado seguro bare-metal dentro de la excepción de HardFault, diseñada para apagar inmediatamente los actuadores críticos (Válvula y Bomba) antes de quedar en estado de coma inducido.

#include <stdint.h>

// Direcciones de memoria ficticias (Simulando registros de un Cortex-M STM32)
// En un código real, incluirías <stm32xxxx.h> para usar GPIOA->BSRR
#define GPIOA_BSRR (*((volatile uint32_t *) 0x40020018)) // Bit Set/Reset Register

// Constantes de hardware para los pines de tu diseño
#define PIN_VALVULA_GAS  (1 << 5)  // Supongamos que la válvula está en PA5
#define PIN_BOMBA_MOTOR  (1 << 6)  // Supongamos que la bomba está en PA6

/**
 * @brief Excepción de Máxima Prioridad: Manejador de Falla Severa de Hardware.
 * Se invoca automáticamente si la CPU choca (ej. desbordamiento de pila, 
 * acceso a memoria no alineada, puntero nulo).
 */
void HardFault_Handler(void) {
    
    // =========================================================================
    // 1. SAFE STATE ROUTINE (RUTINA DE ESTADO SEGURO)
    // =========================================================================
    // NO usamos HAL_GPIO_WritePin(). La memoria puede estar corrupta.
    // Hablamos directamente al hardware de silicio usando registros (Bare-Metal).
    // En STM32, el registro BSRR apaga pines escribiendo un 1 en la mitad superior (Reset bits).
    
    // Apagar Válvula inmediatamente (Desplazamos 16 bits para acceder al Reset)
    GPIOA_BSRR = (PIN_VALVULA_GAS << 16); 
    
    // Apagar Bomba inmediatamente
    GPIOA_BSRR = (PIN_BOMBA_MOTOR << 16);
    
    // (Opcional): Si tienes un LED rojo de error en hardware puro, enciéndelo aquí.


    // =========================================================================
    // 2. BLOQUEO TERMINAL
    // =========================================================================
    // Deshabilitar todas las interrupciones enmascarables para evitar que 
    // otro proceso intente tomar el control sobre un sistema corrupto.
    __asm("cpsid i"); 
    
    // Bucle infinito. 
    // El microcontrolador se quedará atrapado aquí.
    // El Independent Watchdog Timer (IWDG) de hardware notará que el Súper Bucle
    // dejó de "alimentarlo" y forzará un reinicio del sistema (Hard Reset).
    while (1) {
        // En desarrollo: Poner un punto de interrupción (Breakpoint) aquí 
        // para analizar los registros de la CPU con el depurador (Debugger JTAG).
    }
}
        

📝 Resumen del Día

• El HardFault_Handler es la última línea de defensa del procesador ante un error catastrófico de software o un fallo eléctrico en el bus de memoria.
• En entornos industriales, el manejador por defecto no sirve. Debes inyectar una lógica que coloque los actuadores peligrosos en un Estado Seguro (Safe State).
• Dentro de un manejador de fallas, evita invocar funciones externas, librerías complejas o RTOS. Utiliza punteros volátiles para interactuar de forma bare-metal directa con los registros del hardware (ej. BSRR en STM32).