Memoire Flash & Esp32

Salut à tous. quand on veut faire simple on fait compliquer je pense être le roi.
dans mon projet de datalog je souhaiterai remplacer la micro sd par de la memoire Flash.
j ai acheté ce module Module Memory Card SPI et une carte esp32
j ai fait mes branchements comme cela


maintenant comment être sur que c est sur la flash externe que j écris, et comment connaitre la taille de la memoire ? merci

Bonsoir

Sous le capot métallique du module WROOM32 il ya déjà une mémoire Flash SPI (indispensable, sans elle l'ESP32 ne peut fonctioner) Pourquoi ajouter une seconde mémoire Flash ?

Capacité de la mémoire : regarder la référence de la puce , si c'est une W25Q128 la notice est içi , elle contient 128 Mbit soit 16 Moctet

pour exploiter une telle mémoire Flash SPI externe supplémentaire il vaut mieux diposer d'une librairie adaptée , est-ce le cas ?

Pourquoi vous embêter à rajouter 4 Mo de stockage quand vous pouvez utiliser la flash de votre esp32?
Combien de stockage utilisez vous pour votre code ? De combien avez vous besoin pour le log ?

intérieur d'un module WROOM32, a gauche l'ESP32, à droite l'indispensable mémoire flash SPI (4 Moctet)
WROOM32.png

WROOM32.png

pour l exploiter j utilise la librairie SPIFFS.h
lorsque je lance le programme Spiffs.test tout se passe bien

#include "FS.h"
#include "SPIFFS.h"

/* You only need to format SPIFFS the first time you run a
   test or else use the SPIFFS plugin to create a partition
   https://github.com/me-no-dev/arduino-esp32fs-plugin */
#define FORMAT_SPIFFS_IF_FAILED true

void listDir(fs::FS &fs, const char * dirname, uint8_t levels){
    Serial.printf("Listing directory: %s\r\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("\tSIZE: ");
            Serial.println(file.size());
        }
        file = root.openNextFile();
    }
}

void readFile(fs::FS &fs, const char * path){
    Serial.printf("Reading file: %s\r\n", path);

    File file = fs.open(path);
    if(!file || file.isDirectory()){
        Serial.println("- failed to open file for reading");
        return;
    }

    Serial.println("- 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\r\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("- frite failed");
    }
}

void appendFile(fs::FS &fs, const char * path, const char * message){
    Serial.printf("Appending to file: %s\r\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\r\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\r\n", path);
    if(fs.remove(path)){
        Serial.println("- file deleted");
    } else {
        Serial.println("- delete failed");
    }
}

void testFileIO(fs::FS &fs, const char * path){
    Serial.printf("Testing file I/O with %s\r\n", path);

    static uint8_t buf[512];
    size_t len = 0;
    File file = fs.open(path, FILE_WRITE);
    if(!file){
        Serial.println("- failed to open file for writing");
        return;
    }

    size_t i;
    Serial.print("- writing" );
    uint32_t start = millis();
    for(i=0; i<2048; i++){
        if ((i & 0x001F) == 0x001F){
          Serial.print(".");
        }
        file.write(buf, 512);
    }
    Serial.println("");
    uint32_t end = millis() - start;
    Serial.printf(" - %u bytes written in %u ms\r\n", 2048 * 512, end);
    file.close();

    file = fs.open(path);
    start = millis();
    end = start;
    i = 0;
    if(file && !file.isDirectory()){
        len = file.size();
        size_t flen = len;
        start = millis();
        Serial.print("- reading" );
        while(len){
            size_t toRead = len;
            if(toRead > 512){
                toRead = 512;
            }
            file.read(buf, toRead);
            if ((i++ & 0x001F) == 0x001F){
              Serial.print(".");
            }
            len -= toRead;
        }
        Serial.println("");
        end = millis() - start;
        Serial.printf("- %u bytes read in %u ms\r\n", flen, end);
        file.close();
    } else {
        Serial.println("- failed to open file for reading");
    }
}

