Conectarea unui RTC I2C la o placă Raspberry Pi

1

Una din problemele cele mai delicate în utilizate plăcii de dezvoltare Raspberry Pi este contorizarea exactă a trecerii timpului / menținerea orei exacte. Implicit funcționarea plăcii Raspberry Pi pleacă de la presupunerea că există întotdeauna disponibilă o conexiune Internet prin intermediul căreia se va face sincronizarea de timp și astfel se va asigura o contorizare exactă a trecerii timpului. În cazurile în care nu este disponibilă o conexiune Internet, sisteme izolate care funcționează în mod autonom de exemplu, menținerea orei exacte în mod corect este o provocare mai ales după întreruperea alimentării. Cea mai simplă soluție pentru a preveni funcționarea utilizând o referință de timp eronată este adăugarea plăcii Raspberry Pi a unui modul RTC (Real Time Clock).

1

Un modul RTC este capabil să contorizeze în mod exact trecerea timpului și, mai mult decât atât, este capabil să mențină setările de oră și dată în lipsa alimentării cu energie electrică utilizând o mică baterie de 3V.

În cadrul proiectului de față vom exemplifica utilizarea unui modul RTC cu o placă Raspberry Pi prin două variante de modul RTC:

SparkFun Real Time Clock Module bazat pe circuitul DS1307 – unul dintre cele mai utilizate circuite RTC;

2

https://www.robofun.ro/module/module-rtc/real_time_clock

Olimex Real Time Clock RTC bazat pe circuitul NXP PCF8563.

3

https://www.robofun.ro/module/module-rtc/mod-rtc

Ambele module RTC se vor interconecta cu placa Raspberry Pi prin intermediul protocolului serial I2C.

Circuitul DS1307 funcționează la 5V din acest motiv pentru a putea interconecta modulul cu placa de dezvoltare Raspberry Pi (a cărei linii I2C nu acceptă niveluri de tensiune mai mari de 3.3V) este nevoie să dezactivăm rezistențele de pull-up aflate pe PCB-ul modulului și care țin liniile I2C la 5V – comunicația I2C va utiliza rezistențele de pull-up aflate pe placa Raspberry Pi. Dezactivarea se face prin decositorirea unui jumper al modulului (indicat în imaginea următoare). ATENȚIE!!! Este esențială decositorirea corectă, deconectarea sigură a rezistențelor ce țin liniile I2C conectate la 5V altfel este posibilă distrugerea pinilor plăcii Raspberry Pi. Se poate verifica suplimentar, cu ajutorul unui multimetru, rezistența dintre pinii 5V și SDA/SCL. Dacă rezistența este infinită (indicată de obicei de multimetru prin 1) atunci decuplarea este corectă și putem conecta modulul la placa Raspberry Pi. Dacă multimetru indică între 2 și 4Kohm atunci rezistențele nu au fost deconectate corect – se poate încerca răzuirea fină a jumperului cu o lamă.

4

Modalitatea de conectare a celor două module cu placa de dezvoltare este similară: pinii SDA, SCL ai modulelor se conectează la pinii SDA, SCK ai plăcii Raspberry PI (pinii 3 și 5). Pinul GND se conectează la pinul de GND (pinul 6). Modulul bazat pe DS1307 are conectat pinul de 5V la pinul de 5V al plăcii Raspberry Pi (pinul 4) iar modulul bazat pe PCF8563 are pinul de alimentare conectat la pinut de 3.3V al plăcii Raspberry Pi (pinul 1).

5

Conectorul modulului RTC bazat pe circuitul PCF8563 este de tip UEXT (specific companiei Olimex – imagine mai jos) iar semnificația pinilor este următoarea: pinul 1 – 3.3V, pinul 2 – GND, pinul 5 – SCL și pinul 6 – SDA.

6

Pentru menținerea orei și datei ambele module RTC necesită o baterie de 3V. Modulul DS1307 necesită o baterie de 12mm (inclusă în kit), de exemplu CR1225. Modulul PCF8563 necesită o baterie de 20mm (nu este inclusă în kit), de exemplu CR2032.

