Let’s PI: Zero to IoT

Apariția Raspberry Pi Zero a făcut disponibile funcționalitățile familiei Raspberry Pi la o dimensiune și un cost mult mai mici. La jumătatea dimensiunii unei plăci obișnuite Raspberry Pi, varianta Zero oferă un microprocesor BCM2835 la 1GHz frecvență de funcționare, 512MB memorie RAM, ieșire video mini HDMI, port micro USB OTG, conector cameră și toate facilitățile oferite de sistemul de operare Raspbian.

Singura problemă pentru a utiliza această variantă a plăcii Raspberry Pi este conectivitatea de rețea. Fără a apela la versiunea Zero W, ce oferă conectivitate WiFi, putem utiliza placa Raspberry Pi Zero în proiecte IoT fără nici un fel de problemă. Este recomandată achiziționarea unui kit ce include adaptoarele HDMI – mini HDMI și micro USB OTG – USB precum și bareta de pini deoarece ele sunt absolut necesare în utilizarea plăcii Raspberry Pi Zero. Pentru punerea în funcțiune mai sunt necesare și un card microSD pentru sistemul de operare, se recomandă un card de calitate, și un alimentator de 5V.

După copierea imaginii sistemului de operare pe cardul de memorie avem următoarele opțiuni pentru interacțiunea cu placa Raspberry Pi Zero:

  • Conectăm placa la un monitor cu intrare HDMI (prin intermediul adaptorului mini HDMI – HDMI) și la o tastatură USB (prin intermediul adaptorului micro USB – USB). Această variantă de utilizare ne permite utilizarea plăcii de dezvoltare dar nu oferă nici o facilitate de conectare la Internet.
  • Conectăm, prin intermediul adaptorului micro USB – USB, o placă de rețea USB. Interacțiunea cu placa Raspberry Pi Zero se va face în linie de comandă prin intermediul protocolului SSH (utilizând programul PUTTY de exemplu). Majoritatea plăcilor de rețea, mai ales cea indicată, vor fi văzute în mod automat de sistemul de operare Raspbian și nu vor necesita nici o operație de instalare / configurare suplimentară. Pentru a activa serviciul SSH încă de la prima pornire a plăcii este necesară creare unui fișier gol cu numele ssh pe cardul pe care copiem sistemul de operare (a se vedea și „Enable SSH when creating SD card”). Bineînțeles, se poate utiliza un adaptor de rețea WiFi în locul celui Internet dar probabilitatea ca acest tip de adaptoare să necesite operații suplimentare de instalare / configurare este mai mare, cu alte cuvinte nu ne vom putea conecta din prima la placă fără tastatură și monitor.
  • Este posibilă combinarea celor două soluții anterioare dar este necesară utilizarea unui hub USB – placa de dezvoltare are un singur port USB OTG și este necesară conectarea tastaturii și a adaptorului de rețea. Este o soluție ce complică destul de mult utilizarea plăcii, este de preferat achiziționarea unei plăci Raspberry Pi 3.

Vom exemplifica realizarea sistemului IoT utilizând cea de a doua opțiune: placa Raspberry Pi Zero, adaptor micro USB – USB și placă de rețea USB. Ca serviciu IoT vom utiliza serviciul gratuit Robofun IoT iar datele raportate vor proveni de la un senzor digital de temperatură și umiditate SHT11. Conectarea dintre senzorul digital și placa de dezvoltare se face în felul următor:

3

Senzorul se va alimenta la 3.3V, pinul SCK se va conecta la pinul 23 iar pinul DAT la pinul 18. Pentru configurarea și scrierea programului IoT ne vom conecta la placa Raspberry Pi Zero prin SSH utilizând Putty. Este recomandată aducerea la zi a pachetelor software:

# sudo apt-get update

# sudo apt-get upgrade

Programul va fi scris în limbajul Python și va utiliza biblioteca pi-sht1x, pentru instalarea acesteia vom executa:

# sudo apt-get install python3-pip

# pip3 install pi-sht1x

Testele au fost realizate sub Raspbian 9, kernel 4.14.34+, Python 3.5.3 și pi-sht1x 1.0.9. Programul utilizat este următorul (PiZeroIoT.py):

import RPi.GPIO as GPIO

from pi_sht1x import SHT1x

import urllib.request

DATA_PIN = 18

SCK_PIN = 23

with SHT1x(DATA_PIN, SCK_PIN, gpio_mode=GPIO.BCM) as sensor:

temp = sensor.read_temperature()

humidity = sensor.read_humidity(temp)

SENSOR1_TOKEN="…"

SENSOR2_TOKEN="…"

urllib.request.urlopen("http://iot.robofun.ro/api/v1/senzor/"+SENSOR1_TOKEN+"/input?value="+str(temp)).read()

urllib.request.urlopen("http://iot.robofun.ro/api/v1/senzor/"+SENSOR2_TOKEN+"/input?value="+str(humidity)).read()

Variabilele SENSOR1_TOKEN și SENSOR2_TOKEN trebuie completate cu datele obținute în urma definirii a doi senzori în cadrul platformei Robofun IoT. Pentru a executa programul în mod automat la anumite intervale de timp vom crea o intrare în fișierul de configurare a serviciului cron (/etc/crontab) de forma (execuție la 10 minute):

*/10 *  * * *   pi      python3 /home/pi/PiZeroIoT.py

După repornirea sistemului, fără a ne conecta la placă, programul se va executa în mod automat și vom putea vedea graficele pentru temperatură și umiditate în interfața serviciului IoT:

4

5

Cum să realizăm un sistem IoT LoRaWAN

În cadrul proiectului ”LoRa meets Robofun IoT” am văzut cum putem realiza un sistem IoT utilizând comunicația radio LoRa. Utilizând module radio LoRa putem transmite date la mare distanță dar pentru implementarea unui sistem IoT este necesară implementarea atât a modulului de achiziție (sau acționare) cât și a sistemului de tip gateway ce face legătura cu rețeaua Internet și cu serviciile cloud IoT. Specificațiile LoRaWAN permit implementare unor rețele radio LoRa standardizate astfel încât sistemele gateway să permită conectarea dispozitivelor IoT după un set de reguli larg acceptate. Realizarea unui sistem IoT LoRaWAN presupune realizare unui sistem de achiziție / acționare care respectă acest set de reguli și se conectează la o infrastructură de gateway-uri deja existentă (nu mai este nevoie să realizăm și să operăm sistemul gateway). Există mai multe rețele de gateway-uri LoRaWAN dar în cadrul acestui proiect vom arăta cum putem realiza un sistem ce folosește rețeaua TTN (The Things Network). Accesul în rețeaua TTN este gratuit deoarece se bazează pe gateway-uri particulare partajate între utilizatorii rețelei. Tot ce trebuie să faceți este să verificați dacă vă aflați în aria de acoperire a unui sistem gateway TTN.

