Pi pico, micropython.asm_thumb: ADR Rd, <label> and LDR Rd, <label> not implemented?

[jc40h56]

Micropython Pico H version 1.20.0 using Thonny
I'm trying to set up Timer-based interrupts using @micropython.asm_thumb, but can't find a way to read the address of the interrupt handling code to put in the interrupt vector table.
It seems like LDR is not set up to work with < label > , and ADR is not implemented at all?

I'm new to this so maybe I'm missing something obvious?
Are there any tricks to get around this?
Thanks!

@micropython.asm_thumb
def test(r0):
    label(loop)
    ldr(r0, loop)

results in "SyntaxError: unsupported Thumb instruction 'ldr' with 2 arguments"

@micropython.asm_thumb
def test(r0):
    label(loop)
    adr(r0, loop)

SyntaxError: unsupported Thumb instruction 'adr' with 2 arguments

[scruss]

Suggested workarounds may be here: How to load 32 bit constant from assembler with @micropython.asm_thumb - MicroPython Forum (Archive)

[rkompass]

Hello @jc40h56,

as it seems you are interested in getting the address of the actual machine code of your asm_thumb function this may help you:

@micropython.viper
def rbit16_vip(v: int) -> int:
    v = (v & 0x00ff) << 8 | (v & 0xff00) >> 8
    v = (v & 0x0f0f) << 4 | (v & 0xf0f0) >> 4
    v = (v & 0x3333) << 2 | (v & 0xcccc) >> 2
    return (v & 0x5555) << 1 | (v & 0xaaaa) >> 1

def inspect(f, nbytes=16):
    import machine
    import array
    import ubinascii
    @micropython.asm_thumb
    def dummy1():
        pass
    @micropython.viper
    def dummy2() -> int:
        return 0
    if type(f) != type(dummy1) and type(f) != type(dummy2):
        raise ValueError('expecting an inline-assembler or viper function')
    baddr = bytes(array.array('O', [f]))
    addr = int.from_bytes(baddr, 'little')
    print('function object at: 0x%08x' % addr)
    print('number of args: %u' % machine.mem32[addr + 4])
    code_addr = machine.mem32[addr + 8]
    print('machine code at: 0x%08x' % code_addr)  # seems to fit even with viper : code begins with 'FE B5' and ends with 'FE BD'
    print('-- code --')
    for i in range(nbytes):
        print('%02x' % machine.mem8[code_addr + i], end='')
    print('\n----------')

def test():
    inspect(rbit16_vip, 400)
test()

You may have to try other values in machine.mem32[addr + 8] and also the number of arguments seems to no longer work iirc.

To transplant this address into the interrupt vector table: There was an attempt of that already. Reportedly only partly successfull.
If you have success please let us know. Someday perhaps I will study all of it and try to make a really fast quadrature encoder from the insights.

[jc40h56]

Thanks for your answers @scruss and @rkompass !
I think I have to catch up on some of the basic workings of machine code to get my head around this. Will get back when/if there's progress

[jc40h56]

Just to report back that I got timer interrupts working using @micropython.asm_thumb thanks to your tips here
I found the addressof() described 1.2.1 here useful to exchange data.
Noted that I couldn't get branching ie bl(label) in the interrupt routine to work (worked otherwise).
Also the time function like time.sleep_us() in python hang. Which maybe is not surprising since it likely uses the same timer interrupt?

[samneggs]

@rkompass This is very cool. You wouldn't happen to expand this code into a disassembler?
Also, the assembly functions work but the viper functions seem to be giving me strange results. Have you tested with MicroPython v21?

[rkompass]

To give due credit, the core of the above code is from @dhylands (didn't hear of him for a while, hope he is doing well).
As the details used are not documented, things may change any time. I had success with viper then, did not try it with latest MP versions.

Btw. I just happened to do a disassembler ... for the RP2 PIO =:-) - as another fragment for a PIO debugger.
Next fragment will have to be translating this into MP.

