Station météo IoT avec RPi et ESP8266 : 10 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

Dans les didacticiels précédents, nous avons joué avec NodeMCU, des capteurs et appris à capturer et à enregistrer des données sur ThingSpeak (une plate-forme Internet des objets (IoT) qui vous permet de collecter et de stocker des données de capteurs dans le cloud et de développer des applications IoT):

IOT MADE EASY: CAPTURE DE DONNÉES MÉTÉOROLOGIQUES À DISTANCE: TEMPÉRATURE ET HUMIDITÉ UV ET DE L'AIR

Avec ce nouveau tutoriel, nous allons apprendre à faire de même mais cette fois-ci, en utilisant un Raspberry Pi pour capturer les données de plusieurs capteurs différents et aussi en explorant différentes manières de communiquer entre les appareils et le web:

Capteurs et type de communication:

• DHT22 (Température et Humidité) ==> Communication numérique
• BMP180 (Température et Pression) ==> Protocole I2C
• DS18B20 (Température) ==> Protocole 1-Wire

Le schéma fonctionnel montre ce que nous obtiendrons à la fin avec ce projet:

Étape 1: BoM - Nomenclature

1. Framboise Pi V3 - 32,00 $ US
2. Capteur de température et d'humidité relative DHT22 - 9,95 USD
3. Résistance 4K7 ohm
4. Capteur de température étanche DS18B20 - 5,95 USD
5. Résistance 4K7 ohm
6. Capteur de pression barométrique, de température et d'altitude BMP180 - 6,99 USD

Étape 2: Installation du capteur de température et d'humidité

Le premier capteur à installer sera le DHT22 pour capturer les données de température de l'air et d'humidité relative. 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.

DHT22 Caractéristiques principales:

• À bas prix
• Alimentation 3 à 5V et E/S
• Utilisation actuelle de 2,5 mA max pendant la conversion (lors de la demande de données)
• 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
• Pas plus de 0,5 Hz de fréquence d'échantillonnage (une fois toutes les 2 secondes)
• Taille du corps 15,1 mm x 25 mm x 7,7 mm
• 4 broches avec espacement de 0,1"

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, en connectant le capteur aux broches RPi comme ci-dessous:

1. Broche 1 - Vcc ==> 3.3V
2. Broche 2 - Données ==> GPIO 16
3. Broche 3 - Pas de connexion
4. 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 également installer sa librairie sur notre RPi.

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_Sensor

cd DHT22_Sensor

Sur votre navigateur, accédez à Adafruit GitHub:

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éé. Rendez-vous ensuite dans le répertoire de la bibliothèque (sous-dossier qui se crée automatiquement lorsque vous dézippez le fichier), et exécutez la commande:

sudo python3 setup.py installer

Ouvrez un programme de test (DHT22_test.py) depuis mon GITHUB

importer Adafruit_DHT

DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 humidité, température = Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) si l'humidité n'est pas None et la température n'est pas None: print('Temp={0:0.1f}*C Humidity={1:0.1 f}%'.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-dessous montre le résultat.

Étape 3: Installation du DS18B20 - Capteur de température

Aperçu du capteur:

Nous utiliserons dans ce tutoriel une version étanche du capteur DS18B20. Il est très utile pour les températures éloignées dans des conditions humides, par exemple sur un sol humide. Le capteur est isolé et peut prendre des mesures jusqu'à 125oC (Adafrut ne recommande pas de l'utiliser au-dessus de 100oC en raison de sa gaine de câble en PVC).

Le DS18B20 est un capteur numérique ce qui le rend bon à utiliser même sur de longues distances ! Ces capteurs de température numériques à 1 fil sont assez précis (±0,5 °C sur une grande partie de la plage) et peuvent donner jusqu'à 12 bits de précision à partir du convertisseur numérique-analogique embarqué. Ils fonctionnent très bien avec le NodeMCU à l'aide d'une seule broche numérique, et vous pouvez même en connecter plusieurs à la même broche, chacune ayant un ID 64 bits unique gravé en usine pour les différencier.

Le capteur fonctionne de 3.0 à 5.0V, ce qui signifie qu'il peut être alimenté directement à partir du 3.3V fourni par l'une des broches Raspberry (1 ou 17).

Le capteur a 3 fils:

• Noir: GND
• Rouge: VCC
• Jaune: données à 1 fil

