roboapi 0.4.2__py3-none-any.whl

roboapi/hardware/ur/compliant.py

@@ -0,0 +1,128 @@
+"""UR e-Series control using the native 500 Hz Cartesian admittance loop."""
+
+from __future__ import annotations
+
+import time
+
+import numpy as np
+
+from ... import geometry as geo
+from ...errors import ControlNotReady
+from .dashboard import Dashboard
+from .feedback import URFeedbackReader
+from .ipc import NativeLoop
+
+class CompliantArm:
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self._native = None
+        self._reader = None
+        self._error = None
+        self._dashboard = Dashboard(cfg.ip)
+
+    @property
+    def live(self):
+        return bool(self._native and self._native.live)
+
+    @property
+    def last_error(self):
+        return self._error or (self._native.last_error if self._native else None)
+
+    def connect(self):
+        self.disconnect()
+        self._error = None
+        try:
+            if self._dashboard.version()[0] not in (5, 10):
+                raise ValueError("e-Series compliant control requires a PolyScope 5 or 10 controller")
+            self.check_motion_ready()
+            # Check the installation TCP independently of the control RTDE recipe.
+            self._reader = URFeedbackReader(self.cfg.ip)
+            self._reader.connect()
+            self._native = NativeLoop(self.cfg)
+            self._native.start()
+            # Start holding the measured pose before accepting a target.
+            self._native.request(b"C", self._native.snapshot()["tcp"])
+        except BaseException:
+            self.disconnect()
+            raise
+
+    def disconnect(self):
+        if self._native is not None:
+            self._native.close()
+        if self._reader is not None:
+            self._reader.disconnect()
+        self._native = self._reader = None
+
+    def _state(self):
+        if not self.live:
+            raise RuntimeError("not_alive: " + str(self.last_error or "UR control disconnected"))
+        return self._native.snapshot()
+
+    def get_joints(self):
+        return np.asarray(self._state()["q"])
+
+    def get_eef_pose(self):
+        return geo.rotvec6_to_pose7(np.asarray(self._state()["tcp"]))
+
+    def get_wrench(self):
+        return np.asarray(self._state()["wrench"])
+
+    def get_tcp_speed(self):
+        return np.asarray(self._state()["tcp_speed"])
+
+    def get_tcp_offset(self):
+        if self._reader is None:
+            raise RuntimeError("UR read-only feedback disconnected")
+        return np.asarray(self._reader.snapshot()["tcp_offset"])
+
+    def check_motion_ready(self):
+        self._dashboard.require_remote()
+
+    def servo_pose(self, pose7, twist=None, *, position_only=False):
+        del twist
+        self._state()
+        self._native.request(b"C" if position_only else b"P", geo.pose7_to_rotvec6(np.asarray(pose7)))
+
+    def stop_motion(self):
+        if self._native is not None:
+            self._native.request(b"H")
+
+    def hold(self):
+        self.stop_motion()
+
+    def zero_ft(self):
+        """Request sensor zeroing once, without an extra settling wait."""
+        self._state()
+        self._native.request(b"Z")
+
+    def control_status(self):
+        return self._native.status() if self._native else {
+            "backend": "ur_eseries", "live": False, "mode": "DISCONNECTED",
+            "admittance_active": False, "configured_hz": self.cfg.fastloop_freq,
+            "last_error": self.last_error,
+        }
+
+    def recover(self, should_stop=None):
+        deadline = time.monotonic() + 30.0
+        detail = "dashboard_error"
+        while time.monotonic() < deadline:
+            if should_stop is not None and should_stop():
+                raise RuntimeError("UR recovery cancelled")
+            ready, detail = self._dashboard.step(should_stop=should_stop)
+            if detail == "motion_interrupted":
+                raise RuntimeError("UR recovery cancelled")
+            if ready:
+                break
+            if detail == "remote_control_required":
+                raise ControlNotReady("Switch PolyScope to Remote, then retry.")
+            if detail.startswith(("external_reset_required", "remote_control_required",
+                                  "confirm_safety_required", "unsupported_")):
+                self._error = detail
+                raise RuntimeError(detail + ": a person has to clear this at the robot")
+            time.sleep(2.0)
+        else:
+            self._error = detail
+            raise RuntimeError("recover timed out: " + detail)
+        if should_stop is not None and should_stop():
+            raise RuntimeError("UR recovery cancelled")
+        self.connect()

