ESP32 VGA Output with DAC: Build AI-Controlled Displays via ASI Biont

Introduction

Ever wanted to turn an old VGA monitor into a live dashboard for your IoT data, without a PC? In this guide, I'll show you how to connect an ESP32 with a simple resistor DAC to any VGA monitor, and then integrate it with the ASI Biont AI agent using MQTT. The AI will manage what's displayed — from sensor telemetry to smart home status — all through chat commands. No manual coding of the display logic; you just describe your needs, and the AI writes the MicroPython firmware and the cloud integration code. Let's get our hands dirty.

Why VGA + ESP32 + AI?

VGA is a classic analog video standard (640×480 @ 60 Hz). The ESP32's two 8-bit DACs can generate the horizontal and vertical sync signals, while GPIO pins drive RGB color through resistors. With a simple resistor ladder (R-2R or weighted), you get up to 8 colors. This setup is perfect for headless status displays: show temperature, humidity, alerts, or even simple animations. Pairing it with ASI Biont means you can update the screen content remotely via Telegram or web chat — the AI handles the MQTT bridge and command parsing.

Hardware Setup

Components

Circuit

Connect the ESP32 pins to the VGA connector:
- GPIO25 → VGA pin 1 (RED) via 330Ω
- GPIO26 → VGA pin 2 (GREEN) via 330Ω
- GPIO27 → VGA pin 3 (BLUE) via 330Ω
- GPIO32 → VGA pin 13 (HSYNC) – using DAC1 for sync
- GPIO33 → VGA pin 14 (VSYNC) – using DAC2 for sync
- GND → VGA pin 5,6,7,8,10 (ground)

For better color depth, use three resistors per color (R-2R ladder). But 3-bit RGB (8 colors) is enough for text and simple graphics.

Software: MicroPython Firmware

We'll use Micropython-ESP32-VGA library (or a custom one). The firmware reads MQTT topics from ASI Biont and renders text/graphics.

ESP32 Code (MicroPython)

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

# VGA constants
WIDTH = 640
HEIGHT = 480
# Pins
hsync = DAC(Pin(32, Pin.OUT))
vsync = DAC(Pin(33, Pin.OUT))
red = Pin(25, Pin.OUT)
green = Pin(26, Pin.OUT)
blue = Pin(27, Pin.OUT)

# Simple framebuffer (character-based)
class VGADisplay:
    def __init__(self):
        self.buffer = [[' ']*80 for _ in range(30)]  # 80x30 text
        self.cursor = (0,0)

    def clear(self):
        self.buffer = [[' ']*80 for _ in range(30)]
        self.cursor = (0,0)

    def print_at(self, x, y, text):
        for i, c in enumerate(text):
            if x+i < 80:
                self.buffer[y][x+i] = c

    def render(self):
        # In real code, drive sync signals and scan out pixel data
        # Simplified: just set sync to VGA timings
        # For this example, we just update a global state
        pass

disp = VGADisplay()

# WiFi
def connect_wifi():
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    wlan.connect('your_ssid', 'your_password')
    while not wlan.isconnected():
        time.sleep(0.5)
    print('WiFi connected')

# MQTT callback
def mqtt_callback(topic, msg):
    text = msg.decode()
    print('Received:', text)
    # Parse command: "CLEAR" or "PRINT x,y,text"
    if text == 'CLEAR':
        disp.clear()
    elif text.startswith('PRINT'):
        parts = text.split(',')
        if len(parts) >= 3:
            x = int(parts[1])
            y = int(parts[2])
            msg_text = ','.join(parts[3:])
            disp.print_at(x, y, msg_text)
    # Trigger render (in real code)
    disp.render()

# Main
connect_wifi()
client = MQTTClient('esp32_vga', 'mqtt.eclipseprojects.io', port=1883)
client.set_callback(mqtt_callback)
client.connect()
client.subscribe(b'vga/display')
print('Waiting for commands...')
while True:
    client.check_msg()
    time.sleep(0.05)

Integrating with ASI Biont

ASI Biont connects to this ESP32 via MQTT. You describe the display requirements in the chat, and the AI writes a Python script that runs in the sandbox (execute_python) to publish commands to the MQTT topic.

Step-by-step in Chat

1. User: "Connect to my ESP32 VGA display. MQTT broker is mqtt.eclipseprojects.io, topic vga/display. Show current temperature from a DHT22 sensor on my other ESP32."
2. AI writes a Python script that:
3. Subscribes to the sensor's MQTT topic (e.g., sensor/temperature)
4. Reads the latest value
5. Publishes a formatted command to vga/display: "PRINT 0,0,Temp: 23.5C"
6. Runs periodically using a simple loop (within the 30-second timeout, it can publish multiple times)

Example AI-Generated Script (sandbox)

import paho.mqtt.client as mqtt
import time

broker = "mqtt.eclipseprojects.io"
port = 1883

# Connect to broker
def on_connect(client, userdata, flags, rc):
    print("Connected with result code "+str(rc))
    client.subscribe("sensor/temperature")

# Store latest temperature
latest_temp = None
def on_message(client, userdata, msg):
    global latest_temp
    latest_temp = msg.payload.decode()
    print("Received temp:", latest_temp)

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
client.connect(broker, port, 60)
client.loop_start()

# Wait for a reading
time.sleep(2)

if latest_temp:
    # Send VGA display command
    display_client = mqtt.Client()
    display_client.connect(broker, port, 60)
    cmd = f"PRINT 0,0,Temp: {latest_temp}C"
    display_client.publish("vga/display", cmd)
    print("Published to VGA:", cmd)
    display_client.disconnect()
else:
    print("No temperature received")

client.loop_stop()
client.disconnect()

The sandbox runs this script. The AI can also schedule it via a cron-like mechanism (by repeating the script execution every few minutes).

Real Use Cases

1. IoT Telemetry Dashboard

Display multiple sensors (temperature, humidity, pressure) on the VGA monitor. The AI subscribes to all sensor topics and formats a multi-line display:

Temp: 23.5C  Hum: 55%
Pressure: 1013 hPa
Last update: 14:32:05

2. Smart Home Status

Show door/window sensors, alarm status, and energy consumption. The AI can change colors based on alerts (green for normal, red for alarm).

3. Server Room Monitor

Display CPU temperature, disk usage, and network status of a server. The AI connects via SSH to the server, runs a script to fetch stats, then publishes to the VGA topic.

Advantages of AI Integration

• No manual coding of display logic – just describe what you want to see.
• Dynamic content – AI can fetch data from any source (MQTT, HTTP API, database) and format it.
• Remote control – update the display from anywhere via Telegram or web chat.
• Zero configuration – AI automatically discovers the MQTT broker details from your description.

Pitfalls to Avoid

Conclusion

Connecting a vintage VGA monitor to an ESP32 and controlling it via ASI Biont is a perfect example of bridging old hardware with modern AI. You get a dedicated display for your IoT data without a computer, and the AI handles all the integration logic. Whether you're monitoring sensors, showing smart home status, or just displaying a clock, the process is the same: describe your setup in the chat, and the AI writes the code.

Ready to build your own AI-controlled VGA display? Head over to asibiont.com, create an API key, and start a chat. Tell the AI: "Connect to my ESP32 VGA display via MQTT at mqtt.eclipseprojects.io, topic vga/display. Show the current temperature from my DHT sensor every 10 seconds." See it come to life in minutes.