Ici, vous pouvez trouver les données complètes: Fiche technique DS18B20

Installation du capteur:

Suivez le schéma ci-dessus et effectuez les connexions:

• Vcc ==> 3.3V
• Gnd ==> Gnd
• Données ==> GPIO 4 (par défaut pour la bibliothèque)

Installation de la bibliothèque Python:

Ensuite, installons la bibliothèque Python qui gérera le capteur:

sudo pip3 installer w1thermsensor

Avant d'exécuter le script pour tester le capteur, vérifiez si l'interface "1-Wire" est activée dans votre RPi (voir l'écran d'impression ci-dessus)

N'oubliez pas de redémarrer votre RPi, après avoir changé sa configuration

Test du capteur:

Pour tester le capteur, un simple script python peut être utilisé:

heure d'importation

de w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor() tandis que True: temperature = ds18b20Sensor.get_temperature() print("La température est %s celsius" % temperature) time.sleep(1)

Étape 4: Installation du BMP180

Aperçu du capteur:

Le BMP180 est le successeur du BMP085, une nouvelle génération de capteurs de pression numériques de haute précision pour les applications grand public. L'électronique à très faible consommation et basse tension du BMP180 est optimisée pour une utilisation dans les téléphones portables, les PDA, les appareils de navigation GPS et les équipements de plein air. Avec un bruit à basse altitude de seulement 0,25 m à un temps de conversion rapide, le BMP180 offre des performances supérieures. L'interface I2C permet une intégration facile du système avec un microcontrôleur. Le BMP180 est basé sur la technologie piézorésistive pour la robustesse CEM, la haute précision et la linéarité ainsi que la stabilité à long terme.

La fiche technique complète du BMP se trouve ici: BMP180 - Capteur de pression numérique

Installation du capteur: suivez le schéma ci-dessus et effectuez les connexions:

• Vin ==> 3.3V
• GND ==> GND
• SCL ==> GPIO 3
• SDA ==> GPIO 2

Activation de l'interface I2C

Accédez à Configuration RPi et confirmez que l'interface I2C est activée. Sinon, activez-le et redémarrez le RPi.

Utilisation du BMP180

Si tout a été installé correctement et que tout a été connecté correctement, vous êtes maintenant prêt à allumer votre Pi et à commencer à voir ce que le BMP180 vous dit sur le monde qui vous entoure.

La première chose à faire est de vérifier si le Pi voit votre BMP180. Essayez ce qui suit dans une fenêtre de terminal:

sudo i2cdetect -y 1

Si la commande a fonctionné, vous devriez voir quelque chose de similaire à l'écran d'impression du terminal ci-dessus, indiquant que le BMP180 est sur le canal '77'.

Installation de la bibliothèque BMP180:

Créez un répertoire pour installer la bibliothèque:

mkdir BMP180_Sensorcd BMP180_Sensor

Sur votre navigateur, rendez-vous sur Adafruit GITHub:

github.com/adafruit/Adafruit_Python_BMP

Téléchargez la bibliothèque en cliquant sur le lien de téléchargement zip à droite et décompressez l'archive dans votre dossier créé par Raspberry Pi. Allez ensuite dans le sous-dossier créé et exécutez la commande suivante dans le répertoire de la bibliothèque:

sudo python3 setup.py installer

Ouvrez votre IDE Python et créez un programme de test et nommez-le, par exemple BMP180Test.py

importer Adafruit_BMP. BMP085 en tant que BMP085sensor = BMP085. BMP085() print('Temp = {0:0.2f} *C'.format(sensor.read_temperature())) print('Pressure = {0:0.2f} Pa'. format(sensor.read_pressure())) print('Altitude = {0:0.2f} m'.format(sensor.read_altitude())) print('Sealevel Pressure = {0:0.2f} Pa'.format(sensor.read_sealevel_pressure()))

Exécutez le programme de test:

python3 BMP180Test.py

L'écran d'impression du terminal ci-dessus montre le résultat.

Notez que cette pression est présentée en Pa (Pascals). Voir l'étape suivante pour mieux comprendre cet appareil.

Étape 5: Mesurer la météo et l'altitude avec le BMP180

Prenons le temps de comprendre un peu plus ce que nous obtiendrons, avec les lectures BMP. Vous pouvez ignorer cette partie du didacticiel ou y revenir plus tard.

Si vous voulez en savoir plus sur les lectures des capteurs, veuillez consulter ce super tutoriel:

Le BMP180 a été conçu pour mesurer avec précision la pression atmosphérique. La pression atmosphérique varie en fonction du temps et de l'altitude.

Qu'est-ce que la pression atmosphérique ?

La définition de la pression atmosphérique est une force que l'air autour de vous exerce sur tout. Le poids des gaz dans l'atmosphère crée la pression atmosphérique. Une unité de pression courante est « livres par pouce carré » ou psi. Nous utiliserons ici la notation internationale, c'est-à-dire les newtons par mètre carré, que l'on appelle pascals (Pa).

Si vous preniez 1 cm de large, une colonne d'air pèserait environ 1 kg

Ce poids, en appuyant sur l'empreinte de cette colonne, crée la pression atmosphérique que nous pouvons mesurer avec des capteurs comme le BMP180. Parce que cette colonne d'air d'une largeur de cm pèse environ 1 kg, il s'ensuit que la pression moyenne au niveau de la mer est d'environ 101325 pascals, ou mieux, 1013,25 hPa (1 hPa est également connu sous le nom de milibar - mbar). Cela baissera d'environ 4% tous les 300 mètres que vous montez. Plus vous montez, moins vous verrez de pression, car la colonne au sommet de l'atmosphère est beaucoup plus courte et pèse donc moins. C'est utile à savoir, car en mesurant la pression et en faisant quelques calculs, vous pouvez déterminer votre altitude.

La pression atmosphérique à 3 810 mètres n'est que la moitié de celle au niveau de la mer.

Le BMP180 affiche la pression absolue en pascals (Pa). Un pascal est une très petite quantité de pression, approximativement la quantité qu'une feuille de papier exerce sur une table. Vous verrez plus souvent des mesures en hectopascals (1 hPa = 100 Pa). La bibliothèque utilisée ici fournit des valeurs à virgule flottante en hPa, qui sont également égales à un millibar (mbar).

Voici quelques conversions vers d'autres unités de pression:

• 1 hPa = 100 Pa = 1 mbar = 0,001 bar
• 1 hPa = 0,75006168 Torr
• 1 hPa = 0,01450377 psi (livres par pouce carré)
• 1 hPa = 0,02953337 inHg (pouces de mercure)
• 1 hpa = 0,00098692 atm (atmosphères standard)

Effets de la température

Parce que la température affecte la densité d'un gaz, que la densité affecte la masse d'un gaz et que la masse affecte la pression (ouf), la pression atmosphérique changera considérablement avec la température. Les pilotes l'appellent « altitude densité », ce qui facilite le décollage par temps froid que par temps chaud car l'air est plus dense et a un effet aérodynamique plus important. Pour compenser la température, le BMP180 intègre un capteur de température plutôt bon ainsi qu'un capteur de pression.

Pour effectuer une lecture de pression, vous prenez d'abord une lecture de température, puis vous la combinez avec une lecture de pression brute pour obtenir une mesure de pression finale compensée en température. (La bibliothèque rend tout cela très facile.)

Mesure de la pression absolue

Si votre application nécessite une mesure de pression absolue, il vous suffit d'obtenir une lecture de température, puis d'effectuer une lecture de pression (voir l'exemple de croquis pour plus de détails). La lecture de pression finale sera en hPa = mbar. Si vous le souhaitez, vous pouvez le convertir en une unité différente en utilisant les facteurs de conversion ci-dessus.

Notez que la pression absolue de l'atmosphère variera à la fois avec votre altitude et les conditions météorologiques actuelles, qui sont toutes deux des éléments utiles à mesurer.

Observations météorologiques

La pression atmosphérique à n'importe quel endroit sur terre (ou n'importe où avec une atmosphère) n'est pas constante. L'interaction complexe entre la rotation de la Terre, l'inclinaison de l'axe et de nombreux autres facteurs entraîne le déplacement de zones de pression plus élevée et plus basse, ce qui à son tour provoque les variations météorologiques que nous voyons chaque jour. En surveillant les changements de pression, vous pouvez prévoir les changements météorologiques à court terme. Par exemple, une chute de pression signifie généralement que le temps est humide ou qu'une tempête approche (un système dépressionnaire s'installe). L'augmentation de la pression signifie généralement que le temps clair approche (un système anticyclonique se déplace). Mais rappelez-vous que la pression atmosphérique varie également avec l'altitude. La pression absolue dans ma maison, Lo Barnechea au Chili (altitude 950m) sera toujours inférieure à la pression absolue à San Francisco par exemple (moins de 2 mètres, presque au niveau de la mer). Si les stations météorologiques ne faisaient que signaler leur pression absolue, il serait difficile de comparer directement les mesures de pression d'un endroit à un autre (et les prévisions météorologiques à grande échelle dépendent des mesures d'autant de stations que possible).

