RP2040 I2S continuous generated waveform

[ruffrecords]

I am working on a Pico project which can generate a variety of continuous repeating waveforms for testing audio equipment (sine, square, triangle, white noise etc). It is easy enough to generate these in an array (or load them in from a library or SD card) but the part I am not sure about is how to set up I2S to continuously repeat the waveform without blocking. I have scoured Mike Teachman's examples but I am not confident that an i2s_callback() would be fast enough. As the I2S functionality is subject to Technical Review can I suggest an optional loop flag be useful for this kind of application?

Also, to avoid lots of heap activity I plan for there to be a single buffer for the waveform, some or all of which may be required for a particular waveform. Would the sensible thing to do be to pass a memory view of the required section of the array?

For information the signal is 16 bit mono at a sample rate of 80K/s. The lowest frequency to be generated is 10Hz which requires a 16,000 byte buffer

Cheers

Ian

[GitHubsSilverBullet]

Easy. Two DMA channels, triggering each other and both sending the array data to I2S.
At the end of each DMA transaction an interrupt is generated and the ISR resets the appropriate buffer address(es).
Done. Consumes almost no CPU cycles at all.

[GitHubsSilverBullet]

Exactly.
And once you've managed to do that, there's another way to do things. Without any interrupts, without spending even a single CPU cycle.
Just let the DMA stuff reconfigure themselves. Twists the brain at first, but it's also very satisfying when it runs.
And you still have 2×100% CPU remaining.

[ruffrecords]

That sounds particularly attractive but I have no idea how to achieve that in micropython.

Cheers

Ian

[GitHubsSilverBullet]

Two DMA channels.
The first one is configured as a ring buffer of one WORD size (4 Bytes), on each trigger only reading and writing one WORD. Always the same one, always writes to one register (READ ADR) of the other channel.
Therefore not needing any reconfiguration whatsoever. Then triggers that 2nd chained channel.
The 2nd channel writes the whole buffer to the target and - once finished – triggers the 1st, the ring buffer DMA again.
That closes the never ending circle.

[miketeachman]

@ruffrecords The existing I2S implementation should be able to do what you are seeking. Using asyncio would appear to be a suitable option of the 3 I2S mode (blocking, non-blocking, asyncio). Create one coroutine to continuously and repeatedly send the sample buffer using the asyncio write example as a guide. Than, create additional coroutines to manage whatever else the application needs to do.

@GitHubsSilverBullet your description of two chained DMA channels is how the C implementation of I2S works on the rp2 port. You can find the code here. To my eye there does not seem to be an advantage to coding DMA chaining in python with viper, asm, etc. Note: I am the author of the rp2 I2S implementation.

[GitHubsSilverBullet]

@miketeachman
What I showed/described was just a general information about how to feed data into peripherals without using the CPU. I didn't dissect that particular module in question.
Nevertheless, using the described DMA method is certainly the one with the least CPU power draw. (It's rather difficult to get below zero)