Sistem IOT monitorizare temperatura si umiditatea solului

 

Obiectiv 

Am dezvoltat acest sistem pentru un prieten care are o casa la tara, unde are o mica gradina. Nu locuieste acolo tot timpul, si vrea sa stie daca este sau nu cazul sa irige gradina.

Arhitectura

Ca sa aiba acces la date de oriunde, am ales sa trimit datele in Internet folosind http://iot.robofun.ro .

Mai jos este graficul temperaturii, in timp real :

http://iot.robofun.ro/public/senzor/8rr6e9r8sag76t0vnkrcrnp4ml

In acest moment datele masurate sunt publice. Intra pe http://iot.robofun.ro si foloseste “Testeaza Cont Demo”.

Pentru nodul care face efectiv masurarea valorilor am ales :

Arduino Pro Mini 3.3 V https://www.robofun.ro/arduino_pro_mini_328_8mhz 

  • am ales asta pentru ca este o placa care consuma extrem de putin in sleep mode, ceea ce imi permite sa o alimentez pe baterii

Modul Radio RFM69  – https://www.robofun.ro/sparkfun-rfm69-breakout-434mhz-

Senzor Umiditate Sol https://www.robofun.ro/soil-moisture-sensor

Senzor de Temperatura Inlantuibil Brick – https://www.robofun.ro/senzor-temperatura-inlantuibil-brick-DS18B20-motherboard

Senzor de Temperatura DS18B20+ – https://www.robofun.ro/senzor-temperatura-DS18B20

  • am ales senzorii de temperatura inlantuibili pentru ca folosind doar 3 fire pot monta oricat de multi senzori (pe aceleasi 3 fire).  Distanta intre Arduino si senzori poate ajunge la cateva sute de metri.

Cutie 6 baterii AA – https://www.robofun.ro/cutie-6-baterii

As fi putut sa pun direct un modul wifi si sa renunt la WIFI, dar m-am gandit ca poate in viitor voi vrea sa extind sistemul cu mai multi senzori pus in zone in care nu bate WIFI-ul din casa.

 

Pentru gateway (sistemul catre trimite valorile in cloud) am ales :

Arduino YUN  – https://www.robofun.ro/arduino_yun

Sunt multe lucruri care imi plac tare la acest dispozitiv :

  • este foarte robusta, de fiecare data a mers exact cum trebuie, in toate proiectele unde am folosit-o; libraria este bine scrisa, simplu de folosit
  • are atat conectivitate WIFI cat si prin fir de retea
  • setarea datelor de retea WIFI se face foarte foarte simplu, fara sa fie nevoie sa reprogramez placa; acest punct a fost unul esential pentru mine, pentru ca era cam aiurea sa ii cer amicului sa-mi dea parola lui de WIFI ca sa o pun eu in cod; folosind Arduino YUN, te conectezi la o retea generata chiar de placa si din interfata web de configurare (intri folosind telefonul mobil intr-un site web) setezi tot ce vrei; un exemplu mai clar aici – https://www.youtube.com/watch?v=9-hPhWHWnvs 

Modul Radio RFM69  – https://www.robofun.ro/sparkfun-rfm69-breakout-434mhz-

  • pentru receptia datelor trimise de nod

Arduino Pro Mini 3.3 V https://www.robofun.ro/arduino_pro_mini_328_8mhz 

  • dat fiind ca modulul radio functioneaza maxim la 3.3V, iar Arduino YUN functioneaza la 5V, am mai folosit inca un Arduino Pro Mini 3.3V pentru interfatare; Arduino Pro Mini este conectat la modulul radio (3.3V ambele), iar apoi trimite datele printr-o conexiune SoftwareSerial catre Arduino YUN. Dat fiind ca doar trimite date catre YUN (si nu si receptioneaza date inapoi), este OK din punct de vedere al nivelelor de tensiune. “1” logic este trimis de catre Arduino Pro Mini ca 3.3V, iar YUN interpreteaza si el tot ca “1” logic acest nivel, chiar daca functioneaza la 5V.

 

  • folosirea unui Arduino Pro Mini pe post de convertor de nivel logic (asa cum am facut eu) nu este chiar cea mai desteapta idee 🙂 Iti recomand sa folosesti un device special gandit pentru asta – https://www.robofun.ro/logic-level-convertor-4-canale-bidirectional . Daca folosesti un logic level convertor poti sa faci transmisie radio in ambele sensuri (si de la nod catre YUN si de la YUN catre nod). Eu nu l-am folosit pentru ca in momentul in care am realizat proiectul nu am avut unul la indemana.

 

