Inspire FTP Dexterity Hand

SDK Installation and Usage

This SDK is primarily implemented in Python and relies on unitree_sdk2_python, while also utilizing PyQt5 and PyQtGraph for visualization.

Install Dependencies

clone the SDK working directory:

git clone https://github.com/NaCl-1374/inspire_hand_ws.git

Update submodules:

git submodule init  # Initialize submodules
git submodule update  # Update submodules to the latest version

Install unitree_sdk2_python:
Terminal window
```
cd unitree_sdk2_python
pip install -e .
```

 ref: [unitree_sdk2_python](https://github.com/unitreerobotics/unitree_sdk2_python)，Install the required dependencies, and proceed with subsequent operations after the unitree_sdk2_python test passes.

Install inspire_hand_sdk
Terminal window
```
cd ../inspire_hand_sdk
pip install -e .
```

If error when pip3 install -e . ref: unitree_sdk2_python,This error mentions that the cyclonedds path could not be found. First compile and install cyclonedds:

Usage

Dexterous Hand and Environment Configuration

First, configure the network for the device. The default IP for the is:left hand is 192.168.123.210,right hand is 192.168.123.211. The device running the driver must be on the same subnet as the dexterous hand. After configuration, execute ping 192.168.123.210 or ping 192.168.123.211 to check if communication is normal.

If you need to adjust the IP of the dexterous hand and other parameters, you can run the Dexterous Hand Configuration Panel in the usage example below. The panel will automatically read the device information in the current network. After modifying the parameters on the panel, you need to click Write Settings to send the parameters to the dexterous hand. The parameters will not take effect until you click Save Settings and restart Hand.

For configuration using RS-485 communication, the method is similar to TCP, allowing you to modify the device ID through the configuration panel. However, due to the limited bandwidth of RS-485, only one device can run on a bus at about 20 Hz, so usually only the port number needs to be changed.

To grant serial port access to a user in Ubuntu, you can add the user to the dialout group, which has permissions for serial devices (e.g., /dev/ttyS0 or /dev/ttyUSB0). Here’s how:

Check if the user is already in the dialout group:
Terminal window
```
groups $USER
```
Add the user to the dialout group (replace your_username with the actual username):
Terminal window
```
sudo usermod -aG dialout your_username
```
Log out and back in (or reboot) to apply the new permissions.
Verify the permissions: You can check the device permissions with:
Terminal window
```
ls -l /dev/ttyUSB0
```

After these steps, the user should have access to serial devices.

If you modify the IP, you need to change the following code in the relevant files to update the ip option to the new IP address. It is recommended to change it to the same 192.168.123.*** subnet as unitree_sdk2.

  # inspire_hand_sdk/example/Vision_driver.py and inspire_hand_sdk/example/Headless_driver.py
handler=inspire_sdk.ModbusDataHandler(ip=inspire_hand_defaut.defaut_ip, LR='r', device_id=1)

window = MainWindow(ip=defaut_ip)

Here, the LR option is the parameter for the DDS message suffix *, which can be defined according to the device.

When running, be sure to modify the DDS working network card option; for details, refer to the G1 SDK Quick Development for DDS configuration.

The main communication interface definitions of the SDK are as follows: please configure according to the instructions.

class ModbusDataHandler:
    def __init__(self, data=data_sheet, history_length=100, network=None, ip=None, port=6000, device_id=1, LR='r', use_serial=False, serial_port='/dev/ttyUSB0', baudrate=115200, states_structure=None, initDDS=True, max_retries=5, retry_delay=2):
        """_summary_
        Calling self.read() in a loop reads and returns the data, and publishes the DDS message at the same time
        Args:
            data (dict, optional): Tactile sensor register definition. Defaults to data_sheet.
            history_length (int, optional): Hand state history_length. Defaults to 100.
            network (str, optional): Name of the DDS NIC. Defaults to None.
            ip (str, optional): ModbusTcp IP. Defaults to None will use 192.1686.11.210.
            port (int, optional): ModbusTcp IP port. Defaults to 6000.
            device_id (int, optional): Hand ID. Defaults to 1.
            LR (str, optional): Topic suffix l or r. Defaults to 'r'.
            use_serial (bool, optional): Whether to use serial mode. Defaults to False.
            serial_port (str, optional): Serial port name. Defaults to '/dev/ttyUSB0'.
            baudrate (int, optional): Serial baud rate. Defaults to 115200.
            states_structure (list, optional): List of tuples for state registers. Each tuple should contain (attribute_name, start_address, length, data_type). If None ,will publish All Data
            initDDS (bool, optional): Run ChannelFactoryInitialize(0),only need run once in all program
            max_retries (int, optional): Number of retries for connecting to Modbus server. Defaults to 3.
            retry_delay (int, optional): Delay between retries in seconds. Defaults to 2.
        Raises:
            ConnectionError: raise when connection fails after max_retries
        """
!!!

Here's the translated usage example in English:

---

### Usage Examples

Below are instructions for several common usage examples:

1. **Publishing Control Commands via DDS**:

    Run the following script to publish control commands:
    ```bash
    python inspire_hand_sdk/example/dds_publish.py
    ```

2. **Subscribing to the Status of the Dexterous Hand and Tactile Sensor Data, and Visualizing**:

    Run the following script to subscribe to the status and sensor data of the dexterous hand, and visualize the data:
    ```bash
    python inspire_hand_sdk/example/dds_subscribe.py
    ```

3. **Dexterous Hand DDS Driver (Headless Mode)**:

    Use the following script for driving operations in headless mode:
    ```bash
    python inspire_hand_sdk/example/Headless_driver.py
    ```
    !!! note
   Programs with 485 indicate the use of RS-485 drivers, while those without it indicate the use of TCP drivers. The `l/r/double` suffixes represent single left/right and both hands driving simultaneously.
:::

4. **Dexterous Hand DDS Driver (Panel Mode)**:

    Use the following script to enter panel mode and control the dexterous hand's DDS driver:
    ```bash
    python inspire_hand_sdk/example/Vision_driver.py
    ```

5. **Dexterous Hand Configuration Panel**:

    Run the following script to use the configuration panel for the dexterous hand:
    ```bash
    python inspire_hand_sdk/example/init_set_inspire_hand.py
    ```

6. **Publishing Control Commands via DDS in C++**:

    Run the following commands to compile and run the example program:
    ```bash
    cd inspire_hand_sdk
    mkdir build && cd build
    cmake ..
    make
    ./hand_dds
    ```

---