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

📖 Teoría a Estudiar

Evaluación Fase 1: Consolidación de la Máquina de Estados

¡Llegaste al final de la Fase 1! Durante estos 60 días has construido un arsenal de herramientas en C puro: punteros, manejo de bits, arquitecturas bare-metal, Watchdogs, rutinas de estado seguro y manipulación de memoria. Ahora es el momento de orquestar todo esto bajo el patrón de diseño más importante en la ingeniería de sistemas embebidos: la Máquina de Estados Finita (FSM - Finite State Machine).

Una FSM es un modelo matemático de computación. Define que un sistema solo puede estar en un único estado a la vez. En lugar de tener un código secuencial (espagueti) que se bloquea esperando eventos, la FSM se evalúa de forma cíclica y asíncrona. Si ocurre un evento válido (transición), el sistema cambia de estado; si ocurre un evento crítico, salta inmediatamente a un estado de error, garantizando control absoluto en cada microsegundo.

Estructura de la FSM en C

1. Enumeración (Enum): Se define un tipo de dato que contiene todos los estados posibles del sistema. Esto elimina los "números mágicos" de estado.
2. Variable de Estado: Una variable global (o estática) que guarda el estado actual.
3. Despachador (Switch-Case): Una función no bloqueante que evalúa la variable de estado mediante un switch y ejecuta solo el fragmento de código correspondiente al estado actual, saliendo rápidamente para permitir que otras tareas del Súper Bucle se sigan ejecutando.

⚙️ Proyecto Práctico: El Núcleo de Control

Ejercicio 1: Integra los conceptos de Timeout, control predictivo de volumen y manejo de estados en una estructura de firmware profesional para la gestión del flujo principal.

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

// --- 1. DEFINICIÓN DE ESTADOS ---
typedef enum {
    ST_REPOSO,          // Esperando cliente/teclado
    ST_INICIANDO,       // Abriendo válvulas, validando sensores
    ST_DESPACHANDO,     // Leyendo flujo y procesando volumen
    ST_FINALIZANDO,     // Cerrando válvulas compensando inercia
    ST_ERROR            // Bloqueo por timeout, sobrepresión o fallo
} EstadoMaquina_t;

// Variable global de la FSM
EstadoMaquina_t estado_actual = ST_REPOSO;

// Mocks de variables del sistema
uint32_t volumen_objetivo_ml = 20000;
uint32_t volumen_actual_ml = 0;
bool boton_inicio_presionado = false;
bool sensor_error_critico = false;


// --- 2. MOTOR DE LA MÁQUINA DE ESTADOS ---
// Esta función se llama miles de veces por segundo desde el Súper Bucle
void procesar_maquina_despacho(void) {
    
    // Evaluar interrupciones críticas asíncronas globales
    if (sensor_error_critico && estado_actual != ST_ERROR) {
        estado_actual = ST_ERROR;
    }

    switch (estado_actual) {
        
        case ST_REPOSO:
            // hardware_valvula_set(LOW);
            if (boton_inicio_presionado) {
                printf("Transicion: REPOSO -> INICIANDO\n");
                volumen_actual_ml = 0; 
                boton_inicio_presionado = false; // Consumir evento
                estado_actual = ST_INICIANDO;
            }
            break;

        case ST_INICIANDO:
            // hardware_valvula_set(HIGH);
            // Aquí iría el Watchdog de flujo (Día 52)
            printf("Transicion: INICIANDO -> DESPACHANDO\n");
            estado_actual = ST_DESPACHANDO;
            break;

        case ST_DESPACHANDO:
            // Simulación de lectura continua del caudalímetro
            volumen_actual_ml += 50; 
            
            // Barrera de software (Día 53)
            if (volumen_actual_ml >= (volumen_objetivo_ml - 150)) { // 150ml de inercia
                printf("Transicion: DESPACHANDO -> FINALIZANDO\n");
                estado_actual = ST_FINALIZANDO;
            }
            break;

        case ST_FINALIZANDO:
            // hardware_valvula_set(LOW);
            // generar_ticket_json(); (Día 58)
            printf("Despacho Completado. Transicion a REPOSO.\n\n");
            estado_actual = ST_REPOSO;
            break;

        case ST_ERROR:
            // ESTADO SEGURO DE BLOQUEO (Día 54)
            // hardware_apagar_todo_emergencia();
            // printf("SISTEMA BLOQUEADO. REQUIERE REINICIO MANUAL.\n");
            break;
            
        default:
            // Buena práctica MISRA-C: Manejar estados indefinidos
            estado_actual = ST_ERROR;
            break;
    }
}


int main(void) {
    printf("--- INICIANDO FIRMWARE DESPACHADOR ---\n");
    
    // Simulación del Súper Bucle
    boton_inicio_presionado = true; // Forzar el inicio
    
    for (int i = 0; i < 5; i++) {
        procesar_maquina_despacho();
        // Al no tener delays, el procesador puede hacer otras cosas aquí
    }
    
    return 0;
}
        

📝 Resumen de la Fase 1

• Eliminaste la dependencia de funciones bloqueantes (como delay()) a favor de lógica basada en deltas de tiempo (Milisegundos) y Máquinas de Estados asíncronas.
• Comprendiste cómo tratar la memoria, empleando punteros, máscaras XOR (In-place) y arreglos estáticos (como el búfer JSON) para garantizar cero fugas de memoria y prevenir el temido Heap Fragmentation.
• Diseñaste tu software con mentalidad de misión crítica: manejando errores por HardFault, secuencias POST al arranque, y recuperación ante cortes de energía (Dying Gasp).