ESP32-CAM & SD-Card

[db91595]

Hiermit konnte ich meine 16GB SD-Card testen

Oben sind gesammelte Werke.
Meine Frage (an die, die Interna vom ESP32 kennen) - da GPIO 4 sowohl von der FlashLed als auch vom SD-Card-Leser benutzt werden:
Kann man die FlashLed "remappen"? (entl. auf GPIO16?)
(Ich habe aus einer ESP32-CAM ohne CAM einen WebServer gemacht.)
(Wenn ich dort die SD-Card benutze leuchtet jedes mal die FlashLed)
(Ewige Lösung wäre FlashLed auslöten. Möchte ich aber nicht.)
(Man könnte sie ja noch mal gebrauchen.)

Code:

/*
  SD card read/write
https://github.com/v12345vtm/CameraWebserver2SD/blob/master/CameraWebserver2SD/CameraWebserver2SD.ino
https://gist.github.com/youjunjer/b70b6e54ae7201a46387b8e73894ba51
http://i.imgur.com/4CoXOuR.png
.arduino15/packages/esp32/hardware/esp32/1.0.4/libraries/SD

   ESP32-CAM board uses  the SD card to the following pins:
   SD Card | ESP32    |esp32-cam
      D2       -          -
      D3       SS         gpio13
      CMD      MOSI       gpio15
      VSS      GND        gnd
      VDD      3.3V       3.3v
      CLK      SCK        gpio14
      VSS      GND        gnd
      D0       MISO       gpio2
      D1       -          gpio4 + LED flash also  :(
  FLASHLED                gpio4
  led1                    gpio33 (mini smd ledje below ESP32-controler)
      SD card socket : pin 9 is SD ( = CARD DETECTION , is a card inserted ? )

*/
  Example from https://gist.github.com/youjunjer/b70b6e54ae7201a46387b8e73894ba51
  Das erste Beispiel das funktioniert.
  Einziger "Nachteil": beim Zugriff auf SD-CARD leuchtet FlashLed hell, am Ende nur schwach.
  Wenn ich an GPIO4 einen PullDown von 4k7 mache geht nach SD-Zugriff die FlashLed ganz aus.

  Was sehr gut funktioniert: // https://github.com/robotzero1/esp32cam-timelapse/blob/master/timelapse-sd.ino
  Da leuchtet die FlashLed nur kurz bei Cam-Aufnahme und geht mit PullDown dann aus.

// This post referred to this git. I just trimmed cam and wifi part.
// https://github.com/v12345vtm/CameraWebserver2SD/blob/master/CameraWebserver2SD/CameraWebserver2SD.ino

#include "FS.h"
#include "SD_MMC.h"

#define FlashLed  4  //esp32-cam licht !!! (gross & hell !!!)

//List dir in SD card
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();
    }
}

//Create a dir in SD card
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");
    }
}

//delete a dir in SD card
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");
    }
}

//Read a file in SD card
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());
    }
}

//Write a file in 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;
    }

   //fwrite(fb->buf, 1, fb->len, file);
    if(file.print(message)){
        Serial.println("File written");
    } else {
        Serial.println("Write failed");
    }
}

//Append to the end of file in 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");
    }
}

//Rename a file in SD card
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");
    }
}

//Delete a file in SD card
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");
    }
}