Pentru sistemul IoT vom utiliza o placă de dezvoltare Arduino Uno și un shield Dragino LoRa echipat cu un modul radio LoRa în frecvență de 868MHz. Pentru partea de achiziție vom exemplifica măsurarea temperaturii utilizând un senzor brick conectat la pinul analogic A0 al plăcii de dezvoltare.

3

Pentru implementarea comunicației LoRaWAN vom utiliza biblioteca Arduino-LMIC. Testele au fost realizate utilizând Arduino IDE 1.8.3 și versiunea 1.5.0+arduino-1 a bibliotecii. Programul pleacă de la exemplul ttn-abp al bibliotecii în care vom efectua o serie de mici modificări. În primul rând trebuie să înregistrăm sistemul pe platforma TTN pentru a obține datele de autentificare în rețea:

static const PROGMEM u1_t NWKSKEY[16] = { … };

static const u1_t PROGMEM APPSKEY[16] = { … };

static const u4_t DEVADDR = … ;

Înregistrarea presupune crearea unui cont de utilizator, definirea unei aplicații (Applications) și, în cadrul aplicației, definirea unui dispozitiv (Device). În secțiunea se setări (Settings) a noului dispozitiv trebuie aleasă metoda ABP de activare și debifată opțiunea Frame Counter Checks. Tot în cadrul acestei secțiuni se regăsesc datele de autentificare în rețeua TTN. Pentru mai multe detalii legate de definirea aplicației și dispozitivului în rețeua TTN se poate consulta și materialul „LoRaWAN IoT with Arduino Uno, Dragino v1.3 & TheThingsNetwork”.

4

Tot în secțiunea de inițializare a exemplului se va șterge declarația mesajului mydata (se va defini din nou în program sub o altă formă) și se va modifica intervalul de postare a mesajelor (postarea la 1 minut este destul de agresivă pentru politica de utilizare a rețelei TTN).

const unsigned TX_INTERVAL = 3600;

Shield-ul Dragino LoRa necesită următoarea modificare în structura de definire a pinilor utilizați:

const lmic_pinmap lmic_pins = {

    .nss = 10,

    .rxtx = LMIC_UNUSED_PIN,

    .rst = 9,

    .dio = {2, 6, 7},

};

Ultima modificare adusă exemplului ttn-abp este rescrierea procedurii do_send pentru a trasmite valoare achiziționată de la brick-ul de temperatură în locul mesajului text predefinit. După cum se poate observa se va transmite valoarea returnată de funcția analogRead, prelucrarea numerică pentru a obține valoarea temperaturii se va face în sistemul cloud TTN.

void do_send(osjob_t* j){

    static uint8_t mydata[2];

    int reading = analogRead(A0);

    mydata[0] = highByte(reading);

    mydata[1] = lowByte(reading);

    if (LMIC.opmode & OP_TXRXPEND) {

        Serial.println(F(“OP_TXRXPEND, not sending”));

    } else {

        LMIC_setTxData2(1, mydata, sizeof(mydata), 0);

        Serial.println(F(“Packet queued”));

    }

}

După punerea în funcțiune a sistemului, și dacă vă aflați în aria de acoperire a unui gateway TTN, în consola TTN vor începe să apară valorile transmise de acesta (secțiunea Application Data). După cum se poate observa datele transmise sunt sub forma unui șir de valori în hexazecimal (2 octeți – 16 biți).

5

Pentru a transforma datele primite într-o formă mai ușor de înțeles se va scrie o funcție de decodare (în secțiunea Payload Formats / decoder). Această funcție va avea și rolul de a calcula temperatura echivalentă valorii achiziționate. După implementarea acestei funcții vom putea vedea în secțiunea de Application Data valoarea efectivă a temperaturii.

function Decoder(bytes, port) {

  var decoded = (((((bytes[0]<<8)|bytes[1])*5.0)/1024.0)-0.5)*100;

  return { value:decoded };

}

6

Atenție!!! Platforma TTN nu este o platformă IoT – nu stochează datele preluate de la sistemele LoRaWAN. Datele se pot observa în consolă doar dacă sunt transmise atunci când consola este deschisă. Platforma TTN permite în schimb transmiterea datelor primite prin rețeaua LoRaWAN către alte platforme online inclusiv platforme IoT. În secțiunea Integrations se pot defini diverse mecanisme automate de redirectare a datelor către sisteme precum Cayenne, OpenSensors sau IFTTT. Vom explica în cele ce urmează cum putem transmite datele către serviciul IFTTT care ne va trimite apoi valoarea temperaturii prin email. Bineînțeles, multitudinea de opțiuni oferite de platforma IFTTT permite redirectarea datelor către un serviciu IoT, postarea pe o rețea de socializare sau interacțiunea directă cu alte dispozitive IoT.

Definirea mecanismului automat de trimitere a datelor către serviciului IFTTT presupune adăugarea unui integrator de tipul IFTTT Maker (add integration / secțiunea Integrations). Conexiunea între cele două servicii (TTN și IFTTT) se realizează pe baza Event Name (trebuie să fie identic cu numele declanșatorului IFTTT) și Key (cheie de autentificare oferită de obiectul IFTTT Webhooks).

7

În cadrul platformei IFTTT se va realiza o regulă ce va avea declanșator serviciul Webhooks (Event Name trebuie să fie identic cu cel definit în platforma TTN) și ca efect transmiterea unui email.

8

La fiecare valoare a temperaturii transmisă de sistemul nostru vom primi un email de forma:

9

Pentru mai multe variante de realizare a unui sistem IoT LoRaWAN se pot consulta și următoarele materiale:

LoRa meets Robofun IoT

Modulele radio LoRa oferă posibilitatea de a transmite date la distanță mare (sute de metri sau chiar kilometri) utilizând module electronice de cost redus și cu un consum de energie scăzut. Acest lucru constituie o metodă eficientă pentru a extinde aria de acoperire pentru rețelele IoT fără fir. Chiar dacă semnalul WiFi are o acoperire limitată fiind influențat de puterea dispozitivelor de tip AP și de mediul în care operează (câmp deschis, locuințe sau birouri) există posibilitatea să extindem aria de acoperire radio a unei rețele IoT prin intermediul comunicațiilor ISM iar soluțiile LoRa oferă o variantă foarte bună cost / arie de acoperire.

