hex-zmq-servers 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

hex_zmq_servers/cam/berxel/cam_berxel.py

@@ -30,8 +30,9 @@ class HexCamBerxel(HexCamBase):
     def __init__(
         self,
         camera_config: dict = CAMERA_CONFIG,
+        realtime_mode: bool = False,
     ):
-        HexCamBase.__init__(self)
+        HexCamBase.__init__(self, realtime_mode)
 
         try:
             self.__serial_number = camera_config["serial_number"]

hex_zmq_servers/cam/berxel/cam_berxel_cli.py

@@ -11,6 +11,8 @@ from ..cam_base import HexCamClientBase
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,

hex_zmq_servers/cam/berxel/cam_berxel_srv.py

@@ -24,6 +24,8 @@ except (ImportError, ValueError):
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,
@@ -48,7 +50,8 @@ class HexCamBerxelServer(HexCamServerBase):
         HexCamServerBase.__init__(self, net_config)
 
         # camera
-        self._device = HexCamBerxel(params_config)
+        self._device = HexCamBerxel(params_config,
+                                    net_config.get("realtime_mode", False))
 
     def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
         if recv_hdr["cmd"] == "is_working":

hex_zmq_servers/cam/cam_base.py

@@ -17,6 +17,8 @@ from ..zmq_base import HexZMQClientBase, HexZMQServerBase, HexRate
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,
@@ -25,8 +27,8 @@ NET_CONFIG = {
 
 class HexCamBase(HexDeviceBase):
 
-    def __init__(self):
-        HexDeviceBase.__init__(self)
+    def __init__(self, realtime_mode: bool = False):
+        HexDeviceBase.__init__(self, realtime_mode)
 
     def __del__(self):
         HexDeviceBase.__del__(self)
@@ -47,24 +49,40 @@ class HexCamClientBase(HexZMQClientBase):
     def __init__(self, net_config: dict = NET_CONFIG):
         HexZMQClientBase.__init__(self, net_config)
         self._rgb_seq = 0
+        self._used_rgb_seq = 0
         self._depth_seq = 0
-        self._rgb_queue = deque(maxlen=10)
-        self._depth_queue = deque(maxlen=10)
+        self._used_depth_seq = 0
+        self._rgb_queue = deque(maxlen=self._deque_maxlen)
+        self._depth_queue = deque(maxlen=self._deque_maxlen)
 
     def __del__(self):
         HexZMQClientBase.__del__(self)
 
     def get_rgb(self, newest: bool = False):
         try:
-            return self._rgb_queue.popleft(
-            ) if not newest else self._rgb_queue[-1]
+            if self._realtime_mode or newest:
+                hdr, img = self._rgb_queue[-1]
+                if self._used_rgb_seq != hdr["args"]:
+                    self._used_rgb_seq = hdr["args"]
+                    return hdr, img
+                else:
+                    return None, None
+            else:
+                return self._rgb_queue.popleft()
         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]
+            if self._realtime_mode or newest:
+                hdr, img = self._depth_queue[-1]
+                if self._used_depth_seq != hdr["args"]:
+                    self._used_depth_seq = hdr["args"]
+                    return hdr, img
+                else:
+                    return None, None
+            else:
+                return self._depth_queue.popleft()
         except IndexError:
             return None, None
 
@@ -117,8 +135,8 @@ class HexCamServerBase(HexZMQServerBase):
     def __init__(self, net_config: dict = NET_CONFIG):
         HexZMQServerBase.__init__(self, net_config)
         self._device: HexDeviceBase = None
-        self._rgb_queue = deque(maxlen=10)
-        self._depth_queue = deque(maxlen=10)
+        self._rgb_queue = deque(maxlen=self._deque_maxlen)
+        self._depth_queue = deque(maxlen=self._deque_maxlen)
 
     def __del__(self):
         HexZMQServerBase.__del__(self)
@@ -143,9 +161,12 @@ class HexCamServerBase(HexZMQServerBase):
 
         try:
             if depth_flag:
-                ts, count, img = self._depth_queue.popleft()
+                ts, count, img = self._depth_queue[
+                    -1] if self._realtime_mode else self._depth_queue.popleft(
+                    )
             else:
-                ts, count, img = self._rgb_queue.popleft()
+                ts, count, img = self._rgb_queue[
+                    -1] if self._realtime_mode else self._rgb_queue.popleft()
         except IndexError:
             return {"cmd": f"{recv_hdr['cmd']}_failed"}, None
         except Exception as e:

hex_zmq_servers/cam/dummy/cam_dummy.py

@@ -20,8 +20,8 @@ from ...hex_launch import hex_log, HEX_LOG_LEVEL
 
 class HexCamDummy(HexCamBase):
 
-    def __init__(self, params_config: dict = {}):
-        HexCamBase.__init__(self)
+    def __init__(self, params_config: dict = {}, realtime_mode: bool = False):
+        HexCamBase.__init__(self, realtime_mode)
         self._working.set()
 
     def __del__(self):

hex_zmq_servers/cam/dummy/cam_dummy_cli.py

@@ -11,6 +11,8 @@ from ..cam_base import HexCamClientBase
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,

hex_zmq_servers/cam/dummy/cam_dummy_srv.py

@@ -24,6 +24,8 @@ except (ImportError, ValueError):
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,
@@ -40,7 +42,8 @@ class HexCamDummyServer(HexCamServerBase):
         HexCamServerBase.__init__(self, net_config)
 
         # camera
-        self._device = HexCamDummy(params_config)
+        self._device = HexCamDummy(params_config,
+                                   net_config.get("realtime_mode", False))
 
     def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
         if recv_hdr["cmd"] == "is_working":

hex_zmq_servers/cam/realsense/cam_realsense.py

@@ -32,8 +32,9 @@ class HexCamRealsense(HexCamBase):
     def __init__(
         self,
         camera_config: dict = CAMERA_CONFIG,
+        realtime_mode: bool = False,
     ):
-        HexCamBase.__init__(self)
+        HexCamBase.__init__(self, realtime_mode)
 
         try:
             self.__serial_number = camera_config["serial_number"]
@@ -134,8 +135,9 @@ class HexCamRealsense(HexCamBase):
             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_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

hex_zmq_servers/cam/realsense/cam_realsense_cli.py

@@ -11,6 +11,8 @@ from ..cam_base import HexCamClientBase
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,

hex_zmq_servers/cam/realsense/cam_realsense_srv.py

@@ -24,6 +24,8 @@ except (ImportError, ValueError):
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,
@@ -47,7 +49,8 @@ class HexCamRealsenseServer(HexCamServerBase):
         HexCamServerBase.__init__(self, net_config)
 
         # camera
-        self._device = HexCamRealsense(params_config)
+        self._device = HexCamRealsense(params_config,
+                                       net_config.get("realtime_mode", False))
 
     def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
         if recv_hdr["cmd"] == "is_working":

hex_zmq_servers/cam/rgb/cam_rgb.py

@@ -35,8 +35,9 @@ class HexCamRGB(HexCamBase):
     def __init__(
         self,
         camera_config: dict = CAMERA_CONFIG,
+        realtime_mode: bool = False,
     ):
-        HexCamBase.__init__(self)
+        HexCamBase.__init__(self, realtime_mode)
 
         try:
             self.__cam_path = camera_config["cam_path"]
@@ -106,8 +107,9 @@ class HexCamRGB(HexCamBase):
 
         rgb_count = 0
         depth_queue.append((hex_zmq_ts_now(), 0,
-                         np.zeros((self.__resolution[1], self.__resolution[0]),
-                                  dtype=np.uint16)))
+                            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

hex_zmq_servers/cam/rgb/cam_rgb_cli.py

@@ -12,6 +12,8 @@ from ...zmq_base import HexRate
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,

hex_zmq_servers/cam/rgb/cam_rgb_srv.py

@@ -24,6 +24,8 @@ except (ImportError, ValueError):
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,
@@ -47,7 +49,8 @@ class HexCamRGBServer(HexCamServerBase):
         HexCamServerBase.__init__(self, net_config)
 
         # camera
-        self._device = HexCamRGB(params_config)
+        self._device = HexCamRGB(params_config,
+                                 net_config.get("realtime_mode", False))
 
     def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
         if recv_hdr["cmd"] == "is_working":

hex_zmq_servers/config/cam_berxel.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/cam_dummy.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/cam_realsense.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/cam_rgb.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/mujoco_archer_y6.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/mujoco_e3_desktop.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/robot_dummy.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/robot_gello.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/robot_hexarm.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/config/zmq_dummy.json

