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

hex_zmq_servers/__init__.py

@@ -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__ = [
@@ -76,47 +84,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/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 time
+import threading
+import numpy as np
+
+from ..cam_base import HexCamBase
+from ...zmq_base import (
+    hex_zmq_ts_now,
+    hex_zmq_ts_delta_ms,
+    HexSafeValue,
+)
+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_values: list[HexSafeValue | threading.Event]):
+        rgb_value = hex_values[0]
+        depth_value = hex_values[1]
+        stop_event = hex_values[2]
+
+        frames = self.__pipeline.wait_for_frames()
+        bias_ns = np.int64(time.time_ns()) - 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_value.set((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_value.set(
+                    (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,30 @@
+#!/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)
+
+    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)

hex_zmq_servers/cam/rgb/__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_rgb import HexCamRGB
+from .cam_rgb_cli import HexCamRGBClient
+from .cam_rgb_srv import HexCamRGBServer
+
+__all__ = [
+    "HexCamRGB",
+    "HexCamRGBClient",
+    "HexCamRGBServer",
+]

hex_zmq_servers/cam/rgb/cam_rgb.py

@@ -0,0 +1,107 @@
+#!/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 cv2
+import threading
+import numpy as np
+
+from ..cam_base import HexCamBase
+from ...zmq_base import (
+    hex_zmq_ts_now,
+    HexRate,
+    HexSafeValue,
+)
+from ...hex_launch import hex_log, HEX_LOG_LEVEL
+
+CAMERA_CONFIG = {
+    "cam_path": "/dev/video0",
+    "resolution": [640, 480],
+    "frame_rate": 30,
+    "sens_ts": True,
+}
+
+
+class HexCamRGB(HexCamBase):
+
+    def __init__(
+        self,
+        camera_config: dict = CAMERA_CONFIG,
+    ):
+        HexCamBase.__init__(self)
+
+        try:
+            self.__cam_path = camera_config["cam_path"]
+            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
+        # camera variables
+        self.__cap = cv2.VideoCapture(self.__cam_path)
+        # camera variables
+        self.__intri = np.zeros(4)
+
+        # open device
+        self.__cap.set(cv2.CAP_PROP_FOURCC, cv2.VideoWriter_fourcc(*"MJPG"))
+        self.__cap.set(cv2.CAP_PROP_FRAME_WIDTH, self.__resolution[0])
+        self.__cap.set(cv2.CAP_PROP_FRAME_HEIGHT, self.__resolution[1])
+        self.__cap.set(cv2.CAP_PROP_FPS, self.__frame_rate)
+
+        print("#############################")
+        print(
+            f"# Resolution: ({self.__cap.get(cv2.CAP_PROP_FRAME_WIDTH)}, {self.__cap.get(cv2.CAP_PROP_FRAME_HEIGHT)})"
+        )
+        print(f"# FPS: {self.__cap.get(cv2.CAP_PROP_FPS)}")
+        four_cc_int = int(self.__cap.get(cv2.CAP_PROP_FOURCC))
+        four_cc_str = chr(four_cc_int & 0xff) + chr(
+            (four_cc_int >> 8) & 0xff) + chr((four_cc_int >> 16) & 0xff) + chr(
+                (four_cc_int >> 24) & 0xff)
+        print(f"# FourCC: {four_cc_str}")
+        print("#############################")
+
+        # start work loop
+        self._working.set()
+
+    def get_intri(self) -> np.ndarray:
+        self._wait_for_working()
+        return self.__intri
+
+    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]
+
+        rgb_count = 0
+        depth_value.set((hex_zmq_ts_now(), 0,
+                         np.zeros((self.__resolution[1], self.__resolution[0]),
+                                  dtype=np.uint16)))
+        rate = HexRate(self.__frame_rate * 5)
+        while self._working.is_set() and not stop_event.is_set():
+            # read frame
+            ret, frame = self.__cap.read()
+
+            # collect rgb frame
+            if ret:
+                rgb_value.set((hex_zmq_ts_now(), rgb_count, frame))
+                rgb_count = (rgb_count + 1) % self._max_seq_num
+
+            rate.sleep()
+
+        # close
+        self.close()
+
+    def close(self):
+        if not self._working.is_set():
+            return
+        self._working.clear()
+        self.__cap.release()
+        hex_log(HEX_LOG_LEVEL["info"], "HexCamRGB closed")

hex_zmq_servers/cam/rgb/cam_rgb_cli.py

@@ -0,0 +1,30 @@
+#!/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 HexCamRGBClient(HexCamClientBase):
+
+    def __init__(
+        self,
+        net_config: dict = NET_CONFIG,
+    ):
+        HexCamClientBase.__init__(self, net_config)
+
+    def get_intri(self):
+        intri_hdr, intri = self.request({"cmd": "get_intri"})
+        return intri_hdr, intri

hex_zmq_servers/cam/rgb/cam_rgb_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_rgb import HexCamRGB
+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.rgb.cam_rgb import HexCamRGB
+
+NET_CONFIG = {
+    "ip": "127.0.0.1",
+    "port": 12345,
+    "client_timeout_ms": 200,
+    "server_timeout_ms": 1_000,
+    "server_num_workers": 4,
+}
+
+CAMERA_CONFIG = {
+    "cam_path": "/dev/video0",
+    "resolution": [640, 480],
+    "frame_rate": 30,
+    "sens_ts": True,
+}
+
+
+class HexCamRGBServer(HexCamServerBase):
+
+    def __init__(
+        self,
+        net_config: dict = NET_CONFIG,
+        params_config: dict = CAMERA_CONFIG,
+    ):
+        HexCamServerBase.__init__(self, net_config)
+
+        # camera
+        self._device = HexCamRGB(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, HexCamRGBServer)

hex_zmq_servers/config/cam_realsense.json

@@ -0,0 +1,15 @@
+{
+    "net": {
+        "ip": "127.0.0.1",
+        "port": 12345,
+        "client_timeout_ms": 200,
+        "server_timeout_ms": 1000,
+        "server_num_workers": 4
+    },
+    "params": {
+        "serial_number": "243422073194",
+        "resolution": [640, 480],
+        "frame_rate": 30,
+        "sens_ts": true
+    }
+}