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

📖 Teoría Explícita: Lógica y Arquitectura

1. Lógicos (`&&`, `||`) vs Bit a Bit (`&`, `|`) a Nivel ALU

Un error clásico que destruye sistemas embebidos es confundir ambos operadores. La diferencia no es solo sintáctica; el microcontrolador (ARM Cortex-M) los compila en instrucciones de máquina completamente distintas:

• Bit a Bit (`&`, `|`): Se ejecutan dentro de la ALU (Unidad Aritmético Lógica). Toman dos registros de 32 bits, los comparan bit por bit de manera simultánea (en 1 solo ciclo de reloj) y devuelven un nuevo número de 32 bits. Se usan para configurar hardware puro.
• Lógicos (`&&`, `||`, `!`): En realidad se traducen en Instrucciones de Salto (Branching) en ensamblador (ej. BEQ - Branch if Equal, BNE - Branch if Not Equal). Evalúan una condición; si es 0 (Falso), el procesador salta a otra línea de código. Solo devuelven 1 o 0 lógico.

2. El Cortocircuito Lógico (Short-Circuit Evaluation)

Debido a que los operadores lógicos son saltos de código condicionales, C implementa evaluación perezosa (Lazy Evaluation). Esto es un arma secreta para optimizar el rendimiento y garantizar la seguridad.

Operador	Expresión	Comportamiento Explícito a Bajo Nivel
AND (`&&`)	if (A && B && C)	Si A es FALSO (0), el procesador aborta inmediatamente. B y C nunca se ejecutan en la memoria.
OR (`||`)	if (A || B || C)	Si A es VERDADERO (1), el procesador aborta inmediatamente. B y C nunca se ejecutan. Todo asume Verdadero.

3. Failsafe: Seguridad Pasiva y Lógica Negativa (NC)

En el despachador de gas LP, si un cable del botón de paro de emergencia se troza accidentalmente (o por vandalismo), el sistema debe entrar en alarma. Si usas un botón Normalmente Abierto (NO) que envía 3.3V al ser presionado, un cable trozado siempre leerá 0V... ¡El microcontrolador creerá que todo está bien mientras el gas se derrama! Por ello, todo sensor de seguridad crítica se diseña Normalmente Cerrado (NC).

• Estado Reposo (Seguro): El botón deja pasar 3.3V al pin del STM32 (Lógica 1).
• Estado Alarma (Peligro): Al presionar el botón, se abre el circuito. El pin cae a 0V (Lógica 0).
• Fallo de Cable: Si se rompe el cable, el pin cae a 0V (Lógica 0). El sistema se auto-protege.

⚡ Circuito KiCad: Pull-Up Externo vs Interno

Aunque el STM32 tiene resistencias Pull-Up internas configurables por software, en ambientes industriales ruidosos (donde hay motores trifásicos o bombas de gas grandes), estas resistencias débiles (~40kΩ) no son suficientes. El ruido electromagnético (EMI) inducirá falsos ceros lógicos. En tu PCB, debes colocar una resistencia Pull-Up externa fuerte (ej. 4.7kΩ) conectada a 3.3V en el pin del Paro de Emergencia, junto con un capacitor cerámico de 100nF a tierra para crear un filtro pasabajas tipo RC contra rebotes mecánicos.

⚙️ Ejercicios Prácticos

Ejercicio 1: Programa la función de enclavamiento de seguridad utilizando operadores lógicos. Organiza la evaluación priorizando el hardware físico sobre las comunicaciones lentas.

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

// --- Prototipos ficticios de lectura de hardware ---
// Retorna true (1) si recibe 3.3V, false (0) si recibe 0V.
bool gpio_leer_paro_emergencia(void); 
bool adc_leer_presion_segura(void);
bool uart_esp32_token_valido(void);

/**
 * @brief  Cadena de Interlocks (Permisivos).
 *         Evalúa las condiciones en orden de velocidad y criticidad.
 * @return true si el sistema es seguro para operar.
 */
bool verificar_permisivos_despacho(void) {
    
    // ORDEN ESTRATÉGICO PARA EL CORTOCIRCUITO LÓGICO:
    // 1. gpio_leer_paro_emergencia(): Toma 1 ciclo de reloj leer un pin. (Lo más rápido).
    // 2. adc_leer_presion_segura(): Toma ~15 ciclos leer el registro del ADC.
    // 3. uart_esp32_token_valido(): Requiere parsear un buffer en RAM, toma cientos de ciclos.
    
    // Si el operador oprime el botón rojo (falso), la CPU aborta la evaluación 
    // en el paso 1 y jamás entra a revisar la UART, ganando microsegundos valiosos
    // para disparar el relé de apagado.
    
    if ( gpio_leer_paro_emergencia() && 
         adc_leer_presion_segura() && 
         uart_esp32_token_valido() ) 
    {
        return true; 
    } 
    else 
    {
        return false; 
    }
}

// Integración en el Súper Bucle de una tarea de FreeRTOS
void vTask_MonitorDespacho(void *pvParameters) {
    for(;;) {
        // Operador Lógico NOT (!): Invierte el booleano.
        // Se lee: "Si los permisivos NO son verdaderos..."
        if ( !verificar_permisivos_despacho() ) {
            
            // Llamamos al apagado incondicional del Día 1
            Safe_Shutdown(); 
            
            // Aquí podríamos agregar una notificación por UART al ESP32
            // de que el sistema entró en falla de seguridad.
        }
        
        vTaskDelay(pdMS_TO_TICKS(50)); 
    }
}
        

📝 Resumen del Día

• Lógico vs ALU: && es para condiciones (saltos BNE/BEQ). & es para matemáticas en binario puro (ALU).
• Optimización por Orden: En condiciones compuestas con &&, siempre coloca a la izquierda la función que se ejecute más rápido o que sea más probable que falle.
• Failsafe: Todo interruptor de seguridad de grado industrial debe ser Normalmente Cerrado (NC) y conectarse con resistencias Pull-Up fuertes (ej. 4.7kΩ).