Course_Controllers_Unit_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ROS Control MicroCourse"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 1: Basic Concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:green;color:white;\">SUMMARY</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimated time to completion: <b>20 minutes</b><br><br>\n",
    "This unit is an introduction to some basic concepts regarding ROS controllers and the ros_control package that you need to know in order to be able to fully understand the contents of the course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:green;color:white;\">END OF SUMMARY</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The ros_control packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic Concepts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ros_control packages are a set of packages that include controller interfaces, controller managers, transmissions, hardware_interfaces, and the control_toolbox. All of these packages together allow you to interact and control the joints and actuators of your robot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a very brief explanation of how they work: the ros_control packages take the joint state data and an input set point(goal) as input, and sends the appropriate command to the actuators as an output (typically an effort command), in order to achieve the provided set point(goal) given the actual joint states. It uses a generic control loop feedback mechanism, typically a PID controller, to control the output. This output is passed to the robot through the hardware interface."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this course, we will be focusing on how to integrate these ros_control packages within a simulation environment, so you can control your simulated robot using this amazing tool!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can have a look at the following image to see how ros_control interacts either with a simulated robot or a real one."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/ros_control_diagram2.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The third party block represents the one that is sending the goal to the ros_control packages, which could be, for instance, the Navigation Stack or a MoveIt application. You can also visualize the ros_control block (in orange), the hardware interface box at the bottom (which represents the connection between the different controllers and the RobotHW), and both a simulated and a real robot at the right side of the image."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Don't worry if you don't really understand it. By completing this course, you will be able to better understand how this workflow goes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ROS controllers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ros_control packages provide a set of controller plugins to interact in different ways with the joints of your robot. The list is as follows:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "<li><b>effort_controllers</b>: Used when you want to send commands to an effort interface. This means that the joints you want to control accept effort commands.\n",
    "<ul>\n",
    "<li><i><b>joint_effort_controller</b></i>: The effort_controllers plugin accepts effort values as input.</li>\n",
    "<li><i><b>joint_position_controller</b></i>: The effort_controllers plugin accepts position values as input.</li>\n",
    "<li><i><b>joint_velocity_controller</b></i>: The effort_controllers plugin accepts velocity values as input.</li>\n",
    "</ul>\n",
    "</li>\n",
    "<li><b>position_controllers</b>: Used when you want to send commands to a position interface. This means that the joints you want to control accept position commands.\n",
    "<ul>\n",
    "<li><i><b>joint_position_controller</b></i>: The position_controllers plugin accepts only position values as input.</li>\n",
    "</ul>\n",
    "</li>\n",
    "<li><b>velocity_controllers</b>: Used when you want to send commands to a velocity interface. This means, that the joints you want to control accept velocity commands.\n",
    "<ul>\n",
    "<li><i><b>joint_velocity_controller</b></i>: The velocity_controllers plugin accepts only velocity values as input.</li>\n",
    "</ul>\n",
    "</li>\n",
    "<li><b>joint_state_controller</b>: This plugin provides the state of the joints, publishing them into a topic called <i><b>/joint_states</b></i>.\n",
    "<ul>\n",
    "<li><i><b>joint_state_controller</b></i></li>\n",
    "</ul>\n",
    "</li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This may be a little bit confusing. Let's try to make it clearer!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basically, the plugins described before have input commands (goal) and output commands (how to achieve that goal). The output commands are the category names, which are related to the joint interface - so to what kind of joint you are dealing with. This means that the effort_controllers plugin, for instance, will always communicate with a joint that uses an effort interface. And the same happens with the velocity and position controllers.<br><br>\n",
    "However, the effort_controllers plugin can accept input commands of any type - either effort, position, or velocity commands - which are the sub-categories on the list. These input commands will then be translated by the plugin to effort commands so that the joint can understand them. In the case of the position or velocity controllers, they just accept input commands of the same type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Regarding the joint_state_controller, we can summarize it by saying that it is in charge of providing constant information about the state of the robot, so this plugin will <b>ALWAYS</b> have to be set."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, depending on the joints that your robot has, you will choose one plugin or another, except for the joint_state_controller, which you will always have to set. You can also load more than one plugin (the effort, position, and/or velocity) for a robot, and switch between them using the controller_manager, but that won't be covered in this course."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 1.1</p>\n",
    "<br>\n",
    "a) Go to the <i><b>pi_robot_pkg</b></i> package and copy the file named <i><b>pirobot_control.yaml</b></i> (which is inside the <i><b>config</b></i> folder) into your workspace. After doing that, you can just execute the following commands:\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "roscd pi_robot_pkg"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "cp config/pirobot_control.yaml /home/user/catkin_ws/src"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you will be able to visualize the file in the IDE, which is much more pleasant."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/ide1.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Have a look at this file and identify which type of controllers are being launched in the file."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> effort_controllers + joint_effort_controller<br>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> effort_controllers + joint_position_controller<br>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> effort_controllers + joint_velocity_controller<br>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> position_controllers + joint_position_controller<br>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> velocity_controllers + joint_velocity_controller<br>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> joint_state_controller + joint_state_controller<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#AE0202;color:white;\">Solution for Exercise 1.1</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "effort_controllers + joint_position_controller and joint_state_controller + joint_state_controller"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 1.1</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Hardware Interfaces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, after the plugins do their job, their output is sent to what is called the hardware interface. The hardware interface is a software representation of the robot and its abstract hardware. The hardware interface allocates each resource for the controllers and sends values to each resource, so it acts like an intermediary between the controller plugins and the real or simulated robot. So, the values from the hardware interface can be sent to Gazebo or to the real robot."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are lots of hardware_interfaces in the ros_control packages, but for the purpose of this course, we are just going to focus on the following ones:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<ul>\n",
    "<li><b>Joint Command Interfaces</b>\n",
    "<ul>\n",
    "<li><i><b>Effort Joint Interface</b></i></li>\n",
    "<li><i><b>Velocity Joint Interface</b></i></li>\n",
    "<li><i><b>Position Joint Interface</b></i></li>\n",
    "</ul>\n",
    "</li>\n",
    "<li><b>Joint State Interfaces</b></li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, three types of Joint Command Interfaces exist. These interfaces are the ones that allow you to command your joints, so there is one for each type of joint supported: Effort Joints, Position Joints, and Velocity Joints."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Joint State Interfaces, as we explained before, will be in charge of providing the current state of the joints."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 1.2</p>\n",
    "<br>\n",
    "a) Do the same as you did in the previous exercise, but with the file named <i><b>pi_robot_v2.urdf</b></i> (which is inside the <i><b>urdf</b></i> folder)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Have a look at this file and identify which type of hardware interface this simulation is using."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> Effort Joint Interface<br>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> Velocity Joint Interface<br>\n",
    "<input type=\"checkbox\" name=\"vehicle\" value=\"Bike\"> Position Joint Interface<br>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#AE0202;color:white;\">Solution for Exercise 1.1</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Effort Joint Interface"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 1.2</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that's all for this first introduction. Now it's time to begin the real work! Don't worry if you still have many doubts at this point. As you advance through the course and do the exercises, they will be clarified."
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}