Es obvio que las SD se han convertido en algo indispensable en nuestra vida digital , estando presentes en infinidad de dispositivos electrónicos como smartphones, cámaras digitales, cámaras de seguridad, reproductores multimedia, ordenadores, microcontroladores, y un larguísimo etcétera.

Por otro lado, de vez en cuando nos encontramos con proyectos basados en ESP32 ( y todas sus variantes) que necesitan una forma de almacenar una gran cantidad de datos de forma escalable y eficiente (es decir, necesitamos construir lo que viene a llamarse un registrador de datos o en ingle «datalogger»), siendo lo ideal por tanto usar con nuestro microntrolador precisamente estas tarjetas SD o micro SD, dada su gran capacidad para empaquetar GigaBytes de datos en un espacio más pequeño que una moneda.

SPI es un acrónimo que significa «Serial Peripheral Interface». Es un protocolo de comunicación serie que se utiliza para transferir datos entre dispositivos electrónicos, como microcontroladores, sensores, dispositivos de almacenamiento, etc. SPI permite a varios dispositivos compartir un canal de comunicación y cada dispositivo puede actuar como esclavo o maestro. El protocolo SPI es conocido por ser rápido y flexible, y por tener una arquitectura sencilla que permite una fácil integración en una amplia gama de aplicaciones electrónicas. Además, el protocolo SPI es compatible con una amplia gama de velocidades de transmisión de datos, lo que lo hace adecuado para una variedad de aplicaciones con diferentes requisitos de velocidad y capacidad de procesamiento.

El ESP32 es un microcontrolador que incluye una interfaz de comunicación SPI, lo que significa que puede utilizar el protocolo SPI para comunicarse con otros dispositivos electrónicos. Aquí hay algunos de los usos más comunes de la interfaz SPI en el ESP32:

1. Comunicación con sensores: El ESP32 puede utilizar la interfaz SPI para comunicarse con sensores, como acelerómetros, giroscopios, sensores de temperatura, etc.
2. Comunicación con dispositivos de almacenamiento: El ESP32 puede utilizar la interfaz SPI para comunicarse con dispositivos de almacenamiento, como tarjetas SD o dispositivos Flash, para leer y escribir datos.
3. Comunicación con pantallas táctiles: El ESP32 puede utilizar la interfaz SPI para comunicarse con pantallas táctiles y controlar la visualización y la entrada de datos.
4. Comunicación con dispositivos de radiofrecuencia: El ESP32 puede utilizar la interfaz SPI para comunicarse con dispositivos de radiofrecuencia, como módulos Bluetooth o Wi-Fi, para transferir datos a larga distancia.

En resumen, la interfaz SPI en el ESP32 se puede utilizar para una amplia gama de aplicaciones, lo que lo hace una herramienta valiosa para desarrollar proyectos electrónicos y de Internet de las cosas.

En este post vamos a ver que en realidad leer o escribir datos en una SD ( o micro-sd) en el entorno de la familia Arduino es en realidad muy sencillo gracias a las librería SD y también al protocolo SPI para la comunicación con el lector de SD.

Descripción general del hardware.

Para este proyecto se ha probado el lector de sd de AZDelivery el cual nos proporciona una expansión fácil y económica del espacio de almacenamiento mediante la ranura SD. La comunicación es muy fácil con el microcontrolador a través del protocolo SPI (como vamos a ver ) y soporta tarjetas Micro SD (2G), tarjetas Micro SDHC (32G) (tarjeta de alta velocidad). Además el módulo lee todos los datos contenidos en la tarjeta SD y se puede conectar fácilmente a varios tipos de microcontroladores ( además si lo compramos a este fabricante incluye un E-Book que proporciona información útil sobre cómo comenzar su proyecto, ayuda con una configuración rápida y ahorra tiempo en el proceso de configuración proporcionándonos una serie de ejemplos de aplicación, guías de instalación completas y bibliotecas, etc.).

El módulo de la tarjeta micro SD contiene dos componentes principales que, sin duda, hacen que sea fácil agregar el registro de datos a su próximo proyecto Arduino:

• El voltaje de funcionamiento de cualquier tarjeta micro SD estándar es de 3,3 V. Por lo tanto, no podemos conectarlo directamente a circuitos que usan lógica de 5V. De hecho, cualquier voltaje que supere los 3,6 V dañará permanentemente la tarjeta micro SD. Es por eso; el módulo tiene un regulador de caída ultrabaja incorporado que convertirá los voltajes de 3,3 V a 6 V a ~3,3 V.
• También hay un chip 74LVC125A en el módulo que convierte la lógica de la interfaz de 3,3 V-5 V a 3,3 V. Esto se llama cambio de nivel lógico. Eso significa que puede usar esta placa para interactuar con microcontroladores de 3,3 V y 5 V como Arduino.

En realidad, hay dos formas de interactuar con tarjetas micro SD: modo SPI y modo SDIO. El modo SDIO es mucho más rápido y se usa en teléfonos móviles, cámaras digitales, etc, pero desgraciadamente este modo es más complejo y requiere la firma de documentos de confidencialidad( por esa razón, es probable que los aficionados como nosotros nunca encuentren el código de interfaz del modo SDIO). En su lugar, cada módulo de tarjeta SD se basa en el modo SPI de «menor velocidad y menos sobrecarga» que es fácil de usar para cualquier microcontrolador (como Arduino).

Asignación de pines del módulo de la tarjeta Micro SD

El módulo de la tarjeta micro SD que vamos a usar es bastante simple de conectar. Tiene seis pines:

• VCC :El pin que suministra energía para el módulo y debe conectarse al pin de 5V en el Arduino.
• GND (TIERRA): debe estar conectado a tierra de Arduino.
• MISO (Master In Slave Out): es la salida SPI del módulo de tarjeta Micro SD.
• MOSI (Salida maestra Entrada esclava): es la entrada SPI al módulo de tarjeta Micro SD.
• SCK (reloj serie): pin acepta pulsos de reloj que sincronizan la transmisión de datos generada por Arduino.
• CS (Selección de esclavo): es utilizado por Arduino (Master) para habilitar y deshabilitar dispositivos específicos en el bus SPI.

Preparación de la tarjeta micro SD

Antes de insertar la tarjeta micro SD en el módulo y conectarla al Arduino, debe formatear correctamente la tarjeta. Para la biblioteca Arduino que discutiremos, y casi todas las demás bibliotecas SD, la tarjeta debe estar formateada FAT16 o FAT32.

Si tiene una tarjeta SD nueva, es probable que ya esté formateada previamente con un sistema de archivos FAT. Sin embargo, es posible que tenga problemas con el formato de fábrica de la tarjeta o, si es una tarjeta antigua, debe reformatearse. De cualquier manera, siempre es una buena idea formatear la tarjeta antes de usarla, ¡incluso si es nueva!

Es recomendable utilizar la utilidad oficial de formateo de tarjetas SD : escrita por la asociación SD , ¡resuelve muchos problemas que surgen con un mal formateo! Descargue el formateador y ejecútelo en su ordenador, simplemente seleccione la unidad correcta y haga clic en FORMATEAR.

Cableado: conexión del módulo de tarjeta Micro SD a Arduino

Ahora que su tarjeta está lista para usar, ¡podemos conectar la placa de conexión micro SD!

Para empezar, inserte el módulo de la tarjeta micro SD en una placa de pruebas. Conecte el pin VCC en el módulo a 5V en el pin Arduino y GND a tierra. Ahora nos quedamos con los pines que se usan para la comunicación SPI. Como las tarjetas micro SD requieren una gran cantidad de transferencia de datos, brindarán el mejor rendimiento cuando se conecten a los pines SPI del hardware en un microcontrolador. Los pines SPI del hardware son mucho más rápidos que «bit-banging» del código de la interfaz usando otro conjunto de pines.

Tenga en cuenta que cada placa Arduino tiene diferentes pines SPI que deben conectarse en consecuencia. Para placas ESP32 (En el ejemplo DOIT ESP32 DEVKIT1) esos pines son digitales 18 (SCK), 19 (MISO) y 23 (MOSI). También necesitará un cuarto pin para la línea ‘chip/slave select’ (SS). Por lo general, este es el pin 5, pero en realidad puede usar cualquier pin que desee (siempre que lo inicialize en el código).

Si tiene una placa Mega, ¡los pines son diferentes! Querrá usar digital 50 (MISO), 51 (MOSI), 52 (SCK) y 53 (SS). Consulte la siguiente tabla para una comprensión rápida.

