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

📖 Teoría Explícita: Paso por Referencia y Operador Flecha

1. Agrupando Datos: El poder de `struct`

Una pantalla HMI industrial necesita actualizar múltiples datos simultáneamente: Litros, Precio y Estado. En lugar de tener tres variables sueltas rondando por la memoria, C nos permite crear un "molde" llamado struct. Una estructura empaqueta estas variables en un solo bloque de memoria contiguo. Esto es fundamental para enviar tramas de datos limpias hacia una pantalla I2C o por UART al módulo ESP32.

2. Paso por Valor vs Paso por Referencia

Paso por Valor (Aficionado): Envías el struct completo a la función de la pantalla. El compilador se ve obligado a hacer una copia idéntica byte por byte en la pila (Stack). Pierdes tiempo de procesador y duplicas el consumo de RAM estérilmente.
Paso por Referencia (Industrial): Le envías a la función únicamente la Dirección de Memoria (Puntero) de donde empieza la estructura. La función no copia nada; va directamente a la memoria original y lee/escribe los datos in-situ. El costo en memoria es siempre de solo 4 bytes (tamaño de un puntero en un STM32 de 32 bits), sin importar si tu estructura pesa 1 byte o 1 Kilobyte.

3. El Operador Flecha (`->`)

Cuando trabajas con una estructura de forma local, accedes a sus variables internas usando un punto (ej. display.volumen = 100;). Pero cuando estás trabajando con un Puntero a una estructura (porque la recibiste por referencia), el punto ya no funciona. Debes usar el operador flecha ->. Este operador mágicamente hace dos cosas al mismo tiempo: desreferencia el puntero (abre la caja) y accede a la variable interna.

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

Ejercicio 1: Actualizador de Pantalla. Crearemos la estructura de datos que representa lo que el usuario ve en la pantalla. Luego, una función recibirá el puntero de esta estructura y la actualizará directamente en la memoria usando el operador flecha.


#include <stdint.h>

// 1. DEFINICIÓN DEL MOLDE DE DATOS (STRUCT)
// Agrupamos la información semántica para la HMI (Human Machine Interface)
typedef struct {
    uint32_t volumen_ml;    // Volumen en mililitros (Punto fijo)
    uint32_t precio_c;      // Precio en centavos (Punto fijo)
    uint8_t  estado_fsm;    // Estado de la máquina (Reposo, Despacho, Falla)
} DatosPantalla_t;

// --- Funciones ficticias del núcleo ---
extern uint32_t Obtener_Volumen_Protegido(void); 
extern uint32_t Calcular_Costo_Actual(void);
extern uint8_t  Obtener_Estado_FSM(void);

/**
 * @brief  Actualiza la estructura de la pantalla sin copiar datos masivos.
 * @param  ptr_pantalla: Puntero a la estructura original de datos.
 */
void Actualizar_Buffer_Pantalla(DatosPantalla_t *ptr_pantalla) {
    
    // VALIDACIÓN DE SEGURIDAD:
    // Nunca asumas que el puntero es válido. Si te envían un puntero NULL (0x00)
    // e intentas escribir en él, el procesador lanzará un Hard Fault.
    if (ptr_pantalla == 0x00) {
        return; // Puntero nulo. Abortar misión de manera segura.
    }

    // PASO POR REFERENCIA:
    // Usamos el operador flecha (->) para escribir directamente en la RAM original.
    // Observa que no usamos 'sprintf' aquí. Pasamos matemáticas puras a la HMI.
    
    ptr_pantalla->volumen_ml = Obtener_Volumen_Protegido();
    ptr_pantalla->precio_c   = Calcular_Costo_Actual();
    ptr_pantalla->estado_fsm = Obtener_Estado_FSM();
}

// =====================================================================
// SIMULACIÓN DE LA TAREA PRINCIPAL
// =====================================================================
void Super_Bucle_Main(void) {
    
    // Instanciamos físicamente la estructura en la memoria
    DatosPantalla_t informacion_cliente; 
    
    // Limpieza de memoria (Buena práctica en C puro)
    informacion_cliente.volumen_ml = 0;
    informacion_cliente.precio_c = 0;
    informacion_cliente.estado_fsm = 0;
    
    while(1) {
        // Le pasamos a la función la DIRECCIÓN (&) de la estructura, no la estructura.
        Actualizar_Buffer_Pantalla(&informacion_cliente);
        
        // Ahora 'informacion_cliente' tiene los datos frescos. 
        // Procedemos a enviar estos bytes físicos por I2C o UART hacia el LCD.
        // Enviar_Trama_Display( (uint8_t*)&informacion_cliente, sizeof(DatosPantalla_t) );
    }
}

🚀 Avance del Proyecto Tesis: Despachador de Gas LP

Hito Logrado: Comunicación entre módulos por Referencia Puntera.

Al dominar los struct combinados con los punteros y el operador ->, acabas de construir el puente de comunicación de tu sistema. El núcleo de metrología puede estar en un archivo .c y el código que controla la pantalla LCD puede estar en otro. En lugar de compartir variables globales (lo cual es peligroso), simplemente le pasas el puntero de la estructura a la función que lo necesite. Tu memoria RAM permanece intacta, rápida y elástica, un requisito crítico para microcontroladores pequeños.

📝 Resumen del Día

Estructuras (`struct`): Molde de memoria que agrupa variables de distintos tipos lógicamente conectadas (volumen, precio, estado).
Paso por Referencia: Es enviar un puntero (una dirección) a una función en lugar del valor completo. Ahorra tiempo de procesamiento y evita la fragmentación del Stack.
Operador Flecha (`->`): Sustituye al operador punto (`.`) cuando estamos trabajando con un puntero a una estructura. Permite escribir/leer la variable dentro de la dirección de memoria apuntada.
Validación NULL: Siempre revisa que el puntero no sea 0x00 antes de usar el operador flecha. Escribir en la dirección cero causa un colapso inminente (Hard Fault).