LilyGO Meets AI: How to Connect an ESP32-Based Microcontroller to ASI Biont for Smart IoT Automation

LilyGO Meets AI: How to Connect an ESP32-Based Microcontroller to ASI Biont for Smart IoT Automation

If you’ve ever worked with LilyGO boards—those compact ESP32-based modules packed with LoRa, TFT displays, or SD card slots—you know how versatile they are for IoT projects. But writing custom firmware for every sensor read, relay toggle, or data log can be tedious. What if you could just tell an AI agent what you want, and it handles the integration for you? That’s exactly what ASI Biont does. In this article, we’ll walk through a real-world case: using ASI Biont to connect to a LilyGO T3 V1.6 (ESP32 with LoRa) via MQTT, read a DHT22 temperature/humidity sensor, and control a relay—all without writing a single line of firmware code. The AI writes the Python scripts, manages the MQTT broker connection, and even sends alerts when thresholds are exceeded.

Why Connect LilyGO to an AI Agent?

LilyGO boards are popular in the maker and industrial IoT communities because they combine ESP32’s Wi-Fi/Bluetooth with specialized hardware like LoRa, TFT, and GPS. However, typical projects require: (1) writing Arduino or MicroPython firmware, (2) setting up a cloud or local server to receive data, (3) coding alert logic, and (4) building a dashboard. This is time-consuming, especially when requirements change frequently.

ASI Biont eliminates steps 2–4. You keep the LilyGO board running a simple MQTT client (firmware that just publishes sensor data and subscribes to command topics). The AI agent, running in the cloud, connects to your MQTT broker, reads the data, processes it, and can publish commands back. All you do is describe what you want in a chat interface.

Which Connection Method Does ASI Biont Use?

For LilyGO boards, the most practical method is MQTT via paho-mqtt. Here’s why:

For this case, we assume your LilyGO board runs Arduino firmware that publishes to an MQTT broker. You can set up a broker on a Raspberry Pi, a cloud VM, or use a free public broker like test.mosquitto.org (for testing only).

Real-World Use Case: Temperature Monitoring and Relay Control

Scenario: You have a LilyGO T3 V1.6 connected to a DHT22 temperature/humidity sensor and a relay module. The board publishes sensor readings every 10 seconds to the topic lilygo/sensor. You want the AI to:
- Log all readings to a CSV file.
- If temperature exceeds 30°C, publish a command to lilygo/relay to turn on a fan.
- Send a Telegram alert if humidity drops below 20%.

Step 1: LilyGO Firmware (Arduino)

You only need a simple MQTT client on the board. Example sketch (using PubSubClient library):

#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

const char* ssid = "your_SSID";
const char* password = "your_PASSWORD";
const char* mqtt_server = "192.168.1.100";

WiFiClient espClient;
PubSubClient client(espClient);
DHT dht(4, DHT22);  // GPIO4

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
  dht.begin();
}

void callback(char* topic, byte* payload, unsigned int length) {
  if (strcmp(topic, "lilygo/relay") == 0) {
    int relayState = (char)payload[0] == '1' ? HIGH : LOW;
    digitalWrite(16, relayState);  // GPIO16 for relay
  }
}

void loop() {
  if (!client.connected()) {
    client.connect("LilyGOClient");
    client.subscribe("lilygo/relay");
  }
  client.loop();
  float h = dht.readHumidity();
  float t = dht.readTemperature();
  if (!isnan(t) && !isnan(h)) {
    String payload = String(t) + "," + String(h);
    client.publish("lilygo/sensor", payload.c_str());
  }
  delay(10000);
}

This is the only code you write manually. Everything else is handled by ASI Biont.

Step 2: Connect ASI Biont to the MQTT Broker

Open the ASI Biont chat interface and describe your setup:

“Connect to MQTT broker at 192.168.1.100:1883, subscribe to topic lilygo/sensor, parse the temperature and humidity (comma-separated). Log every reading to CSV. If temperature > 30°C, publish ‘1’ to lilygo/relay to turn on the fan. If humidity < 20%, send a Telegram alert to chat ID 123456789 using my bot token xyz.”

ASI Biont’s AI agent (powered by a large language model) interprets this request and writes a Python script using the paho-mqtt library, which runs inside the execute_python sandbox. The sandbox has a 30-second timeout per execution, so the script uses asyncio with a loop that subscribes and processes messages.

Example script the AI generates (simplified):

import paho.mqtt.client as mqtt
import csv
import asyncio
import httpx

BROKER = "192.168.1.100"
PORT = 1883
TOPIC_SENSOR = "lilygo/sensor"
TOPIC_RELAY = "lilygo/relay"
TELEGRAM_BOT_TOKEN = "xyz"
TELEGRAM_CHAT_ID = "123456789"

async def on_message(client, userdata, msg):
    payload = msg.payload.decode()
    temp, hum = map(float, payload.split(","))
    # Log to CSV
    with open("/tmp/sensor_log.csv", "a", newline="") as f:
        writer = csv.writer(f)
        writer.writerow([temp, hum])
    # Check thresholds
    if temp > 30:
        client.publish(TOPIC_RELAY, "1")
    if hum < 20:
        async with httpx.AsyncClient() as http:
            await http.get(f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage",
                           params={"chat_id": TELEGRAM_CHAT_ID, "text": f"Humidity low: {hum}%"})

async def main():
    client = mqtt.Client()
    client.on_message = lambda c, u, m: asyncio.create_task(on_message(c, u, m))
    client.connect(BROKER, PORT, 60)
    client.subscribe(TOPIC_SENSOR)
    client.loop_start()
    await asyncio.sleep(30)  # sandbox timeout
    client.loop_stop()

asyncio.run(main())

The AI runs this script in the sandbox. It subscribes to the topic, processes incoming messages, logs data, and triggers actions—all within a 30-second window. For continuous operation, you can set the script to run periodically (e.g., every minute using a cron-like scheduler or by asking the AI to loop with short sleeps).

Step 3: Results and Metrics

After running this integration for one week, here’s what happened:

The AI’s ability to adapt—e.g., changing the threshold to 28°C by simply saying “change temp threshold to 28”—saved hours of re-flashing firmware.

How to Do It Yourself

1. Set up your LilyGO board with the Arduino sketch above (or any MQTT client).
2. Run an MQTT broker (e.g., Mosquitto on a local Raspberry Pi, or use a cloud broker).
3. Go to asibiont.com, open the chat, and describe your task in plain English.
4. Provide connection details (broker IP, port, topics). The AI will generate and execute the integration script.
5. Monitor and tweak – ask the AI to change behavior, add logging, or integrate with other services (Telegram, Slack, email).

No dashboard panels, no “add device” buttons. Everything happens through the conversation. The AI uses industrial_command for MQTT operations (publish) and execute_python for complex scripts.

Why This Approach Changes IoT Development

Traditional IoT development requires separate skills: firmware programming, backend development, database management, and alerting. ASI Biont collapses this into a single chat interface. For LilyGO users, this means:

• Zero backend coding – the AI handles MQTT, CSV, HTTP requests.
• Instant adaptability – change logic by just asking.
• Accessibility – you don’t need to be a Python expert; the AI writes the code.

Conclusion

LilyGO boards are powerful, but their true potential unlocks when connected to an intelligent agent that can process data and act on it in real time. ASI Biont’s MQTT integration, combined with its ability to write and execute Python scripts on the fly, turns a simple sensor node into a fully automated system. Whether you’re monitoring a greenhouse, controlling a smart home, or logging industrial data, the process is the same: describe, connect, automate.

Ready to try it? Head over to asibiont.com and start your first integration today. No downloads, no setup—just a chat conversation with an AI that builds your IoT logic in seconds.