Ecriture carte SD avec ESP32

Bonjour, je rencontre un problème pour écrire sur une carte SD avec une carte ESP32.
Je suis parti du code que j'exécutais avec succès sur un Arduino UNO, mais mon programme plante sévère sur ESP32 et le seul équipement connecté que je n'avais pas testé séparément est le module SD (en "espérant" que ce soit ça le problème, sinon ça va être la galère, nouveau sujet à prévoir je crains..).

J'ai fait des recherches pour trouver un code proche de celui adapté à Arduino, j'ai trouvé celui qui suit, mais il n'ajoute pas le texte dans le fichier à la suite de ce qu'il y a déjà :

 #include <SD.h>

#define PIN_SPI_CS 5 // The ESP32 pin GPIO5

// Problèmes :
//Remplace et n'ajoute pas le texte à la suite
// Affiche le texte au deuxième lancement de la carte

File myFile;

void setup() {
  Serial.begin(115200);  // modifier avec 115200

  if (!SD.begin(PIN_SPI_CS)) {
    while (1) {
      Serial.println(F("SD CARD FAILED, OR NOT PRESENT!"));
      delay(1000);
    }
  }

  Serial.println(F("SD CARD INITIALIZED."));

  // open file for writing
  myFile = SD.open("/esp32.txt", FILE_WRITE);

  if (myFile) {
    myFile.println("Created by esp32io.com"); // write a line to esp32.txt
    myFile.println("Learn ESP32 and SD Card test3"); // write another line to esp32.txt
    myFile.close();
  } else {
    Serial.print(F("SD Card: Issue encountered while attempting to open the file esp32.txt"));
  }

  // open file for reading
  myFile = SD.open("/esp32.txt", FILE_READ);
  if (myFile) {
    while (myFile.available()) {
      char ch = myFile.read(); // read characters one by one from Micro SD Card
      Serial.print(ch); // print the character to Serial Monitor
    }
    myFile.close();
  } else {
    Serial.print(F("SD Card: Issue encountered while attempting to open the file esp32.txt"));
  }
}

void loop() {
}

J'ai donc poussé les recherches et trouvé un code sensé marcher pour l'ESP32 (fonction append pour ajouter du texte à la suite), et là, eh bien il ne se passe rien du tout... :tired_face: Compilation OK, et puis rien, le fichier .txt n'est pas créé, si je le crée il ne se remplit pas, pas de message d'erreur, même si la carte n'est pas présente... Bref c'est pire. Le code en question :


#include "FS.h"
#include "SD.h"
#include "SPI.h"

// Résultat : il ne se passe rien, pas d'écriture, pas de message moniteur, même si la carte n'est pas présente, pas de message d'erreur.

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 setup() {

  appendFile(SD, "hello.txt", "World!\n");		//écriture dans le fichier. Le \n fait un retour à la ligne
  Serial.println("OK");
}

void loop() {
}

Vu que je n'ai besoin que d'écrire sur ma carte SD des valeurs à la suite et pas de les relire ou renommer, etc, est-ce que quelqu'un aurait un moyen simple de faire que le texte s'ajoute à partir du premier code présenté, ce qui est naturel sous Arduino ?

Code d'origine sous Arduino :

myFile = SD.open("stat.csv", FILE_WRITE); // ouvre le fichier csv en écriture, le crée si n'existe pas

    if (myFile) {           // écrit sur la carte
    myFile.print(deltaT);myFile.print(";");myFile.println(distriJour); 
    myFile.close();           // ferme le fichier
    }   // fin écriture carte

Merci de vos lumières :bulb:

Ca peut venir du fait qu'il existe deux bibliothèques SD, une pour Arduino

et une pour ESP32 :

Tu devrais tester les exemples de celle de l'ESP32 pour voir si ça fonctionne.

Sinon, ça peut venir de la manière de connecter ton module SD. L'exemple en question indique ce schéma de câblage :

