Still Struggling

[kjm1102]

The https://github.com/micropython/micropython-esp32-ulp/blob/master/examples/counter.py I think shows how to get the count from the ulp into the .py program. However to setup a ULP counter that counts pulses from a gpio pin (eg the ulp assembler code at https://esp32.com/viewtopic.php?t=12454 it looks like the .py program has to send some values (like gpio pin number & debounce info) to the ULP? Could we maybe have another example for us novices on how to do that?

[wnienhaus]

For 99% of things you don't need any setup in the main program, because the ULP can also do that. Most of the rtc_* C functions actually translate down to macros which set peripheral registers. If you can trace the C code of those functions to where the peripheral registers get set, you can use that code in the ULP.

The main thing you would want to do is to set the GPIO pin into RTC mode (so it can be read from the ULP) and to set it into input mode. The blink.py example shows how to do the former: https://github.com/micropython/micropython-esp32-ulp/blob/master/examples/blink.py#L63 and to set a GPIO to input mode use something like this:

WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1); //set gpio4 to input mode

With regards to "variable passing", you can hard code the GPIO pin number, debounce info, etc into the ULP assembler code. In the example you referenced, they simply reference memory locations from C that are in the RTC memory as set up by the assembler code (e.g. debounce_counter: .long 0), but there is no need to actually reference most of those memory addresses from the main program. The only one you are likely interested in from the MicroPython code is the counter value and the counter.py example shows how to read that. Note - from MicroPython we need to read by offset into the memory, rather than "variable names", because MicroPython has no idea of what was declared in the assembly code (there is an old issue #34 that had an idea of how we could implement such a thing, but so far it's not possible).

[kjm1102]

I had a red hot go at counting lows on gpio4

from esp32 import ULP
from machine import mem32, deepsleep, reset_cause, RTC; rtc=RTC()
from esp32_ulp import src_to_binary
from time import time
import json


load_addr, entry_addr = 0, 4
ULP_MEM_BASE = 0x50000000
ULP_DATA_MASK = 0xffff                           # ULP data in lower 16 bits

causes={2:'reset', 1:'hardreset', 3:'wdt', 4:'wakeup', 5:'pwrup'}; cause=causes[reset_cause()]; print(), print('pwrup cause', cause)
if cause!='wakeup':
  dic={'To':time(), 'Co':0}; rtc.memory(json.dumps(dic))
  source = """\
  # constants from:
  # https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/soc.h
  #define DR_REG_RTCIO_BASE            0x3ff48400
  # constants from:
  # https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/rtc_io_reg.h
  #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))
  #define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
  #define RTC_GPIO_IN_NEXT_S           14
  # constants from:
  # https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/rtc_io_channel.h
  #define RTCIO_GPIO4_CHANNEL          10
  # When accessed from the RTC module (ULP) GPIOs need to be addressed by their channel number                                                        gpio4 is ch 10
  .set gpio, RTCIO_GPIO4_CHANNEL
  # connect GPIO to ULP (0:GPIO connected to digital GPIO module, 1:GPIO connected to analog RTC module)
  WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1); //set gpio4 to input mode
  data: .long 0
  entry:
    move r3, gpio                                            # r3 = gpio addr
    ld r3, r3, 0                                             # r3 = gpio + 0
    READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16)
    rsh r0, r0, r3                                           # r0 = r0 >> r3
    jumpr inc, 0, eq                                         # jump to incrementer if input=r0=0
    halt
  inc:
    move r3, data                                            # r3=data addr
    ld r2, r3, 0                                             # r2=data=r3+0
    add r2, r2, 1                                            # r2=r2+1
    st r2, r3, 0                                             # data(addr[r3+0])=r2
    halt                                                     # halt ULP co-prozessor for wakeup_period us
  """
  binary = src_to_binary(source)
  ulp = ULP()
  ulp.set_wakeup_period(0, 50000)                # use timer0, wakeup after 50ms
  ulp.load_binary(load_addr, binary)
  mem32[ULP_MEM_BASE + load_addr] = 0x1000
  ulp.run(entry_addr)
print(hex(mem32[ULP_MEM_BASE + load_addr] & ULP_DATA_MASK))
deepsleep(1000)

but the counter isn't incrementing with the gpio4 pin connected to gnd, just stuck on 0x1000

all I've got to show for my day with ulp assembler is my brain hurts. Also how did you know that gpio4 is RTC_IO_TOUCH_PAD0_REG ?

[kjm1102]

Had another go at incrementing a counter each time I find a lo on gpio4(rtc ch10)

from esp32 import ULP
from machine import mem32, deepsleep, reset_cause, RTC; rtc=RTC()
from esp32_ulp import src_to_binary
from time import time
import json


load_addr, entry_addr = 0, 4
ULP_MEM_BASE = 0x50000000
ULP_DATA_MASK = 0xffff                                                    # ULP data in lower 16 bits

causes={2:'reset', 1:'hardreset', 3:'wdt', 4:'wakeup', 5:'pwrup'}; cause=causes[reset_cause()]; print(), print('pwrup cause', cause)
if cause!='wakeup':
  dic={'To':time(), 'Co':0}; rtc.memory(json.dumps(dic))
  source = """\
  #define DR_REG_RTCIO_BASE            0x3ff48400                         # from https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/soc.h
  #define RTC_IO_TOUCH_PAD0_REG        (DR_REG_RTCIO_BASE + 0x94)         # from https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/rtc_io_reg.h
  #define RTC_IO_TOUCH_PAD0_MUX_SEL_M  (BIT(19))
  #define RTC_IO_TOUCH_PAD0_FUN_IE_M   (BIT(13))
  #define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
  #define RTC_GPIO_IN_NEXT_S           14
  .set channel, 10                                                        # from https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/rtc_io_channel.h
  WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1); # set gpio4 to input mode, apparently gpio4(ie ch10)=TOUCH_PAD0 (connected to digital GPIO:0, analog RTC:1)
  data:   .long 0
  entry:  move r3, channel                                                # r3 = ch addr
          ld r3, r3, 0                                                    # r3 = ch + 0
          READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16)           # use READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + 16, 2) for RTC IOs 16 & 17
          rsh r0, r0, r3                                                  # r0 = r0 >> r3 = analog input
          and r0, r0, 1                                                   # r0 = analog input msd
          jumpr incr, 0, eq                                               # jump to incrementer if input msd=0
          halt                                                            # halt ULP for wakeup_period us
  incr:   move r3, data                                                   # r3=data addr
          ld r2, r3, 0                                                    # r2=MEM[data addr + 0]=data
          add r2, r2, 1                                                   # r2=r2+1
          st r2, r3, 0                                                    # data(addr[r3+0])=r2
          halt
  """
  binary = src_to_binary(source)
  ulp = ULP()
  ulp.set_wakeup_period(0, 50000)                                         # use timer0, wakeup after 50ms
  ulp.load_binary(load_addr, binary)
  mem32[ULP_MEM_BASE + load_addr] = 0x1000
  ulp.run(entry_addr)
print(hex(mem32[ULP_MEM_BASE + load_addr] & ULP_DATA_MASK))
deepsleep(1000)

Still not incrementing sadly

[kjm1102]

Why does it always have to be a feast or a famine in this life?

from esp32 import ULP
from machine import mem32, deepsleep, reset_cause, RTC; rtc=RTC()
from esp32_ulp import src_to_binary
from time import time
import json

load_addr, entry_addr = 0, 4
ULP_MEM_BASE = 0x50000000
ULP_DATA_MASK = 0xffff                                                    # ULP data in lower 16 bits

causes={2:'reset', 1:'hardreset', 3:'wdt', 4:'wakeup', 5:'pwrup'}; cause=causes[reset_cause()]; print(), print('pwrup cause', cause)
if cause!='wakeup':
  dic={'To':time(), 'Co':0}; rtc.memory(json.dumps(dic))
  source = """\
  #define DR_REG_RTCIO_BASE            0x3ff48400                         # from https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/soc.h
  #define RTC_IO_TOUCH_PAD0_REG        (DR_REG_RTCIO_BASE + 0x94)         # from https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/rtc_io_reg.h
  #define RTC_IO_TOUCH_PAD0_MUX_SEL_M  (BIT(19))
  #define RTC_IO_TOUCH_PAD0_FUN_IE_M   (BIT(13))
  #define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
  #define RTC_GPIO_IN_NEXT_S           14
  .set channel, 10                                                        # gpio4=ch10 https://github.com/espressif/esp-idf/blob/1cb31e5/components/soc/esp32/include/soc/rtc_io_channel.h
  #WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1); # set gpio4 to input mode, apparently gpio4(ie ch10)=TOUCH_PAD0 (connected to digital GPIO:0, analog RTC:1)
  data:   .long 0
  entry:  move r3, channel                                                # r3 = ch addr
          ld r3, r3, 0                                                    # r3 = ch + 0
          READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16)           # use READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + 16, 2) for RTC IOs 16 & 17
          rsh r0, r0, r3                                                  # r0 = r0 >> r3 = analog input
          and r0, r0, 1                                                   # r0 = analog input msd
          jumpr incr, 0, eq                                               # jump to incrementer if analog input msd=0
          halt                                                            # halt ULP for wakeup_period us
  incr:   move r3, data                                                   # r3 = data addr
          ld r2, r3, 0                                                    # r2 = MEM[data addr + 0]=data
          add r2, r2, 1                                                   # r2 = r2+1
          st r2, r3, 0                                                    # data = MEM(addr[r3+0]) = r2
          halt
  """
  binary = src_to_binary(source)
  ulp = ULP()
  ulp.set_wakeup_period(0, 50000)                                         # use timer0, wakeup after 50ms
  ulp.load_binary(load_addr, binary)
  mem32[ULP_MEM_BASE + load_addr] = 0x1000
  ulp.run(entry_addr)
print(mem32[ULP_MEM_BASE + load_addr] & ULP_DATA_MASK)
deepsleep(1000)

Got it counting again by knobbling line22 (line 22 inhibits any counting whatsoever). Unfortunately it counts continuously without reference to the state of gpio4(channel10)

[kjm1102]

Today I gave up on counting & tried my luck reading the staus of gpio4

from esp32 import ULP
from machine import mem32, deepsleep, reset_cause, RTC; rtc=RTC()
from esp32_ulp import src_to_binary
from time import time
import json


load_addr, entry_addr = 0, 4
ULP_MEM_BASE = 0x50000000
ULP_DATA_MASK = 0xffff                                                    # ULP data in lower 16 bits

causes={2:'reset', 1:'hardreset', 3:'wdt', 4:'wakeup', 5:'pwrup'}; cause=causes[reset_cause()]; print(), print('pwrup cause', cause)
if cause!='wakeup':
  dic={'To':time(), 'Co':0}; rtc.memory(json.dumps(dic))
  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))
  #define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
  #define RTC_GPIO_IN_NEXT_S           14
  .set channel, 10
  WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1)
  data:   .long 0
  entry:  move r3, channel                                                # r3 = ch addr
          ld r3, r3, 0                                                    # r3 = MEM[channel addr + 0] = channel
          READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16)           # use READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + 16, 2) for RTC channels 16 & 17
          rsh r0, r0, r3                                                  # r0 = r0 >> r3 = analog input
          and r2, r0, 1                                                   # r2 = ro>>1 = analog input msd
          st r2, r3, 0                                                    # data = MEM(addr[r3+0]) = r2
    """
  binary = src_to_binary(source)
  ulp = ULP()
  ulp.set_wakeup_period(0, 50000)                                         # use timer0, wakeup after 50ms
  ulp.load_binary(load_addr, binary)
  mem32[ULP_MEM_BASE + load_addr] = 0x1000
  ulp.run(entry_addr)

print('gpio4', mem32[ULP_MEM_BASE+load_addr] & ULP_DATA_MASK)
deepsleep(1000)                                                          # wakeup+run takes ~4s, so 30s between prints

No joy, I can toggle gpio4 input hi/lo as much as I like, the register is always 4096. If it was easy everyone would be doing it, right?

[kjm1102]

Trial & error, story of my programming life.

from esp32 import ULP
from machine import mem32, mem8, deepsleep, reset_cause, RTC; rtc=RTC()
from esp32_ulp import src_to_binary
from time import time
import json


load_addr, entry_addr = 0, 4
ULP_MEM_BASE = 0x50000000
ULP_DATA_MASK = 0xffff                                                     # ULP data in lower 16 bits

causes={2:'reset', 1:'hardreset', 3:'wdt', 4:'wakeup', 5:'pwrup'}; cause=causes[reset_cause()]; print(), print('pwrup cause', cause)
if cause!='wakeup':
  dic={'To':time(), 'Co':0}; rtc.memory(json.dumps(dic))
  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))
  #define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
  #define RTC_GPIO_IN_NEXT_S           14
  .set channel, 10
  WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1) # connect GPIO to ULP
  WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1)  # gpio input mode

  data:   .long 0
  entry:  move r3, channel                                                # r3 = ch addr
          ld r3, r3, 0                                                    # r3 = MEM(addr[channel+0]) = channel
          READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16)           # use READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + 16, 2) for RTC channels 16 & 17
          rsh r0, r0, r3                                                  # r0 = r0 >> r3 = analog input
          and r2, r0, 1                                                   # r2 = ro>>1 = analog input msd
          st r2, r3, 0                                                    # data = MEM(addr[r3+0]) = r2
    """
  binary = src_to_binary(source)
  ulp = ULP()
  ulp.set_wakeup_period(0, 50000)                                         # use timer0, wakeup after 50ms
  ulp.load_binary(load_addr, binary)
  mem32[ULP_MEM_BASE + load_addr] = 0x1000
  ulp.run(entry_addr)

