Regarding i2s_frame_map

[IFX-Anusha]

Hi,
Currently, We are working on the I2S module for the MicroPython PSoC6 port. It's in progress & I could read & write samples. But still, some issues are there regarding data reading into the buffer (I doubt that is related to the data format). I referred to the existing I2S module implementations for other ports. There i2s_frame_map[ ] is used for mapping the audio samples. Could anyone please explain in detail that? So that I could adapt the same to the PSoC6 port.

Regards,
Anusha

[miketeachman]

The i2s_frame_map[] table is used when reading samples from an ADC, such as a MEMS microphone. Every audio sample received from an ADC is 4 bytes. There is a left and right channel sample, so 8 bytes, which is called a frame. I2S hardware devices follow the I2S protocol. Left channel is sent first, most significant bit first, followed by the Right channel. But, the I2S peripherals internal to a microcontroller do not deliver data in the same byte order that is observed in the I2S protocol. The mapping table takes the bytes received from the I2S peripheral and reorders them to make the resulting byte order consistent for all ports in MicroPython. The consistent format in MicroPython is little endian byte ordering, left channel, then right channel. The mapping table converts the byte ordering that is received from the I2S peripheral to this consistent format.

Here is the mapping table for the STM32 port:

STATIC const int8_t i2s_frame_map[NUM_I2S_USER_FORMATS][I2S_RX_FRAME_SIZE_IN_BYTES] = {
    { 0,  1, -1, -1, -1, -1, -1, -1 },  // Mono, 16-bits
    { 2,  3,  0,  1, -1, -1, -1, -1 },  // Mono, 32-bits
    { 0,  1, -1, -1,  2,  3, -1, -1 },  // Stereo, 16-bits
    { 2,  3,  0,  1,  6,  7,  4,  5 },  // Stereo, 32-bits

Suppose that the I2S instance is configured for 32 bit mono. The 2nd line in the array contains the recipe for mapping the 8 bytes of stereo audio samples that come from the STM32 I2S peripheral to the desired format, 32 bit mono. Note that mono format uses only the left channel coming from the peripheral.

    { 2,  3,  0,  1, -1, -1, -1, -1 },  // Mono, 32-bits

Each of the 8 elements correspond to one of the 8 bytes in the audio sample received from the I2S peripheral. Consider the first element. The first element maps the first byte in the 8 byte stereo audio sample to the byte location in the resulting 32 bit mono sample (which is in little endian ordering). In this case, the number '2' indicates that the first byte coming from the I2S peripheral is mapped to the 3rd byte (indicated by the '2') in the 32 bit mono sample. '3' indicates that the 2nd byte from the I2S peripheral is mapped to the 4th byte in the 32 bit mono sample. The '-1's mark the bytes that are not used. In this case, the '-1's mark the right channel bytes which are not used for the specified mono format, which uses only the left channel audio sample.

The I2S peripherals in the various ports are not consistent in the sample byte ordering. The mapping tables are different for each port.

For the PSoC6 port you will need to build this map by understanding the byte order that is delivered from the PSoC6 I2S peripheral. The reference manual might provide some insight. If not, you might need to use an oscilloscope to monitor the serial I2S data flowing between the microcontroller and I2S hardware device, then compare that to the data that is delivered by the I2S peripheral.

Hope this helps to understand the mapping table.

[IFX-Anusha]

Thanks ! This is clear now.

I have other confusion regarding the different modes in I2S. According to the documentation all modes uses DMA for transfer right. Then how it exactly makes the difference between blocking & Non blocking since it's the DMA is doing the transfer & CPU is free from it.

[miketeachman]

There are two distinct sample data copy procedures happening in I2S. Consider the write(buf) method:

1. copy sample data from the application buffer,buf, into the I2S instance internal buffer,ibuf. This copy does not use DMA. For blocking mode, the full copy happens when the write() method is called. If ibuf becomes full during the copy, write() will block until adequate space becomes available in ibuf. For non-blocking mode, the copy is done incrementally using an IRQ (STM32, RP2, MIMXRT) or a FreeRTOS task (ESP32).
2. copy sample data from ibuf to the I2S peripheral that is internal to the microcontroller. This copy always uses DMA, for all I2S modes, for all ports.

You might consider not implementing non-blocking mode which can be a challenge. Using asyncio mode should be able to accomplish the same non-blocking goals. For asyncio mode, the asyncio scheduler performs the copy of sample data from buf to ibuf. If ibuf becomes full during the buf copy, the asyncio scheduler will run waiting co-routines.