AI-Driven Dashboards on Legacy VGA: Integrating ESP32 + DAC with ASI Biont

When Old-School VGA Meets Modern AI Agents

If you've ever managed a factory floor or a remote monitoring station, you know the pain: a perfectly good 20-inch VGA monitor sits idle because the sensor data it used to display is now locked inside cloud APIs and spreadsheets. Meanwhile, your engineering team spends weeks writing custom firmware just to push a few numbers onto a screen.

This is exactly the problem ASI Biont solves by connecting an AI agent to legacy display hardware like a VGA output built from an ESP32 + DAC. Instead of writing a dedicated backend, you simply describe what you want in a chat dialog, and the AI handles the entire integration—from generating MicroPython code for the ESP32 to sending industrial commands over a COM port.

In this article, I'll walk through a real-world case: using an ESP32-based VGA display as a live KPI dashboard for a production line, all controlled by ASI Biont's AI agent. No custom management panels, no waiting for a developer to "release a driver." Just a conversation and a few lines of code.

What Is an ESP32 + DAC VGA Output?

The ESP32 is a low-cost microcontroller with a dual-core Xtensa processor, plenty of GPIOs, and—crucially for this project—a built-in Digital-to-Analog Converter (DAC) on two specific pins (GPIO25 and GPIO26). While the ESP32 doesn't have a native VGA controller, you can generate VGA-like signals by combining the DAC with a resistor ladder (R-2R network) and careful timing. This technique was popularized by bitluni and the ESP32 community, who demonstrated 240p and 360p color output with just a handful of resistors.

For our purposes, the ESP32 becomes a headless display driver: it receives serial commands (via UART) and draws text, rectangles, or bar charts directly to a VGA monitor. The monitor becomes a persistent, low-power status board that doesn't require a webserver or a browser tab.

Why Connect It to an AI Agent?

Standalone ESP32 VGA displays are great for showing static data, but they become truly useful when they can react to events and update in real time. That's where ASI Biont comes in. The AI agent acts as a middleware that:

• Reads data from PLCs, databases, or web APIs.
• Processes and formats that data into human-readable text.
• Sends it over a serial link to the ESP32, which renders it on a VGA screen.
• Even handles error logging and message queuing.

The beauty is that you don't need to write a single line of integration code on the host side. ASI Biont's chat interface generates the Python script for you, and you can then run it locally or on a Raspberry Pi.

The Connection: COM Port via Hardware Bridge

In this case, the most practical connection is through a COM port (RS-232/RS-485) using the Hardware Bridge that you download from the ASI Biont dashboard. The bridge runs on a computer or single-board computer that has a USB-to-UART adapter connected to the ESP32's TX/RX pins.

The bridge is launched with a simple command:

python bridge.py --token=YOUR_TOKEN --ports=COM3 --baud 115200 --rate=10

This opens the serial port, maintains a connection to ASI Biont's cloud agent, and periodically checks for pending commands. The --rate=10 means the bridge polls the AI ten times per second, so real-time updates feel snappy.

Once the bridge is running, you can use the industrial_command() function from within any ASI Biont chat conversation to send data to the ESP32:

industrial_command(
    protocol="serial",
    command="display",
    payload={
        "line1": "Temp: 72.4F",
        "line2": "Pressure: 98.2 kPa",
        "alert": False
    }
)

The bridge translates this into a formatted string and writes it to the COM port. No HTTP API is needed—industrial commands go directly through the bridge.

Code Example: MicroPython for the ESP32

On the other side, the ESP32 runs a simple MicroPython sketch that listens for serial data and updates the VGA screen. Here's a minimal version:

# MicroPython on ESP32 with VGA DAC output
from machine import Pin, DAC, UART
import vga_manager  # simplified for clarity

uart = UART(1, baudrate=115200, tx=Pin(1), rx=Pin(3))
uart.init(bits=8, parity=None, stop=1)

vga = vga_manager.VGA()
vga.init()
vga.clear()

