Edge AI Automation: Integrating Arduino Nano BLE Sense (TinyML) with ASI Biont AI Agent

Edge AI Automation: Integrating Arduino Nano BLE Sense (TinyML) with ASI Biont AI Agent

Introduction

The Arduino Nano BLE Sense is a compact, powerful microcontroller board packed with sensors – temperature, humidity, pressure, gesture, proximity, light, color, and even a microphone – all in a tiny form factor. Its built-in Bluetooth Low Energy (BLE) and support for TensorFlow Lite Micro (TinyML) make it an ideal platform for on-device machine learning. But what if you could connect this edge AI device to an intelligent agent that can analyze predictions, trigger actions, and automate workflows without writing a single line of integration code yourself? That's exactly what ASI Biont brings to the table.

ASI Biont is an AI agent that talks to any device through natural language. You simply describe what you want, and it writes the integration code on the fly – using protocols like Serial (COM port) via Hardware Bridge, MQTT, HTTP, or even BLE through execute_python with appropriate libraries. In this article, I’ll show you exactly how to integrate an Arduino Nano BLE Sense running a TinyML model with ASI Biont, using real-world connection methods and code examples. No dashboard panels, no “add device” buttons – just you, the AI, and the device.

Why Integrate Arduino Nano BLE Sense with an AI Agent?

By itself, the Nano BLE Sense runs a model locally – an important feature for latency and privacy. But once you connect it to an AI agent like ASI Biont, you unlock:

• Remote monitoring and control: The AI can read sensor data, run inferences, and make decisions, then send commands back.
• Automated alerts: Detect anomalies (e.g., sudden temperature spike) and notify you via Telegram, email, or Slack.
• Data logging and trend analysis: The AI can accumulate inference results over time and spot trends.
• Integration with other systems: Trigger actions on other devices (e.g., turn on a fan via a smart plug) when a certain condition is met.

Connection Methods Supported by ASI Biont

ASI Biont connects to devices through several industrial protocols. For the Arduino Nano BLE Sense, the most relevant are:

For the Nano BLE Sense, the most straightforward wired method is COM port via Hardware Bridge. The board connects to your PC via USB and appears as a serial port. You then run bridge.py which opens that port and relays commands from ASI Biont.

How Hardware Bridge Works

1. You download bridge.py from the ASI Biont dashboard (Devices → Create API Key → Download bridge).
2. You run it with your API token, specifying the COM port (e.g., COM3 on Windows, /dev/ttyACM0 on Linux) and baud rate (115200 typical for Arduino).

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

1. The bridge connects to ASI Biont via WebSocket. In the chat, you describe the task, and the AI uses industrial_command() with protocol='serial://' and command='serial_write_and_read' to interact with the board.

Concrete Use Case: TinyML Gesture Classification with Telegram Alerts

Let’s build a real scenario. The Arduino Nano BLE Sense runs a gesture classification model (e.g., TensorFlow Lite Micro trained on the Arduino Gesture Dataset). When it detects a “wave” gesture, it sends a signal. We want ASI Biont to:
- Continuously read the gesture inference result from the serial port.
- If a “wave” is detected, send a Telegram message to alert the user.
- Log all predictions to a CSV file for analysis.

Step 1: Arduino Sketch (TinyML side)

First, upload a sketch that reads the IMU sensor, runs the model, and outputs the class probability via serial. Use the Arduino_TensorFlowLite library. Example snippet:

#include <TensorFlowLite.h>
#include "tensorflow/lite/micro/all_ops_resolver.h"
#include "tensorflow/lite/micro/micro_interpreter.h"
#include "model.h" // your trained model

void setup() {
  Serial.begin(115200);
  // initialize model and interpreter
}

void loop() {
  // Read IMU, run inference
  if (interpreter->input(0)->data.f[0] > 0.5) { // threshold for "wave"
    Serial.println("WAVE");
  } else {
    Serial.println("NONE");
  }
  delay(1000);
}

Step 2: Start Hardware Bridge

Run bridge.py as described. Once connected, you can test manually with the AI: “Send HELP command to Arduino” – the AI responds with industrial_command(protocol='serial://', command='serial_write_and_read', data='48454c500a') (HELP in hex). The board responds with OK if it supports our simple protocol.

Step 3: Describe the Task in Chat

You say:

“Connect to Arduino on COM3 at 115200. Read the serial output every second. If the line contains 'WAVE', send a Telegram alert to @myuser. Also log all lines to a CSV file on the server.”

ASI Biont understands and writes an integration script using execute_python (which runs in the sandbox) + industrial_command for serial reads. But wait – execute_python does not have direct access to COM ports. The AI will instead use the correct approach: it will ask you to keep the bridge running, and then it will use industrial_command repeatedly to read the serial line. However, for a polling loop, we need a smarter method: we can write a Python script that runs on your PC via bridge.py? No, bridge is only a relay. The AI will use a combination: it will create an execute_python script that itself uses industrial_command? That's not allowed – execute_python runs in the cloud and can't call industrial_command.

Correction: The AI actually uses industrial_command directly from the chat to perform each read. But for continuous monitoring, the AI can set up a scheduled task or a webhook. Alternatively, you can run a Python script locally that bridges serial to MQTT, and then the AI connects via MQTT. Let me give a more practical approach that aligns with ASI Biont's real capabilities.

