77 lines
2.4 KiB
Markdown
77 lines
2.4 KiB
Markdown
# How to Build Your Own Arm
|
|
|
|
### Define your own config for the robot arm (unitree_deploy/robot_devices/arm/config.py)
|
|
|
|
```python
|
|
@ArmConfig.register_subclass("z1") # Register your custom arm wrapper. Here use def __init__(self, config: Z1DualArmConfig):
|
|
@dataclass
|
|
class Z1ArmConfig(ArmConfig):
|
|
port: str
|
|
motors: dict[str, tuple[int, str]]
|
|
mock: bool = False
|
|
init_pose_left: list = None
|
|
init_pose_right: list = None
|
|
control_dt: float = 1/500.0
|
|
|
|
# Default parameters go first [parameters that may need to be customized],
|
|
# Non-default parameters go later [fixed parameters]
|
|
```
|
|
|
|
### Description of methods in your arm class (unitree_deploy/robot_devices/arm/utils.py)
|
|
|
|
```python
|
|
# Base class for Arm, extensible with required methods
|
|
|
|
class Arm(Protocol):
|
|
def connect(self): ...
|
|
def disconnect(self): ...
|
|
def motor_names(self): ...
|
|
|
|
def read_current_motor_q(self): ...
|
|
def read_current_arm_q(self): ...
|
|
def read_current_arm_dq(self): ...
|
|
def write_arm(self): ...
|
|
|
|
def arm_ik(self): ...
|
|
```
|
|
|
|
How to implement external calls?
|
|
Use make_arm_motors_buses_from_configs [based on the config file] to construct the UnitreeRobot class.
|
|
Use make_arm_motors_bus [based on arm_type] which is generally used for external module loading.
|
|
|
|
### Implementation of the arm class (unitree_deploy/robot_devices/arm/.../....py)
|
|
|
|
```python
|
|
# These methods need to be implemented and completed
|
|
def connect(self): ...
|
|
def disconnect(self): ...
|
|
def motor_names(self): ...
|
|
# connect() and disconnect() should handle initialization and homing respectively
|
|
|
|
def read_current_motor_q(self): ...
|
|
def read_current_arm_q(self): ...
|
|
def read_current_arm_dq(self): ...
|
|
# Outputs should be unified as np.ndarray
|
|
|
|
def write_arm(self): ...
|
|
# Write control commands here
|
|
|
|
def arm_ik(self): ...
|
|
# Wrap IK into your own arm class for external calling
|
|
|
|
# Private/protected properties [for reading motor names, IDs, etc.]
|
|
@property
|
|
def motor_names(self) -> list[str]:
|
|
return list(self.motors.keys())
|
|
|
|
@property
|
|
def motor_models(self) -> list[str]:
|
|
return [model for _, model in self.motors.values()]
|
|
|
|
@property
|
|
def motor_indices(self) -> list[int]:
|
|
return [idx for idx, _ in self.motors.values()]
|
|
```
|
|
|
|
All arms use threading to implement \_subscribe_motor_state and \_ctrl_motor_state threads for internal reading and writing within the class.
|