while True:
    if uart.any():
        line = uart.readline().decode().strip()
        # Format: "display:line1;line2;alert"
        if line.startswith("display:"):
            parts = line[8:].split(";")
            vga.draw_text(0, 0, parts[0])
            vga.draw_text(0, 20, parts[1])
            if len(parts) > 2 and parts[2] == "1":
                vga.fill_rect(0, 40, 320, 10, vga.RED)
            else:
                vga.fill_rect(0, 40, 320, 10, vga.GREEN)

This is intentionally simplified—you'll need a proper VGA library like ESP32-VGA, but the important part is the UART protocol. The ESP32 doesn't know or care that the commands come from an AI agent; it just receives formatted strings and draws them.

How ASI Biont Writes the Entire Integration

Now for the truly magical part. You don't write the bridge script, the MicroPython firmware, or the data-processing logic yourself. Instead, you open a chat with ASI Biont and describe your setup:

"I have an ESP32 with a DAC VGA output connected to COM4 at 115200 baud. I want it to display the current temperature and pressure from my Modbus PLC every second. The temperature goes on line 1, pressure on line 2, and turn the background red if temperature exceeds 80°C."

ASI Biont responds with a complete solution:

1. It generates the MicroPython code for the ESP32 (which you flash using esptool.py).
2. It generates a Python script that reads from the PLC via pymodbus.
3. It wraps everything in an execute_python block that runs on your local machine (or a server) and uses industrial_command to push updates to the bridge.

The best part: this works with any device. ASI Biont uses a universal execute_python sandbox, so if you need to talk to a device that isn't natively supported (say, a custom CAN bus protocol), the AI will generate a Python script using libraries like python-can, pyserial, paho-mqtt, or opcua-asyncio. No need to wait for a developer to add support—just explain the protocol, and the AI writes the integration on the fly.

Real-World Case: Production Line KPI Display

Let's ground this in a concrete scenario. A mid-sized automotive parts manufacturer had an old 19" VGA monitor mounted above a CNC work cell. Previously, the monitor was connected to a dedicated PC that showed a web dashboard. The PC kept crashing, and the IT team was tired of maintaining it.

They replaced the PC with an ESP32 + DAC VGA board and connected it to a serial port on a small Linux server. Then they asked ASI Biont to create a new dashboard.

The AI agent generated a script that:

• Polled the CNC's Modbus/TCP registers every second.
• Calculated cycle time, part count, and error rate.
• Sent a formatted string to the ESP32 via industrial_command.
• The ESP32 rendered the metrics on the VGA display with color-coded alerts.

Results

The setup ran for six months with zero hardware failures. The display updated every second—well within the 10-ms latency of a 115200 baud serial link. The maintenance team could now change the screen layout by simply telling ASI Biont in chat what they wanted, and the AI would push updated firmware and host code automatically. Metrics that were previously invisible (like error rate per shift) became visible at a glance, reducing manual log-checking time by an estimated 40% (internal company estimate).

Why This Approach Wins

But the real advantage is flexibility. Yesterday, the dashboard showed cycle times; today, you might want it to show weather data from a public API. With ASI Biont, you just describe the new requirement, and the system regenerates the integration. There's no need to touch a single wire on the ESP32.

Conclusion

Connecting an ESP32 + DAC VGA output to an AI agent isn't just a neat hack—it's a practical way to breathe new life into old displays while making real-time data accessible. ASI Biont eliminates the two biggest barriers: writing the communication layer and formatting the data. Because every device connection is handled through the universal execute_python mechanism, you're never locked into a specific protocol or vendor.

If you have a device that needs a brain—whether it's a VGA monitor, a CAN bus controller, or an Arduino on a COM port—try explaining it to ASI Biont. You'll be surprised how quickly it goes from "I wonder if this works" to a tangible, working dashboard.

Ready to try it yourself? Head over to asibiont.com, download the Hardware Bridge, and ask the AI to connect your device. No coding skills required—just describe what you have and what you want to see.