ESP32 y SD CARD, protocolo SPI

La comunicación SPI (Serial Peripheral Interface) es un protocolo de comunicación síncrono que permite la transferencia de datos entre dispositivos electrónicos. Fue desarrollado por Motorola y es ampliamente utilizado en sistemas embebidos y microcontroladores debido a su simplicidad, velocidad y eficiencia.

El protocolo SPI funciona mediante una arquitectura maestro-esclavo. Un dispositivo actúa como maestro, mientras que uno o más dispositivos actúan como esclavos. La comunicación se realiza a través de cuatro líneas de señal:

1. SCLK (Serial Clock): es una señal de reloj generada por el maestro para sincronizar la transmisión de datos entre los dispositivos.
2. MOSI (Master Out Slave In): es la línea de datos de salida del maestro y de entrada para el esclavo. El maestro envía datos a través de esta línea a los dispositivos esclavos.
3. MISO (Master In Slave Out): es la línea de datos de entrada del maestro y de salida para el esclavo. Los dispositivos esclavos envían datos al maestro a través de esta línea.
4. SS (Slave Select) o CS (Chip Select): es una línea de selección de esclavos utilizada por el maestro para seleccionar un dispositivo esclavo específico con el que desea comunicarse. Cada esclavo tiene su propia línea SS/CS.

El funcionamiento básico de la comunicación SPI es el siguiente:

1. El maestro configura la línea SS/CS en estado bajo para seleccionar un esclavo específico.
2. El maestro genera una señal de reloj en la línea SCLK.
3. Durante cada ciclo de reloj, el maestro envía un bit de datos por la línea MOSI y lee un bit de datos de la línea MISO. Los datos se transfieren en serie, bit a bit.
4. Una vez finalizada la transmisión, el maestro coloca la línea SS/CS en estado alto para desactivar la comunicación con el esclavo.

La comunicación SPI es full-duplex, lo que significa que los datos pueden transmitirse y recibirse al mismo tiempo. Además, es posible configurar la polaridad y fase del reloj (modo SPI) para adaptarse a diferentes dispositivos y aplicaciones.

En resumen, la comunicación SPI es un protocolo de comunicación síncrono, simple y eficiente que permite la transferencia de datos entre dispositivos electrónicos a través de un sistema maestro-esclavo y cuatro líneas de señal: SCLK, MOSI, MISO y SS/CS.

Codigo en C++ para implementarlo con el entorno Arduino

// Incluir las bibliotecas necesarias

#include <SPI.h> // Librería para la comunicación SPI (Serial Peripheral Interface)
#include <SD.h>  // Librería para manejar la tarjeta SD
#include <FS.h>  // Librería para manejar el sistema de archivos

#define SD_CS_PIN 5 // Definir el pin CS (Chip Select) de la tarjeta SD

// La función setup() se ejecuta una vez al inicio del programa

void setup() {

  // Inicializar la comunicación serie a una velocidad de 115200 baudios

  Serial.begin(115200);

  // Inicializar la tarjeta SD utilizando el pin CS definido anteriormente

  if (!SD.begin(SD_CS_PIN)) {

    // Si la inicialización falla, mostrar un mensaje de error y terminar

    Serial.println("Error al inicializar la tarjeta SD");
    return;
  }

  // Si la inicialización tiene éxito, mostrar un mensaje de confirmación

  Serial.println("Tarjeta SD inicializada correctamente");

  // Crear o abrir un archivo en la tarjeta SD con el nombre "test.txt" y modo de escritura
  
  File myFile = SD.open("/test.txt", FILE_WRITE);
  if (!myFile) {

    // Si no se puede abrir el archivo, mostrar un mensaje de error y terminar

    Serial.println("Error al abrir el archivo");
    return;
  }

  // Escribir datos en el archivo (en este caso, una cadena de texto)

  myFile.println("Hola, tarjeta SD!");

  // Cerrar el archivo para asegurar que los datos se guarden correctamente

  myFile.close();

  // Mostrar un mensaje indicando que los datos se han escrito en el archivo

  Serial.println("Datos escritos en el archivo");

  // Abrir el archivo "test.txt" en modo de lectura

  myFile = SD.open("/test.txt", FILE_READ);
  if (!myFile) {

    // Si no se puede abrir el archivo, mostrar un mensaje de error y terminar

    Serial.println("Error al abrir el archivo");
    return;
  }

  // Leer los datos del archivo y enviarlos a través de la comunicación serie

  while (myFile.available()) {

    // Leer un byte del archivo y enviarlo a través de la comunicación serie

    Serial.write(myFile.read());
  }

  // Cerrar el archivo después de leer todos los datos

  myFile.close();
}

