Um assistente de voz feito por você

Versão 1

ESP32-S3 + servidor no PC

Peças

Ligação

Passo a passo

1. Instale o servidor no PC: Python 3.10+, depois pip install flask faster-whisper openai python-dotenv requests, o Piper com a voz pt_BR-faber-medium e o ffmpeg.
2. Escolha a IA no arquivo .env (veja abaixo). Para começar sem custo, use o Ollama no próprio PC.
3. Monte o circuito na protoboard, conferindo pino por pino com a figura.
4. No Arduino IDE, instale o núcleo ESP32 versão 3 ou mais nova, escolha "ESP32S3 Dev Module" e ative PSRAM: OPI PSRAM.
5. Crie o segredos.h com o nome e a senha do Wi-Fi e o endereço do servidor. Envie o código para a placa.
6. Teste: segure o botão BOOT, fale "que horas são no Japão?" e solte. O LED acende enquanto grava.

Código do ESP32-S3 (Arduino)

// Assistente de voz - ESP32-S3 (núcleo ESP32 3.x no Arduino IDE)
// Segure o botão BOOT e fale (até 4 s). A resposta sai no alto-falante.
#include <WiFi.h>
#include <HTTPClient.h>
#include <ESP_I2S.h>
#include "segredos.h"  // WIFI_NOME, WIFI_SENHA, SERVIDOR
                       // Só dados da rede. Chave de IA NUNCA entra aqui.
const int BOTAO = 0;   // botão BOOT da própria placa
const int LED = 2;     // aceso = gravando
I2SClass mic, falante;

