Wednesday Tutorial (Sensors and Driving).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Wednesday Workshop - Let's Go For a Drive\n",
    "\n",
    "## Part 1 - Exploring the Sensors\n",
    "\n",
    "As we learned at the end of the last workshop, the iRobot has many different sensors. Not all of these will be useful but we need to be comfortable with the important ones and understand how to use the API to get sensor data.\n",
    "\n",
    "Let's first get the usual boilerplate done so we can interact with the robot. Same as last time. Discuss with your teammate what each of these statements are doing. The staff will come around and ask you."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "from breezycreate2 import Robot\n",
    "import time, pprint\n",
    "\n",
    "bot = Robot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Everytime we call \n",
    "\n",
    "```python\n",
    "bot.robot.get_packet(100)\n",
    "```\n",
    "\n",
    "We get updated sensor values from the robot. Because the robot is usually in motion and constantly interacting with its environment we will want to continuously get these values from the robot. To do this we will need to repeatedly ask the API to update the sensor values. For now let's do that by using a _while_ loop. \n",
    "\n",
    "Fill in the code below to update and print the sensor values at each time step. To avoid printing lots and lots of sensor values we also want to wait half a second before getting new values. This can be done using the time.sleep() function. \n",
    "\n",
    "(look back at the last worksheet to see how to access the sensor data)\n",
    "\n",
    "The _while_ loop will continue looping for _duration_ seconds. To loop indefinitely one could just use \n",
    "\n",
    "\n",
    "```python\n",
    "while True:\n",
    "    # sensor polling here\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# time limit for while loop \n",
    "# you can change this\n",
    "duration = 60 \n",
    "\n",
    "start_time = time.time()\n",
    "# keep looping until 60 seconds have expired\n",
    "while (time.time() - start_time) < duration:\n",
    "    #  TODO\n",
    "    #         - get a new packet with sensor data\n",
    "    #         - pretty print the sensor values\n",
    "    #         - wait 0.5 seconds (to make output more manageable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now try re-running the above code and interacting with the robot. Start by pushing the front bumpers down on the robot? Do you see a change in sensor values? \n",
    "\n",
    "Try pressing one of the buttons on the robot. Can the sensors detect this? Where is that data stored?\n",
    "\n",
    "Keep playing around with the robot and looking at how the sensor values change to get some intuition for what they do. \n",
    "\n",
    "\n",
    "#### Example:\n",
    "\n",
    "We've written some code that reads the value of the physical bump sensors at the front of the robot. They are positioned as follows:\n",
    "                                                          _______\n",
    "                                                         /       \\\n",
    "                                            Left Bumper  |       |   Right Bumper \n",
    "                                                         |       |\n",
    "                                                         |       |\n",
    "                                                         \\       /\n",
    "                                                          -------\n",
    "To see what this code does execute the following:\n",
    "\n",
    "Try pressing the physical bumpers and see what happens!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# this loads the staff function demo_physical_bumper\n",
    "from staff_solutions.sensors_demo import demo_physical_bumper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# now we run that function\n",
    "demo_physical_bumper(bot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it's your turn.\n",
    "\n",
    "Let's focus on one group of sensors in particular: the __light bumper sensors__. \n",
    "\n",
    "These sensors are positioned around the robot as follows \n",
    "\n",
    "                                Front Left     Front Right \n",
    "                          \n",
    "                          Left                               Right\n",
    "\n",
    "They use an optical sensor to detect the presence of an object without needing to physically touch it. They're useful for avoiding obstacles and navigation. \n",
    "\n",
    "The output of these sensors is a signal strength between 0 and 4095 - 0 for nothing and 4095 for a strong conviction that there is an object in front of the sensor. The API has also implemented boolean value interpretations of these signals that instead output True or False. You can find both in the sensor packets (go back and inspect them from earlier)\n",
    "\n",
    "We want to do the same thing that the _demo_physical_bumper_ function did - poll the sensors and print the output of these 4 sensors in particular. Write a function to do this below. The function should take in a robot object and a duration and run a loop the prints the (updated) sensor values (both the boolean and the signal strength) for that length of time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def print_output_of_light_bumper_sensors(robot, duration=60):\n",
    "    #  your code here \n",
    "    #\n",
    "    #\n",
    "    # "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's run your code and test it. Try moving your hand in front of the sensors and see if the sensor values changes. \n",
    "\n",
    "If you get an error you will need to go back and debug your code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print_output_of_light_bumper_sensors(bot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important group of sensors on the robot are the cliff sensors. These are positioned like the light bumper sensors \n",
    "                                Front Left     Front Right \n",
    "                          \n",
    "                          Left                               Right\n",
    "\n",
    "and also output signal strengths in the range 4095 - 0.\n",
    "\n",
    "These sensors are used to detect if the robot is at the edge of a cliff (e.g. a staircase). Write a function that is similar to before except reads the boolean and signal strength value for each of these cliff sensors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def print_output_of_cliff_sensors(robot, duration=60):\n",
    "    # your code here \n",
    "    #\n",
    "    #\n",
    "    #"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run your code. To test the sensors push the robot gradually twoard the edge of a table and see if the sensors triger. As before if you get errors you will need to debug your code. The staff will come around and help you if you get stuck."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "print_output_of_cliff_sensors(bot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you finish Part 1 take a 10 minute break. \n",
    "\n",
    "## Part 2 - Putting the Robot in Motion\n",
    "\n",
    "Now for some fun. The robot has two motors and each one powers a wheel. They can be controlled independently of one another. In general we are most concerned about two things - the __velocity__ of the robot and the __direction__ the robot is traveling in. We can control these by setting the robot's speed and turning radius. \n",
    "\n",
    "To start let's just try to drive in a straight line and stop. \n",
    "\n",
    "There are multiple API Calls that we can use to do this. The easiest one is in the Robot class.\n",
    "\n",
    "```python\n",
    "class Robot:\n",
    "\n",
    "    ... \n",
    "    \n",
    "    def setForwardSpeed(self, speed)\n",
    "```\n",
    "\n",
    "Go into the API and look up what the units are for the speed. Also look for the various other ways we can control the robot's speed (in both the Robot class and the \\_Create2 class) \n",
    "\n",
    "Once you've done this let's put the robot in motion.\n",
    "\n",
    "Note that once you set a speed the robot continues with that speed until you tell it otherwise! If you forget to tell it to stop it will just keep going and wreak havoc. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# start robot moving forward slowly\n",
    "bot.setForwardSpeed(100)\n",
    "\n",
    "# let it drive for half a second\n",
    "time.sleep(0.5)\n",
    "\n",
    "# now tell it to stop \n",
    "bot.setForwardSpeed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it is your turn. Write code to have the robot move forward for one second. Stop and then move backward for one second. \n",
    "\n",
    "If you are bold try increasing the speed and see what happens. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another important part of driving the robot will be making it turn!\n",
    "\n",
    "Have a look at the _Robot_ API and figure out what function to call.\n",
    "\n",
    "Fill in and run the code below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# start the robot turning \n",
    "bot.#your code here\n",
    "\n",
    "# wait 0.5 seconds\n",
    "# your code here\n",
    "\n",
    "\n",
    "# stop turning! (don't forget this)\n",
    "# your code here "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We may want to turn while driving. Unfortuantely the Robot API doesn't let us do this so we will need to use the \\_Create2 API instead. Go into the API documentation and look up what the __drive__ method does.\n",
    "\n",
    "\n",
    "When ready play around with the values for VELOCITY and RADIUS in the code below and execute it to see how the robot behavior changes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# CHANGE THESE!\n",
    "VELOCITY = None\n",
    "RADIUS = None\n",
    "\n",
    "# tell the robot to drive!\n",
    "bot.robot.drive(VELOCITY, RADIUS)\n",
    "\n",
    "# let it drive for a second\n",
    "time.sleep(1)\n",
    "\n",
    "# now tell it to stop \n",
    "bot.robot.drive(0, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use this API method to program the robot to make increasingly large circles. You'll need to periodically increate the value of the RADIUS argument to do this!\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's do something more complicated. \n",
    "\n",
    "Program the robot to move around a __square__\n",
    "\n",
    "\n",
    "Have the robot travel for _one second_ at _500 mm/s_ for each edge of the square.\n",
    "\n",
    "\n",
    "Ask the staff if you get stuck!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "#\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we want to know how far the robot has traveled or turned. In general we will never be able to know this for certain because the sensors are noisy. Because of this there will always be uncertainty in the state of the world. \n",
    "\n",
    "Explain to the staff why this might be a problem. Also do you have any ideas on how we can resolve this?\n",
    "\n",
    "In the previous task we asked you to have the robot travel in a square and specified the lengths of the each edge using a time and speed. For example\n",
    "\n",
    "1 seconds * 500 mm/s = 500 mm\n",
    "\n",
    "However the robot has to start and stop moving - it doesn't instantly travel at 500 mm/s. So the length of each edge is actually smaller than that. \n",
    "\n",
    "Thankfully the sensor API gives us a way to learn how far the robot has traveled as measured by the number of rotations of the wheels. The robot keeps track of that and will give us the distance traveled since the last time we asked it (since the last call to get_packet) but capped at a maximum of 32767. \n",
    "\n",
    "Run the following code and talk with your teammate about what is going on.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# keep track of total distance traveled\n",
    "total_distance_traveled = 0\n",
    "bot.robot.get_packet(100)\n",
    "\n",
    "\n",
    "# starting out \n",
    "bot.robot.get_packet(100)\n",
    "print 'distance: '+ str(bot.robot.sensor_state['distance'])\n",
    "print 'angle: '+ str(bot.robot.sensor_state['angle'])\n",
    "\n",
    "\n",
    "# going forward \n",
    "bot.setForwardSpeed(100)\n",
    "time.sleep(0.5)\n",
    "\n",
    "# now tell it to stop \n",
    "bot.setForwardSpeed(0)\n",
    "bot.robot.get_packet(100)\n",
    "print 'distance: '+ str(bot.robot.sensor_state['distance'])\n",
    "print 'angle: '+ str(bot.robot.sensor_state['angle'])\n",
    "total_distance_traveled += bot.robot.sensor_state['distance']\n",
    "time.sleep(1)\n",
    "\n",
    "# now turn \n",
    "bot.setTurnSpeed(100)\n",
    "time.sleep(1)\n",
    "\n",
    "# stop turning\n",
    "bot.setTurnSpeed(0)\n",
    "bot.robot.get_packet(100)\n",
    "print 'distance: '+ str(bot.robot.sensor_state['distance'])\n",
    "print 'angle: '+ str(bot.robot.sensor_state['angle'])\n",
    "total_distance_traveled += bot.robot.sensor_state['distance']\n",
    "time.sleep(1)\n",
    "\n",
    "# go forward\n",
    "bot.setForwardSpeed(100)\n",
    "time.sleep(0.5)\n",
    "\n",
    "# now tell it to stop \n",
    "bot.setForwardSpeed(0)\n",
    "bot.robot.get_packet(100)\n",
    "print 'distance: '+ str(bot.robot.sensor_state['distance'])\n",
    "print 'angle: '+ str(bot.robot.sensor_state['angle'])\n",
    "total_distance_traveled += bot.robot.sensor_state['distance']\n",
    "\n",
    "\n",
    "print '\\n'\n",
    "print '\\n'\n",
    "print 'total distance traveled '+ str(total_distance_traveled)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now rewrite the code to have the robot drive in a square with each edge 1 meter in length. You'll need to keep track of how far the robot has traveled along each edge to do this \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Once you finish Part 2 take a 10 minute break. \n",
    "\n",
    "## Part 3 - Driving By Using The Sensors\n",
    "\n",
    "Now so far we the robot's behavior hasn't depnded on its interaction with the environment. We've essentialy given it static instructions - drive for x seconds. stop. turn for y seconds. In general we want to make our robot's behavior dynamic and have the robot respond as it learns things about its surroundings. This will require us to use the sensors from Part 1 as well as the motion API from Part 2. \n",
    "\n",
    "A word of caution: \n",
    "\n",
    "for the remainder of the workshop we will be using the \"full\" mode of the robot. This disables all safety features. If you tell the robot to go as fast as it can into a wall the robot will do so and the wheels will keep spinning until you tell it to stop. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# we now need to put the bot in full mode\n",
    "bot.robot.full()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just be aware of this and be ready to intervene if your robot gets out of control. To shut off the robot run the following emergency command"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# only run this line in case of emergency\n",
    "bot.robot.stop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 1 - Stopping at the Wall\n",
    "\n",
    "Write code so that your robot slowly advances forward and continues until it detects a wall using the light bumper sensors. Once you hit the wall let the world know by playing a note\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# your code here \n",
    "#\n",
    "#  - start the robot moving forward\n",
    "#  - continually poll the sensors until you detect something\n",
    "#  - upon detection stop the robot \n",
    "#  - and play a note"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now extend your code form the previous problem to make it stop at the way and turn around and go back to where it started. Put your modified code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 2 - Avoiding Falling \n",
    "\n",
    "Place the robot on a table. Have the robot advance forward until it discovers the edge of the table. At this point stop the robot and have it let the world know by playing a note. To do this you will need to use the cliff sensors to detect the edge.\n",
    "\n",
    "Make sure to have a friend ready to catch the robot if it fails!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here\n",
    "#\n",
    "#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Task 3 - Wall Following \n",
    "\n",
    "Now for something more difficult. Position the robot directly facing the wall. The goal is to program the robot  to advance, detect the wall, and then turn and follow it as close as possible to the wall itself. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# your code here \n",
    "# \n",
    "#"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}