Course_Drones_Unit1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/drone_course_image2.png\" width=\"700\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/robotignite_logo_text.png\" width=\"700\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Programming Drones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Unit 1: Basic Control of a Drone"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:green;color:white;\">SUMMARY</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Estimated time to completion: <b>1 hour</b><br><br>\n",
    "In this unit, you are going to see some basic concepts that you need to know in order to be able to control and pilot a drone."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:green;color:white;\">END OF SUMMARY</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The very first thing you will want to be able to do when you start working with a mobile robot is to move it, right?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Well then, in this first chapter, you are going to see how you can easily move the robot by using two basic methods:\n",
    "\n",
    "* Publishing directly to topics\n",
    "* Using the keyboard teleop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So... let's stop talking and go for it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Move the drone by directly publishing to topics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first thing we need to know in order to move the drone through topics is which topics will allow us to do that, right? Let's then have a look at the topics provided by the simulation and see if we can figure it out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "<p class=\"transparent\">Execute in WebShell #1</p>\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rostopic list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Can you guess which ones they are? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/drone_topics1.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/drone_topics2.png\" width=\"300\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you know? Well, there are two things you need to take into account here. \n",
    "\n",
    "First, we have the topic that was used in order to control and send the velocity commands to the drone, which is the **/cmd_vel** topic. So, by publishing into this topic, we will be able to control the movement of the drone when it's in the air. \n",
    "\n",
    "Second, we have the topics that are used in order to make the drone take off and land, which are **/drone/takeoff** and **/drone/land**. So, by publishing into these topics, we will be able to send orders to the drone so that it will take off or land, depending on the topic we publish in."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But how is that done? What do we need to publish into these topics? Let's have a look at how this works!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rostopic info /cmd_vel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rostopic info /drone/takeoff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rostopic info /drone/land"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/cmd_vel_info.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/rostopic_takeoff.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/rostopic_land.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, we have two different types of messages here. The **cmd_vel** topic uses the **geometry_msgs/Twist** message, and the **/drone/takeoff** and **/drone/land** topics use the **std_msgs/Empty** message. These are the two types of messages that we will need to send to each topic in order to control the drone. So, let's have a look at these messages!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rosmsg show geometry_msgs/Twist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rosmsg show std_msgs/Empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/twist_msg.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/rosmsg_empty.png\" width=\"500\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's go by parts. As you can see, the **Twist** message contains two vectors: one for the linear velocities, and the other one for the angular velocities. Each of these vectors has its own corresponding components in x, y, and z. So, what does this mean? This means that we can send velocity commands to the drone in different linear and angular components. For instance, if we apply a velocity in the linear x component, the drone will move forward. If we apply a velocity in the linear y component, the drone will move sideways, without turning. And so on. So, not all the fields need to be filled; just the ones that we are interested in. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the other hand, the **Empty** message doesn't contain anything in it. It is, obviously, an empty message!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, if you want to see how you can fill these messages in order to control the drone, just follow the next exercise!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 1.1</p>\n",
    "<br>\n",
    "a) Execute the following command in order to generate the structure of the std_msgs/Empty message.\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rostopic pub /drone/takeoff [TAB][TAB]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will see something like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/drone_publish_takeoff.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, you can just press enter in order to make the drone take off."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Execute the following command in order to generate the structure of the geometry_msgs/Twist message.\n",
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rostopic pub /cmd_vel [TAB][TAB]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will see something like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/drone_publish_circle_empty.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Now, fill in the message with the proper velocities you want to send to your robot. For this exercise, let's set the **linear velocity in x to 0.5**, and the **angular velocity in z to 0.5** as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/drone_publish_circle.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, by applying a linear x velocity, the drone will move forward. And by applying an angular z velocity, the drone will rotate on its axis. So, in the end, we are generating a circular movement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Just press enter in order to send the message! If everything went OK, you should see the drone doing a circular movement."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/drone_circle.gif\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e) In order to stop the robot's movement, you will have to set the velocities to 0 again."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f) Finally, in order to land the drone again, you will have to publish an empty message to the **/drone/land** topic."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rostopic pub /drone/land [TAB][TAB]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "g) You can continue playing a little bit with the drone and testing how the drone moves by applying velocities to the different components."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 1.1</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! So you have seen how to control the drone by publishing directly to the topics. Now, let's see how else you can achieve this."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Moving the robot with the keyboard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, it's just too cumbersome to have to publish the velocities into a topic each time we want to move the robot, and gets much more complicated when we want to execute more complex trajectories. Fortunately, there is a very good ROS program that allows us to control the movement of the robot by just using the keyboard. Sounds good, right?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to see how you can control the Turtlebot3 robot with the keyboard, follow the next exercise!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 1.2</p>\n",
    "<br>\n",
    "a) First of all, you will need to make the drone take off in order to be able to use the keyboard teleop program. This is a limitation existing in the keyboard teleoperation scripts. But don't worry! We are going to modify this later in the exercise."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Go to your workspace and execute the following command in order to download the keyboard teleoperation program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "git clone https://github.com/ros-teleop/teleop_twist_keyboard.git"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "c) Now, you can execute the program by running the next command:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rosrun teleop_twist_keyboard teleop_twist_keyboard.py"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can now control the drone using your keyboard, as you did in the demo unit. It's quite annoying to have to manually take off and land the drone each time you want to teleoperate it, don't you think? Let's modify it then!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Open the **teleop_twist_keyboard.py** file in the IDE, and have a look at the code. You will need to modify some things in the code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "e) At the beginning of the file, import the Empty message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import roslib; roslib.load_manifest('teleop_twist_keyboard')\n",
    "import rospy\n",
    "\n",
    "from geometry_msgs.msg import Twist\n",
    "from std_msgs.msg import Empty"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "f) Next, create two new Publishers, one for landing and the other one for taking off. And create an instance of the Empty message:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "if __name__==\"__main__\":\n",
    "        settings = termios.tcgetattr(sys.stdin)\n",
    "\n",
    "    pub = rospy.Publisher('cmd_vel', Twist, queue_size = 1)\n",
    "    rospy.init_node('teleop_twist_keyboard')\n",
    "    pub2 = rospy.Publisher('drone/takeoff', Empty, queue_size = 1)\n",
    "    pub3 = rospy.Publisher('drone/land', Empty, queue_size = 1)\n",
    "    empty_msg = Empty()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "g) Finally, just add two conditions for the new keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "while(1):\n",
    "    key = getKey()\n",
    "    if key in moveBindings.keys():\n",
    "        x = moveBindings[key][0]    \n",
    "        y = moveBindings[key][1]    \n",
    "        z = moveBindings[key][2]    \n",
    "        th = moveBindings[key][3]\n",
    "    elif key in speedBindings.keys():   \n",
    "        speed = speed * speedBindings[key][0]   \n",
    "        turn = turn * speedBindings[key][1]\n",
    "\n",
    "        print vels(speed,turn)  \n",
    "        if (status == 14):\n",
    "            print msg   \n",
    "        status = (status + 1) % 15\n",
    "\n",
    "    elif key == '1':\n",
    "        pub2.publish(empty_msg)\n",
    "    elif key == '2':\n",
    "        pub3.publish(empty_msg)\n",
    "\n",
    "    else:\n",
    "        x = 0   \n",
    "        y = 0   \n",
    "        z = 0   \n",
    "        th = 0  \n",
    "        if (key == '\\x03'):\n",
    "            break\n",
    "\n",
    "    twist = Twist()\n",
    "twist.linear.x = x*speed; twist.linear.y = y*speed; twist.linear.z = z*speed;\n",
    "twist.angular.x = 0; twist.angular.y = 0; twist.angular.z = th*turn\n",
    "pub.publish(twist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! So, now you can run the script again and try the new keys you have set up for taking off and landing the drone!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 1.2</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Control Modes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, you already know all the basics for how to control the drone by sending velocity commands to it. But let me tell you one thing: this is not the only way you can control the node."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Two modes exist in which you can control a drone. The **velocity mode**, which is the one you have been using up until now, and the **position mode**. In the position mode, you can control the drone by sending space coordinates in the format (x,y,z), which will be referenced to the odometry frame. So, for instance, if you send the following coordinates (1,2,1) to the drone, the drone will automatically move and apply the required velocities in order to go to those coordinates in the world."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I think it will be better if you see how this works in an exercise. So, let's go for it!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 1.3</p>\n",
    "<br>\n",
    "a) First of all, you will need to switch the position control mode on. For that, you need to publish into the **/drone_posctrl** topic. This topic uses the **std_msgs/Bool** type of message."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table style=\"float:left;background: #407EAF\">\n",
    "<tr>\n",
    "<th>\n",
    "Execute in WebShell #1\n",
    "</th>\n",
    "</tr>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "rostopic pub /drone/pos_ctrl std_msgs/Bool [TAB][TAB]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You will now see something like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/switch_mode_false.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, now all you need to do is set the **data** variable to true inside this message. When you publish the message into the topic, the position mode will be activated."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/switch_mode_true.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) You can now start sending coordinates to the drone. To use this mode, you have to publish to the **/cmd_vel** topic, just as you were doing up until now. But in this case, you will be sending coordinates instead of velocities. These coordinates will be placed in the linear velocities vector. For instance, let's send the following coordinates to the drone:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(0,0,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This coordinates will be written into the command, like this:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/posctrl_example.png\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So, with the following command, we are ordering the drone to stay at the same position in x and y, but to move up 1 meter on the z axis, which will cause something similar to the take off."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/posctrl0.gif\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(1,0,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are telling the drone to move 1 meter on the x axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/posctrl1.gif\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(1,1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are telling the drone to move 1 meter on the y axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/posctrl2.gif\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(2,0,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are telling the drone to move 1 meter on the x axis, and to go back 1 meter on the y axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/posctrl3.gif\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "(2,0,2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are telling the drone to move 1 meter on the z axis."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"img/posctrl4.gif\" width=\"600\" />"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Do you get how it works? It's quite interesting, right? Now you can play with the drone a little in this mode, in order to completely get used to it and how it works. When you are done, you can go back to the **velocity mode** by publishing a message to the **/drone/vel_mode** topic with the **data** variable as true."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 1.3</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating some basic trajectories"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Great! So at this point, you already know all the basics for controlling a drone, using both control modes. You are now ready to start creating some simple trajectories for it. For instance, you can create a service that, when called, makes your drone execute one of the following three predefined trajectories: circle, square, or triangle."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For that, you will have to do the following:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1- Create a Service message that has a string as a request. For instance, it could have the following structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# request\n",
    "string label\n",
    "---\n",
    "#response\n",
    "bool navigation_successfull\n",
    "string message"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2- Create a Service Server that receives this request and, depending on the name that comes in the string (circle, square, or triangle), will reproduce one trajectory or another. You will need to define the necessary code in order to perform all of the trajectories inside this Service Server code. Also, besides executing the specified trajectory, the drone has to take off before starting the trajectory, and land after the trajectory is completed."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3- Finally, return a response indicating if the drone completed the requested trajectory successfully."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">Exercise 1.4</p>\n",
    "<br>\n",
    "a) Create a new package called **drone_trajectories**. Inside this package, create three new folders: **launch**, **src**, and **srv**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "b) Create the Service Server code. If you don't really know how to create a Service Server, you can have a look at the **ROS Services - part 2** chapter of the **ROS Basic in 5 Days Course**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For instance, you could create a class with the following three functions for controlling the drone inside your Service Server."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# function that makes the drone stop\n",
    "def stop_drone(self):\n",
    "  rospy.loginfo(\"Stopping...\")\n",
    "  self._move_msg.linear.x = 0.0\n",
    "  self._move_msg.angular.z = 0.0\n",
    "  self.publish_once_in_cmd_vel(self._move_msg)\n",
    "\n",
    "# function that makes the drone turn\n",
    "def turn_drone(self):\n",
    "  rospy.loginfo(\"Turning...\")\n",
    "  self._move_msg.linear.x = 0.0\n",
    "  self._move_msg.angular.z = 1.0\n",
    "  self.publish_once_in_cmd_vel(self._move_msg)\n",
    "\n",
    "# function that makes the drone move forward\n",
    "def move_forward_drone(self):\n",
    "  rospy.loginfo(\"Moving forward...\")\n",
    "  self._move_msg.linear.x = 1.0\n",
    "  self._move_msg.angular.z = 0.0\n",
    "  self.publish_once_in_cmd_vel(self._move_msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By combining these three functions properly, you can create any trajectory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "c) Create the required Service message. If you don't know exactly how to do this, you can have a look at the **ROS Services - part 2** chapter of the **ROS Basic in 5 Days Course**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "d) Finally, call the Service and test that it works properly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"background:#EE9023;color:white;\">End of Exercise 1.4</p>"
   ]
  }
 ],
 "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
}