Reflex Stack

Citation

If you use this software in your research, please cite our paper.

@inproceedings{koenig2022tactile,
      title={The Role of Tactile Sensing in Learning and Deploying Grasp Refinement Algorithms}, 
      author={Alexander Koenig and Zixi Liu and Lucas Janson and Robert Howe},
      booktitle={IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS), 2022}, 
      year={2022}
}

System Architecture

This repository contains a simulator for the Reflex TakkTile robotic hand and the Reflex Interface, an accompanying C++ library.

Reflex Simulator: The idea behind the Reflex simulator is that you swap out the simulator for the real hand without any hassle. To achieve this, the simulator uses the same ROS topics and message definitions as the real hand does. We model some features of the Reflex, such as the tactile sensors and the underactuated distal flexure.

Reflex Interface (RI): The RI consists of two parts. The State module stores the most up to date state information of the Reflex and calculates various useful metrics for grasp analysis (e.g. grasp wrench space, epsilon, grasp matrix, slip prediction, ...). The Command module offers high-level control of the robotic hand via ROS services. Further, the RI offers a Keyboard Teleoperation Node for manual control of the robotic hand and the wrist (useful for debugging). The RI will also work on the real hand, although with a reduced feature set (since less information is available).

Installation

Option 1 - Using Docker

___ **(1) Clone**: Clone this repo along with its submodules. ```bash git clone --recursive git@github.com:axkoenig/reflex_stack.git cd reflex_stack ``` **(2) Build the Container**: If you simply want to try this software out you can directly skip to step (3), which will download the pre-built image from Dockerhub. However, if you want to modify or extend this software you must build it yourself with the included Dockerfile (this may take a while as it builds Gazebo from source ...). ```bash docker build -t axkoenig/reflex_stack . ``` **(3) Run the Container** Run the container and shell into it to check if everything works. The first command will download the pre-build container from Dockerhub if Docker finds no local container named reflex_stack. ```bash docker run --name sim -it --rm axkoenig/reflex_stack # in terminal 1: start simulation container docker exec -it sim bash -l # in terminal 2: shell into container rostopic echo /reflex_interface/hand_state # in terminal 2: print out reflex hand state ``` Side-note: If you want to run multiple simulations on one computer just make sure that no ports overlap. You can specifiy the ports like this. ```bash # first simulation docker run --env ROS_MASTER_URI=http://localhost:11311 --env GAZEBO_MASTER_URI=http://localhost:11321 --name sim_1 -it --rm axkoenig/reflex_stack # second simulation docker run --env ROS_MASTER_URI=http://localhost:11312 --env GAZEBO_MASTER_URI=http://localhost:11322 --name sim_2 -it --rm axkoenig/reflex_stack ``` **(4) Visualize Simulation** If you want to work with the Gazebo GUI follow these steps and you can view it in your browser. Kill any running containers from step (3). ```bash docker-compose up # in the reflex_stack directory localhost:8080/vnc.html # type this in your browser ``` Note that if you have gzclient installed locally you can follow [this](https://registry.hub.docker.com/_/gazebo) tutorial and check [this](https://www.youtube.com/watch?v=P__phnA57LM) video (which will probably give you a smoother rendering). If you are running the container on Ubuntu check out [this](http://wiki.ros.org/docker/Tutorials/Hardware%20Acceleration) tutorial for hardware acceleration. **(5) Interact with Simulation** If you want to teleoperate the robotic hand you can fire up the keyboard teleoperation node in a separate terminal. ```bash docker exec -it sim bash -l rosrun reflex_interface finger_teleop_node ``` **(6) What next?** There you have it! But where to go next? If you want to write custom controllers you can write a new ROS node that subscribes to `reflex_takktile/hand_state` and publishes to `reflex_takktile/command_position`. You could also integrate this new node into the Docker network by adding it to the `docker-compose.yml` file.

High-Level Interaction

The Reflex Interface offers several high-level ROS services to automate functions that are commonly used by grasping controllers. Below is a list of all ROS services provided by the Reflex Interface.

# services for pre-configured grasping positions 
/reflex_interface/open
/reflex_interface/close
/reflex_interface/pinch
/reflex_interface/spherical_close
/reflex_interface/spherical_open
# services to trigger other actions
/reflex_interface/close_until_contact
/reflex_interface/position_increment
/reflex_interface/tighten_grip

Calling a ROS service is a simple one-liner in your terminal. You can use auto-complete in your terminal to get a stub of the service definition.

# some services don't take any arguments
rosservice call /reflex_interface/close_until_contact "{}"
# some services do
rosservice call /reflex_interface/position_increment "{f1: 0.2, f2: 0.4, f3: 0.3, preshape: 1.5, from_measured_pos: true, blocking: false, tolerance: 0.01, time_out: 0.0}" 

Keyboard Teleoperation

Below is a list of keys that you can use to teleoperate the robotic hand. You can also use they keyboard teleoperation node on the real hand. Some commands (such as spherical close) are disabled on the real hand as fingers may crash into each other.

Acknowledgements

• The robot description package was initially based on the ll4ma_robots_description package by the Utah Learning Lab for Manipulation Autonomy.
• The keyboard teleoperation node contains some code for non-blocking keyboard input from teleop_twist_keyboard.cpp.