hex-dora-node-robot 0.0.1a1__tar.gz

hex_dora_node_robot-0.0.1a1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

hex_dora_node_robot-0.0.1a1/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: hex_dora_node_robot
+Version: 0.0.1a1
+Summary: Dora Node for using Hex Robot
+Author-email: Dong Zhaorui <847235539@qq.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dora-rs>=0.3.9
+Requires-Dist: hex-driver-robot<0.1.0,>=0.0.0
+Dynamic: license-file
+
+# hex_dora_node_robot
+
+Dora nodes for controlling HEXFELLOW robot arms. Supports Archer Y6, Firefly Y6, and Hello Y6 robot models with state reading and command sending over the Dora dataflow.
+
+## Nodes
+
+| Node | Description | Inputs | Outputs |
+| --- | --- | --- | --- |
+| `hex-dora-node-archer-y6` | Archer Y6 robot driver (6-DOF arm with optional grip) | `tick`, `arm_mit_cmd`, `arm_mit_comp_cmd`, `arm_pos_cmd`, `arm_pose_cmd`, `grip_mit_cmd`, `grip_mit_comp_cmd`, `grip_pos_cmd` | `arm_motor`, `arm_end`, `grip_motor` |
+| `hex-dora-node-firefly-y6` | Firefly Y6 robot driver (6-DOF arm with optional grip) | `tick`, `arm_mit_cmd`, `arm_mit_comp_cmd`, `arm_pos_cmd`, `arm_pose_cmd`, `grip_mit_cmd`, `grip_mit_comp_cmd`, `grip_pos_cmd` | `arm_motor`, `arm_end`, `grip_motor` |
+| `hex-dora-node-hello-y6` | Hello Y6 robot driver (6-DOF arm with 7-DOF grip and RGB LED) | `tick`, `grip_led_cmd` | `arm_motor`, `grip_motor` |
+
+## Installation
+
+```bash
+pip install hex_dora_node_robot
+```
+
+## YAML Examples
+
+### Archer Y6
+
+```yaml
+nodes:
+  - id: archer_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-archer-y6
+    inputs:
+      tick: dora/timer/millis/2
+      arm_pos_cmd: planner/arm_pos_cmd
+      grip_pos_cmd: planner/grip_pos_cmd
+    outputs:
+      - arm_motor
+      - arm_end
+      - grip_motor
+    env:
+      NODE_NAME: archer_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      GRIP_TYPE: gp80
+      POSE_END_IN_FLANGE: 0.187,0.0,0.0,1.0,0.0,0.0,0.0
+```
+
+### Firefly Y6
+
+```yaml
+nodes:
+  - id: firefly_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-firefly-y6
+    inputs:
+      tick: dora/timer/millis/2
+      arm_pos_cmd: planner/arm_pos_cmd
+      grip_pos_cmd: planner/grip_pos_cmd
+    outputs:
+      - arm_motor
+      - arm_end
+      - grip_motor
+    env:
+      NODE_NAME: firefly_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      GRIP_TYPE: gp80
+      POSE_END_IN_FLANGE: 0.187,0.0,0.0,1.0,0.0,0.0,0.0
+```
+
+### Hello Y6
+
+```yaml
+nodes:
+  - id: hello_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-hello-y6
+    inputs:
+      tick: dora/timer/millis/2
+      grip_led_cmd: planner/grip_led_cmd
+    outputs:
+      - arm_motor
+      - grip_motor
+    env:
+      NODE_NAME: hello_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      LED_BUFFER_SIZE: 10
+```
+
+## Inputs
+
+### Timer
+
+| Input | Type | Description |
+| --- | --- | --- |
+| `tick` | `dora/timer/millis/*` | Timer tick to trigger state reading |
+
+### Arm Commands (Archer Y6 / Firefly Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `arm_mit_cmd` | `q_tar(6)`, `dq_tar(6)`, `tau(6)`, `kp(6)`, `kd(6)` | MIT torque command for arm |
+| `arm_mit_comp_cmd` | `q_tar(6)`, `dq_tar(6)`, `tau(6)`, `kp(6)`, `kd(6)` | MIT command with gravity/friction compensation |
+| `arm_pos_cmd` | `q_tar(6)`, `kp(6)`, `kd(6)`, `err_limit(1)` | Joint position command for arm |
+| `arm_pose_cmd` | `pos(3)`, `quat(4)`, `kp(6)`, `kd(6)`, `err_limit(1)` | Cartesian pose command for arm |
+
+### Grip Commands (Archer Y6 / Firefly Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `grip_mit_cmd` | `q_tar(dof)`, `dq_tar(dof)`, `tau(dof)`, `kp(dof)`, `kd(dof)` | MIT torque command for grip |
+| `grip_mit_comp_cmd` | `q_tar(dof)`, `dq_tar(dof)`, `tau(dof)`, `kp(dof)`, `kd(dof)` | MIT command with friction compensation |
+| `grip_pos_cmd` | `q_tar(dof)`, `kp(dof)`, `kd(dof)`, `err_limit(1)` | Joint position command for grip |
+
+### Grip LED Command (Hello Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `grip_led_cmd` | `r(6)`, `g(6)`, `b(6)` | RGB LED strip command (0-255 per channel) |
+
+## Outputs
+
+### `arm_motor`
+
+Archer Y6 / Firefly Y6: `{"pos": float64[6], "vel": float64[6], "eff": float64[6]}`
+
+Hello Y6: `{"pos": float64[6], "vel": float64[6]}`
+
+### `arm_end`
+
+Archer Y6 / Firefly Y6 only: `{"pos": float64[3], "quat": float64[4]}`
+
+### `grip_motor`
+
+Archer Y6 / Firefly Y6: `{"pos": float64[dof], "vel": float64[dof], "eff": float64[dof]}`
+
+Hello Y6: `{"pos": float64[7]}`
+
+## Arrow Dict Encoding
+
+All data is transmitted as `dict[str, arr]` via flat `float64` Arrow arrays. The `metadata` dict describes the layout using field names as keys mapped to their array lengths:
+
+```python
+# Example arm_motor metadata for Archer/Firefly Y6
+metadata = {
+    "fields": "pos,vel,eff",  # field order in the flat array
+    "pos": "6",               # pos occupies 6 elements
+    "vel": "6",
+    "eff": "6",
+}
+```
+
+Use `hex_dora_node_robot.util.dict_decode` to unpack and `dict_encode` to pack:
+
+```python
+from hex_dora_node_robot.util import dict_decode, dict_encode
+
+# Decode state from a robot node
+state = dict_decode(event["value"], event["metadata"])
+print(state["pos"], state["vel"])
+
+# Encode command to send to the robot node
+import numpy as np
+cmd = {
+    "q_tar": np.zeros(6),
+    "kp": np.array([400.0, 400.0, 500.0, 200.0, 100.0, 100.0]),
+    "kd": np.array([5.0, 5.0, 5.0, 5.0, 2.0, 2.0]),
+    "err_limit": np.array([0.03]),
+}
+storage, metadata = dict_encode(cmd, event["metadata"])
+node.send_output("arm_pos_cmd", storage, metadata)
+```
+
+## Environment Variables
+
+### Common (all robot nodes)
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `NODE_NAME` | `str` | `""` | Dora node name |
+| `HOST` | `str` | `192.168.1.100` | Robot controller IP address |
+| `PORT` | `int` | `8439` | WebSocket port |
+| `CTRL_RATE` | `float` | `1000` | Control loop rate (Hz) |
+| `STATE_BUFFER_SIZE` | `int` | `200` | Size of the state ring buffer |
+| `SEN_TS` | `bool` | `True` | Use sensor timestamps |
+
+### Archer Y6 / Firefly Y6
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `GRIP_TYPE` | `str` | `gp80` | Grip model (`gp80` or `empty` for no grip) |
+| `POSE_END_IN_FLANGE` | `str` | `0.187,0.0,0.0,1.0,0.0,0.0,0.0` | End-effector pose in flange frame `[x,y,z,qw,qx,qy,qz]` |
+
+### Hello Y6
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `LED_BUFFER_SIZE` | `int` | `10` | Size of the LED command buffer |
+
+## License
+
+This project is licensed under Apache-2.0.

