ESP32-S3 ULP

[IcedRooibos]

Just wanted to check - there is currently no way to use the ULP with the ESP-32 S3 in micropython, correct?

Would it be possible using a native C module?

[glenn20]

Yes, this would appear to be true. The ports/esp32/esp32_ulp.c file is wrapped in a #if CONFIG_IDF_TARGET_ESP32 so it is only enabled for the ESP32. However, the API for the esp32s3 seems comaptible with the esp32, so it would seem that this could be enabled for the esp32s3. (Note this is the ULP FSM - not the additional RISC-V ULP). Note - I have not tested any of this with a real module - just checking the code.

[mattytrentini]

Jinx! (Sorry @glenn20 I didn't see your response before posting mine)

[mattytrentini]

The ESP32-S3 has two ULPs; the 'classic' or 'FSM' ULP which I believe should work and is intended to be backwards-compatible with the ULP on the original ESP32. Currently it's only enabled for the original ESP32 but I think it ought to work on the S2 and S3 where the ULP FSM is available.

The second ULP is based on a RISC-V core, and this is currently unsupported in MicroPython, to my knowledge. The RISC-V ULP is present on the S2 and S3.

It would be a nice addition to the esp32 module and looks similar to the FSM ULP in implementation. For someone keen, take a look at the current esp32_ulp.c file and compare with the RISC-V ULP IDF docs.

[IcedRooibos]

Thanks both! That's interesting to know. I thought I would test it by compiling with the ifdef statement removed (along with the corresponding endif) but it ends up with an error message. (I've compiled and tested the regular old GENERIC_S3_SPIRAM_OCTAL without issues already so the error should be related to this change)

#if CONFIG_IDF_TARGET_ESP32 <-- removed this line
** stuff **
#endif <-- and this line

frozen_content.c:96:5: error: redeclaration of enumerator 'MP_QSTR_run'
     MP_QSTR_run,
     ^~~~~~~~~~~
In file included from /home/luv090909/micropython/py/obj.h:33,
                 from /home/luv090909/micropython/py/objint.h:30,
                 from frozen_content.c:16:
./genhdr/qstrdefs.generated.h:873:6: note: previous definition of 'MP_QSTR_run' was here
 QDEF(MP_QSTR_run, 35180, 3, "run")
      ^~~~~~~~~~~
/home/luv090909/micropython/py/qstr.h:41:34: note: in definition of macro 'QDEF'
 #define QDEF(id, hash, len, str) id,
                                  ^~
[213/218] Building C object esp-idf/main/CMakeFiles/__idf_main.dir/__/machine_rtc.c.obj
ninja: build stopped: subcommand failed.
ninja failed with exit code 1
-e See https://github.com/micropython/micropython/wiki/Build-Troubleshooting
make: *** [Makefile:52: all] Error 1

For now I will make do without the ULP on this board but good to know there's an option if I can put in the work.

Thank you!

[IcedRooibos]

Wall of text below the details of which aren't particularly important - I am curious how far off am I? If I continue doing these sort of tests do you think I might get something working? Or will it need a lot more playing with the internals to get there? Wondering if I should try a bit more or not.

I also saw the comment below:
the ESP32-S2 will not work as it is not binary compatible with the ESP32.
on this library: https://github.com/micropython/micropython-esp32-ulp
So even if I get the module successfully compiled and imported I don't think it's actually going to function, yeah?

Wall of text

Got a bit curious so was playing around a bit more.

I think the issue previously was I didnt remake the submodules with the board parameter passed, so I just had to

make submodules BOARD=GENERIC_S3_SPIRAM_OCT

and then

make BOARD=GENERIC_S3_SPIRAM_OCT

Still fails, but a lot later. Here's the error message:

In file included from /home/[username]/micropython/py/mpstate.h:35,
                 from /home/[username]/micropython/py/runtime.h:29,
                 from ../esp32_ulp.c:27:
../esp32_ulp.c:90:52: error: 'CONFIG_ESP32_ULP_COPROC_RESERVE_MEM' undeclared here (not in a function); did you mean 'CONFIG_ESP32S3_ULP_COPROC_RESERVE_MEM'?
     { MP_ROM_QSTR(MP_QSTR_RESERVE_MEM), MP_ROM_INT(CONFIG_ESP32_ULP_COPROC_RESERVE_MEM) },
                                                    ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
/home/[username]/micropython/py/obj.h:346:23: note: in expansion of macro 'MP_OBJ_NEW_SMALL_INT'
 #define MP_ROM_INT(i) MP_OBJ_NEW_SMALL_INT(i)
                       ^~~~~~~~~~~~~~~~~~~~
