Como gestionar una SD desde un ESP32


Módulo de tarjeta MicroSD

Existen diferentes módulos de tarjetas microSD compatibles con el ESP32. En este post vamos a ver una aplicación de estos económicos módulos que nos pueden servir para un sinfín de aplicaciones.

Este módulo de lector de tarjetas SD facilita las aplicaciones que implican el uso de una tarjeta SD proporcionando una interfaz sencilla con un microcontrolador y que se puede utilizar como unidades periféricas normales.

Programando el microcontrolador en consecuencia, es posible leer y escribir en una tarjeta SD.
Las señales procedentes de la tarjeta SD (MOSI, SCK, MISO y CS) son reportadas en el modulo y luego conectadas al conector de 2×8 pines pre-soldados. Esto facilita la integración del lector de tarjetas SD en diferentes tipos de proyectos.

La programación permite leer y escribir en la tarjeta SD usando su microcontrolador, y el modulo es adecuado para varios tipos de proyectos y requisitos, como reproductores MP3, sistemas de control MCU/ARM, etc.

En este post vamos a utilizar por tanto el módulo de tarjeta microSD que se muestra en la imagen superior (es un módulo de tarjeta microSD también es compatible con otros microcontroladores como Arduino y las placas ESP8266 NodeMCU así como el ESp32 y compatibles ), el cual se comunicará mediante el protocolo de comunicación SPI (aunque se puede usar cualquier otro módulo de tarjeta microSD con una interfaz SPI).

Asignación de pines del módulo de la tarjeta MicroSD – SPI

El módulo de la tarjeta microSD se comunica mediante el protocolo de comunicación SPI. Puede conectarlo al ESP32 usando los pines SPI predeterminados.

Módulo de tarjeta microSDESP32
VCC Vin (5v)
CSGPIO5
MOSIGPIO23
CLKGPIO18
MISOGPIO19
TIERRATIERRA

Piezas necesarias

Para este post, necesitamos las siguientes partes:

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

Diagrama de cableado del módulo de tarjeta microSD ESP32

Preparación de la tarjeta microSD

Antes de continuar con el tutorial, asegúrese de formatear su tarjeta microSD como FAT32 . Siga las siguientes instrucciones para formatear su tarjeta microSD o use una herramienta de software como SD Card Formater (compatible con Windows y Mac OS).

1.  Inserte la tarjeta microSD en su computadora. Vaya a  Mi PC  y haga clic derecho en la tarjeta SD. Seleccione  Formato  como se muestra en la siguiente figura.

Tarjeta MicroSD Módulo formatear tarjeta sd

2.  Aparece una nueva ventana. Seleccione  FAT32 , presione  Iniciar  para iniciar el proceso de formateo y siga las instrucciones en pantalla.

Tarjeta MicroSD Módulo formatear tarjeta sd

ESP32 Manejo de archivos con un módulo de tarjeta MicroSD

Hay dos bibliotecas diferentes para ESP32 (incluidas en el núcleo de Arduino para ESP32): la biblioteca SD y la biblioteca SDD_MMC.h .

Si usa la biblioteca SD, está usando el controlador SPI. Si usa la biblioteca SDD_MMC, está usando el controlador ESP32 SD/SDIO/MMC. Puede obtener más información sobre el controlador ESP32 SD/SDIO/MMC .

ESP32 Manejar archivos en tarjeta microSD Ejemplo Leer y escribir

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.

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-microsd-card-arduino/
  
  This sketch can be found at: Examples > SD(esp32) > SD_Test
*/

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

const int chipSelect = SS;//10;

void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
  Serial.println("LISTDIR.....");
  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.println("CREATEDIR.....");
  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.println("REMOVEDIR.....");
  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.println("READFILE.....");
  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);


Serial.println("WRITEFILE.....");
  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.println("APPENDFILE.....");
  
  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.println("RENAMEFILE.....");
  
  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.println("DELETEFILE.....");
  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){
  
  Serial.println("TESTFILEIO.....");
  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);

  delay(2000);
  if(!SD.begin(SS)){
 // 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;
  }

delay(2000);
 Serial.println("TIPO DE TARJETA...");
  Serial.print("SD Card Type: ");
  if(cardType == CARD_MMC){
    Serial.println("MMC");
  } else if(cardType == CARD_SD){
    Serial.println("SDSC");  //ESTA
  } else if(cardType == CARD_SDHC){
    Serial.println("SDHC");
  } else {
    Serial.println("UNKNOWN");
  }


