Hi, i have bought this microSD breakout board from adafruit.
I could make it work with arduino, following the tutorial (i don't know why is the only one in the internet), but the problem is that i tryed making it work with esp32, but i'm probably wrong on the wiring.
Is there somebody that already tryed wiring the microSD breakout board to the esp32?
Thanks!
You don't say which Arduino board you tried but have you taken into account that the ESP32 is a 3V3 board rather than a 5V board ?
How do you have the SD module powered and wired to the ESP32 ?
I tried the arduino Uno R3 board, and works perfectly.
And my project have esp32 and an random arduino, so i take the 5v and gnd from the arduino.
The problem is that this board nobody have made a tutorial for esp32, so I don't feel comfortable putting wiring randomly
Which pins on the ESP32 did you connect the SD card to ?
I assume that it has an SPI interface
SCK 18, MISO 19, MOSI 23, SDCS 13 works for me.
ok... im gonna try it
What did you try before ?
UKHeliBob I tryed:
SCK 18 (because the name was similar) MISO 19 (same name), MOSI (same name) SDCS 2.
Now i have a problem, the gpio13 is already used for a display, but the SCK MISO MOSI are available. The problem is what other pin can replace the gpio 13? I thought for example the gpio36 or 39, or 22, or 21 ...
Those are input only pins, not much use for SDCS which needs to be an output capable pin.
ah ok, so in base this site
i could use gpio22, 21?
If 21 or 22 are not connected to anthing else, then try them.
ok i will!
I have an error, i wired like this:
5V ----> 5V (external Arduino)
GND -> GND (external Arduino)
CLK --> GPIO18
DO ---> GPIO19
DI ----> GPIO23
CS ----> GPIO22
the code:
File myFile;
void setup(){
pinMode(22, OUTPUT);
if (!SD.begin(22)) {
Serial.println("initialization failed!");
return;
}
Serial.println("initialization done.");
myFile = SD.open("settings.txt", FILE_WRITE);
// if the file opened okay, write to it:
if (myFile) {
Serial.print("Writing to settings.txt...");
myFile.println("testing 1, 2, 3.");
// close the file:
myFile.close();
Serial.println("done.");
} else {
// if the file didn't open, print an error:
Serial.println("error opening settings.txt");
}
}
In the serial monitor I get the error ''initialization failed!"
Maybe i'm wrong in the pinMode?
That you have not posted
the error is the message in the serial monitor. Ok... is not an 'error' but it doesn't work
Please copy the message from the Serial monitor and post it here in code tags. Please do not post a picture of the Serial monitor
The error in the Serial monitor...:
initialization failed!
I went the the SD.h folder library, and in src/utility/sd2pinmap.h i replaced every definition of sck, miso, mosi, and cs, with the same declaration:
uint8_t const SS_PIN = 22;
uint8_t const MOSI_PIN = 23;
uint8_t const MISO_PIN = 19;
uint8_t const SCK_PIN = 18;
Now in the Serial monitor i don't get the error
initialization failed!
But i get the error (with error i mean the println from the code):
error opening settings.txt
Finally after hours i made it... let me explain.
Wiring (i tried 3v and 5v and nothing changed):
3V -> 3V
GND -> GND
SCK -> gpio18
DO (miso) -> gpio19
DI (mosi) -> gpio23
CS (ss) -> gpio5
Easy and fast Code:
#include "FS.h"
#include "SD.h"
#include "SPI.h"
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 setup(){
Serial.begin(115200);
if(!SD.begin()){
Serial.println("Card Mount Failed");
return;
}
if(cardType == CARD_NONE){
Serial.println("No SD card attached");
return;
}
writeFile(SD, "/hello.txt", "Hello ");
readFile(SD, "/hello.txt");
}
void loop(){
}
Complicate Example Code:
#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()){
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(){
}
1 Like
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.