hex_dora_node_robot-0.0.1a1/README.md

@@ -0,0 +1,208 @@
+# hex_dora_node_robot
+
+Dora nodes for controlling HEXFELLOW robot arms. Supports Archer Y6, Firefly Y6, and Hello Y6 robot models with state reading and command sending over the Dora dataflow.
+
+## Nodes
+
+| Node | Description | Inputs | Outputs |
+| --- | --- | --- | --- |
+| `hex-dora-node-archer-y6` | Archer Y6 robot driver (6-DOF arm with optional grip) | `tick`, `arm_mit_cmd`, `arm_mit_comp_cmd`, `arm_pos_cmd`, `arm_pose_cmd`, `grip_mit_cmd`, `grip_mit_comp_cmd`, `grip_pos_cmd` | `arm_motor`, `arm_end`, `grip_motor` |
+| `hex-dora-node-firefly-y6` | Firefly Y6 robot driver (6-DOF arm with optional grip) | `tick`, `arm_mit_cmd`, `arm_mit_comp_cmd`, `arm_pos_cmd`, `arm_pose_cmd`, `grip_mit_cmd`, `grip_mit_comp_cmd`, `grip_pos_cmd` | `arm_motor`, `arm_end`, `grip_motor` |
+| `hex-dora-node-hello-y6` | Hello Y6 robot driver (6-DOF arm with 7-DOF grip and RGB LED) | `tick`, `grip_led_cmd` | `arm_motor`, `grip_motor` |
+
+## Installation
+
+```bash
+pip install hex_dora_node_robot
+```
+
+## YAML Examples
+
+### Archer Y6
+
+```yaml
+nodes:
+  - id: archer_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-archer-y6
+    inputs:
+      tick: dora/timer/millis/2
+      arm_pos_cmd: planner/arm_pos_cmd
+      grip_pos_cmd: planner/grip_pos_cmd
+    outputs:
+      - arm_motor
+      - arm_end
+      - grip_motor
+    env:
+      NODE_NAME: archer_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      GRIP_TYPE: gp80
+      POSE_END_IN_FLANGE: 0.187,0.0,0.0,1.0,0.0,0.0,0.0
+```
+
+### Firefly Y6
+
+```yaml
+nodes:
+  - id: firefly_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-firefly-y6
+    inputs:
+      tick: dora/timer/millis/2
+      arm_pos_cmd: planner/arm_pos_cmd
+      grip_pos_cmd: planner/grip_pos_cmd
+    outputs:
+      - arm_motor
+      - arm_end
+      - grip_motor
+    env:
+      NODE_NAME: firefly_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      GRIP_TYPE: gp80
+      POSE_END_IN_FLANGE: 0.187,0.0,0.0,1.0,0.0,0.0,0.0
+```
+
+### Hello Y6
+
+```yaml
+nodes:
+  - id: hello_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-hello-y6
+    inputs:
+      tick: dora/timer/millis/2
+      grip_led_cmd: planner/grip_led_cmd
+    outputs:
+      - arm_motor
+      - grip_motor
+    env:
+      NODE_NAME: hello_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      LED_BUFFER_SIZE: 10
+```
+
+## Inputs
+
+### Timer
+
+| Input | Type | Description |
+| --- | --- | --- |
+| `tick` | `dora/timer/millis/*` | Timer tick to trigger state reading |
+
+### Arm Commands (Archer Y6 / Firefly Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `arm_mit_cmd` | `q_tar(6)`, `dq_tar(6)`, `tau(6)`, `kp(6)`, `kd(6)` | MIT torque command for arm |
+| `arm_mit_comp_cmd` | `q_tar(6)`, `dq_tar(6)`, `tau(6)`, `kp(6)`, `kd(6)` | MIT command with gravity/friction compensation |
+| `arm_pos_cmd` | `q_tar(6)`, `kp(6)`, `kd(6)`, `err_limit(1)` | Joint position command for arm |
+| `arm_pose_cmd` | `pos(3)`, `quat(4)`, `kp(6)`, `kd(6)`, `err_limit(1)` | Cartesian pose command for arm |
+
+### Grip Commands (Archer Y6 / Firefly Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `grip_mit_cmd` | `q_tar(dof)`, `dq_tar(dof)`, `tau(dof)`, `kp(dof)`, `kd(dof)` | MIT torque command for grip |
+| `grip_mit_comp_cmd` | `q_tar(dof)`, `dq_tar(dof)`, `tau(dof)`, `kp(dof)`, `kd(dof)` | MIT command with friction compensation |
+| `grip_pos_cmd` | `q_tar(dof)`, `kp(dof)`, `kd(dof)`, `err_limit(1)` | Joint position command for grip |
+
+### Grip LED Command (Hello Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `grip_led_cmd` | `r(6)`, `g(6)`, `b(6)` | RGB LED strip command (0-255 per channel) |
+
+## Outputs
+
+### `arm_motor`
+
+Archer Y6 / Firefly Y6: `{"pos": float64[6], "vel": float64[6], "eff": float64[6]}`
+
+Hello Y6: `{"pos": float64[6], "vel": float64[6]}`
+
+### `arm_end`
+
+Archer Y6 / Firefly Y6 only: `{"pos": float64[3], "quat": float64[4]}`
+
+### `grip_motor`
+
+Archer Y6 / Firefly Y6: `{"pos": float64[dof], "vel": float64[dof], "eff": float64[dof]}`
+
+Hello Y6: `{"pos": float64[7]}`
+
+## Arrow Dict Encoding
+
+All data is transmitted as `dict[str, arr]` via flat `float64` Arrow arrays. The `metadata` dict describes the layout using field names as keys mapped to their array lengths:
+
+```python
+# Example arm_motor metadata for Archer/Firefly Y6
+metadata = {
+    "fields": "pos,vel,eff",  # field order in the flat array
+    "pos": "6",               # pos occupies 6 elements
+    "vel": "6",
+    "eff": "6",
+}
+```
+
+Use `hex_dora_node_robot.util.dict_decode` to unpack and `dict_encode` to pack:
+
+```python
+from hex_dora_node_robot.util import dict_decode, dict_encode
+
+# Decode state from a robot node
+state = dict_decode(event["value"], event["metadata"])
+print(state["pos"], state["vel"])
+
+# Encode command to send to the robot node
+import numpy as np
+cmd = {
+    "q_tar": np.zeros(6),
+    "kp": np.array([400.0, 400.0, 500.0, 200.0, 100.0, 100.0]),
+    "kd": np.array([5.0, 5.0, 5.0, 5.0, 2.0, 2.0]),
+    "err_limit": np.array([0.03]),
+}
+storage, metadata = dict_encode(cmd, event["metadata"])
+node.send_output("arm_pos_cmd", storage, metadata)
+```
+
+## Environment Variables
+
+### Common (all robot nodes)
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `NODE_NAME` | `str` | `""` | Dora node name |
+| `HOST` | `str` | `192.168.1.100` | Robot controller IP address |
+| `PORT` | `int` | `8439` | WebSocket port |
+| `CTRL_RATE` | `float` | `1000` | Control loop rate (Hz) |
+| `STATE_BUFFER_SIZE` | `int` | `200` | Size of the state ring buffer |
+| `SEN_TS` | `bool` | `True` | Use sensor timestamps |
+
+### Archer Y6 / Firefly Y6
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `GRIP_TYPE` | `str` | `gp80` | Grip model (`gp80` or `empty` for no grip) |
+| `POSE_END_IN_FLANGE` | `str` | `0.187,0.0,0.0,1.0,0.0,0.0,0.0` | End-effector pose in flange frame `[x,y,z,qw,qx,qy,qz]` |
+
+### Hello Y6
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `LED_BUFFER_SIZE` | `int` | `10` | Size of the LED command buffer |
+
+## License
+
+This project is licensed under Apache-2.0.

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot/main_archer_y6.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2026 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2026-04-13
+################################################################
+
+import os, traceback
+import numpy as np
+from dora import Node
+from hex_util_runtime import get_dora_node_name, get_dora_bool
+from hex_driver_robot import HexRobotArcherY6, HexRobotArcherY6Params
+
+from .util import dict_encode, dict_decode
+
+
+def main():
+    node_name = get_dora_node_name(os.getenv('NODE_NAME', ""))
+    params = HexRobotArcherY6Params(
+        host=os.getenv('HOST', '192.168.1.100'),
+        port=int(os.getenv('PORT', '8439')),
+        ctrl_rate=float(os.getenv('CTRL_RATE', '1000')),
+        state_buffer_size=int(os.getenv('STATE_BUFFER_SIZE', '200')),
+        sens_ts=get_dora_bool(os.getenv('SEN_TS', 'True')),
+        grip_type=os.getenv('GRIP_TYPE', 'gp80'),
+        pose_end_in_flange=np.fromstring(
+            os.getenv('POSE_END_IN_FLANGE',
+                       '0.187,0.0,0.0,1.0,0.0,0.0,0.0'),
+            sep=',',
+        ),
+    )
+    robot = None
+    try:
+        robot = HexRobotArcherY6(params)
+        robot.start()
+        dofs = robot.get_dofs()
+        grip_dof = dofs["grip"]
+
+        node = Node(node_name)
+        for event in node:
+            if event["type"] == "INPUT":
+                event_id = event["id"]
+
+                if event_id == "tick":
+                    arm_motor = robot.get_arm_motor(latest=True)
+                    if arm_motor is not None:
+                        storage, metadata = dict_encode(
+                            {
+                                "pos": arm_motor["pos"],
+                                "vel": arm_motor["vel"],
+                                "eff": arm_motor["eff"],
+                            },
+                            event["metadata"],
+                        )
+                        node.send_output("arm_motor", storage, metadata)
+
+                    arm_end = robot.get_arm_end(latest=True)
+                    if arm_end is not None:
+                        storage, metadata = dict_encode(
+                            {
+                                "pos": arm_end["pos"],
+                                "quat": arm_end["quat"],
+                            },
+                            event["metadata"],
+                        )
+                        node.send_output("arm_end", storage, metadata)
+
+                    if grip_dof > 0:
+                        grip_motor = robot.get_grip_motor(latest=True)
+                        if grip_motor is not None:
+                            storage, metadata = dict_encode(
+                                {
+                                    "pos": grip_motor["pos"],
+                                    "vel": grip_motor["vel"],
+                                    "eff": grip_motor["eff"],
+                                },
+                                event["metadata"],
+                            )
+                            node.send_output("grip_motor", storage, metadata)
+
+                elif event_id == "arm_mit_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_mit_cmd(cmd)
+
+                elif event_id == "arm_mit_comp_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_mit_comp_cmd(cmd)
+
+                elif event_id == "arm_pos_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_pos_cmd(cmd)
+
+                elif event_id == "arm_pose_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_pose_cmd(cmd)
+
+                elif event_id == "grip_mit_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_grip_mit_cmd(cmd)
+
+                elif event_id == "grip_mit_comp_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_grip_mit_comp_cmd(cmd)
+
+                elif event_id == "grip_pos_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_grip_pos_cmd(cmd)
+
+            elif event["type"] == "ERROR":
+                raise RuntimeError(event["error"])
+
+    except Exception:
+        traceback.print_exc()
+    finally:
+        if robot is not None:
+            robot.stop()
+            robot.deinit_robot()

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot/main_firefly_y6.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2026 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2026-04-13
+################################################################
+
+import os, traceback
+import numpy as np
+from dora import Node
+from hex_util_runtime import get_dora_node_name, get_dora_bool
+from hex_driver_robot import HexRobotFireflyY6, HexRobotFireflyY6Params
+
+from .util import dict_encode, dict_decode
+
+
+def main():
+    node_name = get_dora_node_name(os.getenv('NODE_NAME', ""))
+    params = HexRobotFireflyY6Params(
+        host=os.getenv('HOST', '192.168.1.100'),
+        port=int(os.getenv('PORT', '8439')),
+        ctrl_rate=float(os.getenv('CTRL_RATE', '1000')),
+        state_buffer_size=int(os.getenv('STATE_BUFFER_SIZE', '200')),
+        sens_ts=get_dora_bool(os.getenv('SEN_TS', 'True')),
+        grip_type=os.getenv('GRIP_TYPE', 'gp80'),
+        pose_end_in_flange=np.fromstring(
+            os.getenv('POSE_END_IN_FLANGE',
+                       '0.187,0.0,0.0,1.0,0.0,0.0,0.0'),
+            sep=',',
+        ),
+    )
+    robot = None
+    try:
+        robot = HexRobotFireflyY6(params)
+        robot.start()
+        dofs = robot.get_dofs()
+        grip_dof = dofs["grip"]
+
+        node = Node(node_name)
+        for event in node:
+            if event["type"] == "INPUT":
+                event_id = event["id"]
+
+                if event_id == "tick":
+                    arm_motor = robot.get_arm_motor(latest=True)
+                    if arm_motor is not None:
+                        storage, metadata = dict_encode(
+                            {
+                                "pos": arm_motor["pos"],
+                                "vel": arm_motor["vel"],
+                                "eff": arm_motor["eff"],
+                            },
+                            event["metadata"],
+                        )
+                        node.send_output("arm_motor", storage, metadata)
+
+                    arm_end = robot.get_arm_end(latest=True)
+                    if arm_end is not None:
+                        storage, metadata = dict_encode(
+                            {
+                                "pos": arm_end["pos"],
+                                "quat": arm_end["quat"],
+                            },
+                            event["metadata"],
+                        )
+                        node.send_output("arm_end", storage, metadata)
+
+                    if grip_dof > 0:
+                        grip_motor = robot.get_grip_motor(latest=True)
+                        if grip_motor is not None:
+                            storage, metadata = dict_encode(
+                                {
+                                    "pos": grip_motor["pos"],
+                                    "vel": grip_motor["vel"],
+                                    "eff": grip_motor["eff"],
+                                },
+                                event["metadata"],
+                            )
+                            node.send_output("grip_motor", storage, metadata)
+
+                elif event_id == "arm_mit_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_mit_cmd(cmd)
+
+                elif event_id == "arm_mit_comp_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_mit_comp_cmd(cmd)
+
+                elif event_id == "arm_pos_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_pos_cmd(cmd)
+
+                elif event_id == "arm_pose_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_arm_pose_cmd(cmd)
+
+                elif event_id == "grip_mit_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_grip_mit_cmd(cmd)
+
+                elif event_id == "grip_mit_comp_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_grip_mit_comp_cmd(cmd)
+
+                elif event_id == "grip_pos_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    robot.set_grip_pos_cmd(cmd)
+
+            elif event["type"] == "ERROR":
+                raise RuntimeError(event["error"])
+
+    except Exception:
+        traceback.print_exc()
+    finally:
+        if robot is not None:
+            robot.stop()
+            robot.deinit_robot()

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot/main_hello_y6.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2026 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2026-04-13
+################################################################
+
+import os, traceback
+import numpy as np
+from dora import Node
+from hex_util_runtime import get_dora_node_name, get_dora_bool
+from hex_driver_robot import HexRobotHelloY6, HexRobotHelloY6Params
+
+from .util import dict_encode, dict_decode
+
+
+def main():
+    node_name = get_dora_node_name(os.getenv('NODE_NAME', ""))
+    params = HexRobotHelloY6Params(
+        host=os.getenv('HOST', '192.168.1.100'),
+        port=int(os.getenv('PORT', '8439')),
+        ctrl_rate=float(os.getenv('CTRL_RATE', '1000')),
+        state_buffer_size=int(os.getenv('STATE_BUFFER_SIZE', '200')),
+        sens_ts=get_dora_bool(os.getenv('SEN_TS', 'True')),
+        led_buffer_size=int(os.getenv('LED_BUFFER_SIZE', '10')),
+    )
+    robot = None
+    try:
+        robot = HexRobotHelloY6(params)
+        robot.start()
+
+        node = Node(node_name)
+        for event in node:
+            if event["type"] == "INPUT":
+                event_id = event["id"]
+
+                if event_id == "tick":
+                    arm_motor = robot.get_arm_motor(latest=True)
+                    if arm_motor is not None:
+                        storage, metadata = dict_encode(
+                            ["pos", "vel"],
+                            arm_motor,
+                            event["metadata"],
+                        )
+                        node.send_output("arm_motor", storage, metadata)
+
+                    grip_motor = robot.get_grip_motor(latest=True)
+                    if grip_motor is not None:
+                        storage, metadata = dict_encode(
+                            {
+                                "pos": grip_motor["pos"],
+                            },
+                            event["metadata"],
+                        )
+                        node.send_output("grip_motor", storage, metadata)
+
+                elif event_id == "grip_led_cmd":
+                    cmd = dict_decode(event["value"], event["metadata"])
+                    cmd["r"] = cmd["r"].astype(np.int64)
+                    cmd["g"] = cmd["g"].astype(np.int64)
+                    cmd["b"] = cmd["b"].astype(np.int64)
+                    robot.set_grip_led_cmd(cmd)
+
+            elif event["type"] == "ERROR":
+                raise RuntimeError(event["error"])
+
+    except Exception:
+        traceback.print_exc()
+    finally:
+        if robot is not None:
+            robot.stop()
+            robot.deinit_robot()

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot/util.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding:utf-8 -*-
+################################################################
+# Copyright 2026 Dong Zhaorui. All rights reserved.
+# Author: Dong Zhaorui 847235539@qq.com
+# Date  : 2026-04-13
+################################################################
+
+import numpy as np
+import pyarrow as pa
+
+
+def dict_encode(keys, data_dict, metadata):
+    metadata.pop("timestamp", None)
+    metadata["fields"] = ",".join(keys)
+
+    parts = []
+    for key in keys:
+        val = np.atleast_1d(np.asarray(data_dict[key],
+                                       dtype=np.float64)).ravel()
+        parts.append(val)
+        metadata[key] = str(len(val))
+
+    storage = pa.array(np.concatenate(parts))
+    return storage, metadata
+
+
+def dict_decode(storage, metadata):
+    data = storage.to_numpy().astype(np.float64)
+    fields = metadata["fields"].split(",")
+    result = {}
+    offset = 0
+    for f in fields:
+        size = int(metadata[f])
+        result[f] = data[offset:offset + size] if size > 1 else data[offset]
+        offset += size
+    return result

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot.egg-info/PKG-INFO

