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

📖 Teoría a Estudiar: Doble Buffer (Ping-Pong)

En el desarrollo en C puro (bare-metal) sin sistemas operativos de tiempo real, la recepción asíncrona de datos es uno de los mayores desafíos. Si recibes una ráfaga de datos por UART y tu procesador tarda en procesarlos, los nuevos bytes sobrescribirán a los viejos, perdiendo información crítica. La solución es el Buffer Ping-Pong.

¿Cómo funciona la arquitectura Ping-Pong?

En lugar de tener un solo arreglo de memoria, creamos dos. Mientras el hardware (por interrupción o DMA) escribe datos nuevos en el Buffer Ping de forma invisible en segundo plano, la CPU tiene total libertad y tiempo para analizar, procesar y despachar los datos que ya están completos en el Buffer Pong. Cuando el Ping se llena, los roles se intercambian instantáneamente mediante punteros de memoria, sin mover un solo byte físicamente.

⚙️ Ejercicios Prácticos

Ejercicio: Implementa en C una estructura de doble buffer utilizando manipulación de punteros. El objetivo es evitar funciones pesadas que bloqueen la CPU y no usar bucles de copia de datos, gestionando el intercambio de buffers con el costo computacional mínimo.

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

#define BUFFER_SIZE 64

// 1. Asignación estática de la memoria (evita fragmentación y uso de malloc)
uint8_t buffer_A[BUFFER_SIZE];
uint8_t buffer_B[BUFFER_SIZE];

// 2. Punteros maestros de control
uint8_t* ptr_rx = buffer_A;     // Hardware (UART/ISR) escribe aquí
uint8_t* ptr_procesamiento = buffer_B; // Súper bucle lee de aquí

volatile bool datos_listos = false;

// --- SIMULACIÓN: Rutina de Servicio de Interrupción (ISR) de UART ---
void UART_Rx_ISR(uint8_t byte_recibido) {
    static uint8_t indice = 0;
    
    // Almacenamos el byte directamente por puntero
    ptr_rx[indice] = byte_recibido;
    indice++;
    
    // Si el buffer de recepción se llenó o se detecta fin de trama
    if (indice >= BUFFER_SIZE || byte_recibido == '\n') {
        indice = 0;
        datos_listos = true; // Levantamos la bandera para el Súper Bucle
    }
}

// --- SÚPER BUCLE ---
int main(void) {
    while(1) {
        // Ejecución no bloqueante
        if (datos_listos) {
            
            // 3. SWAP (INTERCAMBIO) DE PUNTEROS
            // Tomamos una sección crítica ultra-corta
            // No copiamos arreglos, solo intercambiamos direcciones de memoria (costo CPU: casi 0)
            uint8_t* ptr_temp = ptr_rx;
            ptr_rx = ptr_procesamiento;
            ptr_procesamiento = ptr_temp;
            
            datos_listos = false;
            
            // 4. Procesamiento
            // Ahora CPU puede parsear 'ptr_procesamiento' con calma
            // Mientras tanto, la próxima interrupción UART ya escribirá en el nuevo 'ptr_rx'
            // procesar_trama_sin_sprintf(ptr_procesamiento);
        }
        
        // El resto del código de control industrial sigue corriendo sin congelarse
    }
    return 0;
}
        

📝 Resumen del Día

• El Buffer Ping-Pong es una estrategia de concurrencia donde se alterna el uso de dos espacios de memoria idénticos para separar el proceso de escritura de datos asíncronos de su lectura y procesamiento por la CPU.
• En C bare-metal, el intercambio de buffers nunca se hace moviendo los datos con bucles for. Se realiza un intercambio lógico de punteros de memoria, lo cual se ejecuta en solo un par de ciclos de reloj.
• Esta arquitectura elimina los bloqueos (freezes) del sistema operativo, permitiendo que las rutinas de seguridad de misión crítica sigan operando mientras se reciben tramas largas de comunicación.