Caso práctico: Visualizador de espectro I2S en tiempo real

Objetivo y caso de uso

Qué construirás: Un visualizador de espectro de audio en tiempo real utilizando un Arduino Nano RP2040 Connect, un micrófono INMP441 y una pantalla ILI9341.

Para qué sirve

• Visualizar en tiempo real la amplitud de diferentes frecuencias de audio capturadas por el micrófono INMP441.
• Monitorear la calidad del sonido en entornos de grabación o eventos en vivo.
• Crear una herramienta educativa para entender el espectro de audio y sus componentes.
• Implementar un sistema de alerta visual para niveles de sonido peligrosos en ambientes industriales.

Resultado esperado

• Visualización fluida de espectros de audio con actualizaciones en tiempo real a 30 FPS.
• Medición de latencias de procesamiento de audio inferiores a 50 ms.
• Capacidad de detectar y mostrar frecuencias de hasta 20 kHz con precisión.
• Generación de informes de niveles de sonido en dB con un rango de 0 a 120 dB.

Público objetivo: Ingenieros de audio, estudiantes de electrónica; Nivel: Avanzado

Arquitectura/flujo: Captura de audio -> Procesamiento I2S -> Visualización en pantalla ILI9341.

Nivel: Avanzado

Prerrequisitos

Sistema operativo (probado)

• Linux: Ubuntu 22.04 LTS (kernel 5.15.x)
• Windows: Windows 11 23H2 (Build 22631.x)
• macOS: Sonoma 14.5 (Apple Silicon o Intel)

Nota: El procedimiento y los comandos se muestran principalmente para Linux/macOS (bash). En Windows PowerShell/CMD son equivalentes cambiando rutas y comillas donde corresponda.

Toolchain exacta (versiones fijadas)

• Arduino CLI: 0.35.3
• Core para RP2040 (Earle Philhower): rp2040:rp2040 4.1.2
• Bibliotecas Arduino:
• I2S (incluida en el core rp2040:rp2040 4.1.2)
• Adafruit GFX Library 1.11.9
• Adafruit ILI9341 1.6.1
• arduinoFFT 1.6.0

Drivers y puertos

• Arduino Nano RP2040 Connect usa USB CDC-ACM nativo. En:
• Linux/macOS: no requiere controladores adicionales.
• Windows 10/11: no requiere CP210x/CH34x (no aplican a este modelo). Si el puerto no aparece, actualizar Windows Update o instalar “Arduino Mbed OS RP2040 Boards” desde el IDE para forzar la instalación del driver CDC-ACM firmado.
• Puerto serie típico:
• Linux: /dev/ttyACM0, /dev/ttyACM1
• macOS: /dev/cu.usbmodemXXXX
• Windows: COM3, COM4, etc.

Materiales

• 1x Arduino Nano RP2040 Connect (modelo exacto)
• 1x Micrófono I2S INMP441 (módulo breakout 3.3 V)
• 1x Pantalla TFT ILI9341 2.4″/2.8″ SPI (3.3 V, controlador ILI9341)
• Cables dupont hembra-hembra
• Resistencia 100–220 Ω para el pin LED/BLED de la pantalla (retroiluminación)
• Cable USB-C o Micro-USB según la placa (Nano RP2040 Connect utiliza Micro-USB)
• Fuente: Alimentación USB del PC (5 V). Todos los periféricos funcionan a 3.3 V.

Observaciones importantes:
– El Arduino Nano RP2040 Connect trabaja a 3.3 V en sus GPIO. INMP441 e ILI9341 aceptan 3.3 V, por lo que no se requieren conversores de nivel.
– El INMP441 requiere líneas I2S: BCLK (SCK), LRCLK/WS y SD (datos desde micrófono al MCU).
– La pantalla ILI9341 usa SPI: SCK, MOSI, MISO (opcional para lectura), CS, DC, RST, LED.

Preparación y conexión

Esquema de pines (enlazado con el código)

Seleccionaremos pines del Nano RP2040 Connect que sean cómodos y queden libres de funciones especiales usadas por el core:

• I2S INMP441:
• BCLK (SCK): D3
• LRCLK (WS): D2
• SD (Datos IN): D4
• L/R: GND (canal izquierdo)
• VDD: 3.3V

• GND: GND

• ILI9341 (SPI):

• CS: D10
• DC: D9
• RST: D8
• MOSI: D11 (SPI MOSI)
• MISO: D12 (SPI MISO; no imprescindible)
• SCK: D13 (SPI SCK)
• LED/BLED: 3.3V mediante resistencia 100–220 Ω
• VCC: 3.3V
• GND: GND

Tabla de cableado detallada:

Notas de conexión:
– Conecta GND común entre los tres módulos.
– INMP441 es sensible a ruidos de reloj; mantén los cables BCLK/LRCLK/SD cortos y enrutados juntos si es posible.
– La retroiluminación (LED/BLED) puede conectarse al 3.3V con la resistencia recomendada. Si la pantalla no enciende, revisa este punto.

Código completo (C++ para Arduino RP2040)

Objetivo: capturar audio en tiempo real desde el INMP441 vía I2S, realizar una FFT, y pintar un visualizador de barras del espectro en el ILI9341 con escala logarítmica de frecuencia y caída suave de los picos.

Características clave:
– Toma N=1024 muestras a Fs=16000 Hz (resolución de bin ≈ 15.625 Hz).
– Ventaneo Hann para reducir fugas espectrales.
– Mapeo logarítmico de bins a ~64 barras.
– Renderizado con Adafruit GFX + ILI9341 usando SPI hardware.
– Control de fps para evitar parpadeos.

Sketch principal

// i2s-spectrum-visualizer.ino
// Dispositivo: Arduino Nano RP2040 Connect + INMP441 + ILI9341
// Toolchain: Arduino CLI 0.35.3 + rp2040:rp2040@4.1.2
// Librerías: Adafruit_GFX 1.11.9, Adafruit_ILI9341 1.6.1, arduinoFFT 1.6.0

#include <Arduino.h>
#include <I2S.h>                // Provista por rp2040:rp2040 (Earle Philhower)
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ILI9341.h>
#include <arduinoFFT.h>

// ------- Configuración de pines -------
static const int PIN_I2S_BCLK = 3;   // INMP441 SCK/BCLK -> D3
static const int PIN_I2S_LRCLK = 2;  // INMP441 WS/LRCLK -> D2
static const int PIN_I2S_SD = 4;     // INMP441 SD -> D4

static const int TFT_CS  = 10;       // ILI9341 CS -> D10
static const int TFT_DC  = 9;        // ILI9341 DC -> D9
static const int TFT_RST = 8;        // ILI9341 RST -> D8

// ------- Configuración de audio/FFT -------
static const uint32_t SAMPLE_RATE = 16000; // Hz
static const uint16_t N_SAMPLES   = 1024;  // Potencia de 2 para FFT
static const uint8_t  N_BARS      = 64;    // Número de barras a dibujar

// Bufferes para FFT
double vReal[N_SAMPLES];
double vImag[N_SAMPLES];
arduinoFFT FFT(vReal, vImag, N_SAMPLES, SAMPLE_RATE);

// I2S: entrada únicamente (del mic hacia MCU)
I2S i2s(INPUT);

// Pantalla
Adafruit_ILI9341 tft = Adafruit_ILI9341(TFT_CS, TFT_DC, TFT_RST);

// Variables para renderizado
uint16_t screenW, screenH;
uint16_t barWidth;
uint8_t  margin = 2; // px entre barras
float    peakHold[N_BARS];
uint32_t lastDraw = 0;
const    uint16_t targetFPS = 30;

// Tabla Hann precalculada
float hann[N_SAMPLES];

// Asignación logarítmica de bins a barras
uint16_t binIdxStart[N_BARS + 1]; // rangos de bins por barra

// Funciones auxiliares
void initHann() {
  for (uint16_t i = 0; i < N_SAMPLES; i++) {
    hann[i] = 0.5f * (1.0f - cosf((2.0f * PI * i) / (N_SAMPLES - 1)));
  }
}

