klass I2S – Inter-IC Sound-bussprotokoll¶

Klassen I2S driver en Inter-IC Sound-buss (I2S) i styrenhetsläge – MCU:n genererar bitklockan (SCK) och ordvalsklockan (WS) och utbyter sampeldata på SD-linjen. Drivrutinen stöder kontinuerlig DMA i bakgrunden, så Python-sidan behöver bara hålla den interna sampelbufferten matad. Lägen för enbart kringutrustning/mottagare stöds inte.

Tillgänglig på STM32 OpenMV-kameror som kopplar in en I2S-kringutrustning samt på OpenMV Cam RT1062. Exponeras inte på OpenMV Cam AE3 (alif-porten).

I2S(2) på STM32 OpenMV-kameror delar sina stift med SPI(2) – bitklocka på P2 (SCK), ordval på P3 (NSS), och den seriella datalinjen följer SPI:ns konvention för datariktning: TX använder P0 (MOSI), RX använder P1 (MISO).

Exempel – utgång (TX). Konstruera en TX-buss för att driva en extern ljud-DAC vid 44,1 kHz, 16-bitars monosampel, med en 16384-bytes (16 KiB) DMA-stödbuffert:

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,
)

Exempel – ingång (RX). Konstruera en RX-buss som fångar från en mikrofon vid 22,05 kHz, 32-bitars stereo (vänster + höger sammanflätat), med en 16384-bytes (16 KiB) DMA-stödbuffert:

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,
)

Överföringsmetoderna kan användas i tre stilar:

Blockerande – write() och readinto() returnerar först när operationen är klar:

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

Icke-blockerande – installera ett återanrop med irq(), så returnerar överföringsmetoderna omedelbart. Återanropet körs från MicroPython-schemaläggaren när DMA:n tömmer TX-bufferten eller fyller RX-bufferten:

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 är en ström och kan omslutas av 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)

Konstruktor¶

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)¶

Konstruera ett I2S-objekt med givet id:

id identifierar en viss I2S-buss; det är kort- och portspecifikt

Parametrar som endast anges med nyckelord och stöds på alla portar:

sck är ett stiftobjekt för den seriella klocklinjen

ws är ett stiftobjekt för ordvalslinjen

sd är ett stiftobjekt för den seriella datalinjen

mck är ett stiftobjekt för masterklocklinjen; masterklockans frekvens är samplingsfrekvens * 256

mode anger mottagning eller sändning

bits anger sampelstorlek (bitar), 16 eller 32

format anger kanalformat, STEREO eller MONO

rate anger ljudsamplingsfrekvens (Hz); detta är frekvensen för ws-signalen

ibuf anger intern buffertlängd (bytes)

På alla portar körs DMA kontinuerligt i bakgrunden och låter användarapplikationer utföra andra operationer medan sampeldata överförs mellan den interna bufferten och I2S-kringutrustningen. Att öka storleken på den interna bufferten kan öka den tid under vilken användarapplikationer kan utföra icke-I2S-operationer innan underflöde (t.ex. write-metoden) eller överflöde (t.ex. readinto-metoden).

Metoder¶

init(*, sck: Pin, ws: Pin, sd: Pin, mck: Pin | None = None, mode: int, bits: int, format: int, rate: int, ibuf: int) → None¶: se Konstruktor för beskrivningar av argument

deinit() → None¶: Avinitialisera I2S-bussen

readinto(buf: bytearray) → int¶: Läs ljudsampel in i bufferten som anges av buf. buf måste stödja buffertprotokollet, såsom bytearray eller array. Byteordningen för ”buf” är little-endian. För Stereo-format föregår vänster kanals sampel höger kanals sampel. För Mono-format används vänster kanals sampeldata. Returnerar antalet lästa bytes

write(buf: bytes) → int¶: Skriv ljudsampel som finns i buf. buf måste stödja buffertprotokollet, såsom bytearray eller array. Byteordningen för ”buf” är little-endian. För Stereo-format föregår vänster kanals sampel höger kanals sampel. För Mono-format skrivs sampeldatan till både höger och vänster kanal. Returnerar antalet skrivna bytes

irq(handler: Callable[[I2S], None]) → None¶: Ange ett återanrop. handler anropas när buf töms (write-metoden) eller blir full (readinto-metoden). Att ange ett återanrop ändrar write- och readinto-metoderna till icke-blockerande drift. handler anropas i MicroPython-schemaläggarens kontext.

static shift(*, buf: bytearray, bits: int, shift: int) → None¶: bitvis skift av alla sampel som finns i buf. bits anger sampelstorlek i bitar. shift anger antalet bitar att skifta varje sampel. Positivt för vänsterskift, negativt för högerskift. Används vanligtvis för volymkontroll. Varje bitskift ändrar sampelvolymen med 6 dB.

Konstanter¶

RX: int¶: för att initialisera I2S-bussens mode till mottagning

TX: int¶: för att initialisera I2S-bussens mode till sändning

STEREO: int¶: för att initialisera I2S-bussens format till stereo

MONO: int¶: för att initialisera I2S-bussens format till mono