@@ -0,0 +1,221 @@
+Metadata-Version: 2.4
+Name: hex_dora_node_robot
+Version: 0.0.1a1
+Summary: Dora Node for using Hex Robot
+Author-email: Dong Zhaorui <847235539@qq.com>
+License-Expression: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dora-rs>=0.3.9
+Requires-Dist: hex-driver-robot<0.1.0,>=0.0.0
+Dynamic: license-file
+
+# hex_dora_node_robot
+
+Dora nodes for controlling HEXFELLOW robot arms. Supports Archer Y6, Firefly Y6, and Hello Y6 robot models with state reading and command sending over the Dora dataflow.
+
+## Nodes
+
+| Node | Description | Inputs | Outputs |
+| --- | --- | --- | --- |
+| `hex-dora-node-archer-y6` | Archer Y6 robot driver (6-DOF arm with optional grip) | `tick`, `arm_mit_cmd`, `arm_mit_comp_cmd`, `arm_pos_cmd`, `arm_pose_cmd`, `grip_mit_cmd`, `grip_mit_comp_cmd`, `grip_pos_cmd` | `arm_motor`, `arm_end`, `grip_motor` |
+| `hex-dora-node-firefly-y6` | Firefly Y6 robot driver (6-DOF arm with optional grip) | `tick`, `arm_mit_cmd`, `arm_mit_comp_cmd`, `arm_pos_cmd`, `arm_pose_cmd`, `grip_mit_cmd`, `grip_mit_comp_cmd`, `grip_pos_cmd` | `arm_motor`, `arm_end`, `grip_motor` |
+| `hex-dora-node-hello-y6` | Hello Y6 robot driver (6-DOF arm with 7-DOF grip and RGB LED) | `tick`, `grip_led_cmd` | `arm_motor`, `grip_motor` |
+
+## Installation
+
+```bash
+pip install hex_dora_node_robot
+```
+
+## YAML Examples
+
+### Archer Y6
+
+```yaml
+nodes:
+  - id: archer_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-archer-y6
+    inputs:
+      tick: dora/timer/millis/2
+      arm_pos_cmd: planner/arm_pos_cmd
+      grip_pos_cmd: planner/grip_pos_cmd
+    outputs:
+      - arm_motor
+      - arm_end
+      - grip_motor
+    env:
+      NODE_NAME: archer_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      GRIP_TYPE: gp80
+      POSE_END_IN_FLANGE: 0.187,0.0,0.0,1.0,0.0,0.0,0.0
+```
+
+### Firefly Y6
+
+```yaml
+nodes:
+  - id: firefly_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-firefly-y6
+    inputs:
+      tick: dora/timer/millis/2
+      arm_pos_cmd: planner/arm_pos_cmd
+      grip_pos_cmd: planner/grip_pos_cmd
+    outputs:
+      - arm_motor
+      - arm_end
+      - grip_motor
+    env:
+      NODE_NAME: firefly_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      GRIP_TYPE: gp80
+      POSE_END_IN_FLANGE: 0.187,0.0,0.0,1.0,0.0,0.0,0.0
+```
+
+### Hello Y6
+
+```yaml
+nodes:
+  - id: hello_y6
+    build: pip install hex_dora_node_robot
+    path: hex-dora-node-hello-y6
+    inputs:
+      tick: dora/timer/millis/2
+      grip_led_cmd: planner/grip_led_cmd
+    outputs:
+      - arm_motor
+      - grip_motor
+    env:
+      NODE_NAME: hello_y6
+      HOST: 192.168.1.100
+      PORT: 8439
+      CTRL_RATE: 1000
+      STATE_BUFFER_SIZE: 200
+      SEN_TS: True
+      LED_BUFFER_SIZE: 10
+```
+
+## Inputs
+
+### Timer
+
+| Input | Type | Description |
+| --- | --- | --- |
+| `tick` | `dora/timer/millis/*` | Timer tick to trigger state reading |
+
+### Arm Commands (Archer Y6 / Firefly Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `arm_mit_cmd` | `q_tar(6)`, `dq_tar(6)`, `tau(6)`, `kp(6)`, `kd(6)` | MIT torque command for arm |
+| `arm_mit_comp_cmd` | `q_tar(6)`, `dq_tar(6)`, `tau(6)`, `kp(6)`, `kd(6)` | MIT command with gravity/friction compensation |
+| `arm_pos_cmd` | `q_tar(6)`, `kp(6)`, `kd(6)`, `err_limit(1)` | Joint position command for arm |
+| `arm_pose_cmd` | `pos(3)`, `quat(4)`, `kp(6)`, `kd(6)`, `err_limit(1)` | Cartesian pose command for arm |
+
+### Grip Commands (Archer Y6 / Firefly Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `grip_mit_cmd` | `q_tar(dof)`, `dq_tar(dof)`, `tau(dof)`, `kp(dof)`, `kd(dof)` | MIT torque command for grip |
+| `grip_mit_comp_cmd` | `q_tar(dof)`, `dq_tar(dof)`, `tau(dof)`, `kp(dof)`, `kd(dof)` | MIT command with friction compensation |
+| `grip_pos_cmd` | `q_tar(dof)`, `kp(dof)`, `kd(dof)`, `err_limit(1)` | Joint position command for grip |
+
+### Grip LED Command (Hello Y6 only)
+
+| Input | Fields | Description |
+| --- | --- | --- |
+| `grip_led_cmd` | `r(6)`, `g(6)`, `b(6)` | RGB LED strip command (0-255 per channel) |
+
+## Outputs
+
+### `arm_motor`
+
+Archer Y6 / Firefly Y6: `{"pos": float64[6], "vel": float64[6], "eff": float64[6]}`
+
+Hello Y6: `{"pos": float64[6], "vel": float64[6]}`
+
+### `arm_end`
+
+Archer Y6 / Firefly Y6 only: `{"pos": float64[3], "quat": float64[4]}`
+
+### `grip_motor`
+
+Archer Y6 / Firefly Y6: `{"pos": float64[dof], "vel": float64[dof], "eff": float64[dof]}`
+
+Hello Y6: `{"pos": float64[7]}`
+
+## Arrow Dict Encoding
+
+All data is transmitted as `dict[str, arr]` via flat `float64` Arrow arrays. The `metadata` dict describes the layout using field names as keys mapped to their array lengths:
+
+```python
+# Example arm_motor metadata for Archer/Firefly Y6
+metadata = {
+    "fields": "pos,vel,eff",  # field order in the flat array
+    "pos": "6",               # pos occupies 6 elements
+    "vel": "6",
+    "eff": "6",
+}
+```
+
+Use `hex_dora_node_robot.util.dict_decode` to unpack and `dict_encode` to pack:
+
+```python
+from hex_dora_node_robot.util import dict_decode, dict_encode
+
+# Decode state from a robot node
+state = dict_decode(event["value"], event["metadata"])
+print(state["pos"], state["vel"])
+
+# Encode command to send to the robot node
+import numpy as np
+cmd = {
+    "q_tar": np.zeros(6),
+    "kp": np.array([400.0, 400.0, 500.0, 200.0, 100.0, 100.0]),
+    "kd": np.array([5.0, 5.0, 5.0, 5.0, 2.0, 2.0]),
+    "err_limit": np.array([0.03]),
+}
+storage, metadata = dict_encode(cmd, event["metadata"])
+node.send_output("arm_pos_cmd", storage, metadata)
+```
+
+## Environment Variables
+
+### Common (all robot nodes)
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `NODE_NAME` | `str` | `""` | Dora node name |
+| `HOST` | `str` | `192.168.1.100` | Robot controller IP address |
+| `PORT` | `int` | `8439` | WebSocket port |
+| `CTRL_RATE` | `float` | `1000` | Control loop rate (Hz) |
+| `STATE_BUFFER_SIZE` | `int` | `200` | Size of the state ring buffer |
+| `SEN_TS` | `bool` | `True` | Use sensor timestamps |
+
+### Archer Y6 / Firefly Y6
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `GRIP_TYPE` | `str` | `gp80` | Grip model (`gp80` or `empty` for no grip) |
+| `POSE_END_IN_FLANGE` | `str` | `0.187,0.0,0.0,1.0,0.0,0.0,0.0` | End-effector pose in flange frame `[x,y,z,qw,qx,qy,qz]` |
+
+### Hello Y6
+
+| Variable | Type | Default | Description |
+| --- | --- | --- | --- |
+| `LED_BUFFER_SIZE` | `int` | `10` | Size of the LED command buffer |
+
+## License
+
+This project is licensed under Apache-2.0.

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+hex_dora_node_robot/__init__.py
+hex_dora_node_robot/main_archer_y6.py
+hex_dora_node_robot/main_firefly_y6.py
+hex_dora_node_robot/main_hello_y6.py
+hex_dora_node_robot/main_robot_test.py
+hex_dora_node_robot/util.py
+hex_dora_node_robot.egg-info/PKG-INFO
+hex_dora_node_robot.egg-info/SOURCES.txt
+hex_dora_node_robot.egg-info/dependency_links.txt
+hex_dora_node_robot.egg-info/entry_points.txt
+hex_dora_node_robot.egg-info/requires.txt
+hex_dora_node_robot.egg-info/top_level.txt

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot.egg-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+hex-dora-node-archer-y6 = hex_dora_node_robot.main_archer_y6:main
+hex-dora-node-firefly-y6 = hex_dora_node_robot.main_firefly_y6:main
+hex-dora-node-hello-y6 = hex_dora_node_robot.main_hello_y6:main

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot.egg-info/requires.txt

