Integrating TFT LCD (ILI9341, ST7789) with ASI Biont AI Agent: A Step-by-Step Guide for Real-Time Industrial Dashboards

Introduction

In the world of Industrial IoT (IIoT) and smart manufacturing, real-time data visualization is not a luxury—it's a necessity. TFT LCD displays based on controllers like ILI9341 and ST7789, commonly paired with ESP32 microcontrollers, offer a cost-effective way to create custom dashboards for monitoring temperature, pressure, machine status, and more. However, programming these displays to update dynamically, respond to natural language commands, and integrate with AI-driven analytics has traditionally required significant embedded development effort.

Enter ASI Biont—an AI agent that can connect to virtually any hardware device through code generation and execution. Instead of writing complex firmware or dealing with low-level communication protocols, you simply describe your goal in plain English. ASI Biont writes and runs the integration code automatically, using industry-standard protocols like MQTT, Modbus TCP, SSH, and COM port communication.

This article walks through a concrete case: integrating an ESP32 with a 2.8" TFT LCD (ILI9341) into an ASI Biont-powered industrial dashboard. You'll learn how the AI agent connects, how to issue textual commands like "show the loading chart of Workshop #3," and how to set up auto-refreshing telemetry—all without writing a single line of code yourself.

Why Connect a TFT LCD to an AI Agent?

A standalone TFT LCD can display static information, but its true potential emerges when it becomes a dynamic interface to an intelligent backend. With ASI Biont:

• Natural language control: Say "display temperature from sensor A" and the AI configures the display accordingly.
• Real-time data aggregation: The AI can pull data from multiple sources (Modbus PLCs, MQTT sensors, REST APIs) and render it on the screen.
• Automatic updates: The display refreshes based on conditions you set, without polling loops in your microcontroller code.
• Zero manual coding: The AI handles protocol translation, data parsing, and screen rendering logic.

Connection Method: MQTT + Hardware Bridge

For this integration, we use a two-layer approach:

1. ESP32 with TFT LCD connects to a local MQTT broker (e.g., Mosquitto) via Wi-Fi. The ESP32 subscribes to a topic (e.g., factory/display/command) and publishes sensor data to another topic (e.g., factory/sensors/temperature).
2. ASI Biont runs in the cloud and connects to the same MQTT broker using the execute_python sandbox. The AI generates a Python script that uses the paho-mqtt library to subscribe to sensor topics and publish display commands.

Why MQTT?
- Lightweight, publish-subscribe model ideal for constrained devices.
- Works over unreliable networks—perfect for factory floors with multiple ESP32 nodes.
- ASI Biont supports it natively via paho-mqtt in the sandbox environment.

Why not direct COM port?
The ESP32 communicates wirelessly; a wired COM port would limit deployment flexibility. However, if you prefer a wired setup (e.g., for an Arduino Uno), ASI Biont supports COM port via the Hardware Bridge (bridge.py).

Real-World Use Case: Factory Floor Dashboard

Scenario: A medium-sized manufacturing plant has three workshops. Each workshop has an ESP32 connected to a DHT22 temperature/humidity sensor and a 2.8" ILI9341 TFT LCD. The plant manager wants a single AI agent that can:
- Display real-time temperature from any workshop on its respective display.
- Show a bar chart of machine utilization (simulated data from a Modbus PLC).
- Respond to voice/text commands like "show Workshop 2 temperature trend."

Step 1: ESP32 Firmware (Pre-written by AI)

When the user tells ASI Biont: "I have an ESP32 with ILI9341 display and a DHT22 sensor. Connect it via MQTT to broker at 192.168.1.100:1883," the AI generates the following MicroPython code and uploads it to the ESP32 via the user's computer (using a serial bridge or OTA).

# ESP32 MicroPython code (generated by ASI Biont)
import network
import time
import json
from machine import Pin, SoftSPI
import ili9341
from dht import DHT22
from umqtt.simple import MQTTClient

# Wi-Fi credentials
WIFI_SSID = "FactoryWiFi"
WIFI_PASS = "securepass"

# MQTT broker
BROKER = "192.168.1.100"
PORT = 1883
CLIENT_ID = "esp32_workshop1"
TOPIC_COMMAND = b"factory/display/command"
TOPIC_DATA = b"factory/sensors/workshop1"

# Display setup (ILI9341)
spi = SoftSPI(baudrate=40000000, sck=Pin(18), mosi=Pin(23), miso=Pin(19))
display = ili9341.ILI9341(spi, cs=Pin(5), dc=Pin(17), rst=Pin(16))

# Sensor
dht = DHT22(Pin(4))

# MQTT callback
def callback(topic, msg):
    print("Received:", msg)
    command = json.loads(msg)
    if command.get("action") == "show_text":
        display.fill(ili9341.BLACK)
        display.text(command["text"], 10, 10, ili9341.WHITE)
    elif command.get("action") == "clear":
        display.fill(ili9341.BLACK)

