High Performance Boards

The Metro RP2350 and Feather ESP32-S3 have shown the best SD card performance during benchmarking. These boards both produced consistent results. There are several contributing features that have come together to make this possible. By comparing these two setups in more detail, it will become clear what was done to achieve these speeds.  The RP2350 runs the SPI bus to the SD card at 25 MHz (the SPI-mode ceiling); SDIO allows a higher 40 MHz clock.

Comparison Chart

Feather ESP32-S3

Results

The following results are based on the benchmarking style Jeff Epler originally published in his excellent guide, Adafruit microSD SPI or SDIO Card Breakout Board. 

• Bulk reads and writes with the ESP32-S3 can be 2-3 times faster than the RP2350.
• Choose the ESP32-S3 for media such as bitmaps, WAV, and MP3 files.
• For frequent tiny writes, the RP2350 is the clear choice.

Card Ratings Compared

There are two different stories here. With SDIO, the card absolutely matters. The SDIO setup requires a high tier card with an A2 / U3 rating to keep up. It was able to read over 7 MB/s. 

The other story with an SPI setup is that the card won't have a significant effect on bulk throughput. With a single 1-bit SPI line, the cards are indistinguishable. A2, A1, and Class 10 cards all perform the same; throughput only drops with the unlabeled 64 MB card.

If you need to brush up on your card ratings, they're explained in detail in the Understanding microSD and SD cards: speeds, markings and more.

SDIO with an ESP32-S3

SPI with a Metro RP2350

exFAT for CircuitPython

You might be surprised to know you can use high capacity SD cards > 32 GB with CircuitPython. These large-capacity cards require exFAT (large filesystem support);  exFAT support was added to CircuitPython a while ago, but this was not well publicized.

The only boards that do not support exFAT are boards with very restricted firmware space, like the M0 (SAMD21) boards without extra flash (Trinket M0, GEMMA M0, Feather M0 Basic).  M0 Express boards like the Metro M0 do have exFAT support

This means you can use a modern SD card, 64 GB or larger, with great specs like a A2 / U3 rating. Any card greater than 32 GB will need to be formatted with exFAT on your host computer. CircuitPython does not have tools to format these natively: CircuitPython is only able to format FAT12, FAT16 and FAT32. 

 exFAT provides some wins. Its larger clusters and lack of a FAT chain likely aid performance.

Which FAT?

The storage capacity of your SD card determines the filesystem that gets installed. Yes, you can do wacky things like format a 16GB card with exFAT, but that would be out of compliance with the SD Association capacity standard. This chart is shows how capacity of the SD card dictates the filesystem that is to be used. 

Slow Startup Due to USB SD Card Presentation

Currently, by default, CircuitPython will present a mounted SD card as a USB drive to the host computer. This is a nice convenience so you do not need to manually move the SD card to an SD card reader to read or write it directly. But this convenience comes at a cost: it causes the program to start slowly, because when the host computer mounts the USB drive, the OS will read a lot of metadata (the FAT tables) from the filesystem. FAT32 in particular has a large amount of metadata. Both FAT16 and exFAT have tiny FAT tables. Using FAT16 or exFAT avoids a 10 - 20 second slow start.

The operating system also typically reads the names of all the files in the top-level directory so it can display it in a file browsing window, and that can also take a while.

You can prevent this slow startup by disabling the presentation of the SD card as a USB drive. Turn it off by adding this line to the settings.toml file on the CIRCUITPY:

CIRCUITPY_SDCARD_USB = false

1

CIRCUITPY_SDCARD_USB = false

You can also disable USB presentation entirely if you are building your own CircuitPython from scratch. Most people will not do this, but it is mentioned here for completeness. You would add this setting to mpconfigboard.mk or elsewhere in the build:

CIRCUITPY_SDCARD_USB=0

1

CIRCUITPY_SDCARD_USB=0

SD Driver to Chip Mapping

To align expectations with the reality of what can be done with CircuitPython today, here are benchmarks on a few boards in different configurations. These can be compared to the original baseline Metro RP2350 (SPI) / Feather ESP32-S3 (SDIO) boards as well as against each other for relative performance.

These tests use the following:

• PyPortal M4 - Everything is built-in (TFT, Controller, WiFi, SD card slot)
• 3.5" FeatherWing V2 + Feather RP2350 
• Feather RP2350 + Adalogger FeatherWing
• RP2040 Adalogger
• Memento Camera (ESP32-S3)

PyPortal M4

The PyPortal M4 has a nice screen, WiFi and an SD card slot. When benchmarking with a 64GB A2/U3 SD card, the results show excellent SPI based performance. It is right in line with the Metro RP2350. While the PyPortal is significantly slower than an SDIO setup for bulk read/write, it wins at logging lines per second. This board did require a 3 second pause between benchmarks to re-stabilize, something other boards did not struggle with.

3.5" FeatherWing + Feather RP2350 

There is a significant slowdown with the 3.5" FeatherWing V2 display, but it is still near 2 MB/s bulk read/write. It's not as fast as the PyPortal M4. 

Feather RP2350 + Adalogger FeatherWing

