Other Problem with ESP32 and SD card...

Status
Not open for further replies.

rbghongade

Active Member
Licensed User
Longtime User
Dear friends,
Tried to interface LOLIN32 with SD card but got compilation error:
B4X:
D:\DEVELO~1\WEMOSP~1\WEMOS_SD\B4R_SD~1\Objects\bin\sketch\rSD.cpp:11:7: note:   initializing argument 2 of 'bool B4R::B4RSD::open(B4R::B4RString*, Int)'
  bool B4RSD::open (B4RString* FileName, Int mode) {
       ^
D:\DEVELO~1\WEMOSP~1\WEMOS_SD\B4R_SD~1\Objects\bin\sketch\rSD.cpp: In member function 'bool B4R::B4RSD::OpenReadWrite(B4R::B4RString*)':
rSD.cpp:25: error: invalid conversion from 'const char*' to 'Int {aka short int}' [-fpermissive]
   return open(FileName, FILE_WRITE);
                                   ^
D:\DEVELO~1\WEMOSP~1\WEMOS_SD\B4R_SD~1\Objects\bin\sketch\rSD.cpp:11:7: note:   initializing argument 2 of 'bool B4R::B4RSD::open(B4R::B4RString*, Int)'
  bool B4RSD::open (B4RString* FileName, Int mode) {
       ^
Multiple libraries were found for "SD.h"
Used: C:\Users\RAJESH\Documents\Arduino\hardware\espressif\esp32\libraries\SD
Not used: C:\Program Files (x86)\Arduino\libraries\SD
exit status 1
It seems there is some incompatibility with ESP32 SD library! (Probably needs a new/modified wrapper!)
This Arduino sketch works fine:
 

Attachments

  • SD_Test.zip
    1.4 KB · Views: 369

Toley

Active Member
Licensed User
Longtime User
I was able to run an SD card on ESP32 with Arduino so it might works. Note that you have to connect your SD card on those pins.
687474703a2f2f692e696d6775722e636f6d2f34436f584f75522e706e67
 
Upvote 0

rbghongade

Active Member
Licensed User
Longtime User
Dear Erel,
The unfortunately the new rSD library does not work. It compiles ok but is unable to create a file on the SD card.
Here is my code:
B4X:
Sub Process_Globals
   Public Serial1 As Serial
   Private timer1 As Timer
   Private sd As SD
   Private analogPin As Pin                         
   
End Sub

Private Sub AppStart
    Serial1.Initialize(115200)
    Log("AppStart")
    sd.Initialize(5)
    analogPin.Initialize(36, analogPin.MODE_OUTPUT)
    timer1.Initialize("timer1_Tick", 100)
    timer1.Enabled = True
  
End Sub

Sub Timer1_Tick
    Dim a As String
    Dim bc As ByteConverter
    Dim k(1) As Byte
    Dim rawvoltage As UInt = analogPin.AnalogRead

 
      Log( rawvoltage)
    Log("File opened :",sd.OpenReadWrite("NEW.TXT"))

    Dim b As String
    a=rawvoltage
    b=JoinStrings(Array As String(a,CRLF))
    k=bc.stringToBytes(b)
    sd.Position=sd.CurrentFile.Size
    sd.Stream.WriteBytes(k,0,k.length)
    sd.Close

End Sub
 
Upvote 0

rbghongade

Active Member
Licensed User
Longtime User
Dear Erel,
The code does not return anything.
The same library works great for ESP8266 and returns filelist.
 
Last edited:
Upvote 0

CoraDias

New Member
Hi...as per my knowledge in IDF sdmmc driver, clock frequencies used for default speed and high speed mode are 20 and 40 MHz, respectively, because the peripheral clock divider allows only 160MHz/n frequencies, and the closest ones (26.7MHz and 53.3MHz) would be out of spec.

heavy copper pcb
 
Last edited:
Upvote 0

whcir

Member
Licensed User
Longtime User
Has this problem been fixed? I too am able to write to the SD card using the Arduino IDE, but not using B4R. SD.Initialize returns true, but the other functions return false.
 
Upvote 0

whcir

Member
Licensed User
Longtime User
This is from the examples in Arduino and runs with no errors

B4X:
#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(){

}

This is the test B4R code.

B4X:
#Region Project Attributes
    #AutoFlushLogs: True
    #CheckArrayBounds: True
    #StackBufferSize: 1000
    #DefineExtra:#define SKIP_B4RNEW
#End Region
  
Sub Process_Globals
    'These global variables will be declared once when the application starts.
    'Public variables can be accessed from all modules.
    Public Serial1 As Serial
    Private sd As SD
  
End Sub

Private Sub AppStart
    Serial1.Initialize(115200)
    Log("AppStart")
    Log("Initialize: ", sd.Initialize(5)) '4 is the CS pin when using the ethernet shield
    Log("OpenReadWrite: ", sd.OpenReadWrite("log.txt"))
    sd.Stream.WriteBytes("abcde", 0, 5)
    sd.Close
    Log("Open: ", sd.OpenRead("log.txt"))
    Log("Size: ", sd.CurrentFile.Size)
    sd.Close
    Log("Free memory: ", AvailableRAM)
End Sub
 
Upvote 0

whcir

Member
Licensed User
Longtime User
Arduino
B4X:
SD Card Type: SDSC
SD Card Size: 1876MB
Listing directory: /
  FILE: /test.txt  SIZE: 0
  FILE: /foo.txt  SIZE: 13
Creating Dir: /mydir
Dir created
Listing directory: /
  FILE: /test.txt  SIZE: 0
  FILE: /foo.txt  SIZE: 13
  DIR : /mydir
Removing Dir: /mydir
Dir removed
Listing directory: /
  FILE: /test.txt  SIZE: 0
  FILE: /foo.txt  SIZE: 13
Writing file: /hello.txt
File written
Appending to file: /hello.txt
Message appended
Reading file: /hello.txt
Read from file: Hello World!
Deleting file: /foo.txt
File deleted
Renaming file /hello.txt to /foo.txt
File renamed
Reading file: /foo.txt
Read from file: Hello World!
0 bytes read for 0 ms
1048576 bytes written for 32140 ms
Total space: 1843MB
Used space: 1MB

B4R
B4X:
AppStart
Initialize: 1
OpenReadWrite: 0
Open: 0
Size: 0
Free memory: 346468

/test.txt    1024kb    0
/foo.txt    0kb    0
 
Upvote 0
Status
Not open for further replies.
Top