Reading data into RX FIFO

[Prakhar005]

Hello,
I am implementing a state machine where I am reading data into the ISR register, one bit at a time in a loop. The code is as follows:

`
@asm_pio()
def state_function:

set(x,30) % set the counter for the loop

label("reading` loop")
in_(pins,1)
jmp(x_dec, reading loop" )

push(no block). % push the data into RX_FIFO

sm_read = StateMachine(0, freq=10000, in_base)
sm_read.active(1)
time.sleep(3)
sm_read.active(0)

`

As you can see after I read the data into ISR using "in_" command, I push the data into RX_FIFO. However, I am not clear on how to access the data stored in the RX_FIFO into an array in my main program. I looked up uPy documentation and it suggests using StateMachine.get() command . However, I am unsure where and how this should be implemented? Also, is there a way to clear the RX_FIFO once I have read from it? Thank you very much any help! :)

[rkompass]

First: use triple ` before and after code blocks to get multiline code formatting.

In sm_read = StateMachine(0, freq=10000, in_base) the program is missing, you correct to:
sm_read = StateMachine(0, state_function, freq=10000, in_base=pp) where pp is the pin number you would like to read from with your in_(pins, 1) instruction.

With this instruction the ISR gets filled and you push the ISR correctly after 30 such fills to the FIFO.
Your state machine runs your program cyclically for 3 seconds but the FIFO has only 4 words, so from the 5-th iteration onwards the pushed data are lost because the RX_FIFO is full.
The FIFO is cleared automatically by reading it. So you first query the number of words in the FIFO by sm_read.rx_fifo() and then do as many get() s. Afterwards the FIFO is empty or there are new words written just while you read it.
As an example I previously did a quadratic encoder with the PIO that pushed permanently the actual value nonblockingly into the FIFO program.

I then read that from python by:

    def read(self):
        for _ in range(self.sm_qenc.rx_fifo()):
            self.sm_qenc.get()
        n = self.sm_qenc.get()
        return n

In that example there is an additional get() from python that waits for the new, actual value (we are not interested in what the encoder value was when the FIFO was full but what its value is now).

[Prakhar005]

Thank you @rkompass for your response. It is really enlightening to learn about the nuances of Pico and micropython. (thanks for pointing out how to get the multiline coding format, :) I was struggling with it)

I have a few questions based on your response:

1. What is the size of the RX FIFO? Is it 32 bits? I could not find a clear description of it in the documentation. Sorry, if this is a silly question.
2. I wish to write two 32-bit data values to the RX FIFO. In case the size of RX FIFO is indeed 32 bits, then when I would try to write the second 32-bit data, it would not get written to the FIFO, since FIFO is already full. Is there a way to read the FIFO after the first 32-bit data has been written and then read the FIFO and then repeat the same for the second 32-bit data?

Also, where would you suggest to include the get command. Would it be after the time.sleep() command or before it?
Please let me know if I am missing something very obvious. Thank you once again for your help! :)

[rkompass]

1. RX_FIFO and TX_FIFO have 32 bit size. Silly question?: Only if you know where to look for information and don't use that.
   Looking at https://datasheets.raspberrypi.com/rp2040/rp2040-datasheet.pdf at page 309 it states "4×32-bit bus FIFO in each direction (TX/RX), reconfigurable as 8×32 in a single direction".
   This pdf is an important source of information (although not helpful at the beginner level), as sometimes you may understand the workings of something only if you study the registers that set a certain function. These registers also may reveal functionality that is not available in micropython and not reported in the micropython docs. Easier information resources are micropython docs and the RP2040 Python SDK.
   Best accessible imho are presentations like this. And example programs like here.
   I learnt it by seeing presentations like the above and also by copy-pasting the Github examples into Thonny and trying out and modifying.
2. If you write the second 32-bit word to the FIFO it is not full yet. Btw you may set the PIO RX_FIFO to 8 words if you do not need the TX_FIFO. You may write the 32-bit word (or less bits, if you like) up to 4 (or 8) times, then data get lost if you do push(noblock) more often; otherwise, if you push(block) then the PIO halts until the FIFO is read from the python side and thus new FIFO space automatically gets available.
   The thing is: The PIO may generate data very fast, faster than python may read them. It is up to you as programmer to decide how to deal with it: Write your PIO program so that it does not generate data very fast, or let it generate data fast and accept losing some of the data (perhaps you are only interested in the latest data, then you may clear the FIFO by reading the old data until you get new data). Or try to process data very fast, even from the python side. You may let a dma transfer data automatically from the PIO FIFO to a memory location, if you set it up properly. And then let your python program process the memory. But I would recommend to get acquainted with the PIO first.

[Prakhar005]

Thank you very much for sharing these resources! It is very helpful for me as a beginner to receive such guidance! :)
That makes a lot of sense about the size of RX/TX FIFOs. I will certainly work on ramping my knowledge of the PIO blocks well enough.
I was able to implement the read functionality and it worked well.

Thanks once again for your help! :)

[rkompass]

Nice. Good luck. Thanks for the feedback.