| """Client for the art_lockstep physics server (NEW CODE). |
| |
| One server process == one episode == one freshly constructed Chrono system, |
| ARTcar and RigidTerrain. Communication is strictly request/response over |
| pipes, so results never depend on wall-clock timing. |
| """ |
| import os |
| import select |
| import subprocess |
| import time |
|
|
| STATE_FIELDS = ('step time cog_x cog_y cog_z q_e0 q_e1 q_e2 q_e3 vel_x vel_y vel_z wloc_x wloc_y wloc_z ' |
| 'ref_x ref_y ref_z applied_steer applied_thr applied_brake drv_steer drv_thr drv_brake ' |
| 'veh_speed finite step_wall_s').split() |
|
|
| DEFAULT_BINARY = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), 'build', 'art_lockstep') |
|
|
|
|
| class PhysicsError(RuntimeError): |
| """Infrastructure failure of the physics server (crash, timeout, message format).""" |
|
|
|
|
| class PhysicsServer: |
| def __init__(self, x, y, yaw, binary=DEFAULT_BINARY, terrain_json=None, waypoint_boxes=None, |
| replicate_vis=False, timeout_s=120.0, stderr_path=None): |
| self.timeout_s = timeout_s |
| args = [binary, '--x', repr(float(x)), '--y', repr(float(y)), '--yaw', repr(float(yaw))] |
| if terrain_json: |
| args += ['--terrain-json', terrain_json] |
| if waypoint_boxes: |
| args += ['--waypoint-boxes', waypoint_boxes] |
| if replicate_vis: |
| args += ['--replicate-vis', '1'] |
| self.args = args |
| self.extra_output = [] |
| t0 = time.perf_counter() |
| self._stderr = open(stderr_path, 'w') if stderr_path else subprocess.DEVNULL |
| env = dict(os.environ) |
| env.setdefault('OMP_NUM_THREADS', '1') |
| self.proc = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=self._stderr, |
| bufsize=0, env=env) |
| self._buf = b'' |
| ready = self._read_until(b'READY') |
| self.ready_line = ready |
| self.server_init_s = float(ready.split()[1].split('=')[1]) |
| self.state = self._parse_state(self._read_until(b'X ')) |
| self.spawn_to_ready_s = time.perf_counter() - t0 |
| self.step_calls = 0 |
|
|
| |
| def _readline(self): |
| deadline = time.monotonic() + self.timeout_s |
| while b'\n' not in self._buf: |
| remaining = deadline - time.monotonic() |
| if remaining <= 0: |
| raise PhysicsError(f'physics server timeout after {self.timeout_s}s') |
| r, _, _ = select.select([self.proc.stdout], [], [], remaining) |
| if not r: |
| continue |
| chunk = os.read(self.proc.stdout.fileno(), 1 << 16) |
| if not chunk: |
| raise PhysicsError(f'physics server exited (code {self.proc.poll()})') |
| self._buf += chunk |
| line, self._buf = self._buf.split(b'\n', 1) |
| return line.decode() |
|
|
| def _read_until(self, prefix): |
| while True: |
| line = self._readline() |
| if line.startswith(prefix.decode()): |
| return line |
| if line.startswith('ART_LOCKSTEP_FATAL'): |
| raise PhysicsError(line) |
| self.extra_output.append(line) |
|
|
| def _send(self, text): |
| try: |
| os.write(self.proc.stdin.fileno(), text.encode()) |
| except (BrokenPipeError, OSError) as e: |
| raise PhysicsError(f'physics server pipe error: {e}') |
|
|
| @staticmethod |
| def _parse_state(line): |
| parts = line.split()[1:] |
| if len(parts) != len(STATE_FIELDS): |
| raise PhysicsError(f'bad state line ({len(parts)} fields): {line[:200]}') |
| st = {} |
| for k, v in zip(STATE_FIELDS, parts): |
| st[k] = float(v) |
| st['step'] = int(parts[0]) |
| st['finite'] = int(parts[STATE_FIELDS.index('finite')]) |
| return st |
|
|
| |
| def step(self, n): |
| if n <= 0: |
| raise ValueError('step count must be positive') |
| self._send(f'S {int(n)}\n') |
| self.state = self._parse_state(self._read_until(b'X ')) |
| self.step_calls += 1 |
| if not self.state['finite']: |
| raise PhysicsError(f"non-finite physics state at step {self.state['step']}") |
| return self.state |
|
|
| def set_inputs(self, steering, throttle, braking): |
| self._send(f'U {float(steering)!r} {float(throttle)!r} {float(braking)!r}\n') |
| parts = self._read_until(b'OK').split() |
| return float(parts[1]), float(parts[2]), float(parts[3]) |
|
|
| def close(self): |
| if self.proc.poll() is None: |
| try: |
| self._send('Q\n') |
| self.proc.wait(timeout=10) |
| except Exception: |
| self.proc.kill() |
| self.proc.wait() |
| if self._stderr not in (None, subprocess.DEVNULL): |
| self._stderr.close() |
| return self.proc.returncode |
|
|
