Head Movement Example

Jump to: navigation , search

The Head "Wobbler" Example randomly moves the head to demonstrate using the head pan .


Sawyer's head can rotate left-to-right in pan mode. The pan motion swings Sawyer's 'face' (a.k.a. screen) to a settable angle.

The head wobbler example is intended to be a simple demo whose code can be examined to learn how to use the head and demonstrate the use of the intera_interface Head class.

If you would like to follow along with the actual source code for the example on GitHub, it can be found through this link for head wobbler example.


From an RSDK Shell, run the head_wobbler.py demo from the intera_examples package:

$ rosrun intera_examples head_wobbler.py

Sawyer's head will begin panning left and right to random angles.

Code Walkthrough

Now, let's break down the code.

  1. import argparse
  2. import random
  4. import rospy
  6. import intera_interface
  8. from intera_interface import CHECK_VERSION

This imports the intera interface for accessing the head class.

  1. class Wobbler(object):
  3.     def __init__(self):
  4.         """
  5.        'Wobbles' the head
  6.        """
  7.         self._done = False
  8.         self._head = intera_interface.Head()

The _head is an object of the Head class within the interface_interface. This creates a subscriber to the topic robot/head/head_state and publishers to the topics robot/head/command_head_pan. The object _head, would be used to control the head panning.

  1.         # verify robot is enabled
  2.         print("Getting robot state... ")
  3.         self._rs = intera_interface.RobotEnable(CHECK_VERSION)
  4.         self._init_state = self._rs.state().enabled
  5.         print("Enabling robot... ")
  6.         self._rs.enable()
  7.         print("Running. Ctrl-c to quit")

intera_interface.RobotEnable(CHECK_VERSION) checks if the sdk version updated in the settings is compatible with the sdk version loaded on the param server of the Robot and creates an object _rs of the RobotEnable class. The next line sets the _init_state of the robot to its current state. The enable() performs the actual enabling of the robot. It is important to note that the robot should be in enabled state before attempting to move its joints.

  1.     def clean_shutdown(self):
  2.         """
  3.        Exits example cleanly by moving head to neutral position and
  4.        maintaining start state
  5.        """
  6.         print("\nExiting example...")
  7.         if self._done:
  8.             self.set_neutral()
  9.         if not self._init_state and self._rs.state().enabled:
  10.             print("Disabling robot...")
  11.             self._rs.disable()

This function performs a clean shutdown of the program. The _done variable gets updated once the head finishes its wobbling. Then, the head is moved to its neutral position and checks if the _init_state was in disabled state and the current state is enabled. If so, it resets the robot to the disable state.

  1.     def set_neutral(self):
  2.         """
  3.        Sets the head back into a neutral pose
  4.        """
  5.         self._head.set_pan(0.0)

The set_pan function moves the head to the desired joint position. It employs a PID position controller to move the head joint to that position. In order to move the head to the neutral position, the pan is set to 0.

  1.     def wobble(self):
  2.         self.set_neutral()
  3.         """
  4.        Performs the wobbling
  5.        """
  6.         command_rate = rospy.Rate(1)
  7.         control_rate = rospy.Rate(100)
  8.         start = rospy.get_time()

This is where the actual wobbling happens. Before the robot starts to wobble its head, it moves its head to the neutral position.

  1.         while not rospy.is_shutdown() and (rospy.get_time() - start < 10.0):
  2.             angle = random.uniform(-2.0, 0.95)

This retrieves a random floating point number between -2.0 and 0.95. These random angles are generated for 10 seconds.

  1.             while (not rospy.is_shutdown() and
  2.                    not (abs(self._head.pan() - angle) <=
  3.                        intera_interface.HEAD_PAN_ANGLE_TOLERANCE)):

This ensures that it loops till the current head pan position and the random angle generated above is within the HEAD_PAN_ANGLE_TOLERANCE.

  1.                 self._head.set_pan(angle, speed=0.3, timeout=0)
  2.                 control_rate.sleep()
  3.             command_rate.sleep()

This publishes the corresponding position and the speed to the robot/head/command_head_pan.

  1.         self._done = True
  2.         rospy.signal_shutdown("Example finished.")

Once the wobbling is completed, the _done variable is updated as True and a shutdown signal is sent.

  1. def main():
  2.     """RSDK Head Example: Wobbler
  3.    Nods the head and pans side-to-side towards random angles.
  4.    Demonstrates the use of the intera_interface.Head class.
  5.    """
  6.     arg_fmt = argparse.RawDescriptionHelpFormatter
  7.     parser = argparse.ArgumentParser(formatter_class=arg_fmt,
  8.                                      description=main.__doc__)
  9.     parser.parse_args(rospy.myargv()[1:])
  11.     print("Initializing node... ")
  12.     rospy.init_node("rsdk_head_wobbler")
  14.     wobbler = Wobbler()

An object of the Wobbler class is generated and this initializes the head interface, checks for the appropriate version and enables the robot.

  1.     rospy.on_shutdown(wobbler.clean_shutdown)
  2.     print("Wobbling... ")
  3.     wobbler.wobble()
  4.     print("Done.")
  6. if __name__ == '__main__':
  7.     main()

Panning happens when the wobble() function is called.