ESP32 Wroom et memoire interne

Bonjour à tous,

Peut ton utilisé le stockage interne de l'ESP32 Wroom comme une carte SD pour faire un DataLogger ?

Quel est sa taille ? dans la partie: "3.2 External Flash and SRAM"

il indique 11mb , est-ce correct ?

Merci

Bonjour

Peut ton utilisé le stockage interne de l'ESP32 Wroom comme une carte SD pour faire un DataLogger ?

Oui en utilsant un système de fichiers sur une partie de la mémoire Flash

il indique 11mb , est-ce correct ?

ça dépend... c'est flexible

Pour ce type d'application on alloue en général une partie de la mémoire Flash SPI (externe à l'ESP32 mais interne au module !) à un petit système de fichier : SPIFFS ou FFat

Pour répartir l'espace mémoire Flash SPI entre Application, OTA, Système de fichiers..... il est procédé systématiquement à un partitionnement.

-> Voir les options de partitionnement offertes dans le menu Tools/Partition Scheme

Le module WROOM32 intègre, sous le capot métallique, une mémoire Flash SPI de 4MB associée à l'ESP32.

En délaissant la possibilité d'OTA, on peut allouer jusqu'à 3MB au système de fichier (24Mb)

Le partitionnement par défaut réserve 1,5MB (12Mb) au système de fichier sur les 4MB disponibles

al1fch: Pour répartir l'espace mémoire Flash SPI entre Application, OTA, Système de fichiers..... il est procédé systématiquement à un partitionnement.

[...]

En délaissant la possibilité d'OTA, on peut allouer jusqu'à 3MB au système de fichier (24Mb)

Merci de ce réponses .

24Mb c'est suffisant.

On pourrais récupérés les données ces données via une page web ?

Bonsoir

Du coup j’ai essayé le fichier exemple :

FFat_Test :

#include "FS.h"
#include "FFat.h"

// This file should be compiled with 'Partition Scheme' (in Tools menu)
// set to 'Default with ffat' if you have a 4MB ESP32 dev module or
// set to '16M Fat' if you have a 16MB ESP32 dev module.

// You only need to format FFat the first time you run a test
#define FORMAT_FFAT 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);
    Serial.setDebugOutput(true);
    if (FORMAT_FFAT) FFat.format();
    if(!FFat.begin()){
        Serial.println("FFat Mount Failed");
        return;
    }

    Serial.printf("Total space: %10u\n", FFat.totalBytes());
    Serial.printf("Free space: %10u\n", FFat.freeBytes());
    listDir(FFat, "/", 0);
    writeFile(FFat, "/hello.txt", "Hello ");
    appendFile(FFat, "/hello.txt", "World!\r\n");
    readFile(FFat, "/hello.txt");
    renameFile(FFat, "/hello.txt", "/foo.txt");
    readFile(FFat, "/foo.txt");
    deleteFile(FFat, "/foo.txt");
    testFileIO(FFat, "/test.txt");
    Serial.printf("Free space: %10u\n", FFat.freeBytes());
    deleteFile(FFat, "/test.txt");
    Serial.println( "Test complete" );
}

void loop(){

}

Mais le fichier me retourne :

FFat Mount Failed

C’est pas le fichier dédier a l’ESP32 ?

C'est bon j'ais trouvé il fallait modidier un fichier:

Name, Type, SubType, Offset, Size, Flags

nvs, data, nvs, 0x9000, 0x5000, otadata, data, ota, 0xe000, 0x2000, app0, app, ota_0, 0x10000, 0x140000, app1, app, ota_1, 0x150000,0x140000, ffat, data, fat, 0x290000,0x170000,

Du coup si je supprime la ligne otadata je récupere de la place ?

l'exemple FFat_test a-t-il été copilé après la sélection d'une option adaptés dans le menu Tools/Partition Scheme ? .... une option prévue pour une mémoire Flash de 4MB et FFAT?

/!\ Attention en retouchant un fichier de partitionnement comme celui-ci :

# Name,   Type, SubType, Offset,  Size, Flags
nvs,      data, nvs,      0x9000,  0x5000,
otadata,  data, ota,     0xe000,  0x2000,
app0,     app,  ota_0,   0x10000, 0x140000,
app1,     app,  ota_1,   0x150000,0x140000,
ffat,      data, fat,        0x290000,0x170000,

Il faut redéfinir les tailles des partitions en hexa et recalculer toutes les adresses d'offset !! c'est un travail minutieux pour aboutir à un ensemble cohérent !! A éviter sauf raison particulière = besoin d'un plan de partitionnement très spécial.

[u]Mieux vaut jouer avec le menu Partitionnementt de l'IDE qui propose un bon choix[/u] si on prend une carte ESP32 DEV Module, ce menu est là poyur éiyter de mettre les moins dans le cambouis et passer pas mal de temps avant de produire quelque chose de positif

Chez moi l'exemple Ffat-test compilé pour

  • Type de carte : ESP32 Dev Module
  • Partition Scheme : default 4MB with ffat.....

est compilé sans problème et tourne correctement sur une carte 'no name' à ESP32 dans le terminal on lit

Total space:    1458176
Free space:    1458176
Listing directory: /
Writing file: /hello.txt
- file written
Appending to file: /hello.txt
- message appended
Reading file: /hello.txt
- read from file:
Hello World!
Renaming file /hello.txt to /foo.txt
- file renamed
Reading file: /foo.txt
- read from file:
Hello World!
Deleting file: /foo.txt
- file deleted
Testing file I/O with /test.txt
- writing................................................................
 - 1048576 bytes written in 7579 ms
- reading................................................................
- 1048576 bytes read in 260 ms
Free space:     409600
Deleting file: /test.txt
- file deleted
Test complete

Le menu de partionnnement dans l'IDE

Je ne l'ai pas :

le menu d epartitionnement n'apparait paspour toutes les cartes à ESP32 présentes dans l'IDE, il y en a des nouvelles tous les jours !!

Ceux qui font l'extension ESP32 pour Arduino ne peuvent pas suivre et écrire eux mêmes des descriptions pour chaque carte sortant sur le marché.... d'où des cartes moins bien renseignées avec un menu incomplet.

Prendre un autre type de carte. S'il y a un module WROOM32 sur la carte, prendre du basique : ESP32 DEV (ma carte testée plus haut porte abusivement le logo Wemos, elle est en fait de fabrication indéterminée je préfère prendre pour le type de carte un choix basiquedans le menu plutôt qu'un choix avec des paramètres non sélectionnables)

Ah ok ( vous avec modifier après coup)

Merci des infos

Salut tout le monde quelqu'un permet de me aidez comment stocker mon tableau de mesure avec la carte esp32 , afin de l'accéder avec mon smartphone pour récupérer les données aidez moi svp et merci d'avance j'ai besoin d'un petit code