| """Bridge-as-a-service: load one PCLA agent in the PCLA env and drive it from an |
| external simulator that speaks a tiny socket protocol. The simulator (MetaDrive now, |
| BeamNG later) sends a front camera + ego gps/imu/speed each step; we reply with the |
| agent's throttle/steer/brake. Keeps the sim in its own Python env (no dependency |
| clash with the 41 agents). |
| |
| Protocol (localhost TCP): 4-byte big-endian length + pickle payload. |
| client -> {"cmd":"route","waypoints":[[lat,lon],...]} -> {"ok":True} |
| client -> {"cmd":"step","camera":<jpeg bytes>,"gps":[lat,lon,alt], |
| "imu":[7],"speed":m/s,"dt":s} -> {"throttle","steer","brake"} |
| client -> {"cmd":"close"} -> (server exits) |
| """ |
| import argparse, os, pickle, socket, struct, sys |
| import numpy as np, cv2 |
|
|
| _HERE = os.path.dirname(os.path.abspath(__file__)) |
| _ROOT = os.path.dirname(os.path.dirname(_HERE)) |
| sys.path.insert(0, _ROOT) |
| sys.path.insert(0, os.path.join(_ROOT, "pcla_bridge")) |
| from pcla_bridge import PCLAAgentBridge |
| from bridge_sample import build_sensors |
|
|
|
|
| def _recvall(conn, n): |
| buf = b"" |
| while len(buf) < n: |
| chunk = conn.recv(n - len(buf)) |
| if not chunk: |
| return None |
| buf += chunk |
| return buf |
|
|
| def recv_msg(conn): |
| hdr = _recvall(conn, 4) |
| if not hdr: |
| return None |
| (n,) = struct.unpack(">I", hdr) |
| return pickle.loads(_recvall(conn, n)) |
|
|
| def send_msg(conn, obj): |
| data = pickle.dumps(obj, protocol=4) |
| conn.sendall(struct.pack(">I", len(data)) + data) |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--agent", default="neat_aim2dsem") |
| ap.add_argument("--host", default="127.0.0.1") |
| ap.add_argument("--port", type=int, default=8770) |
| a = ap.parse_args() |
|
|
| print(f"[server] loading agent '{a.agent}' (this can take a bit) ...", flush=True) |
| bridge = PCLAAgentBridge(a.agent) |
| print("[server] agent expects:", sorted(bridge.sensor_layout()), flush=True) |
| warned = set() |
|
|
| srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM) |
| srv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) |
| srv.bind((a.host, a.port)) |
| srv.listen(1) |
| print(f"[server] READY listening on {a.host}:{a.port}", flush=True) |
| conn, _ = srv.accept() |
| print("[server] client connected", flush=True) |
|
|
| n = 0 |
| try: |
| while True: |
| msg = recv_msg(conn) |
| if msg is None or msg.get("cmd") == "close": |
| break |
| if msg["cmd"] == "route": |
| bridge.set_route(msg["waypoints"]) |
| send_msg(conn, {"ok": True, "n": len(msg["waypoints"])}) |
| print(f"[server] route set: {len(msg['waypoints'])} waypoints", flush=True) |
| continue |
| if msg["cmd"] == "step": |
| frame = cv2.imdecode(np.frombuffer(msg["camera"], np.uint8), cv2.IMREAD_COLOR) |
| tele = {"gps": msg["gps"], "imu": msg["imu"], "speed": msg["speed"]} |
| sensors = build_sensors(bridge, frame, tele, warned) |
| lidar_bytes = msg.get("lidar") |
| if lidar_bytes: |
| cloud = np.frombuffer(lidar_bytes, np.float32).reshape(-1, 4).copy() |
| for sid, spec in bridge.sensor_layout().items(): |
| if spec["type"] == "sensor.lidar.ray_cast": |
| sensors[sid] = cloud |
| if "lidar_wired" not in warned: |
| print(f"[server] wiring real LiDAR into '{sid}' ({len(cloud)} pts)", flush=True) |
| warned.add("lidar_wired") |
| ctrl = bridge.step(sensors, dt=msg.get("dt", 0.1)) |
| send_msg(conn, {"throttle": float(ctrl.throttle), |
| "steer": float(ctrl.steer), |
| "brake": float(ctrl.brake)}) |
| n += 1 |
| finally: |
| conn.close() |
| srv.close() |
| print(f"[server] done after {n} steps", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
