hex-zmq-servers 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

hex_zmq_servers/__init__.py

@@ -9,8 +9,8 @@
 from .hex_launch import HexLaunch, HexNodeConfig, HEX_LOG_LEVEL, hex_dict_str, hex_log, hex_err
 
 from .device_base import HexDeviceBase
-from .zmq_base import HexRate, hex_zmq_ts_now, hex_zmq_ts_delta_ms
-from .zmq_base import HexSafeValue, HexZMQClientBase, HexZMQServerBase, hex_server_helper
+from .zmq_base import hex_zmq_ts_to_ns, ns_to_hex_zmq_ts, hex_ns_now, hex_zmq_ts_now, hex_zmq_ts_delta_ms
+from .zmq_base import HexRate, HexZMQClientBase, HexZMQServerBase, hex_server_helper
 from .zmq_base import HexZMQDummyClient, HexZMQDummyServer
 
 from .robot import HexRobotBase, HexRobotClientBase, HexRobotServerBase
@@ -18,6 +18,10 @@ from .robot import HexRobotDummy, HexRobotDummyClient, HexRobotDummyServer
 from .robot import HexRobotGello, HexRobotGelloClient, HexRobotGelloServer
 from .robot import HexRobotHexarm, HexRobotHexarmClient, HexRobotHexarmServer, HEXARM_URDF_PATH_DICT
 
+from .cam import HexCamBase, HexCamClientBase, HexCamServerBase
+from .cam import HexCamDummy, HexCamDummyClient, HexCamDummyServer
+from .cam import HexCamRGB, HexCamRGBClient, HexCamRGBServer
+
 import os
 
 file_dir = os.path.dirname(os.path.abspath(__file__))
