hex-zmq-servers 0.3.16__py3-none-any.whl → 1.0.0__py3-none-any.whl

hex_zmq_servers/__init__.py

@@ -15,7 +15,6 @@ from .zmq_base import HexZMQDummyClient, HexZMQDummyServer
 
 from .robot import HexRobotBase, HexRobotClientBase, HexRobotServerBase
 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
@@ -28,7 +27,6 @@ file_dir = os.path.dirname(os.path.abspath(__file__))
 HEX_ZMQ_SERVERS_PATH_DICT = {
     "zmq_dummy": f"{file_dir}/zmq_base.py",
     "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",
@@ -36,7 +34,6 @@ HEX_ZMQ_SERVERS_PATH_DICT = {
 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",
@@ -80,9 +77,6 @@ __all__ = [
     "HexRobotDummy",
     "HexRobotDummyClient",
     "HexRobotDummyServer",
-    "HexRobotGello",
-    "HexRobotGelloClient",
-    "HexRobotGelloServer",
     "HexRobotHexarm",
     "HexRobotHexarmClient",
     "HexRobotHexarmServer",
@@ -104,6 +98,7 @@ from importlib.util import find_spec
 
 _HAS_BERXEL = find_spec("berxel_py_wrapper") is not None
 _HAS_REALSENSE = find_spec("pyrealsense2") is not None
+_HAS_DYNAMIXEL = find_spec("dynamixel-sdk") is not None
 _HAS_MUJOCO = find_spec("mujoco") is not None
 
 # Optional: berxel
@@ -140,6 +135,23 @@ if _HAS_REALSENSE:
         "HexCamRealsenseServer",
     ])
 
+# Optional: dynamixel
+if _HAS_DYNAMIXEL:
+    from .robot import HexRobotGello, HexRobotGelloClient, HexRobotGelloServer
+    HEX_ZMQ_SERVERS_PATH_DICT.update({
+        "robot_gello":
+        f"{file_dir}/robot/gello/robot_gello_srv.py",
+    })
+    HEX_ZMQ_CONFIGS_PATH_DICT.update({
+        "robot_gello":
+        f"{file_dir}/config/robot_gello.json",
+    })
+    __all__.extend([
+        "HexRobotGello",
+        "HexRobotGelloClient",
+        "HexRobotGelloServer",
+    ])
+
 # Optional: mujoco
 if _HAS_MUJOCO:
     from .mujoco import HexMujocoBase, HexMujocoClientBase, HexMujocoServerBase

hex_zmq_servers/cam/berxel/cam_berxel.py

@@ -47,8 +47,8 @@ class HexCamBerxel(HexCamBase):
 
         # variables
         # berxel variables
-        self.__context = None
-        self.__device = None
+        self.__context: BerxelHawkContext | None = None
+        self.__device: BerxelHawkDevice | None = None
         # camera variables
         self.__intri = np.zeros(4)
 
@@ -214,7 +214,15 @@ class HexCamBerxel(HexCamBase):
         return True
 
     def __start_stream(self):
-        self.__device.setColorExposureGain(self.__exposure, self.__gain)
+        if self.__serial_number.startswith('P008'):
+            self.__device.setSonixAEStatus(False)
+            self.__device.setSonixExposureTime(int(self.__exposure // 100))
+        else:
+            self.__device.setColorExposureGain(self.__exposure, self.__gain)
+        self.__device.setDepthElectricCurrent(700)
+        self.__device.setDepthAE(False)
+        self.__device.setDepthExposure(43)
+        self.__device.setDepthGain(1)
         self.__device.setRegistrationEnable(True)
         self.__device.setFrameSync(True)
         while self.__device.setSystemClock() != 0:

hex_zmq_servers/config/robot_hexarm.json

@@ -13,7 +13,6 @@
         "device_port": 8439,
         "control_hz": 1000,
         "arm_type": "archer_l6y",
-        "use_gripper": true,
         "mit_kp": [
             200.0,
             200.0,
@@ -21,7 +20,13 @@
             75.0,
             15.0,
             15.0,
-            20.0
+            20.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0
         ],
         "mit_kd": [
             12.5,
@@ -30,7 +35,13 @@
             6.0,
             0.31,
             0.31,
-            1.0
+            1.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+            0.0
         ],
         "sens_ts": true
     }

hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6.py

@@ -76,21 +76,36 @@ class HexMujocoArcherY6(HexMujocoBase):
         mujoco.mj_resetData(self.__model, self.__data)
 
         # state init
-        self.__state_robot_idx = [0, 1, 2, 3, 4, 5, 6]
-        self.__state_obj_idx = [12, 13, 14, 15, 16, 17, 18]
-        self.__ctrl_robot_idx = [0, 1, 2, 3, 4, 5, 6]
-        self.__ctrl_obj_idx = [0, 1, 2, 3, 4, 5, 6]
-        self._limits = np.stack(
-            [self.__model.jnt_range[self.__state_robot_idx, :]],
-            axis=0,
-        )
+        self.__state_idx = {
+            "robot_arm": ([0, 1, 2, 3, 4, 5]),
+            "robot_gripper": [6],
+            "obj": [12, 13, 14, 15, 16, 17, 18],
+        }
+        self.__ctrl_idx = {
+            "robot_arm": [0, 1, 2, 3, 4, 5],
+            "robot_gripper": [6],
+        }
+        self.__limit_idx = {
+            "robot_arm":
+            np.arange(len(self.__state_idx["robot_arm"])).tolist(),
+            "robot_gripper":
+            (np.arange(len(self.__state_idx["robot_gripper"])) +
+             len(self.__state_idx["robot_arm"])).tolist(),
+        }
+        print(f"self.__limit_idx: {self.__limit_idx}")
+        self._limits = self.__model.jnt_range[np.concatenate(
+            [self.__state_idx["robot_arm"], self.
+             __state_idx["robot_gripper"]]), :].copy().reshape(-1, 1, 2)
         if not self.__tau_ctrl:
             self.__mit_kp = np.ascontiguousarray(np.asarray(self.__mit_kp))
             self.__mit_kd = np.ascontiguousarray(np.asarray(self.__mit_kd))
             self.__mit_ctrl = CtrlUtil()
         self.__gripper_ratio = 1.33 / 1.52
         self._limits[0, -1] *= self.__gripper_ratio
-        self._dofs = np.array([len(self.__state_robot_idx)])
+        self._dofs = np.array([
+            len(self.__state_idx["robot_arm"]),
+            len(self.__state_idx["robot_gripper"])
+        ])
         keyframe_id = mujoco.mj_name2id(
             self.__model,
             mujoco.mjtObj.mjOBJ_KEY,
@@ -242,16 +257,25 @@ class HexMujocoArcherY6(HexMujocoBase):
         pos = copy.deepcopy(self.__data.qpos)
         vel = copy.deepcopy(self.__data.qvel)
         eff = copy.deepcopy(self.__data.qfrc_actuator)
-        pos[self.__state_robot_idx[-1]] = pos[
-            self.__state_robot_idx[-1]] * self.__gripper_ratio
+        pos[self.__state_idx["robot_gripper"]] = pos[
+            self.__state_idx["robot_gripper"]] * self.__gripper_ratio
         return self.__mujoco_ts() if self.__sens_ts else hex_zmq_ts_now(
         ), np.array([
-            pos[self.__state_robot_idx],
-            vel[self.__state_robot_idx],
-            eff[self.__state_robot_idx],
-        ]).T, self.__data.qpos[self.__state_obj_idx].copy()
+            pos[self.__state_idx["robot_arm"] +
+                self.__state_idx["robot_gripper"]],
+            vel[self.__state_idx["robot_arm"] +
+                self.__state_idx["robot_gripper"]],
+            eff[self.__state_idx["robot_arm"] +
+                self.__state_idx["robot_gripper"]],
+        ]).T, self.__data.qpos[self.__state_idx["obj"]].copy()
 
     def __set_cmds(self, cmds: np.ndarray):
+        state_idx = self.__state_idx["robot_arm"] + self.__state_idx[
+            "robot_gripper"]
+        ctrl_idx = self.__ctrl_idx["robot_arm"] + self.__ctrl_idx[
+            "robot_gripper"]
+        limit_idx = self.__limit_idx["robot_arm"] + self.__limit_idx[
+            "robot_gripper"]
         tau_cmds = None
         if not self.__tau_ctrl:
             cmd_pos = None
@@ -278,8 +302,8 @@ class HexMujocoArcherY6(HexMujocoBase):
                 raise ValueError(f"The shape of cmds is invalid: {cmds.shape}")
             tar_pos = self._apply_pos_limits(
                 cmd_pos,
-                self._limits[0, :, 0],
-                self._limits[0, :, 1],
+                self._limits[limit_idx, 0, 0],
+                self._limits[limit_idx, 0, 1],
             )
             tar_pos[-1] /= self.__gripper_ratio
             tau_cmds = self.__mit_ctrl(
@@ -287,13 +311,13 @@ class HexMujocoArcherY6(HexMujocoBase):
                 cmd_kd,
                 tar_pos,
                 tar_vel,
-                self.__data.qpos[self.__state_robot_idx],
-                self.__data.qvel[self.__state_robot_idx],
+                self.__data.qpos[state_idx],
+                self.__data.qvel[state_idx],
                 cmd_tor,
             )
         else:
             tau_cmds = cmds.copy()
-        self.__data.ctrl[self.__ctrl_robot_idx] = tau_cmds
+        self.__data.ctrl[ctrl_idx] = tau_cmds
 
     def __get_rgb(self):
         self.__rgb_cam.update_scene(self.__data, "end_camera")

hex_zmq_servers/mujoco/e3_desktop/mujoco_e3_desktop.py

@@ -77,18 +77,37 @@ class HexMujocoE3Desktop(HexMujocoBase):
         mujoco.mj_resetData(self.__model, self.__data)
 
         # state init
-        self.__state_left_idx = [0, 1, 2, 3, 4, 5, 6]
-        self.__state_right_idx = [12, 13, 14, 15, 16, 17, 18]
-        self.__obj_pose_idx = [24, 25, 26, 27, 28, 29, 30]
-        self.__ctrl_left_idx = [0, 1, 2, 3, 4, 5, 6]
-        self.__ctrl_right_idx = [7, 8, 9, 10, 11, 12, 13]
-        self._limits = np.stack(
-            [
-                self.__model.jnt_range[self.__state_left_idx, :],
-                self.__model.jnt_range[self.__state_right_idx, :]
-            ],
-            axis=0,
-        )
+        self.__state_idx = {
+            "left_arm": [0, 1, 2, 3, 4, 5],
+            "left_gripper": [6],
+            "right_arm": [12, 13, 14, 15, 16, 17],
+            "right_gripper": [18],
+            "obj": [24, 25, 26, 27, 28, 29, 30],
+        }
+        self.__ctrl_idx = {
+            "left_arm": [0, 1, 2, 3, 4, 5],
+            "left_gripper": [6],
+            "right_arm": [7, 8, 9, 10, 11, 12],
+            "right_gripper": [13],
+        }
+        self.__limit_idx = {
+            "left_arm":
+            np.arange(len(self.__state_idx["left_arm"])).tolist(),
+            "left_gripper": (np.arange(len(self.__state_idx["left_gripper"])) +
+                             len(self.__state_idx["left_arm"])).tolist(),
+            "right_arm": (np.arange(len(self.__state_idx["right_arm"])) +
+                          len(self.__state_idx["left_arm"]) +
+                          len(self.__state_idx["left_gripper"])).tolist(),
+            "right_gripper":
+            (np.arange(len(self.__state_idx["right_gripper"])) +
+             len(self.__state_idx["left_arm"]) +
+             len(self.__state_idx["left_gripper"]) +
+             len(self.__state_idx["right_arm"])).tolist(),
+        }
+        self._limits = self.__model.jnt_range[np.concatenate([
+            self.__state_idx["left_arm"], self.__state_idx["left_gripper"],
+            self.__state_idx["right_arm"], self.__state_idx["right_gripper"]
+        ]), :].copy().reshape(-1, 1, 2)
         if not self.__tau_ctrl:
             self.__mit_kp = np.ascontiguousarray(np.asarray(self.__mit_kp))
             self.__mit_kd = np.ascontiguousarray(np.asarray(self.__mit_kd))
@@ -97,8 +116,10 @@ class HexMujocoE3Desktop(HexMujocoBase):
         self._limits[0, -1] *= self.__gripper_ratio
         self._limits[1, -1] *= self.__gripper_ratio
         self._dofs = np.array([
-            len(self.__state_left_idx),
-            len(self.__state_right_idx),
+            len(self.__state_idx["left_arm"]),
+            len(self.__state_idx["left_gripper"]),
+            len(self.__state_idx["right_arm"]),
+            len(self.__state_idx["right_gripper"]),
         ])
         keyframe_id = mujoco.mj_name2id(
             self.__model,
@@ -347,35 +368,47 @@ class HexMujocoE3Desktop(HexMujocoBase):
         pos = copy.deepcopy(self.__data.qpos)
         vel = copy.deepcopy(self.__data.qvel)
         eff = copy.deepcopy(self.__data.qfrc_actuator)
-        pos[self.__state_left_idx[-1]] = pos[
-            self.__state_left_idx[-1]] * self.__gripper_ratio
-        pos[self.__state_right_idx[-1]] = pos[
-            self.__state_right_idx[-1]] * self.__gripper_ratio
+        pos[self.__state_idx["left_gripper"]] = pos[
+            self.__state_idx["left_gripper"]] * self.__gripper_ratio
+        pos[self.__state_idx["right_gripper"]] = pos[
+            self.__state_idx["right_gripper"]] * self.__gripper_ratio
         return self.__mujoco_ts() if self.__sens_ts else hex_zmq_ts_now(
         ), np.array([
-            pos[self.__state_left_idx],
-            vel[self.__state_left_idx],
-            eff[self.__state_left_idx],
+            pos[self.__state_idx["left_arm"] +
+                self.__state_idx["left_gripper"]],
+            vel[self.__state_idx["left_arm"] +
+                self.__state_idx["left_gripper"]],
+            eff[self.__state_idx["left_arm"] +
+                self.__state_idx["left_gripper"]],
         ]).T, np.array([
-            pos[self.__state_right_idx],
-            vel[self.__state_right_idx],
-            eff[self.__state_right_idx],
-        ]).T, self.__data.qpos[self.__obj_pose_idx].copy()
+            pos[self.__state_idx["right_arm"] +
+                self.__state_idx["right_gripper"]],
+            vel[self.__state_idx["right_arm"] +
+                self.__state_idx["right_gripper"]],
+            eff[self.__state_idx["right_arm"] +
+                self.__state_idx["right_gripper"]],
+        ]).T, self.__data.qpos[self.__state_idx["obj"]].copy()
 
     def __set_cmds(self, cmds: np.ndarray, robot_name: str):