An ARM disassembler would be nice of course. If you find a very compact piece of code that does that in Python or, perhaps another clear language, we might try to port. If it's 10+ files/pieces of code referencing each other I'm out - feeling too old / not motivated.

[peterhinch]

@jc40h56 A random thought.

An ISR's return value is immaterial when run in response to an interrupt. I would guess that if you wrote your ISR so that it returned its own address, this wouldn't affect its runtime behaviour. The first instruction copies R15 (the PC) to another register (say R8). The last instruction copies R8 to R0 (the return value). So your Python code runs the ISR once to establish its location. Note this re using a suitable type hint.

[jc40h56]

That's a good idea, thanks!

[peterhinch]

For context the inline assembler supports a data assembler directive allowing arbitrary data to be stored. Sadly it is almost useless. In typical use you would define a label then issue data statements. Unfortunately there is no way to determine the address defined by the label, so you can't write code to access the data.

Many years ago I submitted a PR to fix this but it was never accepted - probably because it was something of a hack.

[rkompass]

Hello Peter @peterhinch,

do you have a link to your PR?
Storing data in the data assembler directive is desired for having the ability to run assembler ISRs that somehow deliver a result. Which hopefully are faster than MP ISRs. I assume you had this in mind too.

I used the above method of bytes(array.array('O', [f])) for function f to get access to these data and then programmed a quadrature encoder by that (code below).
What's now missing is a way to circumvent the rather slow MP machinery to decide which ISR is to be run and starting the ISR.
I could imagine having a header in the assembler ISR that evaluates whether the respective pins are changed and, if not, branch to the ordinary MP handling function - that is to the original address in the interrupt vector table.
But even with that being solved it also would require to set the priority of GPIO interrupts above all the other normal interrupts.
Perhaps we can solve that together.
Iirc having the ability to run assember ISRs was once on the todo list for MP.

The quadrature encoder code (, tested last year):

# Micropython quadrature encoder for RP2040 in assembler, based on state table 
#
# Copyright (c) 2022 Raul Kompass
# Released under the MIT License (MIT) - see LICENSE file
#
# The assembler code saves its yx_old, pos and err values within a free space (many data(4, 0x00000000)) in itself,
#   at separate positions for pin pairs 0/1, 2/3, 4/5, ... .

from machine import Pin, mem8, mem32
from array import array
from time import sleep_ms