Pentru a implementa o soluție LoRa în vederea extinderii ariei de acoperire IoT vom implementa un sistem gateway ce va realiza transferul datelor provenite de la modulele IoT către un sistem specific IoT și anume Robofun IoT. Modulul gateway propus se bazează pe placa de dezvoltare NodeMCU ce oferă conectivitate WiFi și un modul LoRa RFM96W în bandă de 433MHz. Conexiuniile între placa de dezvoltare și modulul radio sunt prezentate în diagrama următoare:

2.png

Modulul radio RFM96W se interconectează cu placa de dezvoltare prin intermediul magistralei SPI:

  • Pinul SCK al modulului se conectează la pinul D5 (GPIO14 – HSCLK);
  • Pinul MISO se conectează la pinul D6 (GPIO12 – HMISO);
  • Pinul MOSI se conectează la pinul D7 (GPIO13 – HMOSI);
  • Pinul CS se conectează la pinul D2;
  • Pinul RST se conectează la pinul D3;
  • Pinul G0 (INT) se conectează la pinul D1;
  • Vin și GND la pinii 3.3V și GND ai plăcii de dezvoltare.

Pentru ca placa să poată transmite prin Internet datele către serviciul Robofun IoT este necesară înregistrarea gratuită pe platformă:

3

După înregistrare și conectare este necesară definirea (Adauga senzor) a trei senzori: Temperatura, Umiditate și Nivel baterie, pentru a putea transmite datele primite de la sistemul IoT către platforma online. După definirea fiecărui senzor este necesar să copiem cheia de autentificare (Token) pentru a fi utilizată în program.

4

5

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.8.3 (pentru instalarea plăcii NodeMCU sub Arduino IDE se poate vedea materialul „Quick Start to Nodemcu (ESP8266) on Arduino IDE”), extensia esp8266 versiunea 2.3.0 și biblioteca RadioHead 1.7.9. În cadrul programului trebuie personalizate datele de conectare la rețeaua WiFi (ssid și password) precum și cheile de autentificare pentru cele trei canale IoT (SENSOR_TOKEN1, SENSOR_TOKEN2 și SENSOR_TOKEN3).

#include <SPI.h>

#include <RH_RF95.h>

#include <ESP8266WiFi.h>

#include <ESP8266HTTPClient.h>

const char* ssid = “…”;

const char* password = “…”;

#define RFM95_CS D2

#define RFM95_RST D3

#define RFM95_INT D1

#define RF95_FREQ 434.0

RH_RF95 rf95(RFM95_CS, RFM95_INT);

#define LED D0

void setup() {

  pinMode(LED, OUTPUT);

  digitalWrite(LED,HIGH);    

  pinMode(RFM95_RST, OUTPUT);

  digitalWrite(RFM95_RST, HIGH);

  Serial.begin(9600);

  delay(100);

  Serial.println();

  Serial.println();

  Serial.println(“Gateway Module starting…”);

  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”);

  digitalWrite(RFM95_RST, LOW);

  delay(10);

  digitalWrite(RFM95_RST, HIGH);

  delay(10);

  while (!rf95.init()) {

    Serial.println(“LoRa radio init failed”);

    while (1);

  }

  Serial.println(“LoRa radio init OK!”);

  if (!rf95.setFrequency(RF95_FREQ)) {

    Serial.println(“setFrequency failed”);

    while (1);

  }

  Serial.print(“Set Freq to: “);

  Serial.println(RF95_FREQ);

}

typedef struct {float temperature; float humidity;

float bat_voltage;} ParametriiRX;

ParametriiRX parametrii;

Ledul de pe placa de dezvoltare (conectat pe pinul D0) se va aprinde pe perioada recepției de mesaje LoRa. Toate datele primite prin intermediul LoRa vor fi postate pe platforma Robofun IoT. Sistemul va raporta și în consola serială toate mesajele recepționate.

6

