Capteur_de_température_avec_ESP8266_micropython_et_un_TMP102.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Introduction\n",
    "\n",
    "Les objets connectés sont à la mode. \n",
    "On les trouve dans un très grand nombre d'applications, allant des capteurs de températures, aux pesées-personne en passant par les montres. \n",
    "Dans cet article, nous allons nous intéresser à la conception un capteur de température connecté. \n",
    "Nous utiliserons un ESP8266 sous micropython et un GYTMP102. \n",
    "\n",
    "## ESP8266\n",
    "\n",
    "<img src=\"https://github.com/vfreysz/TMP102_micropython/blob/master/Image/NodeMCU_DEVKIT_1.0.jpg?raw=true\" />\n",
    "\n",
    "Wikipedia l'introduit de la manière suivante: \n",
    "> L’ESP8266 est un circuit intégré à microcontrôleur avec connexion WiFi développé par le fabricant chinois Espressif. En août 2014, les passionnés d’électronique commencent à s’intéresser à la version ESP-01 de ce circuit intégré produite par une entreprise tierce, AI-Thinker. Celui-ci, de taille réduite, permet de connecter un microcontrôleur à un réseau WiFi et d’établir des connexions TCP/IP avec des commandes Hayes. La traduction progressive de la documentation (à l'origine uniquement en chinois) motivée par le bas prix du circuit a permis le développement d'une communauté de développeurs et de passionnés de l'ESP8266.\n",
    "\n",
    "Si je devais le résumé rapidement c'est un arduino en plus puissant et moins cher avec le wifi intégré, mais un nombre de GPIO moins important. \n",
    "Du fait de son hardware plus puissant, il a permis la communauté de porter de nombreux langages sur ce microcontrôleur:\n",
    "\n",
    "- Avec des scripts Lua, interprétés ou compilés, avec le firmware NodeMCU\n",
    "- En C++, avec l’IDE Arduino\n",
    "- En JavaScript, avec le firmware Espruino\n",
    "- En MicroPython, avec le firmware MicroPython\n",
    "- En C, avec le SDK d’Espressif\n",
    "- En C, avec le SDK esp-open-sdk3 basé sur la chaîne de compilation GCC\n",
    "\n",
    "## Micropython\n",
    "\n",
    "Dans cet article nous utiliserons <a href=\"https://micropython.org/\">Micropython</a>, qui est une implémentation logicielle du langage de programmation Python 3, écrit en C, et optimisé pour fonctionner sur des microcontrôleurs. Dans cet article nous utiliserons la version 1.9.2. \n",
    "\n",
    "## GYTMP102\n",
    "\n",
    "Le GYTMP102 est un capteur de température très abordable, basé sur le TMP102 avec une précision de 0,5°C et qui communique l'information via une interface I2C. \n",
    "Des photos du capteur se trouvent ci-dessous:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div id=\"select\">\n",
    "  <a title=\"TMP102 Dessus\"><img src=\"https://github.com/vfreysz/TMP102_micropython/blob/master/Image/tmp102_1.jpg?raw=true\" style=\"width: 50%\" alt=\"alt1\"></a>\n",
    "  <a title=\"TMP102 Dessous\"><img src=\"https://github.com/vfreysz/TMP102_micropython/blob/master/Image/tmp102_2.jpg?raw=true\" style=\"width: 50%\" alt=\"alt1\"></a>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Connecter la sonde et le microcontrôleur\n",
    "\n",
    "Pour connecter la sonde et le microcontrôleur, nous allons utiliser l'I2C qui est un bus informatique très utilisé. \n",
    "\n",
    "Wikipedia l'introduit de la manière suivante: \n",
    "> I2C (signifie : Inter-Integrated Circuit, en anglais) est un bus informatique qui a émergé de la « guerre des standards » lancée par les acteurs du monde électronique. Conçu par Philips pour les applications de domotique et d’électronique domestique, il permet de relier facilement un microprocesseur et différents circuits, notamment ceux d’un téléviseur moderne : récepteur de la télécommande, réglages des amplificateurs basses fréquences, tuner, horloge, gestion de la prise péritel, etc.\n",
    "\n",
    "Physiquement, il comprend 2 fils: SCL et SDA, respectivement les lignes d'horloge et de données qu'il va nous falloir connecter au microcontrôleur. \n",
    "\n",
    "Pour l'ESP8266 sous micropython et comme expliqué dans la <a href=\"http://docs.micropython.org/en/latest/esp8266/esp8266/quickref.html#i2c-bus\">documentation</a>, le pilote I2C est implémenté de manière logiciel, fonctionne sur toutes les broches et est accessible via la classe machine.I2C.\n",
    "\n",
    "Ci-dessous une représentation de l'ESP8266 avec les caractéristiques des GPIO et surtout leurs numéros qu'il nous faudra connaitre pour spécifier l'interface i2c."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://github.com/vfreysz/TMP102_micropython/blob/master/Image/esp8266_devkit_horizontal-01.png?raw=true\" alt=\"Drawing\" style=\"width: 700px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maintenant, il nous faut savoir comment communiquer avec notre capteur, adresses, fréquence, etc. Toutes les informations nécessaires sont en général disponibles dans la documentation du capteur. Pour le capteur qui nous intéresse elle se trouve <a href=\"http://www.ti.com/lit/ds/symlink/tmp102.pdf\">ici</a>. \n",
    "\n",
    "Avant d'aller plus loin, vérifions que notre notebook est bien connecté à l'ESP8266. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le microcontroleur est connecté au kernel\r\n"
     ]
    }
   ],
   "source": [
    "print(\"Le microcontroleur est connecté au kernel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On importe les modules pour crée une interface I2C."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "from machine import Pin, I2C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On connect le capteur. SCL est connecté sur le GPIO 14 et SDA sur le GPIO 12.\n",
    "\n",
    "<img src=\"https://github.com/vfreysz/TMP102_micropython/blob/master/Image/Connections.jpg?raw=true\" alt=\"Drawing\" style=\"width: 700px;\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On crée une interface I2C sur les GPIO ou nous avons connecté le capteur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "i2c = I2C(scl=Pin(14), sda=Pin(12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On scanne l'interface i2c pour connaitre les adresses des objets présents."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "l'adresse est: 72\r\n"
     ]
    }
   ],
   "source": [
    "#On regarde les adresses possibles\n",
    "adresse = i2c.scan()\n",
    "if len(adresse) == 1:\n",
    "    print(\"l'adresse est:\", adresse[0])\n",
    "else:\n",
    "    print(\"il y a plusieurs objets sur le bus i2c\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La <a href=\"http://www.ti.com/lit/ds/symlink/tmp102.pdf\">documentation</a> nous explique qu'il y a deux modes. Un mode normal sur 12 bits et un mode étendu sur 13 bits pour mesurer des températures supérieures à 128°C. \n",
    "Nous nous intéresserons au mode normal. \n",
    "\n",
    "Nous allons interroger le capteur et lire les 2 premiers bytes (1 bytes = 1 octet = 8 bits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nous avons donc deux bytes: b'\\x18\\x90'\r\n"
     ]
    }
   ],
   "source": [
    "#Nombre de bytes à lire\n",
    "nb_bytes = 2\n",
    "#On stocke les bytes dans 'reg'\n",
    "reg = i2c.readfrom(adresse[0], nb_bytes)\n",
    "print(\"Nous avons donc deux bytes:\",reg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "D'aprés la <a href=\"http://www.ti.com/lit/ds/symlink/tmp102.pdf\">documentation</a>, le premier byte est le \"most significant byte\" (MSB), le deuxieme est le \"less significant byte\" (LSB)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MSB: 0b11000 LSB: 0b10010000\r\n"
     ]
    }
   ],
   "source": [
    "#Byte 1 is the most significant byte (MSB)\n",
    "MSB = reg[0]\n",
    "#Byte 2 is the less significant byte (LSB)\n",
    "LSB = reg[1]\n",
    "print(\"MSB:\",bin(MSB),\"LSB:\",bin(LSB))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons regarder si la température est négative. \n",
    "Pour que la température soit négative, il faut que le 1er bit de MSB soit égal à 1. \n",
    "Pour tester le 1er bit, on décale MSB de 7 bits sur la droite. Tous les nouveaux bits qui apparaissent valent 0.\n",
    "Nous aurons donc la valeur 0 si le 1er bit vaut 0 et la valeur 1 si le 1er bit vaut 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Température est négative: False\r\n"
     ]
    }
   ],
   "source": [
    "negative = (MSB >> 7) == 1\n",
    "print(\"Température est négative:\",negative)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Température positive\n",
    "\n",
    "Nous voulons maintenant connaitre la valeur de la température. Pour ce faire, nous devons tout d'abord concaténer les 12 bits qui nous intéressent. Nous avons récupéré 2 bytes (octets) soit 16 bits. Pour le mode normal sur 12 bits la <a href=\"http://www.ti.com/lit/ds/symlink/tmp102.pdf\">documentation</a>\n",
    "nous explique qu'il faut tous les bits de MSB et les 4 premiers de LSB. \n",
    "Pour ce faire, nous allons prendre le premier byte et décaler de 8 bits \"vers la gauche\" de manière à pouvoir lui ajouter LSB. \n",
    "Nous ajouterons LSB et nous décalerons les 16 bits de 4 bits \"vers la droite\" de manière à ne tenir compte que des 12 bits qui nous intéressent. Il faut ensuite convertir les 12 bits en chiffre décimal (ce que python fait automatiquement), et enfin  multiplier ce chiffre par la résolution (0.0625) pour avoir la température. \n",
    "\n",
    "Regardons comment cela se formalise:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24.5625\r\n"
     ]
    }
   ],
   "source": [
    "bits_16 = (MSB << 8) + LSB\n",
    "bits_12 = bits_16 >> 4\n",
    "temperature = bits_12 * 0.0625\n",
    "print(temperature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Que l'on peut écrire de manière plus concise !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24.5625\r\n"
     ]
    }
   ],
   "source": [
    "print((((MSB << 8) | LSB) >> 4) * 0.0625)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Température négative\n",
    "\n",
    "Ne pouvant pas faire de mesure de température négative facilement en cette période de l'année, nous allons utiliser les 12 bits codant la température -25°C dans la <a href=\"http://www.ti.com/lit/ds/symlink/tmp102.pdf\">documentation</a>. Les 12 bits encodant -25°C sont les suivants:'111001110000'. \n",
    "Pour décoder une température négative, il faut récupérer le complément, lui ajouter 1,  puis le multiplier par la résolution. \n",
    "Construire le complément consiste à remplacer les 1 par 0 et les 0 par 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Le complement est: 000110001111\r\n"
     ]
    }
   ],
   "source": [
    "moins_25 = '111001110000'\n",
    "complement_moins_25 = ''\n",
    "for i in range(len(moins_25)):\n",
    "    if moins_25[i] == '1':\n",
    "        complement_moins_25 = complement_moins_25 + '0'\n",
    "    else:\n",
    "        complement_moins_25 = complement_moins_25 + '1'\n",
    "print('Le complement est:', complement_moins_25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la température est: -25.0\r\n"
     ]
    }
   ],
   "source": [
    "t_m25 = int(complement_moins_25, 2) + 1\n",
    "t_m25 *= -0.0625\n",
    "print('la température est:', t_m25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La méthode que nous venons d'appliquer est intéressante d'un point de vue pédagogique, mais peu efficient. \n",
    "Mais nous pouvons arriver au même résultat de manière beaucoup plus efficace."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "la température est: -25.0\r\n"
     ]
    }
   ],
   "source": [
    "nb_bits = 12\n",
    "moins_25_int = int(moins_25, 2)\n",
    "complement_moins_25 = moins_25_int - (1 << nb_bits)\n",
    "t_m25 = complement_moins_25 * 0.0625\n",
    "print('la température est:', t_m25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# La fonction finale\n",
    "\n",
    "Nous construisons une fonction qui effectue toutes les étapes que nous venons de détailler:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": []
    }
   ],
   "source": [
    "def temperature_tmp102(bus,adresse):\n",
    "    nb_bytes = 2 #nb bytes a lire\n",
    "    nb_bits = 12 #nb bits encodage température\n",
    "    reg = bus.readfrom(adresse, nb_bytes) #lecture des bytes\n",
    "    MSB, LSB = reg[0], reg[1]\n",
    "    negative = (MSB >> 7) == 1 #test température négative\n",
    "    t_12_bits = (((MSB << 8) | LSB) >> 4) #récupération des 12bits de la température\n",
    "    if negative == True:\n",
    "        t_12_bits = t_12_bits - (1 << nb_bits)\n",
    "    temperature = t_12_bits * 0.0625\n",
    "    return temperature"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nous allons tester notre fonction en mesurant la température chaque seconde pendant 10s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[24.625, 24.5625, 24.5625, 24.5625, 24.5625, 24.5625, 24.5625, 24.5625, 24.5625, 24.5625]\r\n"
     ]
    }
   ],
   "source": [
    "import utime\n",
    "\n",
    "bus = I2C(scl=Pin(14), sda=Pin(12))\n",
    "add = 72\n",
    "temperature = []\n",
    "for i in range(10):\n",
    "    temperature.append(temperature_tmp102(bus,add))\n",
    "    utime.sleep(1)\n",
    "\n",
    "print(temperature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conclusion\n",
    "\n",
    "Dans cet article, nous avons utilisé un ESP8266 couplé à un TMP102 pour construire un capteur de température sous micropython. Il est ensuite possible de crée une interface web, héberger sur l'ESP8266, qui affiche la température. Il est aussi possible de la transmettre via le protocole MQTT ou de stoker les valeurs dans la mémoire interne. Ces éléments seront traités dans un prochain article."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "kernelspec": {
   "display_name": "MicroPython - /dev/ttyUSB0",
   "language": "micropython",
   "name": "micropython"
  },
  "language_info": {
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}