rainbow-rb-sdk 0.0.9.dev5__py3-none-any.whl

rainbow/rb_sdk/__init__.py

@@ -0,0 +1,42 @@
+"""Rainbow Robotics SDK package.
+
+이 패키지는 문서 빌드 중에 종속성을 방지하기 위해 lazy import를 사용하여 선택된 SDK 진입점을 제공합니다.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+__all__ = ["RBAmrSDK", "RBManipulateSDK", "RBBaseSDK", "RBRby1SDK"]
+
+# 타입체커/IDE(자동완성)용: 여기서는 import 해도 런타임에 실행되지 않음
+if TYPE_CHECKING:
+    from .amr import RBAmrSDK
+    from .base import RBBaseSDK
+    from .manipulate import RBManipulateSDK
+    from .rby1 import RBRby1SDK
+
+
+def __getattr__(name: str):
+    if name == "RBManipulateSDK":
+        from .manipulate import RBManipulateSDK  # noqa: PLC0415
+        return RBManipulateSDK
+
+    if name == "RBBaseSDK":
+        from .base import RBBaseSDK  # noqa: PLC0415
+        return RBBaseSDK
+
+    if name == "RBAmrSDK":
+        from .amr import RBAmrSDK  # noqa: PLC0415
+        return RBAmrSDK
+
+    if name == "RBRby1SDK":
+        from .rby1 import RBRby1SDK  # noqa: PLC0415
+        return RBRby1SDK
+
+    raise AttributeError(name)
+
+
+def __dir__() -> list[str]:
+    # dir(rb_sdk) 결과가 __all__과 일치하게 (IDE/REPL 친화)
+    return sorted(__all__)

rainbow/rb_sdk/amr.py

@@ -0,0 +1,57 @@
+
+
+from rainbow.rb_sdk.amr_sdk.amr_capability import RBAmrCapabilitySDK
+from rainbow.rb_sdk.amr_sdk.amr_program import RBAmrProgramSDK
+
+from .amr_sdk.amr_control import RBAmrControlSDK
+from .amr_sdk.amr_file import RBAmrFileSDK
+from .amr_sdk.amr_localization import RBAmrLocalizationSDK
+from .amr_sdk.amr_map import RBAmrMapSDK
+from .amr_sdk.amr_move import RBAmrMoveSDK
+from .amr_sdk.amr_setting import RBAmrSettingSDK
+from .amr_sdk.amr_status import RBAmrStatusSDK
+from .base import RBBaseSDK
+
+
+class RBAmrSDK(RBBaseSDK):
+    """Rainbow Robotics AMR SDK"""
+
+    move: RBAmrMoveSDK
+    """AMR 이동 관련 SDK 집합"""
+
+    control: RBAmrControlSDK
+    """AMR 제어 관련 SDK 집합"""
+
+    localization: RBAmrLocalizationSDK
+    """AMR 위치 추정 관련 SDK 집합"""
+
+    map: RBAmrMapSDK
+    """AMR 맵 관련 SDK 집합"""
+
+    setting: RBAmrSettingSDK
+    """AMR 설정 관련 SDK 집합"""
+
+    file: RBAmrFileSDK
+    """AMR 파일 관련 SDK 집합"""
+
+    status: RBAmrStatusSDK
+    """AMR 상태 관련 SDK 집합"""
+
+    capability: RBAmrCapabilitySDK
+    """AMR 기능 관련 SDK 집합"""
+
+    program: RBAmrProgramSDK
+    """AMR 프로그램 관련 SDK 집합"""
+
+    def __init__(self):
+        super().__init__(server="amr")
+
+        self.move = RBAmrMoveSDK()
+        self.control = RBAmrControlSDK()
+        self.localization = RBAmrLocalizationSDK()
+        self.map = RBAmrMapSDK()
+        self.setting = RBAmrSettingSDK()
+        self.file = RBAmrFileSDK()
+        self.status = RBAmrStatusSDK()
+        self.capability = RBAmrCapabilitySDK()
+        self.program = RBAmrProgramSDK()

rainbow/rb_sdk/amr_sdk/amr_accessory.py

@@ -0,0 +1,200 @@
+import asyncio
+import uuid
+from contextlib import suppress
+from time import time
+from typing import Any
+
+from rainbow.rb_flat_buffers.SLAMNAV.RequestLiftPower import RequestLiftPowerT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseLiftPower import ResponseLiftPowerT
+from rainbow.rb_schemas.sdk import FlowManagerArgs
+from rainbow.rb_utils.parser import t_to_dict
+
+from rainbow.rb_sdk.base import RBBaseSDK
+
+
+class RBAmrAccessorySDK(RBBaseSDK):
+    """ Rainbow Robotics AMR Accessory SDK """
+
+    async def _accessory_flow_manager_solver(self, robot_model: str, req_id: str, flow_manager_args: FlowManagerArgs | None = None):
+        """
+        Accessory flow manager solver for AMR.
+        """
+        if flow_manager_args is None:
+            return None
+
+        done_event = asyncio.Event()
+        state: dict[str, Any] = {
+            "finished": False,
+            "error": "",
+            "last_seen": time.monotonic(),
+        }
+
+        def all_stop(*, flow_manager_args: FlowManagerArgs | None = None):
+            """모든 프로세스 정지"""
+            with suppress(Exception):
+                self.zenoh_client.query_one("muscat/stop", payload={})
+            if flow_manager_args is not None:
+                flow_manager_args.done()
+
+        async def _on_status(*, obj_payload=None, unsubscribe=None, **_):
+            if state["finished"] or obj_payload is None:
+                return
+
+            try:
+                flow_manager_args.ctx.check_stop()
+                state["last_seen"] = time.monotonic()
+
+                obj = t_to_dict(obj_payload)
+                print(f"FLOW MANAGER ACCESSORY STATUS >>>>>>>>>>> {obj.get('mapState').get('mapId')} {req_id} {obj.get('mapState').get('mapResult')} ", flush=True)
+
+                # if obj.get("mapState").get("mapId") != req_id:
+                #     raise RuntimeError("Map ID Mismatch")
+
+                # if obj.get("mapState").get("mapResult") == "success":
+                #     print("Map Flow Manager SOLVER DONE", flush=True)
+                #     flow_manager_args.done()
+                #     state["finished"] = True
+                #     if unsubscribe is not None:
+                #         unsubscribe()
+                #     done_event.set()
+                # elif obj.get("mapState").get("mapResult") == "fail":
+                #     raise RuntimeError("Map Load Fail")
+                # elif obj.get("mapState").get("mapResult") == "cancel":
+                #     raise RuntimeError("Map Load Cancel")
+            except Exception as e:
+                state["finished"] = True
+                state["error"] = str(e)
+                if unsubscribe is not None:
+                    unsubscribe()
+                done_event.set()
+
+        async def _watchdog():
+            timeout_sec = 2.0
+            interval_sec = 0.5
+            while not state["finished"]:
+                await asyncio.sleep(interval_sec)
+                if state["finished"]:
+                    return
+                if time.monotonic() - state["last_seen"] > timeout_sec:
+                    state["finished"] = True
+                    state["error"] = "Map Load Fail (Timeout)"
+                    done_event.set()
+                    return
+
+        # sub_handle = self.zenoh_client.subscribe(
+        #     f"amr/{robot_model}/status",
+        #     _on_status,
+        #     flatbuffer_obj_t=StatusT,
+        #     options=SubscribeOptions(
+        #         dispatch="queue",
+        #         overflow=OverflowPolicy.LATEST_ONLY,
+        #         parse_dict_payload=False,
+        #     ),
+        # )
+        watchdog_task = asyncio.create_task(_watchdog())
+
+
+        try:
+            await done_event.wait()
+            if state["error"] != "":
+                raise RuntimeError(state["error"])
+        except asyncio.CancelledError:
+            pass
+        except Exception as e:
+            all_stop(flow_manager_args=flow_manager_args)
+            raise RuntimeError(str(e)) from e
+        finally:
+            watchdog_task.cancel()
+            try:
+                await watchdog_task
+            except asyncio.CancelledError:
+                print("WATCHDOG CANCELLED", flush=True)
+            # sub_handle.close()
+
+        return None
+
+    def set_lift_power(self, robot_model: str, switch: bool, req_id: str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseLiftPowerT:
+        """
+        [Lift 전원 제어]
+        - robot_model: 로봇 모델
+        - switch: 리프트 전원 스위치 (True: ON, False: OFF)
+        - req_id: 요청 ID (선택 사항)
+        - flow_manager_args: 플로우 매니저 인자 (선택 사항)
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        # 1) RequestLiftPower 객체 생성
+        req = RequestLiftPowerT()
+        req.id = req_id
+        req.switch = switch
+
+        # 2) 요청 전송
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/accessory/lift",
+            flatbuffer_req_obj=req,
+            flatbuffer_res_T_class=ResponseLiftPowerT,
+            flatbuffer_buf_size=2048,
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Lift Power failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            print(result["dict_payload"].get("result"))
+            if result["dict_payload"].get("result") == "reject":
+                raise RuntimeError(result["dict_payload"].get("message"))
+
+            self._run_coro_blocking(
+                self._accessory_flow_manager_solver(
+                    robot_model=robot_model,
+                    req_id=req_id,
+                    flow_manager_args=flow_manager_args,
+                )
+            )
+        return result["obj_payload"]
+
+    # def set_foot_pose(self, robot_model: str, foot_pose: FootPoseT, req_id: str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseFootPoseT:
+    #     """
+    #     [Foot Pose 제어]
+    #     - robot_model: 로봇 모델
+    #     - foot_pose: 발 포즈 정보
+    #     - req_id: 요청 ID (선택 사항)
+    #     - flow_manager_args: 플로우 매니저 인자 (선택 사항)
+    #     """
+
+    #     if req_id is None:
+    #         req_id = str(uuid.uuid4())
+
+    #     # 1) RequestFootMove 객체 생성
+    #     req = RequestFootMoveT()
+    #     req.id = req_id
+    #     req.pose = foot_pose
+
+    #     # 2) 요청 전송
+    #     result = self.zenoh_client.query_one(
+    #         f"amr/{robot_model}/accessory/foot",
+    #         flatbuffer_req_obj=req,
+    #         flatbuffer_res_T_class=ResponseFootMoveT,
+    #         flatbuffer_buf_size=2048,
+    #     )
+
+    #     # 3) 결과 처리 및 반환
+    #     if result.get("obj_payload") is None:
+    #         raise RuntimeError("Call Foot Pose failed: obj_payload is None")
+
+    #     if flow_manager_args is not None:
+    #         print(result["dict_payload"].get("result"))
+    #         if result["dict_payload"].get("result") == "reject":
+    #             raise RuntimeError(result["dict_payload"].get("message"))
+
+    #         self._run_coro_blocking(
+    #             self._accessory_flow_manager_solver(
+    #                 robot_model=robot_model,
+    #                 req_id=req_id,
+    #                 flow_manager_args=flow_manager_args,
+    #             )
+    #         )
+    #     return result["obj_payload"]

