Question about DMA

[fma38]

Hi!

I started to write a stepper module which handles accelerations in both moveto and jog modes. At first, I used a simple PWM, and an ISR to regularly compute the speed and position on the fly tp update the PWM, but it was not very accurate, and I often overshoot the position in moveto mode.

I then used a PIO and a DMA to pre-compute the entire pulses sequence, which works fine (I still have a little overshoot, but I guess the problem is in my acceleration generator). You can see the discussion and the help I got to implement this here: https://github.com/orgs/micropython/discussions/12448. I repost the main code here:

@staticmethod
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW)
def _pioPulses():
    # In the routine, ISR contains pulseFreq, and Y nbPulses.
    # X is used as pulseFreq counter. Y is decremented until 0.

    # Get input values (pulseFreq, nbPulses)
    # Blocking
    pull().side(0)  # get pulseFreq from FIFO; set output LOW
    mov(isr, osr)   # store pulseFreq to ISR
    pull()          # get nbPulses from FIFO
    mov(y, osr)     # store nbPulses to Y

    # Start pulsing (square)
    label("start")
    
    mov(x, isr).side(1)      # put previously saved pulseFreq to counter; set output HIGH
    label("loopHigh")
    jmp(x_dec, "loopHigh")   # decrement pulseFreq counter and loop if non 0
    
    mov(x, isr).side(0)      # put previously saved pulseFreq to counter; set output LOW
    label("loopLow")
    jmp(x_dec, "loopLow")    # decrement pulseFreq counter and loop if non 0
    
    jmp(y_dec, "start")      # loop on nbPulses

@property
def value(self):
    self._sm.exec("push()")  # push ISR (which contains current pulseFreq value) to the FIFO
    return self._sm.get()    # return FIFO content

My first problem is that getting the speed on the fly messes up the DMA: the pulses are not sent correctly, and the DMA seems to stop too soon. Any idea what can happen here?

[fma38]

I should RTFM :o/

3.4.6.2. Operation
  "Push the contents of the ISR into the RX FIFO, as a single 32-bit word. Clear ISR to all-zeroes."

[fma38]

Here is a version which seems to work fine:

@staticmethod
@rp2.asm_pio(sideset_init=rp2.PIO.OUT_LOW)
def _pioPulses():
    """
    
    In the main loop, OSR contains pulseFreq, and Y nbPulses.
    X is used as pulseFreq counter. Y is decremented until 0.
    """
    
    # Get input values (pulseFreq, nbPulses)
    # Blocking
    pull().side(0)  # get pulseFreq from FIFO; set output LOW
    mov(x, osr)     # store pulseFreq to ISR
    pull()          # get nbPulses from FIFO
    mov(y, osr)     # store nbPulses to Y
    mov(osr, x)     # store back pulseFreq to OSR

    # Start pulsing (square)
    label("start")
    
    mov(x, osr).side(1)      # put previously saved pulseFreq to counter; set output HIGH
    label("loopHigh")
    jmp(x_dec, "loopHigh")   # decrement pulseFreq counter and loop if non 0
    
    mov(x, osr).side(0)      # put previously saved pulseFreq to counter; set output LOW
    label("loopLow")
    jmp(x_dec, "loopLow")    # decrement pulseFreq counter and loop if non 0
    
    jmp(y_dec, "start")      # loop on nbPulses

@property
def value(self):
    """
    """
    self._sm.exec("mov(isr, osr)")  # store OSR (containing pulseFreq) to ISR
    self._sm.exec("push()")         # push ISR to the FIFO

    return self._sm.get()

[robert-hh]

Looks good.

[fma38]

I'm now working on the stop command: I need to cancel the DMA, restart the State Machine, ensure the output is off, send a new deceleration sequence... Fun ;o)

[fma38]

When the DMA sends values to the PIO FIFO, is it possible to use shorts (16 bits), or should I always use words (32 bits)?

[robert-hh]

Just try. The PIO usxes 32 bit registers. It may be that when feeding with 16 bit, the other half is undefined, or 0.

[rkompass]

It's possible. You may set your DMA transfer size to 32 (DSIZE = 2), 16 (DSIZE=1) or 8 bits (DSIZE=0).
It may be set depending on the PUSH_THRESH/PULL_THRESH of the PIO state machine setting if you like. But that's your own decision/responsibility.

Example code:

# ---- a function that extracts data from an object that might be source (src=1) or destination (src=0) in the DMA transfer -----
#
#  arguments:
#     obj:     object
#     src:     1 if object is source, or 0 if destination
#  returns:
#     addr:    starting address of transfer                                                             *  always returned
#     incr:    address increment (0 for no, 1 for increment)                                            *  always returned
#     count:   number of data transfers (None if not specified)                                         -  may be None
#     dsize:   data transfer size: 0 for 8 bits, 1 for 16, 2 for 32 bits (None if not specified)        -  may be None
#                  note that dsize may be 3 (64 bits: that has to be corrected later by doubling the count)
#     dreq:    data request number, if the object synchronizes its transfers by that, else None         -  may be None
#
def par_StateMachine(obj, src):
    if not isinstance(obj, StateMachine):
        return None
    #  print('recognized StateMachine:', obj)    # debugging
    sm = int(str(obj).split(')')[0].split('(')[1])
    if sm < 4:                   # PIO 0
        pio = 0x50200000         # PIO0_BASE
        dreq = sm + 4*src        # 0..3 if dest, 4..7 if source
    else:                        # PIO1
        sm %= 4
        pio = 0x50300000         # PIO1_BASE
        dreq = sm + 8 + 4*src    # 8..11 if dest, 12..15 if source
    addr = pio + 0x10 + 0x10*src + 4*sm  # PIO_TXF0 / PIO_RXF0 depending on src
    bits = (machine.mem32[pio+0xd0+24*sm] >> (20 if src else 25)) & 0x1f  # extract PUSH_THRESH if source else PULL_THRESH: 
    if bits > 16 or bits == 0:    # number of bits shifted to ISR/from OSR before autopush/autopull or cond. push/pull; 0 for value 32
        dsize = 2
    elif bits > 8:
        dsize = 1
    else:
        dsize = 0
    return addr, 0, None, dsize, dreq

[fma38]

If I set pull_tresh=16, and ask the DMA to send a buffer of array('I'), with data_size=1, it does not work: it seems that the SM code freezee on the pull()...

[rkompass]

pull_tresh=16 would correspond to dsize=1, but with Micropython array('I') is 32 bits.

To debug you may use self._sm.exec("pull()"), _sm.exec("mov(isr, osr)") and self._sm.exec("push()") to examine the values that are actually there, perhaps.

[rkompass]

As your PIO program uses pull() programmatically i.e. there is no AUTOPULL pull_tresh should not be relevant.

[rkompass]

There is a possibility that the PIO pulled just the zeros in the higher 2 bytes of each 4-byte word in your 32bit array...

[fma38]

My bad, I was using 'H'...
Ok, so, I have to use 32 bits arrays. It works fine this way, but it uses twice the memory I really need.
BTW, I already tried to write a simple example as you suggest, pull/mov/push, and trigger an IRQ to read-back what the DMA is feeding, but I get garbage in all cases, even with the 'I' / 32bits... Strange.