Laboratoire 0.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Laboratoire 0: Introduction aux outils"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bienvenue dans les laboratoires de robotique mobile! Cette séance a pour objectif de vous familiariser avec les outils que nous utiliserons tout au long de la session. Si vous voyez ce message, c'est que vous avez déjà réussi à lancer jupyter. Bien! Voyons maintenant comment les notebooks fonctionnent."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter et IPython\n",
    "\n",
    "[Jupyter](http://jupyter.org/) est une plate-forme interactive qui permet de combiner texte et code dans un notebook, comme celui que vous voyez présentement. Le back-end que nous utiliserons est [IPython](https://ipython.org/), ce qui veut dire que nous pouvons entrer du code python dans une cellule de la présente page."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('En sélectionnant cette cellule puis en appuyant sur SHIFT+Enter, vous exécuterez du code python.')\n",
    "\n",
    "for i in range(10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notez qu'il est aussi possible d'exécuter une cellule en appuyant sur un bouton de la barre d'outils.\n",
    "\n",
    "Pendant la session, on pourra donc communiquer avec le robot à travers Jupyter. Nous avons déjà écrit une librarie qui permet de communiquer avec le robot. Nous vous fournirons des exemples de code pour établir la communication, puis vous aurez à analyser les données récoltées."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Jupyter: trucs et astuces\n",
    "\n",
    "Mais avant de commencer, quelques informations à propos de Jupyter. Vous pouvez arrêter l'exécution d'une cellule en sélectionnant la cellule puis en appuyant sur `i` deux fois (le `i` est pour _interrupt_). Pratique quand on lance une boucle infinie par accident!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Lancez l'exécution de cette cellule puis arrêtez-là en utilisant \"i i\".\n",
    "\n",
    "while True:\n",
    "    i = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Une autre façon d'arrêter l'exécution du code est de sélectionner, dans le menu du haut, `Kernel >> Interrupt`. Remarquez aussi les autres options de ce menu, qui vous seront certainement très utiles. `Kernel >> Restart` relance le back-end python: toutes les variables que vous aviez assigné avant vont disparaître. En cas de problème, c'est toujours une bonne idée de relancer le back-end puis de ré-exécuter les cellules qui nous intéressent avant de paniquer.\n",
    "\n",
    "Finalement, une liste plus complète des raccourcis clavier est disponible [ici](https://sowingseasons.com/blog/reference/2016/01/jupyter-keyboard-shortcuts/23298516)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interagir avec le robot\n",
    "\n",
    "En premier lieu assurez vous que votre ordinateur est connecté au même réseau wifi que les robots. La SSID du réseau est `glo7021_24ghz` ou bien `glo7021_5ghz`. Le mot de passe du réseau est `unchevalblanc`.\n",
    "\n",
    "Il est maintenant temps de nous connecter au robot. La logique de connexion sera expliquée plus en détail cette fois-ci. Dans les prochains laboratoires, nous vous fournirons le code sans explications.\n",
    "\n",
    "Importons d'abord la classe qui nous permet de communiquer avec le robot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from robmob.robot import Robot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il faut ensuite fournir l'IP du robot qui vous a été fourni. L'IP est sur une étiquette collée au robot. Avec l'IP, on peut créer une instance de la classe `Robot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "robot_ip = '192.168.0.100' # Remplacez cette ip par l'ip de votre robot\n",
    "robot = Robot(robot_ip)\n",
    "robot.connect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant que nous sommes connectés au robot, tentons de communiquer avec un de ses senseurs. Débutons avec un capteur infra-rouge. Comme il y a deux capteurs infra-rouge sur le robot, il faut spécifier l'ID du senseur avec lequel on veut communiquer (`0` ou `1`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from robmob.sensors import SharpSensor\n",
    "\n",
    "sensor = SharpSensor(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, la ligne la plus importante. On doit ajouter la variable `sensor` dans la collection des senseurs que notre robot « écoute ». Ça revient à dire au robot de capturer les données du capteur infra-rouge, et de les ranger dans l'instance `sensor` que nous avons créé."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "robot.add_sensor(sensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Au moment où vous exécutez cette ligne, les données partent du robot vers votre machine. Dans le cas du capteur infra-rouge le flux de données est assez léger, mais quand nous jouerons avec des capteurs plus sophistiqués, le wifi sera mis à l'épreuve. Tentez de garder cela en tête au cours de la session!\n",
    "\n",
    "L'instance de `SharpSensor` contient un buffer qui se fait remplir par `robot`. Jetons-y un coup d'oeil. `SharpSensor.peek_data()` nous retourne la dernière donnée qui nous a été envoyée par le robot. Si vous l'exécutez plusieurs fois vous aurez de valeurs différentes.\n",
    "\n",
    "> **PROTIP** Appuyez sur CTRL-Enter (au lieu de SHIFT-Enter) pour exécuter une même cellule plusieurs fois de suite (sans que la prochaine cellule ne soit sélectionnée)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sensor.peek_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sensor.read_buffer()` retourne les `sensor.buffer_size` dernières données."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print('Voici les ' + str(sensor.buffer_size) + ' dernières données:')\n",
    "sensor.read_buffer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **PROTIP** Comme le capteur infra-rouge a une fréquence d'acquitision très rapide, le buffer se remplit rapidement. D'autres capteurs (comme la kinect) ne sont pas aussi rapides, et il se peut que le buffer soit vide si vous exécutez cette fonction plusieurs fois de suite. Il suffira alors de patienter un peu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graphiques avec pyplot\n",
    "\n",
    "On peut maintenant faire un graphique avec ces données! Importons d'abord un module qui nous permet de faire des graphiques: `matplotlib.pyplot`. Ce module se comporte de façon très similaire à MATLAB. Vous trouverez un tutoriel pour pyplot [ici](http://matplotlib.org/users/pyplot_tutorial.html). Rechercher \"How to ... pyplot\" dans google reste l'outil le plus utile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ici on indique à jupyter qu'il devrait afficher les graphiques dans le notebook, au lieu de simplement nous retourner leur adresse mémoire..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, collectons les données, puis affichons-les!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "data = sensor.read_buffer()\n",
    "plt.plot(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Améliorons ce graphique avec un titre et des axes. Ce genre de code vous sera utile tout au long de la session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "figure = plt.figure()\n",
    "plt.plot(data)\n",
    "\n",
    "figure.suptitle('Capteur infra-rouge')\n",
    "plt.xlabel('Temps')\n",
    "plt.ylabel('Force du signal (V)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous savez maintenant faire des interactions avec votre base robotique! Si il vous reste du temps, vous pouvez explorer d'autres possibilités en ouvrant le notebook `Controller.ipynb`. Bonne session!"
   ]
  }
 ],
 "metadata": {
  "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.5.3"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}