print('gpio4', mem32[ULP_MEM_BASE+load_addr] & ULP_DATA_MASK)
print([chr(mem8[0x50000000 + i]) for i in range(0,32)])
deepsleep(1000)                                                           # wakeup+run takes ~4s, so 30s between prints

pwrup cause wakeup
gpio4 4096
['\x00', '\x10', '\x00', '\x00', '%', '\x05', '\xb4', '\x16', '\x00', '\x00', '\x00', '\x00', '\xa3', '\x00', '\x80', 'r', '\x0f', '\x00', '\x00', '\xd0', '\t', '\x01', '\xb8', '.', '0', '\x00', '\xc0', 'p', '\x12', '\x00', '@', 'r']

Still not seeing the gpio4 input level in data

[wnienhaus]

It looks like you have been inching closer and closer with each attempt. Great persistence there!

What I think was missing in your earlier attempts was this line:

WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1) # connect GPIO to ULP

This connects the GPIO to the RTC subsystem and is needed for the ULP to read the GPIO.

Your latest code has this line now, so now it should work!

But

But... your code is likely crashing the ULP.

To explain, If we remove all "non-code" lines (such as #define and .set), then the first 4 things in your assembly code are:

WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1) # connect GPIO to ULP
WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1)  # gpio input mode
data:   .long 0
entry:  move r3, channel

