Fase 5: Diseño Industrial y Proyecto Final

📖 Teoría a Estudiar

¿Qué es MISRA-C?

El lenguaje C fue diseñado para escribir sistemas operativos rápidos, asumiendo que el programador "sabe lo que hace". C te permite leer memoria que no te pertenece, dividir por cero y sobreescribir punteros de ejecución. En un videojuego, esto causa que la aplicación se cierre (Crash). En una bomba de infusión médica o en nuestro Despachador de Gas LP, esto causa la muerte.

MISRA (Motor Industry Software Reliability Association) es un conjunto de reglas creadas originalmente por Ford y Rover para el software de frenos ABS. Hoy es el estándar global para todo sistema crítico embebido (SIL-3 / SIL-4). Si tu código viola una regla MISRA, no puede ser implementado en un hardware crítico. Así de simple.

Las 10 Reglas de Oro de Seguridad Total (Adaptación Industrial)

Aplica esto como un dogma en tu STM32 y serás mejor que el 90% de los programadores comerciales:

1. Cero Asignación Dinámica (Muerte a malloc): Prohibido usar malloc() o free(). Con 96KB de RAM, la memoria se fragmentará en 3 meses, tu RTOS se quedará sin bloque continuo (Heap Exhaustion) y la máquina colapsará. Usa static o arrays de tamaño fijo en tiempo de compilación.
2. Prohibidos los Punteros Salvajes: Un puntero no puede tener más de dos niveles de indirección (**ptr). Deben inicializarse siempre a NULL o a una dirección válida.
3. Tipado Fuerte Estricto (stdint.h): Olvida el tipo int o long. Su tamaño cambia entre compiladores de 16, 32 y 64 bits. Usa EXCLUSIVAMENTE uint8_t, int32_t, uint32_t, etc. Sabes exactamente qué tamaño tiene en memoria.
4. El Mandamiento del default: Todo switch-case DEBE tener un bloque default, incluso si crees que todas las opciones están cubiertas. En ese bloque debes atrapar errores catastróficos.
5. Sin Códigos Muertos (Dead Code): Cualquier función o variable que no se utilice debe ser eliminada. El código muerto confunde auditorías y desperdicia valiosos sectores Flash.
6. Límites de Arrays: Nunca se debe confiar en los índices entrantes. Antes de acceder a buffer[i], se debe validar que i < MAX_SIZE.
7. Sin Recursividad: Una función no debe llamarse a sí misma. La recursividad desborda el Pila (Stack Overflow) en procesadores ARM con memoria finita.
8. Inicialización Obligatoria: Las variables no pueden declararse vacías (uint8_t estado;). Deben tener un valor conocido desde el ciclo 1 (uint8_t estado = 0;).
9. Conversión Implícita Prohibida (Casting): No mezcles tipos con signos y sin signos, ni promuevas de 8 bits a 32 bits sin un cast explícito que el desarrollador haya pensado.
10. No goto: El uso de saltos incondicionales rompe el flujo estructurado del programa y hace el análisis estático casi imposible.

⚙️ Ejercicios Prácticos

Laboratorio de Código C: No basta con saber qué reglas usar, hay que saber cómo se ven. A continuación, compararemos un fragmento de código escrito por un estudiante con un fragmento certificado bajo la directiva MISRA-C para controlar la válvula electromecánica.

/**
 * @file valvula_control.c
 * @brief Comparativa: C Estándar (Peligroso) vs C-MISRA (Industrial)
 */

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

// =========================================================================
// ❌ EL MODO AMATEUR (VIOLA LAS REGLAS MISRA-C)
// =========================================================================
// - Usa 'int' (Violación Regla 4.6: Tipos básicos sin tamaño fijo).
// - No inicializa 'status' (Violación Regla 9.1: Valor antes de uso).
// - No hay 'default' en el switch (Violación Regla 16.4).
// - Asume que 'pin_array' no se desbordará.

int pines_valvulas[3] = {10, 11, 12};

