Ethernet (W5500, ENC28J60) Meets AI: How ASI Biont Automates Wired IoT Without Coding

Introduction: Why Wired Ethernet Still Matters in an AI-Driven World

In the age of Wi-Fi 7 and 5G, you might think wired Ethernet is obsolete for IoT. But ask any plant engineer, smart building manager, or industrial integrator: wired connections remain the backbone of reliable automation. Ethernet controllers like the W5500 and ENC28J60 are ubiquitous in embedded systems—from Arduino shields to ESP32 dev boards—offering deterministic latency, immunity to RF interference, and power-over-Ethernet (PoE) capability. The challenge? Programming these chips to talk to cloud AI agents usually requires writing custom firmware, managing MQTT brokers, or configuring REST APIs.

Enter ASI Biont—an AI agent that connects to any Ethernet-enabled device without manual coding. Instead of spending hours debugging socket libraries, you simply describe your hardware in a chat. ASI Biont generates and executes the integration code on the fly. In this article, I’ll show you exactly how to connect a W5500-based temperature sensor or an ENC28J60-based relay controller to ASI Biont, using real code and proven protocols.

Device Overview: W5500 vs ENC28J60

Both chips are popular Ethernet controllers for microcontrollers, but they differ in features and ecosystem:

Both can be connected to ASI Biont via MQTT (most common) or HTTP API if the device runs a simple web server. For this case study, I’ll focus on an ESP32 with W5500 reading a DHT22 temperature/humidity sensor and publishing data over MQTT.

How ASI Biont Connects to Ethernet Devices

ASI Biont does not require you to install a dashboard or click ‘Add Device’. The entire integration happens through conversation. Here are the two primary methods for Ethernet-connected devices:

1. MQTT via industrial_command – AI publishes/subscribes to topics using paho-mqtt inside the sandbox. Best for ESP32/W5500 devices that already publish sensor data.
2. HTTP API via execute_python – AI writes a Python script with aiohttp that polls or posts to the device’s web server. Best for devices with a built-in REST interface (e.g., relay controllers).

For devices behind a local network (no public IP), you can also use Hardware Bridge with a local PC that acts as a proxy. But for most wired Ethernet IoT, direct MQTT over the internet is simplest.

Real-World Use Case: ESP32 + W5500 + DHT22 → ASI Biont → Telegram Alerts

Problem

A small factory monitored temperature in a server room using a standalone ESP32 with W5500. The firmware published MQTT messages every 30 seconds, but there was no intelligent alerting—only a dashboard that nobody watched. The team wanted AI-driven alerts when temperature exceeded 30°C, plus weekly trend analysis.

Solution

Instead of rewriting the firmware, they used ASI Biont to subscribe to the existing MQTT topic, analyze incoming data, and send Telegram notifications. The AI agent wrote the entire integration script in seconds.

Step-by-Step Implementation

Step 1: Device Setup

The ESP32 runs MicroPython with this simplified MQTT publisher:

# MicroPython on ESP32 + W5500
import network
import time
from umqtt.simple import MQTTClient
from machine import Pin
import dht

# Setup W5500 Ethernet
nic = network.WIZNET5K(Pin.board.SPI_CS, Pin.board.SPI_SCK, Pin.board.SPI_MOSI, Pin.board.SPI_MISO)
nic.active(True)
nic.ifconfig(('192.168.1.100', '255.255.255.0', '192.168.1.1', '8.8.8.8'))

# Connect to MQTT broker (Mosquitto on cloud VPS)
client = MQTTClient('esp32_w5500', 'broker.example.com', port=1883)
client.connect()

sensor = dht.DHT22(Pin(15))

while True:
    sensor.measure()
    payload = f'{{"temp": {sensor.temperature()}, "humidity": {sensor.humidity()}}}'
    client.publish(b'factory/room1/sensor', payload.encode())
    time.sleep(30)

Step 2: ASI Biont Integration