/*
 * pin 1 - not used          |  Micro SD card     |
 * pin 2 - CS (SS)           |                   /
 * pin 3 - DI (MOSI)         |                  |__
 * pin 4 - VDD (3.3V)        |                    |
 * pin 5 - SCK (SCLK)        | 8 7 6 5 4 3 2 1   /
 * pin 6 - VSS (GND)         | ▄ ▄ ▄ ▄ ▄ ▄ ▄ ▄  /
 * pin 7 - DO (MISO)         | ▀ ▀ █ ▀ █ ▀ ▀ ▀ |
 * pin 8 - not used          |_________________|
 *                             ║ ║ ║ ║ ║ ║ ║ ║
 *                     ╔═══════╝ ║ ║ ║ ║ ║ ║ ╚═════════╗
 *                     ║         ║ ║ ║ ║ ║ ╚══════╗    ║
 *                     ║   ╔═════╝ ║ ║ ║ ╚═════╗  ║    ║
 * Connections for     ║   ║   ╔═══╩═║═║═══╗   ║  ║    ║
 * full-sized          ║   ║   ║   ╔═╝ ║   ║   ║  ║    ║
 * SD card             ║   ║   ║   ║   ║   ║   ║  ║    ║
 * Pin name         |  -  DO  VSS SCK VDD VSS DI CS    -  |
 * SD pin number    |  8   7   6   5   4   3   2   1   9 /
 *                  |                                  █/
 *                  |__▍___▊___█___█___█___█___█___█___/
 *
 * Note:  The SPI pins can be manually configured by using `SPI.begin(sck, miso, mosi, cs).`
 *        Alternatively, you can change the CS pin and use the other default settings by using `SD.begin(cs)`.
 *
 * +--------------+---------+-------+----------+----------+----------+----------+----------+
 * | SPI Pin Name | ESP8266 | ESP32 | ESP32‑S2 | ESP32‑S3 | ESP32‑C3 | ESP32‑C6 | ESP32‑H2 |
 * +==============+=========+=======+==========+==========+==========+==========+==========+
 * | CS (SS)      | GPIO15  | GPIO5 | GPIO34   | GPIO10   | GPIO7    | GPIO18   | GPIO0    |
 * +--------------+---------+-------+----------+----------+----------+----------+----------+
 * | DI (MOSI)    | GPIO13  | GPIO23| GPIO35   | GPIO11   | GPIO6    | GPIO19   | GPIO25   |
 * +--------------+---------+-------+----------+----------+----------+----------+----------+
 * | DO (MISO)    | GPIO12  | GPIO19| GPIO37   | GPIO13   | GPIO5    | GPIO20   | GPIO11   |
 * +--------------+---------+-------+----------+----------+----------+----------+----------+
 * | SCK (SCLK)   | GPIO14  | GPIO18| GPIO36   | GPIO12   | GPIO4    | GPIO21   | GPIO10   |
 * +--------------+---------+-------+----------+----------+----------+----------+----------+
 *
 * For more info see file README.md in this library or on URL:
 * https://github.com/espressif/arduino-esp32/tree/master/libraries/SD
 */

J'ai testé l'exemple complet SD_Test inclus dans l'IDE, ça a marché une fois avec le module SPI Reader pour la carte SD.
J'ai supprimé les parties du programme qui ne m'intéressaient pas, et là il ne se passe rien. J'ai relancé le programme SD_Test complet, et il ne m'affiche que la fin du message attendu :

1048576 bytes read for 2369 ms
1048576 bytes written for 2499 ms
Total space: 15185MB
Used space: 1MB

J'ai enlevé le module SPI Reader pour câbler directement un support MicroSD avec les fils soudés en me disant que le module SPI gênait peut-être le bon fonctionnement, essai de SD_Test, pareil, que le message de fin ci-dessus.
J'avais bien une librairie Arduino SD installée. Je l'ai supprimée en me disant qu'elle était peut-être incluse dans le package ESP32 d'Espressif. Je n'ai pas de message de librairie manquante à la compilation, en allant fouiller dans les dossiers, elle existe bien sous esp32... J'ai renommé le dossier SD dans le répertoire Arduino car elle existait encore malgré sa suppression (?). Fermé Arduino, réouvert SD_Test, pas mieux.
J'ai tenté de réécrire mon propre code avec les briques que j'avais et maintenant j'ai le message à la compilation qui me dit que j'ai deux librairies SD, dont une non utilisée (Arduino). Et ça en reste là.
C'est désespérant.

L'ESP32 est un processeur rapide, et la console série de l'IDE peut être lente.
Tu peux essayer de mettre un delay(2000); après le Serial.begin pour voir si tu verras l'ensemble des messages.

A mon avis, si tu vois ceux de la fin, c'est que tout s'est bien déroulé...

Merci @lesept !
Le petit délai après le Serial.begin() a bien éclairci les choses.
J'ai supprimé la bibliothèque SD de l'Arduino, celle pour l'ESP32 est incluse dans le package d'Espressif.
Du coup, j'ai pu délimiter un code minimal à partir du modèle SD_Test inclus à l'IDE. Il faut garder le code suivant (avec quelques commentaires d'info) :

#include "SD.h"
//Les FS.h et SPI.h semblent intégrées à SD.h

void{} ... // ce que l'on veut parmi le choix proposé

void setup() {
  Serial.begin(115200);
  while (!Serial) {
    delay(10);
  }
delay(2000);    // ajouté pour temps d'activation Moniteur
Serial.println("C'est parti");    // ajout


#ifdef REASSIGN_PINS
  SPI.begin(sck, miso, mosi, cs);
  if (!SD.begin(cs)) {
#else
  if (!SD.begin()) {
#endif
    Serial.println("Card Mount Failed");
    return;
  }
  
  uint8_t cardType = SD.cardType();
// pour les commandes qui suivent, ce que l'on veut en cohérence avec les void{} conservés au début 
/*
  listDir(SD, "/", 0);
  createDir(SD, "/mydir");
  listDir(SD, "/", 0);
  removeDir(SD, "/mydir");
  listDir(SD, "/", 2);
  */
  //writeFile(SD, "/hello.txt", "Test ");
  appendFile(SD, "/stat.csv", "Test");  // le fichier sera créé s'il n'existe pas
  appendFile(SD, "/stat.csv", " 04\n");
  readFile(SD, "/stat.csv");
  Serial.println("\n C'est fait");
/*
  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() {}