Saltar a contenido

INMP441: reconocimiento de voz con Wit.ai

En este ejemplo la placa entiende lo que dices. Al pulsar el botón A, graba 3 segundos de audio con el micrófono INMP441, los envía por WiFi al servicio Wit.ai de Meta y muestra en el monitor serie el texto reconocido.

Es el primer paso para un asistente de voz: con el texto ya puedes encender un LED, responder con el altavoz o mostrar algo en la pantalla.

Qué vas a aprender:

  • Reservar memoria en la PSRAM para guardar audio.
  • Grabar un bloque de audio con el bus I2S.
  • Enviar datos binarios a una API por HTTPS con una petición POST.
  • Extraer el texto de la respuesta de Wit.ai.

Antes de empezar

Prueba primero el micrófono con INMP441 Nivel de sonido. Si ahí los valores cambian al hablar, este ejemplo funcionará.

1. Mapa de pines

Micrófono INMP441 (I2S)

Pin del INMP441 Conexión Constante Función
SCK GPIO 4 MIC_BCLK Reloj de bits
WS GPIO 5 MIC_WS Selección de canal
SD GPIO 6 MIC_DOUT Datos de audio hacia el ESP32
L/R GND — Canal izquierdo
VDD 3,3 V — Alimentación (nunca a 5 V)
GND GND — Tierra común

Botón y LED

Elemento GPIO Constante Función
Botón A 13 BTN_A Inicia la grabación
LED 1 7 LED1 Encendido mientras graba
LED 2 8 LED2 Encendido mientras espera a Wit.ai

2. Preparar el entorno

Cuenta y token de Wit.ai

  1. Entra en wit.ai con tu cuenta de Meta (Facebook).
  2. Crea una aplicación nueva y elige Spanish como idioma.
  3. Ve a Management → Settings y copia el Server Access Token.

Wit.ai es gratuito. No hace falta entrenarlo para obtener la transcripción: el texto reconocido llega desde el primer momento.

Librerías

Todas vienen con el soporte del ESP32 (core 3.x):

Librería Para qué sirve
WiFi.h Conexión a la red
WiFiClientSecure.h Conexión cifrada (HTTPS)
HTTPClient.h Petición POST a Wit.ai
ESP_I2S.h Lectura del micrófono

Configuración de la placa

Usa la misma configuración que en LCD 240x240. Es importante que PSRAM esté en OPI PSRAM: el audio se guarda ahí.

El programa usa Serial0 (puerto UART). Si usas el puerto USB nativo, cámbialo por Serial.

3. Código

Cambia TU_RED, TU_CLAVE y TU_TOKEN_DE_WIT por tus datos antes de subirlo.

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include <ESP_I2S.h>

// =====================================================
// Configuración
// =====================================================
const char *ssid     = "TU_RED";
const char *password = "TU_CLAVE";
const char *witToken = "TU_TOKEN_DE_WIT";   // Server Access Token
const char *witUrl   = "https://api.wit.ai/speech?v=20240304";

// =====================================================
// Pines
// =====================================================
#define MIC_BCLK 4
#define MIC_WS   5
#define MIC_DOUT 6

#define BTN_A 13
#define LED1   7
#define LED2   8

// =====================================================
// Audio
// =====================================================
#define FRECUENCIA   16000                          // Muestras por segundo
#define SEGUNDOS     3                              // Duración de la grabación
#define TAM_AUDIO    (FRECUENCIA * 2 * SEGUNDOS)    // 16 bits = 2 bytes por muestra

I2SClass mic;
uint8_t *audio;                                     // Buffer en PSRAM

// =====================================================
// Graba SEGUNDOS de audio en el buffer
// =====================================================
size_t grabar() {
  // Descarta las primeras muestras: el micrófono tarda en estabilizarse
  uint8_t descarte[1024];
  for (int i = 0; i < 4; i++) mic.readBytes((char *)descarte, sizeof(descarte));

  size_t total = 0;
  while (total < TAM_AUDIO) {
    size_t leidos = mic.readBytes((char *)audio + total, min((size_t)4096, TAM_AUDIO - total));
    if (leidos == 0) break;
    total += leidos;
  }
  return total;
}