MicroSD card module	ESP32
VCC	+5v
CS	GPIO 5
MOSI	GPIO 23
CLK	GPIO 18
MISO	GPIO 19
GND	GND

En caso de que esté utilizando una placa Arduino diferente a la mencionada anteriormente, es recomendable consultar la documentación oficial de Arduino antes de continuar.

Para cablear el módulo de la tarjeta microSD a la placa ESP32, puede seguir el siguiente diagrama esquemático (para los pines SPI por defecto de ESP32):

Realmente dadas las poquísimas conexiones necesarias, el montaje se puede hacer directamente con un cable de cinta de 6 hilos como podemos ver en la imagen .

Código Arduino: prueba del módulo de la tarjeta SD con CardInfo

Existen dos librerías diferentes para el ESP32 (incluidas en el núcleo de Arduino para el ESP32): la librería SD y la librería SDD_MMC.h.

Si utiliza la biblioteca SD, está utilizando el controlador SPI. Si usa la librería SDD_MMC estás usando el controlador SD/SDIO/MMC del ESP32.

Hay varios ejemplos en Arduino IDE que muestran cómo manejar archivos en la tarjeta microSD usando el ESP32. En el IDE de Arduino, vaya a Archivo > Ejemplos > SD(esp32) > SD_Test, o copie el siguiente código:

/*
    This sketch can be found at: Examples > SD(esp32) > SD_Test
*/

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
  Serial.printf("Listing directory: %s\n", dirname);

  File root = fs.open(dirname);
  if(!root){
    Serial.println("Failed to open directory");
    return;
  }
  if(!root.isDirectory()){
    Serial.println("Not a directory");
    return;
  }

  File file = root.openNextFile();
  while(file){
    if(file.isDirectory()){
      Serial.print("  DIR : ");
      Serial.println(file.name());
      if(levels){
        listDir(fs, file.name(), levels -1);
      }
    } else {
      Serial.print("  FILE: ");
      Serial.print(file.name());
      Serial.print("  SIZE: ");
      Serial.println(file.size());
    }
    file = root.openNextFile();
  }
}

void createDir(fs::FS &fs, const char * path){
  Serial.printf("Creating Dir: %s\n", path);
  if(fs.mkdir(path)){
    Serial.println("Dir created");
  } else {
    Serial.println("mkdir failed");
  }
}

void removeDir(fs::FS &fs, const char * path){
  Serial.printf("Removing Dir: %s\n", path);
  if(fs.rmdir(path)){
    Serial.println("Dir removed");
  } else {
    Serial.println("rmdir failed");
  }
}

void readFile(fs::FS &fs, const char * path){
  Serial.printf("Reading file: %s\n", path);

  File file = fs.open(path);
  if(!file){
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while(file.available()){
    Serial.write(file.read());
  }
  file.close();
}

void writeFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Writing file: %s\n", path);

  File file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }
  if(file.print(message)){
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

void appendFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);
  if(!file){
    Serial.println("Failed to open file for appending");
    return;
  }
  if(file.print(message)){
      Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

void renameFile(fs::FS &fs, const char * path1, const char * path2){
  Serial.printf("Renaming file %s to %s\n", path1, path2);
  if (fs.rename(path1, path2)) {
    Serial.println("File renamed");
  } else {
    Serial.println("Rename failed");
  }
}

void deleteFile(fs::FS &fs, const char * path){
  Serial.printf("Deleting file: %s\n", path);
  if(fs.remove(path)){
    Serial.println("File deleted");
  } else {
    Serial.println("Delete failed");
  }
}

void testFileIO(fs::FS &fs, const char * path){
  File file = fs.open(path);
  static uint8_t buf[512];
  size_t len = 0;
  uint32_t start = millis();
  uint32_t end = start;
  if(file){
    len = file.size();
    size_t flen = len;
    start = millis();
    while(len){
      size_t toRead = len;
      if(toRead > 512){
        toRead = 512;
      }
      file.read(buf, toRead);
      len -= toRead;
    }
    end = millis() - start;
    Serial.printf("%u bytes read for %u ms\n", flen, end);
    file.close();
  } else {
    Serial.println("Failed to open file for reading");
  }


  file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }

  size_t i;
  start = millis();
  for(i=0; i<2048; i++){
    file.write(buf, 512);
  }
  end = millis() - start;
  Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
  file.close();
}

