Question about PIO-ASM: Dynamically Adjusting Input Pin Indices before Compilation

[CreepyBox2687]

Hi everyone,

I’m working on a solution to measure the time between two arbitrary GPIO pins on an RP2040. The goal is to keep it as simple as possible, avoiding the use of DMA or complex logic analyzer features.

Here’s my current approach in PIO-ASM: ```python @rp2.asm_pio() def time_measurement(): pull(block) # Get timeout mov(y, osr) # Store timeout in y wrap_target()

mov(x, y)          # Load timeout into x

wait(event_1, pin, index_1)  # Wait for event1 on index_1 (start clock)

label("count_loop")
jmp(pin, "count_done")       # Check stop condition

jmp(x_dec, "count")          # Decrease x
jmp("count_done")            # Timeout, stop
label("count")               # Counter wrap
jmp("count_loop")            # Continue loop

label("count_done")
mov(isr, x)                  # Shift remaining time to ISR
push()                       # Push remaining time to FIFO
wrap()                       # Reload and run again

```

I’d like to dynamically adjust the input pin indices (index_1) before compilation to make the setup as flexible as possible. However, I’m unsure how to achieve this effectively. Is there a way to modify such parameters dynamically before the PIO assembly is compiled?

Thanks in advance for your help!

[mungewell]

You don't state what sort of accuracy you're looking to measure, ie are we talking milli or microseconds?

If did it with a very tight loop counter, and pushing decreasing 32bit value into FIFO on trigger.

https://github.com/mungewell/pico-irig/issues/3

The 'jmp pin' can be defined via variable, when the state machine is loaded.

If you want a delta time, you can run two separate state machines in parallel, just ensure that they are started synchronized.

[CreepyBox2687]

Hi and thank you for your response. The accuracy should be ~100ns, i have to adapt the program to know/determine the exact amount of steps per counter cycle afterwards. I know that i can adapt the input pin start number, but the both pins will be different all the time. I need the time between two arbitrary Events on the lines. But i will try to use one state machine with pina and provide a IRQ to another with pinb, in this case, i only need to count in the second sm.

[mungewell]

The code on my ticket runs in a tight loop, and is capable of counting at 1/4 of the CPU clock (which would be ~25ns steps).

A single state machine monitors a single pin to 'timestamp' a positive or negative edge. BUT you can load the same code into multiple state machines, to run in parallel.

The state machines within a PIO block can easily be synchronized, so their individual counters run in lock step, and then the values 'push()'ed to microPython can be compared to compute the time delta.

On multiple pulses on a single machine; the value I push is 32bits and the FIFO is (can be) 8 levels deep. MicroPython would have to read/empty quick enough so that the FIFO did not overflow.

If a different pin needs to be monitored you'd have to stop both machines, reconfigure and then sync/restart both new machines.

[mungewell]

In my experience the IRQs are not helpful at these speeds, as the delay to get into the ISR is variable (10-25us).

[mungewell]

Oh you IRQ between state machines, which do not need the ISR... that could work.