Possibility to use 120MHz flash setting for ESP32S3

dawinq · October 10, 2023, 6:53pm

Hello there,
I’m trying to figure out a way to set the 120MHz flash speed setting in the .ini file for esp32s3, namely speaking the “board_build.f_flash”.
To be exact the board is ESP32-S3-WROOM-2 M0N32R8V.

Browsing the files I’ve found:

esp32s3.menu.FlashMode.qio=QIO 80MHz
esp32s3.menu.FlashMode.qio.build.flash_mode=dio
esp32s3.menu.FlashMode.qio.build.boot=qio
esp32s3.menu.FlashMode.qio.build.boot_freq=80m
esp32s3.menu.FlashMode.qio.build.flash_freq=80m
esp32s3.menu.FlashMode.qio120=QIO 120MHz
esp32s3.menu.FlashMode.qio120.build.flash_mode=dio
esp32s3.menu.FlashMode.qio120.build.boot=qio
esp32s3.menu.FlashMode.qio120.build.boot_freq=120m
esp32s3.menu.FlashMode.qio120.build.flash_freq=80m
esp32s3.menu.FlashMode.dio=DIO 80MHz
esp32s3.menu.FlashMode.dio.build.flash_mode=dio
esp32s3.menu.FlashMode.dio.build.boot=dio
esp32s3.menu.FlashMode.dio.build.boot_freq=80m
esp32s3.menu.FlashMode.dio.build.flash_freq=80m
esp32s3.menu.FlashMode.opi=OPI 80MHz
esp32s3.menu.FlashMode.opi.build.flash_mode=dout
esp32s3.menu.FlashMode.opi.build.boot=opi
esp32s3.menu.FlashMode.opi.build.boot_freq=80m
esp32s3.menu.FlashMode.opi.build.flash_freq=80m

in .platformio/packages/framework-arduinoespressif32

I’ve based my understanding on DT’s and SPI Flash and External SPI RAM Configuration - ESP32-S3 - — ESP-IDF Programming Guide latest documentation

I think this can be done in esp-idf. I tried to edit the esptool.py, I was able to accept the bootloader but the settings are rejected:

Is there anyone out there that has done this, is it even possible?

cziter15 · February 23, 2024, 7:55am

It looks like you can use board_build.arduino.custom_bootloader property to swap bootloader in your platformio.ini file. The path is evaluated from variants/board directory, which means you must go up two levels in the directory structure and then apply tools\sdk\platform\bin.

In your platformio.ini file put this line:

board_build.arduino.custom_bootloader = ..\..\tools\sdk\esp32s3\bin\bootloader_qio_120m.elf

Be aware as this seems to be experimental feature and remember this setting may override your flash/psram SPI settings.

PS: Arduino flash speed detection is done via switch-based function which relies on chip ID rather than real hardware settings.

dawinq · March 3, 2024, 12:54pm

Hello @cziter15 its been some time and the changes I made to the esptool.py got lost somewhere. Could you provide a full .ini file that uses the custom boot loader with the 120Mhz flash speed setting ?

I would be very grate full !
Thank you

cziter15 · March 3, 2024, 1:31pm

I don’t have any project using 120m atm, but here’s the line:

board_build.arduino.custom_bootloader = …..\tools\sdk\esp32s3\bin\bootloader_qio_120m.elf

Using this you can swap bootloader to the 120m variant. Place this in your environment section of platformio.ini file.

I’m not sure how to test it as standard Arduino function uses chip id to get it’s frequency (not real value). Maybe some kind of bandwidth testing should be implemented to verify speed improvement. Maybe there’s a native esp function to read it. I didn’t have time to get deeper insight. Moreover it seems like experimental and there’s some info that temperature increase may affect flash operability when using 120Mhz.

dawinq · March 3, 2024, 2:58pm

OK so i tested it with this setting:

[env:latest_stable]
platform = https://github.com/platformio/platform-espressif32.git
framework = arduino
board = esp32-s3-devkitc-1
board_build.mcu = esp32s3
;board_build.arduino.memory_type =qio_qspi; qio120 ;opi_opi ;"qio_qspi"
board_build.f_flash = 120000000L
;board_build.flash_mode = qio
board_build.partitions = lib/file_system/custom32MB_partition.csv
board_build.arduino.custom_bootloader = ..\..\tools\sdk\esp32s3\bin\bootloader_qio_120m.elf
board_upload.flash_size = 32MB
build_type = release

And while building:

Building in release mode
Compiling .pio/build/latest_stable/src/main.cpp.o
Building .pio/build/latest_stable/bootloader.bin
Generating partitions .pio/build/latest_stable/partitions.bin
usage: esptool elf2image [-h] [--output OUTPUT] [--version {1,2,3}]
                         [--min-rev-full {0, ... 65535}]
                         [--max-rev-full {0, ... 65535}] [--secure-pad]
                         [--secure-pad-v2]
                         [--elf-sha256-offset ELF_SHA256_OFFSET]
                         [--dont-append-digest] [--use_segments]
                         [--flash-mmu-page-size {64KB,32KB,16KB,8KB}]
                         [--pad-to-size PAD_TO_SIZE]
                         [--flash_freq {80m,60m,48m,40m,30m,26m,24m,20m,16m,15m,12m}]
                         [--flash_mode {qio,qout,dio,dout}]
                         [--flash_size {256KB,512KB,1MB,2MB,2MB-c1,4MB,4MB-c1,8MB,16MB,32MB,64MB,128MB}]
                         [--spi-connection SPI_CONNECTION]
                         input
esptool elf2image: error: argument --flash_freq/-ff: invalid choice: '120m' (choose from '80m', '60m', '48m', '40m', '30m', '26m', '24m', '20m', '16m', '15m', '12m')
Compiling .pio/build/latest_stable/lib005/FS/FS.cpp.o
*** [.pio/build/latest_stable/bootloader.bin] Error 2

cziter15 · March 3, 2024, 4:47pm

It looks like f_flash frequency is only for flashing process.

In platform.txt you can find this:
build.img_freq={build.flash_freq}
build.boot=qio
build.boot_freq={build.flash_freq}

Try to play with boot_freq or img_freq.

github.com

espressif/arduino-esp32/blob/aed7b4fa598765db61678d3253401b8cd64a8ec8/platform.txt#L92


      
          build.extra_flags.esp32h2=-DARDUINO_USB_MODE=1 -DARDUINO_USB_CDC_ON_BOOT={build.cdc_on_boot}
          
          # This can be overriden in boards.txt
          build.zigbee_mode=
          build.zigbee_libs=
          build.flash_size=4MB
          build.flash_mode=dio
          build.flash_freq=80m
          build.img_freq={build.flash_freq}
          build.boot=qio
          build.boot_freq={build.flash_freq}
          build.bootloader_addr=0x1000
          build.custom_bootloader=bootloader
          build.custom_partitions=partitions
          build.code_debug=0
          build.defines=
          build.loop_core=
          build.event_core=
          build.extra_flags=-DARDUINO_HOST_OS="{runtime.os}" -DARDUINO_FQBN="{build.fqbn}" -DESP32 -DCORE_DEBUG_LEVEL={build.code_debug} {build.loop_core} {build.event_core} {build.defines} {build.extra_flags.{build.mcu}} {build.zigbee_mode}
          build.extra_libs=
          build.memory_type={build.boot}_qspi

dawinq · March 3, 2024, 6:40pm

I’ve been trying to make this work with your suggestions but still no luck.

So my .ini looks like this:

[env:esp32-s3-devkitc-1]
platform = espressif32
framework = arduino
board = esp32-s3-devkitc-1
board_build.mcu = esp32s3
board_build.arduino.memory_type = opi_opi ;"qio_qspi"
board_build.f_flash = 80000000L
board_build.flash_mode = qio
board_build.partitions = lib/file_system/custom32MB_partition.csv
board_build.arduino.custom_bootloader = ..\..\tools\sdk\esp32s3\bin\bootloader_qio_120m.elf

build.img_freq=80000000L
build.boot=qio
build.boot_freq=80000000L

board_upload.flash_size = 32MB
build_type = release
lib_ldf_mode = chain+
build_src_filter = +<../src/>
    -<../lib/**/main.cpp>
    +<../lib/>
    -<../**/examples/>
    -<.git/> 
    -<.svn/>

And when i try to build I get warnings:

Warning! Ignore unknown configuration option `build.img_freq` in section [env:esp32-s3-devkitc-1]
Warning! Ignore unknown configuration option `build.boot` in section [env:esp32-s3-devkitc-1]
Warning! Ignore unknown configuration option `build.boot_freq` in section [env:esp32-s3-devkitc-1]

The test code works same regardless these settings. I tried setting both build.img_freq and build.boot_freq to 120000000L and 40000000L etc. I’m testing the Flash read / write speed.

cziter15 · March 3, 2024, 7:11pm

Try
board_build.boot_freq=

dawinq · March 3, 2024, 8:33pm

Ok, I’ve modified my .ini file to look like this:

[env:esp32-s3-devkitc-1]
platform = espressif32
framework = arduino
board = esp32-s3-devkitc-1
board_build.mcu = esp32s3
board_build.arduino.memory_type = opi_opi ;"qio_qspi"
board_build.f_flash = 80000000L
board_build.flash_mode = qio
board_build.partitions = lib/file_system/custom32MB_partition.csv
board_build.arduino.custom_bootloader = ..\..\tools\sdk\esp32s3\bin\bootloader_qio_120m.elf