void setup(){
  Serial.begin(115200);
  if(!SD.begin(5)){
    Serial.println("Card Mount Failed");
    return;
  }
  uint8_t cardType = SD.cardType();

  if(cardType == CARD_NONE){
    Serial.println("No SD card attached");
    return;
  }

  Serial.print("SD Card Type: ");
  if(cardType == CARD_MMC){
    Serial.println("MMC");
  } else if(cardType == CARD_SD){
    Serial.println("SDSC");
  } else if(cardType == CARD_SDHC){
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }

  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);

  listDir(SD, "/", 0);
  createDir(SD, "/mydir");
  listDir(SD, "/", 0);
  removeDir(SD, "/mydir");
  listDir(SD, "/", 2);
  writeFile(SD, "/hello.txt", "Hello ");
  appendFile(SD, "/hello.txt", "World!\n");
  readFile(SD, "/hello.txt");
  deleteFile(SD, "/foo.txt");
  renameFile(SD, "/hello.txt", "/foo.txt");
  readFile(SD, "/foo.txt");
  testFileIO(SD, "/test.txt");
  Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
  Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
}

void loop(){

}

Este ejemplo muestra cómo realizar casi cualquier tarea que pueda necesitar con la tarjeta microSD:

• Listar un directorio;
• Crear un directorio;
• Eliminar un directorio;
• Leer el contenido de un archivo;
• Escribir contenido en un archivo
• Añadir contenido a un archivo;
• Renombrar un fichero;
• Eliminar un archivo;
• Inicializar tarjeta microSD;
• Obtener tipo de tarjeta microSD;
• Obtener el tamaño de la tarjeta microSD;

Alternativamente, puede utilizar los ejemplos SD_MMC – son similares a los ejemplos SD, pero utilizan el controlador SDMMC. Para el controlador SDMMC, necesita un módulo de tarjeta microSD compatible. El módulo que utilizamos en este post no es compatible con SDMMC.

Todos los ejemplos que vamos a a ver por tanto proporciona varias funciones para manejar archivos en la tarjeta microSD.

Listar un directorio

La función listDir() lista los directorios de la tarjeta SD. Esta función acepta como argumentos el sistema de archivos (SD), el nombre del directorio principal y los niveles para entrar en el directorio.

void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
  Serial.printf("Listing directory: %s\n", dirname);

  File root = fs.open(dirname);
  if(!root){
    Serial.println("Failed to open directory");
    return;
  }
  if(!root.isDirectory()){
    Serial.println("Not a directory");
    return;
  }

  File file = root.openNextFile();
  while(file){
    if(file.isDirectory()){
      Serial.print("  DIR : ");
      Serial.println(file.name());
      if(levels){
        listDir(fs, file.name(), levels -1);
      }
    } else {
      Serial.print("  FILE: ");
      Serial.print(file.name());
      Serial.print("  SIZE: ");
      Serial.println(file.size());
    }
     file = root.openNextFile();
  }
}

He aquí un ejemplo de cómo llamar a esta función .

listDir(SD, "/", 0);

Obsérvese que es muy importante la barra invertida antes del directorio pues eso indica que el directorio esta en el directorio raiz .

Crear un directorio
La función createDir() crea un nuevo directorio. Pasa como argumento el sistema de ficheros SD y la ruta del nombre del directorio.

void createDir(fs::FS &fs, const char * path){
  Serial.printf("Creating Dir: %s\n", path);
  if(fs.mkdir(path)){
    Serial.println("Dir created");
  } else {
    Serial.println("mkdir failed");
  }
}

Por ejemplo, el siguiente comando crea un nuevo directorio en la raíz llamado mydir

createDir(SD, "/mydir");

Obsérvese que es muy importante la barra invertida antes del directorio pues eso indica que el directorio esta en el directorio raiz (y se llama mydir).

Eliminar un directorio
Para eliminar un directorio de la tarjeta microSD, utilice la función removeDir() y pase como argumento el sistema de archivos de la SD y la ruta del nombre del directorio.

