RP2: Fragment of an onboard PIO debugger

[rkompass]

I want to share an attempt at an onboard PIO debugger for the RP2 Pico.

Basically I answered my own question whether it is possible to read out the PIO registers including the RX and TX FIFOs in a non-destructive manner.
Answer: It is.
Although the readout is destructive in that it modifies the RX_FIFO and the ISR register at least, these and other registers may be written back again so that in the end the PIO has the same state as before.
At least this is what I hope to have achieved.
If you find that this is not the case, please tell here.

The PIO has to be inactive of course, to not interfere in it's operation.

I have a very simple demonstration appended.
Feedback would be nice, of course.
Other data, like the PC for example, may be read out from the RP2s PIO configuration and operation registers in a more direct manner.
A complete debugger should be able to do more of course: E.g. display the PIO program in a meaningful way (practically this would require sort of a PIO disassembler) and go at least single step through the instructions.

from time import sleep_ms
from rp2 import PIO, StateMachine, asm_pio

@asm_pio(push_thresh=32, in_shiftdir=PIO.SHIFT_LEFT, out_shiftdir=PIO.SHIFT_RIGHT)
def sm_gen():
    set(x, 0)
    label("incr")    # increment x by inverting, decrementing and inverting
    mov(x, invert(x))      [31]
    jmp(x_dec, "here")     [31]
    label("here")
    mov(x, invert(x))      [31]   # 32 x 25 = 800 instructions per loop
    mov(isr, x)            [31]   # could run with 2000 Hz: 
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    nop()                  [31]
    push(noblock)          [31]   #    0.4 s per push()  at 2000 Hz
    jmp("incr")            [31]


#  readout(sm) returns a dict containing 'rx_fifo', 'tx_fifo', 'isr, 'osr', 'x', 'y', 'pins', 'status'
#
#  state machine sm has to be inactive, otherwise the readout interferes with changes due to its operation
# 
def readout(sm):    
    res = {}
    res['rx_fifo'] = []                    # read and save all of rx_fifo
    for _ in range(sm.rx_fifo()):
        res['rx_fifo'].append(sm.get())
    sm.exec('push(noblock)')               # read isr
    res['isr'] = sm.get()
    sm.exec('mov(isr, osr)')               # read osr
    sm.exec('push(noblock)')
    res['osr'] = sm.get()
    sm.exec('mov(isr, x)')                 # read x
    sm.exec('push(noblock)')
    res['x'] = sm.get()
    sm.exec('mov(isr, y)')                 # read y
    sm.exec('push(noblock)')
    res['y'] = sm.get()
    sm.exec('mov(isr, pins)')              # read pins
    sm.exec('push(noblock)')
    res['pins'] = sm.get()
    sm.exec('mov(isr, status)')            # read status
    sm.exec('push(noblock)')
    res['status'] = sm.get()
    res['tx_fifo'] = []                    # read tx_fifo
    for _ in range(sm.tx_fifo()):
        sm.exec('pull(noblock)')
        sm.exec('mov(isr, osr)')
        sm.exec('push(noblock)')
        res['tx_fifo'].append(sm.get())
    for d in res['rx_fifo']:               # restore rx_fifo; uses isr, osr, tx_fifo
        sm.put(d)
        sm.exec('pull(noblock)')
        sm.exec('mov(isr, osr)')
        sm.exec('push(noblock)')
    sm.put(res['isr'])                     # restore isr; uses osr, tx_fifo
    sm.exec('pull(noblock)')
    sm.exec('mov(isr, osr)')
    sm.put(res['osr'])                     # restore osr; uses tx_fifo
    sm.exec('pull(noblock)')
    for d in res['tx_fifo']:               # restore tx_fifo
        sm.put(d)
    return res

def displ_sm_data(res):
    l = len(res['tx_fifo'])
    if l > 0:
        for i in range(l):
            d = res['tx_fifo'][i]
            print('tx_fifo[{:1d}]: 0x{:08X} | 0b {:08b} {:08b} {:08b} {:08b}'.format(
                i, d, d>>24, (d>>16)&0xff, (d>>8)&0xff, d&0xff))
    else:
        print('tx_fifo   : empty')
    l = len(res['rx_fifo'])
    if l > 0:
        for i in range(l):
            d = res['rx_fifo'][i]
            print('rx_fifo[{:01d}]: 0x{:08X} | 0b {:08b} {:08b} {:08b} {:08b}'.format(
                i, d, d>>24, (d>>16)&0xff, (d>>8)&0xff, d&0xff))
    else:
        print('rx_fifo   : empty')
    for r in ('isr', 'osr', 'x', 'y', 'pins', 'status'):
        d = res[r]
        print('{: <10s}: 0x{:08X} | 0b {:08b} {:08b} {:08b} {:08b}'.format(
            r, d, d>>24, (d>>16)&0xff, (d>>8)&0xff, d&0xff))


sm = StateMachine(0, sm_gen, freq=2000)
sm.active(1)
sleep_ms(200)

for i in range(10):
    sm.active(0)
    res=readout(sm)
    print('--------------------------------------------------')
    displ_sm_data(res)
    sm.active(1)
    sleep_ms(400)