După conectarea modulului RTC la placa de dezvoltare Raspberry Pi este necesară configurarea sistemului de operare pentru a utiliza această componentă. Succesiunea următoare de comenzi a fost testată pe un sistem Raspbian 8.0 (jessie) cu kernel 4.1.17-v7+. Alte distribuții de Linux specifice plăcii Raspberry Pi este posibil să necesite o altă modalitate de configurare.

Se va instala suportul software pentru comunicația I2C:

sudo apt-get install -y python-smbus

sudo apt-get install -y i2c-tools

Se va activa comunicația I2C utilizând utilitarul raspi-config:

sudo raspi-config

7

8

9

În acest moment putem verifica conexiunea între placa de dezvoltare și componenta RTC prin intermediul comenzii:

sudo i2cdetect -y 1

10

ce va indica adresa I2C a modulului conectat: 0x68 pentru DS1307 și 0x51 pentru PCF8563.

Dacă conexiunea între modulul RTC și placa de dezvoltare este în regulă putem configura fișierele de inițializare a sistemului de operare pentru a utiliza modulul RTC.

În fișierul /boot/config.txt se adaugă următoarea linie:

dtoverlay=i2c-rtc,ds1307

sau

dtoverlay=i2c-rtc,pcf8663

în funcție de modulul folosit.

Se va înlătura serviciul sistemului de operare ce emulează ceasul hardware:

sudo apt-get -y remove fake-hwclock

sudo update-rc.d -f fake-hwclock remove

iar în fișierul /lib/udev/hwclock-set se vor comenta următoarele linii

#if [ -e /run/systemd/system ] ; then

# exit 0

#fi

și se va reporni sistemul:

sudo reboot

După repornire se poate verifica funcționarea corectă a modulului RTC și a mecanismelor specifice sistemului de operare prin următoarele comenzi:

Prima inițializare a modulului RTC se va face prin intermediul comenzii:

sudo hwclock -D -r

Sincronizarea timpului sistemului cu modulul RTC se va face prin comanda (scrierea datei sistem în memoria modulului RTC):

sudo hwclock -w

Consultarea informațiilor din modulul RTC se va face prin comanda:

sudo hwclock -r

După setarea inițială a modulului RTC sistemul Raspberry Pi se va sincroniza automat la fiecare repornire cu informațiile stocate în memoria internă a modulului RTC – la fiecare repornire ora și data se vor inițializa cu ajutorul modulului RTC care păstrează informațiile și în lipsa alimentării cu energie electrică.

Motorașul meloman

3

Multe aplicații de divertisment necesită combinarea redării audio cu comanda unei mișcări care, cel mai adesea, este implementată cu ajutorul unui motor electric. În cadrul proiectului de față vom vedea cum putem realiza acest lucru: redarea unei piese audio și comanda simultană a unui servomotor (a fost ales acest tip de motor deoarece este un motor ce poate realizări mișcări de precizie – se poate ușor modifica exemplul pentru un alt tip de motor electric).

Pentru implementarea exemplului vom utiliza o placă de dezvoltare Arduino UNO, un servomotor 9g și un modul de redare audio Adafruit VS1053:

1

https://www.robofun.ro/mecanice/servo/servomotor_9g

2

https://www.robofun.ro/module/module-audio/vs1053-codec-microsd-breakout-mp3-wav-midi-ogg-play-record

Schema de interconectare dintre componente este următoarea:

3

Modulul Adafruit VS1053 este un modul bazat pe circuitul DSP VS1053 ce este capabil să redea o varietate mare de formate audio (MP3, AAC, OGG, WMA, MIDI, FLAC, WAV) și chiar să înregistreze flux audio cu codare PCM (WAV) sau OGG. Conexiunile cu placa de dezvoltare sunt următoarele:

  • alimentare: pinul 3.3V al modulului la pinul 3.3V al plăcii de dezvoltare, GND la GND;
  • pin SCLK modul – pin D13 placă de dezvoltare;
  • pin MISO modul – pin D12 placă de dezvoltare;
  • pin MOSI modul – pin D11 placă de dezvoltare;
  • pin CS modul – pin D10 placă de dezvoltare;
  • pin RST modul – pin D7 placă de dezvoltare;
  • pin XDCS modul – pin D8 placă de dezvoltare;
  • pin SDCS modul – pin D4 placă de dezvoltare;
  • pin DREQ modul – pin D3 placă de dezvoltare;
  • mufă jack audio: AGND – pin centru mufă, LOUT – pin stânga margine mufă, ROUT – pin dreapta margine mufă.