The ULP runs instructions sequentially, but line 3 is not an instruction, and should crash the ULP.

Also ulp.run() specifies where the ULP should start, which in your example is 4 bytes (entry_addr) from the start, and basically means "start at the second instruction" in my snippet above (each machine instruction of the ULP is 4 bytes long)

So, you need to move all instructions after the variable and ensure the entry_addr given to ulp.run() is correct. If you stick with only the one .long variable, then 4 is the correct entry_addr... but if you add one more .long variable, entry_addr should be 8, and so on.

Easier GPIO reading

I see you can simplify reading the GPIO value. I notice you are reading 16 bits with this instruction:

READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S, 16)

and then doing bit operations afterwards the get one bit that you want.

But the READ_RTC_REG function takes a "starting bit" and a "number-of-bits-to-read" as arg 2 and 3 respectively, so you can read just 1 bit like this:

READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + channel, 1)

That will get you exactly GPIO4's value into r0.

Putting it together

So putting that all together, I think this should work:

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))
  #define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
  #define RTC_GPIO_IN_NEXT_S           14
  .set channel, 10

  data:   .long 0
  entry:
      WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1) # connect GPIO to ULP
      WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1)  # gpio input mode
      READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + channel, 1) # read gpio value into r0
      move r3, data              # set r3 to the address of data
      st r0, r3, 0               # store r0 into the data variable (to be read with mem32 in micropython)