void setup() {
  pinMode(BOTAO, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
  WiFi.begin(WIFI_NOME, WIFI_SENHA);
  while (WiFi.status() != WL_CONNECTED) delay(300);
  mic.setPins(5, 4, -1, 6);          // SCK, WS, (sem saída), SD
  mic.begin(I2S_MODE_STD, 16000, I2S_DATA_BIT_WIDTH_32BIT,
            I2S_SLOT_MODE_MONO, I2S_STD_SLOT_LEFT);
  falante.setPins(16, 17, 18);       // BCLK, LRC, DIN
  falante.begin(I2S_MODE_STD, 16000, I2S_DATA_BIT_WIDTH_16BIT,
                I2S_SLOT_MODE_MONO);
}

void loop() {
  if (digitalRead(BOTAO) == HIGH) return;  // só grava com o botão
  digitalWrite(LED, HIGH);
  size_t tam = 0;
  uint8_t *wav = mic.recordWAV(4, &tam);    // 4 s de áudio
  digitalWrite(LED, LOW);
  if (!wav) return;

  HTTPClient http;
  http.begin(SERVIDOR);                    // ex.: http://192.168.0.20:5000/falar
  http.setTimeout(30000);                  // a IA pode levar alguns segundos
  http.addHeader("Content-Type", "audio/wav");
  int codigo = http.POST(wav, tam);
  free(wav);                               // o áudio some da memória
  if (codigo == 200) {
    int n = http.getSize();
    uint8_t *resp = (uint8_t *) ps_malloc(n);
    if (resp) {
      http.getStream().readBytes(resp, n);
      falante.playWAV(resp, n);            // toca a resposta
      free(resp);
    }
  }
  http.end();
}

Servidor no PC (Python)

# servidor.py - recebe o áudio, entende, pergunta à IA e devolve a voz.
import os, subprocess, tempfile, requests
from flask import Flask, request
from faster_whisper import WhisperModel
from openai import OpenAI          # serve para qualquer IA "compatível com OpenAI"
from dotenv import load_dotenv

load_dotenv()                      # lê o .env, que NÃO vai para o GitHub
ia = OpenAI(base_url=os.environ["IA_URL"],
            api_key=os.environ.get("CHAVE_IA", "local"))
MODELO = os.environ["IA_MODELO"]
CASA = os.environ.get("CASA_URL")  # controle da casa (S7), se você tiver
ouvido = WhisperModel("small", device="cpu", compute_type="int8")
app = Flask(__name__)

def comando_da_casa(texto):
    """Comando fixo vai direto para a casa, sem gastar IA."""
    t = texto.lower()
    if CASA and "luz" in t:
        estado = "0" if "desliga" in t else "1"
        requests.get(f"{CASA}/rele?n=1&estado={estado}", timeout=3)
        return "Pronto, luz " + ("desligada." if estado == "0" else "ligada.")
    return None

def perguntar_ia(texto):
    r = ia.chat.completions.create(model=MODELO, max_tokens=120, messages=[
        {"role": "system", "content": "Você é o assistente de uma casa. "
         "Responda em português, em no máximo duas frases curtas."},
        {"role": "user", "content": texto}])
    return r.choices[0].message.content

def falar(texto, saida):
    bruto = saida + ".bruto.wav"
    subprocess.run(["piper", "--model", "pt_BR-faber-medium.onnx",
                    "--output_file", bruto], input=texto.encode(), check=True)
    subprocess.run(["ffmpeg", "-y", "-loglevel", "error", "-i", bruto,
                    "-ar", "16000", "-ac", "1", "-sample_fmt", "s16", saida],
                   check=True)

@app.post("/falar")
def receber():
    with tempfile.TemporaryDirectory() as pasta:  # apagada ao final
        entrada = os.path.join(pasta, "pergunta.wav")
        with open(entrada, "wb") as f:
            f.write(request.data)
        partes, _ = ouvido.transcribe(entrada, language="pt")
        texto = " ".join(p.text for p in partes).strip()
        if texto:
            resposta = comando_da_casa(texto) or perguntar_ia(texto)
        else:
            resposta = "Não entendi. Pode repetir?"
        saida = os.path.join(pasta, "resposta.wav")
        falar(resposta, saida)
        with open(saida, "rb") as f:
            dados = f.read()
    return dados, 200, {"Content-Type": "audio/wav"}

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

O comando /rele?n=1&estado=1 é um exemplo: use o endereço que o seu controle da casa (S7) aceitar. Assim "liga a luz da sala" funciona mesmo sem internet.

Versão 2

Raspberry Pi tudo em um

Aqui não há ESP32: o Raspberry Pi ouve, detecta a palavra de ativação, transcreve, pergunta à IA e fala. Use um Raspberry Pi 4 ou 5 com 4 GB ou mais, um microfone USB e uma caixinha de som USB ou P2. No Pi, prefira o Whisper "base" (mais rápido que o "small") e uma IA on-line ou o Ollama rodando num PC da casa.

# assistente_pi.py - roda no Raspberry Pi, junto com o servidor.py
# pip install openwakeword sounddevice soundfile numpy
import subprocess, tempfile
import sounddevice as sd, soundfile as sf
from openwakeword.model import Model
from openwakeword.utils import download_models
from servidor import ouvido, comando_da_casa, perguntar_ia, falar

download_models()                       # só na primeira vez
ativa = Model(wakeword_models=["hey_jarvis"])  # palavra pronta: "hey jarvis"
TAXA, BLOCO = 16000, 1280               # 80 ms de som por vez

with sd.InputStream(samplerate=TAXA, channels=1, dtype="int16",
                    blocksize=BLOCO) as mic:
    while True:
        bloco, _ = mic.read(BLOCO)
        if max(ativa.predict(bloco[:, 0]).values()) < 0.5:
            continue                    # nada é guardado antes da palavra
        audio, _ = mic.read(TAXA * 4)   # ouve 4 s depois da palavra
        with tempfile.TemporaryDirectory() as pasta:
            entrada, saida = pasta + "/p.wav", pasta + "/r.wav"
            sf.write(entrada, audio, TAXA)
            partes, _ = ouvido.transcribe(entrada, language="pt")
            texto = " ".join(p.text for p in partes).strip()
            if texto:
                falar(comando_da_casa(texto) or perguntar_ia(texto), saida)
                subprocess.run(["aplay", "-q", saida])
        ativa.reset()

As palavras de ativação prontas do openWakeWord são em inglês ("hey jarvis", "alexa"). Treinar uma palavra própria em português, como o nome do seu robô, é um ótimo desafio de versão 3.