Nodul care citeste datele

Conexiunile Arduino Pro Mini – modul radio

Senzorul de temperatura (motherboard – https://www.robofun.ro/senzor-temperatura-inlantuibil-brick-DS18B20-motherboard) l-am conectat cu pinul DQ la pinul 6 digital Arduino Pro Mini. GND si 5V le-am conectat la GND, respectiv 3.3 V (chiar daca pe placa este specificat 5V ca tensiune de alimentare, senzorul merge foarte OK si la 3.3 V).

Senzorul de umiditate a solului l-am cuplat pe pinul analogic 0 (VCC la 3.3 V, GND la GND si SIG la pinul analog 0 al placii Arduino Pro Mini).

Sistemul l-am alimentat folosind cutia de baterii (pinii GND si RAW).

Pentru a citi nivelul bateriei (ca sa stiu cand trebuie sa le schimb), am realizat un divizor de tensiune 1:3. Am folosit 3 rezistoare de 100 de K inseriate (legate unul in continuarea celuilalt). Capetele extreme le-am legat la pinul RAW si la pinul GND. Pinul analog 7 (se afla pe zona interioara a placii Arduino Pro Mini) l-am conectat dupa primul rezistor (numarand de la GND). Vezi poza de mai jos.

In acest mod voltajul bateriei (de 9V) este redus de 3 ori, pana la cel mult 3 V, astfel incat tensiunea sa poata fi citita de catre Arduino Pro Mini.

 

Codul sursa pentru nod

Codul sursa pentru nod este bazat pe exemplu Node din libraria pentru modulul radio RFM69.

Este disponibil integral, aici – https://github.com/viorelspinu/iot-sol-umiditate/blob/master/nod/nod.ino

Gateway-ul

Pentru gateway (sistemul care primeste datele prin radio si trimite in Internet) am folosit un Arduino Pro Mini + un modul radio RFM69 pe post de receptor radio, si un Arduino YUN pentru a trimite in Internet.

Am conectat pinul digital 8 al placii Arduino Pro Mini cu pinul digital 8 al placii Arduino YUN pentru a putea trimite datele receptionate prin radio de catre Arduino Pro Mini catre Arduino YUN.

Disclaimer :

  • folosirea unui Arduino Pro Mini pe post de convertor de nivel logic (asa cum am facut eu) nu este chiar cea mai desteapta idee 🙂 Iti recomand sa folosesti un device special gandit pentru asta – https://www.robofun.ro/logic-level-convertor-4-canale-bidirectional . Daca folosesti un logic level convertor poti sa faci transmisie radio in ambele sensuri (si de la nod catre YUN si de la YUN catre nod). Eu nu l-am folosit pentru ca in momentul in care am realizat proiectul nu am avut unul la indemana.

 

Codul sursa Arduino Pro Mini din gateway este disponibil integral, aici – https://github.com/viorelspinu/iot-sol-umiditate/blob/master/gateway/gateway.ino

 

Codul sursa Arduino YUN din gateway este disponibil integral, aici – https://github.com/viorelspinu/iot-sol-umiditate/blob/master/yun/yun.ino

HOT ! 10 (zece) proiecte cu Raspberry Pi 3, în format electronic pe Google Play

162 de pagini de proiecte cu placa Raspberry Pi 3, scrisă într-un limbaj foarte accesibil. Aceasta este ultima carte în limba română scrisă despre Raspberry Pi 3.

În acest moment este în pregătire varianta pe hârtie. Va fi disponibilă pe Robofun cam într-o săptămână. Până atunci, este disponibilă varianta digitală, cu reducere de mai mult de 50% (pe hârtie costul va fi de 39 RON, iar varianta digitală este doar 11.62 RON !).

 

 

 

 

 

 

 

Aici găsești varianta digitală –

https://play.google.com/store/books/details/Radu_Pietraru_10_zece_proiecte_cu_Raspberry_Pi_3?id=qOUpDwAAQBAJ.

 

Cuprinsul este disponibil mai jos.

 

 

 

 

My Heart Will Go IoT

Măsurarea pulsului, a numărului de bătăi ale inimii pe minut, este un instrument de evaluare atât a stării de sănătate dar și a stării emoționale sau a efortului fizic depus. Apariția de senzori optici performanți fac această evaluare foarte simplă permițând măsurarea pulsului cu telefonul mobil sau cu diverse dispozitive de tip brățară. În cadrul proiectului de față vom explica construirea unui astfel de dispozitiv dar, în plus față de  dispozitivele clasice de măsurare a pulsului, vom înregistra datele obținute în cloud.

Atenție!!! Dispozitivul prezentat nu este un dispozitiv medical! Dispozitivul din acest proiect nu poate fi folosit pentru evaluarea stării de sănătate! Proiectul de față prezintă un principiu de măsurare și înregistrare nu și o metodă exactă de calibrare a datelor măsurate.

Pentru implementarea dispozitivului vom utiliza o placă de dezvoltarea Adafruit Feather M0 WiFi și un senzor de particule și puls MAX30105. Schema de interconectare dintre cele două componente este următoarea:

2

Senzorul comunică cu placa de dezvoltare prin intermediul magistralei I2C și atunci conexiunile dintre cele două componente sunt evidente: pinul SCL al senzorului la pinul 4 (SCL) al plăcii de dezvoltare și pinul SDA al senzorului la pinul 3 (SDA) al plăcii de dezvoltare. Pinul /INT al senzorului nu este folosit. Alimentarea senzorului se va face la 5V – pinul 5V se va conecta la pinul USB al plăcii de dezvoltare atâta timp cât placa se alimentează prin intermediul cablului USB. Dacă doriți să transformați sistemul într-un sistem portabil, alimentând placa de la un acumulator LiPo, atunci pinul de 5V al senzorului se va conecta la pinul BAT al plăcii de dezvoltare – senzorul se va alimenta la 3.7V (producătorul specifică posibilitatea de a alimenta senzorul la tensiuni între 3.3V și 5V dar explică că o tensiune de peste 3.5V va asigura o funcționare mai bună a senzorului).

Pentru punerea în funcțiune și pentru integrarea plăcii de dezvoltare cu mediul Arduino IDE este necesară parcurgerea materialului „Adafruit Feather M0 WiFi with ATWINC1500 – ARM Cortex M0+ with fast & fun wireless built in”. Pentru înțelegerea mai bună a modului de funcționare a senzorului de puls se poate parcurge materialul „MAX30105 Particle and Pulse Ox Sensor Hookup Guide”.

Programul sistemului se bazează pe exemplul Example5_HeartRate al bibliotecii software Sparkfun MAX3010x Pulse and Proximity Sensor Library. Programul a fost testat utilizând Arduino IDE 1.8.3 cu extensia Adafruit SAMD Boards 1.0.17 instalată și bibliotecile WiFi101 0.14.3 și Sparkfun MAX3010x 1.0.0. Atenție!!! Pentru a compila programul pentru placa Feather M0 este necesară adăugarea unei linii (#define BUFFER_LENGTH 32) în fișierul MAX30105.cpp al bibliotecii Sparkfun MAX3010x.

#include <SPI.h>

#include <WiFi101.h>

#define WINC_CS   8

#define WINC_IRQ  7

#define WINC_RST  4

#define WINC_EN   2 

Datele de conectare WiFi trebuie personalizate în program. Programul va înregistra datele măsurate în cloud utilizând serviciul Robofun IoT.

char ssid[] = ““;

char pass[] = ““; 

WiFiClient client;

int status = WL_IDLE_STATUS;

char server[] = “iot.robofun.ro”;

Constanta postingInterval va dicta intervalul (în milisecunde) la care se face înregistrarea datelor în cloud.

unsigned long lastConnectionTime = 0;

const unsigned long postingInterval = 30L * 1000L;

#include <Wire.h>

#include “MAX30105.h”

#include “heartRate.h”

MAX30105 particleSensor;

const byte RATE_SIZE = 4;

byte rates[RATE_SIZE];

byte rateSpot = 0;

long lastBeat = 0;

float beatsPerMinute;

int beatAvg;

Decomentarea directivei debug va permite vizualizarea datelor măsurate în concola serială.

//#define debug

3

În cadrul secțiunii setup() se va inițializa conexiunea WiFi și comunicația cu senzorul de puls. Mesajele de eroare vor apărea în consola serială doar dacă este activată directiva debug.

void setup() {

  #ifdef debug

    Serial.begin(115200);

    while (!Serial) { ; }

    Serial.println(“Initializing…”);

  #endif

  WiFi.setPins( 8,7,4,2);

  if (WiFi.status() == WL_NO_SHIELD) {

    #ifdef debug

      Serial.println(“WiFi shield not present”);

    #endif

    while (true);

  }

  while (status != WL_CONNECTED) {

    #ifdef debug

      Serial.print(“Attempting to connect to SSID: “);

      Serial.println(ssid);

    #endif

    status = WiFi.begin(ssid, pass);

    delay(10000);

  }

  #ifdef debug

    Serial.println(“Connected to wifi”);

  #endif

  if (!particleSensor.begin(Wire, I2C_SPEED_FAST))

  {

    #ifdef debug

      Serial.println(“MAX30105 was not found. Please check wiring/power. “);

    #endif

    while (1);

  }

  #ifdef debug

    Serial.println(“Place your index finger on the sensor with steady pressure.”);

  #endif

  particleSensor.setup();

  particleSensor.setPulseAmplitudeRed(0x0A);

  particleSensor.setPulseAmplitudeGreen(0);

}

În cadrul secțiunii loop() se va efectua atât citirea senzorului de puls (BPM – bătăi pe minut, medie – Avg BPM) cât și postarea către serviciul Robofun IoT. În cadrul codului trebuie personalizată cheia de autentificare (TOKEN) primită la înregistrarea senzorului în cadrul serviciului IoT. Intervalul de postare se contorizează începând cu detecția degetului pe senzor, dacă se ia degetul de pe senzor nu se mai efectuează înregistrarea valorilor în cloud. Se recomandă utilizarea unui elastic pentru a asigura o presiune constantă pe senzor.

4

void loop() {

  long irValue = particleSensor.getIR();

  if (checkForBeat(irValue) == true)

  {

    long delta = millis() – lastBeat;

    lastBeat = millis();

    beatsPerMinute = 60 / (delta / 1000.0);

    if (beatsPerMinute < 255 && beatsPerMinute > 20) {

      rates[rateSpot++] = (byte)beatsPerMinute;

      rateSpot %= RATE_SIZE;

      beatAvg = 0;

      for (byte x = 0 ; x < RATE_SIZE ; x++)

        beatAvg += rates[x];

      beatAvg /= RATE_SIZE; }

  }

  #ifdef debug

    Serial.print(“IR=”);

    Serial.print(irValue);

    Serial.print(“, BPM=”);

    Serial.print(beatsPerMinute);

    Serial.print(“, Avg BPM=”);

    Serial.print(beatAvg);

  #endif

  if (irValue < 50000) {

    #ifdef debug

      Serial.print(” No finger?”);

    #endif

    lastConnectionTime = millis();

  }

  #ifdef debug

    Serial.println();

  #endif

  if ((millis() – lastConnectionTime > postingInterval) && (beatAvg > 20))

  {   String temp = “GET /api/v1/senzor/TOKEN/input?value=” + String(beatAvg) + ” HTTP/1.1″;

      char param[100];

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

      if (client.connect(server, 80)) {

        client.println(param);

        client.println(“Host: iot.robofun.ro”);

        client.println(“Connection: close”);

        client.println();

      }

      client.stop();

      lastConnectionTime = millis();

      lastBeat = 0;

  }

}

Pentru a utiliza serviciul Robofun IoT este necesară înregistrarea gratuită.

4

După înregistrare și conectare este necesară definirea unui noi senzor (Adauga senzor).

5

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

3

După configurarea serviciului IoT și încărcarea programului pe placa de dezvoltare putem începe utilizarea dispozitivului și putem observa datele înregistrate on-line:

5

O facilitate foarte interesantă a serviciului Robofun IoT este posibilitatea de partajare a graficelor (Share senzor) sau de integrare a acestora în alte pagini web. Putem astfel să adăugăm paginii web personale sau blog-ului personal un grafic live cu numărul de bătăi ale propriei inimi.

6

Finala Competiției Internet of Things Student Challenge 2017

Dorim să vă invităm la Finala Competiției Internet of Things Student Challenge 2017 în data de 22 Iunie 2017, ora 15 din partea Departamentului de Automatică, Facultatea de Automatică și Calculatoare, Universitatea Tehnică din Cluj-Napoca. În cadrul competiției s-au înscris 14 echipe care au dezvoltat proiecte Internet of Things și Building Automation. Competiția este strâns legată de Conferința Științifică Internațională AQTR (International Conference on Automation, Quality and Testing, Robotics) și va avea loc anual, ridicând ștacheta tot mai sus.

Evenimentul va fi de asemenea transmis LIVE! pe pagina de Facebook: https://www.facebook.com/events/251297775277832??ti=ia

Pagini oficiale ale competiției:
http://contest.aqtr.ro/
https://www.facebook.com/Internet.of.Things.Student.Challenge

Locația evenimentului:
Facultatea de Automatică și Calculatoare, Departamentul de Automatică,
Strada Dorobanților, Nr.71-73, Sala C01, data 22.06.2017, orele 15-22

Cu respect,
IoT Student Challenge 2017 – Organizing Committe

Proiect Blynk IoT

Sparkfun Blynk ESP8266 este o placă de dezvoltare care, pe lângă avantajele oferite de serviciul cloud Blynk (prezentate în cadrul proiectului Cum să realizăm un sistem IoT fără să scriem nici o linie de cod?), oferă o combinație de componente extrem de interesante.

1

Procesorul WiFi ESP8266, senzorul digital de temperatură și umiditate Si7021 integrat și posibilitatea de alimentare de la un acumulator fac din placa Sparkfun Blynk ESP8266 o excelentă platformă pentru experimente IoT. În cadrul proiectului de față vom programa această placă utilizând Arduino IDE și nu vom utiliza platforma cloud specifică ci noul serviciu Robofun IoT.

2

Pentru punerea în funcțiune și programarea plăcii Blynk se recomandă parcurgerea materialului Blynk Board Arduino Development Guide. Pentru prima parte a proiectului nu avem nevoie decât de placa de dezvoltare și cablul USB de încărcare a programului – senzorul de temperatură și umiditate ce va furniza informațiile transmise către serviciul IoT este integrat pe placă.

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.8.1, extensia esp8266 2.1.0 și bibliotecile Sparkfun Si7021 Humidity and Temperature Sensor 1.0.0 și Adafruit NeoPixel 1.1.1 (pe placa de dezvoltare se află și un led RGB WS2812 pe care îl vom comanda utilizând această bibliotecă). Declarațiile inițiale ale programului sunt următoarele:

#include <Wire.h>
#include “SparkFun_Si7021_Breakout_Library.h”
#include <Adafruit_NeoPixel.h>
#include <ESP8266WiFi.h>
#include <ESP8266HTTPClient.h>

În cadrul programului trebuie personalizate datele de conectare WiFi:

char ssid[] = ““;

char pass[] = ““;

WiFiClient client;

float humidity = 0;

float tempC = 0;

Weather sensor;

#define PIN  4

#define NUMPIXELS 1

Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

Varialbila postingInterval indică intervalul de timp între două raportări IoT (în milisecunde, în cazul dat ca exemplu: 10 minute)

unsigned long lastConnectionTime = 0;

const unsigned long postingInterval = 600L * 1000L;

Dacă doriți ca programul să afișeze informații despre execuție se va decomenta următoarea linie:

//#define debug

3

În cadrul secțiunii setup() se va inițializa conexiunea WiFi – pe durata inițializării led-ul RGB de pe placă va lumina roșu.

void setup() {

  pixels.begin();

  pixels.setPixelColor(0, pixels.Color(150,0,0));

  pixels.show();

  #ifdef debug

    Serial.begin(9600);

  #endif

  int status = WL_IDLE_STATUS;

  while (status != WL_CONNECTED)

  {

    status = WiFi.begin(ssid, pass);

    delay(10000);

  }

  #ifdef debug

    Serial.println(“Connected to wifi”);

  #endif

  sensor.begin();

  pixels.setPixelColor(0, pixels.Color(0,0,0));

  pixels.show();

}

Secțiunea loop() va verifica timpul scurs de la ultima raportare și dacă este depășit intervalul specificat se va apela procedura IoTPublish() care se ocupă de citirea senzorului Si7021 și de trimiterea datelor către Robofun IoT. Pe durata execuției procedurii led-ul de pe placă va lumina verde.

void loop() {

  if (millis() – lastConnectionTime > postingInterval)

  {

    pixels.setPixelColor(0, pixels.Color(0,150,0));

    pixels.show();

    IoTpublish();

    pixels.setPixelColor(0, pixels.Color(0,0,0));

    pixels.show();

  }

}

Procedura IoTpublish() va posta datele oferite de senzorul de temperatură și umiditate către serviciul IoT. Postarea se face prin două apeluri HTTP GET, câte unul pentru fiecare parametru trimis (temperatură și umiditate). Apelurile HTTP vor returna răspunsul 1 dacă totul este în regulă sau alte valoare dacă a apărut o eroare. Pentru utilizarea serviciului Robofun IoT este necesară înregistrarea gratuită a unui cont.

4

După înregistrare și conectare este necesară definirea a doi noi senzori.

5

Fiecare senzor va avea propria cheie de autentificare (token) și pentru fiecare dintre cei doi senzori este necesar să copiem această cheie în program (SENZOR_TOKEN1 și SENZOR_TOKEN2).

void IoTpublish() {

  String SENSOR_TOKEN1=”“;

  String SENSOR_TOKEN2=”“;

  HTTPClient http;

  humidity = sensor.getRH();

  tempC = sensor.getTemp();

  String data =

    “http” + “://iot.robofun.ro/api/v1/senzor/” + SENSOR_TOKEN1 + “/input?value=” + String(tempC, DEC);

  http.begin(data);

  int httpCode = http.GET();

  #ifdef debug

    if(httpCode > 0) {

      Serial.printf(“[HTTP] GET… code: %d\n”, httpCode);

      if(httpCode == HTTP_CODE_OK) {

        String payload = http.getString();

        Serial.println(payload);

      }

    } else {

      Serial.printf(“[HTTP] GET… failed, error: %s\n”, http.errorToString(httpCode).c_str());

    }

  #endif

  http.end();

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

  http.begin(data);

  httpCode = http.GET();

  #ifdef debug

    if(httpCode > 0) {

      Serial.printf(“[HTTP] GET… code: %d\n”, httpCode);

      if(httpCode == HTTP_CODE_OK) {

        String payload = http.getString();

        Serial.println(payload);

      }

    } else {

      Serial.printf(“[HTTP] GET… failed, error: %s\n”, http.errorToString(httpCode).c_str());

    }

  #endif

  http.end();

  lastConnectionTime = millis();

}

După încărcarea programului pe placa de dezvoltare și scurgerea unui interval de funcționare mai lung decât postingInterval vom putea vedea deja pe graficul oferit de interfața serviciului valorile achiziționate de senzorul plăcii. În capturile de ecran următoare putem vedea un grafic pe o perioadă mai lungă de timp (temperatura – vizualizare a tuturor valorilor, umiditate – vizualizare a valorilor medii la nivel de săptămână).

6

7

Un atu foarte important al plăcii de dezvoltare Sparkfun Blynk ESP8266 este posibilitatea de alimentare utilizând un acumulator LiPo de 3.7V. Asta conferă sistemului portabilitate – vom dispune de un sistem de achiziție IoT de dimensiunea a două cutii de chibrituri. Totuși, o problemă majoră care se naște în acest caz este evaluarea autonomiei de funcționare a sistemului – determinarea nivelului de încărcare a acumulatorului. Utilizarea convertorului analog-numeric al plăcii în acest scop presupune construirea unui divizor de tensiune (convertorul poate măsura tensiuni între 0V și 3.3V) dar această soluție conduce la descărcarea mai rapidă a acumulatorului. O soluție mult mai elegantă pentru rezolvarea acestei probleme este utilizarea unei componente specializate de măsurare: LiPo Fuel Gauge. Conectarea acestei componente, între conectorul de alimentare al plăcii și acumulator, este prezentată în diagrama următoare:

8

Circuitul integrat MAX17043G+U al componentei de măsurare va supraveghea nivelul de tensiune al acumulatorului și îl va raporta către placa de dezvoltarea prin intermediul magistralei I2C – placa de dezvoltare are un conector special I2C la care se poate conecta componenta de măsurarea. Introducerea componentei de măsurare nu va influența în nici un fel posibilitatea de încărcarea a acumulatorului prin intermediul mufei microUSB de pe placă și nici nu va scădea durata de viață a acumulatorului.

În cadrul programului vom adăuga următoarele funcții și proceduri necesare lucrului cu circuitul MAX17043:

unsigned int vcellMAX17043() {

unsigned int vcell;

vcell = i2cRead16(0x02);

vcell = vcell >> 4;

return vcell; }

float percentMAX17043() {

unsigned int soc;

float percent;

soc = i2cRead16(0x04);

percent = (byte) (soc >> 8);

percent += ((float)((byte)soc))/256;

return percent; }

void qsMAX17043() {

i2cWrite16(0x4000, 0x06); }

unsigned int i2cRead16(unsigned char address) {

int data = 0;

Wire.beginTransmission(MAX17043_ADDRESS);

Wire.write(address);

Wire.endTransmission();

Wire.requestFrom(MAX17043_ADDRESS, 2);

while (Wire.available() < 2) ;

data = ((int) Wire.read()) << 8;

data |= Wire.read();

return data; }

void i2cWrite16(unsigned int data, unsigned char address) {

Wire.beginTransmission(MAX17043_ADDRESS);

Wire.write(address);

Wire.write((byte)((data >> 8) & 0x00FF));

Wire.write((byte)(data & 0x00FF));

Wire.endTransmission(); }

La începutul programului vom defini adresa I2C a circuitului MAX17043:

#define MAX17043_ADDRESS 0x36

Iar în cadrul procedurii IoTpublish() vom adăuga:

float batVoltage;

float batPercentage;

String SENSOR_TOKEN3=”…”;

String SENSOR_TOKEN4=”…”;

….

qsMAX17043();

batPercentage = percentMAX17043();

batVoltage = (float) vcellMAX17043() * 1/800;

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

http.begin(data);

httpCode = http.GET();

#ifdef debug

if(httpCode > 0) {

Serial.printf(“[HTTP] GET… code: %d\n”, httpCode);

if(httpCode == HTTP_CODE_OK) {

String payload = http.getString();

Serial.println(payload);

}

} else {

Serial.printf(“[HTTP] GET… failed, error: %s\n”, http.errorToString(httpCode).c_str());

}

#endif

http.end();

data = “http” + “://iot.robofun.ro/api/v1/senzor/” + SENSOR_TOKEN4 + “/input?value=” + String(batPercentage, DEC);

http.begin(data);

httpCode = http.GET();

#ifdef debug

if(httpCode > 0) {

Serial.printf(“[HTTP] GET… code: %d\n”, httpCode);

if(httpCode == HTTP_CODE_OK) {

String payload = http.getString();

Serial.println(payload); }

} else {

Serial.printf(“[HTTP] GET… failed, error: %s\n”, http.errorToString(httpCode).c_str());   }

#endif

http.end();

Înainte de încărcarea noii versiuni de program este necesar să definim doi noi senzori (unul pentru tensiunea acumulatorului altul pentru procentul de încărcare) și să copiem cheile de autentificare în variabilele asociate: SENZOR_TOKEN3 și SENZOR_TOKEN4. După rularea programului vom putea vedea evoluția parametrilor acumulatorului folosit:

9

10

Proiect Noise-o-Meter IoT

Zgomotul este un factor de stres la fel de puternic ca și căldura, suprasolicitarea sau evenimentele cu impact emoțional dar de cele mai multe ori este ignorat și încadrat în „normalitatea” urbană cotidiană. Cât de mult ne afectează zgomotul înconjurător? Depinde de nivelul de zgomot la care suntem expuși. Cum putem evalua zgomotul din jurul nostru? Aparatele profesionale de măsurat puterea sunetelor sunt destul de scumpe și nu oferă o evaluare pe termen lung. În cadrul acestei lecții prezentăm implementarea unui sistem de măsură a nivelului de zgomot ambiental care, cu ajutorul serviciilor IoT, va permite evaluarea pe termen lung a acestui factor de stres.

Sistemul va utiliza placa de dezvoltare Arduino Leonardo ETH și un modul breakout cu microfon pentru achiziția nivelului de zgomot. Schema de interconectare este următoarea:

schema_bb

Modulul breakout se va alimenta la 3.3V (pinul VCC al modulului se va conecta la pinul 3.3V al plăcii de dezvoltare, pinul GND la pinul GND) și ieșirea analogică a modulului, pinul AUD, se va conecta la pinul de achiziție analogică A0 al plăcii de dezvoltare.

Pentru mai multe detalii despre utilizarea modulului breakout puteți consulta și materialul „Electret Mic Breakout Board Hookup Guide”. Pentru punerea în funcțiune și utilizarea plăcii de dezvoltare Arduino Leonardo ETH puteți consulta materialul „Start with Arduino Leonardo ETH”.

Placa de dezvoltare va realiza partea de achiziție a nivelului de zgomot și va trimite valorile, prin intermediul rețelei Internet, către serviciul Robofun IoT. Serviciul Robofun IoT este un serviciu gratuit ce permite stocarea datelor și vizualizarea evoluției acestora. Serviciul necesită înregistrare (secțiunea Cont nou):

4

După înregistrare și conectare este necesară definirea unui nou senzor (secțiunea Adaugă senzor):

5

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

3

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.8.1 având instalate extensia Arduino AVR Boards 1.6.19 și biblioteca Ethernet2 1.0.4. Pentru ca sistemul să funcționeze este necesară conectarea plăcii Arduino Leonardo ETH la o rețea locală cu servicii DHCP și conectivitate Internet.

#include <SPI.h>

#include <Ethernet2.h>

byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };

EthernetClient client;

char server[] = “iot.robofun.ro”;

const int pinAdc = A0;

În cazul în care placa nu va putea obține configurația de rețea prin DHCP led-ul conectat pe pinul 13 va începe să clipească și programul se va bloca (bucla infinită while(1)) – se va verifica în acest caz conectarea cablului de rețea și se va reseta placa.

void setup() {

      Serial.begin(9600);

      if (Ethernet.begin(mac) == 0) {

        pinMode(13,OUTPUT);

        while(1) {       

         digitalWrite(13,LOW);

         delay(1000);

         digitalWrite(13,HIGH);

         delay(1000);

        }

      }

}

În cadrul secțiunii loop() este necesară completarea cheii de autentificare specifice senzorului definit în cadrul serviciului Robofun IoT (TOKEN).

void loop() {

    float sound = getSound();

    Serial.println(sound);

   String temp = “GET /api/v1/senzor/TOKEN/input?value=” + String(sound) + ” HTTP/1.1″;

    char param[100];

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

    if (client.connect(server, 80)) {

      client.println(param);

      client.println(“Host: iot.robofun.ro”);

      client.println(“User-Agent: arduino-ethernet”);

      client.println(“Connection: close”);

      client.println();

    }

    client.stop();

}

Funcția getSound() va analiza semnalul analogic transmis de modul pe o perioadă de timp egală cu sampleWindow. Analiza va determina amplitudinea maximă a semnalului (variabila peakToPeak) și va face transformarea din valoare eșantionată (interval 0 – 1024) în tensiune (interval 0 – 3.3).

float getSound(){

   const int sampleWindow = 5000;

   unsigned int sample;

   unsigned long startMillis= millis();

   unsigned int peakToPeak = 0; 

   unsigned int signalMax = 0;

   unsigned int signalMin = 1024;

   while (millis() – startMillis < sampleWindow)   {

      sample = analogRead(pinAdc);

      if (sample < 1024)     {

         if (sample > signalMax)         {

            signalMax = sample;         }

         else if (sample < signalMin)         {

            signalMin = sample;         }

      }

   }

   peakToPeak = signalMax – signalMin;

   float volts = (peakToPeak * 3.3) / 1024.0; 

   return volts;

 }

Evoluția zgomotului ambiental se poate observa local deschizând Serial Plotter din meniul Tools al mediului Arduino IDE (programul raportează și pe serială valorile măsurate) dar supravegherea pe termen lung se va face prin interfața web a serviciului Robofun IoT:

robofun

Atenție!!! Valorile măsurate nu sunt calibrate, nu au o unitate de măsură asociate – nu reprezintă valori in decibeli. Valorile măsurate reprezintă doar o intensitate a zgomotului pe o scară de la 0 la 3.3 dar pot da o imagine destul de bună a variației zgomotului în mediul ambiental.