2017-06-25

Il s'avère que s'informer avant d'acheter est peut être une bonne idée. Le capteur de température et d'humidité DHT11 fonctionne de 0°C à 50°C, ce qui n'est pas acceptable pour une installation dans un garage non chauffé où les températures en hiver plongent souvent sous le point de congélation. Ainsi, le DHT11 que j'ai acheté pour un moniteur de porte de garage intelligent sera remplacé par un DHT22 (AM2302) qui a une plage de température beaucoup plus large de -40°C à 80°C.

Ce serait un gaspillage de jeter un capteur de 1,25$ CDN. Pourquoi ne pas l'installer sur le Raspberry Pi qui héberge mon système de domotique? Il sera alors possible d'afficher les données dans Domoticz et éventuellement de garder un journal de la température et de l'humidité ambiante dans le salon.

Il existe de nombreuses descriptions sur le Web sur la façon de le faire. Mais la plupart supposent que la broche GPIO One-Wire par défaut sera utilisée. Malheureusement, elle est recouverte (mais pas utilisée!) par l'horloge en temps réel installée sur le même Raspberry Pi (voir Horloge en temps réel, DS3231, pour Domoticz sur le Raspberry Pi). D'autres recherches sur le Web ont révélé que le problème est facilement résolu sans recours à une modification matérielle.

J'ai aussi décidé de surveiller la température de Raspberry Pi. Cela semble particulièrement utile lors qu'on accélère la cadence du système.

