| CAN_compatibility_arm.cpp [code] | |
| CAN_compatibility_arm.hpp [code] | |
| CAN_compatibility_arm_node.cpp [code] | |
| etherCAT_compatibility_hand.cpp [code] | |
| etherCAT_compatibility_hand.hpp [code] | This compatibility interface is a wrapper around the new etherCAT Hand ROS driver. It is used to present the same interface as the CAN hand |
| etherCAT_compatibility_hand_node.cpp [code] | Contains the main for the EtherCAT wrapper. We start the publishers / subscribers in this node. They all share the same EtherCATCompatibilityHand object, this way the subscriber can update the hand properties, while the publishers publish up to date data. The diagnostics and the other publisher are started in two different threads, to allow them to be published at different frequencies |
| fancy_touch_demo.py [code] | |
| Grasp.py [code] | |
| grasps_interpoler.py [code] | |
| grasps_parser.py [code] | |
| hand_commander.cpp [code] | This is a library that offers a simple interface to send commands to hand joints. It is compatible with the Shadow Robot CAN hand and ethercat hand. It allows the user not worry about the name of the currently running controllers. Only position control is allowed (targets must represent angles) |
| hand_commander.hpp [code] | This is a library that offers a simple interface to send commands to hand joints. It is compatible with the Shadow Robot CAN hand and ethercat hand. It allows the user not worry about the name of the currently running controllers. Only position control is allowed (targets must represent angles) |
| hand_commander_test.cpp [code] | |
| link_joints.cpp [code] | This is an example to show how to get data from the hand, read the position for a specific joint and send this as the target to another joint |
| link_joints.py [code] | |
| real_arm.cpp [code] | The real arm can be used as a simulator. It modelizes the Shadow Robot muscle arm |
| real_arm.h [code] | The real arm is a ROS interface to Shadow Robot muscle arm |
| real_arm_node.cpp [code] | Contains the main for the real arm. We start the publishers / subscribers in this node. They all share the same RealArm object, this way the subscriber can update the arm properties, while the publishers publish up to date data. The diagnostics and the other publisher are started in two different threads, to allow them to be published at different frequencies |
| real_shadowhand.cpp [code] | |
| real_shadowhand.h [code] | The real shadowhand is the ROS interface to Shadow Robot robotic hand |
| real_shadowhand_node.cpp [code] | Contains the main for the real Shadow Dextrous Hand. We start the publishers / subscribers in this node. They all share the same RealShadowhand object, this way the subscriber can update the hand properties, while the publishers publish up to date data. The diagnostics and the other publisher are started in two different threads, to allow them to be published at different frequencies |
| sexy_example_latching.py [code] | |
| shadowhand_publisher.py [code] | |
| shadowhand_ros.py [code] | |
| shadowhand_subscriber.py [code] | |
| sr_articulated_robot.cpp [code] | |
| sr_articulated_robot.h [code] | |
| sr_diagnosticer.cpp [code] | The goal of this ROS publisher is to publish relevant data concerning the hand at a regular time interval. Those data are (not exhaustive): positions, targets, temperatures, currents, forces, error flags, .. |
| sr_diagnosticer.h [code] | The Diagnosticer is a ROS publisher which publishes diagnostic data regarding the Dextrous Hand or the Shadow Robot Arm, on the \/diagnostics topic. The diagnostics can be viewed using the robot_monitor package |
| sr_kinematics.cpp [code] | A ROS node used to subscribe to the tf topic on which the reverse kinematics targets are published. Those targets are then transformed into a pose and sent to the arm_kinematics node which tries to compute the reverse kinematics. On success, the computed targets are then sent to the arm and to the hand |
| sr_kinematics.h [code] | A ROS node used to subscribe to the tf topic on which the reverse kinematics targets are published. Those targets are then transformed into a pose and sent to the arm_kinematics node which tries to compute the reverse kinematics. On success, the computed targets are then sent to the arm and to the hand |
| sr_publisher.cpp [code] | The goal of this ROS publisher is to publish relevant data concerning the hand at a regular time interval. Those data are (not exhaustive): positions, targets, temperatures, currents, forces, error flags, .. |
| sr_publisher.h [code] | This class reads and publishes data concerning the shadowhand / shadowarm. To publish those data, just call the publish() function |
| sr_subscriber.cpp [code] | The role of this ROS subscriber is to receive commands messages (sent by a publisher) and pass them to the hand after translating them to the correct format |
| sr_subscriber.h [code] | This ROS subscriber is used to issue commands to the hand / arm, from sending a set of targets, to changing the controller parameters |
| test_sensor_scope.py [code] | |
| valves.cpp [code] | This is a ROS Interface used to directly access the valves on Shadow Robot's muscle robots |
| valves.h [code] | This is a ROS Interface used to directly access the valves on Shadow Robot's muscle robots |
| valves_node.cpp [code] | |
| virtual_arm.cpp [code] | The virtual arm can be used as a simulator. It modelizes the Shadow Robot muscle arm |
| virtual_arm.h [code] | The virtual arm can be used as a simulator. It modelizes the Shadow Robot muscle arm |
| virtual_arm_node.cpp [code] | Contains the main for the virtual arm. We start the publishers / subscribers in this node. They all share the same VirtualArm object, this way the subscriber can update the arm properties, while the publishers publish up to date data. The diagnostics and the other publisher are started in two different threads, to allow them to be published at different frequencies |
| virtual_shadowhand.cpp [code] | |
| virtual_shadowhand.h [code] | The Virtual Shadowhand can be used as a simulator. As both the real hand and the virtual hand are children from the shadowhand class, using a virtual or a real hand doesn't change anything in the way you call them in your programs |
| virtual_shadowhand_library.cpp [code] | |
| virtual_shadowhand_library.h [code] | |
| virtual_shadowhand_node.cpp [code] | Contains the main for the virtual hand. We start the publishers / subscribers in this node. They all share the same VirtualHand object, this way the subscriber can update the hand properties, while the publishers publish up to date data. The diagnostics and the other publisher are started in two different threads, to allow them to be published at different frequencies |