Laboratoire 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Laboratoire 1\n",
    "## Capteurs infrarouges sharp\n",
    "**Matériel nécessaire :** règle de 1 mètre en aluminium, règle de 30 centimètres, boite (de Kinect), ruban adhésif,\n",
    "feuille blanche et carton noir.\n",
    "![img](img/Sharp_2Y0A02.jpg)\n",
    "\n",
    "### Partie 1 Courbe de calibration d’un capteur\n",
    "\n",
    "Dans cette première partie du laboratoire, vous allez voir comment on peut calibrer un capteur, particulièrement s’il est nonlinéaire. L’idée de base consiste à placer une cible à différents endroits ($x$ en cm), et à mesurer la sortie du capteur ($z$ en Volt). Ainsi, vous allez échantillonner manuellement la fonction $z=f_{capteur}(x)$. Bien que le manufacturier vous fournisse une telle fonction (voir la figure suivante), les aléas de la fabrication font en sorte que chaque capteur est différent. Le capteur à utiliser est celui à longue portée (Sharp 2Y0A02).\n",
    "\n",
    "![img](img/Sharp_datasheet.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Importation des modules\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from robmob.robot import Robot\n",
    "from robmob.sensors import SharpSensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modifiez la valeur de `ip_robot` selon le robot qui vous a été assigné."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Connexion au robot\n",
    "ip_robot = '192.168.0.109'\n",
    "robot = Robot(ip_robot)\n",
    "robot.connect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Il faut ensuite ajouter le capteur Sharp aux capteurs écoutés par le robot. Il y a deux capteurs Sharp sur le robot, un longue distance et un courte distance. Pour cette partie du laboratoire, veillez utiliser le capteur longue distance. Le capteur longue distance est le capteur infra-rouge qui est allongé. L'id du capteur (0 ou 1) est indiqué par une étiquette sur le cable sous le capteur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sharp_sensor_id = 0\n",
    "sharp_sensor = SharpSensor(sharp_sensor_id)\n",
    "\n",
    "robot.add_sensor(sharp_sensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Par défaut, on sauvegarde un buffer de 100 échatillons. Puisque l'acquisition des données se fait à 50hz, on retrouve dans le buffer les deux dernières secondes d'acquisition. Détail très important : les mesures que vous faites vont être bruitées, ce qui signifie qu’en réalité c’est plutôt $z=N(f_{capteur}(x), \\sigma_z^2)$ que vous capturez avec le convertisseur analogue-numérique, où $N(\\mu, \\sigma^2)$ est une distribution normale centrée sur $\\mu$ avec variance $\\sigma^2$. Pour réduire l’erreur due au bruit, les mesures seront moyennées avec la fonction numpy [average](http://docs.scipy.org/doc/numpy/reference/generated/numpy.average.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "data = sharp_sensor.read_buffer()\n",
    "print(data)\n",
    "print(\"La lecture moyenne est de %0.2f volts\" % np.average(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Expérimentations\n",
    "\n",
    "![img](img/Sharp_exp1.png)\n",
    "\n",
    "Remarquez que le capteur est placé de façon verticale sur la tourelle du robot, à une\n",
    "distance minimum de 10 cm de la table, afin de limiter les mauvaises réflexions qui pourraient\n",
    "fausser les valeurs. \n",
    "\n",
    "1. Placez l’extrémité 0 cm de la règle métallique vis-à-vis le capteur infrarouge. Au besoin, utilisez du ruban adhésif pour immobiliser la règle sur la table (ça évitera bien des frustrations). \n",
    "2. Utilisez une boîte en carton comme cible (genre boîte vide d’une Kinect recouverte d’une feuille blanche) que vous placez aux positions telles que dans la table ici-bas. \n",
    "3. Notez la valeur moyenne de voltage $z$ à chaque distance $x$. Pour obtenir la valeur de $z$, évaluez la cellule plus haut.\n",
    "4. Après avoir pris toutes les données, tracez la courbe du capteur. Comparez-là visuellement avec la figure du manufacturier. Prenez le temps d'observer la non-linéarité de la réponse du capteur, ainsi que le fait qu’elle n’est pas une fonction bijective.\n",
    "\n",
    "Distance ($x$) | Voltage ($z$)\n",
    ":------------: | :-----------:\n",
    "5              | ??\n",
    "7.5            | ??\n",
    "10             | ??\n",
    "12.5           | ??\n",
    "15             | ??\n",
    "17.5           | ??\n",
    "20             | ??\n",
    "25             | ??\n",
    "30             | ??\n",
    "35             | ??\n",
    "40             | ??\n",
    "45             | ??\n",
    "50             | ??\n",
    "60             | ??\n",
    "70             | ??\n",
    "80             | ??\n",
    "90             | ??\n",
    "100            | ??\n",
    "110            | ??\n",
    "120            | ??\n",
    "130            | ??\n",
    "140            | ??\n",
    "150            | ??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "xs = [5,    7.5,  10,   12.5, 15,   17.5, 20,   25,   30,   35,   40,   45,   50,   60,   70,\n",
    "      80,   90,   100,  110,  120,  130,  140,  150]\n",
    "\n",
    "zs = [0.00, 0.00, 0.00, 0.00, 0.00, 1.00, 2.50, 2.00, 1.50, 1.20, 1.12, 1.10, 0.80, 0.70, 0.00,\n",
    "      0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00]  #Entrez vos vraies mesures dans le vecteur zs\n",
    "\n",
    "plt.scatter(xs, zs)\n",
    "plt.plot(xs, zs)\n",
    "plt.gca().set_xlim(left=0)\n",
    "plt.gca().set_ylim(bottom=0)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![img](img/Sharp_datasheet.png)\n",
    "\n",
    "### Partie 2 Testez la courbe de calibration\n",
    "\n",
    "Maintenant que vous avez une table de calibration, vous pouvez faire un télémètre infrarouge bon\n",
    "marché! Pour cet exercice, vous devrez convertir une mesure de voltage du capteur (en Volt) en une\n",
    "distance (en cm). Il s’agit ici d’inverser la fonction de capteur pour avoir $x=f^{-1}_{capteur}(z)$. Or, comme\n",
    "la fonction $f^{-1}_{capteur}(x)$ n’est pas bijective, l’inverse n’existe pas. Il vous faut donc scinder en deux\n",
    "votre table de calibration, de sorte que la première table ne contient que les données de voltage\n",
    "croissant avec la distance, et la deuxième table les données de voltage décroissant avec la distance.\n",
    "\n",
    "Par exemple, si vous avez les données suivantes :\n",
    "\n",
    "\n",
    "   |      |      |      |     |      |      |      |      |      |      |      |      |      |     |\n",
    "-- | ---- | ---- | ---- | --- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ----\n",
    "**x**  | 5    | 10   | 15   | 20  | 25   | 30   | 40   | 50   | 60   | 80   | 100  | 120  | 140  | 150\n",
    "**z** | 1.5  | 2.2  | 2.5  | 3   | 2.7  | 2.4  | 2.2  | 1.9  | 1.7  | 1.6  | 1.5  | 1.4  | 1.3  | 1.25\n",
    "\n",
    "\n",
    "La première table de calibration contiendra les valeurs suivantes\n",
    "\n",
    "   |      |      |      |     |\n",
    "-- | ---- | ---- | ---- | --- |\n",
    "**x**  | 5    | 10   | 15   | 20 \n",
    "**z** | 1.5  | 2.2  | 2.5  | 3 \n",
    "\n",
    "Et la deuxième table de calibration sera\n",
    "\n",
    "   |      |      |      |      |      |      |      |      |      |      |     |\n",
    "-- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | --- |\n",
    "**x**  | 20 |  25   | 30   | 40   | 50   | 60   | 80   | 100  | 120  | 140  | 150\n",
    "**z** | 3   |2.7  | 2.4  | 2.2  | 1.9  | 1.7  | 1.6  | 1.5  | 1.4  | 1.3  | 1.25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "split_index = 6 # Ceci est un exemple, veillez choisir votre index, cette valeur était \n",
    "                # le premier index de la deuxième table de calibration. \n",
    "                # NOTE: les arrays numpy sont indexés à 0.\n",
    "        \n",
    "split_value_volt = zs[split_index]\n",
    "\n",
    "xs_proche = xs[0:split_index + 1] #Séparation de l'array en 2 à split_index\n",
    "xs_loin = xs[split_index:]\n",
    "\n",
    "zs_proche = zs[0:split_index + 1]\n",
    "zs_loin = zs[split_index:]\n",
    "\n",
    "print(\"La séparation entre les deux fonctions se fait à %0.2f Volts\\n\" % split_value_volt)\n",
    "print(\"Proche\\n\\tx:\", xs_proche, \"\\n\\tz:\", zs_proche)\n",
    "print(\"Loin\\n\\tx:\", xs_loin, \"\\n\\tz:\", zs_loin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "À l'aide de scipy, on peut maintenant faire une fonction d'interpolation pour chacune des deux sections bijectives de la fonction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from scipy.interpolate import interp1d\n",
    "\n",
    "fn_proche = interp1d(zs_proche, xs_proche)\n",
    "fn_loin = interp1d(zs_loin, xs_loin)\n",
    "\n",
    "# Affichons les fonctions\n",
    "# np.linspace prend deux arguments, qui sont les bornes inférieures \n",
    "# et supérieures des valeurs que vous voulez interpoler. Évidemment, \n",
    "# ces valeurs doivent être à l'intérieur de la courbe de calibration de \n",
    "# votre capteur...\n",
    "borne_superieure = 2.5\n",
    "\n",
    "borne_inferieure_proche = 0.0\n",
    "domaine_proche = np.linspace(borne_inferieure_proche, borne_superieure)\n",
    "codomaine_proche = fn_proche(domaine_proche)\n",
    "plt.plot(domaine_proche, codomaine_proche, color='red', label='Fonction proche')\n",
    "\n",
    "borne_inferieure_loin = 0.0\n",
    "domaine_loin = np.linspace(borne_inferieure_loin, borne_superieure)\n",
    "codomaine_loin = fn_loin(domaine_loin)\n",
    "plt.plot(domaine_loin, codomaine_loin, color='blue', label='Fonction loin')\n",
    "\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Exercice\n",
    "Écrivez la fonction suivante qui convertie une lecture en Volts en cm en utilisant la fonction `fn_proche` ou `fn_loin` selon la mesure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# TODO\n",
    "def volts_to_cm(volts):\n",
    "    return volts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La boucle suivante imprime en temps réel la distance entre le capteur Sharp et l'objet en utilisant la fonction que vous venez de définir. Pour arrêter la boucle, appuyez sur le *stop* dans l'entête du notebook ou faites deux fois la touche *i*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import time\n",
    "from IPython.display import clear_output\n",
    "\n",
    "while True:\n",
    "    volts = sharp_sensor.peek_data()\n",
    "    cm = volts_to_cm(volts)\n",
    "    clear_output(wait=True)\n",
    "    print(volts)\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vous pourrez ainsi voir votre télémètre infrarouge en action en temps réel pendant que vous\n",
    "déplacez la cible! Regardez voir si la mesure de distance à l’écran correspond bien à la position de\n",
    "la boite indiquée par la règle. Vous devriez remarquer que l’erreur est plus grande lorsque la cible\n",
    "est loin. Vous devriez remarquer que les valeurs fluctuent beaucoup plus quand la cible est loin (120\n",
    "cm) que lorsque la cible est proche (30 cm).\n",
    "\n",
    "\n",
    "### Partie 3 Réponse transversale du capteur\n",
    "\n",
    "> **NOTES**\n",
    "1. La taille du faisceau infrarouge augmente en fonction de la distance par rapport au capteur;\n",
    "2. L’intensité lumineuse diminue au fur et à mesure qu’on s’éloigne du centre du rayon.\n",
    "\n",
    "\n",
    "Pour observer la réponse transversale du capteur, il faut déplacer une petite boîte rectangulaire de 8-\n",
    "10 cm de largeur à une distance de 70 cm du capteur, perpendiculairement à l’axe du faisceau. Il\n",
    "faut qu’à la position de départ de la boîte, le faisceau ne soit pas en contact avec la boîte (voltage\n",
    "très bas). Identifiez cette position de départ en regardant le voltage lorsque vous déplacez la boîte de\n",
    "façon latérale : quand il commence à monter, c’est que la boîte pénètre dans le faisceau. Déplacez\n",
    "cette boîte perpendiculairement à l’axe du faisceau par incréments de 0.5 cm. Assurez-vous que la\n",
    "règle perpendiculaire soit bien fixée à la table avec du scotch tape pour ne pas qu’elle se déplace\n",
    "pendant la saisie des données. Que pouvez-vous conclure de l'apparence de la boîte carrée, telle que\n",
    "perçue par ce capteur?\n",
    "\n",
    "![img](img/Sharp_exp2.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "positions = [0.0,  0.5,  1.0,  1.5,  2.0,  2.5,  3.0,  3.5,  4.0,  4.5,  5.0,  5.5,  6.0,  6.5,  7.0,\n",
    "             7.5,  8.0,  8.5,  9.0,  9.5,  10.0, 10.5, 11.0, 11.5, 12.0, 12.5, 13.0, 13.5]\n",
    "\n",
    "volts     = [0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, \n",
    "             0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00] #TODO\n",
    "\n",
    "plt.plot(positions, volts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Partie 4 Dimension de la cible\n",
    "\n",
    "Placez un objet de faible largeur (1-2 cm) à 30, 40, 60 et 90 cm du capteur. En\n",
    "déplaçant la cible transversalement, trouvez la valeur maximale du voltage (qui correspondra à la\n",
    "cible placée au centre du faisceau). Comparez les valeurs de voltage de ce pic à celles\n",
    "préalablement obtenues avec la grosse boîte de carton pour les mêmes distances. D'après vous,\n",
    "pourquoi les valeurs sont-elles différentes? En particulier, y aura-t-il une erreur d’estimation de la\n",
    "distance pour ces petites cibles?\n",
    "\n",
    "\n",
    "Position ($x$) | Voltage ($z$)\n",
    ":------------: | :-----------:\n",
    "30             | ??\n",
    "40             | ??\n",
    "60             | ??\n",
    "90             | ??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "max_volts = 0.0\n",
    "\n",
    "while True:\n",
    "    volts = sharp_sensor.peek_data()\n",
    "    clear_output(wait=True)\n",
    "    max_volts = volts if volts > max_volts else max_volts\n",
    "    print(\"Voltage max: %0.2f\" % max_volts)\n",
    "    time.sleep(0.5)"
   ]
  }
 ],
 "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
}