DC Motors Meet AI: Practical L298N and BTS7960 Integration with ASI Biont

Why Connect a DC Motor Driver to an AI Agent?

DC motors are the muscles of robotics—from robot wheels and conveyor belts to smart blinds and winches. But traditional control systems force you to manually handle wiring, PWM timing, serial protocols, and state machines. When an AI agent like ASI Biont enters the picture, it can take over the entire integration lifecycle: it reads the motor driver datasheet, suggests a wiring diagram, writes the microcontroller firmware, and then controls the motor through simple chat commands.

ASI Biont is not a drag-and-drop dashboard. It connects to hardware through a text-based dialog. You describe your device, and the agent picks the right protocol: COM port through the Hardware Bridge, MQTT, Modbus/TCP, SSH, HTTP API, OPC-UA, and many more. For L298N and BTS7960 motor drivers, the most direct and reliable path is a USB-to-serial connection from a PC to an Arduino or ESP32 running a tiny serial interpreter.

L298N vs BTS7960: Which Driver Fits Your Project?

Both drivers are popular, but they cover different power ranges. The L298N is a classic dual H-bridge for small robots; the BTS7960 is a high-current half-bridge module that can handle large DC motors.

From the AI integration standpoint, the difference is minimal. Both need PWM and direction pins. ASI Biont just needs to know your wiring and command format.

Wiring That an AI Agent Can Understand

Here is a typical hookup for an ESP32 with an L298N:

L298N          ESP32
IN1            GPIO 12
IN2            GPIO 13
EN             GPIO 14 (PWM)
VCC            5V (logic only, separate from motor rail)
GND            GND (common ground)

For the BTS7960, the wiring is slightly different:

BTS7960        ESP32
RPWM           GPIO 13
LPWM           GPIO 12
R_EN, L_EN     5V (or GPIO pins)
VCC            5V
GND            GND

The golden rule is: keep the motor supply rail separate from the 5V logic rail, but always connect the grounds together. If you are unsure, the AI agent can walk you through a safe wiring check before powering up.

Minimal Firmware: A Serial Interpreter for the Motor

The microcontroller does not need a complex library. A short MicroPython script reads serial commands and sets PWM duty cycles. Save this as main.py on an ESP32:

from machine import Pin, PWM
import sys, uasyncio

pwm_pin = PWM(Pin(14), freq=1000)
in1 = Pin(12, Pin.OUT)
in2 = Pin(13, Pin.OUT)

async def main():
    while True:
        line = sys.stdin.readline()
        if line:
            parts = line.strip().split()
            if parts[0] == 'PWM':
                pwm_pin.duty(int(parts[1]))
            elif parts[0] == 'DIR':
                in1.value(int(parts[1]))
                in2.value(int(parts[2]))
        await uasyncio.sleep_ms(5)

uasyncio.run(main())

This interpreter accepts two commands:
- PWM <0-1023> — set motor speed
- `DIR <0

|1> <0|1>` — set direction pins

For a BTS7960, replace the single enable pin with two PWM pins: LPWM for forward and RPWM for reverse.

Connecting ASI Biont Through the Hardware Bridge

ASI Biont uses a small Python utility called bridge.py to talk to serial devices. There is no HTTP API for this bridge—you use the industrial_command() function inside the ASI Biont environment. Start the bridge on your PC by downloading bridge.py from the ASI Biont dashboard and running:

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

This opens COM3 at 115200 baud and polls for commands every 10 Hz. Now you can ask the AI agent in chat: Send PWM 500 to the motor. The agent will translate that into a call like this:

from asi_biont_bridge import industrial_command

response = industrial_command(
    protocol='serial',
    port='COM3',
    baudrate=115200,
    data='PWM 500\n'
)
print(response)

The bridge runs continuously, so the agent can issue direction changes, speed ramps, and read acknowledgment strings from the microcontroller.

From Chat Message to Motor Rotation

In the ASI Biont dialog, you can describe a task in plain English:

Connect to my ESP32 on COM4 at 115200. When I say 'go', ramp the motor from 0 to 700 over 2 seconds, then keep it at 700.

The AI agent will generate the necessary industrial_command() calls and a small sleep loop to produce the ramp. You do not need to write code manually—the agent handles protocol parsing and verifies the wiring you described.

