How to Connect Any UART Device to ASI Biont: COM-Port Integration Guide

The Serial Data Trap

You have a microcontroller on your bench — an ESP32, an Arduino Uno, or a STM32 — dutifully reading a temperature sensor, counting pulses, or controlling a relay. It prints data to the serial port at 115200 baud, and it works fine. But as soon as you need to combine that data with cloud services, send alerts, or let a colleague access it, you're stuck in the serial data trap. You need a terminal, a script, a port forward, and a lot of glue code.

ASI Biont eliminates the glue. This AI agent connects to your UART device through the same serial interface — no custom firmware, no cloud agent on the MCU, no PLC gateway. You just run a small Python bridge on the PC that's physically connected to your board, describe the task in natural language, and the AI takes it from there.

What Is UART and Why Does It Matter?

UART (Universal Asynchronous Receiver/Transmitter) is the simplest serial protocol used by almost every microcontroller on earth. It uses two wires: TX (transmit) and RX (receive), plus a common ground. RS-232 and RS-485 are industrial flavors of the same concept, and USB-to-serial chips turn UART into a virtual COM port on your laptop.

Why connect that to an AI agent? Because UART gives you direct, low-level access to the device. The agent can read sensor values, send configuration commands, monitor system logs, and even perform firmware-level tests. This is especially valuable when the MCU is part of a prototype or a small production line.

The Connection Method: COM Port Hardware Bridge

ASI Biont supports many industrial protocols natively — MQTT, Modbus/TCP, HTTP API, OPC-UA, SSH, and more. For UART, there's no network stack, so ASI Biont uses a Hardware Bridge (bridge.py). This is a small Python program you download from the ASI Biont dashboard (not from a random GitHub repo) and run on your PC.

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

• --token authenticates the bridge with your ASI Biont workspace.
• --ports lists the serial ports to expose (e.g., COM3 on Windows, /dev/ttyUSB0 on Linux).
• --baud sets the baud rate.
• --rate controls the polling frequency in Hz for the bridge to read data and forward it to the cloud.

The bridge does not open an HTTP endpoint. Instead, it creates a secure outbound tunnel to the ASI Biont cloud. Your chat-based AI agent can then interact with the serial port via a special built-in function called industrial_command(). This design keeps the bridge invisible — you never manage ports in a control panel, you just talk to the agent.

Quick Start: Connect an ESP32 to ASI Biont

1. Wire the MCU to your computer

For an ESP32 dev board, a built-in CP2102 or CH340 chip handles the USB-to-UART conversion. Connect the board with a USB cable and note the COM port. For an Arduino Uno or an FTDI adapter, use this wiring:

A clean 3.3V supply is needed for ESP32 boards; the USB port usually provides it.

2. Run the Hardware Bridge

Download bridge.py from asibiont.com/dashboard and run:

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

You'll see Bridge connected in the console.

3. Describe your device in the chat

Open the ASI Biont chat and type:

There's an ESP32 on COM3. It prints temperature as a float on a line every second. Read it and log it to a CSV file.

4. The AI writes and runs the integration

The agent's sandbox executes Python code. Here's the kind of script it might generate:

import csv, time
from datetime import datetime

for _ in range(10):
    # Send a command over the bridge to the serial port
    response = industrial_command(
        protocol='serial',
        command='{"action": "read_line", "port": "COM3"}'
    )
    line = response.get('data', '').strip()
    if line:
        temp = float(line)
        with open('temp_log.csv', 'a') as f:
            writer = csv.writer(f)
            writer.writerow([datetime.now().isoformat(), temp])
    time.sleep(1)

Note the industrial_command() signature — it's a sandbox built-in that routes the command back to the bridge. The script avoids while True because of the 30-second execution timeout; a bounded loop gets the job done.

On the ESP32 side, you might flash a simple MicroPython firmware that responds to requests:

from machine import UART, Pin, ADC
import time

uart = UART(1, baudrate=115200, tx=Pin(4), rx=Pin(5))
adc = ADC(Pin(34))

while True:
    if uart.any():
        cmd = uart.read()
        if b'read_line' in cmd:
            uart.write(str(round(adc.read_uv() / 10000, 2)) + '\n')

10 Practical Automation Scenarios with UART + ASI Biont

Here are ten real-world tasks you can automate right now. Each one is a conversation, not a project.

1. Serial log analysis — Point the bridge at a development board's debug UART and ask the AI to scan for error patterns. It will parse the stream and extract exceptions.
2. Automated hardware tests — For a production line, the AI can send a test command, read the response, and compare it against a known-good waveform.
3. MODBUS RTU sensor polling — Connect an RS-485 temperature transmitter to the bridge, and ask the AI to read holding register 0x0001 every minute and store it in InfluxDB.
4. Power-cycle monitoring — Have the AI toggle a relay through a UART command while monitoring the system's heartbeat on another serial port.
5. Legacy scale integration — Many old weigh scales output a continuous ASCII stream on RS-232. The AI can parse the weight, update a spreadsheet, and even trigger batching software.
6. Firmware over UART — While not a full flasher, the AI can send bootloader commands and upload a binary written in chunks over XMODEM (via the bridge's serial command).
7. Interactive robotics — Send next-velocity vectors to a robot controller over UART and receive encoder positions, letting the AI close a simple control loop.
8. Data fusion — Combine UART sensor data with an external HTTP API (e.g., weather) and generate a summary report.
9. Protocol translation — Let the AI convert UART/RS-485 data to MQTT messages for your IoT platform, no separate gateway needed.
10. Calibration automation — Instruct the AI to adjust coefficients on a sensor module by writing to certain registers and observing the output change.

Each scenario takes seconds to set up because the AI writes the parser, the retry logic, and the error handling automatically.

Universal execute_python: The Escape Hatch

What if your device doesn't use UART? ASI Biont also connects directly via MQTT (paho-mqtt), Modbus/TCP (pymodbus), HTTP API (aiohttp), OPC-UA (opcua-asyncio), SSH (paramiko), and more. And if the protocol isn't in the list, the execute_python tool lets the AI write a custom integration script from scratch. For example, you can ask: "Read from this random CAN device at 500k baud." The AI will generate a python-can script and run it in the sandbox.

The key difference: UART requires the bridge because the sandbox can't reach your physical COM port from the cloud. Once the bridge is running, it's as easy as any other protocol.

Security and Troubleshooting

• Token security: The token in the bridge command is equivalent to a password. Never put it in code, and rotate it from the dashboard if exposed.
• Isolated power: For industrial RS-232/RS-485, use a USB isolator to avoid ground loops between your PC and the equipment.
• Baud rate matching: Make sure the baud rate in the bridge matches the MCU firmware. A mismatch produces garbage bytes, which the AI can detect but better to avoid.
• RS-485 termination: If you're building a Modbus RTU network, add a 120-ohm termination resistor at each end of the bus to prevent reflections.
• Test with a loopback: Before connecting a real device, short TX and RX on the serial adapter and ask the AI to send hello. If it receives the same string, the bridge works.

For detailed protocol documentation, refer to the Espressif ESP32 Technical Reference (for UART registers), the Arduino Serial reference, and the Modbus Application Protocol Specification at modbus.org. ASI Biont's own docs are linked from your dashboard.

Try It Today

You don't need to wait for a custom software release or hire an integration engineer. With ASI Biont, you can connect any UART-based MCU to an AI agent in under ten minutes: download the bridge, run it, and describe your setup in the chat. The AI writes the code, debugs the connection, and delivers the result — all from a conversation.

Go to asibiont.com, grab your token, and give your serial devices a brain.