void initLogBins() {
  // Frecuencias de 20 Hz a 8 kHz aprox. (limitadas por Fs/2 = 8 kHz)
  // Mapeo logarítmico para N_BARS barras.
  float fMin = 20.0f;
  float fMax = SAMPLE_RATE / 2.0f; // 8 kHz
  for (uint8_t b = 0; b <= N_BARS; b++) {
    float p = (float)b / (float)N_BARS;
    float f = fMin * powf(fMax / fMin, p);
    uint16_t k = (uint16_t)roundf((f * N_SAMPLES) / SAMPLE_RATE);
    if (k >= N_SAMPLES / 2) k = (N_SAMPLES / 2) - 1; // Nyquist-1
    binIdxStart[b] = k;
  }
  // Asegurar monotonía estricta
  for (uint8_t b = 1; b <= N_BARS; b++) {
    if (binIdxStart[b] <= binIdxStart[b - 1]) {
      binIdxStart[b] = binIdxStart[b - 1] + 1;
    }
    if (binIdxStart[b] >= (N_SAMPLES / 2)) {
      binIdxStart[b] = (N_SAMPLES / 2) - 1;
    }
  }
}

void drawGrid() {
  tft.fillScreen(ILI9341_BLACK);
  // Ejes y líneas guía sutiles
  uint16_t h = tft.height();
  uint16_t w = tft.width();
  for (int y = h - 1; y > 0; y -= h / 8) {
    tft.drawFastHLine(0, y, w, ILI9341_DARKGREY);
  }
  // Etiquetas de frecuencia aproximadas (opcional simplificado)
  tft.setTextColor(ILI9341_WHITE);
  tft.setTextSize(1);
  tft.setCursor(4, 4);
  tft.print("i2s-spectrum-visualizer");
}

void renderBars(const float *bars, const float *peaks) {
  for (uint8_t i = 0; i < N_BARS; i++) {
    uint16_t x = i * barWidth;
    uint16_t h = tft.height();
    // Altura normalizada a pantalla (0..1 -> 0..h)
    uint16_t barH = (uint16_t)constrain(bars[i] * (h - 1), 0, h - 1);
    uint16_t peakY = h - 1 - (uint16_t)constrain(peaks[i] * (h - 1), 0, h - 1);

    // Borrar columna
    tft.fillRect(x, 0, barWidth - margin, h, ILI9341_BLACK);

    // Color en gradiente simple por altura
    uint16_t color = (barH > (h * 0.75)) ? ILI9341_RED :
                     (barH > (h * 0.50)) ? ILI9341_ORANGE :
                     (barH > (h * 0.25)) ? ILI9341_YELLOW : ILI9341_GREEN;

    // Dibujar barra (desde la base)
    if (barH > 0) {
      tft.fillRect(x, h - barH, barWidth - margin, barH, color);
    }

    // Dibujar marcador de pico
    tft.drawFastHLine(x, peakY, barWidth - margin, ILI9341_CYAN);
  }
}

// Lee N_SAMPLES muestras de I2S y las coloca en vReal (como double)
bool captureSamples() {
  uint16_t captured = 0;
  const uint32_t timeoutMs = 50;
  uint32_t start = millis();
  while (captured < N_SAMPLES) {
    if ((millis() - start) > timeoutMs) return false; // evitar bloqueo
    int32_t sample = 0;
    int available = i2s.available();
    if (available >= 4) { // Lectura de 32-bit
      // La librería I2S entrega datos 24/32 bits firmados según mic
      // Leemos 32 bits y reescalamos a float/double
      sample = i2s.read(); // int32_t
      // INMP441: datos válidos en 24 bits MSB-alineados -> desplazar si es necesario
      // Normalizamos a rango [-1, 1] aproximadamente
      float s = (float)sample / 8388608.0f; // 2^23 (24-bit signed)
      vReal[captured] = (double)s * hann[captured]; // aplicar ventana
      vImag[captured] = 0.0;
      captured++;
    }
  }
  return true;
}

