Hello @Athena,

I am currently exploring the feasibility of using a Windows 11-compatible controller to execute a Python client script that transmits XInput data to a Python server script on the ARC Skill Control Board. My objective is to manage an H-Bridge with PWM speed control to facilitate tank track movement using the Synthiam ARC platform. Do you think this setup can be achieved?

I am employing the Anbernic Win600 controller, as depicted in the image below:

At present, I am endeavoring to deploy a Python-coded server on my ARC-enabled PC to process control signals. I’ve included the Python script I’m using for this configuration below.

#!/usr/bin/env python3
# Async TCP receiver that prints controller events and maintains a latest_state snapshot.

import asyncio, json, signal, sys
from collections import defaultdict

HOST = "0.0.0.0"
PORT = 5555
PRINT_EVENTS = True

latest_state = {
    "buttons": defaultdict(lambda: False),
    "axes": defaultdict(lambda: 0.0),
    "hat": {"x": 0, "y": 0},
    "t": 0.0,
}

def apply_event(ev):
    et = ev.get("type")
    latest_state["t"] = ev.get("t", latest_state["t"])

    if et == "button":
        name = ev.get("name", f"BTN{ev.get('index', -1)}")
        pressed = bool(ev.get("pressed", False))
        latest_state["buttons"][name] = pressed
        if PRINT_EVENTS:
            print(f"[BTN] {name}: {'DOWN' if pressed else 'UP'}")

    elif et == "axis":
        name = ev.get("name", f"AXIS{ev.get('index', -1)}")
        val = float(ev.get("value", 0.0))
        latest_state["axes"][name] = val
        if PRINT_EVENTS:
            print(f"[AXIS] {name}: {val:+.3f}")

    elif et == "hat":
        v = ev.get("value", {"x": 0, "y": 0})
        latest_state["hat"] = {"x": int(v.get("x", 0)), "y": int(v.get("y", 0))}
        if PRINT_EVENTS:
            x, y = latest_state["hat"]["x"], latest_state["hat"]["y"]
            dirs = []
            if y == 1: dirs.append("Up")
            if y == -1: dirs.append("Down")
            if x == -1: dirs.append("Left")
            if x == 1: dirs.append("Right")
            print(f"[HAT] DPad: {'+'.join(dirs) if dirs else 'Neutral'}")

async def handle_client(reader: asyncio.StreamReader, writer: asyncio.StreamWriter):
    peer = writer.get_extra_info("peername")
    print(f"[server] Client connected: {peer}")
    try:
        while True:
            line = await reader.readline()
            if not line:
                break
            try:
                ev = json.loads(line.decode("utf-8"))
            except json.JSONDecodeError:
                continue
            apply_event(ev)
    except asyncio.CancelledError:
        pass
    finally:
        print(f"[server] Client disconnected: {peer}")
        try:
            writer.close()
            await writer.wait_closed()
        except Exception:
            pass

async def status_printer():
    while True:
        await asyncio.sleep(0.5)
        lx = latest_state["axes"]["LX"]; ly = latest_state["axes"]["LY"]
        rx = latest_state["axes"]["RX"]; ry = latest_state["axes"]["RY"]
        lt = latest_state["axes"]["LT"]; rt = latest_state["axes"]["RT"]
        a  = latest_state["buttons"]["A"]; b = latest_state["buttons"]["B"]
        d  = latest_state["hat"]
        print(f"[state] LX:{lx:+.2f} LY:{ly:+.2f} RX:{rx:+.2f} RY:{ry:+.2f} LT:{lt:.2f} RT:{rt:.2f} A:{int(a)} B:{int(b)} D:{d}")

async def main():
    server = await asyncio.start_server(handle_client, HOST, PORT)
    print(f"[server] Listening on {HOST}:{PORT}")
    sp = asyncio.create_task(status_printer())

    # Graceful shutdown for Windows
    stop = asyncio.Future()
    def _sig():
        if not stop.done():
            stop.set_result(True)
    loop = asyncio.get_running_loop()
    try:
        loop.add_signal_handler(signal.SIGINT, _sig)   # may raise on Windows for some signals
        loop.add_signal_handler(signal.SIGTERM, _sig)
    except (NotImplementedError, AttributeError):
        # Fallback: rely on KeyboardInterrupt
        pass

    async with server:
        await asyncio.gather(server.serve_forever(), stop)

    sp.cancel()

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        sys.exit(0)

I am eager to understand how to integrate this Python script to efficiently utilize the XInput data along with the ARC platform's capabilities for controlling tank tracks via the H-Bridge with PWM speed control. The H-Bridge interfaces with an Arduino Nano running the EZB firmware. Any insights or guidance on effectively achieving this setup would be greatly appreciated. Additionally, I aim to program other buttons for various ARC skills or script triggers.