Funcționarea modulului necesită un card microSD pe care să încărcăm un fișier audio  – programul dispozitivului se așteaptă ca fișierul redat să aibă numele 1.mp3 dar acest lucru poate fi modificat. Mufa jack audio poate fi utilizată pentru conectarea unor boxe pasive dar pentru un volum decent se recomandă utilizarea unor boxe active (cu alimentare proprie și amplificare).

Pentru mai multe informații legate de utilizarea modului Adafruit VS1053 puteți consulta:

Adafruit VS1053 MP3/AAC/Ogg/MIDI/WAV Codec Breakout Tutorial

https://learn.adafruit.com/adafruit-vs1053-mp3-aac-ogg-midi-wav-play-and-record-codec-tutorial/

Comanda servomotorului utilizează pinul D9 (plus alimentare 5V și GND). În cazul în care se dorește manipularea unui obiect de dimensiuni mai mari se poate utiliza un servomotor mai puternic dar trebuie avut în vedere faptul că un astfel de motor este posibil să necesite alimentare suplimentară față de ce oferă placa de dezvoltare.

Programul va utiliza biblioteca Adafruit VS1053 externă mediului Arduino IDE:

https://github.com/adafruit/Adafruit_VS1053_Library

#include <SPI.h>

#include <Adafruit_VS1053.h>

#include <SD.h>

#include “Servo.h”

#define BREAKOUT_RESET  7   

#define BREAKOUT_CS     10  

#define BREAKOUT_DCS    8   

#define CARDCS 4  

#define DREQ 3    

Adafruit_VS1053_FilePlayer musicPlayer =

  Adafruit_VS1053_FilePlayer(BREAKOUT_RESET, BREAKOUT_CS,

  BREAKOUT_DCS, DREQ, CARDCS);

#define SERVO_PIN 9

Servo myservo; 

int pos = 10;

În cadrul secțiunii setup() se vor inițializa obiectele necesare interacțiunii cu servomotorul și cu modulul VS1053:

void setup() {

  myservo.attach(SERVO_PIN);

  Serial.begin(9600);

  Serial.println(“Motorasul meloman”);

  if (! musicPlayer.begin()) {

     Serial.println(F(“Nu gasesc VS1053…”));

     while (1);

  }

  Serial.println(F(“VS1053 ok”));

  if (!SD.begin(CARDCS)) {

    Serial.println(F(“Eroare SD…”));

    while (1); 

  }

  Serial.println(“SD ok”);

  musicPlayer.setVolume(0,0);

  if (! musicPlayer.

useInterrupt(VS1053_FILEPLAYER_PIN_INT))

    Serial.println(F(“Pinul DREQ nu este pin

 de intrerupere externa…”));

}

Secțiunea loop() va comanda redarea fișierului audio și va mișca servomotorul cu 5o la fiecare secundă scursă din melodie (de la 10o până la maxim 170o). La finalul piesei audio se va readuce servomotorul la poziția de 10o. Ciclul se va relua după o oră (360 secunde = 60 minute). Folosind capacitatea modulului Adafruit VS1053 de a reda piesa audio independent de rularea programului pe placa Arduino se pot imagina diverse alte combinații de mișcare a servomotorului în paralel cu redarea audio (legănare, modificare viteză de mișcare, indicare a timpului scurs ș.a.m.d.).

void loop() {

  musicPlayer.playFullFile(“1.mp3”);

  if (! musicPlayer.startPlayingFile(“1.mp3”)) {

    Serial.println(“Nu pot accesa 1.mp3 …”);

    while (1);

  }

  Serial.println(F(“Start”));

  while (musicPlayer.playingMusic) {

    Serial.print(“.”);

if (pos<170) myservo.write(pos);   

pos += 5;

    delay(1000);

  }

  Serial.println(“Gata”);

  for (int i=pos; i>10; i-=5) myservo.write(pos);

  delay(60000);

}

Programul a fost dezvoltat și testat cu Arduino IDE 1.6.12, Arduino AVR Boards 1.6.14 și biblioteca Adafruit VS1053 1.0.0.