roboapi/hardware/ur/dashboard.py

@@ -0,0 +1,103 @@
+"""Shared UR Dashboard queries and controller recovery."""
+
+from __future__ import annotations
+
+import re
+import socket
+
+from ...errors import ControlNotReady
+
+
+def dashboard_query(ip: str, command: str) -> str:
+    """Read one Dashboard response; never issue controller state changes."""
+    if command not in {"get serial number", "is in remote control", "safetystatus", "running"}:
+        raise ValueError("only read-only Dashboard queries are allowed")
+    with socket.create_connection((ip, 29999), timeout=2) as dashboard:
+        with dashboard.makefile("rwb") as stream:
+            stream.readline(1024)
+            stream.write((command + "\n").encode())
+            stream.flush()
+            return stream.readline(1024).decode().strip()
+
+
+class Dashboard:
+    """Controller version and explicit recovery through the Dashboard server."""
+
+    _EXTERNAL = {"RECOVERY", "SAFEGUARD_STOP", "SYSTEM_EMERGENCY_STOP", "ROBOT_EMERGENCY_STOP",
+                 "AUTOMATIC_MODE_SAFEGUARD_STOP", "SYSTEM_THREE_POSITION_ENABLING_STOP"}
+
+    def __init__(self, ip: str, timeout: float = 3.0) -> None:
+        self._ip, self._timeout = ip, timeout
+
+    def _ask(self, sock, cmd: str) -> str:
+        sock.sendall((cmd + "\n").encode())
+        return sock.recv(1024).decode(errors="replace").strip()
+
+    @staticmethod
+    def parse_version(text: str) -> tuple[int, int]:
+        match = re.search(r"\b(\d+)\.(\d+)\.", text)
+        if match is None:
+            raise ValueError(f"unsupported controller version: {text}")
+        return int(match[1]), int(match[2])
+
+    def version(self) -> tuple[int, int]:
+        with socket.create_connection((self._ip, 29999), timeout=self._timeout) as sock:
+            sock.settimeout(self._timeout)
+            sock.recv(1024)
+            return self.parse_version(self._ask(sock, "PolyscopeVersion"))
+
+    def require_remote(self) -> None:
+        remote = dashboard_query(self._ip, "is in remote control").lower()
+        if remote == "false":
+            raise ControlNotReady("Switch PolyScope to Remote, then retry.")
+        if remote != "true":
+            raise RuntimeError("Could not read the PolyScope Remote control status.")
+
+    def step(self, should_stop=None) -> tuple[bool, str]:
+        """One stage per call, non-blocking. (ready, detail)."""
+        try:
+            with socket.create_connection((self._ip, 29999), timeout=self._timeout) as sock:
+                sock.settimeout(self._timeout)
+                sock.recv(1024)  # greeting
+                version = self.parse_version(self._ask(sock, "PolyscopeVersion"))
+                if version[0] not in (3, 5, 10):
+                    return False, "unsupported_controller_version"
+                if version[0] in (5, 10) and "true" not in self._ask(sock, "is in remote control").lower():
+                    return False, "remote_control_required"
+                if should_stop is not None and should_stop():
+                    return False, "motion_interrupted"
+                # A URScript runtime error (servol past the arm's reach, say) kills the control
+                # program and leaves a popup on the pendant. The popup is not a safety state, so
+                # nothing below would clear it, and while it is up the program cannot be restarted.
+                self._ask(sock, "close popup")
+                safety = self._ask(sock, "safetystatus").split(":")[-1].strip().upper()
+                mode = self._ask(sock, "robotmode").split(":")[-1].strip().upper()
+                if should_stop is not None and should_stop():
+                    return False, "motion_interrupted"
+                if safety in self._EXTERNAL:
+                    return False, f"external_reset_required:{safety.lower()}"
+                if safety == "PROTECTIVE_STOP":
+                    self._ask(sock, "unlock protective stop")
+                    return False, "unlocking_protective_stop"
+                if safety in {"FAULT", "VIOLATION"}:
+                    self._ask(sock, "close safety popup")
+                    self._ask(sock, "restart safety")
+                    return False, "restarting_safety"
+                if safety not in {"NORMAL", "REDUCED"}:
+                    return False, f"unsupported_safety_status:{safety.lower()}"
+                if mode == "RUNNING":
+                    return True, "dashboard_ready"
+                if mode == "POWER_OFF":
+                    self._ask(sock, "close safety popup")
+                    self._ask(sock, "power on")
+                    return False, "powering_on"
+                if mode in {"POWER_ON", "IDLE"}:
+                    self._ask(sock, "brake release")
+                    return False, "releasing_brakes"
+                if mode == "BOOTING":
+                    return False, "robot_booting"
+                if mode == "CONFIRM_SAFETY":
+                    return False, "confirm_safety_required"
+                return False, f"unsupported_robot_mode:{mode.lower()}"
+        except Exception as exc:
+            return False, f"dashboard_error:{exc or type(exc).__name__}"

