Voice AI Assistant

#include <Arduino.h>
#include <WiFi.h>
#include <HTTPClient.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <ArduinoJson.h>
#include "driver/i2s.h"

// Enter your network and the HTTPS address of your Windows bridge here.
// Keep the OpenAI API key ONLY in the Windows bridge, never in this sketch.

// Forward declarations
void showLines(const String &title, const String &body, bool confirm);
void initI2S();
bool connectWiFi();
void playPcm(HTTPClient &http);
void requestSpeech(const String &url);
void submitConfirmation();
void recordAndAsk();

const char *WIFI_SSID = "YOUR_WIFI_NAME";
const char *WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
const char *BRIDGE_URL = "https://YOUR-WINDOWS-BRIDGE/voice";

constexpr int OLED_SDA = 8;
constexpr int OLED_SCL = 9;
constexpr int I2S_BCLK = 14;
constexpr int I2S_LRCLK = 15;
constexpr int I2S_MIC_DIN = 16;
constexpr int I2S_AMP_DOUT = 17;
constexpr int BUTTON_PIN = 4;
constexpr int SCREEN_WIDTH = 128;
constexpr int SCREEN_HEIGHT = 64;
constexpr int SAMPLE_RATE = 16000;
constexpr uint32_t RECORD_MS = 4000;
constexpr i2s_port_t I2S_PORT = I2S_NUM_0;

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);
String pendingAction;
bool awaitingConfirmation = false;

void showLines(const String &title, const String &body, bool confirm = false) {
  display.clearDisplay();
  display.setTextColor(SSD1306_WHITE);
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.println(title);
  display.drawLine(0, 10, 127, 10, SSD1306_WHITE);
  display.setCursor(0, 15);
  String line;
  for (size_t i = 0; i < body.length(); ++i) {
    char c = body[i];
    line += c;
    if (line.length() >= 20 || c == '\n') {
      display.println(line);
      line = "";
    }
  }
  if (line.length()) display.println(line);
  if (confirm) {
    display.setCursor(0, 54);
    display.print("Premi per confermare");
  }
  display.display();
}

void initI2S() {
  i2s_config_t config = {};
  config.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_TX);
  config.sample_rate = SAMPLE_RATE;
  config.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
  config.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT;
  config.communication_format = I2S_COMM_FORMAT_STAND_I2S;
  config.intr_alloc_flags = 0;
  config.dma_buf_count = 8;
  config.dma_buf_len = 256;
  config.use_apll = false;
  config.tx_desc_auto_clear = true;
  config.fixed_mclk = 0;
  i2s_driver_install(I2S_PORT, &config, 0, nullptr);

  i2s_pin_config_t pins = {};
  pins.bck_io_num = I2S_BCLK;
  pins.ws_io_num = I2S_LRCLK;
  pins.data_out_num = I2S_AMP_DOUT;
  pins.data_in_num = I2S_MIC_DIN;
  i2s_set_pin(I2S_PORT, &pins);
  i2s_zero_dma_buffer(I2S_PORT);
}

bool connectWiFi() {
  if (WiFi.status() == WL_CONNECTED) return true;
  showLines("Connessione Wi-Fi", "Attendi...");
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  unsigned long start = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - start < 15000) delay(100);
  return WiFi.status() == WL_CONNECTED;
}

void playPcm(HTTPClient &http) {
  WiFiClient *stream = http.getStreamPtr();
  uint8_t buffer[512];
  while (http.connected()) {
    int available = stream->available();
    if (available <= 0) {
      delay(1);
      continue;
    }
    int got = stream->readBytes(buffer, min(available, (int)sizeof(buffer)));
    size_t written = 0;
    i2s_write(I2S_PORT, buffer, got, &written, portMAX_DELAY);
  }
}

void requestSpeech(const String &url) {
  if (url.length() == 0) return;
  HTTPClient http;
  http.begin(url);
  int status = http.GET();
  if (status == HTTP_CODE_OK) playPcm(http);
  http.end();
}

void submitConfirmation() {
  if (!connectWiFi()) {
    showLines("Wi-Fi assente", "Controlla rete e password");
    return;
  }
  showLines("Conferma inviata", "Il PC puo eseguire: " + pendingAction);
  HTTPClient http;
  String endpoint = String(BRIDGE_URL);
  int slash = endpoint.lastIndexOf('/');
  if (slash >= 0) endpoint = endpoint.substring(0, slash) + "/confirm";
  http.begin(endpoint);
  http.addHeader("Content-Type", "application/json");
  StaticJsonDocument<384> doc;
  doc["action"] = pendingAction;
  doc["confirmed"] = true;
  String request;
  serializeJson(doc, request);
  int status = http.POST(request);
  awaitingConfirmation = false;
  pendingAction = "";
  if (status < 200 || status >= 300) showLines("Errore ponte", "Il PC non ha accettato la conferma");
  else showLines("Fatto", "Azione confermata sul PC");
  http.end();
}

void recordAndAsk() {
  if (!connectWiFi()) {
    showLines("Wi-Fi assente", "Inserisci rete e password nel codice");
    return;
  }
  showLines("Ascolto", "Parla ora per 4 secondi...");
  const size_t samples = (SAMPLE_RATE * RECORD_MS) / 1000;
  const size_t bytesNeeded = samples * sizeof(int16_t);
  uint8_t *pcm = (uint8_t *)malloc(bytesNeeded);
  if (!pcm) {
    showLines("Memoria insufficiente", "Riavvia il dispositivo");
    return;
  }

  size_t produced = 0;
  int32_t i2sBuffer[128];
  while (produced < bytesNeeded) {
    size_t received = 0;
    i2s_read(I2S_PORT, i2sBuffer, sizeof(i2sBuffer), &received, portMAX_DELAY);
    for (size_t i = 0; i < received / sizeof(int32_t) && produced < bytesNeeded; ++i) {
      int16_t sample = (int16_t)(i2sBuffer[i] >> 14);
      pcm[produced++] = sample & 0xFF;
      pcm[produced++] = (sample >> 8) & 0xFF;
    }
  }

  showLines("Sto chiedendo", "Invio la voce al ponte...");
  HTTPClient http;
  http.begin(BRIDGE_URL);
  http.addHeader("Content-Type", "application/octet-stream");
  http.addHeader("X-Audio-Format", "pcm_s16le");
  http.addHeader("X-Sample-Rate", "16000");
  int status = http.POST(pcm, bytesNeeded);
  free(pcm);
  if (status != HTTP_CODE_OK) {
    showLines("Errore ponte", "Controlla URL e ponte Windows");
    http.end();
    return;
  }

  DynamicJsonDocument reply(2048);
  DeserializationError error = deserializeJson(reply, http.getString());
  http.end();
  if (error) {
    showLines("Risposta non valida", "Il ponte deve restituire JSON");
    return;
  }
  String text = reply["text"] | "Nessuna risposta";
  String speechUrl = reply["audio_url"] | "";
  pendingAction = reply["action"] | "";
  awaitingConfirmation = reply["confirmation_required"] | false;
  showLines("Assistente", text, awaitingConfirmation);
  requestSpeech(speechUrl);
}

void setup() {
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Wire.begin(OLED_SDA, OLED_SCL);
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  display.clearDisplay();
  display.display();
  initI2S();
  showLines("Assistente vocale", "Premi il pulsante per parlare");
}

void loop() {
  static bool previous = HIGH;
  bool now = digitalRead(BUTTON_PIN);
  if (previous == HIGH && now == LOW) {
    delay(25);
    if (digitalRead(BUTTON_PIN) == LOW) {
      if (awaitingConfirmation) submitConfirmation();
      else recordAndAsk();
      while (digitalRead(BUTTON_PIN) == LOW) delay(10);
    }
  }
  previous = now;
}