Pour résoudre ce problème, les stations météorologiques suppriment toujours les effets de l'altitude de leurs lectures de pression signalées en ajoutant mathématiquement la pression fixe équivalente pour donner l'impression que la lecture a été prise au niveau de la mer. Lorsque vous faites cela, une lecture plus élevée à San Francisco qu'à Lo Barnechea sera toujours due aux conditions météorologiques et non à l'altitude.

Pour ce faire, il existe une fonction dans la bibliothèque appelée sea level(P, A). Cela prend la pression absolue (P) en hPa et l'altitude actuelle de la station (A) en mètres, et supprime les effets de l'altitude de la pression. Vous pouvez utiliser la sortie de cette fonction pour comparer directement vos relevés météorologiques à d'autres stations à travers le monde.

Détermination de l'altitude

Étant donné que la pression varie avec l'altitude, vous pouvez utiliser un capteur de pression pour mesurer l'altitude (avec quelques mises en garde). La pression moyenne de l'atmosphère au niveau de la mer est de 1013,25 hPa (ou mbar). Cela tombe à zéro à mesure que vous montez vers le vide de l'espace. Parce que la courbe de cette chute est bien comprise, vous pouvez calculer la différence d'altitude entre deux mesures de pression (p et p0) en utilisant une équation spécifique.

Si vous utilisez la pression au niveau de la mer (1013,25 hPa) comme pression de base (p0), la sortie de l'équation sera votre altitude actuelle au-dessus du niveau de la mer. Il existe une fonction dans la bibliothèque appelée altitude(P, P0) qui vous permet d'obtenir "l'altitude calculée".

L'explication ci-dessus a été extraite du didacticiel BMP 180 Sparkfun.

Étape 6: le matériel complet

Étape 7: Envoi de données à ThingSpeak

À ce stade, nous avons appris à préparer le RPi pour capturer les données des 3 capteurs, en les imprimant sur le terminal. Maintenant, il est temps de voir comment envoyer ces données à notre plate-forme IoT, ThingSpeak.

Commençons!

Tout d'abord, vous devez avoir un compte sur ThinkSpeak.com

Suivez les instructions pour créer une chaîne et prenez note de votre identifiant de chaîne et de votre clé API d'écriture

Téléchargez le script Python depuis mon GitHub: localData ToTS_v1_EXT.py

Commentons les parties les plus importantes du code:

Tout d'abord, importons la bibliothèque ThingSpeak, définissons le client WiFi et définissons votre routeur local et les informations d'identification Thinkspeak:

importer le langage des choses

Il existe plusieurs façons de communiquer avec ThingSpeak, la façon la plus simple serait d'utiliser la bibliothèque cliente pour l'API Thingspeak.com développée par Mikolaj Chwaliz et Keith Ellis.

La bibliothèque peut être téléchargée à partir de https://github.com/mchwalisz/thingspeak ou utiliser PIP sur le terminal:

sudo pip3 installer Thingspeak

Ensuite, dans le script, mettez à jour les informations d'identification du canal ThingSpeak

chId = 9999999 # Entrez avec votre identifiant de chaîne

tsKey='ENTRER AVEC VOTRE CLÉ D'ÉCRITURE DE CANAL' tsUrl='https://api.thingspeak.com/update' ts = Thingspeak. Channel(chId, tsUrl, tsKey)

Maintenant, initialisons les 3 capteurs:

# DS18B20 Bibliothèque 1-Wire

from w1thermsensor import W1ThermSensor ds18b20Sensor = W1ThermSensor() # Par défaut GPIO 4 est utilisé par la bibliothèque # DHT22 Library import Adafruit_DHT DHT22Sensor = Adafruit_DHT. DHT22 DHTpin = 16 # BMP180 library import Adafruit_BMP08. BMP085 comme BMP085Sor. Vous devez définir l'altitude réelle où se trouve votre station météo, en mettant à jour la variable globale "altReal". Dans mon cas, ma Station est située à 950m d'altitude