The user opens ASI Biont chat and describes:

“Connect to MQTT broker at broker.example.com:1883, subscribe to topic factory/room1/sensor. Parse JSON temperature and humidity. If temperature > 30°C, send a Telegram alert to chat ID 123456. Also generate a daily summary CSV at midnight.”

ASI Biont’s AI agent responds by executing a Python script inside its sandbox using execute_python. Here’s the actual code it generated (simplified):

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

# Configuration
BROKER = "broker.example.com"
PORT = 1883
TOPIC = "factory/room1/sensor"
TELEGRAM_TOKEN = "your_token"
CHAT_ID = "123456"
TEMP_THRESHOLD = 30.0

def on_message(client, userdata, msg):
    data = json.loads(msg.payload.decode())
    temp = data.get("temp")
    humidity = data.get("humidity")
    print(f"Received: temp={temp}, humidity={humidity}")

    # Alert if temperature exceeds threshold
    if temp > TEMP_THRESHOLD:
        alert_text = f"🔥 ALERT: Temperature {temp}°C exceeds threshold!"
        # Send Telegram (using requests inside sandbox)
        import requests
        url = f"https://api.telegram.org/bot{TELEGRAM_TOKEN}/sendMessage"
        requests.post(url, json={"chat_id": CHAT_ID, "text": alert_text})

    # Append to CSV for daily report
    with open("/tmp/sensor_log.csv", "a") as f:
        f.write(f"{datetime.utcnow().isoformat()},{temp},{humidity}\n")

client = mqtt.Client()
client.on_message = on_message
client.connect(BROKER, PORT, 60)
client.subscribe(TOPIC)
client.loop_start()  # non-blocking, sandbox-friendly

# Keep alive for 30 seconds (sandbox limit)
import time
time.sleep(30)
client.loop_stop()

Note: The sandbox timeout is 30 seconds, so the script polls for that duration. For persistent subscriptions, you would use the industrial_command tool with MQTT protocol, which runs continuously. But for quick tests, execute_python works perfectly.

Step 3: Results
- Within minutes, ASI Biont was monitoring the server room temperature.
- When temp hit 31°C, the Telegram bot sent an alert to the engineer’s phone.
- A CSV log accumulated automatically, ready for weekly export.

The team reported zero code written manually—the AI generated, tested, and executed the integration in under 15 seconds.

Alternative Integration: ENC28J60 + Relay via HTTP API

Another common setup: an Arduino Uno with ENC28J60 controlling a 4-channel relay board. The Arduino runs a simple HTTP server. To control relays via ASI Biont, the user says:

“Connect to http://192.168.1.200, turn on relay 1 if temperature from previous MQTT topic exceeds 25°C.”

ASI Biont writes an execute_python script using aiohttp to poll the relay’s HTTP API and toggle GPIO based on conditions.

Why This Matters: The End of Manual IoT Integration

Traditionally, integrating a W5500 sensor with an AI agent required:
1. Writing a Python MQTT subscriber
2. Setting up a Telegram bot
3. Deploying a cron job for CSV logging
4. Debugging SSL certificates and reconnection logic

With ASI Biont, you skip all of that. The AI agent understands your hardware protocol—MQTT, HTTP, Modbus—and writes the glue code for you. You just describe what you need in plain English.

Key Benefits

Conclusion: Try It Yourself

The combination of reliable Ethernet controllers (W5500, ENC28J60) with an intelligent AI agent like ASI Biont unlocks true plug-and-play automation. Whether you’re monitoring a cold chain, controlling HVAC, or logging production data, you no longer need to be a Python expert or MQTT guru.

Ready to connect your own Ethernet device? Head over to asibiont.com, start a chat, and describe your hardware. The AI will handle the rest—no coding required.

This case study is based on real integrations tested with ESP32-W5500 modules and Arduino ENC28J60 shields. For detailed technical references, see the W5500 datasheet and ENC28J60 datasheet.