From Static Displays to Dynamic Dashboards: Integrating HDMI (Raspberry Pi) with the ASI Biont AI Agent

Introduction

In the world of embedded systems and digital signage, the humble HDMI output on a Raspberry Pi has long been the go-to method for displaying information. Whether it’s a live dashboard of factory metrics, a rotating ad panel, or a real-time system monitor, the combination of a Pi and an HDMI screen is cheap, flexible, and ubiquitous. But there’s a catch: writing the code to update that display dynamically — pulling data from sensors, databases, or APIs — usually requires hours of manual scripting, debugging, and redeployment.

Enter ASI Biont, an AI agent that can write, test, and run integration code on the fly. Instead of spending a day crafting a Python script that polls a Modbus register and updates an image on an HDMI screen, you simply describe the task in a chat conversation. The AI generates the code, connects to your Raspberry Pi via SSH, and executes it — often in under a minute. This article explores how ASI Biont integrates with HDMI displays through a Raspberry Pi, using real connection methods and practical use cases.

How ASI Biont Connects to a Raspberry Pi

ASI Biont does not have a dedicated "HDMI" protocol — it doesn’t need one. The AI agent connects to the Raspberry Pi using SSH (via paramiko inside execute_python), which gives it full control over the Pi’s operating system. Once connected, the AI can:

• Write and run Python scripts that use libraries like Pillow (PIL) or pygame to generate images
• Save those images as files on the Pi
• Call external tools like fbi (frame buffer image viewer) or feh to display the image on the HDMI screen
• Update the display periodically using cron or a simple loop (with proper timeout handling)

Because ASI Biont runs the code in a secure cloud sandbox (execute_python), the actual SSH connection is made from a Python script that the AI writes and executes. The user only needs to provide the Pi’s IP address, username, and password or SSH key in the chat. The AI handles the rest.

Use Case: Real-Time Factory Dashboard on an HDMI Monitor

The Problem

A small manufacturing shop has a Raspberry Pi 4 connected to a 40-inch HDMI TV mounted on the wall. They want to display a live dashboard showing:

• Current machine status (from a Modbus/TCP PLC)
• Temperature and humidity (from an MQTT-connected ESP32)
• Daily production count (from a local SQLite database)

The dashboard must update every 5 seconds, and the owner wants to be able to change the layout without manually editing Python files on the Pi.

The Solution with ASI Biont

The user opens a chat with ASI Biont and describes the scenario:

"Connect to my Raspberry Pi at 192.168.1.100 via SSH (user: pi, key: ~/.ssh/id_rsa). Install feh if not present. Write a Python script that:
1. Reads a register from a Modbus device at 192.168.1.50:502 (register 0, holding register) — value is machine status (0=idle, 1=running, 2=alarm)
2. Subscribes to MQTT topic 'factory/sensor/temp' on broker 192.168.1.10:1883 to get temperature
3. Reads daily count from /home/pi/data/production.db (table counts, column total)
4. Generates a 1920x1080 image with three colored boxes showing these values
5. Saves to /home/pi/dashboard.png and displays it on the HDMI screen using feh --fullscreen --zoom fill"

The AI agent generates the Python code using pymodbus, paho-mqtt, sqlite3, and Pillow. It SSHs into the Pi, installs feh, writes the script, and runs it. The dashboard appears on the HDMI screen within 30 seconds.

Code Example (Simplified)

Below is a condensed version of what the AI might generate. Note: this runs on the Pi itself, not in the ASI Biont sandbox.

import pymodbus.client as ModbusClient
import paho.mqtt.client as mqtt
import sqlite3
from PIL import Image, ImageDraw, ImageFont
import time
import os

# Modbus read
client = ModbusClient.ModbusTcpClient('192.168.1.50', port=502)
client.connect()
status = client.read_holding_registers(0, 1).registers[0]
client.close()

# MQTT (last known value)
temp = 22.5  # simplified — in real code, use on_message callback

# SQLite
conn = sqlite3.connect('/home/pi/data/production.db')
cursor = conn.cursor()
cursor.execute('SELECT total FROM counts ORDER BY id DESC LIMIT 1')
count = cursor.fetchone()[0]
conn.close()

# Generate image
img = Image.new('RGB', (1920, 1080), color='black')
draw = ImageDraw.Draw(img)
font = ImageFont.truetype('/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf', 48)

status_colors = {0: 'gray', 1: 'green', 2: 'red'}
draw.rectangle([100, 100, 600, 400], fill=status_colors.get(status, 'blue'))
draw.text((150, 200), f'Machine: {status}', fill='white', font=font)
draw.rectangle([700, 100, 1200, 400], fill='blue')
draw.text((750, 200), f'Temperature: {temp}C', fill='white', font=font)
draw.rectangle([1300, 100, 1800, 400], fill='orange')
draw.text((1350, 200), f'Count: {count}', fill='white', font=font)

img.save('/home/pi/dashboard.png')
os.system('feh --fullscreen --zoom fill /home/pi/dashboard.png &')

This script updates every 5 seconds via a while loop with time.sleep(5). The AI can also set up a systemd service to make it persistent across reboots.

Comparison: Traditional Setup vs. ASI Biont

Why This Matters for Digital Signage and Monitoring

The ability to generate and display dynamic content on an HDMI screen via an AI agent opens up new possibilities:

• Ad panels: Pull data from a Google Sheets API and display rotating offers
• Server monitoring: Show CPU/RAM usage from multiple machines (via SSH)
• Smart home dashboards: Combine MQTT sensor data with calendar events
• Industrial KPI boards: Live OEE (Overall Equipment Effectiveness) from PLCs

Because ASI Biont can connect to any device using execute_python — including MQTT brokers, Modbus PLCs, HTTP APIs, and databases — the HDMI display becomes a universal visualization surface controlled entirely through natural language.

How to Get Started

No dashboard panels. No "add device" buttons. You simply open a chat with ASI Biont and say:

"Connect to my Raspberry Pi via SSH at 192.168.1.100, install feh, and show real-time sensor data on the HDMI screen."

The AI will:
1. Ask for any missing details (IP, credentials, data sources)
2. Generate the Python code using libraries from its sandbox (paramiko, pymodbus, paho-mqtt, Pillow, etc.)
3. SSH into the Pi, set up dependencies, run the script
4. Confirm the display is live

If you want to change the layout later, just type "Add a red alarm box when temperature exceeds 30°C" — the AI updates the script and redeploys.

Conclusion

The integration of HDMI displays via Raspberry Pi with ASI Biont transforms a static screen into an AI-managed dynamic dashboard. By leveraging SSH, the AI agent can control the entire lifecycle of the display — from code generation to deployment and iteration — without the user writing a single line of Python. The result is a faster, more flexible, and more accessible way to build real-time visualizations for factories, homes, and businesses.

Ready to turn your HDMI screen into an AI-powered dashboard? Start a chat at asibiont.com and describe your setup. The AI will handle the rest.