void removeDir(fs::FS &fs, const char * path){
  Serial.printf("Removing Dir: %s\n", path);
  if(fs.rmdir(path)){
    Serial.println("Dir removed");
  } else {
    Serial.println("rmdir failed");
  }
}

He aquí un ejemplo:

removeDir(SD, "/mydir");

Obsérvese que es muy importante la barra invertida antes del directorio pues eso indica que el directorio esta en el directorio raiz (y se llama mydir).

Leer el contenido de un archivo
La función readFile() lee el contenido de un archivo e imprime el contenido en el Monitor Serial. Como en las funciones anteriores, pase como argumento el sistema de ficheros SD y la ruta del fichero.

void readFile(fs::FS &fs, const char * path){
  Serial.printf("Reading file: %s\n", path);

  File file = fs.open(path);
  if(!file){
    Serial.println("Failed to open file for reading");
    return;
  }

  Serial.print("Read from file: ");
  while(file.available()){
    Serial.write(file.read());
  }
  file.close();
}

Por ejemplo, la siguiente línea lee el contenido del archivo hello.txt.

readFile(SD, "/hello.txt")

Obsérvese que es muy importante la barra invertidas antes del fichero pues eso indica que el fichero esta en el directorio raiz (y se llama hello.txt).

Escribir contenido en un archivo
Para escribir contenido en un fichero, puede utilizar la función writeFile(). Pase como argumento el sistema de ficheros SD, la ruta del fichero y el mensaje.

void writeFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Writing file: %s\n", path);

  File file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }
  if(file.print(message)){
    Serial.println("File written");
  } else {
    Serial.println("Write failed");
  }
  file.close();
}

La siguiente línea escribe Hola en el archivo hola.txt.

writeFile(SD, "/hello.txt", "Hello ");

Obsérvese que es muy importante la barra invertidas antes del fichero pues eso indica que el fichero esta en el directorio raiz (y se llama hello.txt).

Añadir contenido a un archivo
Del mismo modo, puede añadir contenido a un archivo (sin sobrescribir el contenido anterior) utilizando la función appendFile().

void appendFile(fs::FS &fs, const char * path, const char * message){
  Serial.printf("Appending to file: %s\n", path);

  File file = fs.open(path, FILE_APPEND);
  if(!file){
    Serial.println("Failed to open file for appending");
    return;
  }
  if(file.print(message)){
    Serial.println("Message appended");
  } else {
    Serial.println("Append failed");
  }
  file.close();
}

La siguiente línea añade el mensaje ¡Mundo!\n en el archivo hola.txt. El \n significa que la próxima vez que escriba algo en el archivo, se escribirá en una nueva línea.

appendFile(SD, "/hello.txt", "World!\n");

Cambiar el nombre de un archivo
Puede renombrar un fichero utilizando la función renameFile(). Pasa como argumentos el sistema de ficheros SD, el nombre original del fichero y el nuevo nombre.

void renameFile(fs::FS &fs, const char * path1, const char * path2){
  Serial.printf("Renaming file %s to %s\n", path1, path2);
  if (fs.rename(path1, path2)) {
    Serial.println("File renamed");
  } else {
    Serial.println("Rename failed");
  }
}

La siguiente línea cambia el nombre del archivo hello.txt a foo.txt.

renameFile(SD, "/hello.txt", "/foo.txt");

Borrar un fichero
Utilice la función deleteFile() para borrar un fichero. Pase como argumento el sistema de ficheros SD y la ruta del fichero que desea borrar.

void deleteFile(fs::FS &fs, const char * path){
  Serial.printf("Deleting file: %s\n", path);
  if(fs.remove(path)){
    Serial.println("File deleted");
  } else {
    Serial.println("Delete failed");
  }
}

La siguiente línea borra el archivo foo.txt de la tarjeta microSD.

deleteFile(SD, "/foo.txt");

Probar un archivo
Por último la función testFileIO() muestra el tiempo que se tarda en leer el contenido de un fichero.