Pentru documentare suplimentară puteți consulta și următoarele proiecte:

Arduino MP3 player with DTMF decode to control servos and PWM (RGB LEDS)

https://youtu.be/Gv6AnMNHhsQ

Arduino DCC Function Servo Sound decoder

https://rudysmodelrailway.wordpress.com/2015/02/11/arduino-dcc-function-servo-sound-decoder/

Turn body movement into music with Arduino

https://blog.arduino.cc/2016/05/13/turn-body-movement-into-music-with-arduino/

Moving a Servo To Sound Signals

http://www.instructables.com/id/Moving-a-Servo-To-Sound-Signals/

Christmas Greeting Wreath Arduino and MP3

http://www.instructables.com/id/Christmas-Greeting-Wreath-Arduino-and-MP3/

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

 

 

 

 

Cum să realizăm un sistem IoT fără să scriem nici o linie de cod?

În ciuda simplității utilizării și programării plăcilor de dezvoltare Arduino există o serie de proiecte ce își propun să ușureze și mai mult programarea acestei familii de plăci de dezvoltare eliminând complet partea de programare specifică mediului Arduino IDE. Aceste proiecte permit utilizarea plăcilor de dezvoltarea Arduino chiar de către copii sau de către persoane fără experiență în programare. Câteva exemple de astfel de proiecte:

1

Scratch for Arduino (S4A) – mediu de programare bazat pe limbajul Scratch

http://s4a.cat/

2

Modkit

http://www.modkit.com/

3.png

miniBloq

http://blog.minibloq.org/

 

Totuși, realizarea unui sistem IoT (Internet of Things) necesită, pe lângă partea de programare a unei plăci de dezvoltare, și programarea comunicației Internet, și dezvoltarea unui serviciu online IoT, și implementarea unei aplicații mobile pentru terminalele inteligente ce ne vor permite interacțiunea cu sistemul IoT. La prima vedere nu este o provocare ușor de depășit pentru o persoană fără o pregătire tehnică serioasă. Rolul acestei lecții este să vă prezinte o nouă generație de medii de dezvoltare orientate IoT ce fac implementarea unui astfel de sistem o joacă de copii J.

 

Pornit ca proiect finanțat prin intermediul platformei Kickstarter, proiectul Blynk este o platformă de dezvoltare care își propune să permită dezvoltarea de aplicații Internet Arduino / Android / iOs în doar 5 minute:

4

Blynk – build an app for your Arduino project in 5 minutes

https://www.kickstarter.com/projects/167134865/blynk-build-an-app-for-your-arduino-project-in-5-m

First drag-n-drop IoT app builder for Arduino, Raspberry Pi, ESP8266, SparkFun boards, and others

http://www.blynk.cc/

Platforma Blynk nu se limitează la familia de plăci de dezvoltare Arduino permițând utilizarea de plăci de dezvoltare variate precum:

  • Raspberry Pi

https://www.robofun.ro/raspberry-pi-si-componente/raspberry-pi-v2

https://www.robofun.ro/raspberry-pi-si-componente/raspberry-pi-v3

  • Particle Photon

https://www.robofun.ro/platforme/photon/particle-photon-with-headers

  • Plăci de dezvoltare bazate pe circuitul ESP8266

https://www.robofun.ro/wireless/wireless-wifi/adafruit-feather-huzzah-with-esp8266-wifi

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

https://www.robofun.ro/wireless/wireless-wifi/esp8266-thing

 

Una dintre cele mai interesante plăci de dezvoltare proiectate de compania Sparkfun special pentru a fi utilizată împreună cu platforma Blynk este Sparkfun Blynk Board:

5

Sparkfun Blynk Board ESP8266

https://www.robofun.ro/wireless/wireless-wifi/blynk-board-esp8266

 

Sparkfun Blynk Board se bazează pe circuitul WiFi programabil ESP8266 și integrează, pe lângă posibilitatea de alimentare de la un acumulator LiPo 3.7V și programarea directă prin USB a circuitului ESP8266, și un senzor de temperatură și umiditate Si7021, un led RGB WS2812, un adaptor pentru plaja 0-3.3V a canalului intern ADC a circuitului ESP8266 plus un sistem de conectare la pinii plăcii de dezvoltare a cablurilor cu cleme crocodil.

 