delay(2000);
 Serial.println("TAMAÑO TARJETA...");
  uint64_t cardSize = SD.cardSize() / (1024 * 1024);
  Serial.printf("SD Card Size: %lluMB\n", cardSize);  //1910MB

  listDir(SD, "/", 0);
  delay(2000);
  
  createDir(SD, "/mydir");
  delay(2000);

  
  listDir(SD, "/", 0);
  delay(2000);
  
  removeDir(SD, "/mydir");
  delay(2000);
  
  listDir(SD, "/", 2);
  delay(2000);
  
  writeFile(SD, "/hello.txt", "Hello ");
  delay(2000);

  
  appendFile(SD, "/hello.txt", "World!\n");
  delay(2000);
  
  readFile(SD, "/hello.txt");
  delay(2000);
  
  deleteFile(SD, "/foo.txt");
  delay(2000);
  
  renameFile(SD, "/hello.txt", "/foo.txt");
  delay(2000);

  
  readFile(SD, "/foo.txt");
  delay(2000);

  
  testFileIO(SD, "/test.txt");
  delay(2000);
  delay(2000);
  
 Serial.println("ESPACIO LIBRE TARJETA..");
  Serial.printf("Total space: %lluMB\n", SD.totalBytes() / (1024 * 1024));
  Serial.printf("Used space: %lluMB\n", SD.usedBytes() / (1024 * 1024));
}

void loop(){
//nada que hacer
delay(20000);
Serial.printf("OTRO BUCLE MAS");

}

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
  • Agregar contenido al archivo 
  • Cambiar el nombre de un archivo 
  • Eliminar un archivo 
  • Inicializar tarjeta microSD 
  • Obtenga el tipo de tarjeta microSD 
  • Obtenga el tamaño de la tarjeta microSD 

Alternativamente, puede usar los ejemplos de SD_MMC ; estos son similares a los ejemplos de SD, pero usan el controlador SDMMC. Para el controlador SDMMC, necesita un módulo de tarjeta microSD compatible. El módulo que estamos usando en este post no es compatible con SDMMC.

Cómo funciona el código

Primero, debe incluir las siguientes bibliotecas:FS.hpara manejar archivos,SD.hpara interactuar con la tarjeta microSD ySPI.hpara utilizar el protocolo de comunicación SPI.

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

El ejemplo proporciona varias funciones para manejar archivos en la tarjeta microSD.

Listar un directorio

loslistDir()función enumera los directorios en la tarjeta SD. Esta función acepta como argumentos el sistema de archivos (Dakota del Sur), 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();
  }
}

Aquí hay un ejemplo de cómo llamar a esta función. los/corresponde al directorio raíz de la tarjeta microSD.

listDir(SD, "/", 0);

Crear un Directorio

loscrearDir()La función crea un nuevo directorio. Pasar como argumento elDakota del Sursistema de archivos 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 llamadomidir.

createDir(SD, "/mydir");

Eliminar un directorio

Para eliminar un directorio de la tarjeta microSD, use eleliminarDir()y pase como argumento el sistema de archivos 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");
  }
}

Aquí hay un ejemplo:

removeDir(SD, "/mydir");

Leer contenido del archivo

losleerArchivo()La función lee el contenido de un archivo e imprime el contenido en el monitor serie. Al igual que con las funciones anteriores, pase como argumento elDakota del Sursistema de archivos y la ruta del archivo.

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 delhola.txtexpediente.

readFile(SD, "/hello.txt")

Escribir contenido en un archivo

Para escribir contenido en un archivo, puede utilizar elescribirArchivo()función. Pasar como argumento, elDakota del Sursistema de archivos, la ruta del archivo 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 escribeHolaen elhola.txtexpediente.

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

Agregar contenido a un archivo

De manera similar, puede agregar contenido a un archivo (sin sobrescribir el contenido anterior) usando elagregar archivo ()función.

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 agrega el mensaje¡Mundo!\nen elhola.txtexpediente. los\nortesignifica 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 cambiar el nombre de un archivo usando elrenombrar archivo()función. Pase como argumentos el sistema de archivos SD, el nombre de archivo original y el nuevo nombre de archivo.

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 delhola.txtarchivo afoo.txt.

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

Eliminar un archivo

Utilizar elborrar archivo()Función para eliminar un archivo. Pasar como argumento elDakota del Sursistema de archivos y la ruta del archivo que desea eliminar.

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 elimina elfoo.txtarchivo de la tarjeta microSD.

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