../esp32_ulp.c:90:41: note: in expansion of macro 'MP_ROM_INT'
     { MP_ROM_QSTR(MP_QSTR_RESERVE_MEM), MP_ROM_INT(CONFIG_ESP32_ULP_COPROC_RESERVE_MEM) },
                                         ^~~~~~~~~~
[1395/1403] Building C object esp-idf/main/CMakeFiles/__idf_main.dir/__/machine_sdcard.c.obj
ninja: build stopped: subcommand failed.
ninja failed with exit code 1
-e See https://github.com/micropython/micropython/wiki/Build-Troubleshooting
make: *** [Makefile:52: all] Error 1

so I changed
{ MP_ROM_QSTR(MP_QSTR_RESERVE_MEM), MP_ROM_INT(CONFIG_ESP32_ULP_COPROC_RESERVE_MEM) },

to

{ MP_ROM_QSTR(MP_QSTR_RESERVE_MEM), MP_ROM_INT(CONFIG_ESP32S3_ULP_COPROC_RESERVE_MEM) },

and ran make again. Which worked.

I've attached the compiled firmware here in case anyone wants to play with it but it doesn't work, esp32 doesn't have a ULP module here

>>> dir(esp32)
['__class__', '__name__', '__dict__', 'HEAP_DATA', 'HEAP_EXEC', 'NVS', 'Partition', 'RMT', 'WAKEUP_ALL_LOW', 'WAKEUP_ANY_HIGH', 'gpio_deep_sleep_hold', 'idf_heap_info', 'wake_on_ext0', 'wake_on_ext1', 'wake_on_touch', 'wake_on_ulp']

firmware_ulp.zip

[IcedRooibos]

So I also commented out the following ifdef in modesp32.c

//    #if CONFIG_IDF_TARGET_ESP32
    { MP_ROM_QSTR(MP_QSTR_ULP), MP_ROM_PTR(&esp32_ulp_type) },
//    #endif

And ULP import works fine now. All this means of course is that the module will import - I don't yet know if it will work at all.

>>> import esp32
>>> dir(esp32)
['__class__', '__name__', '__dict__', 'HEAP_DATA', 'HEAP_EXEC', 'NVS', 'Partition', 'RMT', 'ULP', 'WAKEUP_ALL_LOW', 'WAKEUP_ANY_HIGH', 'gpio_deep_sleep_hold', 'idf_heap_info', 'wake_on_ext0', 'wake_on_ext1', 'wake_on_touch', 'wake_on_ulp']

[IcedRooibos]

Ok so after the module loads, running the counter example from here (link) leads to OSError: 260

Firmware attached on the off chance anyone wants to look into it.

firmware-ulp-2.zip

Looking at https://github.com/espressif/esp-idf/blob/master/components/esp_common/include/esp_err.h

This seems to be

#define ESP_ERR_INVALID_SIZE        0x104   /*!< Invalid size */

And here is the code that seems to be throwing the error (link):

esp_err_t ulp_load_binary(uint32_t load_addr, const uint8_t* program_binary, size_t program_size)
{
    size_t program_size_bytes = program_size * sizeof(uint32_t);
    size_t load_addr_bytes = load_addr * sizeof(uint32_t);

    if (program_size_bytes < sizeof(ulp_binary_header_t)) {
        return ESP_ERR_INVALID_SIZE;
    }
    if (load_addr_bytes > CONFIG_ULP_COPROC_RESERVE_MEM) {
        return ESP_ERR_INVALID_ARG;
    }
    if (load_addr_bytes + program_size_bytes > CONFIG_ULP_COPROC_RESERVE_MEM) {
        return ESP_ERR_INVALID_SIZE;
    }

    // Make a copy of a header in case program_binary isn't aligned
    ulp_binary_header_t header;
    memcpy(&header, program_binary, sizeof(header));

    if (header.magic != ULP_BINARY_MAGIC_ESP32) {
        return ESP_ERR_NOT_SUPPORTED;
    }

    size_t total_size = (size_t) header.text_offset + (size_t) header.text_size +
            (size_t) header.data_size;

    ESP_LOGD(TAG, "program_size_bytes: %d total_size: %d offset: %d .text: %d, .data: %d, .bss: %d",
            program_size_bytes, total_size, header.text_offset,
            header.text_size, header.data_size, header.bss_size);

    if (total_size != program_size_bytes) {
        return ESP_ERR_INVALID_SIZE;
    }

    size_t text_data_size = header.text_size + header.data_size;
    uint8_t* base = (uint8_t*) RTC_SLOW_MEM;

    memcpy(base + load_addr_bytes, program_binary + header.text_offset, text_data_size);
    memset(base + load_addr_bytes + text_data_size, 0, header.bss_size);

    return ESP_OK;
}

