Micrófonos I2S en CircuitPython: graba audio y haz NeoPixels que reaccionan al sonido

# SPDX-FileCopyrightText: 2026 Tim Cocks for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""Basic wave file recording example for Metro RP2350 w/ PSRAM.

Records 10 seconds of audio to RAM then writes it to a .wav
file on the sd card.

Must use Metro RP2350 with PSRAM for 10 second recording.

Wiring:
  bclk          -> board.D5
  word select   -> board.D6
  data          -> board.D9

"""
import array
import struct
import time

import board
import audioi2sin


input("press enter to start recording")

#  Recording config
SAMPLE_RATE = 16000
RECORD_SECONDS = 10
CHUNK_SAMPLES = 1024  # samples captured per record() call
OUTPUT_PATH = "/sd/recording.wav"

# Mount SD: Uncomment for devices without builtin SDCard auto-mounting.

# spi = busio.SPI(board.SD_SCK, board.SD_MOSI, board.SD_MISO)
# sdcard = sdcardio.SDCard(spi, cs=board.SD_CARD_DETECT, baudrate=24_000_000)
# vfs = storage.VfsFat(sdcard)
# storage.mount(vfs, "/sd")

#  Mic
# 24-bit MEMS mics ride in 32-bit slots. Downconvert each slot to a
# signed 16-bit PCM sample before writing.
mic = audioi2sin.I2SIn(
    bit_clock=board.D5,
    word_select=board.D6,
    data=board.D9,
    sample_rate=SAMPLE_RATE,
    bit_depth=32,
    mono=True,
    left_justified=False,  # True for SPH0645LM4H
)

actual_rate = mic.sample_rate
print("Recording at", actual_rate, "Hz for", RECORD_SECONDS, "s ->", OUTPUT_PATH)

total_samples = actual_rate * RECORD_SECONDS

# Per-call scratch buffer for the raw 32-bit slots.
raw = array.array("i", [0] * CHUNK_SAMPLES)

# Whole recording buffered in RAM as signed int16 PCM. At 16 kHz mono this is
# ~2 bytes/sample (e.g. 2 s -> 64 KB). Increase RAM headroom or RECORD_SECONDS
# only as far as available memory allows.
pcm16 = array.array("h", [0] * total_samples)


def write_wav_header(file, sample_rate, num_samples, bits_per_sample=16, channels=1):
    byte_rate = sample_rate * channels * bits_per_sample // 8
    block_align = channels * bits_per_sample // 8
    data_size = num_samples * block_align
    file.write(b"RIFF")
    file.write(struct.pack("<I", 36 + data_size))
    file.write(b"WAVE")
    file.write(b"fmt ")
    file.write(
        struct.pack(
            "<IHHIIHH",
            16,  # fmt chunk size
            1,  # PCM
            channels,
            sample_rate,
            byte_rate,
            block_align,
            bits_per_sample,
        )
    )
    file.write(b"data")
    file.write(struct.pack("<I", data_size))


written = 0
start = time.monotonic()

while written < total_samples:
    # Don't overrun the RAM buffer on the final partial chunk.
    request = min(CHUNK_SAMPLES, total_samples - written)
    n = mic.record(raw, request)
    # Convert 24-bit-in-32-bit slots to signed int16. Top 16 bits of each
    # slot are the high bits of the signed 24-bit sample, which is already
    # a serviceable 16-bit PCM representation.
    for i in range(n):
        pcm16[written + i] = raw[i] >> 16
    written += n

elapsed = time.monotonic() - start
print("Captured", written, "samples in", round(elapsed, 2), "s; writing to SD...")
#  Flush the whole capture to SD at once -
with open(OUTPUT_PATH, "wb") as f:
    write_wav_header(f, actual_rate, written)
    f.write(memoryview(pcm16)[:written])

print("Done. Wrote", written, "samples ->", OUTPUT_PATH)

while True:
    pass

# SPDX-FileCopyrightText: 2026 Tim Cocks for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""Audio reactive NeoPixels for SparkleMotion.

The louder the sound picked up by the microphone, the more NeoPixels will turn on.

Wiring:
  LED strip   -> board.D19

"""

import array
import math
import time

import board
from audioi2sin import I2SIn
import neopixel

NUM_PIXELS = 30

# uncomment the line matching your device type
PIXEL_PIN = board.D19  # Pin D19 on Sparkle Motion
# PIXEL_PIN = board.D22 # Pin D22 on Sparkle Motion Stick
# PIXEL_PIN = board.D32 # Pin D32 on Mini Sparkle Motion

SAMPLE_RATE = 16000
SAMPLES_PER_FRAME = 512  # ~32 ms windows

pixels = neopixel.NeoPixel(PIXEL_PIN, NUM_PIXELS, brightness=0.3, auto_write=False)

mic = I2SIn(
    bit_clock=board.D26,
    word_select=board.D33,
    data=board.D25,
    sample_rate=SAMPLE_RATE,
    bit_depth=32,
    mono=True,
    left_justified=False,
)

buf = array.array("i", [0] * SAMPLES_PER_FRAME)


def to_signed24(u32):
    return u32 >> 8


def wheel(pos):
    pos = pos % 256
    if pos < 85:
        return (pos * 3, 255 - pos * 3, 0)
    if pos < 170:
        pos -= 85
        return (255 - pos * 3, 0, pos * 3)
    pos -= 170
    return (0, pos * 3, 255 - pos * 3)


# Smoothed noise floor + peak so the effect adapts to the room.
noise_floor = 2000.0
peak = 20000.0
hue = 0
smoothed_level = 0.0

while True:
    mic.record(buf, len(buf))

    # Compute RMS of the window.
    acc = 0
    for raw in buf:
        s = to_signed24(raw)
        acc += s * s
    rms = math.sqrt(acc / len(buf))

    # Track a slow noise floor and a decaying peak for auto-gain.
    noise_floor = 0.995 * noise_floor + 0.005 * rms
    if rms > peak:
        peak = rms
    else:
        peak *= 0.995
    peak = max(peak, noise_floor + 1000)

    level = (rms - noise_floor) / (peak - noise_floor)
    if level < 0:
        level = 0.0
    elif level > 1:
        level = 1.0

    # Smooth the bar so it doesn't jitter on every frame.
    smoothed_level = 0.6 * smoothed_level + 0.4 * level

    lit = int(smoothed_level * NUM_PIXELS)
    hue = (hue + 2) % 256

    for i in range(NUM_PIXELS):
        if i < lit:
            r, g, b = wheel((hue + i * (256 // NUM_PIXELS)) % 256)
            pixels[i] = (r, g, b)
        else:
            pixels[i] = (0, 0, 0)
    pixels.show()

    time.sleep(0.005)