ullix
commented
3 years ago Upon further investigations I conclude that this is a bug. For me a very serious one as it drastically reduces download speed by a factor of more than 10!
As first test I also coded a chunked response, but as expected, it showed the same failures as reported above. However, this chunk code now allowed to define the chunk size, and this made a huge difference!
I created a 300k (307200 B) file and downloaded that in various configurations. In all tests it always crashed with a wdt message when the download touched 100000; I observed only the two values of 100030 and 101459. Message was:
E (144357) task_wdt: Task watchdog got triggered. The following tasks did not reset the watchdog in time:
E (144357) task_wdt: - async_tcp (CPU 1)
E (144357) task_wdt: Tasks currently running:
E (144357) task_wdt: CPU 0: IDLE0
E (144357) task_wdt: CPU 1: loopTask
E (144357) task_wdt: Aborting.
abort() was called at PC 0x401058a4 on core 0I used various ESP32-WROOM-32E (all latest revision 3) with Flash of 4MB, 8MB, and 16MB. All gave the same result.
Using the code included below I tested for the impact of chunk size, and got a big surprise:
-
1028 Bytes chunk size : all downloads worked. Even a file of 1.2MB could be downloaded correctly!
-
1029 Bytes chunk size : only 1 Byte more and all downloads failed when the filesize was 100k or greater! Files of size 90k so far could be downloaded without problems.
I tested the file systems FFat and LittleFS. Outcome was identical.
I noticed that the download was very slow, slower by about an order of magnitude!
So I used a file of 90k, which could be downloaded under all conditions, and measured download times:
- 1028 Bytes chunk size : 3.1 sec
- 1029 Bytes chunk size : 0.4 sec
- (set by async server) : 0.2 sec (varied between 5600 and 1400 Bytes during a download)
Using 1028 Bytes makes it 15 times slower, but is the only option for big files, when you need speed most!
And one last surprise: removing the print options in chunk-code made it even slower, not faster!
Here is the relevant code:
// File system
// either:
fs::F_Fat * myFS = &FFat;
// or:
fs::LITTLEFSFS * myFS = &LITTLEFS;
// ESPAsyncWebServer setup
server.on("/log.cam", HTTP_GET, [] (AsyncWebServerRequest *request) { staticDataType = CAM;
request->sendChunked(text_plain, onStaticDownLoad);});
// chunk code
size_t onStaticDownLoad(uint8_t *buffer, size_t maxLen, size_t index){
static char * filename; // file to be sent as chunks
static File chunkfile; // file handle of filename
static size_t dnlLen = 1028; // limit to buffer size
uint32_t countbytes = 0; // bytes to be returned
if (index == 0) {
if (staticDataType == CAM) filename = LOGCAM;
else filename = LOGCPS;
samm->printf("onStaticDownLoad: START filename: %s index: %6i maxLen: %5i\n", filename, index, maxLen);
chunkfile = myFS->open(filename);
}
chunkfile.seek(index);
countbytes = chunkfile.read(buffer, min(dnlLen, maxLen));
if (countbytes == 0) {
chunkfile.close();
}
samm->printf("onStaticDownLoad: f: %s index: %6u maxLen: %5u countb: %5u \n"
, filename
, index
, maxLen
, countbytes
);
return countbytes;
}
BlueAndi
zekageri
Pablo2048
I am still seeing these annoying crashes, though progress has been made. I am showing an encouraging update, and the code at the end.
gnalbandian
Out of my first 6 downloads 3 failed with "network error", which always goes hand-in-hand with a WDT triggering a crash. The Serial Monitor shows the typical result:
lbernstone
I have static, binary log files which I download via WiFi. Works well most of the time, but then there are perpetual crashes. It seems the success depends on the size of the files. Up to 64k mostly ok, 64k ... 128k ok for half the trials, beyond that size almost never ok.
I am using the LittleFS file system. The files are build up of 32 bytes binary records, and may eventually grow >2MB. I use this command for downloading as static file:
I also tried this. Works just as well, but no improvement:
The download is triggered from a website, either as a straight link to download the binary file, or as Javascript code inside a function:
Your ReadMe seems to suggest that chunked responses are NOT needed for static files? So, I did not use that here. Am I forgetting any settings, or do I also need to use chunked response when the static file is beyond a certain size? Which size?