In my build/sdkconfig I see

CONFIG_ULP_COPROC_RESERVE_MEM=2040

(I had added CONFIG_ESP32S3_ULP_COPROC_RESERVE_MEM = 2040 to boards/sdkconfig.base)

So I am thinking the library here may not be compiling the source correctly? https://github.com/micropython/micropython-esp32-ulp

Makes sense given it was designed for ESP32 not ESP32S3

[IcedRooibos]

On a slightly related note it looks like if micropython wanted to support the RISC-V ULP it might be not so difficult to do?

https://docs.micropython.org/en/latest/library/esp32.html#ultra-low-power-co-processor

ULP.set_wakeup_period would stay unchanged
ULP.load_binary would call ulp_riscv_load_binary instead with a slight change in arguments passed (only need to pass binary pointer and program size, don't need load address)
ULP.run would call ulp_riscv_run without any other changes

The nice thing about the RISCV coprocessor is it can be programmed in C rather than assembly.

Though since only either the FSM or RISCV version can be enabled and there is an option in the sdk configuration for ULP_COPROC_ENABLED=y and either ULP_COPROC_TYPE=?? with 3 options FSM/ULP-RISCV/LP-RISCV it seems that there would need to be different micropython firmwares for each different coprocessor variant? Or maybe am I missing a way to define this at runtime?

[wnienhaus]

Update: micropython-esp32-ulp now has support for the ESP32-S2 and ESP32-S3.

Currently this exists in an open PR, but it should be merged soon and it can already be tested.

Simply pass -c esp32s2 to the assembler and it will generate an ESP32-S2/S3 (their ULP-FSMs are identical) binary. Refer to the documentation, for how to select the esp32s2 when using the assembler as a library from other MicroPython code.

(Side-note: There's also a ULP disassembler now, which can disassemble ESP32-S2/S3).

[kjm1102]

What's the situation with the C3 Wilko, I guess no ULP-FSM for it since its RISC-V only?

[wnienhaus]

Yes, the C3 does not have a ULP at all, so micropython-esp32-ulp is not relevant for the C3.

(Not related to the C3, but In case you are interested in using the RISC-V ULP of the S2 or S3, there is a draft PR to MicroPython aiming to make that possible: #11572)

[kjm1102]

I'll probably stick with the non riscc ULP since it works and there are less 'how to's for the risc config.

I note I can omit lines like

define RTC_IO_TOUCH_PAD0_RUE  (BIT(27))                                    # pullup

and

WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RUE, 1, 0)       # disable pullup

with the non risc ULP. Is that because we're using it with the RTC mux instead of the digital mux & pullups are already disabled because of that?

[kjm1102]

Yeah I saw that, nice work.

…

On Sat, 15 July 2023, 2:14 am Wilko Nienhaus, ***@***.***> wrote: Yes, the C3 does not have a ULP at all, so micropython-esp32-ulp is not relevant for the C3. (Not related to the C3, but In case you are interested in using the RISC-V ULP of the S2 or S3, there is a draft PR to MicroPython aiming to make that possible: #11572 <#11572>) — Reply to this email directly, view it on GitHub <#11175 (reply in thread)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AV562M4BKTLENPU7HXXZPUTXQFV6RANCNFSM6AAAAAAWPW4WMA> . You are receiving this because you commented.Message ID: ***@***.*** com>

[nubcore]

v1.21 now has support for S2 & S3. I've tested this with an S2 although running in to a bug that borks Wifi, so had to manually install the code rather than use the documented process with mip.

https://docs.micropython.org/en/latest/library/esp32.html#esp32.ULP

There is a very clear but slightly confusing note. DOES NOT WORK WITH RISC-V, the fine print though, there are two ULPs and it implements the Finite State Machine (FSM). So I hope this now answers/resolves your initial question of can you ULP. I certainly can now, getting at least as far as blink. RISC-V ULP looks to be a potential future work to come.

ULP output of GPIO on/off:

0xcafe 0x1
0xcafe 0x0

This is a wicked cool trick, write some assembly in repl and convert to running code!

[kjm1102]

I'd be curious to see if it's possible to configure the risc ulp via C code in the repl?