Create A Simple Copanion Which Uses Grok Humalik

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

// Put the Wi-Fi details and the HTTPS address of YOUR relay here.
// The relay keeps the Humalike, Grok, and ElevenLabs keys private.

// Hoisted type definitions
enum CompanionState { READY, LISTENING, THINKING, SPEAKING, ERROR_STATE };


// Forward declarations
void drawFace(CompanionState state, const char *caption);
void connectWiFi();
void setupAudio();
bool sendAndPlay(int16_t *samples);

const char *WIFI_SSID = "YOUR_WIFI_NAME";
const char *WIFI_PASSWORD = "YOUR_WIFI_PASSWORD";
const char *RELAY_URL = "https://your-relay.example.com/companion";

constexpr int BUTTON_PIN = 4;
constexpr int OLED_SDA_PIN = 8;
constexpr int OLED_SCL_PIN = 9;
constexpr int MIC_BCLK_PIN = 14;
constexpr int MIC_LRCLK_PIN = 15;
constexpr int MIC_DATA_PIN = 5;
constexpr int AMP_BCLK_PIN = 17;
constexpr int AMP_LRCLK_PIN = 18;
constexpr int AMP_DATA_PIN = 6;
constexpr uint32_t SAMPLE_RATE = 16000;
constexpr size_t RECORD_SECONDS = 3;
constexpr size_t SAMPLE_COUNT = SAMPLE_RATE * RECORD_SECONDS;

Adafruit_SSD1306 display(128, 64, &Wire, -1);

CompanionState shownState = ERROR_STATE;

void drawFace(CompanionState state, const char *caption) {
  if (state == shownState && state != ERROR_STATE) return;
  shownState = state;
  display.clearDisplay();
  display.drawRoundRect(2, 2, 124, 45, 8, SSD1306_WHITE);

  if (state == LISTENING) {
    display.fillCircle(38, 23, 7, SSD1306_WHITE);
    display.fillCircle(90, 23, 7, SSD1306_WHITE);
    display.drawCircle(64, 34, 10, SSD1306_WHITE);
  } else if (state == THINKING) {
    display.drawCircle(38, 23, 4, SSD1306_WHITE);
    display.fillCircle(64, 23, 5, SSD1306_WHITE);
    display.fillCircle(90, 23, 7, SSD1306_WHITE);
    display.drawLine(48, 35, 80, 35, SSD1306_WHITE);
  } else if (state == SPEAKING) {
    display.fillCircle(38, 23, 6, SSD1306_WHITE);
    display.fillCircle(90, 23, 6, SSD1306_WHITE);
    display.drawRoundRect(51, 29, 26, 12, 6, SSD1306_WHITE);
  } else if (state == ERROR_STATE) {
    display.drawLine(31, 16, 45, 30, SSD1306_WHITE);
    display.drawLine(45, 16, 31, 30, SSD1306_WHITE);
    display.drawLine(83, 16, 97, 30, SSD1306_WHITE);
    display.drawLine(97, 16, 83, 30, SSD1306_WHITE);
    display.drawLine(43, 38, 85, 38, SSD1306_WHITE);
  } else {
    display.fillCircle(38, 23, 6, SSD1306_WHITE);
    display.fillCircle(90, 23, 6, SSD1306_WHITE);
    display.drawLine(46, 34, 54, 40, SSD1306_WHITE);
    display.drawLine(54, 40, 64, 42, SSD1306_WHITE);
    display.drawLine(64, 42, 74, 40, SSD1306_WHITE);
    display.drawLine(74, 40, 82, 34, SSD1306_WHITE);
  }
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  display.setCursor(6, 53);
  display.print(caption);
  display.display();
}

void connectWiFi() {
  if (WiFi.status() == WL_CONNECTED) return;
  drawFace(THINKING, "Joining Wi-Fi...");
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  const uint32_t started = millis();
  while (WiFi.status() != WL_CONNECTED && millis() - started < 15000) {
    delay(250);
  }
}

void setupAudio() {
  i2s_config_t micConfig = {};
  micConfig.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX);
  micConfig.sample_rate = SAMPLE_RATE;
  micConfig.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
  micConfig.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT;
  micConfig.communication_format = I2S_COMM_FORMAT_I2S;
  micConfig.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
  micConfig.dma_buf_count = 8;
  micConfig.dma_buf_len = 128;
  micConfig.use_apll = false;
  micConfig.tx_desc_auto_clear = false;
  micConfig.fixed_mclk = 0;
  i2s_driver_install(I2S_NUM_0, &micConfig, 0, nullptr);
  i2s_pin_config_t micPins = {};
  micPins.bck_io_num = MIC_BCLK_PIN;
  micPins.ws_io_num = MIC_LRCLK_PIN;
  micPins.data_out_num = I2S_PIN_NO_CHANGE;
  micPins.data_in_num = MIC_DATA_PIN;
  i2s_set_pin(I2S_NUM_0, &micPins);

  i2s_config_t ampConfig = {};
  ampConfig.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX);
  ampConfig.sample_rate = SAMPLE_RATE;
  ampConfig.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT;
  ampConfig.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT;
  ampConfig.communication_format = I2S_COMM_FORMAT_I2S;
  ampConfig.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
  ampConfig.dma_buf_count = 8;
  ampConfig.dma_buf_len = 256;
  ampConfig.use_apll = false;
  ampConfig.tx_desc_auto_clear = true;
  ampConfig.fixed_mclk = 0;
  i2s_driver_install(I2S_NUM_1, &ampConfig, 0, nullptr);
  i2s_pin_config_t ampPins = {};
  ampPins.bck_io_num = AMP_BCLK_PIN;
  ampPins.ws_io_num = AMP_LRCLK_PIN;
  ampPins.data_out_num = AMP_DATA_PIN;
  ampPins.data_in_num = I2S_PIN_NO_CHANGE;
  i2s_set_pin(I2S_NUM_1, &ampPins);
}

int16_t *recordVoice() {
  int16_t *samples = (int16_t *)malloc(SAMPLE_COUNT * sizeof(int16_t));
  if (!samples) return nullptr;

  int32_t input[128];
  size_t made = 0;
  while (made < SAMPLE_COUNT) {
    size_t bytesRead = 0;
    i2s_read(I2S_NUM_0, input, sizeof(input), &bytesRead, portMAX_DELAY);
    const size_t count = bytesRead / sizeof(int32_t);
    for (size_t i = 0; i < count && made < SAMPLE_COUNT; ++i) {
      samples[made++] = (int16_t)(input[i] >> 14);
    }
  }
  return samples;
}

bool sendAndPlay(int16_t *samples) {
  if (WiFi.status() != WL_CONNECTED) return false;
  HTTPClient http;
  http.setTimeout(30000);
  if (!http.begin(RELAY_URL)) return false;
  http.addHeader("Content-Type", "application/octet-stream");
  http.addHeader("X-Audio-Format", "pcm_s16le");
  http.addHeader("X-Sample-Rate", "16000");
  http.addHeader("X-Channels", "1");
  http.addHeader("X-Companion-Id", "desk-companion-01");

  const int code = http.POST((uint8_t *)samples, SAMPLE_COUNT * sizeof(int16_t));
  if (code != HTTP_CODE_OK) {
    http.end();
    return false;
  }

  // The relay response must be raw signed 16-bit little-endian mono PCM at 16 kHz.
  WiFiClient *stream = http.getStreamPtr();
  drawFace(SPEAKING, "Talking...");
  uint8_t buffer[512];
  uint32_t lastData = millis();
  while (http.connected() || stream->available()) {
    const size_t available = stream->available();
    if (available) {
      const size_t received = stream->readBytes(buffer, min(available, sizeof(buffer)));
      size_t written = 0;
      i2s_write(I2S_NUM_1, buffer, received, &written, portMAX_DELAY);
      lastData = millis();
    } else if (millis() - lastData > 30000) {
      break;
    } else {
      delay(1);
    }
  }
  http.end();
  return true;
}

void setup() {
  Serial.begin(115200);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Wire.begin(OLED_SDA_PIN, OLED_SCL_PIN);
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    while (true) delay(1000);
  }
  setupAudio();
  connectWiFi();
  drawFace(WiFi.status() == WL_CONNECTED ? READY : ERROR_STATE,
           WiFi.status() == WL_CONNECTED ? "Press to talk" : "Wi-Fi not ready");
}

void loop() {
  static bool wasPressed = false;
  const bool pressed = digitalRead(BUTTON_PIN) == LOW;
  if (pressed && !wasPressed) {
    delay(30); // a quick tap counts exactly once
    if (digitalRead(BUTTON_PIN) == LOW) {
      connectWiFi();
      if (WiFi.status() != WL_CONNECTED) {
        drawFace(ERROR_STATE, "Check Wi-Fi");
      } else {
        drawFace(LISTENING, "Listening: 3 sec");
        int16_t *voice = recordVoice();
        if (!voice) {
          drawFace(ERROR_STATE, "Out of memory");
        } else {
          drawFace(THINKING, "Thinking...");
          const bool replied = sendAndPlay(voice);
          free(voice);
          drawFace(replied ? READY : ERROR_STATE,
                   replied ? "Press to talk" : "Relay failed");
        }
      }
    }
  }
  wasPressed = pressed;
  delay(10);
}