Monitorizarea temperaturii în sala serverelor

Urmărirea condițiilor de bună funcționare într-o incintă destinată serverelor sau oricăror sisteme de calcul cu funcționare continuă reprezintă o funcționalitate importantă. În cadrul proiectului de față vom prezenta un sistem de monitorizare a temperaturii într-o astfel de incintă.

Sistemul de măsurare va fi construit pe baza unei plăci de dezvoltare A-Star 32U4 Micro dar se poate folosi orice altă placă bazată pe microcontrolerul ATmega 32U4 (precum Arduino Leonardo). În plus se va utiliza un senzor de temperatură analogic brick și un afișaj LCD 16×2 cu conectare I2C. Sistemul va funcționa ca termometru de perete (va afișa temperatura ambientală pe afișajul LCD propriu) și ca senzor USB de temperatură pentru un server. Soluția propusă este mult mai ieftină decât soluțiile comerciale prezente pe piață (a se vedea produsele LinkUSB – 1-Wire USB Interface, LinkUSBi – 1-Wire USB Interface, GO-TEMP). Schema de interconectare între componentele sistemului este următoarea:

2

Atât senzorul de temperatură cât și afișajul LCD se vor alimenta la 5V. Senzorul de temperatură va avea ieșirea (pinul OUT) conectat la pinul A0 al plăcii de dezvoltare. Afișajul LCD (modulul I2C al afișajului) va avea pinul SCL conectat la pinul 3 al plăcii de dezvoltare și pinul SDA la pinul 2.

Programul a fost dezvoltat utilizând Arduino IDE 1.8.5 și biblioteca LiquidTWI 1.5.1.

#include <Wire.h>

#include <LiquidTWI.h>

LiquidTWI lcd(0);

Variabila globală aprins va memora starea luminii de fundal pentru afișajul LCD. Funcția readTempInCelsius va efectua citirea senzorului de temperatură (citirea constă într-un număr de achiziții analogice returnându-se media eșantionărilor efectuate).

boolean aprins;

float readTempInCelsius(int count, int pin) {

  float temperaturaMediata = 0;

  float sumaTemperatura = 0;

  if (aprins) lcd.setBacklight(LOW);

  for (int i =0; i < count; i++) {

    int reading = analogRead(pin);

    float voltage = reading * 5.0;

    voltage /= 1024.0;

    float temperatureCelsius = (voltage – 0.5) * 100 ;

    sumaTemperatura = sumaTemperatura +

 temperatureCelsius;

  }

  if (aprins) lcd.setBacklight(HIGH);

  return sumaTemperatura / (float)count;

}

Secțiunea setup() inițializează conexiunea serială și comunicația I2C cu afișajul LCD. Inițial lumina de fundal a afișajului va fi oprită.

void setup() {

  Serial.begin(9600);

  lcd.begin(16, 2);

  aprins = false;

  lcd.setBacklight(LOW);

  lcd.setCursor(0,0);

  lcd.print(„Temperatura:”);

}

În secțiunea loop() se citește temperatura și se afișează pe ecranul LCD la un interval de o secundă. În cazul primirii caracterului t pe serială se va trimite înapoi valoarea temperaturii în acel moment. Tot pe serială se vor putea recepționa comenzi de aprindere sau stingere a iluminatului de fundal pentru ecranul LCD (caracterele h și l).

3

void loop() {

  int t;

  t = Serial.read();

  float temperatura = readTempInCelsius(10,0);

  if (t==’t’) Serial.println(temperatura);

  if (t==’h’) { lcd.setBacklight(HIGH); aprins = true; }

  if (t==’l’) { lcd.setBacklight(LOW); aprins = false; }

  lcd.setCursor(0,1);

  lcd.print(temperatura); lcd.print(” C”);

  delay(1000);

}

Sistemul se va conecta la un server Linux care va citi periodic temperatura ambientală și o va transmite spre înregistrare către serviciul Robofun IoT. Testele au fost realizate pe un server Linux rulând distribuția CentOS 5.11. Pentru citirea și înregistrarea temperaturii s-a utilizat următorul script bash:

#! /bin/bash