// La función loop() se ejecuta repetidamente en un bucle infinito

void loop() {

  // No es necesario hacer nada en el loop en este ejemplo
}

Codigo en micropython para ejecutarlo en ESP32 con el interprete de micropython.

import machine
import os
import sdcard
from machine import Pin, SPI

# Configurar pines para SPI y CS
SCK_PIN = 18
MOSI_PIN = 23
MISO_PIN = 19
CS_PIN = 5

# Inicializar SPI
spi = SPI(2, sck=Pin(SCK_PIN), mosi=Pin(MOSI_PIN), miso=Pin(MISO_PIN))

# Inicializar tarjeta SD
sd = sdcard.SDCard(spi, Pin(CS_PIN))

# Montar la tarjeta SD como un sistema de archivos
vfs = os.VfsFat(sd)
os.mount(vfs, '/sd')

# Crear o abrir un archivo
with open('/sd/test.txt', 'w') as f:
    # Escribir datos en el archivo
    f.write('Hola, tarjeta SD!')

# Leer datos del archivo
with open('/sd/test.txt', 'r') as f:
    # Mostrar datos del archivo
    print(f.read())

# Desmontar la tarjeta SD
os.umount('/sd')

Este código crea un programa que escribe datos en un archivo en una tarjeta SD y luego lee esos datos y los muestra a través de la comunicación serie. El programa comienza importando las bibliotecas necesarias (SPI, SD y FS) y definiendo el pin CS para la tarjeta SD.

En la función setup(), se inicializa la comunicación serie a 115200 baudios y se intenta inicializar la tarjeta SD. Si la inicialización tiene éxito, el programa crea o abre un archivo llamado «test.txt» en modo de escritura y escribe una cadena de texto en él. Luego, cierra el archivo para asegurar que los datos se guarden correctamente.

A continuación, el programa abre el archivo «test.txt» en modo de lectura y lee sus datos. Los datos se envían a

través de la comunicación serie, de modo que puedas ver el contenido del archivo en el monitor serie del entorno de desarrollo Arduino.

Una vez que se han leído todos los datos, el programa cierra el archivo y finaliza la función setup(). No hay ninguna acción en la función loop(), ya que este ejemplo se centra únicamente en la lectura y escritura de un archivo en una tarjeta SD.

En resumen, este código demuestra cómo utilizar una tarjeta SD con un ESP32 y la librería SD de Arduino para crear un archivo, escribir datos en él, leer los datos y mostrarlos a través de la comunicación serie.

El esquema de conexión es el siguiente:

1. Conecta el pin VCC del módulo de tarjeta SD al pin 3.3V del ESP32.
2. Conecta el pin GND del módulo de tarjeta SD al pin GND del ESP32.
3. Conecta el pin MISO del módulo de tarjeta SD al pin 19 (MISO) del ESP32.
4. Conecta el pin MOSI del módulo de tarjeta SD al pin 23 (MOSI) del ESP32.
5. Conecta el pin SCK del módulo de tarjeta SD al pin 18 (SCK) del ESP32.
6. Conecta el pin CS del módulo de tarjeta SD al pin que hayas definido como SD_CS_PIN en tu código (en el ejemplo, se utilizó el pin 5).

Un video donde puedes ver un ejemplo: