Edge AI Face Detection with ESP32-CAM and OV2640: Integrating with ASI Biont for Real-Time Automation

Introduction

Edge AI is transforming how we deploy machine learning on low-power devices. The ESP32-CAM module, built around the Espressif ESP32 microcontroller and the OV2640 camera sensor, is one of the most accessible platforms for on-device computer vision. With a 2 MP camera, integrated Wi-Fi, and Bluetooth, it can capture JPEG images at up to 1600×1200 resolution and run lightweight neural networks directly on the chip. However, turning raw face detection data into actionable automation — like sending alerts, unlocking doors, or logging entries — typically requires writing custom middleware, setting up cloud servers, and managing network infrastructure. This is where ASI Biont, an AI agent that connects to any device via chat, changes the game.

ASI Biont eliminates the need for manual integration coding. Instead of building a backend to process camera data, you simply describe your ESP32-CAM setup and desired automation in a chat conversation. The AI agent uses its execute_python sandbox to generate and run Python scripts that connect to your device via MQTT, COM port, or SSH — whichever protocol your project requires. In this article, we walk through a real-world case: an ESP32-CAM running a face detection model that streams results to ASI Biont, which then triggers notifications and data logging. Whether you are a hobbyist prototyping a smart doorbell or an engineer deploying an access control system, this guide shows how ASI Biont turns a camera into an intelligent edge node.

Why Connect ESP32-CAM (OV2640) to an AI Agent?

The ESP32-CAM is a powerful edge device, but its on-board processing is limited. While it can detect faces using the ESP-WHO library (based on TensorFlow Lite Micro), the detection events — coordinates, confidence scores, timestamps — are just numbers. Without a central intelligence to interpret, store, and act on those numbers, the camera remains a siloed sensor. An AI agent like ASI Biont bridges this gap by:

• Interpreting data semantically: The agent can understand that "face detected at (120, 80)" means "someone is at the front door."
• Triggering multi-step workflows: One detection can send a Telegram alert, log to a Google Sheet, and turn on a relay — all in seconds.
• Adapting without firmware updates: You change the automation logic by chatting with the AI, not by reflashing the ESP32.
• Providing a unified interface: Instead of managing separate MQTT brokers, webhooks, and databases, you have one chat thread that controls everything.

Connection Method: MQTT + ESP32-CAM

For this integration, MQTT is the most practical choice because:
- The ESP32-CAM already has Wi-Fi and can publish MQTT messages with minimal code.
- ASI Biont's sandbox has paho-mqtt pre-installed, allowing the AI to subscribe to topics and publish commands instantly.
- MQTT is lightweight, works over the internet (using a public broker like HiveMQ Cloud or Mosquitto), and supports quality-of-service levels for reliable delivery.

Alternative methods include:
- COM port via Hardware Bridge: If the ESP32 is connected via USB to a PC, bridge.py can forward serial data to ASI Biont. This is useful for offline setups.
- SSH: If the ESP32 runs a lightweight web server, the AI can SSH into a Raspberry Pi that relays commands.

But for a wireless camera module, MQTT is the sweet spot. The AI writes a Python script that subscribes to a topic like esp32cam/face and publishes control commands to esp32cam/command.

Real-World Use Case: Smart Doorbell with Face Detection

Scenario

A small office wants a smart doorbell that detects faces at the entrance, logs each event with a timestamp, and sends a Telegram message to the team. The ESP32-CAM runs a face detection model (using the ESP-WHO example), and when a face is detected, it publishes a JSON payload to the MQTT broker. ASI Biont receives the payload, parses it, logs it to a local CSV file via execute_python, and sends a notification via the Telegram sandbox library.

Step 1: ESP32-CAM Code (MicroPython / Arduino)

The ESP32 runs a sketch that captures a frame, runs face detection, and publishes results. Below is the core MQTT publishing logic (Arduino framework):

#include <WiFi.h>
#include <PubSubClient.h>
#include "esp_camera.h"
#include "fd_forward.h" // ESP-WHO face detection

const char* ssid = "YOUR_SSID";
const char* password = "YOUR_PASS";
const char* mqtt_server = "broker.hivemq.com";
const int mqtt_port = 1883;
const char* topic_face = "esp32cam/face";

WiFiClient espClient;
PubSubClient client(espClient);
mtmn_config_t mtmn_config = {0}; // face detection config

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);
  client.setServer(mqtt_server, mqtt_port);
  client.connect("ESP32CAM_FaceDetect");

  camera_config_t config;
  config.ledc_channel = LEDC_CHANNEL_0;
  config.ledc_timer = LEDC_TIMER_0;
  config.pin_d0 = Y2_GPIO_NUM;
  config.pin_d1 = Y3_GPIO_NUM;
  config.pin_d2 = Y4_GPIO_NUM;
  config.pin_d3 = Y5_GPIO_NUM;
  config.pin_d4 = Y6_GPIO_NUM;
  config.pin_d5 = Y7_GPIO_NUM;
  config.pin_d6 = Y8_GPIO_NUM;
  config.pin_d7 = Y9_GPIO_NUM;
  config.pin_xclk = XCLK_GPIO_NUM;
  config.pin_pclk = PCLK_GPIO_NUM;
  config.pin_vsync = VSYNC_GPIO_NUM;
  config.pin_href = HREF_GPIO_NUM;
  config.pin_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_scl = SIOC_GPIO_NUM;
  config.pin_pwdn = PWDN_GPIO_NUM;
  config.pin_reset = RESET_GPIO_NUM;
  config.xclk_freq_hz = 20000000;
  config.pixel_format = PIXFORMAT_JPEG;
  config.frame_size = FRAMESIZE_QVGA; // 320x240 for speed
  config.jpeg_quality = 12;
  config.fb_count = 1;
  esp_camera_init(&config);
  mtmn_config = mtmn_init_config();
}

void loop() {
  if (!client.connected()) client.connect("ESP32CAM_FaceDetect");
  client.loop();

  camera_fb_t *fb = esp_camera_fb_get();
  if (!fb) { delay(100); return; }

  // Face detection (simplified - real code uses dl_matrix)
  mtmn_config.min_face = 80;
  mtmn_config.pyramid = 0.7;
  box_array_t *faces = face_detection(fb, &mtmn_config);

  if (faces && faces->len > 0) {
    box_t *box = &(faces->box[0]);
    String payload = "{\"face\":true,\"x\":" + String(box->box[0]) + ",\"y\":" + String(box->box[1]) + ",\"w\":" + String(box->box[2]) + ",\"h\":" + String(box->box[3]) + ",\"confidence\":" + String(box->score) + "}";
    client.publish(topic_face, payload.c_str());
    Serial.println("Face detected: " + payload);
  }
  esp_camera_fb_return(fb);
  delay(1000); // check every second
}

This code publishes a JSON message like {"face":true,"x":120,"y":80,"w":50,"h":60,"confidence":0.92} every time a face is detected.

Step 2: ASI Biont Integration via Chat

Instead of writing a Python listener manually, you open a chat with ASI Biont and describe the task:

"Connect to MQTT broker at broker.hivemq.com:1883. Subscribe to topic 'esp32cam/face'. When a face is detected, log the timestamp and bounding box to a file called faces_log.csv, and send a Telegram message to chat ID 123456789 with the text 'Face detected at [timestamp]'. Also publish a command to turn on an LED on the ESP32 by sending 'LED_ON' to topic 'esp32cam/command'."

Within seconds, the AI generates and runs the following Python script in its sandbox environment:

import paho.mqtt.client as mqtt
import json
import csv
from datetime import datetime
import requests

TELEGRAM_BOT_TOKEN = "YOUR_BOT_TOKEN"
TELEGRAM_CHAT_ID = "123456789"
CSV_FILE = "faces_log.csv"
MQTT_BROKER = "broker.hivemq.com"
MQTT_PORT = 1883
TOPIC_SUB = "esp32cam/face"
TOPIC_PUB = "esp32cam/command"

def on_message(client, userdata, msg):
    try:
        data = json.loads(msg.payload.decode())
        if data.get("face"):
            timestamp = datetime.now().isoformat()
            # Log to CSV
            with open(CSV_FILE, "a", newline="") as f:
                writer = csv.writer(f)
                writer.writerow([timestamp, data["x"], data["y"], data["w"], data["h"], data["confidence"]])
            # Send Telegram notification
            text = f"Face detected at {timestamp}"
            requests.post(f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage", json={"chat_id": TELEGRAM_CHAT_ID, "text": text})
            # Publish command to turn on LED
            client.publish(TOPIC_PUB, "LED_ON")
            print(f"Logged face event: {timestamp}")
    except Exception as e:
        print(f"Error: {e}")

client = mqtt.Client()
client.on_message = on_message
client.connect(MQTT_BROKER, MQTT_PORT, 60)
client.subscribe(TOPIC_SUB)
client.loop_start()

# Keep running for 30 seconds (sandbox limit)
import time
time.sleep(30)
client.loop_stop()

The script runs for 30 seconds (the sandbox timeout), but you can ask the AI to run it continuously by using the industrial_command tool instead — for example, the AI can set up a scheduled task or use a persistent MQTT connection via the bridge.

Step 3: Controlling the ESP32 from ASI Biont

The ESP32 also subscribes to esp32cam/command to receive commands. In the same chat, you can ask: "Turn on the LED on the ESP32 now." The AI publishes LED_ON to the topic, and the ESP32's loop handler toggles the built-in flash LED.

Results and Metrics

After deploying this integration in a test office environment for one week:

Team members reported that the system "just works" — no server maintenance, no code deploys. The CSV log allowed them to analyze peak entry times.

Why ASI Biont is a Game-Changer for Edge AI

Traditional integration requires: (1) writing a Python script that subscribes to MQTT, (2) deploying it on a VPS or Raspberry Pi, (3) handling reconnections and errors, (4) adding notification logic. With ASI Biont, all these steps are replaced by a single chat message. The AI uses execute_python to run the integration code in its cloud sandbox, which has over 40 pre-installed libraries — paho-mqtt, requests, csv, json, and more. If your device uses a different protocol, the AI adapts:

• COM port: Use industrial_command(protocol='serial_write_and_read', data='...') with the Hardware Bridge.
• HTTP API: Use aiohttp or requests in the sandbox.
• Modbus/TCP: Use industrial_command(protocol='modbus_tcp', command='read_registers', ...).
• SSH: Write a paramiko script in execute_python.

You are not limited to predefined integrations. ASI Biont's architecture — where the AI writes code on the fly — means any device with a network or serial interface can be connected in minutes.

Step-by-Step: How to Connect Your ESP32-CAM

1. Flash the ESP32 with the face detection sketch above (use Arduino IDE or PlatformIO). Ensure it connects to your Wi-Fi and MQTT broker.
2. Open the ASI Biont chat at asibiont.com.
3. Describe your setup: "I have an ESP32-CAM publishing face detection data to MQTT topic 'esp32cam/face' on broker.hivemq.com. Subscribe to it, log results to CSV, and send me a Telegram alert when a face is detected. My Telegram bot token is XXX, chat ID YYY."
4. Review the generated script — the AI shows it before execution. You can ask for modifications (e.g., "also save the image URL").
5. Approve execution — the AI runs the script in the sandbox and confirms it is working.
6. Automate further: Ask the AI to run the script every hour, or use industrial_command for persistent connections.

No coding skills required. The AI handles boilerplate, error handling, and library imports.

Conclusion: From Sensor to Action in Seconds

The combination of an ESP32-CAM with OV2640 and ASI Biont demonstrates the power of Edge AI plus conversational integration. Instead of spending days writing custom middleware, you get a production-ready pipeline that detects faces, logs data, and triggers notifications — all through a chat interface. The AI agent writes, debugs, and executes the integration code, adapting to your exact hardware and workflow.

Whether you are building a smart doorbell, a people counter, or an access control system, ASI Biont turns your ESP32-CAM into an intelligent edge node that communicates with the world. No servers to maintain, no APIs to learn — just describe what you need, and the AI makes it happen.

Ready to connect your camera? Start a chat at asibiont.com and tell the AI: "Connect my ESP32-CAM face detector to my automation pipeline."