class QEnc_IntStAsm_4:
    def __init__(self, pins):
        if not isinstance(pins, (tuple, list)) or len(pins) != 2:
            raise ValueError('pair of 2 pins required')
        pn0 = int(str(pins[0]).split(')')[0].split('(')[1].split(',')[0])  # extract number of pin from string representation
        pn1 = int(str(pins[1]).split(')')[0].split('(')[1].split(',')[0])  #    - -  " - -
        if abs(pn0-pn1) != 1:
            raise ValueError('2 successive pins required')
        self.pin_base = min(pn0, pn1)
        if self.pin_base % 1:
            raise ValueError('lower pin number must be even')
        self.pinX = pins[0] if pn0 < pn1 else pins[1]
        self.pinY = pins[1] if pn0 < pn1 else pins[0]
        baddr = bytes(array('O', [self.asm2040_callb]))  # a little magic to access the assember byte code, borrowed from
        addr = int.from_bytes(baddr, 'little')         # https://github.com/dhylands/upy-examples/blob/master/extract_byte_code.py
        self.pos_addr = mem32[addr + 8] + 0x30 + self.pin_base*2   # address of position 32 bit word in asm2040_callb(r0) function
        self.yx_addr = mem32[addr+8] + 0x20 + self.pin_base//2
        self.reset()
        self.resume()

    @staticmethod  # The assembler code exists independently from class instance.
    @micropython.asm_thumb
    def asm2040_callb(r0):     # r0 is the pin id:  id(pinX)
        ldr(r3, [r0, 4])       # r3 is pin_number now
        lsr(r3, r3, 1)         # correct pin numbers by deleting bit 0: 6 and 7 -> 6, 8 and 9 -> 8  (round to lower even integer).
        lsl(r3, r3, 1)         # r3 = pin base
        data(2, 0x4d00)        # ldr  r5, [pc, #0]  load r5 with data following the branch (0x4e00: ldr  r6, [pc, #0])
        b(HERE0)
        data(4, 0x1b8d72e4)    # r5 = 0b00011011100011010111001011100100, the state table in 32 bits
        label(HERE0)
        mov(r6, 0xd0)          # construct gpio's reading address (= 0xd0 << 24 + 4)
        lsl(r6, r6, 24)
        ldr(r2,[r6, 4])        # read gpio's from 0xd0000004
        lsr(r2, r3)            # shift gpio's by pin base to right
        mov(r4, 3)             # r4 = 3
        and_(r2, r4)           # r2 = yx
        mov(r6, r15)           # r6 = start of below storage
        b(HERE1)
        data(4, 0x00000000)    # yx_old pins  0/1  ..  6/7 , accessed as bytes
        data(4, 0x00000000)    # yx_old pins  8/9  .. 14/15
        data(4, 0x00000000)    # yx_old pins 16/17 .. 22/23
        data(4, 0x00000000)    # yx_old pins 24/25, 26/27
        data(4, 0x00000000)    # pos  pins 0/1 initial value , accessed as 32-bit words
        data(4, 0x00000000)    # pos  pins 2/3 initial value
        data(4, 0x00000000)    # pos  pins 4/5 initial value
        data(4, 0x00000000)    # pos  pins 6/7 initial value
        data(4, 0x00000000)    # pos  pins 8/9 initial value
        data(4, 0x00000000)    # pos  pins 10/11 initial value
        data(4, 0x00000000)    # pos  pins 12/13 initial value
        data(4, 0x00000000)    # pos  pins 14/15 initial value
        data(4, 0x00000000)    # pos  pins 16/17 initial value
        data(4, 0x00000000)    # pos  pins 18/19 initial value
        data(4, 0x00000000)    # pos  pins 20/21 initial value
        data(4, 0x00000000)    # pos  pins 22/23 initial value
        data(4, 0x00000000)    # pos  pins 24/25 initial value
        data(4, 0x00000000)    # pos  pins 26/27 initial value
        data(4, 0x00000000)    # errors  pins 0/1 initial value
        data(4, 0x00000000)    # errors  pins 2/3 initial value
        data(4, 0x00000000)    # errors  pins 4/5 initial value
        data(4, 0x00000000)    # errors  pins 6/7 initial value
        data(4, 0x00000000)    # errors  pins 8/9 initial value
        data(4, 0x00000000)    # errors  pins 10/11 initial value
        data(4, 0x00000000)    # errors  pins 12/13 initial value
        data(4, 0x00000000)    # errors  pins 14/15 initial value
        data(4, 0x00000000)    # errors  pins 16/17 initial value
        data(4, 0x00000000)    # errors  pins 18/19 initial value
        data(4, 0x00000000)    # errors  pins 20/21 initial value
        data(4, 0x00000000)    # errors  pins 22/23 initial value
        data(4, 0x00000000)    # errors  pins 24/25 initial value
        data(4, 0x00000000)    # errors  pins 26/27 initial value
        label(HERE1)
        mov(r1, r6)
        lsr(r3, r3, 1)         # r3 = half pin number
        add(r1, r1, r3)        # byte address of yx_old is r6 + pin_base/2   (every pair of pins has its byte)
        ldrb(r0,[r1, 0])       # r0 = yx_old
        strb(r2,[r1, 0])       # yx_old = yx        
        lsl(r0, r0, 3)         # r0 = yx_old*8
        lsr(r5, r0)            # r5 >>= (yx_old*8), the state table is reduced to the 8 bits depending on actual yx
        lsl(r2, r2, 1)         # r2 = 2*yx
        lsr(r5, r2)
        and_(r5, r4)           # r5 >>= 2*yx & 3, this is the result: 0 -> nothing, 1-> forward, 2-> backward, 3-> error
        add(r6, 16)            # r6 now points to   start of pos table
        lsl(r3, r3, 2)         # r3 = 4 * half pin number
        add(r6, r6, r3)        # r6 now points to pos of relevant pin pair
        ldr(r2,[r6, 0])        # r2 = pos
        cmp(r5, 1)
        bne(NEXT0)
        add(r2, 1)             # forward: pos += 1
        label(NEXT0)
        cmp(r5, 2)
        bne(NEXT1)
        sub(r2, 1)             # backward: pos -= 1
        label(NEXT1)
        str(r2,[r6, 0])        # store resulting pos = pos +/- 1
        add(r6, 56)            # r6 now points to errors of relevant pin pair
        cmp(r5, 3)
        bne(NEXT2)
        ldr(r1,[r6, 0])        # r1 = errors
        add(r1, 1)
        str(r1,[r6, 0])        # errors = errors + 1
        label(NEXT2)

    def read(self):
        return mem32[self.pos_addr], mem32[self.pos_addr+56]    # position, errors

    def pause(self):
        self.pinX.irq(trigger=0)
        self.pinY.irq(trigger=0)

    def resume(self):
        mem8[self.yx_addr] = self.pinY()<<1 | self.pinX()   # put old yx values in storage for error-free start        
        try:
            self.pinX.irq(self.asm2040_callb, hard=True)
            self.pinY.irq(self.asm2040_callb, hard=True)
            self.t_int='hard'
        except TypeError:
            self.pinX.irq(self.asm2040_callb)
            self.pinY.irq(self.asm2040_callb)
            self.t_int='soft'

    def reset(self):
        mem8[self.yx_addr] = self.pinY()<<1 | self.pinX()   # put old yx values in storage for error-free continuation        
        mem32[self.pos_addr] = 0     # reset position
        mem32[self.pos_addr+56] = 0  # reset error number

    def deinit(self):
        try:
            self.pinX.irq(None)
        except:
            pass
        try:
            self.pinY.irq(None)
        except:
            pass