Probar un archivo

lostestFileIO()funciones muestra cuánto tiempo lleva leer el contenido de un archivo.

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 prueba laprueba.txtexpediente.

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

Inicializar la tarjeta microSD

En elconfiguración(), las siguientes líneas inicializan la tarjeta microSD conSD.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 laempezar()función, intentará inicializar la comunicación SPI con la tarjeta microSD en el pin predeterminado de selección de chip (CS). Si desea utilizar otro pin CS, puede pasarlo como argumento alempezar()función. Por ejemplo, si desea usar GPIO 17 como un pin CS, debe 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();

Si desea utilizar pines SPI personalizados con la tarjeta microSD, vaya a esta sección .

Obtener tipo de tarjeta microSD

Las siguientes líneas imprimen el tipo de tarjeta microSD en el monitor serie.

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 tamaño de tarjeta microSD

Puede obtener el tamaño de la tarjeta microSD llamando altamaño de tarjeta()método:

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

Prueba de 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));

Demostración

Sube el boceto anterior a tu placa ESP32. Después de eso, abra el monitor en serie y presione el botón RST integrado ESP32. Si la inicialización tiene éxito, obtendrá mensajes similares en el monitor serie.

Características de prueba del módulo de tarjeta MicroSD de la placa ESP32: lectura, escritura, eliminación
Características de prueba del módulo de tarjeta MicroSD de la placa ESP32: lectura, escritura, eliminación

Use pines SPI personalizados con la tarjeta MicroSD

losSD.h y SD_MMC.h son bibliotecas que utilizan los pines VSPI SPI (23, 19, 18, 5) de forma predeterminada. Puede configurar otros pines como pines SPI. El ESP32 presenta dos interfaces SPI: HSPI y VSPI en los siguientes pines:

SPIMOSIMISOCLKCS
VSPIGPIO23GPIO19GPIO18GPIO5
HSPIGPIO13GPIO12GPIO14GPIO15

Para usar otros pines SPI, puede proceder de la siguiente manera:

Al comienzo de su código, declare los pines que desea usar, por ejemplo:

#define SCK  18
#define MISO  19
#define MOSI  23
#define CS  5

En elconfiguración(), cree una nueva clase SPI en HSPI o VSPI. Estamos usando VSPI. Ambos funcionarán bien.

SPIClass spi = SPIClass(VSPI);

Inicialice el protocolo de comunicación SPI en los pines definidos anteriormente:

spi.begin(SCK, MISO, MOSI, CS);

Finalmente, inicialice la tarjeta microSD con elempezar()método. Pase como argumento el pin CS, la instancia SPI que desea usar y la frecuencia del bus.

if (!SD.begin(CS,spi,80000000)) {
  Serial.println("Card Mount Failed");
  return;
}

Aquí está el código de muestra modificado para usar pines SPI personalizados:

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-microsd-card-arduino/
  
  This sketch was mofidied from: Examples > SD(esp32) > SD_Test
*/

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