void setup(){
    Serial.begin(115200);
    if(!SPIFFS.begin(FORMAT_SPIFFS_IF_FAILED)){
        Serial.println("SPIFFS Mount Failed");
        return;
    }
    
    listDir(SPIFFS, "/", 0);
    writeFile(SPIFFS, "/hello.txt", "Hello ");
    appendFile(SPIFFS, "/hello.txt", "World!\r\n");
    readFile(SPIFFS, "/hello.txt");
    renameFile(SPIFFS, "/hello.txt", "/foo.txt");
    readFile(SPIFFS, "/foo.txt");
    deleteFile(SPIFFS, "/foo.txt");
    testFileIO(SPIFFS, "/test.txt");
    deleteFile(SPIFFS, "/test.txt");
    Serial.println( "Test complete" );
}

void loop(){

}

mais je ne sais pas quelle memoire est utilisée pour le test.
la taille du log est au max de 850ko.
Le croquis utilise 1132081 octets (86%) de l’espace de stockage de programmes. Le maximum est de 1310720 octets.
Les variables globales utilisent 40016 octets (12%) de mémoire dynamique, ce qui laisse 287664 octets pour les variables locales. Le maximum est de 327680 octets.
aurais je assez de place dans la flash spi interne ?

Bonsoir

pour l exploiter j utilise la librairie SPIFFS.h

  1. SPIFFS ne peut concerner que la mémoire Flash SPI associée à l'ESP32 dans le module WROOM32 !!... (un module WROOM32 ce n'est pas un ESP32 'tout seul' mais un ESP32 avec ce qu'il faut de composants autour... dont une mémoire Flash SPI)

Pour gérer une éventuelle mémoire Flash SPI supplémentaire il faut écrire un code adapté ou utiliser une librairie adhoc. Sans cela la mémoire Flash additionnelle n'est pas du tout exploitée.
L'IDE Arduino et les outils Espressif associés ne savent pas exploiter spontanément cette mémoire que tu as ajouté.

  1. Le code compilé va forcément dans la mémoire Flash SPI (4 Moctets) du module WROOM32 , pas dans la mémoire que tu as ajouté à l'extérieur.

  2. Les 4 Moctets de Flash situés dans le Module WROOM32 peuvent être utilisés de différentes façons, voir le menu "Partition scheme" qui permet d'allouer jusqu'à 3 Moctets au code sur les 4 Moctets disponibles, c'est énorme !

par défaut c'est 1,2 Moctets pour le code et 1,5 Moctets pour le systeme de fichiers
d'ou le message :

 ........ Le maximum est de 1310720 octets
  1. Si le fichier Log a une taille maximale de 850 ko il tient dans les 1500 ko alloués par défaut à SPIFFS

Merci de votre aide

une autre question piège :
est il possible de recuperer le fichier inscrit dans la SPIFFS via le port USB ? le fichier est un .csv
ou il faut passer par un autre moyen de communication BLE/Wifi....
merci

Bonjour

On récupère ce fichier au moyen de lignes de code dans le programme , par USB, WiFi ou Bluetooth

ca m interesse de plus en plus. as tu un exemple pour l USB ?

l'exemple SPIFFS_Test comporte une fonction envoyant par USB le contenu d'un fichier préalablement enregistré

void readFile(fs::FS &fs, const char * path){
    Serial.printf("Reading file: %s\r\n", path);

    File file = fs.open(path);
    if(!file || file.isDirectory()){
        Serial.println("- failed to open file for reading");
        return;
    }

    Serial.println("- read from file:");
    while(file.available()){
        Serial.write(file.read());
    }
}

Un moteur de recherche lançé avec "ESP32 datalogging SPIFFS" donnera sans doute des exemples plus proches de ce que tu cherches à faire (même chose avec ESP8266)

merci