"""

[kjm1102]

Could you try

from esp32 import ULP
from machine import mem32, mem8, deepsleep, reset_cause, Pin
from esp32_ulp import src_to_binary

load_addr, entry_addr = 0, 4
ULP_MEM_BASE = 0x50000000
ULP_DATA_MASK = 0xffff                           # ULP data in lower 16 bits

causes={2:'reset', 1:'hardreset', 3:'wdt', 4:'wakeup', 5:'pwrup'}; cause=causes[reset_cause()]; print(), print('pwrup cause', cause)
if cause!='wakeup':
  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))
  #define RTC_GPIO_IN_REG              (DR_REG_RTCIO_BASE + 0x24)
  #define RTC_GPIO_IN_NEXT_S           14
  .set channel, 10

  data:   .long 0
  entry:
      WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_MUX_SEL_M, 1, 1) # connect GPIO to ULP
      WRITE_RTC_REG(RTC_IO_TOUCH_PAD0_REG, RTC_IO_TOUCH_PAD0_FUN_IE_M, 1, 1)  # gpio input mode
      READ_RTC_REG(RTC_GPIO_IN_REG, RTC_GPIO_IN_NEXT_S + channel, 1) # read gpio value into r0
      move r3, data              # set r3 to the address of data
      st r0, r3, 0               # store r0 into the data variable (to be read with mem32 in micropython)
  """ 
  
  
  binary = src_to_binary(source)
  ulp = ULP()
  ulp.set_wakeup_period(0, 50000)                # use timer0, wakeup after 50ms
  ulp.load_binary(load_addr, binary)
  mem32[ULP_MEM_BASE + load_addr] = 0x1000
  ulp.run(entry_addr)

