arm_dev
883ed6b0b9
新增包
- arm_kinematics：从 arm_application 提取几何雅可比 + DLS 逆解（纯 numpy）。
它被应用层和驱动层共用，留在应用层会让驱动反向依赖应用层。
arm_application/geom_ik.py 改为 re-export shim，现有 import 一行未改。
- arm_driver_flexiv：非夕驱动适配器。只补 manifest 声明而现有节点缺失的接口
（/home /enable /clear_fault /switch_tool /soft_drag /compliant_descent），
已有能力不重复实现。RDK 访问经 rdk_py310 下的长驻桥，本包不 import flexivrdk。
新接口
- arm_msgs/SwitchTool.srv、arm_msgs/CompliantDescent.action
- 合并 capabilities 里语义重复的 set_tool / switch_tool
修复（都是只在真机上暴露、且难以定位的问题）
- rdk_client 会永久挂死：select 的"可读"不等于"有完整一行"，readline 遇到
半行 JSON 会一直阻塞等换行符，超时机制完全失效。改用 os.read + 自己做行缓冲。
- CompliantDescent 行程少一步：descended + step > max 在浮点累加下会提前跳出，
永远到不了标称行程。改用整数步数计数。
- CompliantDescentRunner 的 TF frame 退化成 _base_link：没继承节点已解析的 SN。
- resolve_orisys_config 仍指向旧路径；load_orisys_from_site 读的是旧键 config。
触觉四路数据打通
- 深度图 / 力矢量场原先被 tactile_worker 有意丢弃（注释写"图像不过队列"），
从未发布到 ROS。新增 image_utils（数组→Image，编码自动判定）、独立的图像
队列（maxsize=1 满则丢旧）与 /tactile/<side>/{image,vector}。
默认关闭（tactile.image_hz=0），开启也不影响三力的 30fps 时序。
- mock 后端也会发图像，无硬件即可验证整条发布链路。
配置
- site.yaml 新增 tactile.image_hz；移除与 model 重复的旧键 tactile.config
- 型号配置从 src/arm_application/config/orisys/ 迁到
devices/sensors/orisys/models/dd03/（随 SDK 一起放）
测试：198 个（原 139）
- arm_kinematics 24（雅可比/逆解的解析算例与不变量）
- arm_driver_flexiv 69（下压状态机 34 + RDK 协议层 35）
- arm_application 59（图像打包 36 + 矢量场探测 23）
440 lines
16 KiB
Python
Executable File
440 lines
16 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
"""RDK 控制桥（必须在 rdk_py310 / Python 3.10 下运行）。
|
||
|
||
为什么需要这个进程
|
||
------------------
|
||
非夕的 `flexivrdk` Python 绑定与 ROS 环境的 Python 3.11 ABI 不兼容，且 RDK 对
|
||
同一台机器人是**独占访问**：多个进程同时连同一个 SN 会失败。所以框架里所有
|
||
RDK 操作都收敛到本进程，由它串行化，业务节点通过 JSON 行协议远程调用。
|
||
|
||
这也让 `arm_driver_flexiv` 不必 import flexivrdk，符合
|
||
`docs/INTERFACES.md` 的约束（业务节点不得 import flexivrdk）。
|
||
|
||
软拖拽为什么用 NRT_JOINT_IMPEDANCE
|
||
----------------------------------
|
||
AUTO(Remote) 模式下示教器上的 Free Drive 按钮不可用（控制权在 Remote）。
|
||
RDK 的 FloatingJoint/FloatingCartesian 通常需要额外授权。
|
||
所以默认用低刚度 NRT_JOINT_IMPEDANCE：目标跟踪实测关节角 + 低刚度，
|
||
于是手臂可以用手推动，同时 Remote 保持开启。
|
||
|
||
线程安全
|
||
--------
|
||
`flexivrdk.Robot` 不是线程安全的。所有 robot API 调用（含拖拽循环）共用同一
|
||
把锁 `rlock`。拖拽期间的关节读取走缓存，避免 Enter 与 Stop() 竞争。
|
||
|
||
行协议（JSON 只写 stdout；RDK 自身日志走 stderr）
|
||
-------------------------------------------------
|
||
{"cmd":"ping"}
|
||
{"cmd":"connect","sn":"Rizon4-063989","iface":"enp4s0"}
|
||
{"cmd":"enable"} # 使能 + 清故障（幂等）
|
||
{"cmd":"clear_fault"} # 显式清故障并使能
|
||
{"cmd":"switch_tool","name":"tool1"} # 切工具；name 空=只查询
|
||
{"cmd":"status"} # operational/fault/mode/tool
|
||
{"cmd":"drag_on","mode":"soft"} # soft | floating
|
||
{"cmd":"drag_off"}
|
||
{"cmd":"joints"}
|
||
{"cmd":"quit"}
|
||
|
||
每个命令的应答都是单行 JSON，含 ``ok`` 字段；失败时另有 ``error``。
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import sys
|
||
import threading
|
||
import time
|
||
from pathlib import Path
|
||
from typing import List, Optional
|
||
|
||
# 公共 RDK 操作统一在 scripts/lib/rdk_helpers.py，避免与 rdk_switch_tool.py
|
||
# 各写一份导致行为漂移。
|
||
sys.path.insert(0, str(Path(__file__).resolve().parent / 'lib'))
|
||
from rdk_helpers import ( # noqa: E402
|
||
clear_fault as rdk_clear_fault,
|
||
ensure_idle,
|
||
ensure_operational,
|
||
resolve_tool_name,
|
||
single_arm_groups,
|
||
switch_tool,
|
||
tool_name,
|
||
tool_params,
|
||
)
|
||
|
||
_JSON_OUT = sys.stdout
|
||
sys.stdout = sys.stderr
|
||
|
||
|
||
def reply(obj: dict) -> None:
|
||
_JSON_OUT.write(json.dumps(obj, ensure_ascii=False) + '\n')
|
||
_JSON_OUT.flush()
|
||
|
||
|
||
def log(msg: str) -> None:
|
||
print(f'[rdk_bridge] {msg}', file=sys.stderr, flush=True)
|
||
|
||
|
||
class SoftDrag:
|
||
def __init__(self, robot, flexivrdk, lock: threading.Lock) -> None:
|
||
self.robot = robot
|
||
self.flexivrdk = flexivrdk
|
||
self._lock = lock
|
||
self._stop = threading.Event()
|
||
self._thread: Optional[threading.Thread] = None
|
||
self.latest_q: List[float] = []
|
||
self._groups = {}
|
||
|
||
def start(self) -> None:
|
||
mode = self.flexivrdk.Mode
|
||
robot = self.robot
|
||
with self._lock:
|
||
robot.SwitchMode(mode.NRT_JOINT_IMPEDANCE)
|
||
st = robot.states()
|
||
self.latest_q = [float(v) for v in list(st.q)[:7]]
|
||
try:
|
||
info = robot.info()
|
||
self._groups = dict(getattr(info, 'single_arm_groups', None) or {})
|
||
except Exception as exc:
|
||
log(f'info.single_arm_groups: {exc}')
|
||
self._groups = {}
|
||
if self._groups:
|
||
for g in self._groups:
|
||
try:
|
||
nom = list(info.K_q_nom[g])
|
||
soft = [max(8.0, 0.08 * float(v)) for v in nom]
|
||
robot.SetJointImpedance(g, soft)
|
||
log(f'SetJointImpedance {g} K={soft}')
|
||
except Exception as exc:
|
||
log(f'SetJointImpedance group {g}: {exc}')
|
||
else:
|
||
n = max(7, len(self.latest_q))
|
||
try:
|
||
robot.SetJointImpedance([35.0] * n, [0.7] * n)
|
||
except Exception as exc:
|
||
log(f'SetJointImpedance flat: {exc}')
|
||
|
||
self._stop.clear()
|
||
self._thread = threading.Thread(target=self._loop, name='soft-drag', daemon=True)
|
||
self._thread.start()
|
||
|
||
def _loop(self) -> None:
|
||
robot = self.robot
|
||
flexivrdk = self.flexivrdk
|
||
while not self._stop.is_set():
|
||
try:
|
||
with self._lock:
|
||
if self._stop.is_set():
|
||
break
|
||
st = robot.states()
|
||
q = [float(v) for v in list(st.q)[:7]]
|
||
self.latest_q = q
|
||
if self._groups:
|
||
cmds = {}
|
||
for g in self._groups:
|
||
try:
|
||
gq = list(st[g].q)
|
||
except Exception:
|
||
gq = q
|
||
n = len(gq)
|
||
cmds[g] = flexivrdk.NrtJointPositionCmd(
|
||
gq, [0.0] * n, [1.5] * n, [2.0] * n
|
||
)
|
||
robot.SendJointPosition(cmds)
|
||
else:
|
||
n = len(q)
|
||
robot.SendJointPosition(q, [0.0] * n, [1.5] * n, [2.0] * n)
|
||
except Exception as exc:
|
||
log(f'soft loop: {exc}')
|
||
time.sleep(0.15)
|
||
# ~20 Hz — keep lock released most of the time
|
||
for _ in range(10):
|
||
if self._stop.is_set():
|
||
return
|
||
time.sleep(0.005)
|
||
|
||
def stop(self) -> None:
|
||
self._stop.set()
|
||
th = self._thread
|
||
if th is not None:
|
||
th.join(timeout=4.0)
|
||
if th.is_alive():
|
||
log('soft loop still alive after join (will idle anyway)')
|
||
self._thread = None
|
||
|
||
|
||
def _ensure_operational(robot) -> Optional[str]:
|
||
"""保留旧名以兼容既有调用点；实现已统一到 rdk_helpers.ensure_operational。"""
|
||
return ensure_operational(robot)
|
||
|
||
|
||
def _idle_async(robot, lock: threading.Lock, flexivrdk, timeout: float = 4.0) -> bool:
|
||
"""Switch to IDLE without blocking the stdin loop forever."""
|
||
done = threading.Event()
|
||
|
||
def run() -> None:
|
||
try:
|
||
acquired = lock.acquire(timeout=2.0)
|
||
try:
|
||
if acquired:
|
||
try:
|
||
robot.Stop()
|
||
except Exception as exc:
|
||
log(f'Stop: {exc}')
|
||
try:
|
||
robot.SwitchMode(flexivrdk.Mode.IDLE)
|
||
except Exception as exc:
|
||
log(f'SwitchMode IDLE: {exc}')
|
||
finally:
|
||
if acquired:
|
||
lock.release()
|
||
finally:
|
||
done.set()
|
||
|
||
threading.Thread(target=run, name='idle', daemon=True).start()
|
||
ok = done.wait(timeout)
|
||
if not ok:
|
||
log('IDLE/Stop timed out — stdin loop continues')
|
||
return ok
|
||
|
||
|
||
def main() -> int:
|
||
import flexivrdk
|
||
|
||
robot = None
|
||
drag_on = False
|
||
soft: Optional[SoftDrag] = None
|
||
rlock = threading.Lock()
|
||
cached_q: List[float] = []
|
||
|
||
for line in sys.stdin:
|
||
line = line.strip()
|
||
if not line:
|
||
continue
|
||
try:
|
||
msg = json.loads(line)
|
||
except Exception as exc: # noqa: BLE001
|
||
reply({'ok': False, 'error': f'bad json: {exc}'})
|
||
continue
|
||
|
||
cmd = str(msg.get('cmd', '')).strip()
|
||
try:
|
||
if cmd == 'ping':
|
||
reply({'ok': True, 'py': sys.version.split()[0]})
|
||
|
||
elif cmd == 'connect':
|
||
sn = str(msg.get('sn', 'Rizon4-063989'))
|
||
iface = str(msg.get('iface') or '')
|
||
robot = None
|
||
last_err = None
|
||
attempts = []
|
||
if iface:
|
||
attempts.extend([(sn, [iface]), (sn, [iface], True)])
|
||
attempts.append((sn,))
|
||
for args in attempts:
|
||
try:
|
||
robot = flexivrdk.Robot(*args)
|
||
log(f'connected {sn} args={args!r}')
|
||
last_err = None
|
||
break
|
||
except TypeError:
|
||
continue
|
||
except Exception as exc:
|
||
last_err = exc
|
||
log(f'connect {args!r}: {exc}')
|
||
robot = None
|
||
if robot is None:
|
||
reply({'ok': False, 'error': str(last_err or 'connect failed')})
|
||
continue
|
||
err = _ensure_operational(robot)
|
||
if err:
|
||
reply({'ok': False, 'error': err})
|
||
continue
|
||
with rlock:
|
||
q = [float(v) for v in list(robot.states().q)[:7]]
|
||
cached_q = q
|
||
reply({'ok': True, 'sn': sn, 'q': q})
|
||
|
||
elif cmd == 'drag_on':
|
||
if robot is None:
|
||
reply({'ok': False, 'error': 'not connected'})
|
||
continue
|
||
err = _ensure_operational(robot)
|
||
if err:
|
||
reply({'ok': False, 'error': err})
|
||
continue
|
||
|
||
prefer = str(msg.get('mode', 'soft')).strip().lower()
|
||
if prefer in ('floating', 'primitive', 'floatingjoint'):
|
||
name = str(msg.get('primitive', 'FloatingJoint')).replace('()', '')
|
||
try:
|
||
with rlock:
|
||
robot.SwitchMode(flexivrdk.Mode.NRT_PRIMITIVE_EXECUTION)
|
||
robot.ExecutePrimitive(name, {})
|
||
drag_on = True
|
||
reply({'ok': True, 'drag': True, 'mode': 'floating', 'primitive': name})
|
||
continue
|
||
except Exception as exc:
|
||
log(f'Floating failed, fallback soft: {exc}')
|
||
|
||
try:
|
||
if soft is not None:
|
||
soft.stop()
|
||
soft = SoftDrag(robot, flexivrdk, rlock)
|
||
soft.start()
|
||
if soft.latest_q:
|
||
cached_q = list(soft.latest_q)
|
||
drag_on = True
|
||
log('soft drag ON')
|
||
reply({
|
||
'ok': True,
|
||
'drag': True,
|
||
'mode': 'soft',
|
||
'hint': 'Push the arm gently; low joint impedance. Enter=photo (s=hold).',
|
||
})
|
||
except Exception as exc:
|
||
reply({'ok': False, 'error': f'soft drag failed: {exc}'})
|
||
|
||
elif cmd == 'drag_off':
|
||
log('drag_off requested')
|
||
if soft is not None:
|
||
if soft.latest_q:
|
||
cached_q = list(soft.latest_q)
|
||
soft.stop()
|
||
soft = None
|
||
if robot is not None:
|
||
_idle_async(robot, rlock, flexivrdk, timeout=4.0)
|
||
drag_on = False
|
||
log('drag_off done')
|
||
reply({'ok': True, 'drag': False, 'q': cached_q})
|
||
|
||
elif cmd == 'joints':
|
||
q: Optional[List[float]] = None
|
||
if soft is not None and len(soft.latest_q) >= 7:
|
||
q = list(soft.latest_q)
|
||
elif len(cached_q) >= 7:
|
||
q = list(cached_q)
|
||
if q is None or len(q) < 7:
|
||
reply({'ok': False, 'error': 'no joint cache'})
|
||
continue
|
||
cached_q = q
|
||
reply({'ok': True, 'q': q, 'drag': drag_on})
|
||
|
||
elif cmd == 'enable':
|
||
if robot is None:
|
||
reply({'ok': False, 'error': '尚未 connect'})
|
||
continue
|
||
err = ensure_operational(robot)
|
||
reply({
|
||
'ok': err is None,
|
||
'error': err,
|
||
'operational': bool(robot.operational()),
|
||
})
|
||
|
||
elif cmd == 'clear_fault':
|
||
if robot is None:
|
||
reply({'ok': False, 'error': '尚未 connect'})
|
||
continue
|
||
err = rdk_clear_fault(robot)
|
||
if err:
|
||
reply({'ok': False, 'error': err})
|
||
continue
|
||
# 清故障后顺手使能，否则调用方还得再发一条 enable。
|
||
err2 = ensure_operational(robot)
|
||
reply({
|
||
'ok': err2 is None,
|
||
'error': err2,
|
||
'fault': bool(robot.fault()),
|
||
'operational': bool(robot.operational()),
|
||
})
|
||
|
||
elif cmd == 'switch_tool':
|
||
if robot is None:
|
||
reply({'ok': False, 'error': '尚未 connect'})
|
||
continue
|
||
want = str(msg.get('name', '')).strip()
|
||
|
||
# 切换工具要求 IDLE；这一步是同步的，因为切换本身不能被打断。
|
||
err = ensure_idle(robot, flexivrdk.Mode, timeout_s=12.0)
|
||
if err:
|
||
reply({'ok': False, 'error': err})
|
||
continue
|
||
|
||
try:
|
||
with rlock:
|
||
tool = flexivrdk.Tool(robot)
|
||
groups = single_arm_groups(robot)
|
||
available = [str(n) for n in (tool.list() or [])]
|
||
anchor = groups[0] if groups else None
|
||
|
||
if not want:
|
||
# 纯查询：不切换，把当前工具与参数报回去。
|
||
params = tool_params(tool, anchor)
|
||
reply({
|
||
'ok': True,
|
||
'switched': False,
|
||
'current': tool_name(tool, anchor),
|
||
'available': available,
|
||
**params,
|
||
})
|
||
continue
|
||
|
||
target = resolve_tool_name(tool, want)
|
||
already = all(tool_name(tool, g) == target for g in groups)
|
||
if not already:
|
||
for g in groups:
|
||
switch_tool(tool, g, target)
|
||
time.sleep(0.3)
|
||
|
||
params = tool_params(tool, anchor)
|
||
reply({
|
||
'ok': True,
|
||
'switched': not already,
|
||
'already': already,
|
||
'current': tool_name(tool, anchor),
|
||
'target': target,
|
||
'available': available,
|
||
**params,
|
||
})
|
||
except Exception as exc: # noqa: BLE001
|
||
reply({'ok': False, 'error': str(exc)})
|
||
|
||
elif cmd == 'status':
|
||
if robot is None:
|
||
reply({'ok': False, 'connected': False, 'error': '尚未 connect'})
|
||
continue
|
||
info = {'ok': True, 'connected': True, 'drag': drag_on}
|
||
try:
|
||
info['operational'] = bool(robot.operational())
|
||
info['fault'] = bool(robot.fault())
|
||
info['mode'] = str(robot.mode())
|
||
except Exception as exc: # noqa: BLE001
|
||
info['error'] = str(exc)
|
||
try:
|
||
with rlock:
|
||
tool = flexivrdk.Tool(robot)
|
||
groups = single_arm_groups(robot)
|
||
info['tool'] = tool_name(tool, groups[0] if groups else None)
|
||
except Exception:
|
||
info['tool'] = ''
|
||
reply(info)
|
||
|
||
elif cmd == 'quit':
|
||
if soft is not None:
|
||
soft.stop()
|
||
soft = None
|
||
if robot is not None and drag_on:
|
||
_idle_async(robot, rlock, flexivrdk, timeout=3.0)
|
||
reply({'ok': True})
|
||
return 0
|
||
|
||
else:
|
||
reply({'ok': False, 'error': f'unknown cmd {cmd}'})
|
||
except Exception as exc: # noqa: BLE001
|
||
log(f'cmd={cmd} error: {exc}')
|
||
reply({'ok': False, 'error': str(exc)})
|
||
return 0
|
||
|
||
|
||
if __name__ == '__main__':
|
||
raise SystemExit(main())
|