t1=$(sensors | grep „Core 0” | sed ‘s/.*:\s*+\(.*\)  .*(.*/\1/’)

t1=${t1:0:2}

curl -X GET ‘http://iot.robofun.ro/api/v1/senzor/…/input?value=’$t1 > /dev/null 2>&1

modprobe cdc_acm

echo „0x1ffb 0x2300” > /sys/bus/usb/drivers/cdc_acm/new_id

stty -F /dev/ttyACM0 9600

echo „t” >/dev/ttyACM0

read -r t2 < /dev/ttyACM0

curl -X GET ‘http://iot.robofun.ro/api/v1/senzor/…/input?value=’$t2 > /dev/null 2>&1

t1=$(($t1+0))

if [ $t1 -gt 45 ]

        then

                echo „h” >/dev/ttyACM0

        else

                echo „l” >/dev/ttyACM0

fi

În cadrul scriptului trebuie personalizate cheile de autentificare pentru cele două valori înregistrate pe serviciul Robofun IoT. Acestea se obțin prin înregistrare gratuită. Pentru a fi rulat în mod automat scriptul va fi trecut în fișierul de configurare /etc/crontab (scriptul va fi rulat la intervale de o oră, se presupune că scriptul a fost salvat sub numele temperature.sh în directorul /root):

# cpu temperature

05 * * * * root /root/temperature.sh

Scriptul va realiza două citiri:

  • În variabila t1 se va salva temperatura nucleului 0 (testele au fost realizate pe o arhitectură multinucleu). Pentru a citi temperatura nucleului s-a utilizat utilitarul sensors. După extragerea temperaturii din informațiile oferite de utilitar aceasta va fi postată pe platforma Robofun IoT.

4

  • În variabila t2 se va salva temperatura temperatura ambientală primită de la senzorul extern USB. Pentru instalarea software a senzorului trebuie să avem în vedere două aspecte:
    • Placa A-Star 32U4 Micro este posibil să fie identificată greșit de sistemul de operare Linux. Este nevoie să aplicăm patch-ul oferit de producătorul plăcii de dezvoltare.
    • Distribuția CentOS 5.11 (pe care s-au realizat testele) este destul de veche. Din acest motiv placa de dezvoltare nu este recunoscută și nu este încărcat în mod automat modulul de nucleu necesar. Din acest motiv vom încărca în mod forțat modulul CDC_ACM (modprobe cdc_acm) și vom forța identificarea plăcii de baza identificatorului USB – VID PID (echo „0x1ffb 0x2300” > …). Pe o distribuție Linux mai nouă este foarte probabil să nu fie necesare aceste comenzi.

Scriptul configurează conexiunea serială (viteză de comunicație 9600bauds), trimite comanda t, citește valoarea temperaturii și o trimite spre înregistrare către platforma Robofun IoT.

5

În final scriptul folosește posibilitatea de comandă serială a iluminatului de fundal a LCD-ului senzorului de temperatură extern USB pentru a semnaliza o temperatură mai mare de 45 de grade pentru nucleul 0. Bineînțeles, sistemul poate fi îmbunătățit pentru a afișa temperatura procesorului serverului – să devină afișaj extern pentru monitorizarea temperaturii procesorului.

Monitorizarea pachetelor WiFi utilizând ESP8266

Spre deosebire de rețelele de comunicație ethernet, rețelele radio fără fir (inclusiv rețelele WiFi) utilizează un mediu de transmisie ce nu poate fi controlat: aerul. Din acest motiv interceptarea pachetelor se poate face de către orice dispozitiv ce poate recepționa traficul radio pe frecvența de emisie. Bineînțeles, în cazul traficului WiFi acest lucru nu înseamnă în mod automat și pierderea confidențialității transmisiei deoarece comunicația este cifrată dar se poate determina numărul de pachete pe un anume canal (încărcarea unui anume canal WiFi).

În cadrul materialului de față vom exemplifica monitorizarea pachetelor WiFi utilizând un circuit WiFi ESP8266, mai exact o placă de dezvoltare Adafruit Feather HUZZAH ESP8266 (se poate utiliza orice placă de dezvoltare bazată pe circuitul ESP8266). Sistemul de monitorizare va dispune și de un ecran OLED monocrom pe care se va afișa graficul evoluției traficului WiFi și de un buton brick ce va permite modificarea canalului WiFi. Comunicația între placa de dezvoltare și ecranul OLED se va face prin intermediul magistralei I2C iar butonul se va conecta la un pin digital al plăcii de dezvoltare.

2

Ecranul OLED va fi alimentat la 3.3V și va avea pinii Clk și Data conectați la pinii SCL (pinul 5) și SDA (pinul 4) ai plăcii de dezvoltare. Butonul va avea ieșirea (OUT) conectată la pinul 0 al plăcii de dezvoltare. ATENȚIE!!! Alimentarea butonului are firele inversate (GND la 3.3V și VCC la GND) deoarece apăsarea butonului se va citi pe 0 logic. Placa de dezvoltare are conectat pe pinul 0 un LED ce se va aprinde la fiecare apăsare a butonului.

Pentru programarea plăcii s-a folosit Arduino IDE 1.8.5 având instalate extensia ESP8266 Community versiunea 2.4.1 și biblioteca ESP8266 and ESP32 Oled Driver for SSD1306 display versiunea 4.0.0. Programul principal se bazează pe PacketMonitor, proiect scris de Stefan Kremser. Versiunea proiectului ce a fost testată este  b6b977b din 5 aprilie 2018. Proiectul necesită următoarele mici modificări în partea de inițializare:

  • Linia 21 va deveni (magistrala I2C e conectată invers față de montajul utilizat în proiect iar adresa afișajului este 0x3c):

SSD1306 display(0x3c, 4, 5);

  • Linia 25 va deveni (butonul este conectat pe linia GPIO0):

#define btn 0

După încărcarea proiectului în memoria plăcii de dezvoltare vom putea monitoriza ce canal WiFi dorim din punctul de vedere al numărului de pachete. Monitorizarea pachetelor nu se va face pentru o anumită rețea WiFi ci pentru toate rețelele WiFi ce utilizează respectivul canal. Graficul de pe ecranul OLED ilustrează istoricul monitorizării. Sistemul poate fi utilizat atât pentru a evalua numărul de pachete radio WiFi din imediata apropiere dar și pentru stabilirea canalului WiFi pentru un nou AP (se va alege, bineînțeles, canalul cel mai puțin aglomerat).

4

Prin apăsarea butonului conectat la pinul GPIO0 se va putea incrementa numărul canalului WiFi monitorizat (de la 1 la 13 ciclic).

5

O altă funcționalitate interesantă a proiectului este detecția atacurilor WiFi de tip dezautentificare. Autorul proiectului prezentat are chiar o versiune de sistem (format dintr-un modul ESP-12 și un LED) dedicat detecției acestui tip de atac specific rețelelor WiFi: DeauthDetector.

6

Mai mult decât atât, Stefan Kremser a conceput o versiune a proiectului ce se bazează pe circuitul ESP32: proiectul PacketMonitor32. Această versiune aduce în plus o facilitate extrem de interesantă: posibilitatea de a înregistra pachetele WiFi interceptate pe o memorie SD card. Conținutul cardului de memorie poate fi analizat ulterior cu un utilitar specializat gen Wireshark.

7

Proiectul prezentat se bazează pe proprietatea circuitului WiFi ESP8266 de a funcționa în mod promiscous adică de a putea intercepta pachete chiar dacă nu îi sunt adresate. Un proiect similar este și proiectul „ESP8266 Mini Sniff”.

Proiect WiFi TV Remote

Proiectul își propune realizarea unei telecomenzi de televizor prin WiFi – un dispozitiv de conversie a comenzilor WiFi în comenzi prin infraroșu specifice unei telecomenzi obișnuite.

Proiectul utilizează un Led Brick Telecomandă Infraroșu:

led-infrarosu

https://www.robofun.ro/electronice/led/led-telecomanda-infrarosu

Această componentă ne va permite să transmitem comenzile către dispozitivul comandat – televizor sau alt dispozitiv care utilizează o telecomandă prin infraroșu.

Pentru implementarea conectivității WiFi proiectul va utiliza o placă de dezvoltare bazată pe controlerul WiFi ESP8266 și anume placa NodeMCU. Chiar dacă nu este o placă din familia Arduino această placă poate fi programată cu ajutorul mediului de dezvoltare Arduino IDE Placa funcționează la 3.3V și se poate alimenta prin intermediul conexiunii USB.

nodemcu

https://www.robofun.ro/wireless/wireless-wifi/NodeMCUv2-ESP8266

Pentru configurarea mediului Arduino IDE se pot urma pașii descriși în materialul ”Quick Start to Nodemcu (ESP8266) on Arduino IDE”:

http://www.instructables.com/id/Quick-Start-to-Nodemcu-ESP8266-on-Arduino-IDE/

Pentru a putea comanda componenta LED Brick vom utiliza o bibliotecă specifică plăcii de dezvoltare NodeMCU – biblioteca IRremoteESP8266 (o adaptare a bibliotecii IRremote pentru ESP8266). Această bibliotecă trebuie instalată separat de componentele specifice plăcii de dezvoltare, adresa de la care poate fi descărcată este:

https://github.com/markszabo/IRremoteESP8266

Schema de interconectare între placa de dezvoltare și modulul LED Brick este simplă:

wifiremotetv_bb

 

Schema de interconectare utilizează un tranzistor NPN 2N3904 pentru a amplifica comanda dată de pinul plăcii de dezvoltare. Astfel pinul IN al LED Brick-ului se va conecta la pinul Vin al plăcii de dezvoltare (este pinul de 5V al alimentării USB) și pinul GND la colectorul tranzistorului. Emitorul tranzistorului se va conecta la masă (GND) și baza va prelua, prin intermediul unui rezistor, comenzile provenite de la pinul D5 (GPIO14) al plăcii de dezvoltare.

O variantă electronică a schemei de interconectare arată în felul următor – rezistorul R2 (180ohm) este integrat în modulul LED Brick:

wifiremotetv_schem

Sistemul va permite trimiterea de comenzi prin infraroșu prin intermediul unei interfețe web simple accesibilă de pe orice sistem (PC sau telefon mobil inteligent) aflat în aceiași rețea ca și sistemul WiFi TV Remote:

screenshot

 

Accesarea interfeței web se poate face cu ajutorul unui client web (browser) accesând adresa IP a sistemului NodeMCU – adresa se preia dinamic (prin DHCP) de către sistem și este afișată în Serial Monitor la pornirea sistemului.

screenshot2

Programul sistemului va utiliza bibliotecile software IRremoteESP8266 (trebuie instalată) și ESP8266WiFi (parte componentă a instalării extensiei ESP8266 pentru mediul Arduino IDE):

#include <IRremoteESP8266.h>

#include <ESP8266WiFi.h>

În program trebuie personalizate datele de conectare la rețeaua WiFi:

const char* ssid = „…..”;

const char* password = „….”;

Comanda către LED Brick se va transmite prin intermediul pinului D5 (GPIO14):

 IRsend irsend(14);

WiFiServer server(80);

În cadrul secțiunii setup() se va inițializa comunicația serială, comunicația cu LED Brick, se va realiza conexiunea WiFi și se va porni componenta web server:

 void setup()

{   Serial.begin(9600);

irsend.begin();

Serial.print(„Connecting to „);

Serial.println(ssid);

WiFi.begin(ssid, password);

while (WiFi.status() != WL_CONNECTED) {

 delay(500);

Serial.print(„.”);

}

Serial.println(„”);

Serial.println(„WiFi connected”);

server.begin();

Serial.println(„Server started”);

Serial.println(WiFi.localIP());

}

În cadrul secțiunii loop() se vor prelua și trata solicitările web (http) provenite de la clienți:

void loop()

{ WiFiClient client = server.available();

if (!client) return;

Serial.println(„new client”);

while(!client.available()){ delay(1); }

String request = client.readStringUntil(‘\r’);

Serial.println(request);

client.flush();

 

Programul implementează trei comenzi specifice unei telecomenzi SONY (Power, P+ și P-). Pentru aflarea altor coduri (pentru alte butoane / pentru alte tipuri de televizoare) se poate consulta materialul ”Telecomanda Universala IR cu Arduino”:

https://www.robofun.ro/forum/viewtopic.php?f=16&t=454

 

if (request.indexOf(„/COMMAND=POWER”) != -1) {

for (int i = 0; i < 3; i++) {

irsend.sendSony(0xa90, 12); // Sony TV power code

delay(40);

}

}

if (request.indexOf(„/COMMAND=PP”) != -1) {

for (int i = 0; i < 3; i++) {

irsend.sendSony(0x90, 12); // Sony P+

delay(40);

}

}

if (request.indexOf(„/COMMAND=PM”) != -1) {

for (int i = 0; i < 3; i++) {

irsend.sendSony(0x890, 12); // Sony P-

delay(40);

}

}

client.println(„HTTP/1.1 200 OK”);

client.println(„Content-Type: text/html”);

client.println(„”);

client.println(„<!DOCTYPE HTML>”);

client.println(„<html>”);

 client.println(„<h1>WiFi TV Remote</h1>”);

 client.println(„<br>”);

client.println(„Click <a href=\”/COMMAND=POWER\”>here</a> to turn ON/OFF the TV<br>”);

client.println(„Click <a href=\”/COMMAND=PP\”>here</a> to change the program [+]<br>”);

client.println(„Click <a href=\”/COMMAND=PM\”>here</a> to change the program [-]<br>”);

client.println(„</html>”);

delay(1);

Serial.println(„Client disonnected”);

Serial.println(„”);

}

Programul a fost realizat și testat cu Arduino IDE 1.6.9, extensia ESP8266 Community 2.3.0 și biblioteca IRremoteESP8266 1.0.0.

 

Sistemul prezentat poate fi folosit și pentru a pune în practică astfel de momente:

https://youtu.be/RWxMqgkW90g

 

Proiectul poate fi completat creând o interfață web mai atrăgătoare, implementând un număr mai mare de comenzi și chiar realizând o telecomandă multi-dispozitiv (comanda mai multor dispozitive utilizând o interfață unică). Mai jos puteți găsi câteva idei de proiecte ce pot fi folosite ca sursă de inspirație:

 

ESP8266 powered Web Controlled Sony Camera Remote

https://youtu.be/D40ZpVjZ744

 

ESP8266 WiFi controlled aircon remote

http://www.instructables.com/id/ESP8266-WiFi-Controlled-Aircon-Remote/

 

Wifi Remote Control using ESP8266

http://www.instructables.com/id/Wifi-Remote-Control-using-ESP8266/

Proiect WiFi Weather Station

Proiectul se bazează pe senzorul Bosch BME280 – senzor integrat de mediu – capabil să măsoare presiunea atmosferică, temperatura în grade C și umiditatea aerului și să ofere, prin intermediul funcțiilor bibliotecii software, temperatura în grade F, altitudinea în metrii / picioare. Cu alte cuvinte, acest senzor este o mică stație meteo într-un singur circuit integrat fiind unul dintre cele mai avansate circuite de acest tip.

BME_280

https://www.bosch-sensortec.com/bst/products/all_products/bme280

Având în vedere formatul extrem de mic (2.5mm x 2.5mm) pentru a putea utiliza acest circuit în cadrul montajului nostru vom folosi modulul Sparkfun Breakout BME280.

BME280Breakout
https://www.robofun.ro/senzori/vreme/sparkfun-atmospheric-sensor-breakout-bme280

Senzorul poate fi conectat la o placă de dezvoltare utilizând magistrala I2C sau SPI (la alegere) și funcționează la tensiunea de alimentare de 3.3V – nu suportă niveluri logice de 5V. Dacă dorim să utilizăm acest senzor cu o placă de dezvoltare ce funcționează la 5V (Arduino Uno, Arduino Mega, Arduino Leonardo) este necesară utilizarea unui convertor de nivel (3.3V-5V):

https://www.robofun.ro/electronice/generale/logic-level-converter-bi-directional .

Senzorul poate fi utilizat fără probleme cu plăci de dezvoltare ce funcționează la 3.3V, câteva exemple:

  • Arduino Pro Mini 328 – 3.3V/8MHz

https://www.robofun.ro/arduino/arduino_pro_mini_328_8mhz

  • Pro Micro 3.3V/8MHz – ATMega 32U4

https://www.robofun.ro/arduino/pro-micro-3-3v-8mhz

  • Arduino Due

https://www.robofun.ro/arduino/arduino-due

  • Arduino Industrial – Olimexino 328

https://www.robofun.ro/platforme/arduino_dev/arduino-industrial

Pentru mai multe detalii legate de funcționarea modulului SparkFun BME280 Breakout se poate parcurge următorul Hookup Guide:

https://learn.sparkfun.com/tutorials/sparkfun-bme280-breakout-hookup-guide

Utilizarea în program a senzorului este facilitată de biblioteca software Sparkfun BME280 Arduino Library ce trebuie instalată sub mediul Arduino IDE înainte de scrierea / încărcarea programului:

https://github.com/sparkfun/SparkFun_BME280_Arduino_Library

Pentru implementarea proiectului vom utiliza o placă de dezvoltare bazată pe controlerul WiFi ESP8266 și anume placa NodeMCU. Chiar dacă nu este o placă din familia Arduino această placă poate fi programată cu ajutorul mediului de dezvoltare Arduino IDE și majoritatea bibliotecilor software funcționează fără probleme – inclusiv Sparkfun BME280 Arduino Library. Placa funcționează la 3.3V și se poate alimenta prin intermediul conexiunii USB. Avantajul major al acestei plăci de dezvoltare este, bineînțeles, conectivitatea de rețea WiFi – scutind necesitatea utilizării unui shield specializat.

nodemcu

https://www.robofun.ro/wireless/wireless-wifi/NodeMCUv2-ESP8266

Pentru configurarea mediului Arduino IDE se pot urma pașii descriși în materialul ”Quick Start to Nodemcu (ESP8266) on Arduino IDE”:

http://www.instructables.com/id/Quick-Start-to-Nodemcu-ESP8266-on-Arduino-IDE/

Conectarea între senzorul BME280 și placa de dezvoltare se va realiza prin intermediul magistralei I2C (conform schemei de interconectare de mai jos):

  • Pinul SCL al senzorului se va conecta la pinul D1 al plăcii de dezvoltare;
  • Pinul SDA al senzorului se va conecta la pinul D2 al plăcii de dezvoltare;
  • Pinul de GND la GND și pinul de 3.3V la 3V3.

 

 

WiFiWeatherStation

Scopul sistemului este acela de a face disponibile informațiile provenite de la senzorul BME280 prin intermediul unei interfețe web (accesibilă de pe orice sistem, PC sau telefon mobil inteligent. din aceiași rețea locală ca și sistemul meteo). Interfața web va afișa timpul de funcționare a sistemului (Uptime), temperatura în grade C (Temperature), un grafic al evoluției temperaturii, umiditatea (Humidity), presiunea atmosferică (Pressure) și altitudinea (Altitude).

screenshot

Accesarea interfeței web se poate face cu ajutorul unui client web (browser) accesând adresa IP a sistemului meteo – adresa se preia dinamic (prin DHCP) de către sistem și este afișată în Serial Monitor la pornirea sistemului.

screenshot2

Programul sistemului se bazează pe exemplul AdvancedWebServer din secțiunea Examples/ESP8266WebServer. În exemplu se inserează partea de achiziție parametrii de la senzorul BME280:

 #include <stdint.h>

#include „SparkFunBME280.h”

#include „Wire.h”

 BME280 mySensor;

 #include <ESP8266WiFi.h>

#include <WiFiClient.h>

#include <ESP8266WebServer.h>

În program trebuie personalizate datele de conectare la rețeaua WiFi:

const char *ssid = „….”;

const char *password = „….”;

ESP8266WebServer server ( 80 );

Led-ul de pe placa de dezvoltare NodeMCU nu este conectat la pinul 13 ci la pinul 0. Mai mult de cât atât, comanda de aprinderea a acestuia se face pe ”0” nu pe ”1”. În cadrul sistemului meteo led-ul de pe placa de dezvoltare se va aprinde la conectarea unui client web.

const int led = D0;

Vectorul temperature_history va stoca valorile de temperatura ce vor folosi la generarea graficului de evoluție.

float temperature_history [39];

int temperature_index = 0;

 char temp[600];

Procedura handleRoot() va construi pagina web la conectarea unui client.

void handleRoot() {

  digitalWrite ( led, 0 );

  int sec = millis() / 1000;

  int min = sec / 60;

  int hr = min / 60;

  temperature_history[temperature_index] = mySensor.readTempC();

  String t = String(temperature_history[temperature_index],2);

  Serial.println(t);

  temperature_index ++;

  if (temperature_index > 38) temperature_index = 0;

  String p = String(mySensor.readFloatPressure(),2);

  Serial.println(p);

  String a = String(mySensor.readFloatAltitudeMeters(),2);

  Serial.println(a);

  String h = String(mySensor.readFloatHumidity(),2);

  Serial.println(h);

  snprintf ( temp, 600,”%02d:%02d:%02d”, hr, (min % 60), (sec % 60));

  String page = „<html>\

    <head>\

      <meta http-equiv=’refresh’ content=’10’/>\

      <title>WiFi Weather Station</title>\

      <style>\

        body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }\

      </style>\

    </head>\

      <body>\

        <h1>WiFi Weather Station</h1>\

        <p><b>Uptime:</b> ” + String(temp) + ” </p>\

        <p><b>Temperature:</b> ” + t + ” C </p>\

        <p><img src=\”/test.svg\” /></p>\

        <p><b>Humidity:</b> ” + h + ” %</p>\

        <p><b>Pressure:</b> ” + p + ” Pa</p>\

        <p><b>Altitude:</b> ” + a + ” m</p>\

      </body>\

    </html>”;

  page.toCharArray(temp,page.length()+1); 

  server.send ( 200, „text/html”, temp );

  digitalWrite ( led, 1 );

}