void computeSpectrum(float *outBars) {
  // FFT
  FFT.Windowing(FFT_WIN_TYP_NONE, FFT_FORWARD); // ya aplicamos ventana Hann manual
  FFT.Compute(FFT_FORWARD);
  FFT.ComplexToMagnitude();

  // Magnitud normalizada: bins [1 .. N/2-1]
  // Acumular energy por banda logarítmica
  for (uint8_t b = 0; b < N_BARS; b++) {
    uint16_t kStart = (b == 0) ? 1 : binIdxStart[b];
    uint16_t kEnd   = binIdxStart[b + 1];
    if (kEnd <= kStart) kEnd = kStart + 1;
    double sum = 0.0;
    for (uint16_t k = kStart; k < kEnd; k++) {
      double mag = vReal[k]; // tras ComplexToMagnitude: vReal[] contiene magnitudes
      sum += mag * mag;      // potencia
    }
    double rms = sqrt(sum / (double)(kEnd - kStart));
    // Compresión logarítmica para visualización
    float val = log10f(1.0f + (float)rms) * 1.8f; // factor empírico
    // Limitar a [0, 1]
    if (val > 1.0f) val = 1.0f;
    if (val < 0.0f) val = 0.0f;
    outBars[b] = val;
  }
}

void setup() {
  // Serial opcional para debug
  Serial.begin(115200);
  delay(200);

  // Pantalla
  tft.begin();
  tft.setRotation(1); // 320x240 horizontal
  screenW = tft.width();
  screenH = tft.height();
  barWidth = screenW / N_BARS;
  drawGrid();

  // Ventana Hann y mapeo logarítmico de bins
  initHann();
  initLogBins();
  for (uint8_t i = 0; i < N_BARS; i++) peakHold[i] = 0.0f;

  // I2S: configurar pines y formato
  i2s.setBCLK(PIN_I2S_BCLK);
  i2s.setLRCLK(PIN_I2S_LRCLK);
  i2s.setDATA(PIN_I2S_SD);
  // Formato típico para INMP441: I2S estándar (Philips), 32 bits por muestra (24 bits válidos)
  if (!i2s.begin(SAMPLE_RATE)) {
    // Algunas versiones usan begin(mode, fs, bits)
    // i2s.begin(I2S_PHILIPS_MODE, SAMPLE_RATE, 32);
    tft.setCursor(0, 20);
    tft.setTextColor(ILI9341_RED);
    tft.setTextSize(2);
    tft.println("Error I2S.begin()");
    while (1) { delay(1000); }
  }
}

void loop() {
  // Control de FPS
  uint32_t now = millis();
  uint32_t frameTime = 1000 / targetFPS;
  if (now - lastDraw < frameTime) return;
  lastDraw = now;

  // Captura I2S
  bool ok = captureSamples();
  if (!ok) {
    // Mostrar advertencia en pantalla
    tft.setCursor(0, 20);
    tft.setTextColor(ILI9341_RED, ILI9341_BLACK);
    tft.setTextSize(1);
    tft.println("I2S timeout: revisar reloj/pines");
    return;
  }

  // FFT -> barras
  static float bars[N_BARS];
  computeSpectrum(bars);

  // Peak hold con decaimiento suave
  const float decay = 0.02f; // descenso por frame
  for (uint8_t i = 0; i < N_BARS; i++) {
    if (bars[i] > peakHold[i]) peakHold[i] = bars[i];
    else peakHold[i] = max(0.0f, peakHold[i] - decay);
  }

  // Renderizado
  renderBars(bars, peakHold);
}

Resumen de bloques clave:
– Configuración de pines: coincide con la tabla de conexión.
– I2S: entrada a 16 kHz, 32 bits (24 válidos en INMP441), lectura como int32 y normalización a [-1, 1].
– FFT: N=1024, ventana Hann aplicada antes de la FFT, conversión a magnitud, agrupación logarítmica de bins.
– Pantalla: 64 barras, colores por altura, pico retenido (peak hold) con decaimiento.
– Control de FPS: 30 fps aproximados para fluidez.

