Laboratoire 1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "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, obstacle (boîte), ruban adhésif, feuille blanche et carton noir.\n",
    "\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)\n",
    "\n",
    "### Exercice 1 - Feuille de spécifications\n",
    "Cherchez la feuille de spécifications du capteur Sharp 2Y0A02 et trouvez les informations suivantes :\n",
    "1. La plage de mesure du capteur;\n",
    "2. La longueur d’onde du faisceau infrarouge;\n",
    "3. Que ce passe-t-il si le capteur est placé face au soleil ou certaines sources de lumière?"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-09-12T15:53:29.770042Z",
     "start_time": "2024-09-12T15:53:29.459599Z"
    }
   },
   "source": [
    "# Importation des modules\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "from robmob.robot import Robot\n",
    "from robmob.rover.sensors import SharpSensor"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Connexion au robot\n",
    "ip_robot = 'localhost'\n",
    "robot = Robot(ip_robot)\n",
    "robot.connect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": "Il faut ensuite ajouter le capteur Sharp aux capteurs écoutés par le robot."
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "sharp_sensor = SharpSensor()\n",
    "\n",
    "robot.add_sensor(sharp_sensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Par défaut, on sauvegarde un buffer de 100 échantillons. \n",
    "Puisque l'acquisition des données se fait à 100hz, on retrouve dans le buffer de la dernière seconde d'acquisition.\n",
    "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$. \n",
    "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).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    },
    "scrolled": true,
    "tags": []
   },
   "outputs": [],
   "source": [
    "data = sharp_sensor.read_buffer()\n",
    "print(data)\n",
    "\n",
    "print(\"La lecture moyenne est de %0.2f\" % np.average(data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    },
    "tags": []
   },
   "source": [
    "## Exercice 2 - Expérimentation avec le capteur\n",
    "Essayez de placer un objet devant le capteur et de prendre une mesure.\n",
    "1. Quels sont les unités de la mesure? Utilisez la feuille de spécifications pour convertir la mesure en cm.\n",
    "2. Quelle est la plage de valeurs retournées par le capteur?\n",
    "3. Que se passe-t-il si l’objet est trop proche du capteur?\n",
    "4. Que se passe-t-il si l’objet est trop loin du capteur?\n",
    "5. Que ce passe-t-il si vous bloquez le faisceau infrarouge avec votre main devant l'émetteur? Identifiez lequel est l'émetteur et lequel est le récepteur avec la feuille de spécifications.\n",
    "\n",
    "## Exercice 3 - Calibration du capteur\n",
    "\n",
    "Ici, on vous demande de calibrer le capteur de distance.\n",
    "Pour ce faire, vous devrez prendre des mesures de voltage pour plusieurs distances connues.\n",
    "\n",
    "Placez un objet devant le robot de la sorte:\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",
    "### Procédure\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 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-la 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": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# TODO placer ici votre code pour prendre les mesures de distance et de voltage"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# Tableaux de distances et de mesures\n",
    "# Il est important de garder le point (distance = 0, volts = 0)\n",
    "xs = [0]  # Entrez vos distance dans xs\n",
    "zs = [0]  # 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": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "![img](img/Sharp_datasheet.png)\n",
    "\n",
    "### Partie 2 Testez la courbe de calibration\n",
    "NOTE : Il y a un bug sur Jupyter depuis 2020, les tableaux ne sont pas correctement affichés.\n",
    "Pour résoudre le problème il suffit de rajouter une lettre ou un mot au tout début du tableau (première ligne première colonne).\n",
    "\n",
    "Maintenant que vous avez une table de calibration, vous pouvez faire un télémètre infrarouge bon marché!\n",
    "Pour cet exercice, vous devrez convertir une mesure de voltage du capteur (en Volt) en une distance (en cm).\n",
    "Il s’agit ici d’inverser la fonction de capteur pour avoir $x=f^{-1}_{capteur}(z)$.\n",
    "Or, comme la fonction $f^{-1}_{capteur}(x)$ n’est pas bijective, l’inverse n’existe pas.\n",
    "Il vous faut donc scinder en deux votre table de calibration, de sorte que la première table ne contient que les données de voltage 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": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "split_index = 0  # 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": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "À l'aide de scipy, on peut maintenant faire une fonction d'interpolation pour chacune des deux sections bijectives de la fonction.\n",
    "Utilisez la fonction [interp1d](https://docs.scipy.org/doc/scipy/reference/generated/scipy.interpolate.interp1d.html) pour interpoler les valeurs de voltage en distance.\n",
    "En d'autres mots, vous aurez deux fonctions $f_{proche}(z)$ et $f_{loin}(z)$ qui convertissent les valeurs de voltage en distance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "from scipy.interpolate import interp1d\n",
    "\n",
    "# Fonction f(volts) = cm\n",
    "fn_proche = ...  # TODO\n",
    "fn_loin = ...  # TODO \n",
    "\n",
    "fn_proche(1.5)\n",
    "fn_loin(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "# 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",
    "\n",
    "# TODO definir les valeurs possibles de voltage pour la branche proche\n",
    "borne_inferieure_proche = 0.0\n",
    "borne_superieure = ...\n",
    "\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",
    "# TODO definir les valeurs possibles de voltage pour la branche loin\n",
    "borne_inferieure_loin = ...\n",
    "\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": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Exercice 4 - Conversion de la mesure en distance\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.\n",
    "Notez que comme la fonction n'est pas bijective, la fonction `volts_to_cm` devra retourner plusieurs valeurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "def volts_to_cm(volts):\n",
    "    # TODO\n",
    "    return volts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "volts_to_cm(2.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "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": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "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('Mesure: ', volts, 'V')\n",
    "    print('Distance estimee', cm, 'cm')\n",
    "    time.sleep(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "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",
    "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)"
   ]
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "# TODO code pour prendre les mesures de la réponse transversale du capteur"
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "positions_horizontale = [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",
    "# TODO remplir les données\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.8, 1., 0.8,\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]\n",
    "\n",
    "plt.plot(positions_horizontale, volts)"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## Exercice 5 - Analyse de la réponse transversale\n",
    "1. Que ce passe-t-il avec la mesure de voltage lorsque la boîte est déplacée latéralement?\n",
    "2. Quel est l'impact sur le bruit de la mesure lorsque la boîte est déplacée latéralement? Utilisez `np.std` pour calculer l'écart-type des mesures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "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": {
    "pycharm": {
     "name": "#%%\n"
    },
    "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 (ipykernel)",
   "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.10.5"
  },
  "widgets": {
   "state": {},
   "version": "1.1.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}