În secțiunea setup() se va realiza conexiunea la rețeaua WiFi specificată, se va porni și configura conexiunea web pentru deservirea solicitărilor client și se va realiza partea de inițializare a senzorului BME280.

void setup()

{

  Serial.begin(57600);

  pinMode ( led, OUTPUT );

  digitalWrite ( led, 1 );

   WiFi.begin ( ssid, password );

   while ( WiFi.status() != WL_CONNECTED ) {

    delay ( 500 );

    Serial.print ( „.” );

  }

  Serial.println ( „” );

  Serial.print ( „Connected to ” );

  Serial.println ( ssid );

  Serial.print ( „IP address: ” );

  Serial.println ( WiFi.localIP() );

   server.on ( „/”, handleRoot );

  server.on ( „/test.svg”, drawGraph );

  server.on ( „/inline”, []() {

    server.send ( 200, „text/plain”, „this works as well” );

  } );

  server.begin();

  Serial.println ( „HTTP server started” );

   mySensor.settings.commInterface = I2C_MODE;

  mySensor.settings.I2CAddress = 0x77;

  mySensor.settings.runMode = 3; //Normal mode

  mySensor.settings.tStandby = 0;

  mySensor.settings.filter = 0;

  mySensor.settings.tempOverSample = 1;

  mySensor.settings.pressOverSample = 1;

  mySensor.settings.humidOverSample = 1;

   Serial.print(„Starting BME280… result of .begin(): 0x”);

  delay(10);

  Serial.println(mySensor.begin(), HEX);

}

