UART to AI: How ASI Biont Talks to Any Microcontroller Over a COM Port

The Problem: Legacy UART Devices Are Data Islands

UART (Universal Asynchronous Receiver/Transmitter) is the lingua franca of microcontrollers. From Arduino to STM32 to ESP32, virtually every MCU exposes one or more UART ports, often bridged to RS-232 or RS-485 for industrial use. The problem? These devices remain data islands. To integrate them into an AI-driven automation stack, you typically need a custom bridge application, a protocol translator, and hours of glue code.

When we tried to connect a legacy STM32-based data logger to an AI agent, we hit the usual wall: no network stack, no MQTT support, just a raw 8-bit UART stream. We needed an AI agent that could read sensor values and control actuators through natural language commands — without writing a custom middleware layer. That's exactly what ASI Biont does.

The Solution: Hardware Bridge for COM Ports

ASI Biont connects to physical UART devices through a Hardware Bridge — a small Python utility (bridge.py) downloaded from the ASI Biont dashboard. Unlike a traditional gateway that exposes a REST API, the bridge works in the opposite direction: it listens for commands from the AI agent over a secured WebSocket connection and forwards them to the COM port. The AI agent doesn't need to know the COM port name, baud rate, or parity settings — those are passed to the bridge at launch:

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

The --rate=10 parameter caps the polling rate to 10 Hz, which is more than enough for most sensor readouts. The bridge can handle multiple ports simultaneously (e.g., --ports=COM3,COM4).

Once the bridge is running, the AI agent can send industrial commands to the device via industrial_command(). No HTTP API, no custom endpoints — just a clean chat dialog where you describe what you want, and ASI Biont translates that into the appropriate UART frames.

Use Case: STM32-Based Temperature Logger

We had an STM32F103 board wired to a PT100 temperature sensor and a relay module. The MCU firmware was minimal (C with HAL), exposing a simple text protocol over UART at 115200 baud:

MCU Firmware (Simplified)

if (strcmp(cmd, "temp\n") == 0) {
    uint16_t adc = read_pt100_adc();
    float temp = adc_to_celsius(adc);
    char buf[32];
    snprintf(buf, sizeof(buf), "%.2f\n", temp);
    HAL_UART_Transmit(&huart1, (uint8_t*)buf, strlen(buf), 100);
}
if (strcmp(cmd, "relay on\n") == 0) HAL_GPIO_WritePin(RELAY_PIN, GPIO_PIN_SET);
if (strcmp(cmd, "relay off\n") == 0) HAL_GPIO_WritePin(RELAY_PIN, GPIO_PIN_RESET);

ASI Biont Integration

We launched the bridge and then opened a chat with the AI agent. The entire interaction was natural language:

User: Poll temperature every 10 seconds and log it. If it exceeds 45°C, turn the relay on.

ASI Biont responded with a sequence of industrial_command() calls:

# Generated by ASI Biont in response to the user request
import time

for i in range(6):  # sample 6 times for demo
    result = industrial_command(
        protocol="uart",
        port="COM3",
        baud=115200,
        command="temp"
    )
    temp = float(result.strip())
    if temp > 45:
        industrial_command(protocol="uart", port="COM3", command="relay on")
    else:
        industrial_command(protocol="uart", port="COM3", command="relay off")
    time.sleep(10)

No need to write a custom Python script by hand — the AI generated the integration logic, handled parsing, and even added a basic control loop.

Beyond COM: Universal execute_python

While the Hardware Bridge is the right choice for physical UART ports, ASI Biont also offers universal execute_python for devices that don't fit a standard protocol. The AI agent writes a short Python script and executes it in a sandbox with 30-second timeout. For network-connected MCUs (e.g., ESP32 over TCP socket), this is perfect:

# User: Read data from ESP32 at 192.168.1.42:9999
import socket
s = socket.create_connection(("192.168.1.42", 9999), timeout=5)
s.sendall(b"GET_TEMP\n")
data = s.recv(128)
print(data.decode().strip())

This means you're not limited to pre-built connectors. If a device speaks a custom binary protocol, you can simply paste a protocol description into the chat, and ASI Biont will write a Python parser using pyserial, struct, or numpy — all within the sandbox. The key benefit: no waiting for a vendor to add support. You can connect anything that gives you a serial stream or a TCP port, right now.

Real-World Results: From 2 Days to 20 Minutes

We ran a pilot at a small water treatment facility where legacy pH sensors were connected via RS-485 to an ESP32 board. The plant engineer wanted to monitor values in a dashboard and receive alerts on Telegram. With ASI Biont, the integration took under 20 minutes from bridge setup to live data flow:

These numbers are from our internal test deployment, not a formal benchmark. But they reflect a common pattern: the AI agent eliminates the ceremony of writing and debugging bridge code.

Why This Matters for Industrial Automation

UART is not glamorous, but it's everywhere — barcode scanners, industrial sensors, CNC controllers, GPS modules. Connecting them to an AI agent via a COM port bridge unlocks a new level of interactivity:

• Natural-language control — "read all sensors" becomes a chat message.
• Automatic protocol discovery — you can ask ASI Biont to reverse-engineer a simple text protocol by sending test frames.
• Predictive maintenance — instead of manually polling, you set up rules and have the AI watch the data stream.

ASI Biont doesn't force you into a single protocol. It supports MQTT, Modbus/TCP, OPC-UA, and dozens more. For UART specifically, the Hardware Bridge is the recommended path because it keeps the connection stable and respects the timing constraints of serial devices.

Try It Yourself

You don't need to be an embedded engineer to connect a microcontroller to ASI Biont. Download the bridge, plug in your UART device, and start chatting with your hardware. The AI agent writes the integration code, handles parsing, and even suggests baud rates based on your device description.

Ready to give your MCU a voice? Go to asibiont.com, start a project, and ask the agent to connect to your UART device. You'll be surprised how far a COM port can take you.