ESP32 - téléchargement d'un fichier bridé par la carte SD

Bonjour,

Avec un ESP32 je cherche a télécharger un fichier depuis une URL et le stocker sur une carte SD. Etant totalement novice dans les requettes http, je cherché du code sur le net. J'ai fini par trouver quelque chose qui fait l'affaire moyennant quelques modifications :

  Serial.println("Fonction download podcast");
  //http setup
  HTTPClient http;
  http.setFollowRedirects(HTTPC_FORCE_FOLLOW_REDIRECTS);
  SD.remove("/newfile.mp3");
  int countFlush=0;
  int temp=millis();

  url="https://sphinx.acast.com/p/open/s/68db9a016d92c33f9c2eff83/e/69822e6c8ac0563acb48cbaa/media.mp3";// "https://proxycast.radiofrance.fr/0760f712-f39e-4aba-a3f2-891453f91f66/5e238698-941a-4afc-8883-dbecfda89821/abd24920-ba92-4670-9c39-daa74c2a00bb/10212-08.05.2026-ITEMA_24504397-2026F10732S0128-NET_MFI_A45F96BC-8696-40FD-8164-EE59879C3448-27-dd056e7b40b2e06b32cf96307a35b48a.m4a";
  http.begin(url);
  int httpcode=http.GET();
  Serial.print("code :"); Serial.println(httpcode);
  int file_size = http.getSize();
  Serial.print("size : ");Serial.println(file_size );

 
   File file = SD.open("/newfile.mp3",FILE_WRITE);
          // get length of document (is -1 when Server sends no Content-Length header)
                int len = http.getSize();
                Serial.print("length"); Serial.println(len);
                // create buffer for read
                uint8_t buff[1024] = { 0 };

                // get tcp stream
                WiFiClient * stream = http.getStreamPtr();

                // read all data from server
                while(http.connected() && (len > 0 || len == -1)) 
                {
                    // get available data size
                    size_t size = stream->available();

                    if(size) {
                        // read up to 1024byte
                        int c = stream->readBytes(buff, ((size > sizeof(buff)) ? sizeof(buff) : size));

                        // write it to Serial
                        file.write(buff,c);
                        file.flush();
                        //if(countFlush>=1){file.flush();countFlush=0;Serial.println("Flush");}else{countFlush++;}
                        full=full+c;
                        Serial.println(full/1000000,1);
                        if(len > 0) {
                            len -= c;
                        }
                    }
                    delay(1);
                }
                
                Serial.println();
               Serial.print("[HTTP] connection closed or file end.\n");
                file.close();
                SD.end();
                    int temp2=millis();
  int diff((temp2-temp_)/1000);
  Serial.println("diff : ");
  Serial.println(diff);
            

initialement le code avait un buffer de 128 bytes, et n'avait pas de file.flush();

sans file.flush(), la boucle tourne jusqu'a télécharger tout le fichier (16.3Mo) mais la taille du fichier est variable (quelques centaines de Ko)

en incluant file.flush() dans la boucle, ça fonctionne mais ça met 678 sec (24 Ko/s)

en augmentant le buffer a 1024, je descends a 162secondes (100Ko/s)

l'utilisation de la foncion flush semble ralentir l'éxécution de la boucle, alors en rajoutant une condition pour l'éxécuter une fois sur deux, je descends a 120secondes (135Ko/s)

dès que j'essaye de passer a un flush tous les 3 step ça fonctione un moment et ça foire, le fichier a une taille variable que plusieurs Mo

Est ce qu'il y a d'autres moyens d'augmenter la vitesse décriture avant d'essayer de passer sur une autre lib (SDMMC ou SDFAT) ? J'ai pas mal galéré a gérer la cohéxistance de la carte SD avec l'écran en SPI, si je peux m'éviter d'autres galères ...

merci !

la carte SD étant en SPI, j'ai essayé de jouer avec la fréquence, et ça permet de gagner un peu, en démarrant la carte à 24Mhz j'arrive a passer le buff a 2048 et le fichier se télécharge en 65sec environ, ce qui fait 250ko/s ...

SDMMC est matériellement plus rapide avec un bus 4 fils de données.

L'ESP32 a 3 controlleurs SPI donc rien net'oblige à partager le bus avec un afficheur.