@@ -26,12 +30,16 @@ HEX_ZMQ_SERVERS_PATH_DICT = {
     "robot_dummy": f"{file_dir}/robot/dummy/robot_dummy_srv.py",
     "robot_gello": f"{file_dir}/robot/gello/robot_gello_srv.py",
     "robot_hexarm": f"{file_dir}/robot/hexarm/robot_hexarm_srv.py",
+    "cam_dummy": f"{file_dir}/cam/dummy/cam_dummy_srv.py",
+    "cam_rgb": f"{file_dir}/cam/rgb/cam_rgb_srv.py",
 }
 HEX_ZMQ_CONFIGS_PATH_DICT = {
     "zmq_dummy": f"{file_dir}/config/zmq_dummy.json",
     "robot_dummy": f"{file_dir}/config/robot_dummy.json",
     "robot_gello": f"{file_dir}/config/robot_gello.json",
     "robot_hexarm": f"{file_dir}/config/robot_hexarm.json",
+    "cam_dummy": f"{file_dir}/config/cam_dummy.json",
+    "cam_rgb": f"{file_dir}/config/cam_rgb.json",
 }
 
 __all__ = [
@@ -54,9 +62,11 @@ __all__ = [
     # base
     "HexDeviceBase",
     "HexRate",
+    "hex_zmq_ts_to_ns",
+    "ns_to_hex_zmq_ts",
+    "hex_ns_now",
     "hex_zmq_ts_now",
     "hex_zmq_ts_delta_ms",
-    "HexSafeValue",
     "HexZMQClientBase",
     "HexZMQServerBase",
     "hex_server_helper",
@@ -76,47 +86,62 @@ __all__ = [
     "HexRobotHexarm",
     "HexRobotHexarmClient",
     "HexRobotHexarmServer",
+
+    # camera
+    "HexCamBase",
+    "HexCamClientBase",
+    "HexCamServerBase",
+    "HexCamDummy",
+    "HexCamDummyClient",
+    "HexCamDummyServer",
+    "HexCamRGB",
+    "HexCamRGBClient",
+    "HexCamRGBServer",
 ]
 
 # Check optional dependencies availability
 from importlib.util import find_spec
 
-_HAS_OPENCV = find_spec("cv2") is not None
 _HAS_BERXEL = find_spec("berxel_py_wrapper") is not None
+_HAS_REALSENSE = find_spec("pyrealsense2") is not None
 _HAS_MUJOCO = find_spec("mujoco") is not None
 
-# Optional: camera
-if _HAS_OPENCV and _HAS_BERXEL:
-    from .cam import HexCamBase, HexCamClientBase, HexCamServerBase
-    from .cam import HexCamDummy, HexCamDummyClient, HexCamDummyServer
+# Optional: berxel
+if _HAS_BERXEL:
     from .cam import HexCamBerxel, HexCamBerxelClient, HexCamBerxelServer
     HEX_ZMQ_SERVERS_PATH_DICT.update({
-        "cam_dummy":
-        f"{file_dir}/cam/dummy/cam_dummy_srv.py",
         "cam_berxel":
         f"{file_dir}/cam/berxel/cam_berxel_srv.py",
     })
     HEX_ZMQ_CONFIGS_PATH_DICT.update({
-        "cam_dummy":
-        f"{file_dir}/config/cam_dummy.json",
         "cam_berxel":
         f"{file_dir}/config/cam_berxel.json",
     })
     __all__.extend([
-        # camera
-        "HexCamBase",
-        "HexCamClientBase",
-        "HexCamServerBase",
-        "HexCamDummy",
-        "HexCamDummyClient",
-        "HexCamDummyServer",
         "HexCamBerxel",
         "HexCamBerxelClient",
         "HexCamBerxelServer",
     ])
 
+# Optional: realsense
+if _HAS_REALSENSE:
+    from .cam import HexCamRealsense, HexCamRealsenseClient, HexCamRealsenseServer
+    HEX_ZMQ_SERVERS_PATH_DICT.update({
+        "cam_realsense":
+        f"{file_dir}/cam/realsense/cam_realsense_srv.py",
+    })
+    HEX_ZMQ_CONFIGS_PATH_DICT.update({
+        "cam_realsense":
+        f"{file_dir}/config/cam_realsense.json",
+    })
+    __all__.extend([
+        "HexCamRealsense",
+        "HexCamRealsenseClient",
+        "HexCamRealsenseServer",
+    ])
+
 # Optional: mujoco
-if _HAS_OPENCV and _HAS_MUJOCO:
+if _HAS_MUJOCO:
     from .mujoco import HexMujocoBase, HexMujocoClientBase, HexMujocoServerBase
     from .mujoco import HexMujocoArcherY6, HexMujocoArcherY6Client, HexMujocoArcherY6Server
     from .mujoco import HexMujocoE3Desktop, HexMujocoE3DesktopClient, HexMujocoE3DesktopServer

hex_zmq_servers/cam/__init__.py

@@ -8,7 +8,7 @@
 
 from .cam_base import HexCamBase, HexCamClientBase, HexCamServerBase
 from .dummy import HexCamDummy, HexCamDummyClient, HexCamDummyServer
-from .berxel import HexCamBerxel, HexCamBerxelClient, HexCamBerxelServer
+from .rgb import HexCamRGB, HexCamRGBClient, HexCamRGBServer
 
 __all__ = [
     # base
@@ -21,8 +21,32 @@ __all__ = [
     "HexCamDummyClient",
     "HexCamDummyServer",
 
-    # berxel
-    "HexCamBerxel",
-    "HexCamBerxelClient",
-    "HexCamBerxelServer",
+    # rgb
+    "HexCamRGB",
+    "HexCamRGBClient",
+    "HexCamRGBServer",
 ]
+
+# Check optional dependencies availability
+from importlib.util import find_spec
+
+_HAS_BERXEL = find_spec("berxel_py_wrapper") is not None
+_HAS_REALSENSE = find_spec("pyrealsense2") is not None
+
+# Optional: berxel
+if _HAS_BERXEL:
+    from .berxel import HexCamBerxel, HexCamBerxelClient, HexCamBerxelServer
+    __all__.extend([
+        "HexCamBerxel",
+        "HexCamBerxelClient",
+        "HexCamBerxelServer",
+    ])
+
+# Optional: realsense
+if _HAS_REALSENSE:
+    from .realsense import HexCamRealsense, HexCamRealsenseClient, HexCamRealsenseServer
+    __all__.extend([
+        "HexCamRealsense",
+        "HexCamRealsenseClient",
+        "HexCamRealsenseServer",
+    ])

hex_zmq_servers/cam/berxel/cam_berxel.py

@@ -9,12 +9,10 @@
 import cv2
 import threading
 import numpy as np
+from collections import deque
 
 from ..cam_base import HexCamBase
-from ...zmq_base import (
-    hex_zmq_ts_now,
-    HexSafeValue,
-)
+from ...zmq_base import hex_zmq_ts_now
 from ...hex_launch import hex_log, HEX_LOG_LEVEL
 from berxel_py_wrapper import *
 
@@ -74,10 +72,10 @@ class HexCamBerxel(HexCamBase):
         self._wait_for_working()
         return self.__serial_number
 
-    def work_loop(self, hex_values: list[HexSafeValue | threading.Event]):
-        rgb_value = hex_values[0]
-        depth_value = hex_values[1]
-        stop_event = hex_values[2]
+    def work_loop(self, hex_queues: list[deque | threading.Event]):
+        rgb_queue = hex_queues[0]
+        depth_queue = hex_queues[1]
+        stop_event = hex_queues[2]
 
         rgb_count = 0
         depth_count = 0
@@ -89,13 +87,13 @@ class HexCamBerxel(HexCamBase):
             # collect rgb frame
             if hawk_rgb_frame is not None:
                 ts, frame = self.__unpack_frame(hawk_rgb_frame, False)
-                rgb_value.set((ts, rgb_count, frame))
+                rgb_queue.append((ts, rgb_count, frame))
                 rgb_count = (rgb_count + 1) % self._max_seq_num
 
             # collect depth frame
             if hawk_depth_frame is not None:
                 ts, frame = self.__unpack_frame(hawk_depth_frame, True)
-                depth_value.set((ts, depth_count, frame))
+                depth_queue.append((ts, depth_count, frame))
                 depth_count = (depth_count + 1) % self._max_seq_num
 
             self.__device.releaseFrame(hawk_rgb_frame)

hex_zmq_servers/cam/berxel/cam_berxel_cli.py

@@ -24,6 +24,7 @@ class HexCamBerxelClient(HexCamClientBase):
         net_config: dict = NET_CONFIG,
     ):
         HexCamClientBase.__init__(self, net_config)
+        self._wait_for_working()
 
     def get_intri(self):
         intri_hdr, intri = self.request({"cmd": "get_intri"})

hex_zmq_servers/cam/cam_base.py

@@ -8,10 +8,11 @@
 
 import threading
 import numpy as np
+from collections import deque
 from abc import abstractmethod
 
 from ..device_base import HexDeviceBase
-from ..zmq_base import HexSafeValue, HexZMQClientBase, HexZMQServerBase
+from ..zmq_base import HexZMQClientBase, HexZMQServerBase, HexRate
 
 NET_CONFIG = {
     "ip": "127.0.0.1",
@@ -31,7 +32,7 @@ class HexCamBase(HexDeviceBase):
         HexDeviceBase.__del__(self)
 
     @abstractmethod
-    def work_loop(self, hex_values: list[HexSafeValue | threading.Event]):
+    def work_loop(self, hex_queues: list[deque | threading.Event]):
         raise NotImplementedError(
             "`work_loop` should be implemented by the child class")
 
@@ -47,14 +48,30 @@ class HexCamClientBase(HexZMQClientBase):
         HexZMQClientBase.__init__(self, net_config)
         self._rgb_seq = 0
         self._depth_seq = 0
+        self._rgb_queue = deque(maxlen=10)
+        self._depth_queue = deque(maxlen=10)
 
     def __del__(self):
         HexZMQClientBase.__del__(self)
 
-    def get_rgb(self):
+    def get_rgb(self, newest: bool = False):
+        try:
+            return self._rgb_queue.popleft(
+            ) if not newest else self._rgb_queue[-1]
+        except IndexError:
+            return None, None
+
+    def get_depth(self, newest: bool = False):
+        try:
+            return self._depth_queue.popleft(
+            ) if not newest else self._depth_queue[-1]
+        except IndexError:
+            return None, None
+
+    def _get_rgb_inner(self):
         return self._process_frame(False)
 
-    def get_depth(self):
+    def _get_depth_inner(self):
         return self._process_frame(True)
 
     def _process_frame(self, depth_flag: bool):
@@ -83,14 +100,25 @@ class HexCamClientBase(HexZMQClientBase):
             print(f"\033[91m__process_frame failed: {e}\033[0m")
             return None, None
 
+    def _recv_loop(self):
+        rate = HexRate(200)
+        while self._recv_flag:
+            hdr, img = self._get_rgb_inner()
+            if hdr is not None:
+                self._rgb_queue.append((hdr, img))
+            hdr, img = self._get_depth_inner()
+            if hdr is not None:
+                self._depth_queue.append((hdr, img))
+            rate.sleep()
+
 
 class HexCamServerBase(HexZMQServerBase):
 
     def __init__(self, net_config: dict = NET_CONFIG):
         HexZMQServerBase.__init__(self, net_config)
         self._device: HexDeviceBase = None
-        self._rgb_value = HexSafeValue()
-        self._depth_value = HexSafeValue()
+        self._rgb_queue = deque(maxlen=10)
+        self._depth_queue = deque(maxlen=10)
 
     def __del__(self):
         HexZMQServerBase.__del__(self)
@@ -99,8 +127,8 @@ class HexCamServerBase(HexZMQServerBase):
     def work_loop(self):
         try:
             self._device.work_loop([
-                self._rgb_value,
-                self._depth_value,
+                self._rgb_queue,
+                self._depth_queue,
                 self._stop_event,
             ])
         finally:
@@ -115,9 +143,11 @@ class HexCamServerBase(HexZMQServerBase):
 
         try:
             if depth_flag:
-                ts, count, img = self._depth_value.get()
+                ts, count, img = self._depth_queue.popleft()
             else:
-                ts, count, img = self._rgb_value.get()
+                ts, count, img = self._rgb_queue.popleft()
+        except IndexError:
+            return {"cmd": f"{recv_hdr['cmd']}_failed"}, None
         except Exception as e:
             print(f"\033[91m{recv_hdr['cmd']} failed: {e}\033[0m")
             return {"cmd": f"{recv_hdr['cmd']}_failed"}, None

hex_zmq_servers/cam/dummy/cam_dummy.py

@@ -8,12 +8,12 @@
 
 import threading
 import numpy as np
+from collections import deque
 
 from ..cam_base import HexCamBase
 from ...zmq_base import (
     hex_zmq_ts_now,
     HexRate,
-    HexSafeValue,
 )
 from ...hex_launch import hex_log, HEX_LOG_LEVEL
 
@@ -27,10 +27,10 @@ class HexCamDummy(HexCamBase):
     def __del__(self):
         HexCamBase.__del__(self)
 
-    def work_loop(self, hex_values: list[HexSafeValue | threading.Event]):
-        rgb_value = hex_values[0]
-        depth_value = hex_values[1]
-        stop_event = hex_values[2]
+    def work_loop(self, hex_queues: list[deque | threading.Event]):
+        rgb_queue = hex_queues[0]
+        depth_queue = hex_queues[1]
+        stop_event = hex_queues[2]
 
         rgb_count = 0
         depth_count = 0
@@ -43,7 +43,7 @@ class HexCamDummy(HexCamBase):
                 (480, 640, 3),
                 dtype=np.uint8,
             )
-            rgb_value.set((hex_zmq_ts_now(), rgb_count, rgb_img))
+            rgb_queue.append((hex_zmq_ts_now(), rgb_count, rgb_img))
             rgb_count = (rgb_count + 1) % self._max_seq_num
 
             # depth
@@ -53,7 +53,7 @@ class HexCamDummy(HexCamBase):
                 (480, 640),
                 dtype=np.uint16,
             )
-            depth_value.set((hex_zmq_ts_now(), depth_count, depth_img))
+            depth_queue.append((hex_zmq_ts_now(), depth_count, depth_img))
             depth_count = (depth_count + 1) % self._max_seq_num
 
             # sleep

hex_zmq_servers/cam/dummy/cam_dummy_cli.py

@@ -24,3 +24,4 @@ class HexCamDummyClient(HexCamClientBase):
         net_config: dict = NET_CONFIG,
     ):
         HexCamClientBase.__init__(self, net_config)