#define SCK  17
#define MISO  19
#define MOSI  23
#define CS  5

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);
  SPIClass spi = SPIClass(VSPI);
  spi.begin(SCK, MISO, MOSI, CS);

  if (!SD.begin(CS,spi,80000000)) {
    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(){

}

Fuente https://randomnerdtutorials.com/esp32-microsd-card-arduino/#sdcardcustompins


Ejemplo: Registro de datos ESP32 en tarjeta microSD

El uso de una tarjeta microSD es especialmente útil para proyectos de registro de datos. Como ejemplo, le mostraremos cómo guardar las lecturas del sensor de un sensor BME280 con marcas de tiempo ( tiempo de época ).

Descripción general del proyecto de tarjeta microSD BME280 de registro de datos ESP32

requisitos previos

Para este ejemplo, asegúrese de tener instaladas las siguientes bibliotecas:

Puede instalar estas bibliotecas utilizando el administrador de bibliotecas de Arduino. En tu IDE de Arduino, ve a Sketch > Incluir biblioteca > Administrar bibliotecas… Luego, busca los nombres de las bibliotecas e instálalos.

Diagrama esquemático

Para este ejemplo, debe conectar el módulo de la tarjeta microSD y el sensor BME280 al ESP32. Aquí hay una lista de las piezas necesarias:

Conecte el circuito siguiendo el siguiente diagrama esquemático.

Diagrama esquemático del circuito de la tarjeta microSD ESP32 BME280

También puedes echar un vistazo a las siguientes tablas:

BME280ESP32
VIN3V3
TIERRATIERRA
SCLGPIO22
ASDGPIO21
módulo de tarjeta microSDESP32
3V33,3 V
CSGPIO5
MOSIGPIO23
CLKGPIO18
MISOGPIO19
TIERRATIERRA

https://8d47f2cdfa0fea8c35311dc564e24b83.safeframe.googlesyndication.com/safeframe/1-0-38/html/container.html

Código

Copie el siguiente código en su IDE de Arduino. Este boceto obtiene lecturas del sensor BME280 (temperatura, humedad y presión) y las registra en un archivo en la tarjeta microSD cada 30 segundos. También registra la marca de tiempo (tiempo de época solicitado a un servidor NTP).

/*
  Rui Santos
  Complete project details at https://RandomNerdTutorials.com/esp32-microsd-card-arduino/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files.
  
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
*/

// Libraries for SD card
#include "FS.h"
#include "SD.h"
#include <SPI.h>

//Libraries for BME280 sensor
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>

// Libraries to get time from NTP Server
#include <WiFi.h>
#include "time.h"

// Replace with your network credentials
const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// Timer variables
unsigned long lastTime = 0;
unsigned long timerDelay = 30000;

// BME280 I2C
Adafruit_BME280 bme;

// Variables to hold sensor readings
float temp;
float hum;
float pres;
String dataMessage;

// NTP server to request epoch time
const char* ntpServer = "pool.ntp.org";

// Variable to save current epoch time
unsigned long epochTime; 

// Function that gets current epoch time
unsigned long getTime() {
  time_t now;
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    //Serial.println("Failed to obtain time");
    return(0);
  }
  time(&now);
  return now;
}

// Initialize WiFi
void initWiFi() {
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
}

// Init BME280
void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

// Initialize SD card
void initSDCard(){
   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;
  }
  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);
}

// Write to the SD card
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();
}

// Append data to the SD card
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 setup() {
  Serial.begin(115200);
  
  initWiFi();
  initBME();
  initSDCard();
  configTime(0, 0, ntpServer);
  
  // If the data.txt file doesn't exist
  // Create a file on the SD card and write the data labels
  File file = SD.open("/data.txt");
  if(!file) {
    Serial.println("File doesn't exist");
    Serial.println("Creating file...");
    writeFile(SD, "/data.txt", "Epoch Time, Temperature, Humidity, Pressure \r\n");
  }
  else {
    Serial.println("File already exists");  
  }
  file.close();
}

void loop() {
  if ((millis() - lastTime) > timerDelay) {
    //Get epoch time
    epochTime = getTime();
    
    //Get sensor readings
    temp = bme.readTemperature();
    //temp = 1.8*bme.readTemperature() + 32;
    hum = bme.readHumidity();
    pres = bme.readPressure()/100.0F;

    //Concatenate all info separated by commas
    dataMessage = String(epochTime) + "," + String(temp) + "," + String(hum) + "," + String(pres)+ "\r\n";
    Serial.print("Saving data: ");
    Serial.println(dataMessage);

    //Append the data to file
    appendFile(SD, "/data.txt", dataMessage.c_str());

    lastTime = millis();
  }
}

https://8d47f2cdfa0fea8c35311dc564e24b83.safeframe.googlesyndication.com/safeframe/1-0-38/html/container.html

Inserte sus credenciales de red en las siguientes variables y el código funcionará de inmediato:

const char* ssid     = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Este ejemplo utiliza las funciones que hemos visto anteriormente para escribir y agregar datos a la tarjeta microSD (escribirArchivo()yagregar archivo ()funciones).

Demostración

Sube el código a tu tablero. Puede comprobar en el monitor serie si todo funciona como se esperaba.

ESP32 BME280 Registro de datos en tarjeta microSD Monitor serie

Deje que el proyecto funcione durante un tiempo para recopilar algunas lecturas. Luego, inserte la tarjeta microSD en su computadora, y debería tener un archivo llamado datos.txt con las lecturas del sensor.

ESP32 BME280 Registro de datos a archivo en tarjeta microSD

Fuente https://randomnerdtutorials.com/esp32-microsd-card-arduino/

Deja una respuesta

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Salir /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Salir /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Salir /  Cambiar )

Conectando a %s

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.