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

📖 Teoría Explícita: El Fenómeno del Rebote

Cuando trabajas con sistemas embebidos, no todas las interfaces de entrada sufren el mismo nivel de ruido físico. En el diseño de un equipo moderno es común integrar diversas tecnologías; por ejemplo, una interfaz principal que utiliza un teclado 4x4 capacitivo. Al carecer de partes móviles, la gestión del "toque" se diseña desde el esquemático y el rutado del PCB (típicamente en KiCad) aislando pistas y dejando que un circuito integrado especializado filtre el ruido mediante umbrales e histéresis. El microcontrolador solo recibe una señal digital limpia o una trama I2C.

Sin embargo, para cumplir con las normas de seguridad industrial, el sistema debe incluir un Botón de Paro de Emergencia de accionamiento electromecánico. Aquí es donde surge el problema: al presionar este tipo de botones, las placas de cobre internas chocan y rebotan repetidas veces durante unos 10 a 20 milisegundos. Si conectamos este botón a una interrupción externa sin un filtro (debouncing), el microcontrolador registrará decenas de activaciones espurias.

Pasos para un Antirrebote por Software (No Bloqueante)

1. Detectar el flanco: Leer el cambio de estado del pin (ej. de ALTO a BAJO).
2. Sello de tiempo (Timestamp): Guardar el valor actual del contador de milisegundos del sistema (como HAL_GetTick()).
3. Ventana de ceguera: Ignorar cualquier otro cambio en ese pin hasta que haya transcurrido un tiempo de seguridad (generalmente 50 ms).
4. Validación: Una vez pasado el tiempo, volver a leer el pin para confirmar que el estado sigue siendo el deseado y no fue solo un pico de ruido electromagnético (EMI).

⚡ Circuito y Asignación de Pines

A nivel hardware, siempre es recomendable colocar un condensador (ej. 100nF) en paralelo con el botón para suavizar los picos físicamente, pero el software es quien da el dictamen final.

Entrada Hardware	Tipo de Señal	Estrategia de Antirrebote
Botón de Paro (Mecánico)	GPIO Input (Pull-up) - Activo en BAJO	Debouncing por Software (Timestamping 50ms).
Teclado Capacitivo 4x4	I2C / Interrupción Limpia	Filtro interno del IC capacitivo (Ajuste de umbrales en PCB).

⚙️ Código C: Implementación del Filtro No Bloqueante

El siguiente código muestra cómo estructurar la validación del Botón de Emergencia dentro de tu ciclo principal (Super Loop) o dentro de una interrupción (dependiendo de la arquitectura), asegurándonos de que nunca se detenga el Súper Bucle usando delay().

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

// Simulación de función de Hardware (devuelve el tiempo en milisegundos)
// En STM32 equivale a HAL_GetTick(); en Arduino a millis();
extern uint32_t obtener_milisegundos(void); 
extern bool leer_pin_emergencia(void); // Retorna 'true' si el botón está presionado (0V con Pull-Up lógico invertido)

// Configuraciones del Filtro
#define TIEMPO_ANTIRREBOTE_MS 50 

// Variables globales para el manejo de estado
typedef enum {
    BOTON_LIBERADO = 0,
    BOTON_REBOTANDO,
    BOTON_PRESIONADO_VALIDO
} EstadoBoton_t;

EstadoBoton_t estado_paro = BOTON_LIBERADO;
uint32_t tiempo_ultimo_flanco = 0;
bool emergencia_activada = false;

/**
 * @brief Tarea de actualización del botón de emergencia.
 *        Debe llamarse en cada iteración del ciclo infinito (Super Loop).
 */
void procesar_boton_emergencia(void) {
    bool lectura_actual = leer_pin_emergencia();
    uint32_t tiempo_actual = obtener_milisegundos();

    switch (estado_paro) {
        
        case BOTON_LIBERADO:
            // Si detectamos que el botón se acaba de presionar
            if (lectura_actual == true) { 
                estado_paro = BOTON_REBOTANDO;
                tiempo_ultimo_flanco = tiempo_actual; // Timestamp inicial
            }
            break;

        case BOTON_REBOTANDO:
            // Revisar si ya pasó el tiempo de "ceguera" de seguridad
            if ((tiempo_actual - tiempo_ultimo_flanco) >= TIEMPO_ANTIRREBOTE_MS) {
                // Volvemos a leer para confirmar. Si sigue presionado, es un evento real.
                if (lectura_actual == true) {
                    estado_paro = BOTON_PRESIONADO_VALIDO;
                    emergencia_activada = true; // Activar bandera global para la FSM
                    // Aquí podríamos llamar directamente a apagar la bomba por seguridad
                } else {
                    // Fue un pico de ruido falso, volvemos a reposo
                    estado_paro = BOTON_LIBERADO;
                }
            }
            break;

        case BOTON_PRESIONADO_VALIDO:
            // Esperar a que el botón se libere (el operador desenclava la seta de emergencia)
            if (lectura_actual == false) {
                estado_paro = BOTON_LIBERADO;
                // Nota: Por norma industrial, liberar el botón no reanuda el proceso, 
                // se requiere un rearme manual desde la Máquina de Estados.
            }
            break;
    }
}

int main(void) {
    // Hardware_Init();
    
    while(1) {
        // Tarea rápida y no bloqueante
        procesar_boton_emergencia();

        if (emergencia_activada) {
            // Ir al ESTADO_EMERGENCIA en tu Máquina de Estados
            // estado_actual = ESTADO_EMERGENCIA;
        }
        
        // ... Resto de la FSM y lecturas del teclado capacitivo ...
    }
    return 0;
}
        

📝 Resumen del Día

• Bounce (Rebote): Fenómeno físico inevitable en los metales de los interruptores mecánicos.
• Timestamping: Técnica de sellado de tiempo que permite medir el paso de los milisegundos sin congelar el microcontrolador (a diferencia de delay()).
• No Bloqueante: La función procesar_boton_emergencia() entra, evalúa rápido y sale, permitiendo que tu programa siga atendiendo al display, flujo y teclado I2C.
• Confirmación: Un filtro por software eficaz requiere siempre una re-evaluación del estado del pin tras la ventana de tiempo.