# # ---------------- for testing ------------------------
# from utime import sleep_ms
# pinX = Pin(16, Pin.IN, Pin.PULL_UP)   # for testing by hand: reactivate this commented section and
# pinY = Pin(17, Pin.IN, Pin.PULL_UP)   #   put switches against GND to both Pin16 and Pin17
# 
# qenc = QEnc_IntStAsm_4((pinX, pinY))
# 
# for i in range(100):
#     pos = qenc.read()
#     print('x:', pos)
#     sleep_ms(100)
# qenc.pause()
# print('---- paused ---')
# sleep_ms(2000)
# qenc.resume()
# print('--- resumed ---')
# for i in range(100):
#     pos = qenc.read()
#     print('x:', pos)
#     sleep_ms(100)
# # -------------------------------------------------------

[peterhinch]

do you have a link to your PR?

#1192

I assume you had this in mind too.

I never investigated writing ISR's in Assembler - it's long struck me as an interesting idea, but I've never had a requirement.

I'm surprised you have found it necessary for a quadrature encoder. You might like to look at this solution (docs, code). The ISR's run in 36μs (dependent on platform).
[EDIT]
The other thing to bear in mind is the distinction between ISR runtime and latency. Latency can exceed runtime by orders of magnitude on platforms like ESP32. On the Pico, hard ISR latency should be short, but you still need to consider the possibility that contact bounce edges may occur in the latency period. This can be prevented with hardware pre-conditioning of the encoder signals.

[rkompass]

I'm surprised you have found it necessary for a quadrature encoder.

Not really. I was rather interested in trying out what's possible going to the limits. This is still of interest, however has not a that high priority for me now. Your code looks fine.