The Feather RP2350 + Adalogger FeatherWing setup will always be limited to SPI, unlike the Feather RP2040 Adalogger which has SDIO potential in the future. The logged lines per second roughly doubled versus the RP2040 Adalogger, a notable difference.

Feather RP2040 Adalogger

The Feather RP2040 Adalogger has bulk throughput just under the 2 MB/s mark. Longer term, CircuitPython may add PIO SDIO support as well as asyncio. Should these be included, it would allow this board to use 4-bit SDIO instead of SPI. The RP2040 Adalogger board could have much faster performance with software updates. 

Memento Camera

The Memento Camera is significantly slower for writes and reads than other configurations. The chip itself is capable, but the card slot is wired for SPI not SDIO, and the frequency is set to 20 MHz to stay within spec. The next speed jump is 26.7 MHz (over spec) as the display is sharing the SPI bus the SD card is on.

These are the parameters and the code used in measuring the data for this guide. Jeff Epler's Benchmarking SD card access code was used with an identical code.py and mount_sd.py varied based on board type.

Other considerations:

• All benchmarks were run on CircuitPython 10.3.0-alpha.2
• Freshly formatted exFAT SD card was used.
• Disabled host OS pass-through
  • settings.toml : CIRCUITPY_SDCARD_USB = false
• Best-of-3 runs
• The file is not closed or flushed after each line
• SD card used - 64 GB A2/U3 SD card (minimum guarantee on card ability)
  • U3 - 30 MB/s
  • A2 - Random read performance: 4000 IOPS
  • A2 - Random write performance: 2000 IOPS
• Clock is fixed on boards with build in SD card slots
• Memento shares the SPI bus with its TFT. Released the display and deselect the TFT_CS pin

Metro RP2350 mount_sd.py

Nothing needs to be done on the RP2040 and RP2350 boards with a built-in SD card slot. The card is automatically mounted.

pass   # /sd is already mounted by firmware at 25 MHz SPI

1

pass   # /sd is already mounted by firmware at 25 MHz SPI

Feather ESP32-S3 mount_sd.py

Set up the 40MHz clock and 4-bit SDIO data pins.

import board, sdioio, storage

sd = sdioio.SDCard(
    clock=board.SCK,
    command=board.MOSI,
    data=[board.MISO, board.D9, board.D10, board.D11],  # DAT0..DAT3 (4-bit bus)
    frequency=40_000_000,                               # 40 MHz — API max, verifies clean
)
storage.mount(storage.VfsFat(sd), "/sd")

1
2
3
4
5
6
7
8
9

import board, sdioio, storage

sd = sdioio.SDCard(
    clock=board.SCK,
    command=board.MOSI,
    data=[board.MISO, board.D9, board.D10, board.D11],  # DAT0..DAT3 (4-bit bus)
    frequency=40_000_000,                               # 40 MHz — API max, verifies clean
)
storage.mount(storage.VfsFat(sd), "/sd")

PyPortal M4 mount_sd.py

import board, sdcardio, storage
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.SD_CS, baudrate=24_000_000)
storage.mount(storage.VfsFat(sd), "/sd")

1
2
3
4

import board, sdcardio, storage
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.SD_CS, baudrate=24_000_000)
storage.mount(storage.VfsFat(sd), "/sd")

Feather RP2350 + 3.5" TFT FeatherWing mount_sd.py

import board, sdcardio, storage
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.D5, baudrate=24_000_000)   # TFT Wing V2 SD CS = D5
storage.mount(storage.VfsFat(sd), "/sd")

1
2
3
4

import board, sdcardio, storage
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.D5, baudrate=24_000_000)   # TFT Wing V2 SD CS = D5
storage.mount(storage.VfsFat(sd), "/sd")

Feather RP2350 + Adalogger FeatherWing mount_sd.py

import board, sdcardio, storage
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.D10, baudrate=24_000_000)  # Adalogger Wing SD CS = D10
storage.mount(storage.VfsFat(sd), "/sd")

1
2
3
4

import board, sdcardio, storage
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.D10, baudrate=24_000_000)  # Adalogger Wing SD CS = D10
storage.mount(storage.VfsFat(sd), "/sd")

Memento ESP32-S3 mount_sd.py

Disable the TFT before initializing the SD card.

import board, sdcardio, storage, digitalio, displayio
displayio.release_displays()                  # stop the camera UI driving the bus
tft = digitalio.DigitalInOut(board.TFT_CS)    # park TFT CS high so it releases the bus
tft.direction = digitalio.Direction.OUTPUT
tft.value = True
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.CARD_CS, baudrate=20_000_000)  # 20 MHz to stay in spec
storage.mount(storage.VfsFat(sd), "/sd")

1
2
3
4
5
6
7
8

import board, sdcardio, storage, digitalio, displayio
displayio.release_displays()                  # stop the camera UI driving the bus
tft = digitalio.DigitalInOut(board.TFT_CS)    # park TFT CS high so it releases the bus
tft.direction = digitalio.Direction.OUTPUT
tft.value = True
spi = board.SPI()
sd = sdcardio.SDCard(spi, board.CARD_CS, baudrate=20_000_000)  # 20 MHz to stay in spec
storage.mount(storage.VfsFat(sd), "/sd")