print('gpio4', mem32[ULP_MEM_BASE+load_addr] & ULP_DATA_MASK)
print([chr(mem8[0x50000000 + i]) for i in range(0,32)])
deepsleep(1000)  

on your esp32 please? Mine is showing

pwrup cause wakeup
gpio4 0
['\x00', '\x00', '\xa3', '\x00', '%', '\x05', '\xcc', '\x19', '%', '\x05', '\xb4', '\x16', '\t', '\x01', '`', ',', '\x03', '\x00', '\x80', 'r', '\x0c', '\x00', '\x00', 'h', 'V', '\xd6', '\xc7', '\x04', '\x1d', 'a', '\xbe', '.']

regardless of the voltage present on the gpio4 input.

[wnienhaus]

It works correctly (as expected) on my ESP32. When I have GPIO4 connected to VCC (3V3) I see gpio4 1 in the output and when i have GPIO4 not connected to anything, I see gpio4 0.

I wonder if there might be something wrong with your GPIO pin? Perhaps try read GPIO4 from MicroPython normally to test that the input works as expected:

from machine import Pin
p=Pin(4, Pin.IN)
while True:
    print(p.value())

This should print lines with 0 or 1 depending on the current state of GPIO4.

[kjm1102]

Yeah I did that already Wilko, that's why I was keen to see your results. On my ESP32 the python works but the ULP always reports 0. What a bugger!

[kjm1102]

I've discovered that the ulp will read gpio4 correctly if cause!=wakeup but not otherwise. Also if I remove the deepsleep (so that the cause is always hardreset) then the ulp reports gpio4 correctly on the first cycle then 4096 subsequently. I'm sure the universe is shouting at me but I'm not getting the message. Do these results give you any clues as to what's going on?

[wnienhaus]

The 4096 will be the 0x1000 you are setting just before ulp.run(..). So when you see that it should mean the ULP has not yet managed to store (overwrite) anything into the data variable.

Or that something overwrote the data variable with 0x1000 again, but in your last code the setting of 0x1000 always happens before the ulp.run() and only once on hardreset so I'll rule out this option.

So I wonder if this is a timing issue. Maybe the main processor manages to read the memory already before the ULP started properly and ran its code. What if you add a sleep of a few milliseconds (>50ms to be sure) after the ulp.run() to give the ULP time to start?

This is only a guess and I'm not very sure of it because a by the time the first deepsleep ends the ULP must have definitely started, but might be worth trying anyway.

[wnienhaus]

Btw when you say

if I remove the deepsleep (so that the cause is always hardreset) then the ulp reports gpio4 correctly on the first cycle then 4096 subsequently

what is a cycle? Do you let it start (which assembles and loads the ULP code) and see the output of the print statements and then you manually press reset each time to start the next cycle?

If so, I fid it very surprising that you get the correct GPIO value on the first cycle and not afterwards. Because all hard resets should be the same.

Or is the first cycle actually a power up? It would also surprise me that the power up and hard reset behave differently in this case - but something must be different between your first cycle and subsequent ones.

Or did you add some kind of loop around part of the code and cycles refer to the iterations of the loop?

[kjm1102]

The delay didn't help, I didn't think it would since it's in the code that runs when cause!=wakeup & the failure to update the gpio4 input value is when the cause==wakeup.

Rather than download the code into the esp32 after each change I just run it from the repl, so a cycle is each time I run it again. I've checked & the behaviour is the same as if I'd downloaded & let it run repeatedly. The only difference is a download runs automatically but with the repl the next cycle occurs when I get a new idea to try out & click 'run' again.

My first cycle is always after a powerup (which is reported as a hardreset). I've been removing/reapplying power because pressing the reset button causes the board to behave the same as pressing the boot button (ie it goes into flashing mode).

Which upython are you running & on what board? I'm running release='1.17.0' on a devkit1 (110k ram, 2m flash). Maybe if I try the same upython version & board as you I can get your results?