// =====================================================
// Busca el último "text" de la respuesta
// =====================================================
String extraerTexto(const String &json) {
  int clave = json.lastIndexOf("\"text\"");
  if (clave < 0) return "";
  int inicio = json.indexOf('"', json.indexOf(':', clave)) + 1;
  int fin = json.indexOf('"', inicio);
  return json.substring(inicio, fin);
}

// =====================================================
// Envía el audio a Wit.ai y devuelve el texto reconocido
// =====================================================
String reconocer(size_t bytes) {
  WiFiClientSecure cliente;
  cliente.setInsecure();               // No verifica el certificado (solo para pruebas)

  HTTPClient https;
  https.setTimeout(15000);
  https.begin(cliente, witUrl);
  https.addHeader("Authorization", String("Bearer ") + witToken);
  https.addHeader("Content-Type",
                  "audio/raw;encoding=signed-integer;bits=16;rate=16000;endian=little");

  int codigo = https.POST(audio, bytes);
  String respuesta = https.getString();
  https.end();

  if (codigo != 200) {
    Serial0.printf("Error HTTP %d: %s\n", codigo, respuesta.c_str());
    return "";
  }
  return extraerTexto(respuesta);
}

// =====================================================
// SETUP
// =====================================================
void setup() {
  Serial0.begin(115200);
  delay(500);
  Serial0.println("\n=== Reconocimiento de voz con Wit.ai ===");

  pinMode(BTN_A, INPUT_PULLUP);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);

  // ---------- Memoria en PSRAM ----------
  audio = (uint8_t *)ps_malloc(TAM_AUDIO);
  if (!audio) {
    Serial0.println("ERROR: No hay PSRAM. Activa 'OPI PSRAM' en Herramientas.");
    while (true) delay(1000);
  }

  // ---------- Micrófono ----------
  mic.setPins(MIC_BCLK, MIC_WS, -1, MIC_DOUT);
  if (!mic.begin(I2S_MODE_STD, FRECUENCIA, I2S_DATA_BIT_WIDTH_16BIT,
                 I2S_SLOT_MODE_MONO, I2S_STD_SLOT_LEFT)) {
    Serial0.println("ERROR: No se pudo iniciar el microfono");
    while (true) delay(1000);
  }

  // ---------- WiFi ----------
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial0.print("Conectando a WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial0.print(".");
  }
  Serial0.printf("\nWiFi conectada. IP: %s\n", WiFi.localIP().toString().c_str());
  Serial0.println("Pulsa el boton A (o envia 'r') y habla durante 3 segundos.");
}

// =====================================================
// LOOP
// =====================================================
void loop() {
  bool pulsado = digitalRead(BTN_A) == LOW;
  bool comando = Serial0.available() && Serial0.read() == 'r';
  if (!pulsado && !comando) return;

  // ---------- Grabar ----------
  Serial0.println("\nGrabando...");
  digitalWrite(LED1, HIGH);
  size_t bytes = grabar();
  digitalWrite(LED1, LOW);
  Serial0.printf("Grabados %u bytes (%.1f s)\n", bytes, bytes / (FRECUENCIA * 2.0));

  // ---------- Reconocer ----------
  Serial0.println("Enviando a Wit.ai...");
  digitalWrite(LED2, HIGH);
  unsigned long inicio = millis();
  String texto = reconocer(bytes);
  digitalWrite(LED2, LOW);

  if (texto.length() > 0) {
    Serial0.printf("Has dicho: \"%s\"  (%lu ms)\n", texto.c_str(), millis() - inicio);
  } else {
    Serial0.println("No se reconocio ningun texto.");
  }

  // Espera a que se suelte el botón
  while (digitalRead(BTN_A) == LOW) delay(10);
  delay(50);
}

4. Cómo funciona

Flujo general

Botón A ──► grabar() ──► audio en PSRAM (96 KB)
                              │
                              ▼  POST por HTTPS
                        Wit.ai (Meta)
                              │
                              ▼  JSON
                   extraerTexto() ──► "enciende la luz"

Memoria en la PSRAM

Tres segundos de audio ocupan:

16 000 muestras/s × 2 bytes × 3 s = 96 000 bytes

