ULP gpio digital read?

[kjm1102]

There is provision for managing gpio pullups when used with the ULP, eg for gpio4

#define RTC_IO_TOUCH_PAD0_RUE  (BIT(27))                                    # pullup
WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RUE, 1, 1)       # enable pullup
#define RTC_IO_TOUCH_PAD0_RDE  (BIT(28))                                    # pulldown
WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RDE, 1, 0)       # disable pulldown

However these don't work in the examples @ https://github.com/micropython/micropython-esp32-ulp/tree/master/examples, you have to add an external pullup. I think this is because all the examples use the gpio inputs with the RTC mux eg

WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1) # connect PAD0 (gpio4) to ULP (1,0 gpio connected to digital mux or 1,1 rtc mux)

rather than the digital mux? Although this a bit of a wild guess, I'm struggling to keep my head above water here.

In all my prowling around the web I can't find an example for ULP reading a gpio input configured with an internal pullup. Surely this is possible?

[nikvostro]

Hi @kjm1102

I'm working on creation of a water consumption counter. And needed to read 2 channels digitally from the balanced magnetic switches (toggles every 10 liters) + touch PIN for flooding sensor (but as wakeup source for main MCU).

I'm a bit confused on using RTCIO_TOUCHPAD instead of RTC_GPIO_IN (see idf pulse_cnt.S example).
And indeed I'm interested in pulling-up or -down respective pins for checking switch states...

Did you progress with finding an answer on your question from elsewhere? Can you comment on reasons for using touchpad instead of gpio?

Regards, Nikolay

[kjm1102]

Mate I needed a lot of hand holding from Wilko to get the coprocessor counting with the main processor in deepsleep via https://github.com/micropython/micropython-esp32-ulp?tab=readme-ov-file. I doubt I'd make any progress with espressif docs, a lot of this stuff is above my pay grade.

[wnienhaus]

I just saw this discussion now. Did you (@nikvostro and/or @kjm1102) manage to read input from a GPIO in deepsleep?
Make sure to use the correct readgpio*.py example file for the edition of the ESP32 you are using.
And if you are using an S3, make sure you are using the very latest code of micropython-esp32-ulp and that you enable the IOMUX clock gate (like here)

[kjm1102]

The original pulse counter certainly worked for me Wilko, back when upython was v1.17, I suppose I should check the latest version with v1.22 upython to check it still does.
I tend to stick with stuff that I know works. Some of the new variants, like the S2 (with it's baked in USB support instead of an external chip) behave badly when I try to flash upython onto them, after flashing the repl does not seem to be on the same port that does the flashing.

[nikvostro]

@kjm1102 @wnienhaus
Looks like it worked for me at the first attempt :)

from esp32 import ULP
from machine import mem32

from esp32_ulp import src_to_binary

source = """\
#define DR_REG_RTCIO_BASE            0x3ff48400
#define RTC_IO_TOUCH_PAD0_REG        (DR_REG_RTCIO_BASE + 0x94)
#define RTC_IO_TOUCH_PAD0_MUX_SEL_M  (BIT(19))
#define RTC_IO_TOUCH_PAD0_FUN_IE_M   (BIT(13))

#GPIO4
#define RTC_IO_TOUCH_PAD0_RUE (BIT(27)) # pullup
#define RTC_IO_TOUCH_PAD0_RDE (BIT(28)) # pulldown

#define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
#define RTC_GPIO_IN_NEXT_S           14
.set channel, 10  # 10 is the channel no. of gpio4

state:      .long 0

entry:
            # connect GPIO to the RTC subsystem so the ULP can read it
            # connect PAD0 (gpio4) to ULP (1,0 gpio connected to digital mux or 1,1 rtc mux)
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1)
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1)

            # switch the GPIO into input mode
            # PAD0 (gpio4) input (1,0 disabled or 1,1 enabled)
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1)
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1)

            #!!!!! pull-up/down
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RUE, 1, 1) # enable pullup
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RDE, 1, 0) # disable pulldown
            WAIT 30000
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RUE, 1, 0) # disable pullup
            WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RDE, 1, 1) # enable pulldown
            WAIT 30000
            
            # read the GPIO's current state into r0
            READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + channel, 1)

            # set r3 to the memory address of "state"
            move r3, state

            # store what was read into r0 into the "state" variable
            st r0, r3, 0

            # halt ULP co-processor (until it gets woken up again)
            halt
"""

binary = src_to_binary(source, cpu="esp32")  # cpu is esp32 or esp32s2

load_addr, entry_addr = 0, 4

ULP_MEM_BASE = 0x50000000
ULP_DATA_MASK = 0xffff  # ULP data is only in lower 16 bits

ulp = ULP()
ulp.set_wakeup_period(0, 100_000)  # use timer0, wakeup after 100.000 cycles
ulp.load_binary(load_addr, binary)

mem32[ULP_MEM_BASE + load_addr] = 0x0  # initialise state to 0
ulp.run(entry_addr)

import time

while True:
    time.sleep(1)
    print(hex(mem32[ULP_MEM_BASE + load_addr] & ULP_DATA_MASK))

GPIO4:

If I run code with pulling-down commented the COM terminal shows respective state of GPIO4: 0x1 - when nothing is connected to the PIN and 0x0 if PIN shorted to GND.

WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RUE, 1, 0) # disable pullup
WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_RDE, 1, 1) # enable pulldown
WAIT 30000

Thanks both!

[wnienhaus]

Great. Thanks for the update. Glad it's working for you.