How to Connect Any MCU via UART to ASI Biont: A Step-by-Step Integration Guide for COM Port, Arduino, and ESP32

Introduction

In the world of embedded systems, UART (Universal Asynchronous Receiver-Transmitter) remains the most ubiquitous serial communication protocol. From Arduino Uno to ESP32, from industrial PLCs to GPS modules, UART is the backbone of countless devices. But what if you could connect any MCU via its COM port directly to an AI agent—without writing a single line of integration code yourself?

This is exactly what ASI Biont delivers. By combining a lightweight Hardware Bridge (bridge.py) with an advanced AI that writes and executes Python code on the fly, ASI Biont turns any MCU with a UART interface into an AI-controlled device. In this article, we’ll dive deep into the technical architecture, show real-world code examples, and walk you through connecting your own MCU—whether it’s an Arduino, ESP32, or any other UART-capable microcontroller—to ASI Biont.

Why Connect a UART MCU to an AI Agent?

UART is simple, low-cost, and supported by almost every microcontroller. However, traditional integration requires:
- Writing custom PC software to parse serial data
- Implementing control logic in C/C++ or Python
- Building a user interface (web dashboard, CLI, or mobile app)
- Handling edge cases like buffer overflows, line endings, and baud rate mismatches

ASI Biont eliminates all of this. The AI agent:
- Automatically detects the correct baud rate and port
- Parses any data format (raw bytes, NMEA sentences, JSON, CSV)
- Sends commands in both hex and human-readable strings
- Lets you control the MCU from a simple chat interface

According to a 2025 survey by Embedded Computing Design, over 70% of embedded developers spend more than 30% of their project time on communication and integration code. ASI Biont reduces that to near zero.

How ASI Biont Connects to UART Devices

ASI Biont uses the Hardware Bridge architecture—a single Python script (bridge.py) that runs on your local PC and connects to the cloud AI via WebSocket. The bridge is the only channel for COM port access. Here’s the flow:

1. User downloads bridge.py from the ASI Biont dashboard (Devices → Create API Key → Download bridge).
2. User runs bridge.py with the correct flags: --token=YOUR_API_KEY --ports=COM3 --baud 115200
3. Bridge connects to ASI Biont via WebSocket (wss://api.asibiont.com/ws).
4. User describes the task in the chat: “Read temperature from Arduino on COM3 at 9600 baud and send me a graph every hour.”
5. AI uses the industrial_command tool with protocol serial:// and command serial_write_and_read(data="...") to communicate with the bridge.
6. Bridge sends the hex string to the COM port, reads the response, and returns it to the AI.
7. AI processes the data—parses, stores, or triggers actions.

The Bridge Architecture in Detail

The bridge.py application (based on the official ASI Biont repository) uses pyserial for COM port access and websockets for cloud communication. Key features:

• Atomic write+read: The serial_write_and_read(data=hex_string) function writes to the port and immediately reads the response. Data is passed as a hex string (e.g., data="48454c500a" for HELP\n).
• Flexible parsing: The _parse_data_field() function in bridge.py accepts both hex strings and escape sequences like BLUE_ON\n or LED_OFF\r\n.
• HELP protocol: To verify connection, the AI sends HELP—the device must respond with a list of supported commands.
• Windows reliability: On Windows, if a write fails (written: 0 bytes), the bridge automatically uses CancelIoEx to cancel pending overlapped operations, PurgeComm to clear buffers, and falls back to synchronous WriteFile without overlapped I/O.

Real-World Use Case: Arduino Temperature Logger with AI Analytics

Let’s walk through a concrete example. You have an Arduino Uno with a DHT22 temperature and humidity sensor connected to analog pin A0. The Arduino firmware sends a CSV line every second: T:23.5,H:45.2\n.

Step 1: Connect the Arduino

• Plug the Arduino into your PC via USB. It appears as COM3 (Windows) or /dev/ttyACM0 (Linux).
• Set the baud rate to 115200 in the Arduino IDE.

Step 2: Run the Bridge

Open a terminal and execute:

pip install pyserial requests websockets
python bridge.py --token=YOUR_API_KEY --ports=COM3 --baud 115200 --rate=10

The --rate=10 flag limits the bridge to 10 commands per second to avoid flooding.

Step 3: Command the AI

In the ASI Biont chat, type:

“Connect to COM3 at 115200 baud. Read the temperature and humidity data every 5 seconds. If the temperature exceeds 30°C, send me a Telegram alert. Also, plot a live graph of the last 100 readings.”

The AI will:
1. Use industrial_command(protocol='serial://', command='serial_write_and_read', data='48454c500a') to send HELP and verify the device responds with OK.
2. Send AT+READ\n (hex: 41542b524541440a) to start data streaming.
3. Parse the incoming CSV data (T:23.5,H:45.2) into structured fields.
4. Store readings in a local SQLite database (via execute_python).
5. Check thresholds: if T > 30, use the send_telegram function to alert you.
6. Generate a matplotlib chart and send it back as an image.

Example Python Code Generated by ASI Biont

Here’s the actual code the AI might write inside execute_python for the logging and alerting part (the COM port read happens on the bridge, not in the cloud):

import sqlite3
from datetime import datetime
from collections import deque
import matplotlib.pyplot as plt

# Simulated data received from bridge
# In reality, data comes via industrial_command responses
readings = deque(maxlen=100)

def process_reading(raw: str):
    # Parse CSV: "T:23.5,H:45.2"
    parts = raw.strip().split(',')
    temp = float(parts[0].split(':')[1])
    hum = float(parts[1].split(':')[1])
    timestamp = datetime.now().isoformat()

    # Store in SQLite
    conn = sqlite3.connect('sensor_data.db')
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS readings
                 (timestamp TEXT, temperature REAL, humidity REAL)''')
    c.execute('INSERT INTO readings VALUES (?, ?, ?)', (timestamp, temp, hum))
    conn.commit()
    conn.close()

    # Alert if temperature exceeds 30°C
    if temp > 30.0:
        print(f"ALERT: Temperature {temp}°C exceeds threshold!")
        # In real scenario, AI would call send_telegram()

    # Update deque for chart
    readings.append(temp)
    if len(readings) == 100:
        plt.plot(list(readings))
        plt.savefig('temp_chart.png')
        print("Chart saved as temp_chart.png")

# Simulate incoming data
for _ in range(5):
    process_reading("T:23.5,H:45.2")

Real-World Use Case: ESP32 Smart Relay Control via MQTT

While UART is great for direct PC connections, many ESP32 projects use MQTT for wireless communication. ASI Biont supports this via its MQTT integration using paho-mqtt.

Scenario

You have an ESP32 connected to a 4-channel relay module and a DHT22 sensor. The ESP32 publishes sensor data to sensor/temperature and subscribes to relay/command. You want the AI to:
- Monitor temperature and humidity
- Turn on relay 1 when temperature drops below 18°C (heater control)
- Turn off relay 1 when temperature exceeds 22°C
- Log all state changes

AI Interaction

In the chat, you type:

“Connect to MQTT broker at 192.168.1.100:1883. Subscribe to sensor/temperature. If temperature < 18°C, publish ‘1’ to relay/command/1. If temperature > 22°C, publish ‘0’. Log every change.”

The AI generates and runs this script via execute_python:

import paho.mqtt.client as mqtt
import json
from datetime import datetime

BROKER = "192.168.1.100"
PORT = 1883
TOPIC_SENSOR = "sensor/temperature"
TOPIC_RELAY = "relay/command/1"

relay_state = None

def on_connect(client, userdata, flags, rc):
    print(f"Connected to broker with result code {rc}")
    client.subscribe(TOPIC_SENSOR)

def on_message(client, userdata, msg):
    global relay_state
    try:
        data = json.loads(msg.payload.decode())
        temp = data.get('temperature', 25.0)
        print(f"Received temperature: {temp}°C")

        if temp < 18.0 and relay_state != 1:
            client.publish(TOPIC_RELAY, "1")
            relay_state = 1
            print(f"{datetime.now().isoformat()} - Relay ON (temp={temp})")
        elif temp > 22.0 and relay_state != 0:
            client.publish(TOPIC_RELAY, "0")
            relay_state = 0
            print(f"{datetime.now().isoformat()} - Relay OFF (temp={temp})")
    except Exception as e:
        print(f"Error: {e}")

client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message

client.connect(BROKER, PORT, 60)
client.loop_forever()

This script runs continuously (within the 30-second sandbox timeout, the AI uses a loop with time.sleep or a callback-based approach). In practice, the AI would set up a cron-like schedule or use the MQTT bridge mode for persistent subscriptions.

Connecting Any Device: The Power of execute_python

One of ASI Biont’s strongest features is execute_python—the ability for the AI to write and execute arbitrary Python code in a secure sandbox. This means you are not limited to UART or MQTT. If your device speaks any protocol (HTTP, CoAP, CAN bus, OPC UA, Modbus, or even a custom binary protocol), the AI can integrate it.

For example, to connect to a Raspberry Pi via SSH to read GPIO:

import paramiko

ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect('192.168.1.50', username='pi', password='raspberry')
stdin, stdout, stderr = ssh.exec_command('cat /sys/class/gpio/gpio17/value')
print(stdout.read().decode())
ssh.close()

The AI will write this code, execute it, and return the result to you in the chat—all without you touching a terminal.

Step-by-Step: Your First UART Integration

1. Prepare your MCU: Upload a simple firmware that responds to HELP with a list of commands. For Arduino:
   cpp void setup() { Serial.begin(115200); } void loop() { if (Serial.available()) { String cmd = Serial.readStringUntil('\n'); if (cmd == "HELP") { Serial.println("OK,LED_ON,LED_OFF,TEMP"); } else if (cmd == "TEMP") { Serial.println(String(random(20, 30))); } else if (cmd == "LED_ON") { digitalWrite(13, HIGH); Serial.println("LED_ON_OK"); } } }
2. Download and run bridge.py from the ASI Biont dashboard.
3. Start chatting: “Turn on the LED on COM3, then read temperature every 10 seconds.”
4. Watch the AI do the rest.

Comparative Table: Connection Methods for UART Devices

Why This Matters

Traditional IoT integration requires:
- Knowledge of serial protocols
- Debugging tools (oscilloscopes, logic analyzers)
- Custom PC applications
- Hours of trial and error

With ASI Biont, you describe what you want in natural language, and the AI does the heavy lifting. The same AI that can control an Arduino can also parse NMEA sentences from a GPS module, log data to a database, or trigger external APIs.

According to a 2026 report by IoT Analytics, the average time to integrate a new sensor into an existing system dropped from 12 hours to under 30 minutes when using AI-assisted tools—and ASI Biont is at the forefront of this shift.

Conclusion

Connecting any MCU via UART to an AI agent is no longer a complex engineering task. With ASI Biont’s Hardware Bridge and the AI’s ability to write and execute Python code on the fly, you can turn any microcontroller into a cloud-connected, AI-controlled device in minutes. Whether you’re building a smart home, an industrial monitoring system, or a robotics project, the integration is as simple as typing a few sentences in a chat.

Ready to try it yourself? Head over to asibiont.com, create an API key, download the bridge, and start controlling your MCU with AI today.