une station météo ARDUINO en réseau privé via votre BOX c’est possible avec un Ethernet Shield . nous allons voir comment.
le tuto est basé sur l’utilisation d’un Shield ethernet Keyestudio mais le principe est le même avec d’autre shield Ethernet. l’avantage du shield Keyestudio est qu’il comporte en plus un slot pour carte micros SD. outre la transmission Ethernet des données, il sera donc également possible de les sauvegarder sur carte micro SD.
petit problème global avec les Shield Ethernet , contrairement au shiel SD , ils n’ont pas d’Horloge RTC intégrée , il va donc falloir en ajouter une. dans ce tuto , on utilisera un module TinyRTC I2C. mais tout autre module RTC peut convenir.
par ailleurs , nous allons profiter de ce module pour notre premier exemple de transmission de données via câble réseau Ethernet en affichant tout simplement la date et l’heure récupérée sur le module dans une page de navigateur .
LE MONTAGE :
pas besoin de schéma fritzing , ici la connexion est simple , on relie les broche Vcc et GND du module RTC aux borches GND et 5V de l’arduino uno et les broches SCL et SDA respectivement au broche Analogiques A5 et A4 de l’Arduino UNO.
LE PROGRAMME :
#include <SPI.h>
#include <Ethernet.h>
#include "RTClib.h"
RTC_DS1307 rtc;
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 15);
EthernetServer server(80);
void setup() {
rtc.begin();
SPI.begin();
Ethernet.begin(mac, ip);
server.begin();
}
void loop() {
EthernetClient client = server.available();
if (client) {
while (client.connected()) {
DateTime time = rtc.now();
client.print("DATE: ");
client.println(time.timestamp(DateTime::TIMESTAMP_DATE));
client.print("TIME: ");
client.println(time.timestamp(DateTime::TIMESTAMP_TIME));
break;
}
delay(100);
client.stop();
}
}
les librairies sont standard , si pas disponibles dans votre IDE , une petite recherche internet vous permettra de les récupérer. en début de programme , via les instruction byte mac[] et IPadress on fixe l’adresse Mac et l’adresse IP du shield ( a modifier suivant les données de votre Box internet) . ensuite la partie void setup , démarre les librairies , et la partie void loop ouvre le serveur puis la boucle while exécute les lignes suivantes tant que la connexion est OK . dans la boucle on lit les données date et heure du module TinyRTC puis on les imprime sur le serveur client via une instruction type “client.print() “
ne reste plus qu’a lire tout ça a l’adresse IP avec un navigateur Web . pas très compliqué , ouvrir votre navigateur préféré et tapez l’adresse IP (ici 192.168.1.15) et vous devriez voir apparaitre quelque chose comme ci dessous:
bien entendu , si vous utilisez votre smartphone connecté en WIFI a votre réseau domestique, ça marche aussi avec l’explorateur web du smartphone.
le problème avec l’affichage obtenu c’est que la structure est extrêmement minimale et surtout la page ne se régénère pas automatiquement , il faut la régénère à la main pour voire l’heure évoluer.
nous allons donc mettre en place une page web basique en HTML avec régénération automatique. et rajouter des test pour la connexion. le programme plus bas est une modification pure et simple d’un programme exemple livré avec la bibliothèque “Ethernet.h” que l’on trouve sous l’IDE ARDUINO dans le chemin:
Fichier/example/Ethernet/Webserver
STRUCTURE MINIMALE D’UNE PAGE HTML
première chose a intégrer , la structure minimale standard obligatoire d’une page web en HTML . ci dessous un petit schéma qui montre les éléments (balises) constitutifs d’une page web standard minimale.
- <!DOCTYPE html> est la balise qui précise le langage utilisé .
- <html> est la balise délimite le début la zone de contenu html
- </html> est la balise qui symbolise la fin de la zone html
- a l’intérieur de cette zone html , on va trouver deux types de balises:
- <head> et </head> pour définir debut et fin de la zone des données d’entête
- <body> et</body> qui délimitent la zone de texte (corps) de la page web
la zone d’entête doit comporter le titre de la page entre les balises <title> et </title>
et le type d’encodage utilisé ici <meta charset=”utf-8″>
petite particularité , sous C++ ARDUINO , concernant la rédaction, il faudra écrire:
<meta charset=\”utf-8\”> </meta>
pour demander la régénération de la page , il faudra insérer “Refresh: x“ avec X le temps de rafraichissement.
passons au programme modifié avec en violet les rajouts par rapport au programme initial .
#include <SPI.h>
#include <Ethernet.h>
#include "RTClib.h"
RTC_DS1307 rtc;
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 15);
EthernetServer server(80);
void setup() {
rtc.begin();
SPI.begin();
Ethernet.begin(mac, ip);
server.begin();
}
void loop() {
EthernetClient client = server.available();
if (client) {
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n' && currentLineIsBlank) {
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close"); // cloture connexion
client.println("Refresh: 10"); // rafraichissement de page toute les 10s
client.println();
client.println("<!DOCTYPE HTML>"); // specifie le type de document=HTML
client.println("<html>"); // debut de la page
client.println("<head>");
client.println("<meta charset=\"utf-8\"></meta>"); //encodage page
client.println("<title>METEO LOCALE</title>"); // titre de la page
client.println("</head>");
client.println("<body>"); // debut de zone du contenu visible
DateTime time = rtc.now();
client.print("DATE: ");
client.print(time.timestamp(DateTime::TIMESTAMP_DATE));
client.print(" TIME: ");
client.print(time.timestamp(DateTime::TIMESTAMP_TIME));
client.println("</body>"); // fin de zone du contenu
client.println("</html>"); // fin de la page
break;
}
if (c == '\n') {
// you're starting a new line
currentLineIsBlank = true;
} else if (c != '\r') {
// you've gotten a character on the current line
currentLineIsBlank = false;
}
}
}
// give the web browser time to receive the data
delay(1000);
// close the connection:
client.stop();
}
}
une fois le programme déversé dans l’arduino , si l’on ouvre le navigateur et que l’on saisi l’adresse 192.168.1.15 , voici ce que donne l’affichage :
on remarque que maintenant la page a un titre “METEO LOCALE” , date et heure sont sur la même ligne et sont mises a jour toutes les 10″ ( seule l’heure varie apres mise a jour).
AJOUT DES CAPTEURS METEO
pour l’étape suivante , ne reste plus qu’a connecter vos capteur météo, pour changer de la version développée ici , nous allons simplifier le montage et remplacer les 2 capteur DHT22 et BMP280 , par un capteur BME280 qui intègre les 3 fonctions; température, pression et Humidité sur un seul module .
c’est un capteur I2C dont le câblage sera donc extrêmement simple, il viendra en parallèle de l’Horloge RTC elle même branchée sur l’I2C. comme toujours avec l’I2C , il faudra contrôler les adresses I2C de chaque composant ( Ici 0x76 pour le capteur BME280 et 0x50 pour l’horloge RTC) et vérifier dans les fichiers des bibliothèques utilisées que les adresses sont les bonnes et faire les modif le cas échéant).
pour cela , on ouvre la bibliotheque “SParFunBME.h” et son fichier complémentaire “SparkFunBME280.cpp” avec un simple editeur de texte genre blocnote de windows, on découvre en general que l’adresse I2C dans la librairie CPP est 0x77 . il faut donc la remplacer par 0x76 et enregistrer le fichier . puis on recompile/televerse le pgme dans l’arduino qui pilote le montage de façon a recuperer la bonne adresse I2C pour le compileur du pgme.
NOTA: la librairie BME280 est en general dans le repertoire “user/nomuser/documents/arduino/librairies”.
voyons maintenant le programme :
par rapport a la version précédente du programme , en violet les ajouts/évolutions concernant le capteur , et pour rendre les données plus visible sur la page , la taille des caractères a été augmentée => ajout d’une ligne ” client.print(“<font size=’10’>”); “
pour aérer la page , chaque information est affichée sur une ligne différente , le saut de ligne se fait par l’envoi d’un client.print(“<br/>”);
#include <Wire.h>
#include <SPI.h>
#include <Ethernet.h>
#include "RTClib.h"
#include <SparkFunBME280.h>
RTC_DS1307 rtc;
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
IPAddress ip(192, 168, 1, 15);
BME280 mySensor;
EthernetServer server(80);
void setup() {
Wire.begin();
rtc.begin();
SPI.begin();
Ethernet.begin(mac, ip);
server.begin();
mySensor.beginI2C();
}
void loop() {
EthernetClient client = server.available();
if (client) {
boolean currentLineIsBlank = true;
while (client.connected()) {
if (client.available()) {
char c = client.read();
Serial.write(c);
if (c == '\n' && currentLineIsBlank) {
client.println("HTTP/1.1 200 OK");
client.println("Content-Type: text/html");
client.println("Connection: close");
client.println("Refresh: 10");
client.println();
client.println("<!DOCTYPE HTML>");
client.println("<html>");
client.println("<head>");
client.println("<meta charset=\"utf-8\"></meta>");
client.println("<title>METEO LOCALE</title>");
client.println("</head>");
client.println("<body>");
DateTime time = rtc.now();
client.print("<font size='10'>");
client.print("Date: ");
client.print(time.timestamp(DateTime::TIMESTAMP_DATE));
client.print("<br/>");
client.print("heure: ");
client.print(time.timestamp(DateTime::TIMESTAMP_TIME));
client.print("<br/>");
client.print("temperature: ");
client.print(mySensor.readTempC());
client.print("<br/>");
client.print("pression: ");
client.print(mySensor.readFloatPressure());
client.print("<br/>");
client.print("Humidité: ");
client.print(mySensor.readFloatHumidity());
client.println("</body>");
client.println("</html>");
break;
}
if (c == '\n') {
currentLineIsBlank = true;
} else if (c != '\r') {
currentLineIsBlank = false;
}
}
}
delay(1000);
client.stop();
}
}
si tout est OK âpres compilation et déversement dans l’ARDUINO UNO , si on ouvre le navigateur sur son PC et que l’on se connecte a l’adresse 192.168.1.15 de l’arduino uno et son ethernet shield on obtient l’affichage ci dessous qui se rafraichis automatiquement toutes les 5 secondes :