void testFileIO(fs::FS &fs, const char * path){
  File file = fs.open(path);
  static uint8_t buf[512];
  size_t len = 0;
  uint32_t start = millis();
  uint32_t end = start;
  if(file){
    len = file.size();
    size_t flen = len;
    start = millis();
    while(len){
      size_t toRead = len;
      if(toRead > 512){
        toRead = 512;
      }
      file.read(buf, toRead);
      len -= toRead;
    }
    end = millis() - start;
    Serial.printf("%u bytes read for %u ms\n", flen, end);
    file.close();
  } 
  else {
    Serial.println("Failed to open file for reading");
  }

  file = fs.open(path, FILE_WRITE);
  if(!file){
    Serial.println("Failed to open file for writing");
    return;
  }

  size_t i;
  start = millis();
  for(i=0; i<2048; i++){
    file.write(buf, 512);
  }
  end = millis() - start;
  Serial.printf("%u bytes written for %u ms\n", 2048 * 512, end);
  file.close();
}

La siguiente función comprueba el archivo test.txt.

testFileIO(SD, "/test.txt");

Inicializar la tarjeta microSD
En setup(), las siguientes líneas inicializan la tarjeta microSD con SD.begin().

Serial.begin(115200);
if(!SD.begin()){
  Serial.println("Card Mount Failed");
  return;
}
uint8_t cardType = SD.cardType();

if(cardType == CARD_NONE){
  Serial.println("No SD card attached");
  return;
}

Si no pasa ningún argumento a la función begin(), intentará inicializar la comunicación SPI con la tarjeta microSD en el pin por defecto de selección de chip (CS). Si desea utilizar otro pin CS, puede pasarlo como argumento a la función begin(). Por ejemplo, si quiere usar GPIO 17 como pin CS, debería usar las siguientes líneas de código:

Serial.begin(115200);
if(!SD.begin(17)){
  Serial.println("Card Mount Failed");
  return;
}
uint8_t cardType = SD.cardType();

Obtener el tipo de tarjeta microSD
Las siguientes líneas imprimen el tipo de tarjeta microSD en el Monitor Serial.

Serial.print("SD Card Type: ");
if(cardType == CARD_MMC){
  Serial.println("MMC");
} else if(cardType == CARD_SD){
  Serial.println("SDSC");
} else if(cardType == CARD_SDHC){
  Serial.println("SDHC");
} else {
  Serial.println("UNKNOWN");
}

Obtener el tamaño de la tarjeta microSD
Puedes obtener el tamaño de la tarjeta microSD llamando al método cardSize():

uint64_t cardSize = SD.cardSize() / (1024 * 1024);
Serial.printf("SD Card Size: %lluMB\n", cardSize);

Para probar las funciones de la tarjeta MicroSD,las siguientes líneas llaman a las funciones que hemos visto anteriormente:

listDir(SD, "/", 0);
createDir(SD, "/mydir");
listDir(SD, "/", 0);
removeDir(SD, "/mydir");
listDir(SD, "/", 2);
writeFile(SD, "/hello.txt", "Hello ");
appendFile(SD, "/hello.txt", "World!\n");
readFile(SD, "/hello.txt");
deleteFile(SD, "/foo.txt");
renameFile(SD, "/hello.txt", "/foo.txt");
readFile(SD, "/foo.txt");
testFileIO(SD, "/test.txt");
Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));

Suba el sketch anterior a tu placa ESP32. Después de eso, abra el Monitor Serie y pulse el botón RST de la placa ESP32. Si la inicialización tiene éxito, obtendrá mensajes similares a los siguientes en el Monitor Serie.

Funciones utilizadas con el objeto Archivo

Además, hay algunas funciones que puede usar con objetos de archivo :

• Puede  usar seek()en un archivo. Esto moverá el cursor de lectura/escritura a una nueva ubicación. Por ejemplo seek(0) , lo llevará al principio del archivo, ¡lo cual puede ser muy útil!
• Así mismo puedes llamar al position()que te indicará en qué parte del expediente te encuentras.
• Si desea saber el tamaño de un archivo, llame size() para obtener la cantidad de bytes en el archivo.
• Los directorios/carpetas son archivos especiales, puede determinar si un archivo es un directorio llamando isDirectory()
• Una vez que tenga un directorio, puede comenzar a revisar todos los archivos en el directorio llamando openNextFile()
• Puede terminar necesitando saber el nombre de un archivo, por ejemplo, si llamó openNextFile()a un directorio. En este caso, llame al name()que devolverá un puntero a la matriz de caracteres con formato 8.3 que puede hacer directamente Serial.print() si lo desea.