;build.img_freq=80000000L
;build.boot=qio
;build.boot_freq=80000000L
board_build.boot_freq=140000000L

board_upload.flash_size = 32MB
build_type = release
lib_ldf_mode = chain+
build_src_filter = +<../src/>
    -<../lib/**/main.cpp>
    +<../lib/>
    -<../**/examples/>
    -<.git/> 
    -<.svn/>

The resaults I got i guess are within the error of measurement. It seems that this setting has no real effect on the read / write flash speed:

board_build.boot_freq=120000000L

21:08:04.050 > Write Speed: 2841.84 KB/s
21:08:22.214 > Read Speed: 5637.52 KB/s

board_build.boot_freq=80000000L

21:10:10.732 > Write Speed: 2863.45 KB/s
21:10:29.434 > Read Speed: 5475.35 KB/s

board_build.boot_freq=140000000L

21:14:47.698 > Write Speed: 2843.58 KB/s
21:15:04.881 > Read Speed: 5959.38 KB/s

board_build.boot_freq=1200000000L

21:16:43.213 > Write Speed: 2943.80 KB/s
21:17:01.370 > Read Speed: 5639.70 KB/s

board_build.boot_freq=12000000000L

21:19:48.713 > Write Speed: 2832.25 KB/s
21:20:06.475 > Read Speed: 5764.79 KB/s

I’ve commented out this settings both board_build.arduino.custom_bootloader and board_build.boot_freq out of the .ini file. And I received:

21:22:12.987 > Write Speed: 2884.18 KB/s
21:22:31.450 > Read Speed: 5546.23 KB/s

Like I mentioned earlier i guess these results prove that the setting isn’t quite there.

The code that i’m using is:

main.cpp:

#include <LittleFS.h>

const int fileSize = 1024; // 1 KB file size
const int numFiles = 100;  // Number of files to write
const char* filenamePrefix = "/file";



void writeFile(int index) {
  String filename = String(filenamePrefix) + String(index);
  File file = LittleFS.open(filename, "w");
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  for (int i = 0; i < fileSize; i++) {
    file.write(random(256)); // Write random data
  }
  file.close();
}

void readFile(int index) {
  String filename = String(filenamePrefix) + String(index);
  File file = LittleFS.open(filename, "r");
  if (!file) {
    Serial.println("Failed to open file for reading");
    return;
  }
  while (file.available()) {
    file.read(); // Reading but not storing data
  }
  file.close();
}



void setup() {
  Serial.begin(115200);

  if (!LittleFS.begin()) {
    Serial.println("LittleFS initialization failed!");
    return;
  }

  // Write files
  unsigned long startTime = millis();
  for (int i = 0; i < numFiles; i++) {
    writeFile(i);
  }
  unsigned long endTime = millis();
  
  unsigned long writeTime = endTime - startTime;
  float writeSpeed = (fileSize * numFiles) / ((float)writeTime / 1000); // in KB/s
  Serial.print("Write Speed: ");
  Serial.print(writeSpeed);
  Serial.println(" KB/s");

  // Read files
  startTime = millis();
  for (int i = 0; i < numFiles; i++) {
    readFile(i);
  }
  endTime = millis();
  
  unsigned long readTime = endTime - startTime;
  float readSpeed = (fileSize * numFiles) / ((float)readTime / 1000); // in KB/s
  Serial.print("Read Speed: ");
  Serial.print(readSpeed);
  Serial.println(" KB/s");
}

void loop() {
  // Nothing in loop for this example
}

dawinq · March 3, 2024, 9:14pm

So i thought that maybe the size of the file tested for read/write operations is too small so i changed:

const int fileSize = 3072000;
const int numFiles = 5;

The partitioning that i gives me 21.5 MB to play with.

Results for:

“Default”:

[env:esp32-s3-devkitc-1]
platform = espressif32
framework = arduino
board = esp32-s3-devkitc-1
board_build.mcu = esp32s3
board_build.arduino.memory_type = opi_opi ;"qio_qspi"
board_build.f_flash = 80000000L
board_build.flash_mode = qio
board_build.partitions = lib/file_system/custom32MB_partition.csv
; board_build.arduino.custom_bootloader = ..\..\tools\sdk\esp32s3\bin\bootloader_qio_120m.elf

; build.img_freq=80000000L
; build.boot=qio
;build.boot_freq=80000000L
; board_build.boot_freq=80000000L

board_upload.flash_size = 32MB
build_type = release
lib_ldf_mode = chain+
build_src_filter = +<../src/>
    -<../lib/**/main.cpp>
    +<../lib/>
    -<../**/examples/>
    -<.git/> 
    -<.svn/>

Results:

21:52:24.293 > Write Speed: 32761.78 KB/s
21:56:29.803 > Read Speed: 62563.90 KB/s

“bootloader_qio_120m.elf”:

[env:esp32-s3-devkitc-1]
platform = espressif32
framework = arduino
board = esp32-s3-devkitc-1
board_build.mcu = esp32s3
board_build.arduino.memory_type = opi_opi ;"qio_qspi"
board_build.f_flash = 80000000L
board_build.flash_mode = qio
board_build.partitions = lib/file_system/custom32MB_partition.csv
board_build.arduino.custom_bootloader = ..\..\tools\sdk\esp32s3\bin\bootloader_qio_120m.elf

; build.img_freq=80000000L
; build.boot=qio
;build.boot_freq=80000000L
board_build.boot_freq=120000000L

board_upload.flash_size = 32MB
build_type = release
lib_ldf_mode = chain+
build_src_filter = +<../src/>
    -<../lib/**/main.cpp>
    +<../lib/>
    -<../**/examples/>
    -<.git/> 
    -<.svn/>

Results:

22:07:12.021 > Write Speed: 32508.76 KB/s
22:11:17.460 > Read Speed: 62581.48 KB/s

As you can see the results are pretty much the same.

jason2866 · March 6, 2024, 2:45pm

Only a bootloader which does support the switching to 120Mhz will not change anything.
The corresponding relevant precompiled Arduino libs needs to have the relevant code.
So it needs a custom compiled Arduino framework for this.
Edit: Mode QIO 120Mhz is included in Arduino framework build.
Looking through Platformio Platform espressif32 code, there is no option to set the 120Mhz.

dawinq · March 6, 2024, 8:56pm

Hello @jason2866 do you know how can i precompile arduino libs to get the 120Mhz flash functionality or somehow copy it over to platforio?

Is it even possible for a person like me to do so or do I have to have something?

jason2866 · March 7, 2024, 10:48am

I am currently doing this. The Platformio Framework should be done. But the 120Mhz support is not correct implemented in ArduinoIDE. So i currently can not implement the needed changes in my Platformio fork. I simply just don’t know what needs to be changed.

github.com/espressif/arduino-esp32

S3 QIO 120Mhz Flash speed not possible

opened 05:20PM - 06 Mar 24 UTC

Jason2866

IDE: Arduino IDE

### Board every s3 board with QIO Flash capable 120Mhz ### Device Descript…ion Setting Flash speed 120Mhz for S3 not possible ### Hardware Configuration none ### Version latest master (checkout manually) ### IDE Name ArduinoIDE ### Operating System MacOS Ventura ### Flash frequency 120Mhz ### PSRAM enabled yes ### Upload speed 115200 ### Description Using the setting 120Mhz flash speed from `boards.txt` `esp32s3.menu.FlashMode.qio120.build.boot_freq=120m` This setting is nowhere used in `platform.txt` when the firmware is merged https://github.com/espressif/arduino-esp32/blob/4123e20a2ca28db70ffeb4db3d5157c8e5b1a058/platform.txt#L159 nor when flashed with esptool https://github.com/espressif/arduino-esp32/blob/4123e20a2ca28db70ffeb4db3d5157c8e5b1a058/platform.txt#L278 and https://github.com/espressif/arduino-esp32/blob/4123e20a2ca28db70ffeb4db3d5157c8e5b1a058/platform.txt#L286 ### Sketch ```cpp none ``` ### Debug Message ```plain none ``` ### Other Steps to Reproduce _No response_ ### I have checked existing issues, online documentation and the Troubleshooting Guide - [X] I confirm I have checked existing issues, online documentation and Troubleshooting guide.

The compiled framework which has all needed compiled in is here
https://github.com/Jason2866/esp32-arduino-lib-builder/releases/download/2156/framework-arduinoespressif32-release_v5.1-1a0b6e0.zip

jason2866 · March 20, 2024, 4:47pm

120Mhz builds should work now. My PRs for the missing code in Arduino and Platformio have been merged. Built a platform. You can try with platform = https://github.com/Jason2866/platform-espressif32.git
An example boards json for 120Mhz is in folder boards.
Blink example has an entry to build with 120Mhz

github.com

Jason2866/platform-espressif32/blob/Arduino/IDF5/examples/arduino-blink/platformio.ini

; PlatformIO Project Configuration File
;
;   Build options: build flags, source filter, extra scripting
;   Upload options: custom port, speed and extra flags
;   Library options: dependencies, extra library storages
;
; Please visit documentation for the other options and examples
; http://docs.platformio.org/page/projectconf.html

[env:esp-wrover-kit]
platform = espressif32
framework = arduino
board = esp-wrover-kit
monitor_speed = 115200
build_flags =
	-DLED_BUILTIN=2

[env:esp32-s3-120]
platform = espressif32
framework = arduino

This file has been truncated. show original

dawinq · March 20, 2024, 6:50pm

Thank you @jason2866 I’ll try this out this weekend and do some read/write flash speed tests with these setting and compare!