@@ -0,0 +1,2 @@
+dora-rs>=0.3.9
+hex-driver-robot<0.1.0,>=0.0.0

hex_dora_node_robot-0.0.1a1/hex_dora_node_robot.egg-info/top_level.txt

@@ -0,0 +1 @@
+hex_dora_node_robot

hex_dora_node_robot-0.0.1a1/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "hex_dora_node_robot"
+version = "0.0.1-alpha.1"
+authors = [{ name = "Dong Zhaorui", email = "847235539@qq.com" }]
+description = "Dora Node for using Hex Robot"
+license = "Apache-2.0"
+readme = "README.md"
+requires-python = ">=3.10"
+
+dependencies = [
+    "dora-rs>=0.3.9",
+    "hex-driver-robot>=0.0.0,<0.1.0",
+]
+
+[dependency-groups]
+dev = ["pytest>=8.1.1", "ruff>=0.9.1"]
+
+[project.scripts]
+hex-dora-node-archer-y6 = "hex_dora_node_robot.main_archer_y6:main"
+hex-dora-node-firefly-y6 = "hex_dora_node_robot.main_firefly_y6:main"
+hex-dora-node-hello-y6 = "hex_dora_node_robot.main_hello_y6:main"
+
+[tool.ruff.lint]
+extend-select = [
+    "D",    # pydocstyle
+    "UP",   # Ruff's UP rule
+    "PERF", # Ruff's PERF rule
+    "RET",  # Ruff's RET rule
+    "RSE",  # Ruff's RSE rule
+    "NPY",  # Ruff's NPY rule
+    "N",    # Ruff's N rule
+    "I",    # Ruff's I rule
+]

hex_dora_node_robot-0.0.1a1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+