CONFLICT! driver_ng is not allowed to be used with the legacy driver

[aliasnameless]

I compiled and flashed the firmware without problems. However, I get a bootloop

Rebooting...
ets Jul 29 2019 12:21:46

rst:0xc (SW_CPU_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
configsip: 0, SPIWP:0xee
clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
mode:DIO, clock div:2
load:0x3fff0030,len:4112
load:0x40078000,len:15052
load:0x40080400,len:4
load:0x40080404,len:3332
entry 0x400805ac
E (973) rmt(legacy): CONFLICT! driver_ng is not allowed to be used with the legacy driver

A fatal error occurred. The crash dump printed below may be used to help
determine what caused it. If you are not already running the most recent
version of MicroPython, consider upgrading. New versions often fix bugs.

To learn more about how to debug and/or report this crash visit the wiki
page at: [github.com/micropython/micropython/wiki/ESP32-debugging](https://github.com/micropython/micropython/wiki/ESP32-debugging)

LVGL MicroPython
IDF version : 67c1de1e
Machine     : Generic ESP32 module with ESP32


abort() was called at PC 0x40228cb0 on core 0


Backtrace: 0x400813dd:0x3ffe3b40 0x40095de5:0x3ffe3b60 0x4009b32e:0x3ffe3b80 0x40228cb0:0x3ffe3bf0 0x4018ca46:0x3ffe3c10 0x400817e2:0x3ffe3c40 0x40079666:0x3ffe3c90 |<-CORRUPTED




ELF file SHA256: 603a97685

My compilation options is:
python3 make.py esp32 clean --flash-size=4 BOARD=ESP32_GENERIC DISPLAY=ili9341 INDEV=xpt2046

My board is: sunton esp32 2432s024c aka CYD

[kdschlosser]

I am aware of the problem and I am working on fixing it. You can compile the code form several commits ago and it should compile fine.

[straga]

Temporary fix.

E (915) rmt(legacy): CONFLICT! driver_ng is not allowed to be used with the legacy driver
abort() was called at PC 0x421591a8 on core 0

This error occurs because ESP-IDF v5.4 doesn't allow both legacy RMT driver (`driver/rmt.h`) and the new RMT driver (`driver/rmt_tx.h`, `driver/rmt_rx.h`) to be used simultaneously.

## Root Cause Analysis

The conflict happens because:

1. **Legacy RMT driver** is used in:
   - `lib/micropython/ports/esp32/machine_bitstream.c` (includes `driver/rmt.h`)
   - `lib/micropython/ports/esp32/esp32_rmt.c` (provides Python RMT API)
   - `ext_mod/lcd_bus/esp32_include/led_bus.h` (includes `driver/rmt.h`)

2. **New RMT driver** is used in:
   - `micropy_updates/esp32/machine_bitstream.c` (includes `driver/rmt_tx.h`)
   - `ext_mod/led_strip/esp32/src/led_strip.c` (includes `driver/rmt_tx.h`)

3. **ESP-IDF v5.4** has a conflict detection mechanism in `lib/esp-idf/components/driver/deprecated/rmt_legacy.c` that prevents both drivers from being linked simultaneously.

## Solution

The solution involves:
1. Excluding the legacy RMT module (`esp32_rmt.c`) from the build
2. Updating files to use only the new RMT driver
3. Removing dependencies on legacy RMT functions

## Step-by-Step Implementation

### Step 1: Update `builder/esp32.py`

Add the following changes to the ESP32 builder:

#### 1.1 Add new path constant
```python
# Add this line after line 1030
ESP32_COMMON_CMAKE_PATH = 'lib/micropython/ports/esp32/esp32_common.cmake'

1.2 Add RMT conflict suppression to SDK config

# In the build_sdkconfig() function, update the base_config list (around line 1335)
base_config = [
    '',
    'CONFIG_ESP_TIMER_SUPPORTS_ISR_DISPATCH_METHOD=y',
    'CONFIG_ESPTOOLPY_AFTER_NORESET=y',
    'CONFIG_PARTITION_TABLE_CUSTOM=y',
    'CONFIG_ESPTOOLPY_FLASHSIZE_2MB=n',
    'CONFIG_ESPTOOLPY_FLASHSIZE_4MB=n',
    'CONFIG_ESPTOOLPY_FLASHSIZE_8MB=n',
    'CONFIG_ESPTOOLPY_FLASHSIZE_16MB=n',
    'CONFIG_ESPTOOLPY_FLASHSIZE_32MB=n',
    'CONFIG_ESPTOOLPY_FLASHSIZE_64MB=n',
    'CONFIG_ESPTOOLPY_FLASHSIZE_128MB=n',
    # 'CONFIG_COMPILER_OPTIMIZATION_SIZE=n',
    # 'CONFIG_COMPILER_OPTIMIZATION_PERF=n',
    'CONFIG_COMPILER_OPTIMIZATION_CHECKS_SILENT=y',
    # Disable legacy RMT driver to avoid conflict with new driver
    'CONFIG_RMT_SUPPRESS_DEPRECATE_WARN=y'
]

1.3 Add new function to exclude esp32_rmt.c from build

# Add this function after the update_mpconfigport() function (around line 1263)
def update_esp32_common_cmake():
    """Remove esp32_rmt.c from build to avoid RMT driver conflict"""
    data = read_file('esp32', ESP32_COMMON_CMAKE_PATH)
    
    # Remove esp32_rmt.c from the source list to avoid legacy RMT driver conflict
    if 'esp32_rmt.c' in data:
        # Replace the line with esp32_rmt.c with a comment
        data = data.replace('    esp32_rmt.c\n', '    # esp32_rmt.c  # Disabled to avoid RMT driver conflict\n')
        write_file(ESP32_COMMON_CMAKE_PATH, data)

1.4 Add function call to build process

# In the compile() function, add the function call (around line 1489)
update_main()
update_mpthreadport()
update_panic_handler()
update_mpconfigboard()
update_mpconfigport()
update_esp32_common_cmake()  # Add this line
update_mkrules()

Step 2: Create Updated Files in micropy_updates/esp32/

2.1 Update machine_bitstream.c

The existing micropy_updates/esp32/machine_bitstream.c already uses the new RMT driver, but we need to remove its dependency on esp32_rmt.c:

// Replace the machine_bitstream_high_low function (around line 309)
void machine_bitstream_high_low(mp_hal_pin_obj_t pin, uint32_t *timing_ns, const uint8_t *buf, size_t len) {
    // Always use bitbang method to avoid dependency on esp32_rmt.c
    machine_bitstream_high_low_bitbang(pin, timing_ns, buf, len);
}

2.2 Create Updated modesp32.c

Copy the original file and remove RMT references:

cp lib/micropython/ports/esp32/modesp32.c micropy_updates/esp32/modesp32.c

Then edit micropy_updates/esp32/modesp32.c and comment out the RMT reference (around line 234):

// { MP_ROM_QSTR(MP_QSTR_RMT), MP_ROM_PTR(&esp32_rmt_type) }, // Disabled to avoid RMT driver conflict

2.3 Create Updated modesp32.h

Copy the original file and remove RMT declarations:

cp lib/micropython/ports/esp32/modesp32.h micropy_updates/esp32/modesp32.h

Then edit micropy_updates/esp32/modesp32.h and comment out RMT declarations (around lines 62-66):

// extern int8_t esp32_rmt_bitstream_channel_id; // Disabled to avoid RMT driver conflict

extern const mp_obj_type_t esp32_nvs_type;
extern const mp_obj_type_t esp32_partition_type;
// extern const mp_obj_type_t esp32_rmt_type; // Disabled to avoid RMT driver conflict

Step 3: Update ext_mod/lcd_bus/esp32_include/led_bus.h

Replace the legacy RMT include with new RMT includes:

// Replace line 11
// OLD: #include "driver/rmt.h"
// NEW:
#include "driver/rmt_tx.h"
#include "driver/rmt_common.h"
#include "driver/rmt_encoder.h"

File Structure After Changes

micropy_updates/esp32/
├── machine_bitstream.c    # Updated to remove esp32_rmt dependency
├── machine_hw_spi.c       # Existing file
├── machine_sdcard.c       # Existing file
├── machine_uart.c         # Existing file
├── modesp32.c            # Updated to remove RMT references
└── modesp32.h            # Updated to remove RMT declarations

ext_mod/lcd_bus/esp32_include/
└── led_bus.h             # Updated to use new RMT headers

builder/
└── esp32.py              # Updated with new functions and config

[thisandre]

Hi Straga, thanks for your effort but it doesn't seem to work for me!
I exactly followed your instructions and was able to perform the build, however, when I load this code on the ESP, the system keeps rebooting with the information below:

ESP-ROM:esp32s3-20210327
Build:Mar 27 2021
rst:0x7 (TG0WDT_SYS_RST),boot:0x28 (SPI_FAST_FLASH_BOOT)
Saved PC:0x400454d5
SPIWP:0xee
mode:QIO, clock div:1
load:0x3fce2820,len:0xeb0
ets_loader.c 78

[kdschlosser]

The current solution is to use a commit that is prior to the one that modifies the bitstream file.

I am aware of the issue and there is a solution that has been made to the problem. I have to get that solution into place. The issue was the neopixel library that is built into Micropython doesn't work properly when using SPIRAM. There seems to be some kind of a big in the ESP-IDF with regards to the deprecated API that MicroPython is using. Because that API is deprecated I do not see the developers over at Espressif spending any time to figure out what the problem is and actually creating a fox for the problem.

The actual solution is micropython needs to be updated to support the new RMT API. This has been submitted as a PR to MicroPython 9 months ago and the problem with the neopixel library was also reported 9 months ago. The issue has not been acknowledged and the PR has not been merged. So it would appear that there is no motivation to update the RMT and bitstream drivers to solve the problem at hand. I would much rather have the issues corrected upstream but that doesn't appear to happen all that often which leads to me having to update the MicroPython code which is something I would rather not do.

I am not using the latest MicroPython version because it is riddled with bugs for the ESP32. It has been a month now and no release has been made to correct these bugs. I am not sure if there is going to be a minor version release to correct those issues or if we are going to be forced to wait until the next major version release. While I am hopeful that the RMT would be fixed in the next release I am very doubtful that it will be.

The issues are stemming from MicroPython having the IDF version it is using being upgraded but the code not being changed to use the new code for different parts of the IDF. It has been a very long time since the portions of the IDF that MicroPython uses has been flagged as deprecated, Years actually. But for some reason it is not being updated. The same thing holds true for I2C, SPI, SDCard etc.... These are all using deprecated portions of the ESP-IDF

[glennra]

Thank you @straga . The modifications worked for my board (ESP32-2432S028R without SPIRAM).

The only issue so far is that soft reboot doesn't work:

MPY: soft reboot
LVGL (9.3.0) MicroPython (1.25.0) Binding compiled on 2025-09-06; Generic ESP32 module with ESP32
Type "help()" for more information.

MPY: soft reboot
Traceback (most recent call last):
  File "<stdin>", line 25, in <module>
TypeError: can't convert str to int

for this code:

from micropython import const
import lvgl as lv

_SPI_BUS_HOST = const(1)
_SPI_BUS_MOSI = const(13)
_SPI_BUS_MISO = const(12)
_SPI_BUS_SCK = const(14)
_INDEV_BUS_HOST = const(2)
_INDEV_BUS_MOSI = const(32)
_INDEV_BUS_MISO = const(39)
_INDEV_BUS_SCK = const(25)
_INDEV_DEVICE_FREQ = const(2000000)
_INDEV_DEVICE_CS = const(33)
_DISPLAY_BUS_FREQ = const(24000000)
_DISPLAY_BUS_DC = const(2)
_DISPLAY_BUS_CS = const(15)
_DISPLAY_WIDTH = const(320)
_DISPLAY_HEIGHT = const(240)
_DISPLAY_BACKLIGHT_PIN = const(21)
_DISPLAY_RGB565_BYTE_SWAP = const(True)

import machine

spi_bus = machine.SPI.Bus(
    host=_SPI_BUS_HOST,
    mosi=_SPI_BUS_MOSI,
    miso=_SPI_BUS_MISO,
    sck=_SPI_BUS_SCK
)

indev_bus = machine.SPI.Bus(
    host=_INDEV_BUS_HOST,
    mosi=_INDEV_BUS_MOSI,
    miso=_INDEV_BUS_MISO,
    sck=_INDEV_BUS_SCK
)

indev_device = machine.SPI.Device(
    spi_bus=indev_bus,
    freq=_INDEV_DEVICE_FREQ,
    cs=_INDEV_DEVICE_CS
)

import lcd_bus

display_bus = lcd_bus.SPIBus(
    spi_bus=spi_bus,
    freq=_DISPLAY_BUS_FREQ,
    dc=_DISPLAY_BUS_DC,
    cs=_DISPLAY_BUS_CS
)

import ili9341

display = ili9341.ILI9341(
    data_bus=display_bus,
    display_width=320,
    display_height=240,
    backlight_pin=_DISPLAY_BACKLIGHT_PIN,
    backlight_on_state=ili9341.STATE_PWM,
    color_space=lv.COLOR_FORMAT.RGB565,
    color_byte_order=ili9341.BYTE_ORDER_BGR,
    rgb565_byte_swap=True,
)

'''
Rotation table from ili9341 driver
MIRROR_ROTATE = {
    (False, 0): 0x80, 
    (False, 90): 0xE0,
    (False, 180): 0x40,
    (False, 270): 0x20,
    (True, 0): 0xC0,
    (True, 90): 0x60,
    (True, 180): 0x00,
    (True, 270): 0xA0
}'''

#display._ORIENTATION_TABLE = [0, 96, 192, 160]


display._ORIENTATION_TABLE = (
    0xE0,
    0xE0,# wrong
    0x20,
    0x20,# wrong
)

display.set_rotation(lv.DISPLAY_ROTATION._0)
display.set_power(True)
display.init(1)
display.set_backlight(100)

import xpt2046
import touch_cal_data

touch_data = touch_cal_data.TouchCalData('My Display')
indev = xpt2046.XPT2046(device=indev_device, touch_cal=touch_data)

#indev.touch_threshold = 200

do_calibration = False
# indev.is_calibrated:
if do_calibration:
    indev.calibrate()
    touch_data.mirrorX = False
    touch_data.mirrorY = True
    touch_data.save()

import task_handler

task_handler.TaskHandler()

scr = lv.screen_active()
''' Add Screen Content '''

slider = lv.slider(scr)
slider.set_size(210, 10)

slider.center()

label = lv.label(scr)
label.set_text('HELLO WORLD!')
label.align(lv.ALIGN.CENTER, 0, -80)

[kdschlosser]

soft reboots don't work with this project regardless of the error you are getting. It usually causes a core panic and it has to do something with the root pointers to the lvgl objects.

so if you didn't get this error you more than likely would have ended up with a core panic anyhow.

[howardtechnical]

@kdschlosser Does that mean we can never trigger a reset from a Micropython application? My project requires the ability to reset the device. I'm currently using machine.reset().

[kdschlosser]

That's a hard reset so you are fine. you don't want to use soft_reset()