Real-World Scenario: Line-Following Robot

Imagine a robot with two L298N drivers and two IR sensors. ASI Biont can subscribe to MQTT messages from a sensor node and issue motor commands based on a simple decision table: if the left sensor sees black, increase the right motor PWM; if the right sensor sees black, increase the left motor PWM. The AI environment can combine MQTT and serial in one workflow:

import paho.mqtt.client as mqtt
from asi_biont_bridge import industrial_command

def on_sensor(client, userdata, msg):
    data = msg.payload.decode().split()
    if data[0] == 'LEFT' and data[1] == '0':
        industrial_command(protocol='serial', port='COM3', baudrate=115200,
                           data='PWM 300 DIR 0 1\n')
    elif data[0] == 'RIGHT' and data[1] == '0':
        industrial_command(protocol='serial', port='COM3', baudrate=115200,
                           data='PWM 300 DIR 1 0\n')

mqtt_client = mqtt.Client()
mqtt_client.on_message = on_sensor
mqtt_client.connect('192.168.1.100', 1883)
mqtt_client.subscribe('robot/sensors')
mqtt_client.loop_forever()

This example shows how ASI Biont can act as a neural-network-driven brain that combines multiple protocols without a control panel.

Real-World Scenario: Conveyor Belt Sorting

On a small conveyor, a BTS7960 drives a 24 V motor that moves boxes. An optical sensor publishes a count over Modbus/TCP. ASI Biont reads the counter, and when it reaches a threshold, it sends a serial command to stop the conveyor. A simplified execute_python task looks like:

from pyModbusTCP.client import ModbusClient
from asi_biont_bridge import industrial_command

mb = ModbusClient(host='192.168.1.50', port=502)
if mb.open():
    regs = mb.read_holding_registers(0, 1)
    count = regs[0]
    if count >= 10:
        industrial_command(protocol='serial', port='COM3', baudrate=115200,
                           data='PWM 0\n')
        print('Conveyor stopped')

This is a typical mixed-protocol scenario: Modbus for sensing, serial for motion control.

Real-World Scenario: Smart Blinds

For home automation, an ESP32 with an L298N drives a DC motor that raises and lowers blinds. ASI Biont can link the motor to a time schedule or a light sensor. Because the bridge exposes the serial port, the AI agent can handle a chat command like set blinds to 75 percent. The assistant converts the percentage to a PWM value and a duration:

percent = 75
pwm = int(percent * 10.23)  # 1023 max
industrial_command(protocol='serial', port='COM3', baudrate=115200,
                   data=f'PWM {pwm}\n')

The Universal Fallback: execute_python

What if your motor controller speaks Modbus, CAN, or a proprietary protocol? ASI Biont's universal execute_python mechanism takes over. You simply describe the device in chat—port, baud rate, command format, or API endpoint—and the AI agent writes a Python script using pyserial, paho-mqtt, pymodbus, paramiko, aiohttp, opcua-asyncio, or any other library. That script runs in a sandbox with a 30-second timeout, so it is designed for discrete actions, not infinite loops.

This is the killer feature: you do not have to wait for a vendor SDK or a custom connector. The AI has already learned from countless datasheets and code examples. It can infer that a BTS7960 needs two PWM pins or that an L298N needs an enable pin. You just confirm the physical wiring.

Safety and Debugging Notes

• Always connect the logic ground and motor ground together to avoid floating voltages.
• Place a 100 nF ceramic capacitor near the driver's power pins to reduce electrical noise.
• Start with a low PWM value to test rotation direction before running a full sequence.
• If the serial connection does not respond, check the COM port spelling and baud rate. Ask the AI agent to run a loopback test with industrial_command(protocol='serial', data='hello').

Why This Approach Wins

Traditional integration requires writing a custom daemon, handling serial protocols, and building a control panel. With ASI Biont, the AI agent handles all of that at runtime. It reads the situation, chooses the right protocol, and generates the code in seconds. No management panels, no predefined device list. Just describe the task and watch the motor spin.

Get Started

Connecting L298N or BTS7960 to ASI Biont is one of the fastest ways to bring AI-driven control to your robotics or automation project. Download bridge.py from your ASI Biont dashboard, flash the serial interpreter onto your microcontroller, and ask the agent to move a motor. Visit asibiont.com and try it today.