Opcional: archivo de configuración de proyecto (estructura de carpetas)

Si organizas el sketch en una carpeta de proyecto, una estructura mínima:

i2s-spectrum-visualizer/
├─ i2s-spectrum-visualizer.ino
└─ README.md

Compilación, flash y ejecución

Usaremos Arduino CLI (0.35.3) con el core de Earle Philhower para RP2040 (4.1.2). Esto nos da una implementación I2S estable basada en PIO para el RP2040.

1) Instalar Arduino CLI

• Linux/macOS:
• Descarga binario desde https://arduino.github.io/arduino-cli/latest/installation/
• Verifica versión:
  arduino-cli version
  Salida esperada: arduino-cli Version: 0.35.3

2) Agregar índice del core RP2040 (Earle Philhower) y actualizar

arduino-cli config init
arduino-cli config add board_manager.additional_urls https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
arduino-cli core update-index

3) Instalar el core RP2040 y bibliotecas

arduino-cli core install rp2040:rp2040@4.1.2
arduino-cli lib install "Adafruit GFX Library@1.11.9"
arduino-cli lib install "Adafruit ILI9341@1.6.1"
arduino-cli lib install "arduinoFFT@1.6.0"

Verificar:

arduino-cli core list
arduino-cli lib list | grep -E "Adafruit GFX|ILI9341|arduinoFFT"

4) Compilar el sketch

Asumiendo que estás dentro de la carpeta del proyecto y el archivo se llama i2s-spectrum-visualizer.ino:

arduino-cli compile \
  --fqbn rp2040:rp2040:nanorp2040connect \
  --build-property compiler.cpp.extra_flags="-O2" \
  .

Notas:
– FQBN exacto: rp2040:rp2040:nanorp2040connect (placa: Arduino Nano RP2040 Connect).
– Si quieres generar binarios sin cargar:
arduino-cli compile --fqbn rp2040:rp2040:nanorp2040connect --output-dir ./build .

5) Modo carga (UF2) y subida

El core de Earle permite carga automática vía puerto serie. Si falla, usa doble pulsación de reset para entrar en modo UF2 (aparece unidad RPI-RP2).

• Subida directa (auto-reset) especificando puerto:
• Linux/macOS:
  arduino-cli upload -p /dev/ttyACM0 --fqbn rp2040:rp2040:nanorp2040connect .

• Windows (ejemplo):
  arduino-cli upload -p COM4 --fqbn rp2040:rp2040:nanorp2040connect .

• Subida manual en modo UF2:

• Pulsa dos veces el botón RESET rápido; aparecerá una unidad RPI-RP2.
• Compila con:
  arduino-cli compile --fqbn rp2040:rp2040:nanorp2040connect --output-dir ./build .
• Copia el UF2 resultante a la unidad:
  • Linux/macOS:
    cp ./build/i2s-spectrum-visualizer.ino.uf2 /media/$USER/RPI-RP2/
  • Windows:
    Copia el archivo .uf2 al volumen RPI-RP2 desde el Explorador.

6) Ejecución

• Al reiniciar, la pantalla ILI9341 debe encender la retroiluminación y mostrarse el grid.
• Emite algún sonido (palmada, música) cerca del INMP441 para verificar el espectro.

Validación paso a paso

1) Alimentación y pantalla:
– La pantalla debe iluminarse (LED/BLED). Si no:
– Revisa que LED/BLED esté a 3.3V con resistencia.
– Verifica VCC=3.3V y GND.

2) Inicialización:
– Debes ver el texto “i2s-spectrum-visualizer” en la esquina superior.
– Sin señal de audio, las barras deben estar bajas o cercanas a cero con ligeras fluctuaciones por ruido.

3) Captura I2S:
– Emite un tono a 1 kHz (por ejemplo, desde un generador de señal en el móvil).
– Observa una barra alta alrededor de la frecuencia correspondiente (cercana al 1 kHz).
– Si aparece “I2S timeout: revisar reloj/pines” en la pantalla, hay un problema con pines o reloj.

