262 lines
7.6 KiB
C++
262 lines
7.6 KiB
C++
/*
|
|
* pin 1 - D2 | Micro SD card |
|
|
* pin 2 - D3 | /
|
|
* pin 3 - CMD | |__
|
|
* pin 4 - VDD (3.3V) | |
|
|
* pin 5 - CLK | 8 7 6 5 4 3 2 1 /
|
|
* pin 6 - VSS (GND) | ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄ /
|
|
* pin 7 - D0 | ▀ ▀ █ ▀ █ ▀ ▀ ▀ |
|
|
* pin 8 - D1 |_________________|
|
|
* ║ ║ ║ ║ ║ ║ ║ ║
|
|
* ╔═══════╝ ║ ║ ║ ║ ║ ║ ╚═════════╗
|
|
* ║ ║ ║ ║ ║ ║ ╚══════╗ ║
|
|
* ║ ╔═════╝ ║ ║ ║ ╚═════╗ ║ ║
|
|
* Connections for ║ ║ ╔═══╩═║═║═══╗ ║ ║ ║
|
|
* full-sized ║ ║ ║ ╔═╝ ║ ║ ║ ║ ║
|
|
* SD card ║ ║ ║ ║ ║ ║ ║ ║ ║
|
|
* ESP32-S3 DevKit | 21 47 GND 39 3V3 GND 40 41 42 |
|
|
* ESP32-S3-USB-OTG | 38 37 GND 36 3V3 GND 35 34 33 |
|
|
* ESP32 | 4 2 GND 14 3V3 GND 15 13 12 |
|
|
* ESP32-S3-Camera 40 41 42 39 38 37
|
|
* Pin name | D1 D0 VSS CLK VDD VSS CMD D3 D2 |
|
|
* SD pin number | 8 7 6 5 4 3 2 1 9 /
|
|
* | █/
|
|
* |__▍___▊___█___█___█___█___█___█___/
|
|
* WARNING: ALL data pins must be pulled up to 3.3V with an external 10k Ohm resistor!
|
|
* Note to ESP32 pin 2 (D0): Add a 1K Ohm pull-up resistor to 3.3V after flashing
|
|
*
|
|
*
|
|
* For more info see file README.md in this library or on URL:
|
|
* https://github.com/espressif/arduino-esp32/tree/master/libraries/SD_MMC
|
|
*/
|
|
|
|
#include "FS.h"
|
|
#include "SD_MMC.h"
|
|
|
|
// Default pins for ESP-S3
|
|
// Warning: ESP32-S3-WROOM-2 is using most of the default GPIOs (33-37) to interface with on-board OPI flash.
|
|
// If the SD_MMC is initialized with default pins it will result in rebooting loop - please
|
|
// reassign the pins elsewhere using the mentioned command `setPins`.
|
|
// Note: ESP32-S3-WROOM-1 does not have GPIO 33 and 34 broken out.
|
|
// Note: if it's ok to use default pins, you do not need to call the setPins
|
|
int clk = 42;
|
|
int cmd = 39;
|
|
int d0 = 41;
|
|
int d1 = 40;
|
|
int d2 = 37;
|
|
int d3 = 38;
|
|
|
|
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());
|
|
}
|
|
}
|
|
|
|
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");
|
|
}
|
|
}
|
|
|
|
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");
|
|
}
|
|
}
|
|
|
|
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 %lu 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 %lu ms\n", 2048 * 512, end);
|
|
file.close();
|
|
}
|
|
|
|
void setup() {
|
|
Serial.begin(115200);
|
|
while (!Serial)
|
|
;
|
|
Serial.println("starting...");
|
|
/*
|
|
// If you want to change the pin assignment on ESP32-S3 uncomment this block and the appropriate
|
|
// line depending if you want to use 1-bit or 4-bit line.
|
|
// Please note that ESP32 does not allow pin change and will always fail.
|
|
//if(! SD_MMC.setPins(clk, cmd, d0)){
|
|
if(! SD_MMC.setPins(clk, cmd, d0, d1, d2, d3)){
|
|
Serial.println("Pin change failed!");
|
|
return;
|
|
}
|
|
*/
|
|
if (!SD_MMC.setPins(clk, cmd, d0)) {
|
|
Serial.println("Pin change failed!");
|
|
return;
|
|
}
|
|
if (!SD_MMC.begin("/sdcard", true)) {
|
|
Serial.println("Card Mount Failed");
|
|
return;
|
|
}
|
|
uint8_t cardType = SD_MMC.cardType();
|
|
|
|
if (cardType == CARD_NONE) {
|
|
Serial.println("No SD_MMC card attached");
|
|
return;
|
|
}
|
|
|
|
Serial.print("SD_MMC 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_MMC.cardSize() / (1024 * 1024);
|
|
Serial.printf("SD_MMC Card Size: %lluMB\n", cardSize);
|
|
|
|
listDir(SD_MMC, "/", 0);
|
|
createDir(SD_MMC, "/mydir");
|
|
listDir(SD_MMC, "/", 0);
|
|
removeDir(SD_MMC, "/mydir");
|
|
listDir(SD_MMC, "/", 2);
|
|
writeFile(SD_MMC, "/hello.txt", "Hello ");
|
|
appendFile(SD_MMC, "/hello.txt", "World!\n");
|
|
readFile(SD_MMC, "/hello.txt");
|
|
deleteFile(SD_MMC, "/foo.txt");
|
|
renameFile(SD_MMC, "/hello.txt", "/foo.txt");
|
|
readFile(SD_MMC, "/foo.txt");
|
|
testFileIO(SD_MMC, "/test.txt");
|
|
Serial.printf("Total space: %lluMB\n", SD_MMC.totalBytes() / (1024 * 1024));
|
|
Serial.printf("Used space: %lluMB\n", SD_MMC.usedBytes() / (1024 * 1024));
|
|
}
|
|
|
|
void loop() {} |