În cadrul secțiunii loop() se vor trata solicitările de conectare client:

void loop() { server.handleClient(); }

Procedura drawGraph() realizează graficul evoluției temperaturii:

void drawGraph() {

  String out = „”;

  char temp[100];

  out += „<svg xmlns=\”http://www.w3.org/2000/svg\” version=\”1.1\” width=\”400\” height=\”150\”>\n”;

  out += „<rect width=\”400\” height=\”150\” fill=\”rgb(250, 230, 210)\” stroke-width=\”1\” stroke=\”rgb(0, 0, 0)\” />\n”;

  out += „<g stroke=\”black\”>\n”;

  int y = (32 – temperature_history[0])*15;

  for (int x = 10; x < 390; x+= 10) {

    int y2 = (32 – temperature_history[x/10])*15;

    sprintf(temp, „<line x1=\”%d\” y1=\”%d\” x2=\”%d\” y2=\”%d\” stroke-width=\”1\” />\n”, x, 70 + y, x + 10, 70 + y2);

    out += temp;

    y = y2;

  }

  out += „</g>\n</svg>\n”;

  server.send ( 200, „image/svg+xml”, out);

}

Programul a fost realizat și testat cu Arduino IDE 1.6.9, extensia ESP8266 Community 2.3.0 și biblioteca Sparkfun BME280 1.0.0.