void loop() {

  if (rf95.available())  {

    uint8_t buf[RH_RF95_MAX_MESSAGE_LEN];

    uint8_t len = sizeof(buf);

    if (rf95.recv(buf, &len)){

      digitalWrite(LED, LOW);

      RH_RF95::printBuffer(“Received: “, buf, len);

      parametrii = *(ParametriiRX*)buf;

      Serial.print(“Temperature: “);

      Serial.println(parametrii.temperature);

      Serial.print(“Humidity: “);

      Serial.println(parametrii.humidity);

      Serial.print(“Battery Voltage: “);

      Serial.println(parametrii.bat_voltage);

      Serial.print(“RSSI: “);

      Serial.println(rf95.lastRssi(), DEC);

      digitalWrite(LED, HIGH);

      String SENSOR_TOKEN1=”…”;

      String SENSOR_TOKEN2=”…”;

      String SENSOR_TOKEN3=”…”;

      HTTPClient http;

      String data = String(“http://iot.robofun.ro/api/v1/senzor/&#8221;) + SENSOR_TOKEN1 + “/input?value=” + String(parametrii.temperature, DEC);

      http.begin(data);

      int httpCode = http.GET();

      http.end();

      data = String(“http://iot.robofun.ro/api/v1/senzor/&#8221;) + SENSOR_TOKEN2 + “/input?value=” + String(parametrii.humidity, DEC);

      http.begin(data);

      httpCode = http.GET();

      http.end();

      data = String(“http://iot.robofun.ro/api/v1/senzor/&#8221;) + SENSOR_TOKEN3 +  “/input?value=” + String(parametrii.bat_voltage, DEC);

      http.begin(data);

      httpCode = http.GET();

      http.end();    }

    else    {

      Serial.println(“Receive failed”);    }

  }

}

Modulul LoRa ce va beneficia de extinderea ariei de comunicație (se poate afla la sute de metri, sau chiar kilometri în spațiu deschis, de aria de acoperire WiFi) se bazează pe placa de dezvoltare Feather M0 RFM95 433MHz LoRa – placă ce combină puterea unui microcontroler ARM Cortex-M0+ ATSAMD21 (la fel ca și plăcile Arduino M0/Zero) cu conectivitatea unui modul radio LoRa. Placa de dezvoltare va transmite către modulul gateway date preluate de la un senzor digital I2C de temperatură și umiditate Si7021 precum și nivelul bateriei proprii (unul dintre avantajele majore ale plăcilor Feather este posibilitatea de alimentare mobilă de la un acumulator LiPo de 3.7V).

Pentru mai multe informații legate de utilizarea plăcii Feather M0 RFM95 puteți consulta și materialul: „Adafruit Feather M0 Radio with LoRa Radio Module”.

Schema de interconectare între senzor și placa de dezvoltare este specifică unei magistrale I2C (pinii SDA și SCL conectați între senzor și placa de dezvoltare, alimentarea senzorului se va face la 3.3V):

7

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.8.3, extensia Adafruit SAMD Boards 1.0.19 și bibliotecile RadioHead 1.7.9, Adafruit Si7021.

Decomentarea directivei debug va permite observarea funcționării modulului în consola serială.

//#define debug

7.5

#include <SPI.h>

#include <RH_RF95.h>

#define VBATPIN A7

#include <Adafruit_Si7021.h>

Adafruit_Si7021 sensor = Adafruit_Si7021();

#define RFM95_CS 8

#define RFM95_RST 4

#define RFM95_INT 3

#define RF95_FREQ 434.0

RH_RF95 rf95(RFM95_CS, RFM95_INT);

void setup() {

  pinMode(RFM95_RST, OUTPUT);

  digitalWrite(RFM95_RST, HIGH);

  sensor.begin();

  #ifdef debug

    while (!Serial);

    Serial.begin(9600);

    delay(100);

    Serial.println(“LoRa Sensor Module starting…”);

  #endif

  digitalWrite(RFM95_RST, LOW);

  delay(10);

  digitalWrite(RFM95_RST, HIGH);

  delay(10);

  while (!rf95.init()) {

    #ifdef debug

      Serial.println(“LoRa radio init failed”);

    #endif

    while (1);

  }

  #ifdef debug

    Serial.println(“LoRa radio init OK!”);

  #endif

  if (!rf95.setFrequency(RF95_FREQ)) {

    #ifdef debug

      Serial.println(“setFrequency failed”);

    #endif

    while (1);

  }

  #ifdef debug

    Serial.print(“Set Freq to: “);

    Serial.println(RF95_FREQ);

  #endif

  rf95.setTxPower(23, false);

}

typedef struct {float temperature; float humidity;

float bat_voltage;} ParametriiTX;

ParametriiTX parametrii;

void loop() {

  float voltage = analogRead(VBATPIN);

  voltage *= 2;   

  voltage *= 3.3;

  voltage /= 1024;

  parametrii.bat_voltage = voltage;

  parametrii.temperature = sensor.readTemperature();

  parametrii.humidity = sensor.readHumidity();

  #ifdef debug

    Serial.print(“Sample OK: “);

    Serial.print(parametrii.temperature);

   Serial.print(” *C, “);

    Serial.print(parametrii.humidity);

    Serial.println(” %”);

    Serial.print(“VBat: ” ); Serial.println(voltage);

    Serial.println(“Sending to Gateway Module”);

    Serial.println(“Sending…”); delay(10);

  #endif

  RH_RF95::printBuffer(“Sending: “, (uint8_t*)&parametrii, sizeof parametrii);

  #ifdef debug

    Serial.println(“Sending…”); delay(10);

  #endif

  rf95.send((uint8_t *)&parametrii, sizeof parametrii);

  #ifdef debug

    Serial.print(“Waiting for packet to complete…”);

delay(10);

  #endif

  rf95.waitPacketSent();

  #ifdef debug

    Serial.println(“done.”); delay(10);

  #endif

  delay(100);

  rf95.sleep();

  delay(60000);

}

După programarea și punerea în funcțiune a celor două sisteme se pot observa datele înregistrate în cadrul platformei Robofun IoT (capturile de ecran de mai jos reprezintă date înregistrate de sistemul de test pentru temperatură și umiditate).

8

9

Bineînțeles, sistemul LoRa poate deservi atât sisteme de achiziție (temperatură, umiditate, presiunea în diverse conducte, consumul de energie electrică, nivelul radiației solare etc.) dar și sisteme de acționare (chiar dacă nu a fost exemplificată această parte este posibil să comandăm de la distanță diverse mecanisme de închidere / deschidere, motoare etc).

Ce putem face cu datele înregistrate pe Robofun IoT?

Înregistrarea datelor în cloud este una dintre cele mai sigure metode de păstrare a datelor. Accesibilitatea acestora este, în același timp, un avantaj major în cazul vizualizării online. Serviciul cloud Robofun IoT oferă ambele avantaje permițând utilizatorilor să-și păstreze în siguranță datele provenite de la senzorii și sistemele de monitorizare electronică și să aibă disponibile informațiile de oriunde există o conexiune Internet. Dar, mai mult decât atât, datele stocate de serviciul Robofun IoT sunt disponibile pentru a fi preluate de alte servicii cloud și pot da naștere unor aplicații Internet colaborative de prelucrare și gestionare a informațiilor provenite de la dispozitivele IoT.

Datele stocate de serviciul Robofun IoT sunt disponibile utilizatorilor sub forma unei structuri JSON accesibile prin intermediul protocolului HTTP. Astfel, accesând URL-ul:

http://iot.robofun.ro/api/v1/senzor/[aici_introduceti_tokenul_senzorului]/data.json

vom putea vedea toate datele înregistrate de serviciu pentru un anume senzor.

2

Datele în format JSON pot fi preluate și introduse într-o bază de date locală pentru a deservi o aplicație web sau desktop proprie. Se poate vedea proiectul software „json-to-mysql” care permite salvarea unei structuri JSON într-o bază de date MySQL. Totuși, nu este nevoie scrierea unei aplicații proprii pentru a putea utiliza datele stocate în cadrul serviciului Robofun IoT.

O soluție foarte simplă este preluarea datelor într-un fișier Google Sheets. Această soluție este descrisă amănunțit în materialul „How to import JSON data into Google Spreadsheets in less than 5 minutes”. Pentru preluarea datelor se crează un fișier Google Sheets în Google Drive și în modul de editare se selectează Tools / Script editor… .

3

4

Se șterge codul implicit și se copiază codul de la adresa (5) în fișierul de script asociat fișierului Google Sheets. Fișierul de cod se redenumește  ImportJSON.gs și se salvează.

Întoarcându-ne în fișierul Google Sheets vom edita prima celulă din tabel și vom înscrie în aceasta:

=ImportJSON(“http://iot.robofun.ro/api/v1/senzor/[aici_introduceti_tokenul_senzorului] /data.json”)

În mod automat tabelul va prelua la fiecare deschidere datele complete din serviciul Robofun IoT.

5

În momentul în care datele provenite de la senzori se regăsesc în fișierul Google Sheets aceste pot fi folosite ca intrări pentru alte servicii online. Un serviciu online foarte interesant ce oferă posibilitatea interconectării între diverse funcționalități Internet este Zapier.

6

Acesta oferă posibilitatea creării unui cont gratuit și pe baza acestuia este posibilă interconectarea de diverse servicii specifice Internet (email, rețele sociale, servicii de stocare cloud a fișierelor etc.). În cazul nostru vom crea două aplicații (Zaps) ce se vor baza pe informațiile din fișierul Google Sheets. Una dintre aplicații va transforma datele din tabelul Google Sheets într-un flux RSS iar cea de a doua va prelua fiecare linie nouă din tabel și o va transforma într-o postare Facebook.

7

Prima aplicație are ca scop transformarea datelor provenite de la senzor într-un flux RSS astfel încât să poată fi disponibile mai rapid în diverse aplicații de știri. Pentru această aplicație vom alege ca declanșator (Trigger App) Google Sheets – New Spreadsheet Row. Pentru ca serviciul Zapier să poată accesa fișierele de pe Google Drive este necesară acordarea unei permisiuni între cele două servicii. Ca acțiune asociată (Zapier Action) vom alege RSS – serviciu oferit intern de platforma Zapier. După configurarea opțiunilor specifice fluxului RSS și salvarea aplicației vom putea deja să vedem datele pe canalul RSS (datele postate de senzor).

8

Cea de a doua aplicație propusă ilustrează utilizarea datelor provenite de la senzor (via Robofun IoT și Google Sheets) pentru a construi o postare pe rețeaua de socializare Facebook. Vom utiliza același declanșator ca și în cazul precedent dar vom utiliza ca acțiune din secțiunea Facebook – Create Page Post. La fel ca și în cazul precedent este necesar să acordăm permisiunea serviciului Zapier pentru a posta pe pagina noastră de Facebook. După definitivarea configurației la fiecare nouă înregistrare de la senzorul nostru va apărea o postare pe Facebook.

9

Cele două aplicații date ca exemplu sunt doar pentru a vă stârni interesul. Posibilitățile oferite de serviciul Zapier sunt extrem de diverse și includ posibilitatea de interconectare cu alte rețele sociale (Twitter, LinkedIn, Instagram) și servicii Internet (email, Google Forms, servicii online de predicție a vremii, servicii de tipărire online, servicii de SMS online etc.). Aplicațiile pe care le puteți genera utilizând date IoT și servicii online sunt limitate ca diversitate doar de propria imaginație.

Pedometru IoT

Dispozitivele de tip pedometru (dispozitive ce contorizează numărul de pași) sunt din ce în ce mai populare. La acest lucru a condus pe de o parte scăderea prețului dispozitivelor electronice dar și necesitatea psihologică de a avea un ”martor” la eforturile personale de a ne menține în formă. Pedometrele variază ca funcționalitate de la simple dispozitive ce afișează pe un ecran numărul de pași până la dispozitive ce raportează prin protocoale fără fir către telefon sau tabletă numărul de pași permițând astfel generarea de rapoarte pe diverse intervale de timp și chiar clasamente între mai multe persoane.

În cadrul proiectului de față vă propunem implementarea unui dispozitiv de tip pedometru ce raportează numărul de pași prin Internet către serviciul cloud Robofun IoT. Serviciul cloud Robofun IoT este gratuit și permite înregitrarea și vizualizarea datelor prin intermediul unei interfețe web, pentru mai multe detalii puteți consulta documentația oficială a serviciului.

Există mai multe exemple de proiecte ce își propun implementarea funcționalității de pedometru dar nu și funcționalitatea de înregistrare online a datelor. Totuși, putem parcurg câteva astfel de proiecte pentru a înțelege diverse soluții de implementare: „Arduino Pedometer”, „Simple, Easy and Cheap DIY Pedometer With Arduino”, „Arduino Pedometer Watch, With Temperature, Altitude and Compass!”.

Dispozitivul prezentat va utiliza, pentru a putea sesiza fenomenul de ”pas”, un accelerometru digital ADXL345. Analiza fenomenelor fizice implicate (accelerații, recunoașterea tiparului generat de efectuarea unui pas) nu fac subiectul acestei lecții dar recomandăm parcurgerea suplimentară a următorului material: „Full-Featured Pedometer Design Realized with 3-Axis Digital Accelerometer”.

Partea de achiziție a datelor și de comunicație în rețea va fi asigurată de o placă de dezvoltare Sparkfun ESP32 Thing – placă echipată cu microprocesorul ESP32 de la Espressif ce asigură conectivitate WiFi și BLE (chiar dacă dispozitivul prezentat exemplifică doar partea de conectivitate WiFi asta nu înseamnă că acesta nu poate fi dezvoltat suplimentar pentru a putea asigura conectivitate BLE cu dispozitive mobile de tip telefon sau tabletă). Pe lângă puterea de procesare și conectivitatea WiFi placa de dezvoltare oferă avantajul de a funcționa alimentată de la un acumulator LiPo de 3.7V permițând astfel ca sistemul să fie portabil.

Schema de interconectare între placa de dezvoltare și accelerometru este următoarea (accelerometrul se va alimenta la 3.3V, pinul SDA se va conecta la pinul 21 al plăcii de dezvoltare iar SCL la pinul 22, pinul CS se va conecta la 3.3V iar SD0 la GND):

2

Pentru integrarea plăcii Sparkfun ESP32 Thing în mediul Arduino IDE este necesar să parcurgeți materialul „ESP32 Thing Hookup Guide” deoarece sunt necesare operații manuale de copiere și instalare a utilitarelor aferente.

Programul va utiliza, pentru detecția numărului de pași, bibliotecile Pedometer și Accelerometer_ADXL345 a celor de la Seeed-Studio.

Programul a fost dezvoltat și testa utilizând Arduino IDE 1.8.3. În program trebuie personalizate datele de conectare la rețeaua WiFi (networkName și networkPswd).

#include <WiFi.h>

#include “pedometer.h”

#include <ADXL345.h>

Pedometer pedometer;

#include <Wire.h>

const char * networkName = ““;

const char * networkPswd = ““;

const char * hostDomain = “iot.robofun.ro”;

const int hostPort = 80;

const int BUTTON_PIN = 0;

const int LED_PIN = 5;

În cadrul secțiunii setup() se vor realiza inițializările necesare. Placa de dezvoltare are integrate un led (pinul 5) și un buton (pinul 0). Ledul va indica (se va aprinde) activitățile de rețea din program (conectare AP, postare IoT) iar butonul va fi utilizat pentru a reseta numărul de pași efectuați.

void setup() {

  Serial.begin(115200);

  pinMode(BUTTON_PIN, INPUT_PULLUP);

  pinMode(LED_PIN, OUTPUT);

  digitalWrite(LED_PIN, HIGH);

  pedometer.init();

  connectToWiFi(networkName, networkPswd);

  digitalWrite(LED_PIN, LOW); }

Constanta INTERVAL va indica perioda de timp (în milisecunde) la care se va face transmiterea numărului de pași efectuați către serviciul IoT.

#define INTERVAL 60000

unsigned long lastPost = 0;

void loop() {

  if (digitalRead(BUTTON_PIN) == LOW)

pedometer.stepCount = 0;

  if((millis() – lastPost) > INTERVAL) {

    digitalWrite(LED_PIN, HIGH);

    if (WiFi.status() != WL_CONNECTED)

connectToWiFi(networkName, networkPswd);

    requestURL(hostDomain, hostPort);

    digitalWrite(LED_PIN, LOW);

    lastPost = millis();

  }

  delay(10);

}

Procedura connectToWiFi() este responsabilă cu conectarea la rețeaua WiFi.

void connectToWiFi(const char * ssid, const char * pwd)

{ int ledState = 0;

  Serial.println(“Connecting to WiFi network: ” + String(ssid));

  WiFi.begin(ssid, pwd);

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

    digitalWrite(LED_PIN, ledState);

    ledState = (ledState + 1) % 2;

    delay(500);

    Serial.print(“.”);

  }

  Serial.println();

  Serial.println(“WiFi connected!”);

  Serial.print(“IP address: “);

  Serial.println(WiFi.localIP());

}

Procedura requestURL() este responsabilă cu postarea către serviciul IoT. În cadrul acesteia trebuie completată valoarea cheii de autentificare (TOKEN) obținute în urma înregistrării în cadrul serviciului Robofun IoT.

void requestURL(const char * host, uint8_t port) {

  Serial.println(“Connecting to domain: ” + String(host));

  WiFiClient client;

  if (!client.connect(host, port))  {

    Serial.println(“connection failed”);

    return;

  }

  Serial.println(“Connected!”);

  pedometer.stepCalc();

client.print((String)”GET /api/v1/senzor/TOKEN/input?value=” + String(pedometer.stepCount) + “HTTP/1.1\r\n” +  “Host: ” + String(host) + “\r\n” +  “Connection: close\r\n\r\n”);

  unsigned long timeout = millis();

  while (client.available() == 0)

  {

    if (millis() – timeout > 5000)

    {

      Serial.println(“>>> Client Timeout !”);

      client.stop();

      return;

    }

  }

  while (client.available())  {

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

    Serial.print(line);

  }

  Serial.println();

  Serial.println(“closing connection”);

  client.stop();

}

Sistemul va posta în mod automat numărul de pași la un interval de 10 minute. În cazul în care ieșim din aria de acoperire WiFi sistemul va contoriza în continuarea numărul de pași efectuați și la reîntoarcere va realua raportarea. Astfel vom putea evalua numărul de pași efectuați și ”în casă” și afară. Resetarea numărului de pași se va face apăsând butonul de pe pinul 0 al plăcii de dezvoltare.

3

IoT Power Monitor

Măsurarea consumului echipamentelor electronice este o preocupare continuă în domeniul monitorizării utilizării energiei electrice. Evoluția sistemelor IoT a făcut posibilă apariției unor echipamente de monitorizare a consumului ce raportează datele măsurate prin intermediul rețelei Internet direct către un serviciu cloud. În cadrul acestui proiect vom prezenta construcția unui astfel de sistem IoT de monitorizare a puterii electrice consumate.

Sistemul se va baza pe placa de dezvoltare LinkIt Smart 7688 Duo ce oferă o combinație extrem de puternică (asemănătoare și compatibilă software cu placa de dezvoltare Arduino Yun) între un microprocesor MediaTek MT7688 ce rulează sistemul de operare OpenWRT și un microcontroler ATmega32U4.

2

Pentru a utiliza conectivitatea de rețea oferită de componenta MT7688 este nevoie de configurarea conexiunii WiFi. Configurarea conexiunii WiFi necesită conectarea la AP-ul (Access Point) LinkIt_Smart_7688_XXXXXX (XXXXXX este un identificator specific fiecărei plăci în parte) cu ajutorul unui laptop sau un terminal inteligent WiFi (telefon inteligent, tabletă). După conectare se deschide cu ajutorul unui client web (browser) adresa http://192.168.100.1 sau http://mylinkit.local ce permite accesul la interfața de administrare a componentei MT7688 / a sistemului de operare OpenWRT. La prima conectare se va stabili și parola utilizatorului root (utilizator cu drepturi de administrator).

3

Modificările necesare conectării plăcii LinkIt Smart 7688 Duo la Internet presupun trecerea componentei WiFi din mod AP în mod client (Station mode) și configurarea conectării la un AP ce oferă conectivitate Internet. Ambele modificări se fac din secțiunea Network a interfeței de administrare.

4

5

Atenție!!! Nu introduceți placa de dezvoltare într-o subrețea 192.168.100.0/24 deoarece chiar și în modul client interfața AP cu adresa 192.168.100.1 este activă și o altă adresă IP din aceiași subrețea va deruta mecanismul de rutare TCP/IP.

După configurare accesului la Internet, placa se poate accesa prin intermediul interfeței web prezentată anterior sau prin intermediul protocolului SSH, utilizând IP-ul oferit de AP-ul configurat. Utilizatorul necesar conectării este root și parola stabilită anterior. Pentru mai mult informații legate de configurarea plăcii LinkIt Smart 7688 Duo se poate consulta și „Get Started with the LinkIt Smart 7688 Duo Development Board”.

A doua operație de configurare, necesară pentru a utiliza biblioteca Bridge (bibliotecă specifică plăcii Arduino Yun) sub mediul Arduino IDE, necesită conectarea la consola plăcii de dezvoltare LinkIt Smart 7688 Duo prin intermediul unui client SSH (putty (3), de exemplu) și executarea următoarelor comenzi:

uci set yunbridge.config.disabled=’0′ 

uci commit 

reboot

Pentru măsurarea consumului vom utiliza senzorul de curent INA219 – senzor digital I2C ce permite măsurarea de tensiuni de până la 26V și curenți de până la 3.2A cu o precizie de 1%. Interconectarea cu placa de dezvoltare se va face prin intermediul magistralei I2C:

6

Senzorul se va alimenta la 3.3V iar pinii SCL și SDA se vor conecta la pinii D3 respectiv D2 ai plăcii de dezvoltare. Pentru a putea măsura curentul și tensiunea este necesar să trecem linia de alimentare a dispozitivului electronic monitorizat prin senzor. Acest lucru se poate face prin secționarea firului de alimentare sau prin conectarea unei perechi de mufe jack mamă – tată care să permită conectarea mufei de alimentare la senzor și senzorul la dispozitivul electronic. ATENȚIE!!! Inserarea senzorului se face pe linia de tensiune nu pe cea de masă.

Având în vedere scopul de monitorizare IoT a sistemului realizat în cadrul lecției de față vom utiliza cloud Robofun IoT. Pentru utilizarea acestui serviciu este necesară înregistrarea gratuită.

4

După înregistrare și conectare este necesară definirea unui senzor (Adauga senzor) pentru a putea înregistra puterea măsurată.

5

După definirea senzorului este necesar să copiem cheia de autentificare (Token) pentru a o utiliza în program.

3

Programul a fost realizat și testat utilizând Arduino IDE 1.8.3 cu extensia LinkIt Smart 7688 Duo 0.1.8 instalată și biblioteca Adafruit INA219 1.0.0.

#include <Bridge.h>

#include <HttpClient.h>

#include <Wire.h>

#include <Adafruit_INA219.h>

Adafruit_INA219 ina219;

Decomentarea directivei #define debug va permite supravegherea mesajelor de funcționare în consola serială.

//#define debug

void setup(void) {

  #ifdef debug

    SerialUSB.begin(115200);

    while (!SerialUSB);

  #endif

  ina219.begin();

  Bridge.begin();

}

În cadrul secțiunii loop() este necesară completarea valorii TOKEN obținută în procesul de înregistrare a senzorului în platforma Robofun IoT.

void loop(void) {

  float shuntvoltage = 0;

  float busvoltage = 0;

  float current_mA = 0;

  float loadvoltage = 0;

  float power = 0;

  shuntvoltage = ina219.getShuntVoltage_mV();

  busvoltage = ina219.getBusVoltage_V();

  current_mA = ina219.getCurrent_mA();

  loadvoltage = busvoltage + (shuntvoltage / 1000);

  power = loadvoltage * current_mA;

  #ifdef debug

    SerialUSB.print(“Bus Voltage:   “);

   SerialUSB.print(busvoltage);

   SerialUSB.println(” V”);

    SerialUSB.print(“Shunt Voltage: “);

    SerialUSB.print(shuntvoltage);

   SerialUSB.println(” mV”);

    SerialUSB.print(“Load Voltage:  “);

   SerialUSB.print(loadvoltage);

   SerialUSB.println(” V”);

    SerialUSB.print(“Current:       “);

   SerialUSB.print(current_mA); 

   SerialUSB.println(” mA”);

    SerialUSB.print(“Power:       “);

   SerialUSB.print(power);

   SerialUSB.println(” mW”);

    SerialUSB.println(“”);

  #endif

  HttpClient client;

  String temp = “http: ” + “//iot.robofun.ro/api/v1/senzor/TOKEN/input?value=” + String(power,2);

  client.get(temp);

  while (client.available()) {

    char c = client.read();

    #ifdef debug

      SerialUSB.print(c);

    #endif

  }

  #ifdef debug

    SerialUSB.println();

    SerialUSB.flush(); 

  #endif

  delay(60000);

}

Programul va trimite la un interval de 1 minut (60 secunde = 60000 milisecunde) valoarea calculată (puterea instantanee) pe baza curentului și tensiunii măsurate.

Testele au fost realizate monitorizând un dispozitiv de tip router WiFi HUAWEI HG8247H alimentat la 12V DC (curent continuu).

Graficul de valori înregistrate pe ultima zi (toate datele) – se poate observa un consum constant de minim 6600mW (6.6W):

7

Graficul de valori înregistrate pe ultima săptămână (cu mediere) – se poate observa o variație a consumului între 6619mW și 6800mW:

8

IoT UV Monitor

Razele ultraviolete din lumina solară reprezintă un factor de risc pentru om. Monitorizarea nivelului de radiații UV (UV index) se face pe o scară de la 1 la 10 (11 fiind deja un nivel extrem). Realizarea unui sistem electronic ce măsoară cu precizie indexul UV poate oferi informații utile pentru modul în care putem să ne protejăm (îmbrăcăminte, ochelari de protecție, creme de protecție etc.) în activitățile de zi cu zi.

În cadrul proiectului de față vom realiza un sistem care să măsoare indexul UV și să înregistreze datele măsurate pe serviciul cloud Robofun IoT. Pentru utilizarea acestui serviciu este necesară înregistrarea gratuită.

4

După înregistrare și conectare este necesară definirea unui senzor (Adauga senzor) pentru a putea înregistra valorile măsurate (UV index).

5

După definirea senzorului este necesar să copiem cheia de autentificare (Token) pentru a o utiliza în program.

3

Pentru implementarea hardware vom utiliza o placă de dezvoltare Adafruit Feather 32U4 FONA și senzorul digital I2C Si1145. Schema de interconectare între cele două componente este:

2.png

Senzorul se va alimenta de la pinul BAT al plăcii de dezvoltare. Pinul SDA al senzorului se va conecta la pinul 2 al plăcii de dezvoltare iar pinul SCK la pinul 3. Atenție!!! Placa Adafruit Feather 32U4 FONA necesită conectarea unui acumulator LiPo de 3.7V chiar dacă este alimentată prin intermediul cablului USB de programare. Componenta GSM FONA se alimentează direct din acumulator nu din alimentarea USB. Pentru mai multe detalii legate de funcționarea plăcii Adafruit Feather 32U4 FONA se poate parcurge materialul „Adafruit Feather 32u4 FONA – Take your Feather anywhere in the world”.

Funcționarea sistemului necesită o cartelă GSM 2G cu capabilități de transfer de date. Pentru acest lucru vă propunem utilizarea unui SIM Simfony Mobile M2M – cartelă GSM ce oferă exclusiv servicii mobile de date. Cartela este disponibilă gratuit prin comandă promoțională pe site-ul companiei Simfony Mobile SRL sau împreună cu un produs din gama GSM pe site-ul Robofun. Cartela necesită înregistrarea și introducerea codului promoțional pentru activare și oferă gratuit 10MB de date mobile valabile 3 luni. Ulterior costurile de funcționare sunt de 0.25EURO, 0.5EURO, 1EURO pentru 1MB, 5MB respectiv 10MB trafic de date. Chiar dacă traficul inclus are valori modice pentru un sistem de raportare IoT este suficient iar costurile sunt rezonabile. O caracteristică importantă a cartelei SIM Simfony este indepența de un operator de telefonie anume, dispozitivul GSM ce utilizează cartela Simfony poate utiliza orice operator de telefonie mobilă în funcție de zona în care se află chiar și afara României.

3

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.8.3 cu extensia Adafruit AVR Boards 1.4.9 instalată și bibliotecile Adafruit FONA Library 1.3.2 (pentru partea de comunicație cu componenta GSM FONA) și Adafruit SI1145 1.0.0 (pentru comunicația cu senzorul Si1145). În program este necesară completarea cheii de autentiricare (Token) oferite de serviciul cloud (variabila temp).

#include “Adafruit_FONA.h”

#define FONA_RX  9

#define FONA_TX  8

#define FONA_RST 4

#define FONA_RI  7

#define FONA_DTR 5

#define apn “internet.simfony.net”

#define apnusername “” 

#define apnpassword “” 

char replybuffer[255];

#include <SoftwareSerial.h>

SoftwareSerial fonaSS = SoftwareSerial(FONA_TX, FONA_RX);

SoftwareSerial *fonaSerial = &fonaSS;

Adafruit_FONA fona = Adafruit_FONA(FONA_RST);

uint8_t type;

#include <Wire.h>

#include “Adafruit_SI1145.h”

Adafruit_SI1145 uv = Adafruit_SI1145();

Decomentarea directivei #define debug va permite urmărirea funcționării sistemului în consola serială.

//#define debug

void setup() {

  #ifdef debug

    while (!Serial);

    Serial.begin(115200);

    Serial.println(“Initializing…”);

  #endif

  if (! uv.begin()) {

    #ifdef debug

      Serial.println(“Didn’t find Si1145”);

    #endif

    while (1);

  }

  digitalWrite(FONA_DTR,LOW);

  fonaSerial->begin(4800);

  if (! fona.begin(*fonaSerial)) {

    #ifdef debug

      Serial.println(F(“Couldn’t find FONA”));

    #endif

    delay(1);

    while (1);

  }

  #ifdef debug

    type = fona.type();

    Serial.println(F(“FONA is OK”));

    Serial.print(F(“Found “));

    switch (type) {

      case FONA800L:

        Serial.println(F(“FONA 800L”)); break;

      case FONA800H:

        Serial.println(F(“FONA 800H”)); break;

      case FONA808_V1:

        Serial.println(F(“FONA 808 (v1)”)); break;

      case FONA808_V2:

        Serial.println(F(“FONA 808 (v2)”)); break;

      case FONA3G_A:

        Serial.println(F(“FONA 3G (American)”)); break;

      case FONA3G_E:

        Serial.println(F(“FONA 3G (European)”)); break;

      default:

        Serial.println(F(“???”)); break;

    }

   #endif

   #ifdef debug

   char imei[15] = {0};

   uint8_t imeiLen = fona.getIMEI(imei);

   if (imeiLen > 0) {

      Serial.print(“Module IMEI: “); Serial.println(imei);

    }

   #endif

   fona.getSIMCCID(replybuffer); 

  #ifdef debug

    Serial.print(F(“SIM CCID = “));

Serial.println(replybuffer);

  #endif

  if (!fona.enableNetworkTimeSync(true)) {

     #ifdef debug

      Serial.println(F(“Failed to enable NTS”));

     #else

      ;

     #endif

  }

  delay(5000);

  fona.setGPRSNetworkSettings(F(apn),F(apnusername),

F(apnpassword));

  uint8_t n=0;

  #ifdef debug

    Serial.print(“Connecting to network.”);

  #endif

  while (n!=5) {

    n = fona.getNetworkStatus();

    #ifdef debug

      Serial.print(“.”);

    #endif

    delay(1000);

  }

  #ifdef debug

    Serial.println(“OK”);

  #endif

  #ifdef debug

    n = fona.getRSSI();

    int8_t r;

    if (n == 0) r = -115;

    if (n == 1) r = -111;

    if (n == 31) r = -52;

    if ((n >= 2) && (n <= 30)) { r = map(n, 2, 30, -110, –

54); }

    Serial.print(r); Serial.println(F(“dBm”));

  #endif

  delay(5000);

}

void loop() {

  while (!fona.enableGPRS(true)) {

    #ifdef debug

      Serial.println(F(“Failed to turn on GPRS”));

    #endif

    delay(5000);

  }

#ifdef debug

  uint16_t vbat;

  uint16_t pbat;

  if (fona.getBattVoltage(&vbat)) {

Serial.print(F(“VBat = “));

Serial.print(vbat); Serial.println(F(” mV”)); }

  if (fona.getBattPercent(&pbat)) {

Serial.print(F(“VPct = “));

Serial.print(pbat); Serial.println(F(“%”));   }

    Serial.println(“—————————“);

#endif

float UVindex = uv.readUV();

UVindex /= 100.0; 

#ifdef debug

    int light = uv.readVisible();

    Serial.print(“Vis: “); Serial.println(light);

    Serial.print(“UV: “);  Serial.println(UVindex);

#endif

String temp = “http” + “://iot.robofun.ro/api/v1/senzor/TOKEN/input?value=” + String(UVindex,2);

uint16_t statuscode;

int16_t length;

char url[100];

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

#ifdef debug

    Serial.println(url);

    if (!fona.HTTP_GET_start(url, &statuscode, (uint16_t*)&length)) Serial.println(“Failed read HTTP!”);

#else

    fona.HTTP_GET_start(url, &statuscode, (uint16_t*)&length);

#endif

while (length > 0) {

          while (fona.available()) {

            char c = fona.read();

            #ifdef debug

              Serial.write(c);

            #endif

            length–;

            if (! length) break;

          }

          #ifdef debug

            Serial.println();

          #endif

          break;

fona.HTTP_GET_end();

delay(100);

#ifdef debug

    Serial.println(“—————————-“);

    if (!fona.enableGPRS(false))

Serial.println(F(“Failed to turn off GPRS”));

#else

    fona.enableGPRS(false);

#endif

delay(100);

digitalWrite(FONA_DTR,HIGH);

delay(600000);

digitalWrite(FONA_DTR,LOW);

}

Programul va citi valorile indexului UV și va înregistra datele on-line la un interval de 10 minute (60 secunde = 60000 milisecunde). Intervalul de măsurare poate fi modificat în funcție de dinamica monitorizării dorite. Graficul de supraveghere va arăta în felul următor (se poate observa că, într-o zi însorită, indexul UV poate ajunge la valori periculoase în intervalul 15:00-17:00 iar într-o zi noroasă / cu ploaie rămâne la valori subunitare):

4