How to create Programmable IO asm function for RPi pico in runtime

[SteKme]

Hi,

there is a well known decorator for asm pio code within the PY script, such as:

@asm_pio(sideset_init=PIO.OUT_LOW)
def pwm_prog():
pull
set(x, 31) [6]
etc..

What I need to achieve, though, is to assemble the asm function in runtime (need to modify this [6] - in this example - to pause for a correct number of cycles and I don't know exact number in advance as this depends on measurements provided by gpio ticking I measure when the script is started).

I thought of really ugly ways such as writing a new .py file with this function by the master script itself, importing it afterwards and then using, but hope there could be a better way to achieve this? Basically, instead of a function, providing a string with the code or whatever reasonable way?

Thank You so much,
Stepan

[dpgeorge]

You can assemble individual instructions like this:

>>> import rp2
>>> rp2.asm_pio_encode('pull()',1)
32928
>>> rp2.asm_pio_encode('set(x,31)[6]',1)
58943

But then you have to put them together in an array to pass to a StateMachine.

Probably easier to use exec, eg:

>>> exec('import rp2\n@rp2.asm_pio()\ndef f():\n pull()\n set(x,31)[6]', out:={})
>>> out
{'f': [array('H', [32928, 58943]), -1, -1, 4096, 0, None, None, None], 'rp2': <module 'rp2' from 'rp2.py'>}

[SteKme]

for me, exec() will probably work best... it's pretty close to the temp file and I hoped for something more elegant :) , but exec() should solve my situation easiest. Thank You!

[rkompass]

Sorry, this perhaps doubles (the other answer was not there when i wrote this), but perhaps this is a slightly other option:
Once the pio assembly code is processed the binary is accessible as an array.
Assume the short pio program:

@asm_pio(sideset_init=PIO.OUT_LOW)
def pwm_prog():
    pull(noblock)
    set(x, 31) [6]
    nop()      [2]

print(pwm_prog) outputs [array('H', [32896, 58943, 41538]), 29, -1, 1073750016, 0, None, None, 2]
where pwm_prog[0] is the array of binary codes.
bin(pwm_prog[0][1]) yields '0b1110011000111111' , the code for set(x, 31) [6] where according to the RPI2040 Datasheet pdf page 353 the highest bits 111 code the instruction (set), the next 6 bits 00110 the delay/sideset (including perhaps a bit to enable the sideset,
I assume that from these 00110 the first 0 is the enable (no side instruction) then 0 for sideset low, then 110 for delay 6)
then 001 for destination (x) and 11111 for data (31).
As it is an array you may write into it and modify the relevant bits as you need.
pwm_prog[0][1]=58942 changes the second instruction to set(x, 30) [6].
You would have to and-out the bits for the delay [6] and or-in the new value (I assume that is no problem for you).

Also you should perform sm = StateMachine(0, pwm_prog, in_base=pin) afterwards because this is necessary to load the instructions and the additional parameters into the pio registers.

[dpgeorge]

Yes, I like this option! You could even use rp2.asm_pio_encode(...) to assemble the modified instruction and store the result in pwm_prog[0][x].

[rkompass]

Like

delay = 3
pwm_prog[0][1]=rp2.asm_pio_encode('set(x, 31) [{:d}]'.format(delay),1)

Saves you the bit-fiddling :-)

[dpgeorge]

Just make sure you get the second (and optional third) arguments to asm_pio_encode correct (regarding the sideset encoding). Check the output of that function to make sure it's what you expect it to be.

[SteKme]

thanks so much!
Modding the compiled byte code would work to an extent, but I might need to add multiple NOPs when they're limited to [31] idle cycles, so ultimately this flexibility to build new asm code as a string and then compile it with exec() would work better for my specific case.

-- I really appreciate all the hints as others may find them better for their own uses!

[dpgeorge]

Here is another solution: put the asm_pio function inside another function and parameterise it. Eg here is the pio_1hz.py example modified so you can generate the PIO code with different settings:

import time
from machine import Pin
import rp2

def create_blinker(raise_irq, cycles):
    delay = (cycles // 2 - 8) // 32 - 2

    @rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
    def blink():
        # fmt: off
        # Cycles: 1 + 1 + 6 + 32 * (30 + 1) = 1000
        if raise_irq:
            irq(rel(0))
        set(pins, 1)
        set(x, 31)                  [6 - bool(raise_irq)]
        label("delay_high")
        nop()                       [delay]
        jmp(x_dec, "delay_high")

        # Cycles: 1 + 7 + 32 * (30 + 1) = 1000
        set(pins, 0)
        set(x, 31)                  [6]
        label("delay_low")
        nop()                       [delay]
        jmp(x_dec, "delay_low")
        # fmt: on

    return blink


# Create the StateMachine with the blink_1hz program, outputting on Pin(25).
sm = rp2.StateMachine(0, create_blinker(True, 2000), freq=2000, set_base=Pin(25))

# Set the IRQ handler to print the millisecond timestamp.
sm.irq(lambda p: print(time.ticks_ms()))

# Start the StateMachine.
sm.active(1)