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

📖 Teoría Explícita: El Modificador `static` y el Mapa de SRAM

1. Variables Locales (El Stack)

Cuando creas una variable estándar dentro de una función (ej. uint32_t volumen = 0;), esta variable nace y muere con la función. El microcontrolador la almacena temporalmente en una zona de la memoria RAM llamada Stack (Pila). En el momento en que la función termina con un return, esa dirección de memoria se libera y se sobrescribe. No sirve para acumular datos.

2. Variables Globales (El Peligro del `.BSS` / `.DATA`)

Si la declaras fuera de cualquier función, vive para siempre en una sección estática de la memoria. Conservará los litros acumulados. Sin embargo, su "alcance" (Scope) es público. Significa que cualquier otra función en cualquier otro archivo podría modificarla accidentalmente, causando una catástrofe en la facturación.

3. La Solución: Variables `static` Locales

Al agregar la palabra static antes de una variable local (ej. static uint32_t volumen = 0;), cambias su anatomía a bajo nivel. Físicamente, el compilador la saca del efímero Stack y la guarda en la sección permanente de la memoria (igual que una global). Mantiene su valor de por vida. Pero lógicamente, sigue estando encapsulada dentro de la función. Ninguna otra parte del código sabe siquiera que existe.

⚙️ Ejercicios Prácticos: Código C Estricto

Ejercicio 1: El Totalizador Seguro. Vamos a crear una función metrológica que reciba los nuevos pulsos leídos desde la interrupción del flujómetro, los sume a la cuenta histórica, y devuelva el total. Al usar static, eliminamos por completo la necesidad de variables globales.

#include <stdint.h>

// --- Configuración Metrológica ---
// Constante que define que 1 pulso = 15 mL (Aritmética en Punto Fijo)
#define ML_POR_PULSO 15

/**
 * @brief  Totalizador protegido de volumen de Gas LP.
 * @param  nuevos_pulsos: Cantidad de pulsos recién detectados por el hardware.
 * @param  reiniciar_contador: Si es true (1), formatea el contador a cero (Fin de venta).
 * @return El volumen actual acumulado en mililitros exactos.
 */
uint32_t Gestionar_Volumen_Despacho(uint16_t nuevos_pulsos, uint8_t reiniciar_contador) {
    
    // VARIABLE PROTEGIDA (El tesoro del despachador)
    // El modificador 'static' asegura que al salir de la función, 'volumen_acumulado'
    // NO se borre. Sin embargo, nadie fuera de estas llaves { } puede alterar su valor.
    static uint32_t volumen_acumulado = 0;
    
    // 1. Comando de reinicio forzado (Ej. Inicio de un nuevo despacho para un cliente)
    if (reiniciar_contador == 1) {
        volumen_acumulado = 0;
        return 0;
    }
    
    // 2. Acumulación segura
    // Multiplicamos los pulsos por nuestra constante en enteros puros.
    // Esto evita desastres de latencia o truncamientos matemáticos.
    uint32_t volumen_ingresante = (uint32_t)nuevos_pulsos * ML_POR_PULSO;
    volumen_acumulado += volumen_ingresante;
    
    // 3. Retornar una COPIA del valor actual.
    // La pantalla HMI o el módulo ESP32 pueden leer este número, 
    // pero nunca alterarlo directamente en memoria.
    return volumen_acumulado;
}
        

📝 Resumen del Día

• El Stack (Memoria Temporal): Es donde viven las variables locales normales. Nace rápido y se destruye al salir de la función. No sirve para recordar estados a largo plazo.
• El `.BSS / .DATA` (Memoria Permanente): Es donde se guardan las variables que persisten mientras la máquina esté encendida.
• El Superpoder `static`: Combina lo mejor de ambos mundos. Se guarda físicamente en memoria permanente (nunca se borra), pero conserva la "privacidad" de una variable local (nadie más puede acceder a ella).