//Test read and write speed using test.txt file
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);
  Serial.println("SDcard Testing....");

  pinMode(FlashLed, OUTPUT);
  digitalWrite(FlashLed, LOW);
  digitalWrite(FlashLed, HIGH);
  digitalWrite(FlashLed, LOW);
  
   if(!SD_MMC.begin()){
        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() {
  // put your main code here, to run repeatedly:
  Serial.println("loop end, 10sec delay");
  delay(10000);
}

[biologist]

(09.03.2020 12:57)db91595 schrieb:  Oben sind gesammelte Werke.
Meine Frage (an die, die Interna vom ESP32 kennen) - da GPIO 4 sowohl von der FlashLed als auch vom SD-Card-Leser benutzt werden:
Kann man die FlashLed "remappen"? (entl. auf GPIO16?)

Nee, die LED kannst du nicht mappen. Aber es hindert dich ja keiner daran, die SPI-Instanz auf andere GPIOs zu legen. War bei mir notwendig bei meinem Tonuino-Projekt, da auf den Default-GPIOs für SPI bereits der Rfid-Reader steckt.

Code:

#define SPISD_CS                        15
#define SPISD_MOSI                      13
#define SPISD_MISO                      16          // 12 doesn't work with Lolin32-devBoard: uC doesn't start if put HIGH at start
#define SPISD_SCK                       14
[...]
spiSD.begin(SPISD_SCK, SPISD_MISO, SPISD_MOSI, SPISD_CS);

VSPI und HSPI sind hier noch wichtige Stichwörter.
https://docs.espressif.com/projects/esp-...aster.html

[db91595]

Hi biologist,

zu erst mal DANKE für deine Antwort!
"a weng irritation"
Im Beispiel ist eingebunden #include "SD_MMC.h" , du schreibst von "spiSD.begin..."

SD.h // Beispiel aus IDE
bool begin(uint8_t ssPin=SS, SPIClass &spi=SPI, uint32_t frequency=4000000, const char * mountpoint="/sd", uint8_t max_files=5);

SD_MMC.h // Beispiel oben (gefunden mit google)
bool begin(const char * mountpoint="/sdcard", bool mode1bit=false);

Das bekomme ich nicht zusammen "gebacken".

Das Beispiel in der IDE mit SD.h sagt bei mir "Karte nicht gefunden".
Das gefunden Beispiel mit SD_MMC.h funktioniert (lesen, schreiben...). SD-Card(16GB) in PC & ich sehe die Dateien im Explorer.

Das 2te Beispiel "timelapse" funktioniert gut: alle 5sec 1 Picture & speichern auf SD. (Bis m.M.n. auf das geflacker der Led)

[biologist]

Du musst den SPI-Prozess natürlich auch instanzieren.
SPIClass spiSD(HSPI);

Kannst ja mal in meinem Sketch nach spiSD suchen: https://github.com/biologist79/Tonuino-E...c/main.cpp
Bei SPI muss man etwas aufpassen. Also dass man, wenn man das mit Jumperwires macht, halt kurze verwendet. Ich habe auch die Erfahrung gemacht, dass es hilfreich sein kann, wenn man den SPI-Takt runtersetzt: spiSD.setFrequency(1000000);.

[db91595]

DANKE für's Gehirnfutter!
Ich werde mich mal damit auseinander setzen.

[db91595]

Ein kleiner Erfolg.
(TimeLapse macht alle 5sec(oder 10 oder 60...) ein Bild und speichert das in SD-Card)
Ich habe gefunden: https://github.com/robotzero1/esp32cam-timelapse
In seinem Blog: https://robotzero.one/time-lapse-esp32-cameras/
taucht das "FlashLed-Problem" auch auf.

Ich gestehe noch mal "C++ ist nicht meine 'Muttersprache' ".
Aber ich kann lesen und z.T. anpassen.
In dem Blog ist die Rede von "host.flag = SDMMC_HOST_FLAG_1BIT;"
was den Compiler "ärgert".
Nach dem ich die "sdmmc_host.h" gelesen habe hat es auch NUR 5 Minuten gedauert bis ich das fehlende "s" bei "host.flags.." gefunden habe.
(1 Buchstabe Differenz: das dauert bis das auffällt)

@biologist
Da ich in Post #1 in "SD card read/write" kein init_sdcard() drin habe
WIE bekomme ich "host.flags = SDMMC_HOST_FLAG_1BIT;" dort rein?

In Time-Lapse wird benutzt

Code:

// MicroSD
#include "driver/sdmmc_host.h"
#include "driver/sdmmc_defs.h"
#include "sdmmc_cmd.h"
#include "esp_vfs_fat.h"
// GPIO (rtc_gpio_hold_en())
#include "driver/rtc_io.h"

#define FlashLed           4

void setup()
  rtc_gpio_hold_dis(gpio_num_t(FlashLed));
  pinMode(FlashLed, OUTPUT);
  digitalWrite(FlashLed, LOW);
// mit 4k7 PullDown von GPIO 4 zu Gnd ist die Led ganz aus (bei LOW)

static esp_err_t init_sdcard()
{
  esp_err_t ret = ESP_FAIL;
  sdmmc_host_t host = SDMMC_HOST_DEFAULT();
  sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
  esp_vfs_fat_sdmmc_mount_config_t mount_config = {
    .format_if_mount_failed = false,
    .max_files = 1,
  };
  sdmmc_card_t *card;

  host.flags = SDMMC_HOST_FLAG_1BIT; //<--
  // <-- = SD 1-Bit-Kommunikationsmodus = no FlashLed
  // SD wird langsamer beschrieben, aber FlashLed gibt Ruhe
  // muss jeder für sich entscheiden:
  // langsam 1BIT und ohne FlashLed
  // oder schnell 4BIT und mit FlashLed

  Serial.println("Mounting SD card...");
  ret = esp_vfs_fat_sdmmc_mount("/sdcard", &host, &slot_config, &mount_config, &card);
  if (ret == ESP_OK) {
    Serial.println("SD card mount successfully!");
  }  else  {
    Serial.printf("Failed to mount SD card VFAT filesystem. Error: %s", esp_err_to_name(ret));
  }
}

[biologist]

Schau dir mal die Lib dazu von Espressif an: https://github.com/espressif/arduino-esp...MC.cpp#L38

Weiter unten dann:

https://github.com/espressif/arduino-esp...MC.cpp#L66

Und dann noch:

https://github.com/espressif/arduino-esp...c/SD_MMC.h

Der Signatur werden zwei Default-Values mitgegeben, die du aber auch überschreiben kannst. Kannst ja mal begin("/sdcard", true) testen. Ich hoffe mal, dass ich an deiner Frage nicht vorbei geantwortet habe :-)

[db91595]

Versuch 1

Code:

void setup() {  
  Serial.begin(115200);
  Serial.println("SDcard Testing....");

  pinMode(FlashLed, OUTPUT);
  digitalWrite(FlashLed, LOW);
  digitalWrite(FlashLed, HIGH);
  digitalWrite(FlashLed, LOW);

  // SD_MMC Setting -->
  sdmmc_host_t host = SDMMC_HOST_DEFAULT();
  sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
  host.flags = SDMMC_HOST_FLAG_1BIT;  // <-- SD 1-Bit-Kommunikationsmodus = no FlashLed ???
  sdmmc_card_t *card;
  // <-- SD_MMC Setting
  
  if(!SD_MMC.begin())
  {
    Serial.println("Card Mount Failed");
    return;
  }

SerialMonitor:
14:58:26.133 -> SDcard Testing....
14:58:26.200 -> SD_MMC Card Type: SDHC
14:58:26.200 -> SD_MMC Card Size: 15193MB
14:58:26.200 -> Listing directory: /
14:58:26.233 ->   FILE: /capture_2020-03-09_14_47_59.jpg  SIZE: 116138
14:58:26.233 ->   FILE: /capture_2020-03-09_14_48_08.jpg  SIZE: 94675
.....
FlashLed leuchtet !!!

Compiler läuft durch, Sketch läuft aber  // SD_MMC Setting --> hat keine Wirkung