Reconhecimento de
Palavras-Chave (KWS)

Instalar a biblioteca PDM e verificar o microfone

A biblioteca PDM já vem com o pacote de placas do Nano 33 BLE Sense. Para verificar se o microfone funciona, carregue o exemplo de teste:

// No Arduino IDE:
// File → Examples → PDM → PDMSerialPlotter

Abra o Serial Plotter (115200 baud) e fale próximo ao Arduino — você deve ver a forma de onda do áudio em tempo real.

Coletar amostras de áudio

Há duas abordagens para coletar as amostras WAV de 1 segundo:

Opção A — Microfone do PC (mais simples)

Grave diretamente pelo Python com sounddevice:

import sounddevice as sd
import soundfile as sf
import os, time

palavras = ['sim', 'nao', 'liga', 'desliga', 'silencio']
AMOSTRAS = 80   # por classe
SR       = 16000  # Hz

for palavra in palavras:
    os.makedirs(f'dados_audio/{palavra}', exist_ok=True)
    for i in range(AMOSTRAS):
        input(f"\nPressione Enter e diga '{palavra}' ({i+1}/{AMOSTRAS})...")
        audio = sd.rec(SR, samplerate=SR, channels=1, dtype='int16')
        sd.wait()
        sf.write(f'dados_audio/{palavra}/{palavra}_{i:03d}.wav', audio, SR)
        print('Gravado!')

Opção B — Microfone do Arduino

Carregue o sketch coleta_audio.ino, que captura 16.000 amostras (1 segundo a 16 kHz) e transmite via Serial em formato binário. Um script Python lê a porta serial e salva cada gravação como WAV.

Extrair features MFCC com librosa

Antes de treinar, cada arquivo WAV é convertido em uma "imagem" de coeficientes MFCC. Execute o notebook de treinamento que inclui a extração:

import librosa
import numpy as np

def extrair_mfcc(caminho_wav, n_mfcc=40, max_frames=49):
    """Retorna array (max_frames, n_mfcc) normalizado."""
    y, sr = librosa.load(caminho_wav, sr=16000, duration=1.0)
    mfcc  = librosa.feature.mfcc(y=y, sr=sr,
                                   n_mfcc=n_mfcc,
                                   n_fft=512,
                                   hop_length=160,   # 10 ms
                                   win_length=400)  # 25 ms
    # Padeia ou trunca para max_frames
    if mfcc.shape[1] < max_frames:
        mfcc = np.pad(mfcc, ((0,0),(0, max_frames - mfcc.shape[1])))
    else:
        mfcc = mfcc[:, :max_frames]
    # Normaliza por instância (zero mean, unit variance)
    mfcc = (mfcc - mfcc.mean()) / (mfcc.std() + 1e-8)
    return mfcc.T  # shape: (49, 40)

Treinar a CNN com Keras

Execute o notebook de treinamento:

jupyter notebook notebooks/03_treinamento_kws.ipynb

Arquitetura da CNN usada (leve o suficiente para MCU):

from tensorflow import keras

model = keras.Sequential([
    keras.layers.Input(shape=(49, 40)),                  # frames × coef

    keras.layers.Conv1D(32, kernel_size=3, activation='relu'),
    keras.layers.BatchNormalization(),
    keras.layers.MaxPooling1D(pool_size=2),

    keras.layers.Conv1D(64, kernel_size=3, activation='relu'),
    keras.layers.BatchNormalization(),
    keras.layers.GlobalAveragePooling1D(),

    keras.layers.Dense(64, activation='relu'),
    keras.layers.Dropout(0.3),
    keras.layers.Dense(5, activation='softmax')  # 5 classes
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

Converter para TFLite int8 e gerar os .h

Execute o notebook de conversão:

jupyter notebook notebooks/04_conversao_kws_tflite.ipynb

O processo é análogo à Parte 1, mas o dataset representativo usa amostras MFCC:

import tensorflow as tf

def representative_dataset():
    for x in X_val[:200]:
        yield [x[np.newaxis].astype(np.float32)]  # (1, 49, 40)

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations            = [tf.lite.Optimize.DEFAULT]
converter.representative_dataset   = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type     = tf.int8
converter.inference_output_type    = tf.int8

tflite_model = converter.convert()

# Salvar e exportar como array C
with open('outputs/kws_int8.tflite', 'wb') as f:
    f.write(tflite_model)

Execute xxd -i outputs/kws_int8.tflite > arduino/inferencia_kws/kws_model_data.h para gerar o array C.

Implementar o sketch de inferência no Arduino

O sketch inferencia_kws.ino executa o seguinte loop continuamente:

• Captura 16.000 amostras PCM via biblioteca PDM (1 segundo)
• Calcula os coeficientes MFCC on-device (FFT → Mel → DCT)
• Quantiza o input para int8 usando scale e zero_point
• Invoca o MicroInterpreter
• Dequantiza a saída e imprime a classe com maior confiança

// Trecho principal — inferência_kws.ino
if (novo_audio_disponivel) {
  calcular_mfcc(buffer_audio, mfcc_input);  // 49×40 → input tensor

  for (int i = 0; i < 49 * 40; i++) {
    int32_t v = (int32_t)(mfcc_input[i] / input_scale) + input_zp;
    input->data.int8[i] = (int8_t)constrain(v, -128, 127);
  }

  interpreter->Invoke();

  int melhor = argmax_int8(output, kNumClasses);
  float confianca = (output->data.int8[melhor] - output_zp) * output_scale;

  if (confianca > 0.75f) {
    Serial.print("→ "); Serial.println(kLabels[melhor]);
  }
}

Testar a classificação em tempo real

Abra o Serial Monitor a 115200 baud, fale cada palavra a ~20 cm do microfone e observe a saída:

=====================================
  TinyML Parte 2 — KWS em Português
  Arduino Nano 33 BLE Sense
=====================================
  Modelo:   18432 bytes
  Arena:    40 KB
  Classes:  sim | nao | liga | desliga | silencio
=====================================
Aguardando comando de voz...

→ sim      (91.2%)  |  inferência: 22.1 ms
→ desliga  (87.5%)  |  inferência: 21.8 ms
→ silencio (98.0%)  |  inferência: 21.3 ms

LED RGB: verde = sim, vermelho = não, azul = liga, amarelo = desliga, apagado = silêncio.