+        self._wait_for_working()

hex_zmq_servers/cam/realsense/__init__.py

@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2025 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2025-09-12
+################################################################
+
+from .cam_realsense import HexCamRealsense
+from .cam_realsense_cli import HexCamRealsenseClient
+from .cam_realsense_srv import HexCamRealsenseServer
+
+__all__ = [
+    "HexCamRealsense",
+    "HexCamRealsenseClient",
+    "HexCamRealsenseServer",
+]

hex_zmq_servers/cam/realsense/cam_realsense.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2025 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2025-09-14
+################################################################
+
+import threading
+import numpy as np
+from collections import deque
+
+from ..cam_base import HexCamBase
+from ...zmq_base import (
+    hex_ns_now,
+    hex_zmq_ts_now,
+    hex_zmq_ts_delta_ms,
+)
+from ...hex_launch import hex_log, HEX_LOG_LEVEL
+import pyrealsense2 as rs
+
+CAMERA_CONFIG = {
+    "serial_number": '243422073194',
+    "resolution": [640, 480],
+    "frame_rate": 30,
+    "sens_ts": True,
+}
+
+
+class HexCamRealsense(HexCamBase):
+
+    def __init__(
+        self,
+        camera_config: dict = CAMERA_CONFIG,
+    ):
+        HexCamBase.__init__(self)
+
+        try:
+            self.__serial_number = camera_config["serial_number"]
+            self.__resolution = camera_config["resolution"]
+            self.__frame_rate = camera_config["frame_rate"]
+            self.__sens_ts = camera_config["sens_ts"]
+        except KeyError as ke:
+            missing_key = ke.args[0]
+            raise ValueError(
+                f"camera_config is not valid, missing key: {missing_key}")
+
+        # variables
+        # realsense variables
+        ctx = rs.context()
+        serial_numbers = []
+        for dev in ctx.query_devices():
+            serial = dev.get_info(rs.camera_info.serial_number)
+            name = dev.get_info(rs.camera_info.name)
+            print(f"  - Device: {name}, Serial: {serial}")
+            serial_numbers.append(serial)
+        if self.__serial_number not in serial_numbers:
+            print(
+                f"can not find device with serial number: {self.__serial_number}"
+            )
+            return
+
+        # camera variables
+        self.__intri = np.zeros(4)
+
+        # open device
+        self.__pipeline = rs.pipeline()
+        config = rs.config()
+        config.enable_device(self.__serial_number)
+        config.enable_stream(
+            rs.stream.color,
+            self.__resolution[0],
+            self.__resolution[1],
+            rs.format.bgr8,
+            self.__frame_rate,
+        )
+        config.enable_stream(
+            rs.stream.depth,
+            self.__resolution[0],
+            self.__resolution[1],
+            rs.format.z16,
+            self.__frame_rate,
+        )
+        profile = self.__pipeline.start(config)
+        color_profile = profile.get_stream(rs.stream.color)
+        color_intrinsics = color_profile.as_video_stream_profile(
+        ).get_intrinsics()
+        self.__intri[0] = color_intrinsics.fx
+        self.__intri[1] = color_intrinsics.fy
+        self.__intri[2] = color_intrinsics.ppx
+        self.__intri[3] = color_intrinsics.ppy
+        self.__align = rs.align(rs.stream.color)
+        self.__bias_ns = None
+
+        # start work loop
+        self._working.set()
+
+    def get_intri(self) -> np.ndarray:
+        self._wait_for_working()
+        return self.__intri
+
+    def get_serial_number(self) -> np.ndarray:
+        self._wait_for_working()
+        return self.__serial_number
+
+    def work_loop(self, hex_queues: list[deque | threading.Event]):
+        rgb_queue = hex_queues[0]
+        depth_queue = hex_queues[1]
+        stop_event = hex_queues[2]
+
+        frames = self.__pipeline.wait_for_frames()
+        bias_ns = np.int64(hex_ns_now()) - np.int64(
+            frames.get_frame_metadata(rs.frame_metadata_value.sensor_timestamp)
+            * 1_000)
+
+        rgb_count = 0
+        depth_count = 0
+        while self._working.is_set() and not stop_event.is_set():
+            # read frame
+            aligned_frames = self.__align.process(
+                self.__pipeline.wait_for_frames())
+            cur_ns = hex_zmq_ts_now()
+            sen_ts_ns = bias_ns + np.int64(
+                aligned_frames.get_frame_metadata(
+                    rs.frame_metadata_value.sensor_timestamp) * 1_000)
+            sen_ts = {
+                "s": sen_ts_ns // 1_000_000_000,
+                "ns": sen_ts_ns % 1_000_000_000,
+            }
+            if hex_zmq_ts_delta_ms(cur_ns, sen_ts) < 0:
+                sen_ts = cur_ns
+
+            # collect rgb frame
+            color_frame = aligned_frames.get_color_frame()
+            if color_frame:
+
+                rgb_queue.append((sen_ts if self.__sens_ts else cur_ns, rgb_count,
+                               np.asanyarray(color_frame.get_data())))
+                rgb_count = (rgb_count + 1) % self._max_seq_num
+
+            # collect depth frame
+            depth_frame = aligned_frames.get_depth_frame()
+            if depth_frame:
+                depth_queue.append(
+                    (sen_ts if self.__sens_ts else cur_ns, depth_count,
+                     np.asanyarray(depth_frame.get_data())))
+                depth_count = (depth_count + 1) % self._max_seq_num
+
+        # close
+        self.close()
+
+    def close(self):
+        if not self._working.is_set():
+            return
+        self._working.clear()
+        self.__pipeline.stop()
+        hex_log(HEX_LOG_LEVEL["info"], "HexCamRealsense closed")