4) Respuesta en frecuencia:
– Usa tonos de 100 Hz, 500 Hz, 1 kHz, 2 kHz, 4 kHz:
– Verifica que la barra dominante se desplace hacia la derecha a medida que sube la frecuencia.
– A frecuencias > 8 kHz no debería mostrarse actividad (límite de Nyquist a Fs=16 kHz).

5) Dinámica:
– Aumenta y disminuye el volumen de la fuente.
– Las barras deben crecer/disminuir y los picos (líneas cian) deben mantenerse brevemente y decaer suavemente.

6) Estabilidad temporal:
– Observa por 1–2 minutos:
– Debe mantener 25–30 fps aproximadamente, sin parpadeos notables.
– La CPU del RP2040 debe ser suficiente; si notas caídas, reduce N_BARS o N_SAMPLES.

7) Depuración por consola (opcional):
– Abre el monitor serie a 115200 baudios:
arduino-cli monitor -p /dev/ttyACM0 -c baudrate=115200
– Puedes imprimir valores intermedios descomentando logs en el código para confirmar magnitudes.

Troubleshooting

1) Pantalla en negro
– Causas probables:
– LED/BLED no conectado a 3.3 V con resistencia.
– RST, CS o DC mal cableados.
– Alimentación insuficiente en 3.3V (conexiones flojas).
– Solución:
– Verifica conexiones con la tabla.
– Prueba bajando la velocidad SPI (añadir tft.setSPISpeed(16000000) si fuese necesario) o usa cables más cortos.

2) Mensaje “Error I2S.begin()”
– Causas:
– API de I2S en versión del core diferente a la esperada.
– Pines BCLK/LRCLK/SD ocupados o mapeados incorrectamente.
– Soluciones:
– Asegura rp2040:rp2040@4.1.2. Si usas otra versión, adapta a:
i2s.begin(I2S_PHILIPS_MODE, SAMPLE_RATE, 32);
– Cambia pines I2S a otros GPIO compatibles (p. ej., D14–D16) y actualiza el código.

3) “I2S timeout: revisar reloj/pines”
– Causas:
– INMP441 sin alimentación o con GND flotante.
– Cableado de SD/BCLK/LRCLK inverso.
– L/R del INMP441 en estado indeterminado.
– Soluciones:
– Confirma VDD=3.3V, GND común.
– Revisa SCK->D3, WS->D2, SD->D4.
– Conecta L/R a GND (o a 3.3V si deseas canal derecho).

4) Barras no corresponden a la frecuencia (pico desplazado)
– Causas:
– Frecuencia de muestreo efectiva distinta (Fs no coincide).
– Formato de dato del INMP441 (desplazamiento de 24/32 bits).
– Soluciones:
– Verifica SAMPLE_RATE=16000 en código y que i2s.begin lo acepte.
– Ajusta la normalización: si el audio está “bajo”, prueba sample/ (float)(1<<31) o sample >> 8 antes de normalizar.

5) Rendimiento bajo o parpadeo
– Causas:
– N_SAMPLES alto + N_BARS alto.
– Redibujado completo en cada frame.
– Soluciones:
– Reduce N_BARS a 48 o 32.
– Baja SAMPLE_RATE a 12000 Hz si tu uso lo permite.
– Optimiza renderizado: dibuja solo barras que cambian.

6) Artefactos o ruido excesivo
– Causas:
– Cables I2S largos o cercanos a líneas SPI.
– Masa ruidosa.
– Soluciones:
– Cableado corto y trenzado (BCLK+GND, LRCLK+GND).
– Añadir condensador cerámico 0.1 µF cerca del INMP441 entre VDD y GND.

7) No se detecta el puerto en Windows
– Causas:
– Driver CDC-ACM no instalado correctamente.
– Cable USB solo carga.
– Soluciones:
– Probar otro puerto USB y cable “de datos”.
– Actualizar Windows; reinstalar el core desde Arduino IDE para forzar drivers.

