Sd card module

SD Kortelės modulis skirtas dirbti su įvairiais mikrovaldikliais. Jį galima pigiai nusipirkti čia.

Pajungimas prie ESP32

Naudosim SPI2 interface, paliekam pirmajį laisvą, gal reikės pajungti daugiau įrengimų, pajungimo schema būtų tokia:

• ESP32 PIN 16 -> SD Card CS
• ESP32 PIN 14 -> SD Card SCK
• ESP32 PIN 13 -> SD Card MOSI
• ESP32 PIN 5 -> SD Card MISO

Kodo pavyzdys būtų toks:

#include <SPI.h>
#include <SD.h>

#define SD_CS_PIN        16
// These pins will be use for SPI2
#define SD_SCK_PIN       14
#define SD_MOSI_PIN      13
#define SD_MISO_PIN      5

SPIClass SPI2(HSPI);

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.path(), 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();
}

SPIClass SPISD(HSPI);

void setup()
{
  Serial.begin(115200);
  while (!Serial && millis() < 5000);

  //Serial.print(F("\nStart ESP32_SD_SPI2_FileTest on ")); Serial.println(ARDUINO_BOARD);

  Serial.println(F("Current SPI pinout:"));
  Serial.print(F("SD_MOSI_PIN:")); Serial.println(SD_MOSI_PIN);
  Serial.print(F("SD_MISO_PIN:")); Serial.println(SD_MISO_PIN);
  Serial.print(F("SD_CLK_PIN:"));  Serial.println(SD_SCK_PIN);
  Serial.print(F("SD_CS_PIN:"));   Serial.println(SD_CS_PIN);

  Serial.println("Serial communication started.");

  SPISD.begin(SD_SCK_PIN, SD_MISO_PIN, SD_MOSI_PIN);

  if (!SD.begin(SD_CS_PIN, SPISD))
  {
    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()
{
  // put your main code here, to run repeatedly:
  delay(1000);
}

Pavyzdys paprastas, nuskaitoma SD korta, jos direktorijos, parašoma informacija, pratestuojama ar išeina sukurti failus ir t.t.