How to Connect MAX9814 and INMP441 Microphones to ASI Biont: Build a Voice-Controlled AI Assistant Without Coding

from machine import Pin, ADC
import time
import network
from umqtt.simple import MQTTClient

# Wi-Fi credentials
SSID = "your_ssid"
PASS = "your_password"

# MQTT broker (you can use public test.mosquitto.org)
BROKER = "test.mosquitto.org"
TOPIC_PUB = "esp32/mic/level"
TOPIC_SUB = "esp32/mic/command"

# ADC setup (MAX9814 output on GPIO34)
adc = ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)  # full range 0-3.3V
adc.width(ADC.WIDTH_12BIT)  # 0-4095

def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect(SSID, PASS)
    while not wlan.isconnected():
        time.sleep(1)
    print("WiFi connected")

def mqtt_callback(topic, msg):
    if msg == b"start":
        print("AI commands: start capture")
    elif msg == b"stop":
        print("AI commands: stop")

def main():
    connect_wifi()
    client = MQTTClient("esp32_mic", BROKER)
    client.set_callback(mqtt_callback)
    client.connect()
    client.subscribe(TOPIC_SUB)
    print("MQTT connected")

    while True:
        # Read audio level (simple envelope)
        samples = [adc.read() for _ in range(100)]
        avg_level = sum(samples) / len(samples)
        client.publish(TOPIC_PUB, str(int(avg_level)))
        client.check_msg()  # check for incoming commands
        time.sleep(0.5)

main()

import paho.mqtt.client as mqtt
import requests
import time

BROKER = "test.mosquitto.org"
TOPIC_LEVEL = "esp32/mic/level"
TOPIC_CMD = "esp32/mic/command"
TELEGRAM_BOT_TOKEN = "your_token"
TELEGRAM_CHAT_ID = "your_chat_id"

def on_message(client, userdata, msg):
    topic = msg.topic
    payload = msg.payload.decode()
    if topic == TOPIC_LEVEL:
        level = int(payload)
        if level > 3000:
            requests.post(
                f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage",
                json={"chat_id": TELEGRAM_CHAT_ID, "text": f"⚠️ High noise level: {level}"}
            )
    elif topic == TOPIC_CMD:
        if payload == "begin monitoring":
            client.publish(TOPIC_CMD, "start")

def main():
    client = mqtt.Client()
    client.on_message = on_message
    client.connect(BROKER, 1883, 60)
    client.subscribe([(TOPIC_LEVEL, 0), (TOPIC_CMD, 0)])
    client.loop_start()
    time.sleep(300)  # run for 5 minutes
    client.loop_stop()

main()

#include <WiFi.h>
#include <HTTPClient.h>
#include <driver/i2s.h>

const char* ssid = "your_ssid";
const char* password = "your_password";
const char* serverUrl = "https://asi-biont-api.example.com/audio";  // replace with your endpoint

#define I2S_WS 25
#define I2S_SD 32
#define I2S_BCK 26
#define I2S_PORT I2S_NUM_0
#define bufferLen 1024
int16_t sBuffer[bufferLen];

void i2s_install() {
  const i2s_config_t i2s_config = {
    .mode = i2s_mode_t(I2S_MODE_MASTER | I2S_MODE_RX),
    .sample_rate = 16000,
    .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT,
    .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
    .communication_format = i2s_comm_format_t(I2S_COMM_FORMAT_I2S),
    .intr_alloc_flags = 0,
    .dma_buf_count = 8,
    .dma_buf_len = bufferLen,
    .use_apll = false
  };
  i2s_driver_install(I2S_PORT, &i2s_config, 0, NULL);
  const i2s_pin_config_t pin_config = {
    .bck_io_num = I2S_BCK,
    .ws_io_num = I2S_WS,
    .data_out_num = I2S_PIN_NO_CHANGE,
    .data_in_num = I2S_SD
  };
  i2s_set_pin(I2S_PORT, &pin_config);
}

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  i2s_install();
}

void loop() {
  size_t bytesRead;
  i2s_read(I2S_PORT, &sBuffer, bufferLen * 2, &bytesRead, portMAX_DELAY);
  int sample_count = bytesRead / 2;

  // Compute RMS level
  float sum = 0;
  for (int i = 0; i < sample_count; i++) sum += sBuffer[i] * sBuffer[i];
  float rms = sqrt(sum / sample_count);

  // Send to ASI Biont via HTTP
  if (WiFi.status() == WL_CONNECTED) {
    HTTPClient http;
    http.begin(serverUrl);
    http.addHeader("Content-Type", "application/json");
    String json = "{\"rms\":" + String(rms) + ",\"device\":\"esp32_inmp441\"}";
    http.POST(json);
    http.end();
  }
  delay(1000);
}

from aiohttp import web
import json

rms_history = []

async def handle_audio(request):
    data = await request.json()
    rms = data.get("rms", 0)
    rms_history.append(rms)
    if len(rms_history) > 10:
        rms_history.pop(0)
    print(f"Received RMS: {rms}")
    if rms > 500:
        print("⚠️ High audio level detected!")
    return web.Response(text="OK")

app = web.Application()
app.router.add_post('/audio', handle_audio)
web.run_app(app, port=8080)