roboapi/hardware/ur/feedback.py

@@ -0,0 +1,159 @@
+"""UR feedback from Primary read-only (30011), without control interfaces.
+
+The 10 Hz stream contains measured joints, TCP pose, active TCP offset and robot
+timestamps. A reader continuously drains it so idle sampling never leaves old
+packets queued. No URScript, hold, recovery or gripper commands are sent.
+"""
+
+from __future__ import annotations
+
+import socket
+import struct
+import threading
+import time
+
+import numpy as np
+
+from ... import geometry as geo
+from .dashboard import dashboard_query
+
+
+def parse_state(packet: bytes) -> dict | None:
+    """Decode documented Robot State subpackages; ignore unrelated messages."""
+    if len(packet) < 5 or struct.unpack_from("!I", packet)[0] != len(packet):
+        raise ValueError("invalid UR packet length")
+    if packet[4] != 16:
+        return None
+    result = {}
+    offset = 5
+    while offset < len(packet):
+        if len(packet) - offset < 5:
+            raise ValueError("truncated UR subpackage")
+        size, kind = struct.unpack_from("!IB", packet, offset)
+        if size < 5 or offset + size > len(packet):
+            raise ValueError("invalid UR subpackage length")
+        body = packet[offset + 5:offset + size]
+        if kind == 0 and len(body) >= 8:
+            result["timestamp"] = struct.unpack_from("!Q", body)[0]
+            if len(body) >= 17:
+                values = struct.unpack_from("!7?BB", body, 8)
+                names = ("connected", "enabled", "powered", "emergency_stopped",
+                         "protective_stopped", "program_running", "program_paused", "robot_mode", "control_mode")
+                result["robot_mode"] = dict(zip(names, values))
+        elif kind == 1 and len(body) >= 6 * 41:
+            result["joints"] = [struct.unpack_from("!d", body, i * 41)[0] for i in range(6)]
+        elif kind == 4 and len(body) >= 96:
+            values = struct.unpack_from("!12d", body)
+            result["pose"] = geo.rotvec6_to_pose7(np.asarray(values[:6])).tolist()
+            result["tcp_offset"] = list(values[6:])
+        offset += size
+    if not {"timestamp", "joints", "pose", "tcp_offset"} <= result.keys():
+        return None
+    if not all(np.all(np.isfinite(result[key])) for key in ("joints", "pose", "tcp_offset")):
+        raise ValueError("non-finite UR feedback")
+    return result
+
+
+class URFeedbackReader:
+    def __init__(self, ip: str):
+        self.ip = ip
+        self.serial = ""
+        self._socket = None
+        self._thread = None
+        self._stop = threading.Event()
+        self._lock = threading.Lock()
+        self._state = None
+        self._updated = 0.0
+        self._error = None
+
+    def connect(self) -> None:
+        self.disconnect()
+        self._error = None
+        try:
+            serial = dashboard_query(self.ip, "get serial number")
+            if not serial.isdigit():
+                raise ValueError("Could not read the robot serial number.")
+            self.serial = serial
+            self._socket = socket.create_connection((self.ip, 30011), timeout=2)
+            self._socket.settimeout(1)
+            self._stop.clear()
+            self._thread = threading.Thread(target=self._read, name="ur-feedback", daemon=True)
+            self._thread.start()
+            deadline = time.monotonic() + 2
+            while not self.live:
+                if self._error or time.monotonic() >= deadline:
+                    raise RuntimeError(self._error or "No live UR feedback has been received.")
+                time.sleep(0.02)
+        except Exception:
+            self.disconnect()
+            raise
+
+    def _read(self) -> None:
+        buffer = bytearray()
+        try:
+            while not self._stop.is_set():
+                chunk = self._socket.recv(65536)
+                if not chunk:
+                    raise RuntimeError("The read-only connection was closed.")
+                buffer.extend(chunk)
+                while len(buffer) >= 4:
+                    size = struct.unpack_from("!I", buffer)[0]
+                    if not 5 <= size <= 65536:
+                        raise ValueError("invalid UR packet size")
+                    if len(buffer) < size:
+                        break
+                    state = parse_state(bytes(buffer[:size]))
+                    del buffer[:size]
+                    if state is not None:
+                        with self._lock:
+                            # Repeated robot timestamps never refresh the freshness clock.
+                            if self._state is None or state["timestamp"] > self._state["timestamp"]:
+                                self._state = state
+                                self._updated = time.monotonic()
+                if len(buffer) > 65536:
+                    raise ValueError("UR receive buffer exceeded limit")
+        except Exception as exc:
+            if not self._stop.is_set():
+                self._error = str(exc)
+
+    @property
+    def live(self) -> bool:
+        with self._lock:
+            return (not self._stop.is_set() and self._state is not None and self._error is None
+                    and time.monotonic() - self._updated <= 0.5)
+
+    def snapshot(self) -> dict:
+        with self._lock:
+            if self._state is None or self._error or time.monotonic() - self._updated > 0.5:
+                raise ValueError(self._error or "UR feedback is stale. Check the read-only connection.")
+            state = {key: value.copy() if isinstance(value, (list, dict)) else value for key, value in self._state.items()}
+            state["device"] = {"serial": self.serial, "tcp_offset": state["tcp_offset"].copy()}
+            self.validate_device(state["device"])
+            return state
+
+    @property
+    def last_error(self):
+        if self._stop.is_set():
+            return None
+        return self._error or ("UR read-only feedback is stale" if self._state is not None and not self.live else None)
+
+    def validate_device(self, device):
+        if set(device) != {"serial", "tcp_offset"} or not isinstance(device["serial"], str) or not device["serial"].isdigit():
+            raise ValueError("invalid UR calibration device information")
+        offset = np.asarray(device["tcp_offset"], dtype=float)
+        if offset.shape != (6,) or not np.all(np.isfinite(offset)) or np.max(np.abs(offset[:3])) > 1e-6:
+            raise ValueError("Select a flange-centre TCP with zero positional offset in PolyScope.")
+
+    def disconnect(self) -> None:
+        self._stop.set()
+        if self._socket is not None:
+            try:
+                self._socket.shutdown(socket.SHUT_RDWR)
+            except OSError:
+                pass
+            self._socket.close()
+        if self._thread is not None:
+            self._thread.join(timeout=2)
+        self._socket = self._thread = None
+        with self._lock:
+            self._state = None