rainbow/rb_sdk/amr_sdk/amr_capability.py

@@ -0,0 +1,391 @@
+import uuid
+
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilityCamera import RequestCapabilityCameraT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilityDock import RequestCapabilityDockT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilityImu import RequestCapabilityImuT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilityLidar2D import RequestCapabilityLidar2DT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilityLidar3D import RequestCapabilityLidar3DT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilitySafetyBumper import RequestCapabilitySafetyBumperT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilitySafetyInterlock import (
+    RequestCapabilitySafetyInterlockT,
+)
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilitySafetyIo import RequestCapabilitySafetyIoT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilitySafetyObstacle import RequestCapabilitySafetyObstacleT
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilitySafetyOperationStop import (
+    RequestCapabilitySafetyOperationStopT,
+)
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilitySafetySpeedControl import (
+    RequestCapabilitySafetySpeedControlT,
+)
+from rainbow.rb_flat_buffers.SLAMNAV.RequestCapabilityTabos import RequestCapabilityTabosT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilityCamera import ResponseCapabilityCameraT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilityDock import ResponseCapabilityDockT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilityImu import ResponseCapabilityImuT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilityLidar2D import ResponseCapabilityLidar2DT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilityLidar3D import ResponseCapabilityLidar3DT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilitySafetyBumper import ResponseCapabilitySafetyBumperT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilitySafetyInterlock import (
+    ResponseCapabilitySafetyInterlockT,
+)
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilitySafetyIo import ResponseCapabilitySafetyIoT
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilitySafetyObstacle import (
+    ResponseCapabilitySafetyObstacleT,
+)
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilitySafetyOperationStop import (
+    ResponseCapabilitySafetyOperationStopT,
+)
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilitySafetySpeedControl import (
+    ResponseCapabilitySafetySpeedControlT,
+)
+from rainbow.rb_flat_buffers.SLAMNAV.ResponseCapabilityTabos import ResponseCapabilityTabosT
+from rainbow.rb_schemas.fbs_models.amr.v1.slamnav_capability_models import (
+    ResponseCapabilityDockPD,
+)
+from rainbow.rb_schemas.sdk import FlowManagerArgs
+
+from rainbow.rb_sdk.base import RBBaseSDK
+
+
+class RBAmrCapabilitySDK(RBBaseSDK):
+    """
+    [AMR Capability SDK]
+    """
+    def get_capability_dock(self, robot_model: str, req_id: str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilityDockT:
+        """
+        [AMR Capability Dock]
+        """
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        # 1) RequestCapabilityDockT 객체 생성
+        req = RequestCapabilityDockT()
+        req.id = req_id
+
+        # 2) 요청 전송
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/dock",
+            flatbuffer_req_obj=req,
+            flatbuffer_res_T_class=ResponseCapabilityDockPD,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Dock failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_safety_io(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilitySafetyIoT:
+        """
+        [로봇 IO 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilitySafetyIoT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/safety/io",
+            flatbuffer_res_T_class=ResponseCapabilitySafetyIoT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Safety IO failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+
+    def get_capability_camera(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilityCameraT:
+        """
+        [로봇 카메라 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilityCameraT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/camera",
+            flatbuffer_res_T_class=ResponseCapabilityCameraT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Camera failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+
+    def get_capability_lidar2d(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilityLidar2DT:
+        """
+        [로봇 라이다 2D  상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilityLidar2DT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/lidar2d",
+            flatbuffer_res_T_class=ResponseCapabilityLidar2DT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Lidar 2D failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+
+    def get_capability_lidar3d(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilityLidar3DT:
+        """
+        [로봇 라이다 3D  상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilityLidar3DT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/lidar3d",
+            flatbuffer_res_T_class=ResponseCapabilityLidar3DT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Lidar 3D failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_imu(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilityImuT:
+        """
+        [로봇 IMU 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilityImuT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/imu",
+            flatbuffer_res_T_class=ResponseCapabilityImuT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability IMU failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_safety_bumper(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilitySafetyBumperT:
+        """
+        [로봇 안전 범퍼 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilitySafetyBumperT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/safety/bumper",
+            flatbuffer_res_T_class=ResponseCapabilitySafetyBumperT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Safety Bumper failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_safety_interlock(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilitySafetyInterlockT:
+        """
+        [로봇 안전 인터록 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilitySafetyInterlockT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/safety/interlock",
+            flatbuffer_res_T_class=ResponseCapabilitySafetyInterlockT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Safety Interlock failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_safety_obstacle(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilitySafetyObstacleT:
+        """
+        [로봇 안전 장애물 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilitySafetyObstacleT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/safety/obstacle",
+            flatbuffer_res_T_class=ResponseCapabilitySafetyObstacleT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Safety Obstacle failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_safety_operation_stop(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilitySafetyOperationStopT:
+        """
+        [로봇 안전 작동 정지 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilitySafetyOperationStopT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/safety/operation/stop",
+            flatbuffer_res_T_class=ResponseCapabilitySafetyOperationStopT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Safety Operation Stop failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_safety_speed_control(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilitySafetySpeedControlT:
+        """
+        [로봇 안전 속도 제어 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilitySafetySpeedControlT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/safety/speed/control",
+            flatbuffer_res_T_class=ResponseCapabilitySafetySpeedControlT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Safety Speed Control failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]
+
+    def get_capability_tabos(self, robot_model: str, req_id:str | None = None, flow_manager_args: FlowManagerArgs | None = None) -> ResponseCapabilityTabosT:
+        """
+        [로봇 안전 도킹 상태 조회]
+        """
+
+        if req_id is None:
+            req_id = str(uuid.uuid4())
+
+        req = RequestCapabilityTabosT()
+        req.id = req_id
+
+        result = self.zenoh_client.query_one(
+            f"amr/{robot_model}/capability/dock",
+            flatbuffer_res_T_class=ResponseCapabilityTabosT,
+            flatbuffer_req_obj=req,
+            flatbuffer_buf_size=125,
+            timeout=3
+        )
+
+        # 3) 결과 처리 및 반환
+        if result.get("obj_payload") is None:
+            raise RuntimeError("Call Get Capability Tabos failed: obj_payload is None")
+
+        if flow_manager_args is not None:
+            flow_manager_args.done()
+
+        return result["obj_payload"]