@@ -2,6 +2,8 @@
     "net": {
         "ip": "127.0.0.1",
         "port": 12345,
+        "realtime_mode": false,
+        "deque_maxlen": 10,
         "client_timeout_ms": 200,
         "server_timeout_ms": 1000,
         "server_num_workers": 4

hex_zmq_servers/device_base.py

@@ -15,9 +15,10 @@ from .zmq_base import MAX_SEQ_NUM
 
 class HexDeviceBase(ABC):
 
-    def __init__(self):
+    def __init__(self, realtime_mode: bool = False):
         # variables
         self._max_seq_num = MAX_SEQ_NUM
+        self._realtime_mode = realtime_mode
         # thread
         self._working = threading.Event()
 

hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6.py

@@ -49,8 +49,9 @@ class HexMujocoArcherY6(HexMujocoBase):
     def __init__(
         self,
         mujoco_config: dict = MUJOCO_CONFIG,
+        realtime_mode: bool = False,
     ):
-        HexMujocoBase.__init__(self)
+        HexMujocoBase.__init__(self, realtime_mode)
 
         try:
             states_rate = mujoco_config["states_rate"]
@@ -163,11 +164,11 @@ class HexMujocoArcherY6(HexMujocoBase):
         self.__bias_ns = hex_ns_now() - self.__data.time * 1_000_000_000
         init_ts = self.__mujoco_ts() if self.__sens_ts else hex_zmq_ts_now()
         rgb_queue.append((init_ts, 0,
-                       np.zeros((self.__height, self.__width, 3),
-                                dtype=np.uint8)))
+                          np.zeros((self.__height, self.__width, 3),
+                                   dtype=np.uint8)))
         depth_queue.append((init_ts, 0,
-                         np.zeros((self.__height, self.__width),
-                                  dtype=np.uint16)))
+                            np.zeros((self.__height, self.__width),
+                                     dtype=np.uint16)))
         while self._working.is_set() and not stop_event.is_set():
             states_trig_count += 1
             if states_trig_count >= self.__states_trig_thresh:
@@ -194,7 +195,9 @@ class HexMujocoArcherY6(HexMujocoBase):
                 # cmds
                 cmds_robot_pack = None
                 try:
-                    cmds_robot_pack = cmds_robot_queue.popleft()
+                    cmds_robot_pack = cmds_robot_queue[
+                        -1] if self._realtime_mode else cmds_robot_queue.popleft(
+                        )
                 except IndexError:
                     pass
                 if cmds_robot_pack is not None:

hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6_cli.py

@@ -12,6 +12,8 @@ from ...zmq_base import HexRate
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,
@@ -60,7 +62,7 @@ class HexMujocoArcherY6Client(HexMujocoClientBase):
                         self._depth_queue.append((hdr, img))
 
             try:
-                cmds = self._cmds_queue.popleft()
+                cmds = self._cmds_queue[-1]
                 _ = self._set_cmds_inner(cmds)
             except IndexError:
                 pass

hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6_srv.py

@@ -25,6 +25,8 @@ except (ImportError, ValueError):
 NET_CONFIG = {
     "ip": "127.0.0.1",
     "port": 12345,
+    "realtime_mode": False,
+    "deque_maxlen": 10,
     "client_timeout_ms": 200,
     "server_timeout_ms": 1_000,
     "server_num_workers": 4,
@@ -48,13 +50,14 @@ class HexMujocoArcherY6Server(HexMujocoServerBase):
         HexMujocoServerBase.__init__(self, net_config)
 
         # mujoco
-        self._device = HexMujocoArcherY6(params_config)
+        self._device = HexMujocoArcherY6(
+            params_config, net_config.get("realtime_mode", False))
 
         # values
-        self._states_robot_queue = deque(maxlen=10)
-        self._states_obj_queue = deque(maxlen=10)
-        self._rgb_queue = deque(maxlen=10)
-        self._depth_queue = deque(maxlen=10)
+        self._states_robot_queue = deque(maxlen=self._deque_maxlen)
+        self._states_obj_queue = deque(maxlen=self._deque_maxlen)
+        self._rgb_queue = deque(maxlen=self._deque_maxlen)
+        self._depth_queue = deque(maxlen=self._deque_maxlen)
 
     def work_loop(self):
         try:
@@ -87,7 +90,8 @@ class HexMujocoArcherY6Server(HexMujocoServerBase):
                 f"unknown robot name: {robot_name} in {recv_hdr['cmd']}")
 
         try:
-            ts, count, states = queue.popleft()
+            ts, count, states = queue[
+                -1] if self._realtime_mode else queue.popleft()
         except IndexError:
             return {"cmd": f"{recv_hdr['cmd']}_failed"}, None
         except Exception as e:

hex_zmq_servers/mujoco/e3_desktop/mujoco_e3_desktop.py

@@ -50,8 +50,9 @@ class HexMujocoE3Desktop(HexMujocoBase):
     def __init__(
         self,
         mujoco_config: dict = MUJOCO_CONFIG,
+        realtime_mode: bool = False,
     ):
-        HexMujocoBase.__init__(self)
+        HexMujocoBase.__init__(self, realtime_mode)
 
         try:
             states_rate = mujoco_config["states_rate"]
@@ -198,23 +199,23 @@ class HexMujocoE3Desktop(HexMujocoBase):
         self.__bias_ns = hex_ns_now() - self.__data.time * 1_000_000_000
         init_ts = self.__mujoco_ts() if self.__sens_ts else hex_zmq_ts_now()
         head_rgb_queue.append((init_ts, 0,
-                            np.zeros((self.__height, self.__width, 3),
-                                     dtype=np.uint8)))
+                               np.zeros((self.__height, self.__width, 3),
+                                        dtype=np.uint8)))
         head_depth_queue.append((init_ts, 0,
-                              np.zeros((self.__height, self.__width),
-                                       dtype=np.uint16)))
+                                 np.zeros((self.__height, self.__width),
+                                          dtype=np.uint16)))
         left_rgb_queue.append((init_ts, 0,
-                            np.zeros((self.__height, self.__width, 3),
-                                     dtype=np.uint8)))
+                               np.zeros((self.__height, self.__width, 3),
+                                        dtype=np.uint8)))
         left_depth_queue.append((init_ts, 0,
-                              np.zeros((self.__height, self.__width),
-                                       dtype=np.uint16)))
+                                 np.zeros((self.__height, self.__width),
+                                          dtype=np.uint16)))
         right_rgb_queue.append((init_ts, 0,
-                             np.zeros((self.__height, self.__width, 3),
-                                      dtype=np.uint8)))
+                                np.zeros((self.__height, self.__width, 3),
+                                         dtype=np.uint8)))
         right_depth_queue.append((init_ts, 0,
-                               np.zeros((self.__height, self.__width),
-                                        dtype=np.uint16)))
+                                  np.zeros((self.__height, self.__width),
+                                           dtype=np.uint16)))
         while self._working.is_set() and not stop_event.is_set():
             states_trig_count += 1
             if states_trig_count >= self.__states_trig_thresh:
@@ -244,7 +245,9 @@ class HexMujocoE3Desktop(HexMujocoBase):
                 # cmds
                 cmds_left_pack = None
                 try:
-                    cmds_left_pack = cmds_left_queue.popleft()
+                    cmds_left_pack = cmds_left_queue[
+                        -1] if self._realtime_mode else cmds_left_queue.popleft(
+                        )
                 except IndexError:
                     pass
                 if cmds_left_pack is not None:
@@ -258,7 +261,9 @@ class HexMujocoE3Desktop(HexMujocoBase):
 
                 cmds_right_pack = None
                 try:
-                    cmds_right_pack = cmds_right_queue.popleft()
+                    cmds_right_pack = cmds_right_queue[
+                        -1] if self._realtime_mode else cmds_right_queue.popleft(
+                        )
                 except IndexError:
                     pass
                 if cmds_right_pack is not None:
@@ -286,7 +291,8 @@ class HexMujocoE3Desktop(HexMujocoBase):
                 if self.__head_depth:
                     ts, depth_img = self.__get_depth("head_camera")
                     if depth_img is not None:
-                        head_depth_queue.append((ts, head_depth_count, depth_img))
+                        head_depth_queue.append(
+                            (ts, head_depth_count, depth_img))
                         head_depth_count = (head_depth_count +
                                             1) % self._max_seq_num
 
@@ -302,7 +308,8 @@ class HexMujocoE3Desktop(HexMujocoBase):
                 if self.__left_depth:
                     ts, depth_img = self.__get_depth("left_camera")
                     if depth_img is not None:
-                        left_depth_queue.append((ts, left_depth_count, depth_img))
+                        left_depth_queue.append(
+                            (ts, left_depth_count, depth_img))
                         left_depth_count = (left_depth_count +
                                             1) % self._max_seq_num