8) Error al subir por arduino-cli (auto-reset)
– Causas:
– Bootloader no entra en modo programación.
– Soluciones:
– Doble pulsación de RESET para entrar a RPI-RP2 y copiar el .uf2 manualmente.
– Asegurar permisos en Linux (regla udev para /dev/ttyACM*).

Mejoras y variantes

1) Escala logarítmica más precisa
– Reemplazar el mapeo de bins por bandas tipo tercio de octava con pesos, para visualización más musical.

2) Aumento de resolución temporal o espectral
– N_SAMPLES=2048 a costa de FPS.
– Uso de buffers de doble canal DMA si cambias a 48 kHz y reduces N_BARS.

3) Colores dinámicos y temas
– Gradientes HSV basados en frecuencia y amplitud.
– Picos con “cola” y gravedad variable.

4) Compresor/AGC
– Implementar AGC simple para mantener la visualización estable ante cambios de nivel.

5) Curva psicoacústica (A-weighting)
– Aplicar ponderación A o curvas custom para enfatizar bandas de interés.

6) Modo waterfall
– Mantener un historial y desplazar la pantalla para formar un espectrograma 2D.

7) Control táctil o botones
– Si tu módulo ILI9341 es táctil (XPT2046), cambiar parámetros (N_BARS, escala) en tiempo real.

8) Conectividad
– El Nano RP2040 Connect incorpora WiFi/BLE vía módulo NINA. Publicar niveles de banda vía UDP o BLE para monitor remoto (no cubierto aquí).

Checklist de verificación

• [ ] He instalado Arduino CLI 0.35.3 y verificado su versión.
• [ ] He añadido la URL de Earle Philhower y he instalado rp2040:rp2040@4.1.2.
• [ ] He instalado las librerías: Adafruit GFX 1.11.9, Adafruit ILI9341 1.6.1, arduinoFFT 1.6.0.
• [ ] He cableado INMP441: VDD->3.3V, GND->GND, SCK->D3, WS->D2, SD->D4, L/R->GND.
• [ ] He cableado ILI9341: VCC->3.3V, GND->GND, CS->D10, DC->D9, RST->D8, MOSI->D11, SCK->D13, LED->3.3V con resistencia.
• [ ] He compilado con: arduino-cli compile –fqbn rp2040:rp2040:nanorp2040connect .
• [ ] He subido el firmware: arduino-cli upload -p –fqbn rp2040:rp2040:nanorp2040connect .
• [ ] La pantalla muestra “i2s-spectrum-visualizer” y el grid inicial.
• [ ] Al emitir tonos (100 Hz a 4 kHz), veo barras dominantes coherentes.
• [ ] Los picos cian retienen el máximo y decaen suave.
• [ ] No hay errores de “I2S timeout” durante la operación normal.

---

Apéndice: comandos resumidos

# 1) Inicializar CLI y añadir core RP2040
arduino-cli config init
arduino-cli config add board_manager.additional_urls https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
arduino-cli core update-index
arduino-cli core install rp2040:rp2040@4.1.2

# 2) Instalar librerías
arduino-cli lib install "Adafruit GFX Library@1.11.9"
arduino-cli lib install "Adafruit ILI9341@1.6.1"
arduino-cli lib install "arduinoFFT@1.6.0"

# 3) Compilar y subir
arduino-cli compile --fqbn rp2040:rp2040:nanorp2040connect .
arduino-cli upload -p /dev/ttyACM0 --fqbn rp2040:rp2040:nanorp2040connect .

Comentarios finales

Este caso práctico integra adquisición I2S a nivel de hardware (RP2040 + PIO mediante la librería I2S del core Earle Philhower), procesamiento en el dominio de la frecuencia con FFT, y visualización en tiempo real sobre un controlador gráfico SPI. El conjunto “Arduino Nano RP2040 Connect + INMP441 + ILI9341” es una base sólida para aplicaciones de análisis de audio embebido, diagnóstico de ruido y visualizaciones musicales, manteniendo un flujo de trabajo reproducible gracias a versiones de toolchain bloqueadas y un pipeline de compilación/carga 100% por línea de comandos.