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

📖 Teoría a Estudiar

Memoria Flash y Lógica de Guardado (Power-Loss Recovery)

En el diseño de sistemas de punto de venta (como tu despachador), perder el registro de un servicio a la mitad porque se cortó la luz es inaceptable. Sin embargo, no puedes escribir en la Memoria Flash en cada ciclo de tu Súper Bucle por dos razones: la latencia de borrado bloquearía la lectura de sensores, y la memoria se degradaría en un par de días (los sectores Flash soportan típicamente ~10,000 a 100,000 ciclos de borrado/escritura).

La solución en la industria se conoce como la estrategia del "Último Aliento" (Dying Gasp). Se basa en detectar la caída del voltaje de suministro principal antes de que el voltaje del microcontrolador baje de su mínimo operativo, y usar un capacitor de respaldo para mantener la CPU encendida los milisegundos exactos que requiere la rutina de guardado.

Mecánica de Software para el Último Aliento

Al caer el voltaje de la red principal, el pin detector disparará una interrupción de altísima prioridad (típicamente configurada en el NVIC). El software que escribas dentro de esta interrupción debe seguir una dieta estricta:

1. Apagar Periféricos: Deshabilitar inmediatamente pantallas LCD traseras, LEDs y módulos de comunicación para que el capacitor de reserva dure más tiempo (cada miliamperio ahorrado se traduce en milisegundos de vida).
2. Bloquear Interrupciones: Impedir que el Súper Bucle o el temporizador del sistema (SysTick) interrumpan la delicada secuencia de escritura de la memoria Flash.
3. Ejecutar Guardado: Desbloquear la Flash, borrar un sector preasignado, escribir el estado actual (litros y dinero) y volver a bloquear.
4. Estado de Coma (Halt): Atrapar al procesador en un bucle infinito (while(1)) para evitar que intente volver a operar con voltajes inestables hasta que se apague por completo.

⚙️ Ejercicios Prácticos

Ejercicio 1: Programa la rutina C (simulando bare-metal) que se disparará automáticamente cuando el pin detector de caída de voltaje alerte al microcontrolador.

#include <stdint.h>
#include <stdbool.h>

// --- 1. ESTRUCTURA DE DATOS VITALES ---
// Esto agrupa la información del despacho activo para escribirla de golpe
typedef struct {
    uint32_t id_transaccion;
    uint32_t mililitros_despachados;
    uint32_t centavos_cobrados;
    uint32_t checksum_integridad;
} RespaldoDespacho_t;

volatile RespaldoDespacho_t despacho_actual;

// Dirección reservada en la Memoria Flash (Ej. Sector 127 de un STM32)
#define FLASH_RECOVERY_ADDR 0x0801FC00


// --- 2. RUTINA DE INTERRUPCIÓN CRÍTICA (PVD / EXTI) ---
// Se invoca asíncronamente cuando el voltaje de la red cae de 24V.
// En este instante, el equipo está operando exclusivamente con la 
// energía almacenada en el capacitor de la placa (aprox. 5 a 20 ms de vida).
void PVD_CaidaVoltaje_IRQHandler(void) {
    
    // PASO A: Aislar consumos inmediatamente para extender la vida del capacitor
    // hardware_apagar_retroiluminacion_lcd();
    // hardware_cerrar_todas_las_valvulas();
    
    // PASO B: Deshabilitar todas las demás interrupciones (Bloquear el sistema)
    // Evita que un pulso del caudalímetro corrompa la rutina de escritura.
    __asm("cpsid i"); 
    
    // PASO C: Preparar los datos
    despacho_actual.checksum_integridad = 
        despacho_actual.id_transaccion ^ despacho_actual.mililitros_despachados;
    
    // PASO D: Secuencia de Escritura en Flash
    // (Pseudocódigo ilustrando los pasos bare-metal genéricos)
    
    // 1. Desbloquear los registros de la Flash mediante llaves de seguridad
    // FLASH->KEYR = 0x45670123;
    // FLASH->KEYR = 0xCDEF89AB;
    
    // 2. Comandar el borrado de la página
    // FLASH->CR |= FLASH_CR_PER; ...
    
    // 3. Copiar la estructura de la RAM hacia la memoria no volátil
    uint32_t *puntero_origen = (uint32_t *)&despacho_actual;
    uint32_t *puntero_destino = (uint32_t *)FLASH_RECOVERY_ADDR;
    uint32_t numero_de_palabras = sizeof(RespaldoDespacho_t) / 4;
    
    for (uint32_t i = 0; i < numero_de_palabras; i++) {
        // En escritura real de Flash, a menudo se escribe en medias-palabras (16 bits)
        // o se espera a que la bandera de estado de ocupado (BSY) se libere.
        puntero_destino[i] = puntero_origen[i]; 
    }
    
    // 4. Bloquear la Flash para evitar corrupciones por ruidos eléctricos finales
    // FLASH->CR |= FLASH_CR_LOCK;
    
    // PASO E: Coma Inducido
    // El microcontrolador se queda atrapado aquí esperando que la energía 
    // residual del capacitor se agote en los próximos milisegundos.
    while(1) {
        // No hacer absolutamente nada.
    }
}
        

📝 Resumen del Día

• La Memoria Flash tiene un límite físico de ciclos de escritura. No se puede utilizar como una memoria RAM para guardar datos constantemente.
• El hardware y el software deben cooperar íntimamente. Un circuito Dying Gasp (Último aliento) proporciona la ventana de tiempo necesaria aislando un capacitor de reserva.
• La rutina de interrupción por pérdida de energía debe ser monolítica y determinista: apagar cargas pesadas, deshabilitar interrupciones concurrentes, guardar el estado crítico y entrar en un bucle de bloqueo final.