-        ctrl_idx = []
-        state_idx = []
+        state_idx = None
+        ctrl_idx = None
         limit_idx = None
         if robot_name == "left":
-            ctrl_idx = self.__ctrl_left_idx
+            ctrl_idx = self.__ctrl_idx["left_arm"] + self.__ctrl_idx[
+                "left_gripper"]
             if not self.__tau_ctrl:
-                state_idx = self.__state_left_idx
-                limit_idx = 0
+                state_idx = self.__state_idx["left_arm"] + self.__state_idx[
+                    "left_gripper"]
+                limit_idx = self.__limit_idx["left_arm"] + self.__limit_idx[
+                    "left_gripper"]
         elif robot_name == "right":
-            ctrl_idx = self.__ctrl_right_idx
+            ctrl_idx = self.__ctrl_idx["right_arm"] + self.__ctrl_idx[
+                "right_gripper"]
             if not self.__tau_ctrl:
-                state_idx = self.__state_right_idx
-                limit_idx = 1
+                state_idx = self.__state_idx["right_arm"] + self.__state_idx[
+                    "right_gripper"]
+                limit_idx = self.__limit_idx["right_arm"] + self.__limit_idx[
+                    "right_gripper"]
         else:
             raise ValueError(f"unknown robot name: {robot_name}")
         tau_cmds = None