roboapi/hardware/ur/ipc.py

@@ -0,0 +1,206 @@
+"""Process lifecycle and bounded IPC for the native e-Series controller."""
+from __future__ import annotations
+
+from pathlib import Path
+import socket
+import struct
+import subprocess
+import threading
+import time
+
+import numpy as np
+
+PARAMETERS = (
+    "fastloop_freq", "fastloop_rt_prio", "fastloop_mass",
+    "fastloop_stiffness", "fastloop_damping_ratio", "fastloop_hf_mass_ratio",
+    "fastloop_relaxation_hz", "fastloop_filter_tau", "fastloop_wrench_deadband",
+    "fastloop_wrench_notch", "fastloop_max_dt", "fastloop_max_vel", "fastloop_cmd_vel_limit",
+    "fastloop_cmd_acc_limit", "fastloop_pos_loop_kp", "fastloop_speedl_acc_limit",
+    "fastloop_speedl_jerk_limit",
+)
+MODES = {0: "IDLE", 1: "TRACK_POSE", 4: "SWITCHING", 5: "TRACK_POSITION"}
+
+
+def worker_command(cfg) -> list[str]:
+    binary = Path(cfg.fastloop_binary).expanduser().resolve()
+    script = Path(cfg.fastloop_script).expanduser().resolve()
+    command = [str(binary), "--ip", cfg.ip, "--script", str(script),
+               "--zero_ft_on_start", str(int(cfg.zero_ft_on_start))]
+    for name in PARAMETERS:
+        value = getattr(cfg, name)
+        if isinstance(value, bool):
+            value = int(value)
+        command += ["--" + name, ",".join(map(str, value)) if isinstance(value, list) else str(value)]
+    return command
+
+
+class NativeLoop:
+    def __init__(self, cfg):
+        self.cfg = cfg
+        self.process = None
+        self.socket = None
+        self.error = None
+        self._rpc_lock = threading.Lock()
+        self._state_lock = threading.Lock()
+        self._state = {}
+        self._received_at = 0.0
+        self._stop = threading.Event()
+        self._poller = None
+
+    def _read(self, size: int, deadline: float) -> bytes:
+        result = bytearray()
+        while len(result) < size:
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError("UR native IPC deadline exceeded")
+            self.socket.settimeout(remaining)
+            chunk = self.socket.recv(size - len(result))
+            if not chunk:
+                raise RuntimeError("UR C++ control process closed IPC")
+            result.extend(chunk)
+        return bytes(result)
+
+    def _receive(self, deadline: float) -> dict:
+        values = struct.unpack("=43d", self._read(43 * 8, deadline))
+        error_size, = struct.unpack("=I", self._read(4, deadline))
+        if error_size > 65536 or not np.all(np.isfinite(values)):
+            raise RuntimeError("Invalid UR native state packet")
+        error = self._read(error_size, deadline).decode("utf-8", errors="replace")
+        state = {name: list(values[i * 6:(i + 1) * 6])
+                 for i, name in enumerate(("q", "qd", "tcp", "tcp_speed", "wrench"))}
+        for i, name in enumerate(("mode", "fault", "safety_mode", "ticks", "dt_mean_ms",
+                                  "dt_std_ms", "dt_p99_ms", "dt_max_ms", "rtde_hz", "host_hz",
+                                  "program_running", "loop_alive", "loop_ok")):
+            state[name] = values[30 + i]
+        state["last_error"] = error
+        with self._state_lock:
+            advancing = not self._state or state["ticks"] > self._state.get("ticks", -1)
+            self._state = state
+            if advancing:
+                self._received_at = time.monotonic()
+        return state
+
+    def _abort_ipc(self, error):
+        self.error = str(error)
+        self._stop.set()
+        # EOF stops the worker even when a pending status request cannot answer STOP.
+        if self.socket is not None:
+            try:
+                self.socket.shutdown(socket.SHUT_RDWR)
+            except OSError:
+                pass
+
+    def request(self, op: bytes, target=None) -> dict:
+        packet = op
+        if target is not None:
+            vector = np.asarray(target, dtype=np.float64)
+            if vector.shape != (6,) or not np.all(np.isfinite(vector)):
+                raise ValueError("UR native target must contain six finite values")
+            packet += struct.pack("=6d", *vector)
+        deadline = time.monotonic() + self.cfg.native_rpc_timeout_s
+        if not self._rpc_lock.acquire(timeout=self.cfg.native_rpc_timeout_s):
+            self._abort_ipc("UR native IPC lock deadline exceeded")
+            raise RuntimeError(self.error)
+        try:
+            if self.error or self.socket is None:
+                raise RuntimeError(self.error or "UR native IPC disconnected")
+            remaining = deadline - time.monotonic()
+            if remaining <= 0:
+                raise TimeoutError("UR native IPC deadline exceeded")
+            self.socket.settimeout(remaining)
+            self.socket.sendall(packet)
+            return self._receive(deadline)
+        except (OSError, RuntimeError) as exc:
+            self._abort_ipc(exc)
+            raise RuntimeError(self.error) from exc
+        finally:
+            self._rpc_lock.release()
+
+    def start(self):
+        command = worker_command(self.cfg)
+        for path in (command[0], command[4]):
+            if not Path(path).is_file():
+                raise FileNotFoundError("Build the pinned UR native runtime first: " + path)
+        log_dir = Path(self.cfg.fastloop_log_dir).expanduser().resolve()
+        log_dir.mkdir(parents=True, exist_ok=True)
+        self.socket, child = socket.socketpair()
+        try:
+            with (log_dir / "ur-cpp.log").open("ab") as log:
+                self.process = subprocess.Popen(
+                    command + ["--ipc-fd", str(child.fileno())],
+                    pass_fds=(child.fileno(),), stdin=subprocess.DEVNULL, stdout=log, stderr=log,
+                )
+        except BaseException:
+            self.close()
+            raise
+        finally:
+            child.close()
+        try:
+            state = self._receive(time.monotonic() + 15.0)
+            if not state["loop_alive"] or not state["loop_ok"]:
+                raise RuntimeError(state["last_error"] or "fastloop_start_failed")
+            self._stop.clear()
+            self._poller = threading.Thread(target=self._poll, name="ur-state", daemon=True)
+            self._poller.start()
+        except BaseException:
+            self.close()
+            raise
+
+    def _poll(self):
+        while not self._stop.wait(1.0 / self.cfg.rate_hz):
+            try:
+                self.request(b"S")
+            except RuntimeError:
+                return
+
+    def snapshot(self) -> dict:
+        with self._state_lock:
+            return {k: v.copy() if isinstance(v, list) else v for k, v in self._state.items()}
+
+    @property
+    def live(self) -> bool:
+        s = self.snapshot()
+        process = self.process
+        return bool(process and process.poll() is None and not self.error and self._fresh()
+                    and s.get("loop_alive") and s.get("loop_ok") and s.get("program_running"))
+
+    @property
+    def last_error(self) -> str | None:
+        return self.error or self.snapshot().get("last_error") or (
+            "UR native feedback stale" if self._state and not self._fresh() else None)
+
+    def _fresh(self):
+        with self._state_lock:
+            return time.monotonic() - self._received_at <= self.cfg.native_state_stale_after_s
+
+    def close(self):
+        self._stop.set()
+        if self.socket is not None:
+            # EOF asks the worker to stop/join the control loop; it uploads no new program.
+            try:
+                self.socket.shutdown(socket.SHUT_RDWR)
+            except OSError:
+                pass
+            self.socket.close()
+        if self._poller is not None:
+            self._poller.join(timeout=3)
+        if self.process is not None:
+            try:
+                self.process.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                self.process.terminate()
+                try:
+                    self.process.wait(timeout=3)
+                except subprocess.TimeoutExpired:
+                    self.process.kill()
+                    self.process.wait()
+        self.socket = self.process = self._poller = None
+
+    def status(self) -> dict:
+        s = self.snapshot()
+        return {"backend": "ur_eseries", "live": self.live,
+                "mode": MODES.get(int(s.get("mode", 0)), "UNKNOWN"),
+                "admittance_active": self.live and s.get("mode") == 1,
+                "configured_hz": self.cfg.fastloop_freq,
+                "rtde_hz": s.get("rtde_hz"), "host_hz": s.get("host_hz"),
+                "dt_p99_ms": s.get("dt_p99_ms"), "last_error": self.last_error}

