exiting a state machine

[Prakhar005]

Hello,

I am implementing a JTAG state machine by means of PIO in micropython. From my limited understanding of PIO, I understand that the state machine wraps back to its initial state and continues indefinitely. However, I would like the state machine to exit and return to the main program once it has completed one loop of the state machine. Is there any systematic way of doing so? Thanks for the help! :)

[peterhinch]

When you say

I would like the state machine to exit and return to the main program

the state machine runs in the background independently of the main program. The main program will only pause waiting for input from the SM if you write it that way. Likewise you can write the SM code so that it waits for an external event such as a pin change. All this is under your control :)

[Prakhar005]

Thank you very much for your reply! That makes sense. What would be the way to create an event in the SM such that it exits and returns to the main program. I would not Iike to base it on any pin change event. Thank you once again for the help! :)

[peterhinch]

I'm not sure what you mean by "exits and returns to the main program". The SM and the main program run concurrently. This is true concurrency: the SM runs completely independently. You could program a SM to pulse a pin at 10KHz and it would do this with high accuracy regardless of any behaviour of your main program. Of course, this is rarely what you want: most applications need some synchronisation between the SM and the main program, but any synchronisation is imposed by your code. For example you can make the SM pause if the FIFOs become full/empty and you can make the main program pause by issuing a get before the input FIFO has any data.

[Prakhar005]

Thank you for your reply and it was very helpful in enhancing my understanding of pico operations. I am curious about making the SM pause by imposing a condition from the main program. Lets say my code is structured as follows:

@asm_pio(out_init, set_init)
def state_func():

% implement state machine logic here

sm = StateMachine(0, state_func, freq=1000, out_base, set_base)
sm.active(1)
time.sleep(5)
sm.active(0)

Where do I make the check for RX FIFO being full and also how do I use the "get" command to do so? I did not find any systematic examples for using "get" unfortunately. Thank you once again! :)

[rkompass]

To halt the SM from inside programmatically you may use the wait instruction. You may wait for an IRQ e.g. in the range 4..7 which is just a flag. Alternatively you may jump in place like

label(HALT)
jmp(HALT)

which is also only one instruction (the label does not count).
You have to understand that the SM then still runs (in parallel with python like @peterhinch explained), but it does nothing. To stop it running altogether you may execute SM.active(0) from your python program. You may start it anew from your python program with SM.restart() which still requires a SM.active(1) if you deactivated it beforehand.
Alternatively you may use some suitable instructions from python to get it back to start like

SM.exec("set(x, 3)")
SM.exec("mov(pc, x)")

which would let it jump to instruction number 3. This would work even if the SM was still active in the halt loop.
Note that for this you have to be aware, that in uPy the PIO programs fill the 32 instruction registers from the end. So in a PIO program with 10 instructions (labels are no instructions) the first would be number (and pc value) 22. So a 22 instead of 3 in the above example.

[Prakhar005]

Thank you very much! Your response was very helpful. The technique of jumping to a HALT label is very clever! I am quite curious about the IRQ method. How would the command look like? I am thinking something like this:

wait(1,irq,4)

Please let men know if this makes sense. Appreciate the help! :)

[rkompass]

Yes, I think you are right.
Of course you may also wait for such an irq flag to be reset to zero: wait(0,irq,4).
You would set the flag (to 1) with irq(4), set it back (to 0) i.e. clear it with irq(clear, 4) and you have the option to set it and halt and wait for another entity (other SM?, or externally by python - execution of SM.exec("irq(clear, 4)") ) with irq(block, 4).
So I conclude from reading the nice docs at https://docs.micropython.org/en/latest/library/rp2.html and the RP2 PDF manual. I haven't actually testet it.

[rkompass]

You my actually test this quite easily. You can make the state machine slow by running at e.g. 2000 Hz, perhaps also giving every instruction an additional delay which may be a large as 31 as long as you do not use sidesets. With 2000Hz and .delay(31) in every PIO instruction each instruction takes 16 milliseconds. That is slow enough to get and print out the instruction addresses. i.e. the pc values in python by

from machine import mem32
from time import sleep_ms
for _ in range(200):
    print(mem32(0x502000d4))
    sleep_ms(15)

use 0x503.. instead of 0x502.. for the second PIO block and 0ec, 104 or 11c instead of 0d4 for state machines number 1, 2 or 3 instead of 0.

Someone should write a PIO debugger in micropython....