Placa vine preprogramată astfel încât se pot rula direct 14 exemple de proiect:

https://learn.sparkfun.com/tutorials/blynk-board-project-guide

 

Pentru a exemplifica ușurința de a dezvolta un sistem IoT cu ajutorul platformei Blynk vom utiliza placa de dezvoltarea Sparkfun Blynk Board pentru a implementa un sistem de monitorizare a temperaturii și umității prin Internet direct de pe telefonul mobil – fără a scrie nici o linie de cod bineînțeles – în 5 pași simplii:

 

Pasul 1.

Instalăm aplicația Blynk pe terminalul inteligent Android sau iOs și ne înregistrăm pentru utilizarea aplicației.

6

Instalarea aplicației și înregistrarea este gratuită dar utilizarea aplicației necesită un sistem de credite. Creditele sunt utile pentru construirea aplicației și se consumă pe măsură ce aplicațiile construite sunt din ce în ce mai complexe.

La instalarea aplicație vi se oferă 2000 de credite în mod gratuit iar achiziționarea plăcii de dezvoltare Sparkfun Blynk Board mai oferă 15000 de credite – suficient pentru a realiza orice tip de aplicație mobilă doriți.

Android:

Blynk – Arduino, ESP8266, RPi – Android Apps on Google Play

https://play.google.com/store/apps/details?id=cc.blynk

iOS:

Blynk – IoT for Arduino, Raspberry Pi, Particle, ESP8266, BLE and others

https://itunes.apple.com/us/app/blynk-control-arduino-raspberry/id808760481?ls=1&mt=8

Pasul 2.

Creăm un nou proiect sub aplicația Blynk. Modificăm numele proiectului și modelul hardware. Trebuie notat (sau trimis prin email) AUTH TOKEN pentru a putea crea legătura cu placa de dezvoltare la pasul următor.

7

 

Pasul 3.

Alimentăm placa de dezvoltare Sparkfun Blynk Board și cu ajutorul unui dispozitiv WiFi (laptop, telefon, tabletă) ne conectăm la rețeaua WiFi BlynkMe-XXXX. Deschidem un browser și accesăm adresa 192.168.4.1 . În această pagină configurăm rețeaua WiFi la care se va conecta placa de dezvoltare și introducem AUTH TOKEN ce realizează legătura dintre placă și proiectul mobil.

8

 

Pasul 4.

Ne reîntoarcem la proiectul creat în aplicația mobilă Blynk și adăugăm trei Widget Box-uri în interfața aplicației:

 

  • Un Widget de tip Labeled Value pe care îl vom conecta la pinul virtual V6 (pinii virtuali reprezintă niște mecanisme specifice platformei Blynk ce permit conectarea obiectelor din proiectul mobil de funcții ce rulează pe placa de dezvoltare – în cazul nostru pinul virtual V6 face conexiunea cu funcția ce returnează valoarea temperaturii în grade Celsius citită de la senzorul Si7021);

9

  • Un Widget de tip Labeled Value pe care îl vom conecta la pinul virtual V7 (pin virtual ce face conexiunea cu funcția de citire a umidității);

10

  • Un Widget de tip Hystory Graph pe care îl vom conecta simultan la cei doi pini virtuali V6 și V7.

11

Pasul 5.

Rulăm proiectul creat. Cost total aplicație: 1700 de credite (400+400+900).

12

Proiectul de față a ilustrat într-o manieră rapidă și extrem de simplă crearea unei aplicații mobile conectată prin intermediul Internetului la un dispozitiv de achiziție IoT fără a fi nevoie să scriem nici o linie de cod. Bineînțeles, facilitățile oferite de platforma Blynk sunt mult mai avansate și mai variate, unele dintre funcționalități necesitând scrierea de cod pentru o personalizare mai rafinată a implementării dar și în acest caz sarcina programatorului este mult ușurată de mecanismele specifice platformei.

 

Pentru exemple de proiecte cu un grad mai mare de complexitate se poate vizita pagina Blynk de pe site-ul hackster.io:

https://www.hackster.io/blynk/products/blynk