class I2S – Inter-IC Sound-busprotocol

De I2S-klasse stuurt een Inter-IC Sound (I2S)-bus aan in controllermodus – de MCU genereert de bitklok (SCK) en de woordselectieklok (WS) en wisselt sampledata uit op de SD-lijn. De driver ondersteunt continue DMA op de achtergrond, zodat de Python-kant alleen de interne samplebuffer gevuld hoeft te houden. Peripheral-/ontvanger-alleen-modi worden niet ondersteund.

Beschikbaar op STM32 OpenMV-cams die een I2S-randapparaat bedraden en op de OpenMV Cam RT1062. Niet beschikbaar op de OpenMV Cam AE3 (alif-port).

I2S(2) op STM32 OpenMV-cams deelt zijn pinnen met SPI(2) – bitklok op P2 (SCK), woordselectie op P3 (NSS), en de seriële-datalijn volgt de SPI-conventie voor datarichting: TX gebruikt P0 (MOSI), RX gebruikt P1 (MISO).

Voorbeeld – uitvoer (TX). Construeer een TX-bus om een externe audio-DAC aan te sturen op 44,1 kHz, 16-bits monosamples, met een DMA-backingbuffer van 16384 bytes (16 KiB):

from machine import I2S, Pin

audio_out = I2S(
    2,
    sck=Pin("P2"), ws=Pin("P3"), sd=Pin("P0"),
    mode=I2S.TX,
    bits=16,
    format=I2S.MONO,
    rate=44100,
    ibuf=16384,
)

Voorbeeld – invoer (RX). Construeer een RX-bus die opneemt van een microfoon op 22,05 kHz, 32-bits stereo (links + rechts afgewisseld), met een DMA-backingbuffer van 16384 bytes (16 KiB):

from machine import I2S, Pin

audio_in = I2S(
    2,
    sck=Pin("P2"), ws=Pin("P3"), sd=Pin("P1"),
    mode=I2S.RX,
    bits=32,
    format=I2S.STEREO,
    rate=22050,
    ibuf=16384,
)

De overdrachtsmethoden kunnen op drie manieren worden gebruikt:

Blokkerend – write() en readinto() keren pas terug zodra de bewerking is voltooid:

num_written = audio_out.write(buf)   # blocks until buf is drained
num_read = audio_in.readinto(buf)    # blocks until buf is filled

Niet-blokkerend – installeer een callback met irq() en de overdrachtsmethoden keren onmiddellijk terug. De callback wordt uitgevoerd vanuit de MicroPython-scheduler wanneer de DMA de TX-buffer leegt of de RX-buffer vult:

audio_out.irq(i2s_callback)
num_written = audio_out.write(buf)   # returns immediately

audio_in.irq(i2s_callback)
num_read = audio_in.readinto(buf)    # returns immediately

asyncio – I2S is een stream en kan worden omhuld door asyncio.StreamReader / asyncio.StreamWriter

swriter = asyncio.StreamWriter(audio_out)
swriter.write(buf)
await swriter.drain()

sreader = asyncio.StreamReader(audio_in)
num_read = await sreader.readinto(buf)

Constructor

class machine.I2S(id: int, *, sck: Pin, ws: Pin, sd: Pin, mck: Pin | None = None, mode: int, bits: int, format: int, rate: int, ibuf: int)

Construeer een I2S-object met het opgegeven id:

  • id identificeert een bepaalde I2S-bus; dit is board- en port-specifiek

Keyword-only-parameters die op alle ports worden ondersteund:

  • sck is een pin-object voor de seriële kloklijn

  • ws is een pin-object voor de woordselectielijn

  • sd is een pin-object voor de seriële datalijn

  • mck is een pin-object voor de masterkloklijn; de masterklokfrequentie is samplefrequentie * 256

  • mode specificeert ontvangen of verzenden

  • bits specificeert de samplegrootte (bits), 16 of 32

  • format specificeert het kanaalformaat, STEREO of MONO

  • rate specificeert de audio-samplefrequentie (Hz); dit is de frequentie van het ws-signaal

  • ibuf specificeert de lengte van de interne buffer (bytes)

Op alle ports draait DMA continu op de achtergrond, waardoor gebruikersapplicaties andere bewerkingen kunnen uitvoeren terwijl sampledata wordt overgedragen tussen de interne buffer en het I2S-randapparaat. Het vergroten van de interne buffer kan de tijd verlengen waarin gebruikersapplicaties niet-I2S-bewerkingen kunnen uitvoeren vóór onderloop (bijv. de write-methode) of overloop (bijv. de readinto-methode).

Methoden

init(*, sck: Pin, ws: Pin, sd: Pin, mck: Pin | None = None, mode: int, bits: int, format: int, rate: int, ibuf: int) → None

zie Constructor voor beschrijvingen van de argumenten

deinit() → None

Deïnitialiseer de I2S-bus

readinto(buf: bytearray) → int

Lees audiosamples in de buffer die is opgegeven door buf. buf moet het bufferprotocol ondersteunen, zoals bytearray of array. De bytevolgorde van “buf” is little-endian. Bij Stereoformaat gaat het sample van het linkerkanaal vooraf aan dat van het rechterkanaal. Bij Monoformaat worden de sampledata van het linkerkanaal gebruikt. Geeft het aantal gelezen bytes terug

write(buf: bytes) → int

Schrijf audiosamples die zijn opgenomen in buf. buf moet het bufferprotocol ondersteunen, zoals bytearray of array. De bytevolgorde van “buf” is little-endian. Bij Stereoformaat gaat het sample van het linkerkanaal vooraf aan dat van het rechterkanaal. Bij Monoformaat worden de sampledata naar zowel het rechter- als het linkerkanaal geschreven. Geeft het aantal geschreven bytes terug

irq(handler: Callable[[I2S], None]) → None

Stel een callback in. handler wordt aangeroepen wanneer buf wordt geleegd (write-methode) of vol raakt (readinto-methode). Het instellen van een callback verandert de write- en readinto-methoden naar niet-blokkerende werking. handler wordt aangeroepen in de context van de MicroPython-scheduler.

static shift(*, buf: bytearray, bits: int, shift: int) → None

bitsgewijze verschuiving van alle samples in buf. bits specificeert de samplegrootte in bits. shift specificeert het aantal bits waarmee elk sample wordt verschoven. Positief voor verschuiving naar links, negatief voor verschuiving naar rechts. Doorgaans gebruikt voor volumeregeling. Elke bitverschuiving verandert het samplevolume met 6dB.

Constanten

RX: int

voor het initialiseren van de I2S-bus mode op ontvangen

TX: int

voor het initialiseren van de I2S-bus mode op verzenden

STEREO: int

voor het initialiseren van de I2S-bus format op stereo

MONO: int

voor het initialiseren van de I2S-bus format op mono