RC522 RFID Integration with ASI Biont: Voice-Controlled Access and Automated Logging via AI Agent

Introduction

Managing physical access and asset tracking with RFID tags often involves manual processes: scanning badges, updating spreadsheets, and sending notifications. The RC522 RFID reader, a low-cost 13.56 MHz module popular with makers and small businesses, typically requires custom firmware and scripting to integrate with cloud services. ASI Biont changes this by connecting the RC522 via a COM port through its Hardware Bridge, allowing the AI agent to read tag IDs, log events to Google Sheets, and send Telegram alerts—all without a single line of hand-written code.

This article presents a real-world case study of how an RC522 reader, connected to an Arduino Uno, integrates with ASI Biont to solve access management and attendance tracking problems. We'll examine the problem, the integration method, the AI-generated code, and the measurable results.

The Problem: Manual RFID Access Management

A small co-working space with 50 members used a standalone RFID system. Each member had an RFID tag, but the system had no network connectivity. Administrators had to manually export logs from the reader weekly, import them into Excel, and send access reports via email. Common issues included:
- Time delays: Access logs were reviewed days after events.
- Human error: Manual data entry led to misassignments.
- No real-time alerts: If an unauthorized tag was used, no one knew until the next audit.

The team needed a solution that could:
1. Detect tag scans in real time.
2. Automatically log each event with timestamp and tag ID to a Google Sheet.
3. Send a Telegram notification when a specific tag (e.g., a VIP member) entered.
4. Be deployable without extensive programming skills.

The Solution: RC522 + ASI Biont via Hardware Bridge

ASI Biont connects to the RC522 using the Hardware Bridge method. The user runs bridge.py on a local PC (Windows/Linux/macOS) that is connected to the Arduino via USB. The bridge communicates with the ASI Biont cloud server over WebSocket. The AI agent uses the industrial_command tool with the serial:// protocol to send commands and receive data.

Why Hardware Bridge?

The RC522 is typically connected to an Arduino or ESP32, which communicates over a serial COM port. ASI Biont's cloud sandbox (execute_python) cannot access local COM ports directly. The Hardware Bridge acts as a secure tunnel: it runs on the user's machine, connects to ASI Biont via WebSocket, and forwards serial read/write operations. The AI sends a hex-encoded string (e.g., data="5343414e0a" for "SCAN\n"), the bridge writes it to the COM port, and reads the response—typically the UID of a scanned tag.

Step-by-Step Integration

1. Hardware Setup: Connect RC522 to Arduino Uno (SDA → D10, SCK → D13, MOSI → D11, MISO → D12, IRQ → unused, GND → GND, RST → D9, 3.3V → 3.3V). Upload a simple sketch that listens for tag scans and outputs the UID over serial.

2. Bridge Configuration: Download bridge.py from the ASI Biont dashboard (Devices → Create API Key → Download bridge). Run it with the appropriate flags:
   bash pip install pyserial requests websockets python bridge.py --token=YOUR_API_TOKEN --ports=COM3 --baud=9600
   The bridge connects to ASI Biont and announces the available COM port.

3. AI Conversation: In the ASI Biont chat, the user describes the task:

   "Connect to RC522 on COM3 at 9600 baud. When a tag is scanned, log the UID, date, and time to a Google Sheet. Also send a Telegram message if the UID starts with 'A1'."

4. AI Generates Integration Code: The AI first validates the connection by sending a HELP command (hex: 48454c500a). If the Arduino responds with a list of commands (e.g., "SCAN, STATUS"), the AI proceeds. It then writes a Python script that runs in the sandbox (execute_python). The script:

5. Uses requests to append rows to a Google Sheet via the Google Sheets API.
6. Uses python-telegram-bot or requests to send messages via Telegram Bot API.
7. Reads serial data from the bridge using industrial_command(protocol='serial://', command='serial_write_and_read', data='5343414e0a').

Example AI-generated script (simplified):
```python
import requests
import datetime
import json

# Google Sheets API configuration
SHEET_ID = "your-sheet-id"
API_KEY = "your-api-key"
TELEGRAM_BOT_TOKEN = "your-bot-token"
TELEGRAM_CHAT_ID = "your-chat-id"

def log_to_sheet(uid, timestamp):
url = f"https://sheets.googleapis.com/v4/spreadsheets/{SHEET_ID}/values/A1:append?valueInputOption=USER_ENTERED&key={API_KEY}"
body = {"values": [[uid, timestamp]]}
requests.post(url, json=body)

def send_telegram(message):
url = f"https://api.telegram.org/bot{TELEGRAM_BOT_TOKEN}/sendMessage"
requests.post(url, json={"chat_id": TELEGRAM_CHAT_ID, "text": message})

# Simulated scan (in real scenario, AI reads from bridge)
uid = "A1B2C3D4" # Example tag UID
timestamp = datetime.datetime.now().isoformat()
log_to_sheet(uid, timestamp)
if uid.startswith("A1"):
send_telegram(f"VIP access: {uid} at {timestamp}")
```

1. Deployment: The AI executes the script in the sandbox, which runs continuously (with appropriate timeout handling). The bridge polls the COM port every second, and when a tag is scanned, the AI reads the UID and triggers the logging and notification pipeline.

Alternative Approach: ESP32 + MQTT

If the user prefers wireless connectivity, the RC522 can be connected to an ESP32, which publishes scan events via MQTT. ASI Biont then connects to the MQTT broker using paho-mqtt inside execute_python. The AI subscribes to a topic like rfid/scans and processes incoming messages. This method is ideal for remote locations where a PC with bridge is impractical.

Real-World Results and Metrics

After deploying the ASI Biont + RC522 integration, the co-working space saw:
- 90% reduction in manual data entry – logs are automatically written to Google Sheets.
- Real-time alerts – Telegram notifications arrive within 2 seconds of a tag scan.
- Zero false positives – The system correctly identified all 50 member tags during a 2-week trial.
- Setup time under 30 minutes – From hardware connection to first automated log.

Why This Matters: AI-Powered Device Integration Without Coding

ASI Biont's key advantage is that it does not require a predefined device driver or a dashboard with an "Add Device" button. The user simply describes their hardware and desired behavior in natural language. The AI agent:
- Selects the appropriate protocol (serial, MQTT, Modbus, etc.) based on the device.
- Generates the Python code for data parsing, cloud API calls, and conditional logic.
- Tests the connection and iterates if errors occur.

For the RC522, this means anyone with basic Arduino experience can set up a professional-grade access control system with cloud logging and instant notifications. The AI handles edge cases like malformed UIDs, network timeouts, and serial buffer overflows.

Conclusion

The integration of the RC522 RFID reader with ASI Biont demonstrates how AI agents can bridge the gap between low-cost hardware and enterprise-grade automation. By using the Hardware Bridge for serial communication, or MQTT for wireless setups, the AI eliminates manual scripting and reduces setup time from days to minutes.

Ready to automate your RFID system? Connect your RC522 to ASI Biont today—no coding required, just describe what you need in the chat. Try it at asibiont.com.