roboapi/hardware/ur/native/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.16)
+project(roboapi_ur_loop CXX)
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+find_package(Threads REQUIRED)
+option(ROBOAPI_BUILD_CHECKS "Build the control-law checks" ON)
+enable_testing()
+if(NOT URCL_SOURCE_DIR OR NOT RUCKIG_SOURCE_DIR)
+  message(FATAL_ERROR "Provide the locked URCL and Ruckig source directories")
+endif()
+set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
+set(BUILD_TESTS OFF CACHE BOOL "" FORCE)
+set(BUILD_PYTHON_MODULE OFF CACHE BOOL "" FORCE)
+set(BUILD_CLOUD_CLIENT OFF CACHE BOOL "" FORCE)
+set(BUILD_SHARED_LIBS OFF CACHE BOOL "" FORCE)
+add_subdirectory(${RUCKIG_SOURCE_DIR} ${CMAKE_BINARY_DIR}/ruckig EXCLUDE_FROM_ALL)
+add_subdirectory(${URCL_SOURCE_DIR} ${CMAKE_BINARY_DIR}/urcl EXCLUDE_FROM_ALL)
+add_executable(roboapi-ur-loop worker.cpp src/control_loop.cpp src/robot_io_urcl.cpp)
+target_include_directories(roboapi-ur-loop PRIVATE include)
+target_compile_options(roboapi-ur-loop PRIVATE -O2 -Wall -Wextra)
+target_link_libraries(roboapi-ur-loop Threads::Threads ruckig::ruckig ur_client_library::urcl)
+install(TARGETS roboapi-ur-loop DESTINATION bin)
+install(FILES ${URCL_SOURCE_DIR}/resources/external_control.urscript DESTINATION share/roboapi-ur-loop)
+if(ROBOAPI_BUILD_CHECKS)
+  foreach(check cartesian_speedl streaming_pose velocity_governor)
+    add_executable(check_${check} tests/${check}_unit.cpp)
+    target_include_directories(check_${check} PRIVATE include)
+    target_compile_options(check_${check} PRIVATE -UNDEBUG -Wall -Wextra)
+    target_link_libraries(check_${check} ruckig::ruckig)
+    add_test(NAME ${check} COMMAND check_${check})
+  endforeach()
+  add_executable(check_control_modes tests/control_modes_unit.cpp src/control_loop.cpp)
+  target_include_directories(check_control_modes PRIVATE include)
+  target_compile_options(check_control_modes PRIVATE -UNDEBUG -Wall -Wextra)
+  target_link_libraries(check_control_modes Threads::Threads ruckig::ruckig)
+  add_test(NAME control_modes COMMAND check_control_modes)
+endif()

roboapi/hardware/ur/native/dependencies.lock.json

@@ -0,0 +1,13 @@
+{
+  "schemaVersion": 1,
+  "urcl": {
+    "repository": "https://github.com/UniversalRobots/Universal_Robots_Client_Library.git",
+    "version": "2.14.1",
+    "ref": "a854de920d602300ce7c0fe3bd79655cb85bd678"
+  },
+  "ruckig": {
+    "repository": "https://github.com/pantor/ruckig.git",
+    "version": "0.15.3",
+    "ref": "37b6e7a4c60f5befd2506741d5f7d0ae7eefb3db"
+  }
+}