Photo by Jonathan Kemper on Unsplash

Projet VanLife — Récupération des données de températures et enregistrement en base

Introduction

Cet article est le troisième article d’une série concernant la mise en place d’un ensemble des capteurs dans un van, liés à un Raspberry Pi et connecté à une app.

Introduction : Projet Van Life — Introduction — Une semaine de « hackaton » pour OnTheBeach.dev

Article 1 : Projet VanLife — Local First — Créer une API sur RaspberryPi pour gérer localement des données et les synchroniser

Article 2 : Projet VanLife — Local First — Sécurisation de l’API et gestion des utilisateurs

Ces développements ont été fait lors d’un “hackaton/road trip” par OnTheBeach.dev.

Récupération et exploitation de données

Maintenant que nous disposons d’une API sécurisée, nous allons pouvoir commencer à alimenter notre base de données avec des informations sur la vie dans le van, afin qu’elle puisse être exploitée par notre application mobile.

Les premières données que nous allons récupérer sont la température et le taux d’humidité à l’intérieur du van.

Récupération de la température

Le premier capteur que je vais connecter au RP3 sera un capteur de température et de taux d’humidité de l’air. Je me suis procuré un capteur DHT11 de AZDelivery.

Capteur de température et d’humidité DHT11

Pour la connexion du capteur au Raspberry Pi, il faut relier les entrées suivantes.

    DHT11    |    RP3    
_____________|___________
             |
     VCC     |   5V (4)
    DATA     |  GPIO4 (7)
    GND      |  Ground (6)

Mapping des GPIO sur une Raspberry Pi 3

Branchements RP3 et DHT11

Après l’avoir connecté aux broches GPIO du RP3, j’ai récupéré une library créée par Adafruit et les exemples qu’ils ont édités, puis en python j’ai créé le bout de code qui récupèrera toutes les minutes la température et le taux d’humidité mesuré dans le van car le capteur DHT11.

import Adafruit_DHT

import logging
import time

logging.basicConfig(level=logging.DEBUG)

try:
    logging.info("Temp Demo")
    while (True):
        humidity, temperature = Adafruit_DHT.read_retry(11, 4)
        jsonData = {
            "humidity": humidity,
            "temperature": temperature,
            "time": time.strftime('%H:%M:%S')
        }
        logging.info(jsonData)
        time.sleep(60)
except IOError as e:
    logging.info(e)
except KeyboardInterrupt:
    logging.info("ctrl + c:")
    exit()

Et voilà le résultat d’un lancement de ce code.

INFO:root:Temp Demo
INFO:root:{'humidity': 54.0, 'temperature': 25.0, 'time': '16:09:58'}
INFO:root:{'humidity': 54.0, 'temperature': 25.0, 'time': '16:10:59'}

Il ne me reste plus qu’à le transmettre à mon back end local, afin que celui-ci puisse les restituer au front (dans notre cas l’app mobile).

Dans la théorie, je souhaitais configurer le RPZ avec le back end. Comme expliqué dans les premiers articles, je ne suis parti qu’avec un seul Raspberry. De ce fait, le code ci après fonctionnant avec un seul Raspberry, enregistre simplement les données de température et d’humidité dans la base locale.

Je vais donc stocker mes données de température grâce à TinyDB dans ma base locale temperature_db

import Adafruit_DHT
import logging
import time
import json
import uuid

from tinydb import TinyDB, Query

#DB Temperature
temperature_db = TinyDB("DB/temperatures.json")

try:
    logging.info("Temp Demo")
    while (True):
        new_id = uuid.uuid4()
        jsonData = {"id":str(new_id), "humidity": humidity, "temperature": temperature, "ts": int(time.time()*1000)}
        logging.info(jsonData)
        temperature_db.insert(jsonData)
        time.sleep(60)
except IOError as e:
    logging.info(e)
except KeyboardInterrupt:
    logging.info("ctrl + c:")
    exit()

En exécutant mon code, voilà les logs que j’obtiens

INFO:root:Temp Demo
INFO:root:{"id": "4cfd2747-1f21-4c72-b5f5-d8f3c29dc5ce", "humidity": 53.0, "temperature": 26.0, "ts": 1720797344111}
INFO:root:{"id": "48299f85-d050-4f3f-a21c-3d31aaac12c3", "humidity": 53.0, "temperature": 26.0, "ts": 1720797404893}

Si je teste la récupération des températures enregistrées en appelant l’endpoint temperature, j’obtiens bien les données que j’ai postées avec le RP3.

Pour mes tests, j’ai mis une récupération des données toutes les minutes. Je vais maintenant configurer la méthode pour la récupérer toutes les 15 minutes, ce qui sera largement suffisant.

Il faut maintenant configurer le RP3 pour qu’ils lancent ces services quand ils démarrent. Pour cela, nous allons utiliser les services de systemd.

Sur le RP3, nous allons créer un service “fastapi”.

sudo nano /etc/systemd/system/fastapi.service

Nous allons configurer ce service ainsi.

[Service]
ExecStart=python3 -m uvicorn api:app --host 0.0.0.0 --port 8000
WorkingDirectory=/home/pi/Documents/VanLife/
Restart=always
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=vanlife
User=pi
Group=pi
[Install]
WantedBy=multi-user.target

Mon fichier api.py est stocker dans le dossier /Documents/VanLife/. Ne pas oublier d’adapter le chemin en fonction de la structure du projet.

Ensuite exécuter la commande suivante

sudo systemctl enable fastapi.service

Pour le tester immédiatement sans attendre le prochain reboot

sudo systemctl start fastapi.service

Je fais de même pour mon fichier python contenant le code de récupération des températures, en créant un service temperature

sudo nano /etc/systemd/system/temperature.service

[Service]
ExecStart=python3 temp.py
WorkingDirectory=/home/pi/VanLife/app/
Restart=always
StandardOutput=syslog
StandardError=syslog
SyslogIdentifier=temperature
User=pi
Group=pi
[Install]
WantedBy=multi-user.target

sudo systemctl enable temperature.service

sudo systemctl start temperature.service

Et voilà, j’ai un système qui tourne et qui récupère toutes les 15 minutes la température et le taux d’humidité de mon van.

Une amélioration de ce code — en lieu est place d’une boucle permanente — serait de configurer un CRON sur le RP Client, qui lancerait le code de récupération des données toutes les 15 minutes.