mirror of
https://github.com/espressif/esp-idf.git
synced 2024-10-05 20:47:46 -04:00
e7b88a52d1
New example which can benchmark IO speed of SPI flash partition (raw, FATFS, SPIFFS) and SD card (raw, FATFS) connected via SPI and SDMMC.
264 lines
15 KiB
Markdown
264 lines
15 KiB
Markdown
| Supported Targets | ESP32 | ESP32-C2 | ESP32-C3 | ESP32-C6 | ESP32-H2 | ESP32-S2 | ESP32-S3 |
|
|
| ----------------- | ----- | -------- | -------- | -------- | -------- | -------- | -------- |
|
|
|
|
# Storage performance benchmark example
|
|
|
|
(See the README.md file in the upper level 'examples' directory for more information about examples.)
|
|
|
|
**WARNING: This example will format both your SPI flash "storage" partition and SD card (if used)!**
|
|
|
|
This example demonstrates a benchmark of a storage media such as SPI flash memory and SD card.
|
|
Only ESP32 and ESP32-S3 targets can use SDMMC mode when connecting to a SD card.
|
|
|
|
### Pin assignments for SD card connection
|
|
|
|
The GPIO pin numbers used to connect an SD card can be customized using the following:
|
|
|
|
- Run `idf.py menuconfig` in the project directory and open "Performance Benchmark Example Configuration" menu.
|
|
|
|
However, pins cannot be customized when using ESP32 target in SDMMC mode (`SDMMC_HOST_SLOT_1`).
|
|
|
|
This example doesn't utilize card detect (CD) and write protect (WP) signals from SD card slot.
|
|
|
|
The table below shows the default pin assignments.
|
|
|
|
SD card pin | SPI pin | ESP32 pin | ESP32-S2 | ESP32-S3 | ESP32-H2 | ESP32-C3 and other chips | Notes
|
|
------------|---------|---------------|----------|----------|----------|--------------------------|-------------
|
|
D0 | MISO | GPIO2 | GPIO37 | GPIO37 | GPIO0 | GPIO6 | 10k pullup
|
|
D1 | - | GPIO4 | - | GPIO38 | - | - | not used in 1-line SD mode; 10k pullup in 4-line mode
|
|
D2 | - | GPIO12 (MTDI) | - | GPIO33 | - | - | not used in 1-line SD mode; 10k pullup in 4-line mode
|
|
D3 | CS | GPIO13 (MTCK) | GPIO34 | GPIO34 | GPIO1 | GPIO1 | not used in 1-line SD mode, but card's D3 pin must have a 10k pullup
|
|
CLK | SCK | GPIO14 (MTMS) | GPIO36 | GPIO36 | GPIO4 | GPIO5 | 10k pullup
|
|
CMD | MOSI | GPIO15 (MTDO) | GPIO35 | GPIO35 | GPIO5 | GPIO4 | 10k pullup
|
|
|
|
### 4-line and 1-line SD modes
|
|
|
|
By default, this example uses 4 line SD mode, utilizing 6 pins: CLK, CMD, D0 - D3. It is possible to use 1-line mode (CLK, CMD, D0) by changing "SD/MMC bus width" in the example configuration menu (see `CONFIG_EXAMPLE_SDMMC_BUS_WIDTH_1`).
|
|
|
|
Note that even if card's D3 line is not connected to the ESP chip, it still has to be pulled up, otherwise the card will go into SPI protocol mode.
|
|
|
|
### Note about GPIO2 (ESP32 only)
|
|
|
|
GPIO2 pin is used as a bootstrapping pin, and should be low to enter UART download mode. One way to do this is to connect GPIO0 and GPIO2 using a jumper, and then the auto-reset circuit on most development boards will pull GPIO2 low along with GPIO0, when entering download mode.
|
|
|
|
- Some boards have pulldown and/or LED on GPIO2. LED is usually ok, but pulldown will interfere with D0 signals and must be removed. Check the schematic of your development board for anything connected to GPIO2.
|
|
|
|
### Note about GPIO12 (ESP32 only)
|
|
|
|
GPIO12 is used as a bootstrapping pin to select output voltage of an internal regulator which powers the flash chip (VDD_SDIO). This pin has an internal pulldown so if left unconnected it will read low at reset (selecting default 3.3V operation). When adding a pullup to this pin for SD card operation, consider the following:
|
|
|
|
- For boards which don't use the internal regulator (VDD_SDIO) to power the flash, GPIO12 can be pulled high.
|
|
- For boards which use 1.8V flash chip, GPIO12 needs to be pulled high at reset. This is fully compatible with SD card operation.
|
|
- On boards which use the internal regulator and a 3.3V flash chip, GPIO12 must be low at reset. This is incompatible with SD card operation.
|
|
* In most cases, external pullup can be omitted and an internal pullup can be enabled using a `gpio_pullup_en(GPIO_NUM_12);` call. Most SD cards work fine when an internal pullup on GPIO12 line is enabled. Note that if ESP32 experiences a power-on reset while the SD card is sending data, high level on GPIO12 can be latched into the bootstrapping register, and ESP32 will enter a boot loop until external reset with correct GPIO12 level is applied.
|
|
* Another option is to burn the flash voltage selection efuses. This will permanently select 3.3V output voltage for the internal regulator, and GPIO12 will not be used as a bootstrapping pin. Then it is safe to connect a pullup resistor to GPIO12. This option is suggested for production use.
|
|
|
|
The following command can be used to program flash voltage selection efuses **to 3.3V**:
|
|
|
|
```sh
|
|
components/esptool_py/esptool/espefuse.py set_flash_voltage 3.3V
|
|
```
|
|
|
|
This command will burn the `XPD_SDIO_TIEH`, `XPD_SDIO_FORCE`, and `XPD_SDIO_REG` efuses. With all three burned to value 1, the internal VDD_SDIO flash voltage regulator is permanently enabled at 3.3V. See the technical reference manual for more details.
|
|
|
|
`espefuse.py` has a `--do-not-confirm` option if running from an automated flashing script.
|
|
|
|
See [the document about pullup requirements](https://docs.espressif.com/projects/esp-idf/en/latest/api-reference/peripherals/sd_pullup_requirements.html) for more details about pullup support and compatibility of modules and development boards.
|
|
|
|
## How to use example
|
|
|
|
### Configure
|
|
|
|
1. Set the target chip: `idf.py set-target TARGET` (replace TARGET with ESP32 chip series name)
|
|
|
|
1. Configure the example (`idf.py menuconfig` -> "Performance Benchmark Example Configuration") wheter you want to:
|
|
|
|
- Test internal SPI flash
|
|
- Raw access
|
|
- FATFS
|
|
- SPIFFS
|
|
|
|
- Test SD card
|
|
- Select SD card interface
|
|
- SDSPI
|
|
- SDMMC
|
|
- SD card test configuration
|
|
- Raw access
|
|
- FATFS
|
|
- Set SD card frequency
|
|
- Set GPIO pins
|
|
|
|
Some configuration options may be available for ESP32 and ESP32-S3 only.
|
|
|
|
### Build and flash
|
|
|
|
Build the project and flash it to the board, then run monitor tool to view serial output:
|
|
|
|
```
|
|
idf.py -p PORT build flash monitor
|
|
```
|
|
|
|
(Replace PORT with serial port name.)
|
|
|
|
(To exit the serial monitor, type ``Ctrl-]``.)
|
|
|
|
See the Getting Started Guide for full steps to configure and use ESP-IDF to build projects.
|
|
|
|
## Example output
|
|
|
|
```
|
|
I (345) example: Start of the example
|
|
I (355) example: Internal flash test
|
|
I (355) example: Mountig WL layer...
|
|
I (415) example: WL layer mounted
|
|
I (505) example: Test with 128kiB file
|
|
Wrote 131072 bytes in 320.295ms (0.390MiB/s) to address 0
|
|
I (895) example: WL layer unmounted
|
|
I (895) example: Mounting FATFS partition...
|
|
W (895) vfs_fat_spiflash: f_mount failed (13)
|
|
I (895) vfs_fat_spiflash: Formatting FATFS partition, allocation unit size=16384
|
|
I (1105) vfs_fat_spiflash: Mounting again
|
|
I (1105) example: FATFS mounted to /spiflash
|
|
I (1205) example: Test with 128kiB file
|
|
Wrote 131072 bytes (buffer size 4096B) in 1295.988ms (0.096MiB/s)
|
|
Wrote 131072 bytes (buffer size 8192B) in 1277.569ms (0.098MiB/s)
|
|
Wrote 131072 bytes (buffer size 16384B) in 1439.405ms (0.087MiB/s)
|
|
Read 131072 bytes (buffer size 4096B) in 17.721ms (7.054MiB/s)
|
|
Read 131072 bytes (buffer size 8192B) in 16.945ms (7.377MiB/s)
|
|
Read 131072 bytes (buffer size 16384B) in 16.596ms (7.532MiB/s)
|
|
I (5705) example: Test with 256kiB file
|
|
Wrote 262144 bytes (buffer size 4096B) in 2529.380ms (0.099MiB/s)
|
|
Wrote 262144 bytes (buffer size 8192B) in 2867.352ms (0.087MiB/s)
|
|
Wrote 262144 bytes (buffer size 16384B) in 2879.113ms (0.087MiB/s)
|
|
Read 262144 bytes (buffer size 4096B) in 34.809ms (7.182MiB/s)
|
|
Read 262144 bytes (buffer size 8192B) in 33.315ms (7.504MiB/s)
|
|
Read 262144 bytes (buffer size 16384B) in 32.601ms (7.668MiB/s)
|
|
I (14535) example: Test with 512kiB file
|
|
Wrote 524288 bytes (buffer size 4096B) in 5119.009ms (0.098MiB/s)
|
|
Wrote 524288 bytes (buffer size 8192B) in 5897.010ms (0.085MiB/s)
|
|
Wrote 524288 bytes (buffer size 16384B) in 5888.743ms (0.085MiB/s)
|
|
Read 524288 bytes (buffer size 4096B) in 68.975ms (7.249MiB/s)
|
|
Read 524288 bytes (buffer size 8192B) in 66.063ms (7.569MiB/s)
|
|
Read 524288 bytes (buffer size 16384B) in 64.624ms (7.737MiB/s)
|
|
I (32295) example: FATFS partition unmounted
|
|
I (32295) example: Mounting SPIFFS partition...
|
|
W (32295) SPIFFS: mount failed, -10025. formatting...
|
|
I (38195) example: SPIFFS mounted to /spiflash
|
|
I (41555) example: Partition size: total: 896321, used: 0
|
|
I (41645) example: Test with 128kiB file
|
|
Wrote 131072 bytes (buffer size 4096B) in 819.950ms (0.152MiB/s)
|
|
Wrote 131072 bytes (buffer size 8192B) in 777.949ms (0.161MiB/s)
|
|
Wrote 131072 bytes (buffer size 16384B) in 751.682ms (0.166MiB/s)
|
|
Read 131072 bytes (buffer size 4096B) in 101.810ms (1.228MiB/s)
|
|
Read 131072 bytes (buffer size 8192B) in 99.518ms (1.256MiB/s)
|
|
Read 131072 bytes (buffer size 16384B) in 98.472ms (1.269MiB/s)
|
|
I (45335) example: Test with 256kiB file
|
|
Wrote 262144 bytes (buffer size 4096B) in 1650.525ms (0.151MiB/s)
|
|
Wrote 262144 bytes (buffer size 8192B) in 3220.004ms (0.078MiB/s)
|
|
Wrote 262144 bytes (buffer size 16384B) in 7139.803ms (0.035MiB/s)
|
|
Read 262144 bytes (buffer size 4096B) in 204.933ms (1.220MiB/s)
|
|
Read 262144 bytes (buffer size 8192B) in 200.330ms (1.248MiB/s)
|
|
Read 262144 bytes (buffer size 16384B) in 198.129ms (1.262MiB/s)
|
|
I (60365) example: Test with 512kiB file
|
|
Wrote 524288 bytes (buffer size 4096B) in 13917.135ms (0.036MiB/s)
|
|
Wrote 524288 bytes (buffer size 8192B) in 14302.046ms (0.035MiB/s)
|
|
Wrote 524288 bytes (buffer size 16384B) in 14411.794ms (0.035MiB/s)
|
|
Read 524288 bytes (buffer size 4096B) in 317.944ms (1.573MiB/s)
|
|
Read 524288 bytes (buffer size 8192B) in 308.865ms (1.619MiB/s)
|
|
Read 524288 bytes (buffer size 16384B) in 304.305ms (1.643MiB/s)
|
|
I (108835) example: SPIFFS partition unmounted
|
|
I (108835) example: SD card test
|
|
I (108845) example: Initializing SD card
|
|
I (108845) example: Using SDMMC peripheral
|
|
I (108855) example: Mounting SD card - raw access
|
|
I (108855) gpio: GPIO[36]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (108865) gpio: GPIO[35]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (108875) gpio: GPIO[37]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (108885) gpio: GPIO[38]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (108895) gpio: GPIO[33]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (108905) gpio: GPIO[34]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
|
|
I (108955) gpio: GPIO[34]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (108965) example: SD card mounted - raw access
|
|
Name: USD00
|
|
Type: SDHC/SDXC
|
|
Speed: 40.00 MHz (limit: 40.00 MHz)
|
|
Size: 15080MB
|
|
CSD: ver=2, sector_size=512, capacity=30883840 read_bl_len=9
|
|
SSR: bus_width=4
|
|
Wrote 65536 bytes in 25.321ms (2.468MiB/s) to sector 415075
|
|
Read 65536 bytes in 3.809ms (16.409MiB/s) from sector 415075
|
|
Wrote 131072 bytes in 7.415ms (16.858MiB/s) to sector 823598
|
|
Read 131072 bytes in 7.149ms (17.485MiB/s) from sector 823598
|
|
Wrote 196608 bytes in 10.829ms (17.315MiB/s) to sector 180761
|
|
Read 196608 bytes in 10.539ms (17.791MiB/s) from sector 180761
|
|
I (109045) example: SD card unmounted - raw access
|
|
I (109045) example: Mounting SD card - FATFS
|
|
I (109045) gpio: GPIO[36]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (109055) gpio: GPIO[35]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (109065) gpio: GPIO[37]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (109075) gpio: GPIO[38]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (109085) gpio: GPIO[33]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
I (109095) gpio: GPIO[34]| InputEn: 0| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0
|
|
I (109145) gpio: GPIO[34]| InputEn: 0| OutputEn: 0| OpenDrain: 0| Pullup: 1| Pulldown: 0| Intr:0
|
|
W (109155) vfs_fat_sdmmc: failed to mount card (13)
|
|
W (109155) vfs_fat_sdmmc: partitioning card
|
|
W (109155) vfs_fat_sdmmc: formatting card, allocation unit size=16384
|
|
W (110525) vfs_fat_sdmmc: mounting again
|
|
Name: USD00
|
|
Type: SDHC/SDXC
|
|
Speed: 40.00 MHz (limit: 40.00 MHz)
|
|
Size: 15080MB
|
|
CSD: ver=2, sector_size=512, capacity=30883840 read_bl_len=9
|
|
SSR: bus_width=4
|
|
I (110535) example: SD card mounted - FATFS
|
|
I (110715) example: Test with 1MiB file
|
|
Wrote 1048576 bytes (buffer size 4096B) in 200.241ms (4.994MiB/s)
|
|
Wrote 1048576 bytes (buffer size 8192B) in 129.756ms (7.707MiB/s)
|
|
Wrote 1048576 bytes (buffer size 16384B) in 91.955ms (10.875MiB/s)
|
|
Wrote 1048576 bytes (buffer size 32768B) in 91.424ms (10.938MiB/s)
|
|
Read 1048576 bytes (buffer size 4096B) in 121.086ms (8.259MiB/s)
|
|
Read 1048576 bytes (buffer size 8192B) in 87.896ms (11.377MiB/s)
|
|
Read 1048576 bytes (buffer size 16384B) in 72.525ms (13.788MiB/s)
|
|
Read 1048576 bytes (buffer size 32768B) in 74.664ms (13.393MiB/s)
|
|
I (111655) example: Test with 4MiB file
|
|
Wrote 4194304 bytes (buffer size 4096B) in 797.167ms (5.018MiB/s)
|
|
Wrote 4194304 bytes (buffer size 8192B) in 533.538ms (7.497MiB/s)
|
|
Wrote 4194304 bytes (buffer size 16384B) in 530.830ms (7.535MiB/s)
|
|
Wrote 4194304 bytes (buffer size 32768B) in 497.953ms (8.033MiB/s)
|
|
Read 4194304 bytes (buffer size 4096B) in 473.495ms (8.448MiB/s)
|
|
Read 4194304 bytes (buffer size 8192B) in 351.240ms (11.388MiB/s)
|
|
Read 4194304 bytes (buffer size 16384B) in 289.767ms (13.804MiB/s)
|
|
Read 4194304 bytes (buffer size 32768B) in 287.260ms (13.925MiB/s)
|
|
I (115495) example: Test with 16MiB file
|
|
Wrote 16777216 bytes (buffer size 4096B) in 4754.141ms (3.365MiB/s)
|
|
Wrote 16777216 bytes (buffer size 8192B) in 2290.545ms (6.985MiB/s)
|
|
Wrote 16777216 bytes (buffer size 16384B) in 2088.811ms (7.660MiB/s)
|
|
Wrote 16777216 bytes (buffer size 32768B) in 2148.595ms (7.447MiB/s)
|
|
Read 16777216 bytes (buffer size 4096B) in 1899.620ms (8.423MiB/s)
|
|
Read 16777216 bytes (buffer size 8192B) in 1419.345ms (11.273MiB/s)
|
|
Read 16777216 bytes (buffer size 16384B) in 1158.909ms (13.806MiB/s)
|
|
Read 16777216 bytes (buffer size 32768B) in 1148.426ms (13.932MiB/s)
|
|
I (132515) example: SD card unmounted - FATFS
|
|
I (132515) example: End of the example
|
|
```
|
|
|
|
## Troubleshooting
|
|
|
|
### Failure to download the example
|
|
|
|
```
|
|
Connecting........_____....._____....._____....._____....._____....._____....._____
|
|
|
|
A fatal error occurred: Failed to connect to Espressif device: Invalid head of packet (0x34)
|
|
```
|
|
|
|
Disconnect the SD card D0/MISO line from GPIO2 and try uploading again. Read "Note about GPIO2" above.
|
|
|
|
### Card fails to initialize with `sdmmc_init_sd_scr: send_scr (1) returned 0x107` error
|
|
|
|
Check connections between the card and the ESP32. For example, if you have disconnected GPIO2 to work around the flashing issue, connect it back and reset the ESP32 (using a button on the development board, or by pressing Ctrl-T Ctrl-R in IDF Monitor).
|
|
|
|
### Card fails to initialize with `sdmmc_check_scr: send_scr returned 0xffffffff` error
|
|
|
|
Connections between the card and the ESP32 are too long for the frequency used. Try using shorter connections, or try reducing the clock speed of SD interface.
|