Chapter3_Motion_Planning_Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ROS-Industrial MicroCourse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 3: Motion Planning with Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:green;color:white;\">SUMMARY</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimated time of completion: <b>2h</b><br><br>\n",
    "This Unit will show you how to perform motion planning with Python. By completing this Unit, you will be able to create a Python program that performs motion planning on your robot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:green;color:white;\">END OF SUMMARY</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the previous Chapter, you saw that you can plan and execute trajectories for your robot using the MoveIt Rviz environment. But... this is not the common case.<br><br>\n",
    "Usually, you will want to move your robot with your own scripts. And this is exactly what we are going to do in this Chapter! For this Course, we are going to use Python to control the robot, because it's easier and faster. So, let's begin!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Planning a trajectory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you've seen in the previous Chapter, there is a difference between planning a trajectory, and executing it. In this first part of the chapter, we are going to see how to plan a trajectory with Python. For that, just follow the next Demo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Demo 3.1</p>\n",
    "<br>\n",
    "a) First of all, you'll need to launch the MoveIt Rviz environment. Type the following command:\n",
    "<br>\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<p class=\"transparent\">Execute in WebShell #1</p><br>\n",
    "roslaunch myrobot_moveit_config myrobot_planning_execution.launch<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:red;\"><b>NOTE:</b> If the window appears out of focus, just follow the steps described in the previous Chapter.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Execute the following Python code. You can do this by clicking on the cell and pressing Ctr+Enter, or by clicking in the \"Play\" icon at the top-right corner of this notebook. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#! /usr/bin/env python\n",
    "\n",
    "import sys\n",
    "import copy\n",
    "import rospy\n",
    "import moveit_commander\n",
    "import moveit_msgs.msg\n",
    "import geometry_msgs.msg\n",
    "\n",
    "moveit_commander.roscpp_initialize(sys.argv)\n",
    "rospy.init_node('move_group_python_interface_tutorial', anonymous=True)\n",
    "\n",
    "robot = moveit_commander.RobotCommander()\n",
    "scene = moveit_commander.PlanningSceneInterface()    \n",
    "group = moveit_commander.MoveGroupCommander(\"manipulator\")\n",
    "display_trajectory_publisher = rospy.Publisher('/move_group/display_planned_path', moveit_msgs.msg.DisplayTrajectory)\n",
    "\n",
    "pose_target = geometry_msgs.msg.Pose()\n",
    "pose_target.orientation.w = 1.0\n",
    "pose_target.position.x = 0.3\n",
    "pose_target.position.y = 0\n",
    "pose_target.position.z = 1.1\n",
    "group.set_pose_target(pose_target)\n",
    "\n",
    "plan1 = group.plan()\n",
    "\n",
    "rospy.sleep(5)\n",
    "\n",
    "moveit_commander.roscpp_shutdown()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) After a few seconds, you'll see in MoveIt Rviz how the robot is planning the specified motion described in the code above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#AE0202;color:white;\">Expected Result for Demo 3.1</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/planpy3.gif\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Demo 3.1</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:red;color:white;\">IMPORTANT NOTE</p>\n",
    "<br>\n",
    "Once you have finished with the Demo, remember to RESTART the Kernel by hitting the 'RESTART KERNEL' icon at the top right corner of the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:red;color:white;\">IMPORTANT NOTE</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's great! But... how does this code work? What does each part mean? Let's break it down into small pieces."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "import sys\n",
    "import copy\n",
    "import rospy\n",
    "import moveit_commander\n",
    "import moveit_msgs.msg\n",
    "import geometry_msgs.msg"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this section of the code, we are just importing some modules and messages that we'll need for the program. The most important here is the moveit_commander module, which will allow us to communicate with the MoveIt Rviz interface."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "moveit_commander.roscpp_initialize(sys.argv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we are just initializing the moveit_commander module."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "rospy.init_node('move_group_python_interface_tutorial', anonymous=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we are just initializing a ROS node."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "robot = moveit_commander.RobotCommander()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we are creating a RobotCommander object, which basically is an interface to our robot."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "scene = moveit_commander.PlanningSceneInterface()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we creating a PlanningSceneInterface object, which basically is an interface to the world that surrounds the robot."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "group = moveit_commander.MoveGroupCommander(\"manipulator\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we create a MoveGroupCommander object, which is an interface to the <i><b>manipulator</b></i> group of joints that we defined when we created the MoveIt package, back in the Chapter 1. This will allows us to interact with this set of joints which, in this case, is the full arm."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "display_trajectory_publisher = rospy.Publisher('/move_group/display_planned_path', moveit_msgs.msg.DisplayTrajectory)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are defining a Topic Publisher, which will publish into the <i><b>/move_group/display_planned_path<b></i> topic. By publishing into this topic, we will be able to visualize the planned motion through the MoveIt Rviz interface."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "pose_target = geometry_msgs.msg.Pose()\n",
    "pose_target.orientation.w = 1.0\n",
    "pose_target.position.x = 0.7\n",
    "pose_target.position.y = -0.05\n",
    "pose_target.position.z = 1.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we are creating a Pose object, which is the type of message that we will send as a goal. Then, we just give values to the variables that will define the goal Pose. You can have a look at the full structure of the Pose message by issuing the following command on a Web Shell: <i><b>rosmsg show geometry_msgs/Pose</b></i>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/pose_msg.png\" width=\"300\" />"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "plan1 = group.plan()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we are telling the \"manipulator\" group we created previously, to calculate the plan. If the plan is successfully computed, it will be displayed through MoveIt Rviz."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "moveit_commander.roscpp_shutdown()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At the end, we just shut down the moveit_commander module."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 3.1</p>\n",
    "<br>\n",
    "a) First of all, you'll need to launch the MoveIt Rviz environment. Type the following command:\n",
    "<br>\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<p class=\"transparent\">Execute in WebShell #1</p><br>\n",
    "roslaunch myrobot_moveit_config myrobot_planning_execution.launch<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:red;\"><b>NOTE:</b> If the window appears out of focus, just follow the steps described in the previous Chapter.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Create a new package called <i><b>my_motion_scripts</b></i>. Inside this package, create a new directory called <i><b>src</b></i>, with a file named <i><b>planning_script.py</b></i>. Finally, copy inside this file the code you've just executed in the Demo above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Inside the package, create also a launch directory that contains a launch file in order to launch the planning_script.py file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Modify the values assigned to the <i><b>pose_target</b></i> variable. Then launch your code and check if the new Pose is achieved successfully. Repat the process and try with different Poses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;\">\n",
    "<tr>\n",
    "<th>\n",
    "<p style=\"background:#3B8F10;color:white;\">Data for Exercise 3.1</p>\n",
    "<br>\n",
    "Check the following Notes in order to complete the Exercise:\n",
    "<br><br>\n",
    "<span style=\"color:orange\">Note 1: </span>When you launch your Python script with your code, you may se the following error:\n",
    "<img src=\"img/pyerror.png\" width=\"1000\" />\n",
    "<br>\n",
    "This is known issue, and you don't need to worry about it. It is caused because some processes launched are not closed correctly, but it doesn't has any effect on the execution of the code itself. This error should be fixed for the newest ROS distributions, like Kinetic.<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 3.1</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Planning to a joint space goal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, insted of just moving the end-effector towards a goal, we can be interested in setting a goal for an specific joint. Let's see how you can do this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Demo 3.2</p>\n",
    "<br>\n",
    "a) First of all, you'll need to launch the MoveIt Rviz environment. Type the following command:\n",
    "<br>\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<p class=\"transparent\">Execute in WebShell #1</p><br>\n",
    "roslaunch myrobot_moveit_config myrobot_planning_execution.launch<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:red;\"><b>NOTE:</b> If the window appears out of focus, just follow the steps described in the previous Chapter.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Execute the following Python code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#! /usr/bin/env python\n",
    "\n",
    "import sys\n",
    "import copy\n",
    "import rospy\n",
    "import moveit_commander\n",
    "import moveit_msgs.msg\n",
    "import geometry_msgs.msg\n",
    "\n",
    "moveit_commander.roscpp_initialize(sys.argv)\n",
    "rospy.init_node('move_group_python_interface_tutorial', anonymous=True)\n",
    "\n",
    "robot = moveit_commander.RobotCommander()\n",
    "scene = moveit_commander.PlanningSceneInterface()    \n",
    "group = moveit_commander.MoveGroupCommander(\"manipulator\")\n",
    "display_trajectory_publisher = rospy.Publisher('/move_group/display_planned_path', moveit_msgs.msg.DisplayTrajectory)\n",
    "\n",
    "group_variable_values = group.get_current_joint_values()\n",
    "\n",
    "group_variable_values[3] = 1.5\n",
    "group.set_joint_value_target(group_variable_values)\n",
    "\n",
    "plan2 = group.plan()\n",
    "\n",
    "rospy.sleep(5)\n",
    "\n",
    "moveit_commander.roscpp_shutdown()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) When the code ends executing, you'll see in MoveIt Rviz how the robot is planning the specified motion described in the code above."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#AE0202;color:white;\">Expected Result for Demo 3.2</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/joint_traj.gif\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Demo 3.2</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:red;color:white;\">IMPORTANT NOTE</p>\n",
    "<br>\n",
    "Once you have finished with the Demo, remember to RESTART the Kernel by hitting the 'RESTART KERNEL' icon at the top right corner of the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:red;color:white;\">IMPORTANT NOTE</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's great, right? But as we did before, let's analyze the new code we've introduced in order to understand what's going on."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "group.clear_pose_targets()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we are just clearing the actual values of the pose_target variable."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "group_variable_values = group.get_current_joint_values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we are getting the current values of the joints."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "group_variable_values[3] = 1.5\n",
    "group.set_joint_value_target(group_variable_values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we modify the value of 1 of the joints, and set this new joint value as a target."
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "plan2 = group.plan()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we just compute the plan for the new joint space goal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 3.2</p>\n",
    "<br>\n",
    "\n",
    "a) Inside the <i><b>my_motion_scripts</b></i> package, create a new file named <i><b>joint_planning.py</b></i>. Do some tests giving different values to different joints."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 3.2</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting some useful data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Through code, you can also get some valuable data that you may require for your code. Let's see some examples."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get the reference frame for a certain group by executing this line:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print \"Reference frame: %s\" % group.get_planning_frame()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get the end-effector link for a certaing group executing this line:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print \"End effector: %s\" % group.get_end_effector_link()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get a list with all the groups of the robot like this:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print \"Robot Groups:\"\n",
    "print robot.get_group_names()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can get the current values of the joints like this:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print \"Current Joint Values:\"\n",
    "print group.get_current_joint_values()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also get the current Pose of the end-effector of the robot like this:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print \"Current Pose:\"\n",
    "print group.get_current_pose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, you can check the general status of the robot like this:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "print \"Robot State:\"\n",
    "print robot.get_current_state()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 3.3</p>\n",
    "<br>\n",
    "a) First of all, you'll need to launch the MoveIt Rviz environment. Type the following command:\n",
    "<br>\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<p class=\"transparent\">Execute in WebShell #1</p><br>\n",
    "roslaunch myrobot_moveit_config myrobot_planning_execution.launch<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:red;\"><b>NOTE:</b> If the window appears out of focus, just follow the steps described in the previous Chapter.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Create a new file inside the package called <i><b>get_data.py</b></i>. Add all the new code you've learnt just above and check what results you get."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#AE0202;color:white;\">Expected Result for Exercise 3.3</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You should get something similar to this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/get_data_result.png\" width=\"800\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 3.3</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Executing a trajectory"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So at this point, you've seen some methods that allow you to plan a trajectory with Python code. But...what about executing this trajectory in the \"real\" robot? \n",
    "<br><br>\n",
    "In fact, it's very simple. In order to execute a trajectory, you just need to call the <i><b>go()</b></i> function from the planning group. Like this:"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "group.go(wait=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By executing this line of code, you will be telling your robot to execute the last trajectory that has been set for the Planning Group. Let's try this in an Exercise!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 3.4</p>\n",
    "<br>\n",
    "a) First of all, you'll need to launch the MoveIt Rviz environment. Type the following command:\n",
    "<br>\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<p class=\"transparent\">Execute in WebShell #1</p><br>\n",
    "roslaunch myrobot_moveit_config myrobot_planning_execution.launch<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:red;\"><b>NOTE:</b> If the window appears out of focus, just follow the steps described in the previous Chapter.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Create a new Python script called <i><b>execute_trajectory.py</b></i>, and copy inside there the code shown in Demo 3.1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Into your new script, add a line in order to execute that trajectory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) You can try this with any of the codes you have created for Planning trajectories."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#AE0202;color:white;\">Expected Result for Exercise 3.4</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/move_code.gif\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 3.4</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 3.5</p>\n",
    "<br>\n",
    "a) First of all, you'll need to launch the MoveIt Rviz environment. Type the following command:\n",
    "<br>\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<p class=\"transparent\">Execute in WebShell #1</p><br>\n",
    "roslaunch myrobot_moveit_config myrobot_planning_execution.launch<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"color:red;\"><b>NOTE:</b> If the window appears out of focus, just follow the steps described in the previous Chapter.</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Modify the <i><b>execute_trajectory.py</b></i> script, so that now it concatenates at least 2 motions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#AE0202;color:white;\">Expected Result for Exercise 3.5</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/concat_moves.gif\" width=\"400\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 3.5</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that's it! You have finished the Course! I really hope that you enjoyed it and, most of all, that you learned a lot! Now, if you want to know what you can do after finishing this Course, have a look at the Next Unit!"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}