Des données au graphique :un parcours Web avec Flask et SQLite
Capturer des données réelles (RPi/DHT22), les enregistrer dans une base de données (SQLite), créer des graphiques (Matplotlib) et les présenter sur une page web (Flask).
Introduction :des données au graphique. un Web Jorney avec Flask et SQLite
Dans mon tutoriel précédent, Python WebServer With Flask et Raspberry Pi, nous avons appris à interagir avec le monde physique, via une page Web frontale, construite avec Flask. Ainsi, la prochaine étape naturelle consiste à collecter des données du monde réel, en les mettant à notre disposition sur une page Web. Très simple! Mais que se passera-t-il si nous voulons savoir quelle était la situation la veille, par exemple ? Ou faire une sorte d'analyse avec ces données ? Dans ces cas, nous devons également avoir les données stockées dans une base de données.
Bref, sur ce nouveau tutoriel, nous allons :
Capturez des données réelles (température de l'air et humidité relative) à l'aide d'un capteur DHT22 ; chargez ces données sur une base de données locale , construit avec SQLite ; Créer des graphiques avec données historiques en utilisant Matplotlib ; Afficher les données avec des « gages » animés, créés avec JustGage ; Rendre tout disponible en ligne via un serveur Web local créé avec Python et Flacon ;
Le schéma bloc nous donne une idée de l'ensemble du projet :
Étape 1 :BoM - Nomenclature
- Raspberry Pi V3 – 32,00 USD
- Capteur de température et d'humidité relative DHT22 – USD 9,95
- Résistance 4K7 ohm
Étape 2 :Installation de SQLite
OK, l'idée générale sera de collecter des données à partir d'un capteur et de les stocker dans une base de données.
Mais quel « moteur » de base de données faut-il utiliser ?
Il existe de nombreuses options sur le marché et les 2 plus utilisées avec Raspberry Pi et les capteurs sont probablement MySQL et SQLite. MySQL est très connu mais un peu "lourd" pour une utilisation sur des projets simples basés sur Raspberry (d'ailleurs il appartient à Oracle !). SQLite est probablement le choix le plus approprié. Parce qu'il est sans serveur, léger, open source et prend en charge la plupart des codes SQL (sa licence est « Domaine public »). Une autre chose pratique est que SQLite stocke les données dans un seul fichier qui peut être stocké n'importe où.
Mais qu'est-ce que SQLite ?
SQLite est un système de gestion de base de données relationnelle contenu dans une bibliothèque de programmation C. Contrairement à de nombreux autres systèmes de gestion de bases de données, SQLite n'est pas un moteur de base de données client-serveur. Il est plutôt intégré au programme final.
SQLite est un domaine public populaire choix comme logiciel de base de données intégré pour le stockage local/client dans les logiciels d'application tels que les navigateurs Web. C'est sans doute le moteur de base de données le plus largement déployé, car il est utilisé aujourd'hui par plusieurs navigateurs, systèmes d'exploitation et systèmes embarqués répandus (tels que les téléphones portables), entre autres. SQLite a des liaisons avec de nombreux langages de programmation comme Python, celui utilisé sur notre projet.
(En savoir plus sur Wikipédia)
Nous n'entrerons pas dans trop de détails ici, mais la documentation complète de SQLite se trouve sur ce lien : https://www.sqlite.org/docs.html
Ainsi soit-il! Installons SQLite sur notre Pi
Installation :
Suivez les étapes ci-dessous pour créer une base de données.
1. Installez SQLite sur Raspberry Pi à l'aide de la commande :
sudo apt-get install sqlite3 2. Créez un répertoire pour développer le projet :
mkdir Sensors_Database 3. Accédez à ce répertoire :
cd mkdir Sensors_Database/ 3. Donnez un nom et créez une base de données comme databaseName.db (dans mon cas "sensorsData.db") :
sqlite3 sensorData.db Un "shell" apparaîtra, où vous pouvez entrer avec des commandes SQLite. Nous y reviendrons plus tard.
sqlite> Les commandes commencent par un ".", comme ".help", ".quit", etc.
4. Quittez le shell pour revenir au Terminal :
sqlite> .quit L'écran d'impression du terminal ci-dessus montre ce qui a été expliqué.
Le "sqlite>" ci-dessus ne sert qu'à illustrer comment le shell SQLite apparaîtra. Vous n'avez pas besoin de le taper. Il apparaîtra automatiquement.
Étape 3 :Créer et remplir une table
Afin d'enregistrer les données mesurées par le capteur DHT dans la base de données, nous devons créer un tableau (une base de données peut contenir plusieurs tables). Notre tableau s'appellera "DHT_data" et comportera 3 colonnes, dans lesquelles nous enregistrerons nos données collectées :Date et Heure (nom de la colonne : timestamp ), Température (nom de la colonne : temp ) et l'humidité (nom de la colonne : hum ).
Créer un tableau :
Pour créer un tableau, vous pouvez le faire :
- Directement sur le shell SQLite, ou
- Utiliser un programme Python.
1. Utilisation de Shell :
Ouvrez la base de données qui a été créée à la dernière étape :
sqlite3 sensorData.db Et en entrant avec des instructions SQL :
sqlite> BEGIN;sqlite> CREATE TABLE DHT_data (timestamp DATETIME, temp NUMERIC, hum NUMERIC);sqlite> COMMIT; Toutes les instructions SQL doivent se terminer par « ; ». De plus, ces déclarations sont généralement écrites en majuscules. Ce n'est pas obligatoire, mais une bonne pratique.
2. Utilisation de Python
importer sqlite3 en tant que liteimport syscon =lite.connect('sensorsData.db')avec con :cur =con.cursor() cur.execute("DROP TABLE IF EXISTS DHT_data") cur.execute("CREATE TABLE DHT_data(timestamp DATETIME, temp NUMERIC, hum NUMERIC)") Ouvrez le code ci-dessus depuis mon GitHub : createTableDHT.py
Exécutez-le sur votre terminal :
python3 createTableDHT.py Quelle que soit la méthode utilisée, la table doit être créée. Vous pouvez le vérifier sur SQLite Shell en utilisant la commande ".table". Ouvrez le shell de la base de données :
sqlite3> sensorData.db Dans le shell, une fois que vous utilisez le .table commande, les noms des tables créées apparaîtront (dans notre cas, il n'y en aura qu'un :"DHT_table". Quittez le shell après, en utilisant le .quit commande.
sqlite> .tableDHT_datasqlite> .quit Insérer des données dans un tableau :
Entrons dans notre base de données 3 ensembles de données, où chaque ensemble aura 3 composants chacun :(timestamp, temp et hum). Le composant horodatage sera réel et extrait du système, à l'aide de la fonction intégrée « now » et temp et hum sont des données factices en oC et % respectivement.
Remarque que l'heure est en "UTC", ce qui est bien car vous n'avez pas à vous soucier des problèmes liés à l'heure d'été et à d'autres questions. Si vous souhaitez afficher la date en heure localisée, convertissez-la simplement dans le fuseau horaire approprié par la suite.
De la même manière que pour la création de table, vous pouvez insérer des données manuellement via SQLite shell ou via Python. Au niveau du shell, vous le feriez, données par données en utilisant des instructions SQL comme celle-ci (Pour notre exemple, vous le ferez 3 fois) :
sqlite> INSÉRER DANS LES VALEURS DHT_data(datetime('now'), 20.5, 30); Et en Python, vous feriez la même chose mais d'un coup :
importer sqlite3 en tant que liteimport syscon =lite.connect('sensorsData.db')avec con :cur =con.cursor() cur.execute("INSERT INTO DHT_data VALUES (datetime('now'), 20.5, 30)") cur.execute("INSERT INTO DHT_data VALUES(datetime('now'), 25.8, 40)") cur.execute("INSERT INTO DHT_data VALUES(datetime(' maintenant'), 30.3, 50)") Ouvrez le code ci-dessus depuis mon GitHub : insertTableDHT.py
Exécutez-le sur le terminal Pi :
python3 insertTableDHT.py Pour confirmer que le code ci-dessus a fonctionné, vous pouvez vérifier les données de la table via le shell, avec l'instruction SQL :
sqlite> SELECT * FROM DHT_DATA ; L'écran d'impression du terminal ci-dessus montre comment les lignes du tableau apparaîtront.
Étape 4 :Insertion et vérification des données avec Python
Pour commencer, faisons la même chose que nous avons fait auparavant (saisir et récupérer des données), mais en faisant les deux avec python et en imprimant également les données sur le terminal :
import sqlite3import sysconn=sqlite3.connect('sensorsData.db')curs=conn.cursor()# fonction pour insérer des données sur une tabledef add_data (temp, hum) :curs.execute("INSERT INTO DHT_data values(datetime('now'), (?), (?))", (temp, hum)) conn.commit()# appelle la fonction pour insérer dataadd_data (20.5, 30 )add_data (25.8, 40)add_data (30.3, 50)# print database contentprint ("\nEntire database content:\n")for row in curs.execute("SELECT * FROM DHT_data"):print (row)# ferme le base de données après useconn.close() Ouvrez le code ci-dessus depuis mon GitHub : insertDataTableDHT.py et exécutez-le sur votre terminal :
python3 insertDataTableDHT.py L'écran d'impression du terminal ci-dessus montre le résultat.
Étape 5 : Capteur de température et d'humidité DHT22
Jusqu'à présent, nous avons créé une table dans notre base de données, où nous enregistrerons toutes les données qu'un capteur lira. Nous y sommes également entrés avec quelques données factices. Il est maintenant temps d'utiliser des données réelles à enregistrer dans notre table, la température de l'air et l'humidité relative. Pour cela, nous utiliserons l'ancien et le bon DHTxx (DHT11 ou DHT22). Le site ADAFRUIT fournit d'excellentes informations sur ces capteurs. Ci-dessous, quelques informations récupérées à partir de là :
Aperçu
Les capteurs de température et d'humidité DHT à faible coût sont très basiques et lents, mais sont parfaits pour les amateurs qui souhaitent enregistrer des données de base. Les capteurs DHT sont constitués de deux parties, un capteur d'humidité capacitif et une thermistance. Il y a aussi une puce très basique à l'intérieur qui effectue une conversion analogique-numérique et crache un signal numérique avec la température et l'humidité. Le signal numérique est assez facile à lire à l'aide de n'importe quel microcontrôleur.
DHT11 contre DHT22
Nous avons deux versions du capteur DHT, elles se ressemblent un peu et ont le même brochage, mais ont des caractéristiques différentes. Voici les spécifications :
DHT11 (généralement bleu)
Bon pour les lectures d'humidité de 20 à 80 % avec une précision de 5 % Bon pour les lectures de température de 0 à 50 °C Précision de ± 2 °C Pas plus de 1 Hz de fréquence d'échantillonnage (une fois par seconde)
- Très faible coût
- Alimentation 3 à 5 V et E/S
- Utilisation de courant max. de 2,5 mA pendant la conversion (lors de la demande de données)
- Taille du corps 15,5 mm x 12 mm x 5,5 mm
- 4 broches avec un espacement de 0,1
DHT22 (généralement blanc)
Bon pour les lectures d'humidité de 0 à 100 % avec une précision de 2 à 5 % Bon pour les lectures de température de -40 à 125 °C Précision de ±0,5 °C Taux d'échantillonnage pas plus de 0,5 Hz (une fois toutes les 2 secondes)
- Faible coût
- Alimentation 3 à 5 V et E/S
- Utilisation de courant max. de 2,5 mA pendant la conversion (lors de la demande de données)
- Taille du corps 15,1 mm x 25 mm x 7,7 mm
- 4 broches avec un espacement de 0,1
Comme vous pouvez le voir, le DHT22 est un peu plus précis et bon sur une plage légèrement plus large. Les deux utilisent une seule broche numérique et sont « lents » en ce sens que vous ne pouvez pas les interroger plus d'une fois par seconde (DHT11) ou deux (DHT22).
Les deux capteurs fonctionneront correctement pour que les informations intérieures soient stockées dans notre base de données.
Le DHTxx a 4 broches (face au capteur, la broche 1 est la plus à gauche) :
- VCC (nous pouvons nous connecter à 5 V externe ou à 3,3 V depuis RPi) ;
- Sortie de données ;
- Non connecté
- Au sol.
Nous utiliserons un DHT22 dans notre projet.
Une fois que vous utiliserez habituellement le capteur sur des distances inférieures à 20 m, une résistance de 4K7 ohms doit être connectée entre les broches Data et VCC. La broche de données de sortie DHT22 sera connectée au Raspberry GPIO 16.
Vérifiez le schéma électrique ci-dessus reliant le capteur aux broches RPi comme ci-dessous :
- Broche 1 – Vcc ==> 3,3 V
- Broche 2 - Données ==> GPIO 16
- Broche 3 – Pas de connexion
- Broche 4 – Gnd ==> Gnd
N'oubliez pas d'installer la résistance 4K7 ohms entre les broches Vcc et Data. Une fois le capteur connecté, il faut aussi installer sa librairie sur notre RPi. Nous le ferons à l'étape suivante.
Étape 6 :Installation de la bibliothèque DHT
Sur votre Raspberry, à partir de /home, allez dans /Documents :
Cd Documents Créez un répertoire pour installer la bibliothèque et accédez-y :
mkdir DHT22_Sensorcd DHT22_Sensor Sur votre navigateur, accédez à Adafruit GITHub : https://github.com/adafruit/Adafruit_Python_DHT
Téléchargez la bibliothèque en cliquant sur le lien de téléchargement zip à droite et décompressez l'archive sur votre dossier Raspberry Pi récemment créé. Allez ensuite dans le répertoire de la bibliothèque (sous-dossier qui est automatiquement créé lorsque vous décompressez le fichier), et exécutez la commande :
sudo python3 setup.py install Ouvrez un programme de test (DHT22_test.py) depuis mon GITHUB :
import Adafruit_DHTDHT22Sensor =Adafruit_DHT.DHT22DHTpin =16humidité, température =Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) si l'humidité n'est pas Aucune et la température n'est pas Aucune :print('Temp={0:0.1f}*C Humidity={1:0.1f}%'.format(temperature, humidité))else :print('Échec de la lecture. Réessayez !') Exécutez le programme avec la commande :
python3 DHT22_test.py L'écran d'impression du terminal ci-dessus montre le résultat.
Étape 7 :Capturer des données réelles
Maintenant que nous avons les deux, le capteur et notre base de données tous installés et configurés, il est temps de lire et d'enregistrer les données réelles.
Pour cela, nous utiliserons le code :
import timeimport sqlite3import Adafruit_DHTdbname='sensorsData.db'sampleFreq =2 # time in seconds# get data from DHT sensordef getDHTdata():DHT22Sensor =Adafruit_DHT.DHT22 DHTpin =16 hum, temp =Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) si hum n'est pas Aucun et que temp n'est pas Aucun :hum =round(hum) temp =round(temp, 1) logData (temp, hum)# enregistre les données du capteur sur databasedef logData (temp, hum):conn=sqlite3.connect(dbname) curs=conn.cursor() curs.execute("INSERT INTO DHT_data values(datetime('now'), (?), (?))", (temp , hum)) conn.commit() conn.close()# afficher la base de données datadef displayData() :conn=sqlite3.connect(dbname) curs=conn.cursor() print ("\nContenu entier de la base de données :\n") pour ligne dans curs.execute("SELECT * FROM DHT_data") :print (ligne) conn.close()# main functiondef main() :pour i dans la plage (0,3) :getDHTdata() time.sleep(sampleFreq) displayData ()# Exécuter le programme main() Ouvrez le fichier ci-dessus depuis mon GitHub : appDHT.pyet exécutez-le sur votre terminal :
python3 appDHT.py La fonction getDHTdata() capture 3 échantillons de capteur DHT, testez-les pour les erreurs et si OK, enregistrez les données sur la base de données à l'aide de la fonction logData (temp, hum) . La dernière partie du code appelle la fonction displayData() qui imprime tout le contenu de notre table sur Terminal.
L'écran d'impression ci-dessus montre le résultat. Observez que les 3 dernières lignes (lignes) sont les données réelles capturées avec ce programme et les 3 lignes précédentes étaient celles saisies manuellement auparavant.
En fait, appDHT.py n'est pas un bon nom. En général, « appSomething.py » est utilisé avec les scripts Python sur les serveurs web comme nous le verrons plus loin dans ce tutoriel. Mais bien sûr, vous pouvez l'utiliser ici.
Étape 8 :Capturer les données automatiquement
À ce stade, ce que nous devons mettre en œuvre est un mécanisme pour lire et insérer des données dans notre base de données automatiquement, notre « Logger ».
Ouvrir une nouvelle fenêtre de terminal et entrez avec le code Python ci-dessous :
import timeimport sqlite3import Adafruit_DHTdbname='sensorsData.db'sampleFreq =1*60 # time in seconds ==> Sample chaque 1 min# get data from DHT sensordef getDHTdata() :DHT22Sensor =Adafruit_DHT.DHT22 DHTpin =16 hum, temp =Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) si hum n'est pas None et que temp n'est pas None :hum =round(hum) temp =round(temp, 1) return temp, hum # enregistre les données du capteur sur databasedef logData (temp, hum):conn=sqlite3.connect(dbname) curs=conn.cursor() curs.execute("INSERT INTO DHT_data values(datetime('now'), (?), ( ?))", (temp, hum)) conn.commit() conn.close()# main functiondef main():while True:temp, hum =getDHTdata() logData (temp, hum) time.sleep(sampleFreq) # ------------ Exécuter le programme main() Ou obtenez-le sur mon GitHub : logDHT.py. Exécutez-le sur le terminal :
python3 logDHT.py Ce que fait la fonction main() est :
Appelez la fonction getDHTdata() , qui renverra les données capturées par le capteur DHT22. Prenez ces données (température et humidité) et transmettez-les à une autre fonction : logData(temp, hum) qui les insère, avec la date et l'heure réelles, dans notre table. Et se met en veille, en attendant la prochaine heure programmée pour capturer les données (définie par sampleFreq , qui dans cet exemple est de 1 minute).
Laissez la fenêtre Terminal ouverte.
Jusqu'à ce que vous tuiez le programme avec [Ctr+z], par exemple, le programme capturera en continu les données, les alimentant dans notre base de données. Je l'ai laissé fonctionner pendant un certain temps sur une fréquence de 1 minute pour remplir la base de données plus rapidement, en changeant la fréquence après quelques heures à 10 minutes.
Il existe d'autres mécanismes beaucoup plus efficaces pour effectuer ce type de « logger automatique » que d'utiliser « time.sleep », mais le code ci-dessus fonctionnera correctement pour notre objectif ici. Quoi qu'il en soit, si vous souhaitez implémenter un meilleur « planificateur », vous pouvez utiliser Crontab , qui est un outil UNIX pratique pour planifier des tâches. Vous trouverez une bonne explication de ce qu'est Crontab dans ce didacticiel : « Planifier des tâches sur Linux à l'aide de Crontab », par Kevin van Zonneveld.
Étape 9 :Requêtes
Maintenant que notre base de données est alimentée automatiquement, nous devons trouver des moyens de travailler avec toutes ces données. Nous le faisons avec des requêtes !
Qu'est-ce qu'une requête ?
L'une des caractéristiques les plus importantes du travail avec le langage SQL sur les bases de données est la possibilité de créer des « requêtes de base de données ». En d'autres termes, les requêtes extraient les données d'une base de données en les formatant sous une forme lisible. Une requête doit être écrite en langage SQL , qui utilise un SELECT instruction pour sélectionner des données spécifiques.
Nous l'avons en fait utilisé de manière "large" sur la dernière étape :"SELECT * FROM DHT_data".
Exemples :
Créons des requêtes sur les données de la table que nous avons déjà créées. Pour cela, entrez avec le code ci-dessous :
import sqlite3conn=sqlite3.connect('sensorsData.db')curs=conn.cursor()maxTemp =27.6print ("\nContenu entier de la base de données :\n") pour la ligne dans curs.execute("SELECT * FROM DHT_data") :print (row)print ("\nEntrées de la base de données pour une valeur d'humidité spécifique :\n")pour la ligne dans curs.execute("SELECT * FROM DHT_data WHERE hum='29'") :print (row) print ("\nEntrées de la base de données où la température est supérieure à 30oC :\n") pour la ligne dans curs.execute("SELECT * FROM DHT_data WHERE temp>
30.0") :print (row) print ("\nEntrées de la base de données où la température est supérieure à x:\n") pour la ligne dans curs.execute("SELECT * FROM DHT_data WHERE temp>
(?)", (maxTemp,)):print (row) Ou récupérez-le sur mon GitHub : queryTableDHT.py et exécutez-le sur Terminal :
python3 queryTableDHT.py Vous pouvez voir le résultat sur l'écran d'impression du Terminal ci-dessus. Ce sont des exemples simples pour vous donner une idée concernant les requêtes. Prenez le temps de comprendre les instructions SQL dans le code ci-dessus.
Si vous souhaitez en savoir plus sur le langage SQL, une bonne source est le didacticiel SQL de W3School.
Étape 10 : dernières données saisies sur une table :
Une requête très importante est celle qui permet de récupérer les dernières données saisies (ou connecté) sur une table. On peut le faire directement sur le shell SQLite, avec la commande :
sqlite> SELECT * FROM DHT_data ORDER BY timestamp DESC LIMIT 1 ; Ou exécutez un simple code python comme ci-dessous :
import sqlite3conn =sqlite3.connect('sensorsData.db')curs=conn.cursor()print ("\nDernières données enregistrées dans la base de données :\n")pour ligne dans curs.execute("SELECT * FROM DHT_data ORDER BY timestamp DESC LIMIT 1") :print (ligne) Vous pouvez voir le résultat sur le premier écran d'impression Terminal ci-dessus.
Notez que le résultat apparaîtra sous la forme d'un « tuple de valeurs » :(« timestamp », temp, hum).
Le tuple a renvoyé le contenu de la dernière ligne de notre table, qui est formée de 3 éléments :
- ligne[0] =horodatage [chaîne]
- ligne[1] =temp [float]
- row[2] =hum [float]
Ainsi, nous pouvons mieux travailler notre code, pour récupérer des données "propres" de la table, par exemple :
import sqlite3conn=sqlite3.connect('sensorsData.db')curs=conn.cursor()print ("\nDernières données brutes enregistrées dans la base de données :\n") pour la ligne dans curs.execute("SELECT * FROM DHT_data ORDER BY timestamp DESC LIMIT 1") :print (str(row[0])+" ==> Temp ="+str(row[1])+" Hum ="+str(ligne[2])) Ouvrez le fichier depuis mon GitHub : lastLogDataTableDHT.py et exécutez-le sur Terminal :
python3 lastLogDataTableDHT.py Vous pouvez voir le résultat sur l'écran d'impression du 2e terminal ci-dessus.
Étape 11 :Une interface Web pour la visualisation des données
Dans mon dernier tutoriel : Python WebServer With Flask and Raspberry Pi, nous avons appris à implémenter un serveur Web (à l'aide de Flask) pour capturer les données des capteurs et afficher leur état sur une page Web.
C'est ce que nous voulons également accomplir ici. La différence réside dans les données à envoyer à notre frontal, qui seront extraites d'une base de données et pas directement à partir des capteurs comme nous l'avons fait sur ce tutoriel.
Créer un environnement de serveur Web :
La première chose à faire est d'installer Flask sur votre Raspberry Pi. Si vous ne l'avez pas, rendez-vous sur le Terminal et saisissez :
sudo apt-get install python3-flask Le mieux lorsque vous démarrez un nouveau projet est de créer un dossier où organiser vos fichiers. Par exemple :
Depuis chez vous, rendez-vous dans notre répertoire de travail :
Cd Documents/Sensors_Database Créez un nouveau dossier, par exemple :
mkdir dhtWebServer La commande ci-dessus créera un dossier nommé "dhtWebServer", où nous enregistrerons nos scripts python :
/home/pi/Documents/Sensor_Database/rpiWebServer Maintenant, sur ce dossier, créons 2 sous-dossiers : static pour les fichiers CSS et éventuellement JavaScript et les modèles pour les fichiers HTML. Accédez à votre nouveau dossier créé :
cd dhtWebServer Et créez les 2 nouveaux sous-dossiers :
mkdir statique et
modèles mkdir Le répertoire final « arbre », ressemblera à :
├── Sensors_Database ├── sensorData.db ├── logDHT.py ├── dhtWebSensor ├── templates └── statique Nous laisserons notre base de données créée dans le répertoire /Sensor_Database, vous devrez donc connecter SQLite avec "../sensorsData.db".
D'ACCORD! Une fois notre environnement en place, assemblons les pièces et créons notre Application Python WebServer . Le schéma ci-dessus nous donne une idée de ce qu'il faut faire !
Étape 12 :L'application Python WebServer
À partir du dernier diagramme, créons un serveur Web python à l'aide de Flask. Je suggère Geany comme IDE à utiliser, une fois que vous pouvez travailler simultanément avec différents types de fichiers (.py, .html et .css).
Le code ci-dessous est le script python à utiliser sur notre premier serveur Web :
à partir de l'importation du flacon Flask, render_template, requestapp =Flask(__name__)import sqlite3# Récupérer les données de la base de donnéesdef getData() :conn=sqlite3.connect('../sensorsData .db') curs=conn.cursor() pour la ligne dans curs.execute("SELECT * FROM DHT_data ORDER BY timestamp DESC LIMIT 1"):time =str(row[0]) temp =row[1] hum =row [2] conn.close() return time, temp, hum# route principale @app.route("/")def index():time, temp, hum =getData() templateData ={ 'time':time, ' temp':temp, 'hum':hum } return render_template('index.html', **templateData)if __name__ =="__main__":app.run(host='0.0.0.0', port=80, debug=Faux) Vous pouvez obtenir le script python appDhtWebServer.py depuis mon GitHub. Le code ci-dessus fait :
Avec cette requête, la première chose à faire dans le code est de récupérer les données de la base de données à l'aide de la fonction time, temp, hum =getData(). Cette fonction est essentiellement la même requête qui était utilisée auparavant pour récupérer une donnée stockée dans la table. Avec les données en main, notre script retourne à la page Web (index.html ) : heure , temp et hum en réponse à la demande précédente.
- Chaque fois que quelqu'un « clique » sur « / », c'est-à-dire la page principale (index.html) de notre page Web, une requête GET est générée ;
Voyons donc le index.html et style.css fichiers qui seront utilisés pour construire notre front-end :
index.html
Données du capteur DHT Données du capteur DHT
TEMPÉRATURE ==> {{ tempLab }} oC
HUMIDITÉ (rel.) ==> { { humLab }} %
Dernière lecture des capteurs :{{ time }} ==> REFRESH
@2018 Développé par MJRoBot.org