Memory usage question

[tteague]

We are trying to create a product using the RPI Pico (RP2040) that drives a stepper motor. During a single move gc must be disabled to avoid noticeable pauses in the stepping. Running the following script causes the board to crash with a MemoryError.

import gc
import micropython

gc.collect()
micropython.mem_info()
gc.disable()

foo = 2
for i in range(2000):
    foo = foo + foo

micropython.mem_info()
gc.collect()
micropython.mem_info()

Reducing the loop count enough to allow completion shows that the 1-block count and the free memory usage are proportional to the loop count. The final mem_info() shows that this memory is recoverable, and we have tried adding gc.collect calls periodically, but that causes a noticeable glitch that the marketing dept won't accept.

Is there anything that we can do to avoid this problem short of rewriting the project in C?

Thanks

[russhughes]

Each iteration creates new objects to hold the new values of i and foo. With GC turned off, reclaiming the memory used to store the old values is not possible. Have you looked at using the PIO to run the stepper motor?

[tteague]

It turns out that the computation (that is being simplified in the "foo" line is really computing the time in microseconds until the next pulse is due. This is to allow acceleration and deceleration. From what we could see of PIO, it doesn't lend itself that. Did we miss something?

[russhughes]

I think acceleration and deceleration would be difficult with the PIO, and an assembly or 'C' module would be easier.

[robert-hh]

If this line is just using time, then calling time.sleep_us() could be an alternative. The line foo = foo + foo is strange. The way it is set it computes 2**2000. On languages with limited size for integers this is no problem. With MicroPython and it's unlimited integer size it allocates new memory as soon as the value exceeds 2**30. So you could stop the memory allocation by writing it e.g. as:

foo = (foo + foo) & 0xfffffff

That forces the values to stay below 2**30, keeps them in a single word and still consumes time.

[jimmo]

Each iteration creates new objects to hold the new values of i and foo.

@russhughes Just to clarify -- this isn't correct. The for i in range() loop is optimised straight into bytecode and does not allocate. Ordinarily, the assignment to foo wouldn't allocate either, except as Robert says, we're dealing with enormous values for i. MicroPython will happily switch foo into a long integer, but these are heap-allocated.

[russhughes]

@jimmo Thanks, that makes more sense.

[tteague]

Not only does it make sense, but it looks like the clue we needed. By converting the acceleration/deceleration code to use integers only we should be able to keep the project in micropython. Thanks to all of you for the discussion.

[rkompass]

As for the PIO approach:
If you can to do the stepper logic in the PIO (which has been done several times according to a google search) then you may perhaps accelerate/decelerate by writing decreasing/increasing values to the relevant PIO clock divider register while the state machine is running. This assumes that only the speed of output signals has to be changed, not the ratio of time intervals involved.
Given this is the case, then you even may use DMA for writing a sequence of clock divider values to the PIO. A demonstration of this is my third DMA example rp2_dma_test3.py.
As the DMA transfer may be clocked internally only as slow as about 2000 Hz you will need about 8 kB (2000 * 4 for 32 bits) memory filled with precomputed clockdividers for every second of acceleration/deceleration. If this is too much then you may try to use a state machine just for the purpose of generating synchronization signals for the DMA at a lower frequency. I could help at that.