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

📖 Teoría Explícita: El Bus SPI (Serial Peripheral Interface)

El bus SPI es un protocolo de comunicación síncrono, full-duplex y basado en una arquitectura Maestro-Esclavo. A diferencia de I2C, SPI no tiene un estándar formal estricto sobre el protocolo a nivel de software, operando esencialmente como un gran registro de desplazamiento (Shift Register) continuo entre dos dispositivos.

Al ser síncrono, cuenta con una línea de reloj dedicada, cuya velocidad máxima se calcula en función del reloj del bus periférico ($f_{PCLK}$) y un pre-escalador:

$$ f_{SPI} = \frac{f_{PCLK}}{Prescaler} $$

Las 4 Señales Clave del Bus SPI

• SCK (Serial Clock): Generada por el Maestro. Sincroniza la transmisión de cada bit.
• MOSI (Master Out Slave In): Línea de datos del Maestro hacia el Esclavo (a veces llamada SDO/SDI dependiendo de la perspectiva).
• MISO (Master In Slave Out): Línea de datos del Esclavo hacia el Maestro.
• CS / SS (Chip Select / Slave Select): Línea activa en BAJO. El Maestro la tira a tierra (0V) para "despertar" y seleccionar a un Esclavo específico antes de hablar.

⚡ Interfaz de Hardware y Modos de Reloj

A diferencia de I2C, SPI utiliza circuitos Push-Pull, lo que significa que no requiere resistencias Pull-Up externas en las líneas de datos (MOSI, MISO, SCK). Alcanza velocidades de decenas de Megahercios (MHz). Es importante configurar la Polaridad (CPOL) y la Fase (CPHA) del reloj para que coincidan con la hoja de datos del esclavo.

Línea	Tipo de GPIO (Maestro)	Consideración de Diseño
SCK, MOSI	Alternate Function (Push-Pull)	Pistas cortas en el PCB, alejar de señales analógicas sensibles.
MISO	Input (Floating / Pull-Up)	El esclavo toma control de esta línea cuando su CS es bajo.
CS / SS	Output (Push-Pull)	Se requiere 1 pin GPIO dedicado por cada esclavo adicional en el bus.

⚙️ Código C: Estructura de Trama y Transmisión SPI

El código para SPI debe controlar primero el pin Chip Select (CS), enviar y recibir los bytes simultáneamente, y luego liberar el CS. Observa cómo por cada byte que sale, obligatoriamente entra un byte.

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

// Prototipos simulados (En la realidad llamarían a HAL_SPI_TransmitReceive, etc.)
extern void GPIO_WritePin(uint8_t pin, bool state);
extern uint8_t SPI_Hardware_ShiftByte(uint8_t data_out);

// Definiciones
#define PIN_CS_SD_CARD  10
#define LOW             false
#define HIGH            true

/**
 * @brief  Envía y recibe un buffer de datos a través del bus SPI.
 * @param  tx_buffer Puntero a los datos a enviar.
 * @param  rx_buffer Puntero donde se guardarán los datos recibidos.
 * @param  length    Cantidad de bytes en la trama.
 */
void SPI_TransferirTrama(uint8_t* tx_buffer, uint8_t* rx_buffer, uint16_t length) {
    
    // 1. Iniciar transacción: Bajar el Chip Select para seleccionar el esclavo
    GPIO_WritePin(PIN_CS_SD_CARD, LOW);
    
    // Pequeño retardo si el esclavo lo requiere (Setup Time)
    // delay_us(1); 

    // 2. Bucle de transmisión de la trama completa
    for (uint16_t i = 0; i < length; i++) {
        // En SPI, por cada byte que el Maestro empuja, recibe uno de vuelta
        uint8_t byte_enviado = tx_buffer[i];
        uint8_t byte_recibido = SPI_Hardware_ShiftByte(byte_enviado);
        
        // Almacenamos lo que respondió el esclavo en ese mismo ciclo
        if (rx_buffer != NULL) {
            rx_buffer[i] = byte_recibido;
        }
    }
    
    // 3. Finalizar transacción: Subir el Chip Select para liberar al esclavo
    GPIO_WritePin(PIN_CS_SD_CARD, HIGH);
}

// --- EJEMPLO DE USO ---
int main(void) {
    // Trama de comando (Ejemplo ficticio para leer un registro de SD)
    uint8_t comando_tx[4] = {0x50, 0x00, 0x00, 0xFF}; 
    uint8_t respuesta_rx[4] = {0}; // Buffer limpio para la respuesta
    
    // Ejecutar transferencia
    SPI_TransferirTrama(comando_tx, respuesta_rx, 4);
    
    // Ahora 'respuesta_rx' contiene los 4 bytes devueltos por el esclavo.
    
    while(1) {
        // Súper bucle
    }
}
        

📝 Resumen del Día

• Sincronismo Puro: El maestro dicta la velocidad mediante el reloj (SCK). Sin reloj, no hay flujo de datos.
• Full-Duplex: A diferencia de I2C o UART, en SPI se envía y recibe información en el mismo pulso de reloj, intercambiando los registros de desplazamiento.
• Chip Select (CS): Es el mecanismo de direccionamiento por hardware. No hay direcciones enviadas en la trama de bytes; seleccionas a quién le hablas bajando su pin físico.