altReal global

altReal = 950

Une fois entré avec l'altitude réelle de la station en entrée, nous pouvons obtenir la pression absolue, la pression au niveau de la mer, la température et l'altitude en utilisant la fonction bmp180GetData(altitude):

def bmp180GetData(altitude):

temp = bmp180Sensor.read_temperature() pres = bmp180Sensor.read_pressure() alt=bmp180Sensor.read_altitude() presSeaLevel = pres / pow(1.0 - altitude/44330.0, 5.255) temp = round (temp, 1) pres = round (pres/100, 2) # pression absolue en hPa (ou mbar) alt=round (alt) presSeaLevel = round (presSeaLevel/100, 2) # pression absolue en hPa (ou mbar) retour temp, pres, alt, presSeaLevel

La fonction getLocalData(), renverra toutes les données locales capturées par notre station:

def getLocalData():

global timeString global humLab global tempExt global tempLab global presSL global altLab global presAbs # Obtenir l'heure de lecture maintenant = datetime.datetime.now() timeString = now.strftime("%Y-%m-%d %H:%M") # Lire la température extérieure (à 1 mètre de distance) tempExt = round(ds18b20Sensor.get_temperature(), 1) tempLab, presAbs, altLab, presSL = bmp180GetData(altReal) humDHT, tempDHT = Adafruit_DHT.read_retry(DHT22Sensor, DHTpin) si humDHT n'est pas Aucun et tempDHT n'est pas None: humLab = round (humDHT

Une fois que vous avez toutes les données capturées par les fonctions ci-dessus, vous devez les envoyer à ThingSpeak. Vous le ferez en utilisant la fonction sendDataTs():

def sendDataTs():

data = { "field1": tempLab, "field2": tempExt, "field3": humLab, "field4": pressSL, "field5": altLab } ts.update(data) print ("[INFO] Données envoyées pour 5 champs: ", tempLab, tempExt, humLab, pressSL, altLab)

Une fois les données de votre chaîne mises à jour, enregistrez le script et exécutez-le sur votre terminal:

sudo Python3 localData_ToTs_v1_EXT.py

À propos des protocoles de communication

Notez qu'en utilisant la " bibliothèque de chosespeak ", la " bibliothèque de requêtes " est importée, c'est-à-dire une bibliothèque HTTP sous licence Apache2, écrite en Python. La documentation officielle de la demande d'installation se trouve ici:

docs.python-requests.org/en/latest/user/install/

Si nécessaire, avant d'exécuter votre script, vous pouvez vérifier si la bibliothèque de requêtes est installée:

demandes d'installation sudo pip3

En option, vous pouvez utiliser MTTQ comme méthode pour envoyer des données à ThingSpeak. MQTT est différent de HTTP, une fois Il est spécifiquement conçu pour être léger et destiné aux périphériques embarqués avec de faibles performances de RAM et de CPU. De plus, dans la plupart des cas, MQTT utilise moins de bande passante.

Référez-vous à ce tutoriel: Mettre à jour un canal ThingSpeak à l'aide de MQTT sur un Raspberry Pi pour plus de détails.

Étape 8: Envoi de données distantes à ThingSpeak à l'aide d'ESP8266

Pour cette étape, nous utiliserons le même HW qui a été expliqué dans mon tutoriel:

IOT MADE EASY: CAPTURE DE DONNÉES MÉTÉOROLOGIQUES À DISTANCE: TEMPÉRATURE ET HUMIDITÉ UV ET DE L'AIR

Le code que nous utiliserons ici est fondamentalement le même que celui utilisé dans ce didacticiel. Commentons les parties les plus importantes du code:

Tout d'abord, appelons la bibliothèque ESP8266, définissons le client WiFi et définissons votre routeur local et les informations d'identification Thinkspeak:

/* NodeMCU ESP12-E */

#inclure le client WiFiClient; const char* MY_SSID = "ENTRER AVEC VOTRE ID SSD"; const char* MY_PWD = "ENTRER AVEC VOTRE MOT DE PASSE"; /* Thinkspeak */ const char* TS_SERVER = "api.thingspeak.com"; String TS_API_KEY = "ENTRER AVEC VOTRE CLÉ D'ÉCRITURE";

Deuxièmement, incluons une bibliothèque très importante pour les projets IoT: SimpleTimer.h:

/* MINUTERIE */

#include la minuterie SimpleTimer;

Troisièmement, pendant setup(), nous initierons la communication série, appellerons la fonction connectWiFi() et définirons les temporisateurs. Notez que la ligne de code: timer.setInterval(60000L, sendDataTS); appellera la fonction sendDataTS() toutes les 60 secondes, afin de télécharger des données sur le canal ThinkSpeak.

void setup()

{ … Serial.begin(115200); retard(10); … connectWifi(); timer.setInterval (60000L, sendDataTS); … }

Enfin, lors de la boucle(), la seule commande nécessaire est de lancer le timer et c'est tout !

boucle vide()

{ … timer.run(); // Lance SimpleTimer }

Ci-dessous, vous pouvez voir les deux fonctions importantes utilisées pour gérer la communication Thinkspeak:

Connexion ESP12-E avec votre réseau WiFi:

/***************************************************

* Connexion WiFi ************************************************* ***/ void connectWifi() { Serial.print("Connexion à "+ *MY_SSID); WiFi.begin(MY_SSID, MY_PWD); while (WiFi.status() != WL_CONNECTED) { delay(1000); Serial.print("."); } Serial.println(""); Serial.println("WiFi Connecté"); Serial.println(""); }

ESP12-E envoie des données à ThinkSpeak:

***************************************************

* Envoi de données à Thinkspeak Channel ******************************************** ******/ void sendDataTS(void) { if (client.connect(TS_SERVER, 80)) { String postStr = TS_API_KEY; postStr += "&field6="; postStr += String(temp); postStr += "&field7="; postStr += String(hum); postStr += "&field8="; postStr += String(dataSensorUV); postStr += "\r\n\r\n"; client.print("POST /mise à jour HTTP/1.1\n"); client.print("Hôte: api.thingspeak.com\n"); client.print("Connexion: fermer\n"); client.print("X-THINGSPEAKAPIKEY: " + TS_API_KEY + "\n"); client.print("Type de contenu: application/x-www-form-urlencoded\n"); client.print("Contenu-Longueur: "); client.print(postStr.length()); client.print("\n\n"); client.print(postStr); retard(1000); } envoyé++; client.stop(); }

Le code complet se trouve sur mon GitHub: NodeMCU_UV_DHT_Sensor_OLED_TS_EXT

Une fois que vous avez téléchargé le code sur votre NodeMCU. Connectons une batterie externe et faisons quelques mesures sous le soleil. Je place la station distante sur le toit et commence à capturer des données sur ThingSpeak.com comme indiqué sur les photos ci-dessus.

Étape 9: Notes finales

L'objectif principal de ce tutoriel était de montrer comment connecter le Raspberry Pi à ThingSpeak. C'est génial de capturer des données et de les enregistrer sur une plate-forme IoT.

En utilisant cette opportunité, nous avons également envoyé des données à ce canal spécifique, en les capturant à partir d'une station distante à l'aide d'un ESP8266. Cette approche est OK, mais pas la meilleure. Parce que nous avons un fonctionnement "asynchrone", parfois, RPi et ESP8266 essaient de se connecter en même temps (ou avec un petit intervalle) ce qui est réfuté par ThingSpeak. L'idéal serait que l'ESP8266 envoie des données localement vers Raspberry Pi et que le dernier soit chargé de gérer toutes les données. En faisant cela, la "Main Station" (Raspberry Pi), pourrait faire 3 choses:

• Enregistrer toutes les données sur une base de données locale
• Présentez toutes les données sur une page Web locale (en utilisant Flask comme indiqué sur la photo ci-dessus)
• Envoi de toutes les données à ThingSpeak en même temps.

Dans un prochain didacticiel, nous explorerons ces options.

Étape 10: Conclusion

Comme toujours, j'espère que ce projet pourra aider d'autres personnes à trouver leur chemin dans le monde passionnant de l'électronique !

Pour plus de détails et le code final, veuillez visiter mon dépôt GitHub: RPi-NodeMCU-Weather-Station

Pour plus de projets, veuillez visiter mon blog: MJRoBot.org

Restez à l'écoute! Dans le prochain tutoriel, nous enverrons les données d'une station météo distante à une station centrale, basée sur un serveur Web Raspberry Pi:

Salutations du sud du monde !

Rendez-vous dans mon prochain instructable !

Merci, Marcelo