Proiectul a fost realizat cu ajutorul unui fundal sonor asigurat de albumul Ozzy Osbourne – No More Tears.

Programul poate fi completat foarte ușor cu calculul și afișarea mai multor parametrii (punct de rouă, temperatură resimțită) și chiar cu realizarea unei predicții de evoluție a vremii (pe baza evoluției în timp a presiunii atmosferice).

 

Punct de rouă

https://ro.wikipedia.org/wiki/Punct_de_rou%C4%83

 

What is the AccuWeather RealFeel Temperature?

http://www.accuweather.com/en/weather-news/what-is-accuweather-realfeel/7198202

 

Weather forecasting

https://en.wikipedia.org/wiki/Weather_forecasting

 

 

 

 

gsm & 3G shield breadboard tutorial

Pin to pin compatible, compact and light weight modules and having embedded USB ports, c-uGSM and d-u3G shields (micro) are itbrainpower.net latest GSM / 3G-UMTS shields compatible with Arduino, Raspeberry PI, Raspberry PI2 or with any other 2.8-5V micro-controller board. gSPS adapter it is a „plug and run” SWITCHING POWER SUPPLY companion for c-uGSM and d-u3G shields.
Next, I will show to you how to speed up your GSM / 3G projects prototyping.

What you will need

c-uGSM, d-u3G shields and gSPS hardware references