hex_zmq_servers/cam/realsense/cam_realsense_cli.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2025 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2025-09-12
+################################################################
+
+from ..cam_base import HexCamClientBase
+
+NET_CONFIG = {
+    "ip": "127.0.0.1",
+    "port": 12345,
+    "client_timeout_ms": 200,
+    "server_timeout_ms": 1_000,
+    "server_num_workers": 4,
+}
+
+
+class HexCamRealsenseClient(HexCamClientBase):
+
+    def __init__(
+        self,
+        net_config: dict = NET_CONFIG,
+    ):
+        HexCamClientBase.__init__(self, net_config)
+        self._wait_for_working()
+
+    def get_intri(self):
+        intri_hdr, intri = self.request({"cmd": "get_intri"})
+        return intri_hdr, intri

hex_zmq_servers/cam/realsense/cam_realsense_srv.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2025 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2025-09-12
+################################################################
+
+import numpy as np
+
+try:
+    from ..cam_base import HexCamServerBase
+    from .cam_realsense import HexCamRealsense
+except (ImportError, ValueError):
+    import sys
+    from pathlib import Path
+    this_file = Path(__file__).resolve()
+    project_root = this_file.parents[3]
+    if str(project_root) not in sys.path:
+        sys.path.insert(0, str(project_root))
+    from hex_zmq_servers.cam.cam_base import HexCamServerBase
+    from hex_zmq_servers.cam.realsense.cam_realsense import HexCamRealsense
+
+NET_CONFIG = {
+    "ip": "127.0.0.1",
+    "port": 12345,
+    "client_timeout_ms": 200,
+    "server_timeout_ms": 1_000,
+    "server_num_workers": 4,
+}
+
+CAMERA_CONFIG = {
+    "serial_number": '243422073194',
+    "resolution": [640, 480],
+    "frame_rate": 30,
+    "sens_ts": True,
+}
+
+
+class HexCamRealsenseServer(HexCamServerBase):
+
+    def __init__(
+        self,
+        net_config: dict = NET_CONFIG,
+        params_config: dict = CAMERA_CONFIG,
+    ):
+        HexCamServerBase.__init__(self, net_config)
+
+        # camera
+        self._device = HexCamRealsense(params_config)
+
+    def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
+        if recv_hdr["cmd"] == "is_working":
+            return self.no_ts_hdr(recv_hdr, self._device.is_working()), None
+        elif recv_hdr["cmd"] == "get_intri":
+            intri = self._device.get_intri()
+            return self.no_ts_hdr(recv_hdr, intri is not None), intri
+        elif recv_hdr["cmd"] == "get_rgb":
+            return self._get_frame(recv_hdr, False)
+        elif recv_hdr["cmd"] == "get_depth":
+            return self._get_frame(recv_hdr, True)
+        else:
+            raise ValueError(f"unknown command: {recv_hdr['cmd']}")
+
+
+if __name__ == "__main__":
+    import argparse, json
+    from hex_zmq_servers.zmq_base import hex_server_helper
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--cfg", type=str, required=True)
+    args = parser.parse_args()
+    cfg = json.loads(args.cfg)
+
+    hex_server_helper(cfg, HexCamRealsenseServer)