La RAM interna del ESP32-S3 es de 512 KB y la comparten el WiFi, la pila TLS y tu programa. Por eso el buffer se reserva con ps_malloc(), que lo coloca en los 8 MB de PSRAM externa. Es exactamente para lo que la placa tiene PSRAM: con ella podrías grabar más de un minuto.

Grabar con I2S

El micrófono se configura igual que en Nivel de sonido: 16 000 Hz, 16 bits, mono, canal izquierdo. grabar() lee bloques de hasta 4 KB hasta llenar el buffer.

Antes descarta unos 2 KB de audio, porque las primeras muestras tras un rato inactivo pueden traer restos del buffer interno o un pequeño chasquido.

Enviar a Wit.ai

La API de voz recibe el audio en bruto (raw) en el cuerpo de la petición:

Cabecera Valor Significado
Authorization Bearer TU_TOKEN Identifica tu aplicación
Content-Type audio/raw;encoding=signed-integer;bits=16;rate=16000;endian=little Describe el formato del audio

El Content-Type tiene que coincidir con lo que graba el micrófono: enteros con signo, 16 bits, 16 000 Hz y orden little-endian. Si no coincide, Wit.ai interpreta mal el audio y no reconoce nada.

El parámetro v=20240304 de la URL fija la versión de la API, para que la respuesta no cambie si Meta la actualiza.

HTTPS sin verificar el certificado

Wit.ai solo acepta conexiones HTTPS. cliente.setInsecure() cifra la conexión pero no comprueba que el servidor sea realmente Wit.ai. Es suficiente para aprender, pero en un producto conviene cargar el certificado raíz con cliente.setCACert().

La respuesta

Wit.ai envía varios objetos JSON mientras procesa el audio: primero transcripciones parciales y al final la definitiva. Por ejemplo:

{
  "text": "enciende la",
  "type": "PARTIAL_TRANSCRIPTION"
}
{
  "text": "enciende la luz",
  "type": "FINAL_TRANSCRIPTION",
  "is_final": true
}

extraerTexto() busca la última aparición de "text" y devuelve el valor entre comillas, que es la transcripción final. Si después entrenas intents en Wit.ai, la respuesta también los incluirá; para leerlos conviene usar la librería ArduinoJson.

5. Resultado esperado

Pulsa A: el LED 1 se enciende durante 3 segundos mientras hablas. Después el LED 2 se enciende mientras espera la respuesta. En el monitor serie, a 115200 baudios:

=== Reconocimiento de voz con Wit.ai ===
Conectando a WiFi....
WiFi conectada. IP: 192.168.1.42
Pulsa el boton A (o envia 'r') y habla durante 3 segundos.

Grabando...
Grabados 96000 bytes (3.0 s)
Enviando a Wit.ai...
Has dicho: "enciende la luz"  (1840 ms)

6. Solución de problemas

Síntoma Causa probable y solución
ERROR: No hay PSRAM Activa OPI PSRAM en Herramientas.
Error HTTP 400 con "Bad auth" o similar El token es incorrecto. Usa el Server Access Token, no el ID de la app.
Error HTTP -1 o -11 No hay conexión o se agotó el tiempo. Comprueba el acceso a internet.
No se reconocio ningun texto. Habla más cerca y más alto. Comprueba en Nivel de sonido que el micrófono responde.
Reconoce palabras en inglés La aplicación de Wit.ai está en inglés. Crea una nueva con idioma Spanish.
Las tildes salen como á Wit.ai a veces las envía escapadas. Usa ArduinoJson para decodificar el texto.
Se queda en Conectando a WiFi.... Revisa la red y la clave. El ESP32 solo usa redes de 2,4 GHz.

No publiques tus claves

El token de Wit.ai y la contraseña del WiFi no deben subirse a un repositorio público. Si se te escaparon, genera un token nuevo en Wit.ai y cambia la clave de la red.

7. Retos

  1. Enciende el LED 1 si el texto contiene "enciende" y apágalo si contiene "apaga".
  2. Muestra el texto reconocido en la pantalla.
  3. Repite en voz alta lo que entendió con Texto a voz.
  4. Entrena un intent en Wit.ai y lee su nombre y su confianza con ArduinoJson.