All examples bellow are demonstrated based on c-uGSM and gSPS 4V [DDRV] (used for direct 3G-GSM shield powering in „NO Lithium Polymer” powering schema).
NO breadboard differences for gSPS 5V [LiPOL] usage (used in „WITH Lithium Polymer” powering), but you will need to connect one Lithium Polymer battery to the CSM or 3G shield.
d-u3G differences – will be revealed later.

3G/GSM shields reference can be seen here. gSPS switching power supply reference may be found here.

GSM 3G shield breadboard prototyping

Solder the strait row headers to the boards.  Solder the barrel connector to the gSPS power supply, if needed.

GSM-3G-shield-breadboard-mount-what-u-need

Hint: 2×10 pin headers can be used for all examples provided and for 99.99% of your projects. In this case, in picture up here, start from right for c-uGSM / left for g-SPS (RX)  to the left for c-uGSM / right for g-SPS and stop at the 10’th pin (STS).

 

Insert the power supply and the GSM shield in the breadboard as bellow pictures. SIM must be installed to the GSM shield, first. 😉


GSM-3G-shield-breadboard-mount-2

GSM-3G-shield-breadboard-mount-1

GSM-3G-shield-breadboard-mount-3

Between boards, a gap of minimum 5 rows it is required. Insulation separator (foam, cardboard,..) must be inserted between boards in order to prevent the SHORT CIRCUITS!

WARNING:
BOARDS MAY BEND WHEN INSERTED AND CAN CAUSE A SHORT CIRCUITS!!! TAKE ALL NECESSARY STEPS TO PREVENT THIS HAPPEN! YOU ARE THE ONLY RESPONSIBLE FOR HARDWARE HANDLING, USAGE AND WIRING!!!

3G shield (d-u3G shield) difference: at insertion moment, ALIGN both sides (TX 2 TX and SLP 2 SLP).

READY! Now you may continue to wire your project connecting other boards, starting from the breadboard contacts.

Credits

published by Dragos Iosub & itbrainpower.net team on http://itbrainpower.net/ projects and how to section