ESP32C3 and ESP32C6 not enough IDF HEAP for WIFI + BLE

[mispacek]

Port, board and/or hardware

esp32

MicroPython version

MPY version : v1.27.0 on 2025-12-09
IDF version : v5.5.1
Machine : ESP32C3 module with ESP32C3

ble_wifi_mem_probe.py
ble_repl_bletime.py

import ble_wifi_mem_probe as p
p.BLE_PROFILES["c3safe"]["debug"] = 2
p.run("c3safe", 30, "ble_wifi_espnow", "sta_only", False, True)

Reproduction

I trying to make Bluetooth REPL with ESP NOW functionality for https://espide.eu/
On ESP32 and ESP32S3 code works fine.

On ESP32C3 and ESP32C6 code crash with OSError('WiFi Out of Memory'.

Copy ble_wifi_mem_probe.py and ble_repl_bletime.py to ESP and run:

import ble_wifi_mem_probe as p
p.BLE_PROFILES["c3safe"]["debug"] = 2
p.run("c3safe", 30, "ble_wifi_espnow", "sta_only", False, True)

Logs on ESP32 :

MicroPython v1.27.0 on 2025-12-09; Generic ESP32 module with ESP32

Type "help()" for more information.

PROFILE=c3safe run_seconds=30 order=ble_wifi_espnow wifi_mode=sta_only precreate_wifi_obj=False cleanup_at_end=True
[boot] gc_free=134544 gc_alloc=30704
  heap_data free=94256 largest=53248 min_free=50528 total=254472 regions=7
  heap_exec free=78636 largest=53248 min_free=60868 total=139760 regions=3
[BLE_INIT] create BLE object gc_free=133040 heap_data_free=94256 largest=53248
[BLE_INIT] BLE object created gc_free=132160 heap_data_free=94256 largest=53248
[BLE_INIT] BLE active(True) gc_free=131312 heap_data_free=94256 largest=53248
[BLE_INIT] BLE active done gc_free=121888 heap_data_free=47276 largest=45056
[BLE_INIT] BLE irq handler attached gc_free=121024 heap_data_free=47276 largest=45056
[BLE_INIT] register GATTS services (joy=False) gc_free=119248 heap_data_free=47276 largest=45056
[BLE_INIT] GATTS services registered gc_free=117568 heap_data_free=47136 largest=45056
[BLE_INIT] gatts_set_buffer RX gc_free=116688 heap_data_free=47136 largest=45056
[BLE_INIT] gatts_set_buffer RX done gc_free=115776 heap_data_free=47136 largest=45056
[BLE_INIT] config gap_name gc_free=114880 heap_data_free=47136 largest=45056
[BLE_INIT] config gap_name done gc_free=114016 heap_data_free=47136 largest=45056
[BLE_INIT] config mtu=69 gc_free=112720 heap_data_free=47136 largest=45056
[BLE_INIT] config mtu done gc_free=111872 heap_data_free=47136 largest=45056
[BLE_INIT] refresh_mtu gc_free=111024 heap_data_free=47136 largest=45056
[BLE_INIT] refresh_mtu done gc_free=110112 heap_data_free=47136 largest=45056
[BLE_INIT] start advertising gc_free=109024 heap_data_free=47136 largest=45056
[BLE_INIT] advertising started gc_free=108176 heap_data_free=47136 largest=45056
[BLE_INIT] timer init gc_free=107312 heap_data_free=47136 largest=45056
[BLE_INIT] timer started gc_free=106400 heap_data_free=47120 largest=45056
[ble_started] gc_free=125584 gc_alloc=31472
  ble connected=False mtu=69 chunk=66 rx_pending=0 tx_pending=0 tx_drop=0
  heap_data free=47120 largest=45056 min_free=47004 total=254472 regions=7
  heap_exec free=57376 largest=45056 min_free=57344 total=139760 regions=3
[wifi_ready] gc_free=88256 gc_alloc=31424
  ble connected=False mtu=69 chunk=66 rx_pending=0 tx_pending=0 tx_drop=0
  heap_data free=7860 largest=7680 min_free=7648 total=254472 regions=7
  heap_exec free=18248 largest=10240 min_free=18004 total=139760 regions=3`

logs on ESP32C3 :

MicroPython v1.27.0 on 2025-12-09; ESP32C3 module with ESP32C3

Type "help()" for more information.

PROFILE=c3safe run_seconds=30 order=ble_wifi_espnow wifi_mode=sta_only precreate_wifi_obj=False cleanup_at_end=True
[boot] gc_free=150720 gc_alloc=26368
  heap_data free=91388 largest=49152 min_free=91388 total=259660 regions=4
  heap_exec free=91388 largest=49152 min_free=91388 total=259660 regions=4
[BLE_INIT] create BLE object gc_free=149296 heap_data_free=91388 largest=49152
[BLE_INIT] BLE object created gc_free=148496 heap_data_free=91388 largest=49152
[BLE_INIT] BLE active(True) gc_free=147728 heap_data_free=91388 largest=49152
[BLE_INIT] BLE active done gc_free=119952 heap_data_free=28496 largest=22528
[BLE_INIT] BLE irq handler attached gc_free=119168 heap_data_free=28496 largest=22528
[BLE_INIT] register GATTS services (joy=False) gc_free=117472 heap_data_free=28496 largest=22528
[BLE_INIT] GATTS services registered gc_free=115872 heap_data_free=28356 largest=22528
[BLE_INIT] gatts_set_buffer RX gc_free=115072 heap_data_free=28356 largest=22528
[BLE_INIT] gatts_set_buffer RX done gc_free=114240 heap_data_free=28356 largest=22528
[BLE_INIT] config gap_name gc_free=113424 heap_data_free=28356 largest=22528
[BLE_INIT] config gap_name done gc_free=112640 heap_data_free=28356 largest=22528
[BLE_INIT] config mtu=69 gc_free=111424 heap_data_free=28356 largest=22528
[BLE_INIT] config mtu done gc_free=110656 heap_data_free=28356 largest=22528
[BLE_INIT] refresh_mtu gc_free=109888 heap_data_free=28356 largest=22528
[BLE_INIT] refresh_mtu done gc_free=109056 heap_data_free=28356 largest=22528
[BLE_INIT] start advertising gc_free=108048 heap_data_free=28356 largest=22528
[BLE_INIT] advertising started gc_free=107280 heap_data_free=28320 largest=22528
[BLE_INIT] timer init gc_free=106496 heap_data_free=28320 largest=22528
[BLE_INIT] timer started gc_free=105664 heap_data_free=28284 largest=22528
[ble_started] gc_free=121808 gc_alloc=28656
  ble connected=False mtu=69 chunk=66 rx_pending=0 tx_pending=0 tx_drop=0
  heap_data free=28284 largest=22528 min_free=28284 total=259660 regions=4
  heap_exec free=28284 largest=22528 min_free=28284 total=259660 regions=4

FAIL stage=wifi err=RuntimeError("wifi_sta_obj: OSError('WiFi Out of Memory',)",)
Traceback (most recent call last):
  File "ble_wifi_mem_probe.py", line 371, in run
  File "ble_wifi_mem_probe.py", line 229, in init_wifi
  File "ble_wifi_mem_probe.py", line 204, in _step
RuntimeError: wifi_sta_obj: OSError('WiFi Out of Memory',)
[after_fail] gc_free=109792 gc_alloc=28896
  ble connected=False mtu=69 chunk=66 rx_pending=0 tx_pending=0 tx_drop=0
  heap_data free=26444 largest=10752 min_free=7240 total=259660 regions=4
  heap_exec free=26444 largest=10752 min_free=7240 total=259660 regions=4
[after_cleanup] gc_free=124416 gc_alloc=28096
  heap_data free=82748 largest=24576 min_free=7240 total=259660 regions=4
  heap_exec free=82748 largest=24576 min_free=7240 total=259660 regions=4

Expected behaviour

Program try to create BLE and WIfi interface and for 30s monitoring free heap memory...

Expected is running without errors.

Observed behaviour

Traceback (most recent call last):
  File "ble_wifi_mem_probe.py", line 371, in run
  File "ble_wifi_mem_probe.py", line 229, in init_wifi
  File "ble_wifi_mem_probe.py", line 204, in _step
RuntimeError: wifi_sta_obj: OSError('WiFi Out of Memory',)

Additional Information

No, I've provided everything above.

Code of Conduct

Yes, I agree

[Josverl]

Please use GitHub Flavored Markdown to format your posts.
In particular use 'triple backticks'
```py
# code goes here
```
around your code snippets to get syntax highlighting and proper indenting.

---

I have spend some to to repro this to confirm what your logs already show : RuntimeError: wifi_sta_obj: OSError('WiFi Out of Memory',)

Your logs show a classic coexistence memory squeeze: BLE + Wi‑Fi each need large internal IDF buffers, and C3 runs out of suitable memory depending on init order.

So; what is using memory ?

1. the WIFI stack
2. the BLE stack
3. the parsing and compilation process to compile the .py modules into bytecode
4. the module's globals and locals

if I pre-compile the modules to .mpy - then the same code does run on a ESP32-C3 - but still runs out of memory on a ESP32-C6

if I strip down the scanner to do only a BLE scan ( and avoid allocating any WiFi) - it works fine on a C6 as well.

That is the reality of Micro Controllers - there are only limited resources.

[mispacek]

I tried mpy-cross, but in my case it didn’t help much and the setup was still unstable. In the end I made a MicroPython fork and tuned some memory-hungry defaults in ESP-IDF (reduced the max number of TCP connections, lowered a few buffer sizes, and limited BLE to a single parallel connection). That improved things, but it also means that for my use-case I’ll likely need to build MicroPython myself going forward, which is a bit unfortunate.

I do understand the core point: BLE + Wi-Fi coexistence on ESP32-C3/C6 is a tight squeeze, and init order and internal IDF allocations can easily push it over the edge. My main question was whether there is any official / supported way to shift the balance (e.g., documented ESP-IDF/MicroPython build-time options, recommended configs, or a “standard” way to trade features for heap), instead of maintaining a long-term fork.

If you know which specific IDF config knobs are considered safe/recommended for this (or if there’s a reference config for C6 BLE+Wi-Fi coexistence), I’d appreciate pointers.

https://github.com/mispacek/micropython_BLE_FIX

[Josverl]

main question was whether there is any official / supported way to shift the balance (e.g., documented ESP-IDF/MicroPython build-time options, recommended configs, or a “standard” way to trade features for heap),

There is a WiKi doc on adding boards / variants that is quite relevant:

• Adding Board Profiles

Recently I compiled a list of option (with the use of AI) and put that on the WIKI.
You will need to enable / disable the options in your own board configuration ( see below)

• MicroPython Configuration Macros — MICROPY_* macro reference.
• MicroPython MP Macros — MP_* macro reference.

instead of maintaining a long-term fork.

You can create a repo with "Just the board definition and configuration" and use the git magic of submodules to get the rest of MicroPython.
The official [example_boards repo] is a bit out of date.; so I suggest you start from an 1.27.0 branch of my fork for now.

• https://github.com/Josverl/micropython-example-boards/tree/update_1.27.0
  ( I added a CUSTOM_ESP32_C6 to get you started)

Then you get all of :

• your own preferred optimum config
• a way to freeze those custom .py modules into your firmware ( part of the standard build process.
• get MicroPython included without needing a copy. Pinned to a specific version / commit , or just the master branch.

[projectgus]

We do already have a config snippet to increase free RAM:
https://github.com/micropython/micropython/blob/master/ports/esp32/boards/sdkconfig.free_ram

(and a bunch of the sdkconfig.ble_wifi_coex seems to be copied from there, so I guess that's not news @mispacek! 😆)

This config is currently enabled on the generic ESP32-C2 and the ESP32-C5 boards. Not on C3 or C6 at the moment.

The trade off is reduced "performance", but this is hard to benchmark except for some hard limits like a reduced number of max open sockets. I suspect most MicroPython users of C3 and C6 wouldn't notice the performance difference.

So there are two things we could easily consider for MicroPython itself:

1. Add the free_ram config to C3 and C6 boards by default, or:
2. Add a max_free_ram variant of these boards, that pulls in that config.

---

The other option I noticed in sdkconfig.ble_wifi_coex is CONFIG_BT_NIMBLE_MAX_CONNECTIONS=1 which reduces the number of L2CAP buffers in the static memory bool. Not sure if we'd merge a config for this as well, although I suspect many MicroPython uses cases only need one concurrent BLE connection...

[projectgus]

I was preparing a PR to change C3 and C6 to include sdkconfig.free_ram config by default, but I've abandoned it as the performance hit is quite high.

The RAM savings are significant:

Chip	(Default config) Free IDF heap at boot	Free heap after connecting Wi-Fi	(With sdkconfig.free_ram) Free IDF heap at boot	Free heap after connecting Wi-Fi
C3	161144	108892	201180 (+40036)	154304 (+45412)
C6	295084	241200	325932 (+30848)	277688 (+36488)
Original ESP32	143204	93520	143628 (+424)	99036 (+5516)

(Test method was to run mpremote u0 repl --inject-code "import esp32; sum(a[1] for a in esp32.idf_heap_info(esp32.HEAP_DATA))" --inject-file connect_to_wifi.py)

Wi-Fi performance, as measured using iperf3 module with server on MicroPython:

Chip	Before	After
C3	6.4Mbit/sec	3.65Mbit/sec
C6	8.1Mbit/sec	4.43Mbit/sec

(Client command was iperf3 -c IP -i 3 -t 60 -l 32768)

Running the ESP-IDF iperf2 example on the same boards with the same Wi-Fi setup yields 38.4Mbit/sec on C3 and 46.4Mbit/sec on C6. This isn't a fair comparison to MicroPython as the example is optimised C code that tunes a lot of sdkconfig settings to get maximum speed at impact of high memory usage, etc. However, it does show that the slowdown is quite substantial and there's no issue with my test setup.

Given more time someone could probably figure out which setting(s) impact the performance the most and make a less aggressive config. Or we could look at making a board variant for "max free RAM" instead, with the warning that this may reduce Wi-Fi performance by half...