|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |
Dependant Packages
Launch files
Messages
Services
Plugins
Recent questions tagged ih2_azzurra_hand_driver at Robotics Stack Exchange
|
ih2_azzurra_hand_driver package from ih2_azzurra_hand_driver repoih2_azzurra_hand_driver |
ROS Distro
|
Package Summary
| Version | 0.1.0 |
| License | MIT |
| Build type | AMENT_PYTHON |
| Use | RECOMMENDED |
Repository Summary
| Checkout URI | https://github.com/af-a/ih2_azzurra_hand_driver.git |
| VCS Type | git |
| VCS Version | humble |
| Last Updated | 2026-05-04 |
| Dev Status | MAINTAINED |
| Released | UNRELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Package Description
Additional Links
Maintainers
- Ahmed Abdelrahman
Authors
- Ahmed Abdelrahman
Contents
Overview
The ih2_azzurra_hand_driver enables controlling and tracking the state of a Prensilia IH2 Azzurra hand through a Python API.
It can be built as a ROS-independent Python package, which contains the core functionalities, or as a ROS2 package: a wrapper which adds ROS integration. In addition to implementing ROS actions, the ROS wrapper also adds a GUI through which the hand can be controlled.
Installation
Build Python Package
To build the standalone Python package, install with pip when located in the root directory:
pip3 install .
Build ROS Package
To build the ROS package, clone the repository into your ROS workspace and build with:
colcon build --packages-select ih2_azzurra_hand_driver
When the ROS workspace is sourced after building, the Python module can also be imported and used as in the standalone Python build.
Usage
Python Driver
With the Python package installed and the hand connected via a USB connection, the driver can be initialized as follows:
>>> from ih2_azzurra_hand_driver.ih2_hand_control import IH2AzzurraHandController
>>> hand_controller = IH2AzzurraHandController(serial_port='/dev/ttyUSB0')
>>> hand_controller.initialize()
Note: the value of serial_port may need to be adjusted.
The current pose (positions of each DoA motor) can be fetched by calling:
>>> hand_controller.get_pose()
The pose can be set through:
>>> hand_controller.set_pose([2, 46, 43, 19, 20])
Note: Following the convention of Prensilia, motor positions are encoded as an 8-bit integer (range (0, 255)), for flexion/extension or abduction/adduction (thumb).
ROS Interface
To launch the driver node, run:
ros2 launch ih2_azzurra_hand_driver ih2_driver.launch.py
The launch file also starts an rqt_reconfigure GUI:
A desired named pose can be executed by entering its name in the named_pose field. In addition, the position if each of the five degrees of actuation (DoAs) can be individually controlled by modifying its value using the sliders or adjacent entry fields on the GUI.
Actions
The ROS package includes two action servers that utilize the ih2_azzurra_hand_driver_interfaces:
-
MoveHand: moves the hand by setting motor positions to individual values provided in the request field:desired_motor_position. Returns the final hand state. -
MoveHandToNamedPose: moves the hand by setting motor positions to individual values that correspond to a known, named pose that is provided in the request field:desired_named_pose. Returns whether the action was successfull and the resulting hand state.
To move the hand to a pose defined by a set of finger motor positions, send a MoveHand goal:
ros2 action send_goal /driver_node/MoveHand ih2_azzurra_hand_driver_interfaces/action/MoveHand "{'desired_motor_position': [10, 100, 10, 10, 180]}"
File truncated at 100 lines see the full file
Package Dependencies
| Deps | Name |
|---|---|
| ament_copyright | |
| ament_flake8 | |
| ament_pep257 | |
| rclpy | |
| geometry_msgs | |
| std_msgs | |
| action_msgs | |
| ih2_azzurra_hand_driver_interfaces |
System Dependencies
| Name |
|---|
| python3-pytest |