void Control_Valvula_Malo(int numero_valvula, int comando) {
    int status; 
    
    // Si numero_valvula es 5, leerá memoria RAM fuera del arreglo (Buffer Overread)
    int pin = pines_valvulas[numero_valvula];
    
    switch(comando) {
        case 0:
            // Apagar PIN
            status = 0;
            break;
        case 1:
            // Encender PIN
            status = 1;
            break;
    }
    
    // Si comando era 2, status contendrá basura (memoria residual)
    // y aplicará un estado indeterminado al hardware físico.
    Aplicar_Hardware(pin, status); 
}


// =========================================================================
// ✅ EL MODO ARQUITECTO INDUSTRIAL (CUMPLE MISRA-C)
// =========================================================================
// - Tipos estrictos (uint8_t).
// - Constantes ('static const' en lugar de variables globales libres).
// - Comprobación explícita de límites de matriz.
// - Switch con 'default' seguro.
// - Enum en lugar de "números mágicos" 0 y 1.

#define MAX_VALVULAS 3U // La 'U' obliga al compilador a tratarlo como Unsigned

typedef enum {
    VALVULA_CERRAR = 0U,
    VALVULA_ABRIR  = 1U
} EstadoValvula_t;

static const uint8_t pines_valvulas_safe[MAX_VALVULAS] = {10U, 11U, 12U};

/**
 * @brief Aplica estado seguro a válvula física
 * @param num_valvula Índice de la válvula (0 a 2)
 * @param comando     Estado requerido de la enumeración
 */
void Control_Valvula_Seguro(uint8_t num_valvula, EstadoValvula_t comando) {
    
    // 1. Regla MISRA: Inicialización explícita a un estado SEGURO.
    uint8_t status_hardware = 0U; 
    
    // 2. Regla MISRA: Validación estricta de límites (Evita Buffer Overflow)
    if (num_valvula >= MAX_VALVULAS) {
        // Log Error Crítico OOB (Out-of-Bounds)
        // Entrar a Failsafe.
        return; 
    }
    
    uint8_t pin_objetivo = pines_valvulas_safe[num_valvula];
    
    // 3. Regla MISRA: Estructuras de decisión completas
    switch(comando) {
        case VALVULA_CERRAR:
            status_hardware = 0U;
            break;
            
        case VALVULA_ABRIR:
            status_hardware = 1U;
            break;
            
        default:
            // 4. Regla MISRA: El caso default DEBE existir. 
            // Si la RAM se corrompió y 'comando' es 45, entramos aquí.
            // Acción Segura Definitiva: Cerramos Válvula de Gas.
            status_hardware = 0U; 
            // Disparar Alarma_Sistema_Corrupto();
            break;
    }
    
    Aplicar_Hardware_Seguro(pin_objetivo, status_hardware);
}
        

📝 Resumen del Día

• El lenguaje C asume completa responsabilidad por parte del programador. Para evitar comportamientos indefinidos (Undefined Behavior) fatales en sistemas de riesgo, la industria automotriz fundó MISRA-C.
• En un sistema embebido que debe estar encendido 24/7/365, el uso de Asignación Dinámica de Memoria (malloc/free) está estrictamente prohibido. Esto evita la fragmentación del Heap y los Memory Leaks (Fugas de memoria) a largo plazo. Toda la RAM debe reservarse estáticamente en la compilación.
• El uso de los tipos base del compilador (int, char, long) viola la norma de la portabilidad, ya que sus tamaños varían entre microcontroladores de 8, 16 o 32 bits. Se exige la librería estándar <stdint.h> para forzar anchos lógicos puros (uint8_t, int32_t).
• Para prevenir inyecciones lógicas (cuando la RAM sufre corrupción electromagnética), todas las sentencias switch deben poseer la cláusula default, donde se debe programar un estado Fail-safe (apagar motores, cerrar válvulas).
• El cumplimiento de MISRA-C no se revisa a ojo humano, sino obligando al proceso de compilación a pasar por herramientas de Análisis Estático de Código (Ej. PC-Lint, Cppcheck o herramientas integradas en IAR/Keil), las cuales abortarán el binario si detectan una sola desviación del protocolo.