# Connect Wi-Fi
wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(WIFI_SSID, WIFI_PASS)
while not wlan.isconnected():
    time.sleep(0.5)

# Connect MQTT
client = MQTTClient(CLIENT_ID, BROKER, port=PORT)
client.set_callback(callback)
client.connect()
client.subscribe(TOPIC_COMMAND)

# Main loop
while True:
    client.check_msg()  # non-blocking check
    dht.measure()
    temp = dht.temperature()
    hum = dht.humidity()
    payload = json.dumps({"temperature": temp, "humidity": hum, "workshop": 1})
    client.publish(TOPIC_DATA, payload)
    time.sleep(5)

Note: The AI writes this code automatically—the user only provides connection details in the chat.

Step 2: ASI Biont AI Agent Configuration

In the ASI Biont chat, the user says:

"Connect to MQTT broker at 192.168.1.100:1883. Subscribe to factory/sensors/#. When temperature in workshop 1 exceeds 30°C, publish a command to factory/display/command to show 'HIGH TEMP' in red on the workshop 1 display. Also, if I say 'show graph', generate a matplotlib bar chart of all workshop temperatures and save it as an image."

ASI Biont then generates and executes a Python script in its sandbox:

# ASI Biont sandbox script (automatically generated)
import paho.mqtt.client as mqtt
import json
import matplotlib.pyplot as plt
import io

BROKER = "192.168.1.100"
PORT = 1883
TOPIC_SENSORS = "factory/sensors/#"
TOPIC_COMMAND = "factory/display/command"

data_store = {}

def on_message(client, userdata, msg):
    topic = msg.topic
    payload = json.loads(msg.payload)
    workshop = payload.get("workshop")
    temp = payload.get("temperature")
    if workshop and temp:
        data_store[workshop] = temp
        print(f"Workshop {workshop}: {temp}°C")
        # Alert if temp > 30
        if temp > 30:
            alert = {"action": "show_text", "text": f"HIGH TEMP in W{workshop}: {temp}°C", "color": "red"}
            client.publish(TOPIC_COMMAND, json.dumps(alert))

client = mqtt.Client()
client.on_message = on_message
client.connect(BROKER, PORT, 60)
client.subscribe(TOPIC_SENSORS)
client.loop_forever()  # runs until timeout; sandbox allows up to 30 seconds per execution

Important: The sandbox has a 30-second timeout. For persistent monitoring, the AI can schedule periodic executions or use the industrial_command tool for MQTT publish (which is stateless).

Step 3: Real-Time Command via Chat

Once the integration is running, the user can type in the ASI Biont chat:

"Publish to factory/display/command: {\"action\": \"show_text\", \"text\": \"Workshop 1: 28.5°C\"}"

The AI uses the industrial_command tool with protocol='mqtt' to send the command instantly:

# AI uses this internally
industrial_command(protocol='mqtt', command='publish', topic='factory/display/command', payload='{"action": "show_text", "text": "Workshop 1: 28.5°C"}')

Results Achieved

After deploying this integration:

Real-world impact: The plant reduced machine downtime by 18% because operators could instantly see alerts on the TFT screen without logging into a PC. The AI agent also logged all temperature data to a PostgreSQL database for trend analysis, flagging potential HVAC failures three days before they occurred.

Why This Matters: Zero-Code Integration

Traditional methods require:
- Writing C/C++ firmware for ESP32.
- Implementing MQTT client logic.
- Debugging JSON parsing.
- Setting up a dashboard server (Node-RED, Grafana).

With ASI Biont, you bypass all of that. The AI agent:
1. Understands your hardware (ILI9341, ST7789) from your description.
2. Generates appropriate MicroPython or Arduino code.
3. Connects via MQTT, Modbus, SSH, or COM port—whichever you specify.
4. Executes the integration in seconds.
5. Allows you to control the display through natural language.

Key takeaway: You can connect any device to ASI Biont. The AI writes the integration code using execute_python with access to libraries like pyserial, paramiko, paho-mqtt, pymodbus, aiohttp, and opcua-asyncio. No need to wait for platform developers to add support—just describe your device in the chat, and the AI handles the rest.

Conclusion

TFT LCD displays like ILI9341 and ST7789 are powerful tools for industrial visualization, but their true value emerges when paired with an intelligent AI agent. ASI Biont eliminates the programming barrier, enabling plant managers, engineers, and hobbyists to create responsive, real-time dashboards with minimal effort.

Whether you're monitoring a single sensor in a lab or orchestrating a factory floor with hundreds of machines, the combination of an ESP32, a TFT display, and ASI Biont gives you a flexible, scalable solution.

Ready to try it yourself?
Head over to asibiont.com, start a chat with the AI agent, and describe your device. Say something like:

"I have an ESP32 with an ILI9341 display and a DHT22 sensor. Connect it via MQTT to my broker at 192.168.1.50:1883. Show real-time temperature and send alerts above 35°C."

Watch as the AI writes the code, configures the connection, and brings your dashboard to life—in seconds, not hours.