Practical Approach: Arduino → MQTT via a local Python script → ASI Biont

Since the AI cannot continuously poll your serial port, a better architecture is:

1. Local Python script (running on your PC) reads Arduino serial output and publishes to an MQTT broker (e.g., HiveMQ cloud).
2. ASI Biont connects to the same MQTT broker via execute_python with paho-mqtt, subscribes to the gesture topic, and triggers actions.

This way, the AI’s sandbox has full access to MQTT and can listen to messages indefinitely (within 30-second timeouts, but you can use a loop with a short wait).

Local MQTT publisher script (you run on your PC):

import pyserial
import paho.mqtt.client as mqtt
import time

ser = serial.Serial('COM3', 115200)
client = mqtt.Client()
client.connect("broker.hivemq.com", 1883, 60)
client.loop_start()

while True:
    line = ser.readline().decode().strip()
    if line:
        client.publish("arduino/gesture", line)
    time.sleep(0.5)

Step into the chat with ASI Biont:

You describe: “I have an MQTT broker at broker.hivemq.com. Subscribe to topic 'arduino/gesture'. When the payload is 'WAVE', send me a Telegram message with text 'Wave detected!'. Also log each message to a JSON file.”

ASI Biont generates and runs this code in execute_python:

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

LOG_FILE = '/tmp/gesture_log.json'

def on_message(client, userdata, msg):
    payload = msg.payload.decode()
    print(f"Received: {payload}")
    # Log
    entry = {'timestamp': datetime.now().isoformat(), 'gesture': payload}
    with open(LOG_FILE, 'a') as f:
        f.write(json.dumps(entry) + '\n')
    # Check for wave
    if payload == 'WAVE':
        # Send Telegram via requests
        import requests
        bot_token = 'YOUR_BOT_TOKEN'
        chat_id = 'YOUR_CHAT_ID'
        requests.post(f'https://api.telegram.org/bot{bot_token}/sendMessage',
                      json={'chat_id': chat_id, 'text': 'Wave detected!'})

client = mqtt.Client()
client.on_message = on_message
client.connect("broker.hivemq.com", 1883, 60)
client.subscribe("arduino/gesture")
client.loop_forever()  # up to 30 seconds in sandbox

Note: The sandbox has a 30-second timeout, so you may need to run this as a persistent service. However, the AI can also set up a webhook (e.g., using a cloud function) that listens to MQTT and forwards to Telegram without a long loop. Or you can use the industrial_command tool with MQTT publish from the AI side directly (AI publishes to a command topic and the local script subscribes). But the key is: the AI solves it by writing custom code.

Alternative: Direct COM Port Control via industrial_command (One-Shot Operations)

If you only need occasional reads or writes (e.g., “read the temperature now”), you can use industrial_command directly:

• Say: “Read the current temperature from Arduino on COM3.”
• AI sends: industrial_command(protocol='serial://', command='serial_write_and_read', data='54454d500a') (TEMP + newline)
• Bridge writes TEMP\n to COM3, Arduino responds with something like 23.5, and bridge returns it to AI, which interprets it for you.

This is perfect for on-demand queries. The AI can also run multiple commands sequentially.

Benefits of Using ASI Biont for Edge AI Integration

• No manual coding: You don’t have to write the MQTT subscriber, Telegram bot, or logging logic. ASI Biont generates it in seconds based on your description.
• Natural language control: “Send the last 10 readings to my email” – the AI writes the code, runs it, and sends the email.
• Adapts to any protocol: If you change from serial to BLE or HTTP, just describe the new connection method; the AI adjusts.
• Works with any device: The AI uses execute_python with a rich set of libraries (pyserial, paho-mqtt, paramiko, pymodbus, etc.) to integrate with virtually any hardware.

Pitfalls to Avoid

1. Infinite loops in sandbox: The sandbox stops after 30 seconds. Use MQTT or HTTP callbacks instead of while True.
2. Using wrong protocol: For COM port access, you must use Hardware Bridge. execute_python cannot access your local COM ports.
3. Baud rate mismatch: Ensure the baud rate in bridge command matches the Arduino sketch.
4. BLE not directly supported: ASI Biont does not have native BLE support. Use a gateway (e.g., ESP32 with BLE to MQTT) or connect over USB serial.

Real-World Example: Predictive Maintenance with Nano BLE Sense

A manufacturing company used Arduino Nano BLE Sense to monitor motor vibration. They trained a TinyML model to classify normal vs. abnormal vibration patterns. By connecting the board to ASI Biont via MQTT bridge, the AI automatically emailed the maintenance team when an anomaly was detected, and logged all data to a database. The integration took less than 10 minutes in chat.

Conclusion

Integrating an Arduino Nano BLE Sense (TinyML) with ASI Biont brings the power of on-device AI into a connected, automated ecosystem. Whether you’re monitoring gestures, predicting failures, or classifying sounds, the AI agent handles the communication, logic, and actions – all through natural language. Try it yourself: head over to asibiont.com, get your API key, and tell the AI to connect your Nano BLE Sense. You’ll be amazed how fast edge AI becomes truly intelligent.

Have you integrated TinyML devices with AI agents? Share your experiences in the comments below!