@@ -404,8 +437,8 @@ class HexMujocoE3Desktop(HexMujocoBase):
                 raise ValueError(f"The shape of cmds is invalid: {cmds.shape}")
             tar_pos = self._apply_pos_limits(
                 cmd_pos,
-                self._limits[limit_idx, :, 0],
-                self._limits[limit_idx, :, 1],
+                self._limits[limit_idx, 0, 0],
+                self._limits[limit_idx, 0, 1],
             )
             tar_pos[-1] /= self.__gripper_ratio
             tau_cmds = self.__mit_ctrl(

hex_zmq_servers/robot/__init__.py

@@ -8,7 +8,6 @@
 
 from .robot_base import HexRobotBase, HexRobotClientBase, HexRobotServerBase
 from .dummy import HexRobotDummy, HexRobotDummyClient, HexRobotDummyServer
-from .gello import HexRobotGello, HexRobotGelloClient, HexRobotGelloServer
 from .hexarm import HexRobotHexarm, HexRobotHexarmClient, HexRobotHexarmServer, HEXARM_URDF_PATH_DICT
 
 __all__ = [
@@ -25,13 +24,22 @@ __all__ = [
     "HexRobotDummyClient",
     "HexRobotDummyServer",
 
-    # gello
-    "HexRobotGello",
-    "HexRobotGelloClient",
-    "HexRobotGelloServer",
-
     # hexarm
     "HexRobotHexarm",
     "HexRobotHexarmClient",
     "HexRobotHexarmServer",
 ]
+
+# Check optional dependencies availability
+from importlib.util import find_spec
+
+_HAS_DYNAMIXEL = find_spec("dynamixel-sdk") is not None
+
+# Optional: dynamixel
+if _HAS_DYNAMIXEL:
+    from .gello import HexRobotGello, HexRobotGelloClient, HexRobotGelloServer
+    __all__.extend([
+        "HexRobotGello",
+        "HexRobotGelloClient",
+        "HexRobotGelloServer",
+    ])

hex_zmq_servers/robot/hexarm/robot_hexarm.py

@@ -18,7 +18,7 @@ from ...zmq_base import (
     HexRate,
 )
 from ...hex_launch import hex_log, HEX_LOG_LEVEL
-from hex_device import HexDeviceApi, MotorBase
+from hex_device import HexDeviceApi, Arm, Hands
 from hex_device.motor_base import CommandType
 
 ROBOT_CONFIG = {
@@ -26,7 +26,6 @@ ROBOT_CONFIG = {
     "device_port": 8439,
     "control_hz": 250,
     "arm_type": "archer_y6",
-    "use_gripper": True,
     "mit_kp": [200.0, 200.0, 200.0, 75.0, 15.0, 15.0, 20.0],
     "mit_kd": [12.5, 12.5, 12.5, 6.0, 0.31, 0.31, 1.0],
     "sens_ts": True,
@@ -37,6 +36,7 @@ HEX_DEVICE_TYPE_DICT = {
     "archer_d6y": 16,
     "archer_l6y": 17,
     "firefly_y6": 27,
+    "hello": 26,
 }
 
 
@@ -54,7 +54,6 @@ class HexRobotHexarm(HexRobotBase):
             device_port = robot_config["device_port"]
             control_hz = robot_config["control_hz"]
             arm_type = HEX_DEVICE_TYPE_DICT[robot_config["arm_type"]]
-            use_gripper = robot_config["use_gripper"]
             self.__sens_ts = robot_config["sens_ts"]
         except KeyError as ke:
             missing_key = ke.args[0]
@@ -73,8 +72,8 @@ class HexRobotHexarm(HexRobotBase):
         # variables
         # hex_arm variables
         self.__hex_api: HexDeviceApi | None = None
-        self.__arm_archer: MotorBase | None = None
-        self.__gripper: MotorBase | None = None
+        self.__arm: Arm | None = None
+        self.__gripper: Hands | None = None
 
         # buffer
         self.__arm_state_buffer: dict | None = None
@@ -90,40 +89,46 @@ class HexRobotHexarm(HexRobotBase):
         while self.__hex_api.find_device_by_robot_type(arm_type) is None:
             print("\033[33mArm not found\033[0m")
             time.sleep(1)
-        self.__arm_archer = self.__hex_api.find_device_by_robot_type(arm_type)
-        self.__arm_archer.start()
-        self.__arm_dofs = len(self.__arm_archer)
-        self._limits = self.__arm_archer.get_joint_limits()
+        self.__arm = self.__hex_api.find_device_by_robot_type(arm_type)
+        self.__arm.start()
 
         # try to open gripper
-        self.__gripper_dofs = 0
-        self.__gripper = None
-        if use_gripper:
-            self.__gripper = self.__hex_api.find_optional_device_by_id(1)
-            if self.__gripper is not None:
-                self.__gripper_dofs = len(self.__gripper)
-                self._limits += [self.__gripper.get_joint_limits()]
-            else:
-                print("\033[33mGripper not found\033[0m")
+        self.__gripper = self.__hex_api.find_optional_device_by_id(1)
+        if self.__gripper is None:
+            print("\033[33mGripper not found\033[0m")
+
+        # variables init
+        arm_dofs = len(self.__arm)
+        self._dofs = [arm_dofs]
+        self._limits = np.array(self.__arm.get_joint_limits()).reshape(-1, 3, 2)
+        self.__motor_idx = {"robot_arm": np.arange(arm_dofs).tolist()}
+        if self.__gripper is not None:
+            gripper_dofs = len(self.__gripper)
+            self._dofs.append(gripper_dofs)
+            gripper_limits = np.array(self.__gripper.get_joint_limits()).reshape(-1, 3, 2)
+            self._limits = np.concatenate([self._limits, gripper_limits], axis=0)
+            self.__motor_idx["robot_gripper"] = (np.arange(gripper_dofs) +
+                                                 arm_dofs).tolist()
 
         # modify variables
-        self._dofs = [self.__arm_dofs + self.__gripper_dofs]
+        self._dofs = np.array(self._dofs)
+        self._dofs_sum = self._dofs.sum()
         self._limits = np.ascontiguousarray(np.asarray(self._limits)).reshape(
-            self._dofs[0], 3, 2)
+            self._dofs_sum, 3, 2)
         self.__mit_kp = np.ascontiguousarray(np.asarray(self.__mit_kp))
         self.__mit_kd = np.ascontiguousarray(np.asarray(self.__mit_kd))
-        if self.__mit_kp.shape[0] < self._dofs[0] or self.__mit_kd.shape[
-                0] < self._dofs[0]:
+        if self.__mit_kp.shape[0] < self._dofs_sum or self.__mit_kd.shape[
+                0] < self._dofs_sum:
             raise ValueError(
                 "The length of mit_kp and mit_kd must be greater than or equal to the number of motors"
             )
-        elif self.__mit_kp.shape[0] > self._dofs[0] or self.__mit_kd.shape[
-                0] > self._dofs[0]:
+        elif self.__mit_kp.shape[0] > self._dofs_sum or self.__mit_kd.shape[
+                0] > self._dofs_sum:
             print(
                 f"\033[33mThe length of mit_kp and mit_kd is greater than the number of motors\033[0m"
             )
-            self.__mit_kp = self.__mit_kp[:self._dofs[0]]
-            self.__mit_kd = self.__mit_kd[:self._dofs[0]]
+            self.__mit_kp = self.__mit_kp[:self._dofs_sum]
+            self.__mit_kd = self.__mit_kd[:self._dofs_sum]
 
         # start work loop
         self._working.set()
@@ -167,13 +172,12 @@ class HexRobotHexarm(HexRobotBase):
         self.close()
 
     def __get_states(self) -> tuple[np.ndarray | None, dict | None]:
-        if self.__arm_archer is None:
+        if self.__arm is None:
             return None, None
 
         # (arm_dofs, 3) # pos vel eff
         if self.__arm_state_buffer is None:
-            self.__arm_state_buffer = self.__arm_archer.get_simple_motor_status(
-            )
+            self.__arm_state_buffer = self.__arm.get_simple_motor_status()
 
         # (gripper_dofs, 3) # pos vel eff
         if self.__gripper is not None and self.__gripper_state_buffer is None:
@@ -220,24 +224,24 @@ class HexRobotHexarm(HexRobotBase):
         # [[pos_0, tor_0], ..., [pos_n, tor_n]]
         # cmds: (n, 5)
         # [[pos_0, vel_0, tor_0, kp_0, kd_0], ..., [pos_n, vel_n, tor_n, kp_n, kd_n]]
-        if self.__arm_archer is None:
+        if self.__arm is None:
             print("\033[91mArm not found\033[0m")
             return False
 
-        if cmds.shape[0] < self._dofs[0]:
+        if cmds.shape[0] < self._dofs_sum:
             print(
                 "\033[91mThe length of joint_angles must be greater than or equal to the number of motors\033[0m"
             )
             return False
-        elif cmds.shape[0] > self._dofs[0]:
+        elif cmds.shape[0] > self._dofs_sum:
             print(
                 f"\033[33mThe length of joint_angles is greater than the number of motors\033[0m"
             )
-            cmds = cmds[:self._dofs[0]]
+            cmds = cmds[:self._dofs_sum]
 
         cmd_pos = None
-        tar_vel = np.zeros(self._dofs[0])
-        cmd_tor = np.zeros(self._dofs[0])
+        tar_vel = np.zeros(self._dofs_sum)
+        cmd_tor = np.zeros(self._dofs_sum)
         cmd_kp = self.__mit_kp.copy()
         cmd_kd = self.__mit_kd.copy()
         if len(cmds.shape) == 1:
@@ -263,25 +267,25 @@ class HexRobotHexarm(HexRobotBase):
         )
 
         # arm
-        mit_cmd = self.__arm_archer.construct_mit_command(
-            tar_pos[:self.__arm_dofs],
-            tar_vel[:self.__arm_dofs],
-            cmd_tor[:self.__arm_dofs],
-            cmd_kp[:self.__arm_dofs],
-            cmd_kd[:self.__arm_dofs],
+        arm_cmd = self.__arm.construct_mit_command(
+            tar_pos[self.__motor_idx["robot_arm"]],
+            tar_vel[self.__motor_idx["robot_arm"]],
+            cmd_tor[self.__motor_idx["robot_arm"]],
+            cmd_kp[self.__motor_idx["robot_arm"]],
+            cmd_kd[self.__motor_idx["robot_arm"]],
         )
-        self.__arm_archer.motor_command(CommandType.MIT, mit_cmd)
+        self.__arm.motor_command(CommandType.MIT, arm_cmd)
 
         # gripper
         if self.__gripper is not None:
-            mit_cmd = self.__gripper.construct_mit_command(
-                tar_pos[self.__arm_dofs:],
-                tar_vel[self.__arm_dofs:],
-                cmd_tor[self.__arm_dofs:],
-                cmd_kp[self.__arm_dofs:],
-                cmd_kd[self.__arm_dofs:],
+            gripper_cmd = self.__gripper.construct_mit_command(
+                tar_pos[self.__motor_idx["robot_gripper"]],
+                tar_vel[self.__motor_idx["robot_gripper"]],
+                cmd_tor[self.__motor_idx["robot_gripper"]],
+                cmd_kp[self.__motor_idx["robot_gripper"]],
+                cmd_kd[self.__motor_idx["robot_gripper"]],
             )
-            self.__gripper.motor_command(CommandType.MIT, mit_cmd)
+            self.__gripper.motor_command(CommandType.MIT, gripper_cmd)
 
         return True
 
@@ -289,6 +293,6 @@ class HexRobotHexarm(HexRobotBase):
         if not self._working.is_set():
             return
         self._working.clear()
-        self.__arm_archer.stop()
+        self.__arm.stop()
         self.__hex_api.close()
         hex_log(HEX_LOG_LEVEL["info"], "HexRobotHexarm closed")

hex_zmq_servers/robot/hexarm/robot_hexarm_srv.py

@@ -36,9 +36,8 @@ ROBOT_CONFIG = {
     "device_port": 8439,
     "control_hz": 250,
     "arm_type": "archer_l6y",
-    "use_gripper": True,
-    "mit_kp": [200.0, 200.0, 200.0, 75.0, 15.0, 15.0, 0.0],
-    "mit_kd": [12.5, 12.5, 12.5, 6.0, 0.31, 0.31, 0.0],
+    "mit_kp": [200.0, 200.0, 200.0, 75.0, 15.0, 15.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+    "mit_kd": [12.5, 12.5, 12.5, 6.0, 0.31, 0.31, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
     "sens_ts": True,
 }
 

hex_zmq_servers/zmq_base.py

@@ -500,11 +500,16 @@ class HexZMQDummyClient(HexZMQClientBase):
         net_config: dict = NET_CONFIG,
     ):
         HexZMQClientBase.__init__(self, net_config)
-
+        self._wait_for_working()
+        
     def single_test(self):
         resp_hdr, resp_buf = self.request({"cmd": "test"})
-        print(f"resp_hdr: {resp_hdr}")
-        print(f"resp_buf: {resp_buf}")
+        return resp_hdr, resp_buf
+
+    def _recv_loop(self):
+        rate = HexRate(500)
+        while self._recv_flag:
+            rate.sleep()
 
 
 class HexZMQDummyServer(HexZMQServerBase):
@@ -524,6 +529,8 @@ class HexZMQDummyServer(HexZMQServerBase):
             self.close()
 
     def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
+        if recv_hdr["cmd"] == "is_working":
+            return self.no_ts_hdr(recv_hdr, True), None
         if recv_hdr["cmd"] == "test":
             print("test received")
             print(f"recv_hdr: {recv_hdr}")

hex_zmq_servers-1.0.0.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.4
+Name: hex_zmq_servers
+Version: 1.0.0
+Summary: HEXFELLOW ZMQ Servers
+Author-email: Dong Zhaorui <joray.dong@hexfellow.com>
+Maintainer-email: jecjune <zejun.chen@hexfellow.com>, Dong Zhaorui <joray.dong@hexfellow.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/hexfellow/hex_zmq_servers
+Project-URL: Repository, https://github.com/hexfellow/hex_zmq_servers.git
+Project-URL: Bug Tracker, https://github.com/hexfellow/hex_zmq_servers/issues
+Project-URL: Documentation, https://github.com/hexfellow/hex_zmq_servers/wiki
+Keywords: hex_zmq_servers
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyzmq>=27.0.1
+Requires-Dist: hex_device<1.4.0,>=1.3.14
+Requires-Dist: hex_robo_utils<0.3.0,>=0.2.0
+Requires-Dist: opencv-python>=4.2
+Provides-Extra: berxel
+Requires-Dist: berxel_py_wrapper>=2.0.182; extra == "berxel"
+Provides-Extra: realsense
+Requires-Dist: pyrealsense2>=2.56.5.9235; extra == "realsense"
+Provides-Extra: dynamixel
+Requires-Dist: dynamixel-sdk==3.8.4; extra == "dynamixel"
+Provides-Extra: mujoco
+Requires-Dist: mujoco>=3.3.3; extra == "mujoco"
+Provides-Extra: all
+Requires-Dist: berxel_py_wrapper>=2.0.182; extra == "all"
+Requires-Dist: pyrealsense2>=2.56.5.9235; extra == "all"
+Requires-Dist: dynamixel-sdk==3.8.4; extra == "all"
+Requires-Dist: mujoco>=3.3.3; extra == "all"
+Dynamic: license-file
+
+<h1 align="center">HEXFELLOW ZMQ SERVERS</h1>
+
+<p align="center">
+    <a href="https://github.com/hexfellow/hex_zmq_servers/stargazers">
+        <img src="https://img.shields.io/github/stars/hexfellow/hex_zmq_servers?style=flat-square&logo=github" />
+    </a>
+    <a href="https://github.com/hexfellow/hex_zmq_servers/forks">
+        <img src="https://img.shields.io/github/forks/hexfellow/hex_zmq_servers?style=flat-square&logo=github" />
+    </a>
+    <a href="https://doi.org/10.5281/zenodo.18309954">
+        <img src="https://zenodo.org/badge/1088506315.svg" alt="DOI">
+    </a>
+    &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+    <a href="https://github.com/hexfellow/hex_zmq_servers/issues">
+        <img src="https://img.shields.io/github/issues/hexfellow/hex_zmq_servers?style=flat-square&logo=github" />
+    </a>
+</p>
+
+---
+
+# 📖 Overview
+
+## What is `hex_zmq_servers`
+
+`hex_zmq_servers` provides a client–server layer on top of ZeroMQ to control and stream data from HEXFELLOW hardware (robots, RGB/RGB-D cameras) and MuJoCo-based simulators. Servers run device logic and command loops; clients send requests (e.g. `get_rgb`, `get_state`, `set_target`) and receive headers plus optional binary buffers (e.g. images, joint state).
+
+## What problem it solves
+
+- **Decoupled control**: Run device drivers and control loops in separate processes; clients connect over TCP.
+- **Unified transport**: All devices use the same ZMQ request/response pattern (JSON header + NumPy buffer).
+- **Multi-node management**: `HexLaunch` and `HexNodeConfig` start and monitor multiple server/client nodes from one process.
+
+## Target users
+
+- Engineers integrating HEXFELLOW robots into their systems.
+- Researchers running experiments with HEXFELLOW robots.
+
+---
+
+# 📦 Installation
+
+## Requirements
+
+- **Python**
+- **OS**: `Linux` / `macOS`
+- **Core dependencies**:
+  - `pyzmq`
+  - `hex_device`
+  - `hex_robo_utils`
+  - `opencv-python`
+
+Optional device support (install via extras):
+
+| Extra       | Purpose                                         |
+| ----------- | ----------------------------------------------- |
+| `berxel`    | Berxel RGB-D: `berxel_py_wrapper`               |
+| `realsense` | RealSense RGB-D: `pyrealsense2`                 |
+| `dynamixel` | Dynamixel: `dynamixel-sdk`                      |
+| `mujoco`    | MuJoCo sims: `mujoco`                           |
+| `all`       | `berxel` + `dynamixel` + `realsense` + `mujoco` |
+
+## Install from PyPI
+
+For those who don't need examples, you can install the package from PyPI.
+
+- **Full install**: includes all optional devices (Berxel, RealSense, Dynamixel, MuJoCo)
+
+    ```bash
+    pip install hex_zmq_servers[all]
+    ```
+
+- **Core install**: only the core package (no optional devices)
+
+    ```bash
+    pip install hex_zmq_servers
+    ```
+
+## Install from Source
+
+For those who need examples, you can install the package from source code with examples.
+
+**Noet**: We use [**uv**](https://github.com/astral-sh/uv) to manage the Python environment. Please install it first.
+
+1. Clone and install in editable mode. The `venv.sh` script expects [uv](https://github.com/astral-sh/uv).
+
+    ```bash
+    git clone https://github.com/hexfellow/hex_zmq_servers.git
+    cd hex_zmq_servers
+    ./venv.sh
+    ```
+
+   - `./venv.sh` — creates `.venv`, installs `hex_zmq_servers` with `[all]` and `examples/adv/requirements.txt` (e.g. `pygame` for some examples).
+   - `./venv.sh --min` — installs the core package only (no optional device extras). Some examples will not run.
+   - `./venv.sh --pkg-only` — installs the package only, skips example-related dependencies.
+
+2. Activate before running examples:
+
+    ```bash
+    source .venv/bin/activate
+    ```
+
+---
+
+# 📚 Tutorial
+
+See [**Tutorial**](docs/tutorial.md) for details of all tutorials.
+
+# 📑 API
+
+See [**API**](docs/api.md) for details of all APIs.
+
+# 💡 Example
+
+See [**Example**](docs/example.md) for details of all examples.
+
+---
+
+# 🏷️ Citation
+
+If you want to cite this project in your work, you can use the following BibTeX entry:
+
+```bibtex
+@software{hex_zmq_servers,
+  author    = {Dong, Zhaorui},
+  title     = {Hex ZMQ Servers: A ZeroMQ-Based Embodied AI Communication Framework},
+  year      = {2025},
+  publisher = {Zenodo},
+  version   = {v1.0.0},
+  doi       = {10.5281/zenodo.18309960},
+  url       = {https://doi.org/10.5281/zenodo.18309960}
+}
+```
+
+---
+
+# 📄 License
+
+Apache License 2.0. See [LICENSE](LICENSE).
+
+---
+
+# 🌟 Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=hexfellow/hex_zmq_servers&type=Date)](https://star-history.com/#hexfellow/hex_zmq_servers&Date)
+

{hex_zmq_servers-0.3.16.dist-info → hex_zmq_servers-1.0.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
-hex_zmq_servers/__init__.py,sha256=1dnB9YTRq5uAFHo_3dMp1t1UxS4ZrcuZ_7CzBwqAfEM,5426
+hex_zmq_servers/__init__.py,sha256=YZzC3MnGlyafcB6CShZRG-Jai86rMJ4buZKQ7k6Ap6k,5684
 hex_zmq_servers/device_base.py,sha256=SdRfM4VdJQ_gK-SKjt6ut4fWOR9eYpzmTQb6N6Lx7UI,1264
 hex_zmq_servers/hex_launch.py,sha256=x-xCBhpjgK6yWHGk5o5kYsb5ef2GsdeLr8rX59EJR-0,17700
-hex_zmq_servers/zmq_base.py,sha256=1sJTxzQionZE1aJXPVAPf--PtILivD4S3x8AZ8xx17M,16822
+hex_zmq_servers/zmq_base.py,sha256=DXLBSCT2VJQG8Y4aXCZEuKrawupOx3sk7H4crz9uXtc,17030
 hex_zmq_servers/cam/__init__.py,sha256=hZ4NTEaO9uxcBua-nyJTpXxmk_GiIAcK2uWz3QQbwvE,1408
 hex_zmq_servers/cam/cam_base.py,sha256=YQ_uwH-ej7qGRr5RqQBDnaS7jCWV66lxAAkWD5c0gLc,6055
 hex_zmq_servers/cam/berxel/__init__.py,sha256=3fK06RWAS_q8a_3z-RxFTv32e99og-4dMZTxH08TOcY,508
-hex_zmq_servers/cam/berxel/cam_berxel.py,sha256=rAkqZz8a48d_aUFwVP8B2NeH8Zzl7dHqpOaDRxfleVQ,9872
+hex_zmq_servers/cam/berxel/cam_berxel.py,sha256=TXbG2k3ZrpeuBLk1oqBxihn1FNHegUEuchQ_yIMuSm4,10291
 hex_zmq_servers/cam/berxel/cam_berxel_cli.py,sha256=eoeMWoDZziX3V23v2G76KWhfXSf2jpj4DH2Yo74HvuQ,863
 hex_zmq_servers/cam/berxel/cam_berxel_srv.py,sha256=-Ut2GzAH0-5hFQDDIRcGzYz5On7YiXZ9KfOZrK2w53o,2439
 hex_zmq_servers/cam/dummy/__init__.py,sha256=EziQ8H8d9Vm1AYw4YryIumTXpx-lwEnlfzTl7VAnKHM,499
@@ -28,12 +28,12 @@ hex_zmq_servers/config/mujoco_archer_y6.json,sha256=cZFUjppqfqxWYrJPYcxqRk7i6DZD
 hex_zmq_servers/config/mujoco_e3_desktop.json,sha256=pSh-X4tMPrw5iNk39D9PC5l8xjCs5IB2AvRgOZszDQE,823
 hex_zmq_servers/config/robot_dummy.json,sha256=8dQPI2A0NjC1d6oj_TMoHduoyhynA-cwZ_-7J-QWz-g,3023
 hex_zmq_servers/config/robot_gello.json,sha256=DDICCpSvjUR1yqQFQEmFZ9mrmPt05Zre6Gu28ZMyu5Y,1217
-hex_zmq_servers/config/robot_hexarm.json,sha256=0YD1Vgsc3C6EfYCSopAFmef2rSAwG9I196eWTOrTGxk,750
+hex_zmq_servers/config/robot_hexarm.json,sha256=01QovR0ibsDypVUKL4h_6EVeHG3I8QqfCc-jztH7Mm4,925
 hex_zmq_servers/config/zmq_dummy.json,sha256=yuWindzdHoXv2-nlMEXY1e7W-_vWLYKwe-w8m7eBxWQ,251
 hex_zmq_servers/mujoco/__init__.py,sha256=OKG7aJ2BACpob_DuAvikLiRo4M_3DO9Ffapwen87k_0,870
 hex_zmq_servers/mujoco/mujoco_base.py,sha256=1NXyUn3gBfkww9CKEuvVuzXXJQ-dpYoN_04r4bzZHoU,13632
 hex_zmq_servers/mujoco/archer_y6/__init__.py,sha256=v1vApZ-qBLEcqFjDN0eff5kvkzO3s8QHBO4AitBODfc,559
-hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6.py,sha256=DDw7hI7unCr7aMb6QOXz4Wdep8L3Ui_7e20iSUsAZMg,12328
+hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6.py,sha256=9lqQuV8Q43iMlPq1-bKlFaExz77WlTDCiKumyClvKLA,13336
 hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6_cli.py,sha256=O2BfGf80G-K0CWxjsLrzA_HxqFbe9ED8USjG6OqNNII,2140
 hex_zmq_servers/mujoco/archer_y6/mujoco_archer_y6_srv.py,sha256=nHMaHuauakfaNBy-Y7mYmjYtpWOFCEe8LE93smMhuqk,5211
 hex_zmq_servers/mujoco/archer_y6/model/joint_class.xml,sha256=2VPHALLFrf2PLAiF6KLohigtx8sa757RmYHLgJ-QYFc,995
@@ -57,7 +57,7 @@ hex_zmq_servers/mujoco/archer_y6/model/assets/gripper_right_link_1.STL,sha256=fj
 hex_zmq_servers/mujoco/archer_y6/model/assets/gripper_right_link_2.STL,sha256=ucyn656VxBpRx3sshxLxMPJIUZfNfEQ90P-9b8sR0xg,80284
 hex_zmq_servers/mujoco/archer_y6/model/assets/table_link.STL,sha256=dqFXHRqjZSDyvYHCaJkbmYFsKngZRk1xjg_Zl2_jDc4,684
 hex_zmq_servers/mujoco/e3_desktop/__init__.py,sha256=pMLKpJGBHgc9IU142NcM7ubwdXq9E422k6Giui1A8i4,565
-hex_zmq_servers/mujoco/e3_desktop/mujoco_e3_desktop.py,sha256=8Og4sHDh1q3s-bLLfNW-Mqsxc_0zXhYrMZrmiE9PoaY,18353
+hex_zmq_servers/mujoco/e3_desktop/mujoco_e3_desktop.py,sha256=uZT5qSzrHO_g5WzhKhAt1t7yLCKGxzDmD5AixTNSyNc,20214
 hex_zmq_servers/mujoco/e3_desktop/mujoco_e3_desktop_cli.py,sha256=_TJAtGNc7Ka6Sm3xiIJeqJ9fiHRecNpwjCxTNzRPbBI,9414
 hex_zmq_servers/mujoco/e3_desktop/mujoco_e3_desktop_srv.py,sha256=uHd0nE8igamBZHC9ouLKKSrg4NWusvk8dQ0HkTpe_OQ,9344
 hex_zmq_servers/mujoco/e3_desktop/model/joint_class.xml,sha256=2VPHALLFrf2PLAiF6KLohigtx8sa757RmYHLgJ-QYFc,995
@@ -81,7 +81,7 @@ hex_zmq_servers/mujoco/e3_desktop/model/assets/gripper_right_helper_link.STL,sha
 hex_zmq_servers/mujoco/e3_desktop/model/assets/gripper_right_link_1.STL,sha256=fjz04vqaBZGOb9GL6N4CVdIR1kOWrsdwh-jo7CRp9pg,28384
 hex_zmq_servers/mujoco/e3_desktop/model/assets/gripper_right_link_2.STL,sha256=ucyn656VxBpRx3sshxLxMPJIUZfNfEQ90P-9b8sR0xg,80284
 hex_zmq_servers/mujoco/e3_desktop/model/assets/table_link.STL,sha256=dqFXHRqjZSDyvYHCaJkbmYFsKngZRk1xjg_Zl2_jDc4,684
-hex_zmq_servers/robot/__init__.py,sha256=PqzGhsdbaeyYa7EZpAYMvT9myYhCO3OTbSPXVp1uiUM,1026
+hex_zmq_servers/robot/__init__.py,sha256=rgAiVl_aSMarD-lqgLznG1bBQvo8xSPjXev1tk3mKsg,1237
 hex_zmq_servers/robot/robot_base.py,sha256=iau5aCLBKuPkRT3E1PTUfHxM2ji41pohVjO1T4Sdd8k,8564
 hex_zmq_servers/robot/dummy/__init__.py,sha256=_lDtPH-JQ1ltPB8JzD7wLu77iwNOgEZ3fJkz8MNKXrw,517
 hex_zmq_servers/robot/dummy/robot_dummy.py,sha256=_dTLajZCO5gjyw0KWedr8VsOTrtSkikcrJ8L2YpEwwQ,2781
@@ -92,9 +92,9 @@ hex_zmq_servers/robot/gello/robot_gello.py,sha256=AwgMZcADtJR0NPjEYV4_p6v70RCFCw
 hex_zmq_servers/robot/gello/robot_gello_cli.py,sha256=1Ik9sDT8Xh2sXtqR46wbJCt7QhnhTKzJeCEzUiiFLtA,751
 hex_zmq_servers/robot/gello/robot_gello_srv.py,sha256=5w95Rgt0p0vxaH2olX40V3h0CwVH8eEtx2U0iTO8cxM,2970
 hex_zmq_servers/robot/hexarm/__init__.py,sha256=-smiJ_bEpmR6kH7GfqDXQzcmaGCpgyuskdl9Hm_trlI,1852
-hex_zmq_servers/robot/hexarm/robot_hexarm.py,sha256=2mMBXWzMUHrUOqq2iYGbs5xszFx5uNuHkvLAspZ5Ues,10445
+hex_zmq_servers/robot/hexarm/robot_hexarm.py,sha256=ciCD2x2_uREJwBavXLe1r_9JOXYd3VzdB4KPb9TI8os,10827
 hex_zmq_servers/robot/hexarm/robot_hexarm_cli.py,sha256=QbFiZFHnmyu5Wfwzj2fMRGqLdXBrS2HcpTGnG-BH_D8,904
-hex_zmq_servers/robot/hexarm/robot_hexarm_srv.py,sha256=nSB-SuVmBT6v24xajtSyQ9APU9-a0HqiYxSLel9KOs0,2889
+hex_zmq_servers/robot/hexarm/robot_hexarm_srv.py,sha256=ANmqwl532d0cV9XCA29_55E-HGwrSmvSzQEDG-r-a2Y,2924
 hex_zmq_servers/robot/hexarm/urdf/archer_d6y/empty.urdf,sha256=3qrJq2dQ77k2iz_N2hZQwudvqPsLR_-JUAeCE3M7twQ,7451
 hex_zmq_servers/robot/hexarm/urdf/archer_d6y/gp100.urdf,sha256=VcZw5HNS4DCcD5mI5VvouS-72qrOr7-yzNmch6H2TRo,7468
 hex_zmq_servers/robot/hexarm/urdf/archer_d6y/gp100_handle.urdf,sha256=_5KBK-vHuPZASAsp9EkAFjcY4wsmTS6AioR5iHISuK4,7473
@@ -111,8 +111,8 @@ hex_zmq_servers/robot/hexarm/urdf/archer_y6/gp100_handle.urdf,sha256=sKZRz97fnz0
 hex_zmq_servers/robot/hexarm/urdf/archer_y6/gp100_p050.urdf,sha256=Ayq0xhf8euYWD83hv-Wa2-D0LyOqFrVj-N6W1X1GEHo,7448
 hex_zmq_servers/robot/hexarm/urdf/archer_y6/gp100_p050_handle.urdf,sha256=UjeDE7bZgUMPGJlHOJMJofcEjQ2BRkShCUomxhKUPk0,7445
 hex_zmq_servers/robot/hexarm/urdf/firefly_y6/empty.urdf,sha256=OWNmNHVNP0PvYY8s3jvrNBFAiMEYs3Zxr9NnV1APd8g,7601
-hex_zmq_servers-0.3.16.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-hex_zmq_servers-0.3.16.dist-info/METADATA,sha256=yDUcFn5IzzUmcoSUR-BHxRrzvQdy6gejXP4r-TacO_s,4751
-hex_zmq_servers-0.3.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hex_zmq_servers-0.3.16.dist-info/top_level.txt,sha256=lPH1DfgMrQOe0Grh8zSZopf6LmnLvb_aStVmZ41PyAg,16
-hex_zmq_servers-0.3.16.dist-info/RECORD,,
+hex_zmq_servers-1.0.0.dist-info/licenses/LICENSE,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+hex_zmq_servers-1.0.0.dist-info/METADATA,sha256=Fun1vJg3YNVw8e30_cH73wk22Slyc7cW_516TTYwyqk,6506
+hex_zmq_servers-1.0.0.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+hex_zmq_servers-1.0.0.dist-info/top_level.txt,sha256=lPH1DfgMrQOe0Grh8zSZopf6LmnLvb_aStVmZ41PyAg,16
+hex_zmq_servers-1.0.0.dist-info/RECORD,,

{hex_zmq_servers-0.3.16.dist-info → hex_zmq_servers-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

hex_zmq_servers-0.3.16.dist-info/METADATA

@@ -1,147 +0,0 @@
-Metadata-Version: 2.4
-Name: hex_zmq_servers
-Version: 0.3.16
-Summary: HEXFELLOW ZMQ Servers
-Author-email: Dong Zhaorui <joray.dong@hexfellow.com>
-Maintainer-email: jecjune <zejun.chen@hexfellow.com>, Dong Zhaorui <joray.dong@hexfellow.com>
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/hexfellow/hex_zmq_servers
-Project-URL: Repository, https://github.com/hexfellow/hex_zmq_servers.git
-Project-URL: Bug Tracker, https://github.com/hexfellow/hex_zmq_servers/issues
-Project-URL: Documentation, https://github.com/hexfellow/hex_zmq_servers/wiki
-Keywords: hex_zmq_servers
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: POSIX :: Linux
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: pyzmq>=27.0.1
-Requires-Dist: hex_device<1.4.0,>=1.3.1
-Requires-Dist: hex_robo_utils<0.3.0,>=0.2.0
-Requires-Dist: dynamixel-sdk==3.8.4
-Requires-Dist: opencv-python>=4.2
-Provides-Extra: berxel
-Requires-Dist: berxel_py_wrapper>=2.0.182; extra == "berxel"
-Provides-Extra: realsense
-Requires-Dist: pyrealsense2>=2.56.5.9235; extra == "realsense"
-Provides-Extra: mujoco
-Requires-Dist: mujoco>=3.3.3; extra == "mujoco"
-Provides-Extra: all
-Requires-Dist: berxel_py_wrapper>=2.0.182; extra == "all"
-Requires-Dist: mujoco>=3.3.3; extra == "all"
-Requires-Dist: pyrealsense2>=2.56.5.9235; extra == "all"
-Dynamic: license-file
-
-# hex_zmq_servers
-
-## Introduction
-
-**`hex_zmq_servers`** is a comprehensive distributed device control framework based on ZeroMQ, providing efficient client-server communication for HEXFELLOW devices.
-
-## Project Structure
-
-```bash
-hex_zmq_servers/
-├── hex_zmq_servers/         # Core library
-│   ├── robot/               # Robot devices
-│   ├── cam/                 # Camera devices
-│   ├── mujoco/              # Mujoco simulation devices
-│   └── config/              # Default configuration files
-├── examples/                # Example code
-│   ├── basic/               # Basic examples (single device)
-│   └── adv/                 # Advanced examples (multi-device coordination)
-└── venv.sh                  # Virtual environment script
-```
-
-## Devices
-
-### Robot
-
-- **dummy**: Dummy robot, for testing and development
-- **gello**: GELLO robot, based on Dynamixel servo
-- **hexarm**: HexArm robot of HEXFELLOW
-
-### Camera
-
-- **dummy**: Dummy camera, for testing and development
-- **berxel**: Berxel depth camera, providing RGB and depth images
-
-### Mujoco
-
-- **archer_y6**: Physical simulation of Archer Y6 robot
-- **e3_desktop**: Physical simulation of E3 Desktop robot
-
-## Installation
-
-### Install from PyPI
-
-1. For those who only want to use the library in their projects, it is recommended to install it from PyPI.
-
-    ```bash
-    pip install hex_zmq_servers[all]
-    ```
-
-2. If you don't want to install the extra dependencies for extra devices, you can run:
-
-    ```bash
-    pip install hex_zmq_servers
-    ```
-
-### Install from Source Code
-
-1. For those who want to test the examples or contribute to the project, you can install it from source code.
-
-    ```bash
-    git clone https://github.com/hexfellow/hex_zmq_servers.git
-    cd hex_zmq_servers
-    ./venv.sh
-    ```
-
-2. If you don't want to install the extra dependencies for extra devices, you can run:
-
-    ```bash
-    git clone https://github.com/hexfellow/hex_zmq_servers.git
-    cd hex_zmq_servers
-    ./venv.sh --min
-    ```
-
-    (**Important**) Some examples would not work without the extra dependencies.
-
-3. If you don't want to install the examples, you can run:
-
-    ```bash
-    git clone https://github.com/hexfellow/hex_zmq_servers.git
-    cd hex_zmq_servers
-    ./venv.sh --pkg-only
-    ```
-
-## Examples
-
-There are two types of examples in the project:
-
-- **basic/**: Basic examples, showing the usage of a single device
-- **adv/**: Advanced examples, showing multi-device coordination
-
-More details please refer to [examples/README.md](examples/README.md)
-
-## Contributions
-
-Welcome to submit issues and pull requests!
-
-## License
-
-Apache License 2.0
-
-## Contact
-
-- Author: [Dong Zhaorui](https://github.com/IBNBlank)
-- Maintainer: [jecjune](https://github.com/Jecjune)
-- GitHub: [hex_zmq_servers](https://github.com/hexfellow/hex_zmq_servers)
-- Issue Tracker: [hex_zmq_servers](https://github.com/hexfellow/hex_zmq_servers/issues)