Table des matières

  1. Enabling 1-Wire
  2. Installing the Adafruit DHTxx Python Library
  3. Installing a Temperature Sensor in Domoticz
  4. Python Script
  5. CPU Temperature
  6. Temperature Monitoring

  1. Activation de l'interface 1-Wire
  2. Les capteurs de température et d'humidité DHT11 et DHT22/AM2302 communiquent à l'aide du bus de communication 1-Wire. Il s'agit en fait d'une connexion à trois fils, la mise à terre et le courrant sont nécessaires en plus de la ligne de données.

    L'interface 1-Wire peut être activée avec l'utilitaire raspi-config. Cependant, il active l'interface 1-Wire uniquement sur la broche BCM 4 (broche physique 7). Il est nécessaire d'éditer le fichier config.txt dans le répertoire /boot pour utiliser une broche GPIO différente. Ajoutez une ligne à la fin du fichier ou modifiez la ligne dtoverlay=w1-gpio si 1-Wire est déjà activé. J'ai décidé d'utiliser la broche BCM 24 (broche physique 18) pour les données 1-Wire.

    pi@domo:~ $ sudo nano /boot/config.txt
    dtoverlay=w1-gpio, gpiopin=24

    J'ai choisi BCM 24 parce que les broches adjacentes sont 3,3V et la mise à terre ce qui simplifie la connexion.

               3v3 [17][18] BCM 24 - 1-wire
     BCM 10 (MOSI) [19][20] Mise à terre 0v

    Comme il s'agit d'une modification de config.txt, 1-Wire sera activé lors du prochain démarrage. Les impatients peuvent l'activer immédiatement

    pi@domo:~ $ sudo modprobe w1-gpio gpiopin=24
    Mais il s'agit d'une situation temporaire et 1-Wire ne sera pas activé sur BCM 24 automatiquement lors du prochain démarrage sans la modification de config.txt décrite ci-dessus.

    Note: Bien que la série de capteurs DHT utilise le protocole de communication à 1 fil, ils ne sont pas compatibles avec le protocole One Wire de Dallas qui permet à plusieurs dispositifs One Wire d'être connectés en parallèle. En fait, cela n'est pas possible avec les capteurs DHT, chacun doit disposer d'une broche de données dédiée.

    Reference: W1-GPIO - One-Wire Interface.

  3. Installaton de la bibliothèque DHTxx Python de Adafruit
  4. Adafruit a créé quatre bibliothèques pour communiquer avec les capteurs de type DHTxx. J'ai utilisé la bibliothèque en Python. Git et le paquet de développement Python sont nécessaires pour l'installer. Le logiciel de contrôle de versions, Git était déjà installé sur mon Raspberry Pi; Je pense que c'est toujours le cas avec Raspbian.

    pi@domo:~ $ sudo apt-get install build-essential python-dev pi@domo:~ $ git clone https://github.com/adafruit/Adafruit_Python_DHT.git pi@domo:~ $ cd Adafruit_Pyt* pi@domo:~/Adafruit_Python_DHT $ sudo python setup.py install

    Une fois la bibliothèque installée, il est possible de tester que tout fonctionne de manière interactive. Voici un exemple.

    pi@domo:~ $ python Python 2.7.9 (default, Sep 17 2016, 20:26:04) [GCC 4.9.2] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>> import Adafruit_DHT >>> print(Adafruit_DHT.read(11, 24)) (None, None) >>> print(Adafruit_DHT.read(11, 24)) (None, None) >>> print(Adafruit_DHT.read(11, 24)) (50.0, 24.0) >>> print(Adafruit_DHT.read(11, 24)) (None, None) >>> exit() pi@domo:~ $

    Comme on peut le voir, la fonction de lecture peut retourner (None, None) . Une explication possible de cette défaillance est qu'on n'a pas attendu les 2 secondes minimums requises entre lectures successive du DHT11. La bibliothèque fournit une fonction, read_retry, qui tentera jusqu'à 15 fois de lire les données du cap en attendant 2 secondes entre chaque essai. Ces valeurs par défaut peuvent être modifiées.

    Reference: How to Set Up the DHT11 Humidity Sensor on the Raspberry Pi.

  5. Installation d'un capteur de température dans Domoticz
  6. Il est maintenant temps de créer une température virtuelle + capteur d'humidité dans Domoticz. La première étape, si elle n'est pas déjà faite, est de créer un matériel "fictif". Ensuite, un capteur virtuel sera ajouté au matériel. Enfin, les valeurs du capteur seront modifiées avec l'API JSON pour s'assurer que tout fonctionne.

    Ajouter du matériel virtuel

    1. Cliquez sur l'onglet Réglages (Setup).
    2. Sélectionnez Matériel (Hardware) dans le menu déroulant.
    3. Entrez un nom pour le matériel; J'ai choisi Virtual.
    4. Pour le type, sélectionnez Dummy (Does nothing, use for virtual switches only) dans la liste déroulante.
    5. Cliquer sur le bouton Ajouter (Add). Le nouveau matériel, Virtual, sera ajouté dans le tableau au haut de la page:
      On ajoute ce matériel virtuel qu'une seule fois.

    To add a virtual sensor

    1. Click on the Create Virtual Sensors in the newly created Virtual hardware.
    2. Fill in the Name field, select Temp+Hum for Sensor Type in the Create Virtual Sensor window:
      A message will pop up confirming the creation of the sensor and stating that it can be found in the devices' list.
    3. To see the device list, click on the Setup tab and then select Devices.

      Note the virtual sensor idx number. It will be needed later on.

    Testing

    1. Display the newly created sensor by clicking on the Temperature tab. If that tab is not visible on the Web interface then
      1. Click on Setup tab.
      2. Click on Settings in the drop-down menu
      3. Scroll down to the bottom of the  System  page in order to see Active Menus:
      4. Check Temperature.
      5. Scroll up to the top of the page and click on  Apply Settings .
      6. Click on the Temperature tab which should now be visible.
    2. The sensor image will appear as shown on the left.
    3. Open a Web browser and enter the following address and JSON string
      http://192.168.0.22:8080/json.htm?type=command&param=udevice&idx=35&nvalue=0&svalue=21.2;76.7;1 If there is no problem the status on the returned page should be "OK"

      and, after a short delay, the sensor image should now reflect the new temperature, humidity and humidity level.

      Instead of using a Web browser, an MQTT message can be sent assuming that the MQTT hardware has been installed in Domoticiz.

      michel@hp:~$ mosquitto_pub -h 192.168.0.22-t "domoticz/in" -m '{ "idx" : 35, "nvalue" : 1, "svalue" : "21.2;76.7;1"}'

  7. Python Script
  8. A python script can read the sensor data using the Adafruit python DHT library and send on the values to Domoticz.

    pi@domo:~ $ mkdir pythons pi@domo:~ $ cd pythons pi@domo:~/pythons $ nano dht11.py
    !/usr/bin/python import sys import Adafruit_DHT import urllib # parameters DHT_type = 11 OneWire_pin = 24 sensor_idx = 35 url_json = "http://192.168.0.22:8080/json.htm?type=command&param=udevice&idx=" verbose = 1 # set to 1 to print out information to the console # read dht11 temperature and humidity humidity, temperature = Adafruit_DHT.read_retry(DHT_type, OneWire_pin) # use Domoticz JSON url to update cmd = url_json + str(sensor_idx) + "&nvalue=0&svalue=" + str(temperature) + ";" + str(humidity) + ";0" hf = urllib.urlopen(cmd) if verbose > 0: print 'Sensor data: temperature = {0:0.1f}C, humidity = {1:0.1f}%'.format(temperature, humidity) print 'Uploaded to Pi: ' + cmd print 'Response: ' + hf.read() hf.close
    Download the file by clicking on the link dht11.py with the right mouse button.

    This is just a first draft, so we will not bother making it executable. But it can be tested easily.

    pi@domo:~/pythons $ python dht11.py Sensor data: temperature = 24.0C, humidity = 48.0% Uploaded to Pi: http://192.168.0.45:9071/json.htm?type=command&param=udevice&idx=35&nvalue=0&svalue=24.0;48.0;0 Response: { "status" : "OK", "title" : "Update Device" }

    Note the trailing ";0" in the JSON url. It is the value of the HUM_STAT (humidity status?) parameter. Its possible values are 0 to 3.

        0 = Normal
        1 = Comfortable
        2 = Dry
        3 = Wet
    To the right of each value is the string displayed in the first line of the sensor on the Temperature tab.

    Looking over Web offerings, it seems most either systematically set HUM_STAT to 0 as in the above script or else calculate a value using the relative humidity:

    if humidity > 70: HUM_STAT = 3 elif humidity > 30: HUM_STAT = 1 else: HUM_STAT = 2

    The latter approach is not the best. To quote the National Weather Service of the US National Oceanic and Atmospheric Administration "if you want a real judge of just how "dry" or "humid" it will feel outside, look at the dew point instead of the [relative humidity]. The higher the dew point, the muggier it will feel." While I doubt the correctness of the grammar, I trust NOAA's judgement on using the dew point instead of the relative humidity to qualify the perception of dryness. I will take up this question later on.

  9. CPU temperature
  10. The Raspberry Pi has a built-in thermal sensor and reports the current CPU temperature on a regular basis. The measure is written to a file; listing its content shows that the temperature is reported in thousandths of Celsius degree.

    pi@domo:~ $ cat /sys/class/thermal/thermal_zone0/temp 42236

    The CPU temperature is thus 42.236°C (or 108.025°F).

    It also possible to use the vcgencmd utility to get a formatted temperature reading.

    pi@domo:~ $ vcgencmd measure_temp temp=40.6'C

    It is fairly easy to write a python script to read this value and send it on to be displayed in a temperature sensor in Domoticz. Creating a temperature sensor is the same as creating the temperature and humidity sensor as described above except for the sensor type.

    !/usr/bin/python import sys import urllib # parameters cpu_idx = 36 url_json = "http://192.168.0.22:8080/json.htm?type=command¶m=udevice&idx=" verbose = 1 # set to 1 to print out information to the console # read cpu temperature # replace 1000.0 with 1000 to round to nearest degree cpuTemp = int(open('/sys/class/thermal/thermal_zone0/temp').read()) / 1000.0 # use Domoticz JSON url to update cmd = url_json + str(sensor_idx) + "&nvalue=0&svalue=" + str(cpuTemp) hf = urllib.urlopen(cmd) if verbose > 0: print 'Sensor data: temperature = {0:0.1f}C'.format(cpuTemp) print 'Uploaded to Pi: ' + cmd print 'Response: ' + hf.read() hf.close
    Download the file by clicking on the link soc_temp.py with the right mouse button.

    Reference:
    [Tutorial] Show RPI's Temperature with a command.
    RPI vcgencmd usage.

  11. Temperature Monitoring
  12. The two scripts presented above are easily merged into a single python script that will be executed at regular intervals by cron. Here is the script

    #!/usr/bin/python # coding: utf-8 import sys import Adafruit_DHT import urllib # parameters DHT_type = 11 OneWire_pin = 24 room_temp_idx = 35 cpu_temp_idx = 36 url_json = "http://192.168.0.22:8080/json.htm?type=command¶m=udevice&idx=" verbose = 1 # 1 to print out information to the console, 0 for silence # read and report dht11 temperature and humidity humidity, temperature = Adafruit_DHT.read_retry(DHT_type, OneWire_pin) cmd = url_json + str(room_temp_idx) + "&nvalue=0&svalue=" + str(temperature) + ";" + str(humidity) + ";0" hf = urllib.urlopen(cmd) if verbose > 0: print 'Données lues: température ambiante {0:0.1f}°C, humidité {1:0.1f}%'.format(temperature, humidity) print 'URL JSON pour Domoticz: ' + cmd print 'Réponse: ' + hf.read() hf.close # read and report cpu temperature cpuTemp = int(open('/sys/class/thermal/thermal_zone0/temp').read()) / 1e3 cmd = url_json + str(cpu_temp_idx) + "&nvalue=0&svalue=" + str(cpuTemp) hf = urllib.urlopen(cmd) if verbose > 0: print 'Donnée lue: température du Raspberry Pi: {0:0.1f}°C'.format(cpuTemp) print 'URL JSON pour Domoticz: ' + cmd print 'Réponse: ' + hf.read() hf.close
    Download the file by clicking on the link temps.py with the right mouse button (The script was updated on July 4).

    The second line, # coding: utf-8 is the only significant change. It was necessary because French messages will be printed to the console (if verbose is set equal to 1) and these contain Unicode characters. That second line can be removed if only ASCII characters are used in the python script.

    I saved the script under the name temps.py and verified that it worked.

    pi@domo:~/pythons $ python temps.py Données lues: température ambiante 23.0°C, humidité 53.0% URL JSON pour Domoticz: http://192.168.0.45:9071/json.htm?type=command¶m=udevice&idx=35&nvalue=0&svalue=23.0;53.0;0 Réponse: { "status" : "OK", "title" : "Update Device" } Donnée lue: température du Raspberry Pi: 42.8°C URL JSON pour Domoticz: http://192.168.0.45:9071/json.htm?type=command¶m=udevice&idx=36&nvalue=0&svalue=42.774 Réponse: { "status" : "OK", "title" : "Update Device" }

    That means also checking the sensors in Domoticz were updated.

    Since everything worked, I changed the verbose flag to 0, and made the file executable and added an entry in the cron schedule.

    pi@domo:~/pythons $ sudo chmod +x temps.py pi@domo:~/pythons $ crontab -e
    # m h dom mon dow command # update Domoticz temperature and humidty sensors every 5 minutes */5 * * * * /home/pi/pythons/temps.py exit editor saving changes crontab: installing new crontab

    After a while, the logged data accumulated by Domoticz can be viewed in a graph and saved to a file. Click on the Log button on the temperature sensor.

    You need not worry that a precipitous cold snap occurred at the start of the summer. The big fluctuations in the temperature and humidity levels in the late evening of the 27th are "fake news" that I created to see how the calculated dew point changed in response.

    This post is getting long. I will look into further use of the temperature sensors in the next post.