Proiect Închisoarea lui Bachus

5

De cele mai multe ori consumul de alcool afectează capacitatea de a evalua cantitatea de băutură consumată deja dar deschide apetitul pentru a bea din ce în ce mai mult.

1

”Personal nu beau niciodată mai mult de un pahar dar după un pahar devin cu totul și cu totul alt om. Acel om bea enorm de mult… ”

Având în vedere efectele negative grave cauzate de consumul excesiv de alcool proiectul de față își propune să construiască un sistem de protecție care să țină seama de cantitatea de alcool consumată deja – o încuietoare care nu se va deschide dacă persoana este în stare de ebrietate. Această încuietoare poate fi instalată la dulapul sau barul în care sunt depozitate băuturile alcoolice și va încerca să împiedice o persoană să consume mai mult decât este cazul. Bineînțeles, proiectul are un caracter strict demonstrativ – nu există nici o garanție că poate opri o persoană să consume prea mult alcool, fiecare persoană are responsabilitatea să consume băuturi alcoolice cu moderație.

Sistemul se va baza pe o placă de dezvoltare Arduino Uno și va include următoarele componente: un senzor brick alcool MQ-3, o placă releu SPDT 5V, o încuietoare solenoid, un brick buton și două brick-uri led.

2

https://www.robofun.ro/bricks/senzor-alcool-brick

3

https://www.robofun.ro/module/module-releu/releu-spdt-5V

4

https://www.robofun.ro/mecanice/mecanice-altele/incuietoare-solenoid-12vdc

Modul de funcționarea a sistemului va fi următorul: la pornirea sistemului încuietoarea este închisă și ledul roșu este aprins; pentru deblocare se apasă butonul și se suflă în senzor timp de 10 secunde – interval semnalizat de clipirea ledului roșu; dacă proba este negativă, nu există alcool în respirația celui testat, ledul roșu se va stinge, se va aprinde ledul verde și se va comanda de deschidere a încuietorii pentru 10 secunde.

Cele două leduri vor fi conectate pe pinii 5 și 6 ai plăcii de dezvoltare. Pinul 2 al plăcii de dezvoltare va fi utilizat pentru conectarea butonului (INT0) iar pinul 3 pentru comanda către încuietoare. Senzorul de alcool se va conecta pe pinul analogic A0.

#define led_verde 5

#define led_rosu 6

#define pin_releu 3

#define int_buton 0

Schema de interconectare între componentele utilizate este:

5

Chiar dacă senzorii de gaz din familia MQ sunt în general mari consumatori de curent și nu se recomandă alimentarea directă din placa de dezvoltare ci utilizarea unui surse externe de alimentare – senzorul de alcool MQ-3 nu consumă mai mult de 200mA deci poate fi alimentat direct și în cazul alimentării plăcii prin intermediul cablului USB și în cazul utilizării unui alimentator extern.

Comanda încuietorii se va realiza prin intermediul unui releu deoarece funcționează la o altă tensiune (12V) decât restul montajului. Având în vedere faptul că placa de dezvoltare Arduino Uno poate fi alimentată, prin intermediul regulatorului intern de tensiune, la tensiuni între 6V și 12V, sistemul poate fi alimentat în ansamblu de la o singură sursă de tensiune. Nu se recomandă utilizarea de baterii deoarece consumul este destul de mare și nu se va asigura o autonomie prea mare a sistemului.

În cadrul programului se vor utiliza următoarele variabile globale: unlockme – semnalizează apăsarea butonului de deschidere; alcool – conține valoarea citită de la senzor în mod curent; alcool_test – conține valoarea citită în urma testării. Comparația dintre cele două valori va sta la baza de deschidere sau nu a încuietorii.

volatile boolean unlockme = false;

int alcool, alcool_test;

În cadrul secțiunii setup() se realizează inițializarea pinilor de comandă și a procedurii  (unlock()) de tratare a evenimentului de apăsare a butonului.

void setup() {               

    attachInterrupt(int_buton,unlock,RISING);

    pinMode(pin_releu,OUTPUT);

    pinMode(led_rosu,OUTPUT);

    pinMode(led_verde,OUTPUT);

    digitalWrite(pin_releu,LOW);

    digitalWrite(led_verde,LOW);

    digitalWrite(led_rosu,HIGH);

}

void unlock() {  unlockme = true; }

Secțiunea loop() va implementa mecanismul de testare și de comandă a încuietorii. Funcționarea încuietorii se bazează pe un mecanism extrem de simplu: se compară valoarea de test (alcool_test) cu valoarea achiziționată chiar înainte de efectuarea testului (alcool). În cazul în care valoarea este mai mare (detecție alcool) sau egală (nu s-a suflat deloc în senzor) încuietoarea nu se va deschide. Comportamentul senzorului face ca în momentul unui test negativ (se suflă în senzor de către o persoană care nu a consumat alcool) valoarea raportată să fie mai mică decât valoarea citită în gol – acesta este cazul în care încuietoarea se va deschide. Cu alte cuvinte nu se poate păcăli senzorul și să se deschidă încuietoarea fără ca o persoană să efectueze testul.

void loop() {

    alcool = analogRead(0);

    if (unlockme) {

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

        digitalWrite(led_rosu,LOW);

        delay(500);

        digitalWrite(led_rosu,HIGH);

        delay(500);

      }

      unlockme = false;

      alcool_test = analogRead(0);

      if (alcool_test < alcool) {

        digitalWrite(led_rosu,LOW);

        digitalWrite(led_verde,HIGH);

        digitalWrite(pin_releu,HIGH);

        delay(10000);

        digitalWrite(led_rosu,HIGH);

        digitalWrite(led_verde,LOW);

        digitalWrite(pin_releu,LOW);

      }

      unlockme = false;

    }

    delay(1000);

}

În cazul în care doriți să implementați sisteme de testare mai sofisticate decât cel prezentat în această lecție vă recomandăm și următorul proiect:

The Droidalyzer – An open source, Bluetooth alcohol detector accessory for Android Phones

http://www.instructables.com/id/The-Android-Breathalyzer/

Proiect Instalație de Crăciun WiFi

10

Instalațiile de lumini pentru crăciun sunt printre cele mai distractive montaje care se pot realiza cu ajutorul plăcii de dezvoltare Arduino Uno. În cadrul proiectului de față vom realiza o instalație de lumini pentru crăciun conectată prin WiFi și controlabilă prin intermediul telefonului mobil.

1

Pe lângă placa de dezvoltare Arduino Uno vom utiliza shield-ul Sparkfun WiFi CC3000 ce va permite conectarea la rețeaua Internet și recepționarea comenzilor transmise de pe telefonul mobil inteligent.

2

https://www.robofun.ro/wireless/wireless-wifi/cc3000-wifi-shield

Pentru informații legate de utilizarea shield-ului Sparkfun WiFi CC3000 puteți consulta și următorul tutorial:

CC3000 Hookup Guide

https://learn.sparkfun.com/tutorials/cc3000-hookup-guide

Pentru partea de lumini vom utiliza un șir de leduri RGB de 12mm de la Adafruit (se pot utiliza mai multe seturi înseriate atâta timp cât se respectă puterea sursei de alimentare):

3

https://www.robofun.ro/electronice/led/led-uri-pixeli-rgb-de-12mm

Se recomandă citirea cu atenție a informațiilor de utilizare furnizate de producător:

12mm LED Pixels

https://learn.adafruit.com/12mm-led-pixels

Pentru a realiza conexiunea între sistemul de lumini și telefonul mobil, fără a fi nevoie să scriem o aplicație mobilă personalizată, vom utiliza platforma IoT Blynk:

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

boards, and others

http://www.blynk.cc/

Pentru o mai bună înțelegere a lecției de față se poate vedea și proiectul:

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

Cea mai importantă grijă în realizarea montajului este alimentarea corectă a acestuia. Trebuie avut în vedere că sistemul va necesita o sursă externă de tensiune de 5V, minim 2A. Schema de interconectare este următoarea:

4

Chiar dacă schema nu prezintă shield-ul WiFi se presupune că acesta este instalat deasupra plăcii Arduino Uno utilizând un set de conectori Arduino R3.

Sursa de tensiune externă va alimenta atât ansamblul placă de dezvoltare Arduino Uno + shield WiFi cât și șirul de 25 de leduri RGB. Comanda de la placa de dezvoltare se va transmite către șirul de leduri pe două fire: pinul 5 – fir galben – date și pinul 6 – fir verde – semnal de ceas.

În cadrul programului Arduino se vor utiliza următoarele biblioteci externe mediului Arduino IDE:

Blynk Library

https://github.com/blynkkk/blynk-library

Adafruit WS2801 Library

https://github.com/adafruit/Adafruit-WS2801-Library

Adafruit CC3000 Library

https://github.com/adafruit/Adafruit_CC3000_Library

#include <Adafruit_WS2801.h>

#define ADAFRUIT_CC3000_IRQ   2

#define ADAFRUIT_CC3000_VBAT  7

#define ADAFRUIT_CC3000_CS    10

#include <SPI.h>

#include <Adafruit_CC3000.h>

#include <BlynkSimpleCC3000.h>

int dataPin = 5;

int clockPin = 6;

Adafruit_WS2801 strip = Adafruit_WS2801(25, dataPin, clockPin);

În program se va personaliza AUTH TOKEN furnizat de aplicația mobilă Blynk la crearea aplicației de comandă:

char auth[] = “AUTH TOKEN“;

și datele de conectarea la rețeaua WiFi locală:

char ssid[] = ““;

char pass[] = ““;

int wifi_sec = WLAN_SEC_WPA2;

Dacă se dorește urmărirea mesajelor de control ale sistemului Blynk în consola serială se va lăsa următoarea linie necomentată:

#define BLYNK_PRINT Serial 

Următoarele variabile globale permit controlul funcționării sistemului de lumini. Variabila mode reține comportamentul de funcționare, există 5 moduri de funcționare: modul 0 – toate ledurile sunt stinse, modul 1 – toate ledurile sunt aprinse având aceiași culoare dictată de aplicația de comandă, modul 2 – toate ledurile sunt aprinse având culori diferite, modul 3 – este aprins un singur led care se plimbă de la un capăt la altul al șirului de leduri și modul 4 – sunt aprinse toate ledurile iar culoarea este dată de accelerometrul telefonului mobil de pe care se face comanda. Variabila shift va reține comanda de culoare dată de aplicația mobilă. Variabila automat indică declanșarea unui interval de funcționare automată la oră fixă stabilită în aplicația mobilă de comandă. Variabilele lastmode și lastshift conțin ultimele valori ale variabilelor corespondente pentru ca sistemul să poată să răspundă la modificarea acestora.

byte mode = 0;

byte lastmode = 255;

int shift = 0;

int lastshift = -1;

byte automat = 0;

În cadrul secțiunii setup() se va inițializa conexiunea cu platforma Blynk și obiectul de comandă al șirului de leduri.

void setup()

{ Serial.begin(9600);

  Blynk.begin(auth, ssid, pass, wifi_sec);

  strip.begin();

  strip.show(); }

Procedurile BLYNK_WRITE preiau comenzile primite de la aplicația mobilă prin intermediul unor pini virtuali: pinul V1 va transmite comanda de culoare, pinul V2 va transmite comanda de mod de funcționare, pinul V3 va transmite comanda de funcționare automată și pinul V4 va transmite valorile primite de la accelerometrul telefonului mobil.

BLYNK_WRITE(V4) {

  if (mode==4) {

    int r = param[0].asFloat();

    int g = param[1].asFloat();

    int b = param[2].asFloat();

    shift = Color(r,g,b); }

}

BLYNK_WRITE(V3) {

  automat = param.asInt();

  mode = 3; }

BLYNK_WRITE(V2) { mode = param.asInt(); }

BLYNK_WRITE(V1) { shift = param.asInt(); }

În cadrul secțiunii loop() este implementat algoritmul de funcționare propriu-zisă a instalației de lumini – cele 5 moduri de funcționare.

void loop()

{ Blynk.run();

  if ((lastmode!=mode) || (lastshift!=shift) || automat) {

  switch (mode) {

    case 0:

      for (int i = 0; i < strip.numPixels(); i++)

        strip.setPixelColor(i, 0);

      strip.show();

      break;

    case 1:

      for (int i = 0; i < strip.numPixels(); i++)

        strip.setPixelColor(i, Wheel(shift & 255));

      strip.show();

      break;

    case 2:

      for (int i = 0; i < strip.numPixels(); i++)

        strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + shift) & 255));

      strip.show();

      break;

    case 3:

      for (int i = 0; i < strip.numPixels(); i++) {

        if(i>0) strip.setPixelColor(i-1, 0);     

        strip.setPixelColor(i, Wheel(shift & 255));

        strip.show();

        delay(200);

      }     

      strip.setPixelColor(strip.numPixels()-1, 0);

      strip.show();

      break;

    case 4:

      for (int i = 0; i < strip.numPixels(); i++)

        strip.setPixelColor(i, shift);

      strip.show();

      break;

  }

  lastmode = mode;

  lastshift = shift;

  }

}

Funcțiile Wheel și Color sunt folosite pentru prelucrarea comenzilor de culoare.

uint32_t Wheel(byte WheelPos) {

  if (WheelPos < 85) {

    return Color(WheelPos * 3, 255 – WheelPos * 3, 0);

  } else if (WheelPos < 170) {

    WheelPos -= 85;

    return Color(255 – WheelPos * 3, 0, WheelPos * 3);

  } else {

    WheelPos -= 170;

    return Color(0, WheelPos * 3, 255 – WheelPos * 3);

  }

}

uint32_t Color(byte r, byte g, byte b) {

  uint32_t c;

  c = r;

  c <<= 8;

  c |= g;

  c <<= 8;

  c |= b;

  return c;

}

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.6.12, Arduino AVR Boards 1.6.15, Blynk Library 0.4.0, Adafruit CC3000 Library 1.0.3 și Adafruit WS2801 Library 1.0.0.

Bineînțeles, după realizarea și programarea sistemului de lumini este necesară generarea aplicației mobile utilizând aplicația Blynk:

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

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

Se generează o aplicație nouă, putem să o botezăm ”cristmas wifi” de exemplu.

5

Este important să notăm AUTH TOKEN furnizat la crearea aplicației pentru a putea să-l trecem în program.

Aplicația va include 4 controale (Widget Box):

  • Un Slider S (200 de credite) conectat la pinul virtual V2 ce va stabili modul de funcționare a sistemului, variază între 0 și 4;

6

  • Un Slider L (200 de credite) conectat la pinul virtual V1 ce va stabili comanda de culoare, variază între 0 și 500;

7

  • Un Timer (200 de credite) conectat la pinul virtual V3 ce va declanșa funcționarea automată la oră fixă;

8

  • Un Accelerometer (400 de credite) conectat la pinul virtual V4 ce va transmite valorile pe cele 3 axe ale accelerometrului telefonului mobil.

9

În final aplicația va arăta în acest fel. Costul total al aplicație 1000 de credite.

10

La final obținem o instalație de lumini de crăciun la care putem să stabilim culoarea de aprindere, tiparul de aprindere, putem să o programăm să lumineze la oră fixă sau putem pur și simplu să ne facem de cap comandând-o prin intermediul accelerometrului din telefonul mobil. Puteți explora și alte facilități ale platformei Blynk pentru a vă personaliza instalația așa cum doriți.

Se pot consulta și alte metode de comandă WiFi pentru o instalație de lumini dar soluția propusă este una dintre cele mai simple și mai flexibile:

WiFi Controlled LED Christmahanukwanzaa Tree

https://learn.adafruit.com/wifi-controlled-led-christmahanukwanzaa-tree

ESP8266 controlling WS2812 Neopixel LEDs using Arduino IDE – A Tutorial

http://www.instructables.com/id/ESP8266-controlling-Neopixel-LEDs-using-Arduino-ID/

Arduino NeoPixel Wifi

https://create.arduino.cc/projecthub/andres-santos/arduino-neopixel-wifi-d1a93c

Controlling Neopixels with processing via wifi to nodeMCU

http://fablab.ruc.dk/controlling-neopixels-with-processing-via-wifi-to-nodemcu/

Proiect Termometru/Higrometru Color

4

În cadrul proiectului de față ne propunem să explorăm interfețe utilizator alternative. În ciuda ecranelor din ce în mai performante există o tendință clară de a afișa informația altfel, de a distruge monotonia cifrelor și a alfabetului obișnuit – putem aici să dăm exemplu moda ceasurilor binare dar și o serie de dispozitive exotice precum dispozitive de afișare bazate exclusiv pe ”smiley faces” sau dispozitive care indică o anumită stare de funcționare prin schimbarea culorii.

1

Termometru/Higrometru Color este un sistem de măsurare a temperaturii și umidității ambientale dar care spre deosebire de sistemele clasice va indica valoarea parametrilor măsurați prin intermediul unui șir de led-uri RGB.

Există mai multe proiecte ce abordează acest subiect dar într-un mod destul de simplist:

Color Thermometer, powered by Arduino

https://youtu.be/EBrK2lqup-c

Trinket LED Thermometer

https://hackaday.io/project/3440-trinket-led-thermometer

Tutorials with Arduino: Temperature by colors.

http://arduinoarts.com/2011/08/arduino-tutorial-temperature-by-colors/

Temperature-controlled RGB LED

https://www.hackster.io/ben/temperature-controlled-rgb-led-6c8cdf

Visualizing temperature as color using an RGB led, a LM35 sensor and Arduino

https://sjackm.wordpress.com/2012/03/26/visualizing-temperature-as-color-using-an-rgb-led-a-lm35-sensor-and-arduino/

(acest proiect a inspirat și formula de calcul utilizată în programul din această lecție)

Pentru măsurarea temperaturii și umidității vom utiliza un senzor digital I2C Si7021:

2

https://www.robofun.ro/senzori/vreme/enzor-umiditate-si-temperatura-si7021

Pentru afișare vom utiliza un modul Adafruit NeoPixel Ring cu 16 leduri RGB adresabile individual WS2812 5050 (bineîțeles se poate utiliza și varianta cu 24 de leduri fără a modifica schema electrică sau programul, doar numărul de leduri: constanta din program NUMPIXELS) – culoarea va fi dictată de temperatura măsurată iar numărul / poziția ledurilor aprinse vor fi influențate de umiditatea măsurată:

3

https://www.robofun.ro/electronice/led/neopixel-ring-16-x-ws2812-5050-rgb-led

În cadrul programului vom utiliza două biblioteci externe mediului Arduino IDE:

Adafruit Si7021 – pentru a interacționa cu senzorul Si7021

https://github.com/adafruit/Adafruit_Si7021

Adafruit NeoPixel – pentru comanda ledurilor NeoPixel

https://github.com/adafruit/Adafruit_NeoPixel

#include <Adafruit_Si7021.h>

#include <Adafruit_NeoPixel.h>

Adafruit_Si7021 sensor = Adafruit_Si7021();

#define PIN            6

#define NUMPIXELS      16

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

Una din problemele majore ale sistemului propus este consumul destul de mare pentru cele 16 leduri ale modulului NeoPixel – fiecare led poate ajunge la un curent maxim de 60mA adică consumul total al modulului poate ajunge la 0.06A*16=0.96A … aproape 1A. Din acest motiv vom propune două scheme electrice și două moduri de funcționare ale programului. Primul mod de funcționare (LOW_POWER) va aprinde un singur led din cele 16 – culoarea acestuia va fi dictată de temperatură iar poziția de umiditate. Acest mod de funcționare va fi semnalizat în program prin următoarea declarație:

#define LOW_POWER

și va permite alimentarea modulului NeoPixel direct din placa de dezvoltare Arduino Uno:

4Pentru a lucra cu (a aprinde) mai multe leduri simultan este necesară utilizarea unei surse de alimentare externă. Prin comentarea (ștergerea) declarației de LOW_POWER din program, sistemul va aprinde toate ledurile până la poziția dictată de umiditate (variabila max_pixel) generând un efect luminos mult mai puternic. Având în vedere faptul că sistemul se pretează foarte bine la integrarea într-un alt obiect (sub o vază de sticlă sau într-un obiect decorativ transparent) cea de a doua schemă propusă (cu alimentare suplimentară externă) utilizează placa de dezvoltare Arduino Nano pentru o dimensiune mai mică a sistemului:

5

Secțiunea setup() se va ocupa cu inițializarea celor două obiecte de lucru sensor și pixels. Secțiunea loop() va realiza partea de achiziție (sensor.read…) și partea de comandă  (pixels.setPixelColor…) a ledurilor RGB.

void setup() {

  sensor.begin();

  pixels.begin(); }

void loop() {

  float temperature, humidity;

  temperature = sensor.readTemperature();

 humidity = sensor.readHumidity();

Poziționarea ledului aprins sau a numărului de leduri aprinse până la o anumită poziție se va face printr-o corelație umiditate (0%-100%) și numărului de leduri din modulul NeoPixel (0-NUMPIXELS).

  byte max_pixel;

 max_pixel = map(humidity, 0, 100, 0, NUMPIXELS);

Corelarea între temperatură și culoare ledului / ledurilor aprinse se face după următoarele reguli:

  • Componenta roșie (Red) va fi aprinsă la maxim peste 35 de grade, gradual între 18 și 35, deloc sub 18 grade;
  • Componenta verde (Green) va fi aprinsă crescător în intervalul 25 – 28 de grade, descrescător în intervalul 28 – 35 de grade și deloc în afara celor două intervale;
  • Componenta albastră (Blue) va fi aprinsă la maxim sub 18 grade, deloc peste 25 grade iar între cele două valori va descrește gradual.

Bineînțeles, plajele de corelație pot fi modificate în funcție de temperatura ambientală a mediului în care va funcționa sistemul.

byte r = 0, g = 0, b = 0;

 if(temperature<18) r = 0;

 else if (temperature>=18)

r = map(temperature, 18, 35, 1, 254);

 else if (temperature>35) r = 255;

if(temperature<25) g = 0;

 else if ((temperature>25)&&(temperature<=28))

g = map(temperature, 25, 28, 1, 254);

 else if ((temperature>28)&&(temperature<=35))

g = map(temperature, 28, 35, 255,1);

 else if (temperature>35) g = 0;

 if(temperature<18) b = 255;

 else if ((temperature>=18)&&(temperature<=25))

b = map(temperature, 18, 25, 255, 0);

 else if (temperature>25) b = 0;

 pixels.setPixelColor(0, pixels.Color(r,g,b));

 pixels.show();

 delay(500);

 for(int i=1;i<max_pixel;i++){

    #ifdef LOW_POWER

      pixels.setPixelColor(i-1, pixels.Color(0,0,0));

    #endif

    pixels.setPixelColor(i, pixels.Color(r,g,b));

    pixels.show();

    delay(500);

  }

 delay(5000);

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

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

  }

 pixels.show();

}

Programul a fost realizat și testat cu Arduino IDE 1.6.12, Arduino AVR Boards 1.6.15, Adafruit NeoPixel 1.0.6 și Adafruit Si7021 1.0.0.

Proiect Aurora – geomagnetic lights

1

Proiectul de față își propune să realizeze un sistem de lumini care să redea prin culoare valoarea câmpului magnetic al pământului – de aici și denumirea lecției și paralela cu luminile aurorei boreale.

1

Pentru implementare vom utiliza o placă de dezvoltare Polulu A-Star 32U4 Micro bazată pe microcontrolerul ATmega32U4 (la fel ca și Arduino Leonardo) și care are dimensiuni mult mai mici decât oricare altă placă similară (are o dimensiune de două ori mai mică decât Arduino Micro). Bineînțeles în cadrul proiectului se poate substitui placa de dezvoltare cu o placă echivalentă (Arduino Leonardo sau Arduino Micro) dar dimensiunea sistemului va fi … mai mare (și prețul un pic … mai mare).

2

https://www.robofun.ro/platforme/avr/a-star-32u4-micro

Pentru măsurarea câmpului magnetic al pământului vom utiliza senzorul digital I2C HMC5883L – magnetometru pe trei axe:

3

https://www.robofun.ro/senzori/magnetic/magnetometru_3axe_HMC5883L

Pentru implementarea sistemului de lumini ne vom păstra într-o clasă de dimensiuni reduse și vom utiliza un ansamblu de 7 leduri RGB WS2812 5050 și anume Neopixel Jewel:

4

https://www.robofun.ro/electronice/led/neopixel-jewel-7-x-ws2812-5050-rgb-led-with-integrated-drivers

Schema de interconectare între placa de dezvoltare și celelalte două componente ale sistemului este:

5

Senzorul HMC5883L se va alimenta la 3.3V și va utiliza pinii 2 (SDA) și 3 (SCL) ai plăcii de dezvoltare. Neopixel Jewel se va alimenta la 5V și va utiliza pinul 9 al plăcii de dezvoltare (conectat la pinul IN).

Dimensiunea redusă a sistemului rezultat ne va conduce imediat cu gândul la o implemetare portabilă (o broșă sau un glob pentru pomul de crăciun) dar pentru a face acest lucru trebuie avute în vedere două aspecte extrem de importante:

  • Cele 7 leduri 5050 degajă destul de multă căldură dacă sunt aprinse la maxim pentru o perioadă lungă de timp – trebuie lăsat spațiu suficient pentru răcire;
  • Chiar dacă placa de dezvoltare acceptă pe pinul VIN tensiuni între 5.5V și 15V regulatorul intern poate debita un curent maxim de 100mA – nu poate alimenta Neopixel Jewel prin intermediul regulatorului intern al plăcii de dezvoltare – se recomandă utilizarea unei surse externe de 5V de minim 500mA.

Programul sistemului va utiliza următoarele biblioteci externe mediului Arduino IDE:

Adafruit Unified Sensor Driver și Adafruit HMC5883L Driver pentru citirea magnetometrului;

https://github.com/adafruit/Adafruit_Sensor

https://github.com/adafruit/Adafruit_HMC5883_Unified

FastLed pentru comanda Neopixel Jewel.

https://github.com/FastLED/FastLED

Proiectul propune două exemple de program care să realizeze corelarea între citirile oferite de senzorul HMC5883L și comanda Neopixel Jewel dar sperăm ca acestea să reprezinte doar un punct de plecare în explorarea unor variante personale.

Primul exemplu de program va aprinde simultan toate cele 7 leduri ale Neopixel Jewel iar valorile câmpului magnetic al pământului pe cele trei axe vor influența cele trei componente de culoare (RGB – red/green/blue) ale tuturor ledurilor. Astfel se va realiza o corelație între valorile câmpului magnetic pe axele X, Y și Z și valorile R, G, B de comandă. Chiar dacă senzorul este capabil să raporteze valori între -800uT și 800uT ale câmpului magnetic corelarea se va face doar pe intervalul -60uT și 60uT – interval normal de achiziție.

#include <Wire.h>

#include <Adafruit_Sensor.h>

#include <Adafruit_HMC5883_U.h>

Adafruit_HMC5883_Unified mag =

 Adafruit_HMC5883_Unified(12345);

#include “FastLED.h”

#define NUM_LEDS 7

#define DATA_PIN 9

CRGB leds[NUM_LEDS];

void setup() {

  if(!mag.begin())  {  while(1); }

  FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS); }

void loop() {

  sensors_event_t event;

  mag.getEvent(&event);

  int r,g,b;

  r = map(event.magnetic.x, -60, 60, 0, 255);

  g = map(event.magnetic.y, -60, 60, 0, 255);

  b = map(event.magnetic.z, -60, 60, 0, 255);

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

    leds[i].setRGB( r, g, b);

    FastLED.show();

    delay(10);

  }

FastLED.show();

delay(1000); }

Cel de al doilea exemplu de program va calcula unghiul față direcția nord (cap compas) și va indica direcția nord (la fel ca și un instrument de tip busolă).  Pe Neopixel Jewel se vor aprinde doar trei leduri: cel din centru ce va indica intesitatea câmpului magnetic pe axa Z (neutilizată în calculul cap compas) pe culoarea albastră și alte două leduri diametral opuse vor da direcția – unul roșu (ce va indica nordul) și unul verde ce va indica sudul. Bineîțeles, corectitudinea geomagnetică a indicatorului rezultat constă și în alinierea corectă geometrică între senzorul magnetic și Neopixel Jewel.

#include <Wire.h>

#include <Adafruit_Sensor.h>

#include <Adafruit_HMC5883_U.h>

Adafruit_HMC5883_Unified mag = Adafruit_HMC5883_Unified(12345);

#include “FastLED.h”

#define NUM_LEDS 7

#define DATA_PIN 9

CRGB leds[NUM_LEDS];

void setup() {

  if(!mag.begin()) { while(1); }

   FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);   }

void loop() {

  sensors_event_t event;

  mag.getEvent(&event);

  float heading = atan2(event.magnetic.y, event.magnetic.x);

  float declinationAngle = 0.22;

  heading += declinationAngle;

  if(heading < 0) heading += 2*PI;

  if(heading > 2*PI) heading -= 2*PI;

  float headingDegrees = heading * 180/M_PI;

  int l1, l2;

  if ((headingDegrees>=0)&&(headingDegrees<60)) { l1 = 1; l2 = 4; }

  if ((headingDegrees>=60)&&(headingDegrees<120)) { l1 = 2; l2 = 5; }

  if ((headingDegrees>=120)&&(headingDegrees<180)) { l1 = 3; l2 = 6; }

  if ((headingDegrees>=-60)&&(headingDegrees<0)) { l1 = 4; l2 = 1; }

  if ((headingDegrees>=-120)&&(headingDegrees<-60)) { l1 = 5; l2 = 2; }

  if ((headingDegrees>=-180)&&(headingDegrees<-120)) { l1 = 6; l2 = 3; }

  int r,g,b;

  b = map(event.magnetic.z, -60, 60, 0, 255);

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

    leds[i] = CRGB::Black;

    FastLED.show();

    delay(10);

  }

  FastLED.show();

  leds[0].setRGB( 0, 0, b);

  leds[l1].setRGB( 255, 0, 0);

  leds[l2].setRGB( 0, 255, 0);

  FastLED.show();

  delay(1000); }

Cele două programe au fost dezvoltate și testate cu Arduino IDE 1.6.12, Pololu A-Star 32U4 Drivers commit b0fc0c0, FastLED 3.1.3, Adafruit HMC5883 Unified 1.0.0 și  Adafruit Unified Sensor 1.0.2.

Pentru mai multe surse de inspirație puteți trece în revistă și următoarele proiecte:

Neopixel Cosmic Turtle Necklace

https://learn.adafruit.com/neopixel-led-magnetic-pendant-necklace

Jewel Hair Stick

https://learn.adafruit.com/jewel-hair-stick

FLORA NeoGeo Watch

https://learn.adafruit.com/flora-geo-watch

Raspberry Pi ca server de timp

3

În lipsa unei conexiuni Internet un sistem bazat pe Raspberry Pi este incapabil să mențină ora și data exactă dacă se întrerupe alimentarea cu energie electrică. Cea mai simplă modalitate de a rezolva acest lucru este adăugarea unui modul RTC la placă (așa cum am arătat și în proiectul Conectarea unui RTC I2C la o placă Raspberry Pi). În cadrul acestui proiect vom prezenta o modalitate de a transforma un sistem Raspberry Pi în sursă de timp într-o rețea de sisteme fără conexiune Internet. Imaginați-vă o rețea de plăci Raspberry Pi, fără conectivitate Internet, care au nevoie de oră și dată exacte și, mai mult decât atât, acestea să fie sincronizate. Instalarea a câte un modul RTC pe fiecare sistem va rezolva problema orei și datei pe fiecare sistem în parte dar nu va asigura sincronizarea exactă între sisteme. Din acest motiv o soluție mult mai elegantă este instalarea unui singur modul RTC și sincronizarea prin rețea a celorlalte sisteme cu sistemul pe care este instalat modulul RTC.

1

Ca modul RTC vom utiliza un modul Sparkfun DeadOn RTC bazat pe circuitul DS3234 – circuit RTC extrem de precis și care are un sistem de compensare a frecvenței de ceas pentru variații de temperatură.

2

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

Modulul RTC necesită o baterie de 3V / 12mm (CR1220 de exemplu) pentru a menține ora și data în lipsa alimentării cu energie electrică a sistemului – bateria nu este inclusă la cumpărarare modulului.

Interconectarea cu placa Raspberry Pi se face prin intermediul magistralei seriale SPI și necesită următoarele conexiuni: pinul SS al modulului se va conecta la pinul GPIO8, pinul MOSI la pinul GPIO10, pinul MISO la pinul GPIO8, pinul SCLK la pinul GPIO11, pinul VCC la 3.3V și pinul GND la GND (precum în schema următoare).

3

Pentru a comunica cu modulul este necesar să activăm comunicația SPI prin intermediul utilitarului raspi-config:

sudo raspi-config

4

5

6

 

După activarea comunicației SPI vom crea un fișier ds3234-rpi-overlay.dts în care vom introduce următoarele:

/dts-v1/;

/plugin/;

/ {

    compatible = “brcm,bcm2708”;

    fragment@0 {

        target = <&spi0>;

        __overlay__ {

            spidev@0 {

                status = “disabled”;

            };

            ds3234@0 {

                compatible = “ds3234”;

                reg = <0>;

                #address-cells = <1>;

                #size-cells = <0>;

                spi-max-frequency = <500000>;

            };

        };

    };

};

și pe care îl vom transforma cu ajutorul comenzii:

sudo dtc -@ -I dts -O dtb -o ds3234-rpi-overlay.dtb ds3234-rpi-overlay.dts

și să copiem fișierul rezultat în /boot/overlay/ (fișierele de lucru pot fi șterse ulterior)

cp ds3234-rpi-overlay.dtb /boot/overlays/

În cazul în care comanda dtc nu este recunoscută trebuie să instalăm pachetul software device-tree-compiler:

sudo apt-get install device-tree-compiler

În final trebuie să ne asigurăm că fișierul /boot/config.txt conține următoarele două linii:

dtparam=spi=on

dtoverlay=ds3234-rpi

și să restartăm sistemul:

sudo reboot

După repornire vom verifica încărcarea modulului asociat RTC-ului:

pi@raspberrypi ~ $ lsmod | grep ds3234

rtc_ds3234              2088  0

și inițializarea corectă a acestuia:

pi@raspberrypi ~ $ dmesg | grep ds3234

[4.443480] ds3234 spi0.0: Control Reg: 0x1c

[4.443617] ds3234 spi0.0: Ctrl/Stat Reg: 0x88

[4.456070] ds3234 spi0.0: rtc core: registered ds3234 as rtc0

Din acest moment sistemul va utiliza modulul RTC ca sursă de timp. Inițializarea acestuia se va face cu ajutorul comenzii de scriere în memoria internă (sincronizarea de timp inițială):

sudo hwclock -w

iar verificarea se poate face cu ajutorul comenzii:

sudo hwclock -r

Pentru ca ora și data sistemului să fie disponibile în rețea este necesară configurarea unui server de NTP (Network Time Protocol). În general pachetul ntp este deja instalat în distibuția Linux a plăcii Raspberry Pi dar funcționează ca și client (sincronizează ceasul local prin intermediul rețelei Internet utilizând servere NTP publice). Pentru a activa caracteristica de server este necesară editarea fișierului /etc/ntp.conf, comentarea tuturor liniilor și înscrierea următoarei configurații (sau se poate înlocui fișierul cu totul):

driftfile /var/lib/ntp/ntp.drift

statistics loopstats peerstats clockstats

filegen loopstats file loopstats type day enable

filegen peerstats file peerstats type day enable

filegen clockstats file clockstats type day enable

Pentru activarea propriu-zisă a componentei de server sunt necesare următoarele linii (15 este rangul Stratum al serverului NTP, în cazul nostru este extrem de scăzut fiindcă sincronizarea nu se bazează pe un server extern):

server 127.127.1.0

fudge 127.127.1.0 stratum 15

Următoarele două linii sunt necesare pentru ca celelalte sisteme să poată interoga serverul (IPv4 și IPv6):

restrict -4 default kod notrap nomodify nopeer noquery

restrict -6 default kod notrap nomodify nopeer noquery

Vom permite interogările de pe sistemul local:

restrict 127.0.0.1

restrict ::1

și din rețeaua locală din care face parte sistemul (se presupune că este o clasă C de tipul 192.168.xxx.0/24):

restrict 192.168.xxx.0 mask 255.255.255.0 notrap

broadcast 192.168.xxx.255

După salvarea fișierului se va reporni serviciul ntp:

sudo /etc/init.d/ntp restart

și vom verifica starea serverului NTP:

pi@raspberrypi /etc $ ntpq -c rv 127.0.0.1

associd=0 status=0515 leap_none, sync_local, 1 event, clock_sync,

version=”ntpd 4.2.6p5@1.2349-o Mon Jul 25 22:35:28 UTC 2016 (1)”,

processor=”armv7l”, system=”Linux/4.4.38-v7+”, leap=00, stratum=16,

precision=-20, rootdelay=0.000, rootdisp=10.927, refid=…,

reftime=dc06888a.0d4b5241  Thu, Dec 22 2016 19:14:50.051,

clock=dc06888a.405fc437  Thu, Dec 22 2016 19:14:50.251, peer=55790, tc=6,

mintc=3, offset=0.000, frequency=-5.806, sys_jitter=0.000,

clk_jitter=0.001, clk_wander=0.000

Pe celelalte sisteme din rețea (sistemele client) se va edita același fișier /etc/ntp.conf , se va configura o directivă server cu adresa sistemului configurat ca server NTP (celelalte servere se pot comenta) și se va reporni serviciul ntp.

Configurația prezentată a fost testată pe sisteme rulând Raspbian GNU/Linux 8 (jessie), kernel 4.4.38-v7+ și ntp 4.2.6p5.

Materialul de față a fost inspirat de următoarele proiecte:

Raspberry PI and your SPI Real Time Clock (RTC)

http://www.sciencegizmo.com.au/?p=137

The Raspberry Pi as a Stratum-1 NTP Server

http://www.satsignal.eu/ntp/Raspberry-Pi-NTP.html

How sunny is the Blue? (partea a II-a)

Dacă în prima parte a acestui proiect am explicat cum construim un dispozitiv electronic ce măsoară câțiva parametrii asociați cu radiația solară (intensitate luminoasă, index radiații ultraviolete, temperatură ambientală generată) și cum configurăm serviciul Cloud IBM BlueMixTM pentru a putea conecta dispozitivul la acest serviciu, în cadrul părții a doua vom vedea ce alte posibilități interesante oferă platforma cloud.

Configurarea serviciului IBM Watson IoT Platform – Boards and Cards

Cea mai la îndemână facilitate pusă la dispoziție de serviciul IoT IBM Watson este realizarea unui panou de control (dashboard sau board) în care pot fi urmărite în timp real toate informațiile transmise de dispozitivul nostru IoT. La crearea serviciului panoul vine preconfigurat cu 3 secțiuni de supraveghere (boards): Usage Overview – secțiune în care pot fi vizualizate informații legate de cantitatea de informații transferată de dispozitivul IoT către platforma Watson; Device-Centric Analytics – secțiune în care se pot consulta informații legate de proprietățile de bază ale dispozitivului și un istoric al alarmelor generate de aceste (vom vedea imediat într-o secțiune următoare cum definim alarme asociate dispozitivului); Rule-Centric Analytics – similar cu precedenta secțiune dar cu un grad de detaliere mai mare asupra evenimentelor generate de dispozitiv.

2

Bineînțeles, putem crea noi secțiuni de supraveghere (+ Create New Board) în care putem defini afișaje personalizate (+ Add New Card). Pentru dispozitivul nostru vom defini o secțiune pe care o vom denumi DATA și în care vom adăuga 3 afișaje (Cards) – câte unul pentru fiecare dintre parametrii transmiși de dispozitivul nostru: un indicator de tip gauge pentru indexul UV, un  indicator de tip bar chart pentru intensitatea luminoasă și un indicator de tip grafic pentru temperatura ambientală.

3

4

Configurarea unui astfel de afișaj este foarte simplă, trebuie indicate: dispozitivul (în cazul nostru WICED), parametrul dorit pentru afișare (în captura de mai jos Temperature) și tipul de date al parametrului, tipul de afișaj și schema de culoare.

5

Aceste afișaje nu arată istoricul de evoluție al unui parametru ci doar valorile măsurate în timp real. În acest moment platforma nu stochează în nici un fel informațiile transmise de dispozitivul nostru ci doar este capabilă să le afișeze pe măsură ce sunt recepționate.

Configurarea serviciului IBM Watson IoT Platform – Data Storage

Dacă dorim ca informațiile transmise de dispozitivul nostru să fie stocate pentru a putea fi prelucrate ulterior (statistic sau în scopul afișării pe anumite perioade de timp) trebuie să activăm extensia Historical Data Storage. Acest lucru este posibil accesând secțiunea Extension / Historical Data Storage.

6

Această extensie va utiliza baza de date implicită a aplicației create în platforma cloud în lecția anterioară. Datele salvate nu sunt utile direct platformei IBM Watson IoT dar pot fi utilizate de către o aplicație cloud asociată.

7

 

Configurarea serviciului IBM Watson IoT Platform – Definirea de alarme

O altă facilitate utilă oferită de platforma IBM Watson IoT este definirea de alarme asociate datelor recepționate de serviciul IoT. Acestea se definesc în secțiunea Rules. Există două tipuri de alarme Edge Rule și Cloud Rule. Edge Rule este un tip de alarmă ce permite generarea de evenimente către alte aplicații din cloud – un fel de preprocesor de alarme – nu dă naștere la o alarmă propriu-zisă ci trimite mai departe evenimentul. Cloud Rule permite generarea de evenimente imediate: trimiterea unui email, trimiterea evenimentului către IFTTT sau către o aplicație Node-RED. Pentru exemplificare vom defini o alertă de tip Cloud Rule ce va trimite un email de fiecare dată când parametrul temperatură va depăși valoarea de 35oC.

8

9

Astfel, de fiecare când temperatura va depăși valoarea dată vom primi un email de tipul:

10

 

Configurarea unei aplicații Node-RED – postarea de mesaje pe Twitter

În momentul în care am creat aplicația inițială (sundetector – în lecția anterioară), pe lângă baza de date asociată și activarea serviciului Watson, a fost generată și o aplicație implicită Node-RED cu domeniul asociat numeaplicatie.mybluemix.net (în cazul nostru sundetectori.mybluemix.net).

Node-RED este un instrument de programare vizuală destinat sistemelor IoT. Pentru mai multe informații legate de Node-RED puteți consulta și:

Node-RED

https://nodered.org/

What is Node-RED? How can it be used for the Internet of Things?

http://heidloff.net/article/21.01.2015081841NHEAL8.htm

Node RED Programming Guide – Programming the IoT

http://noderedguide.com/

11

Accesând domeniul asociat aplicației Node-RED vom putea utiliza editorul ce ne va permite dezvoltarea aplicației propriu-zise. Aplicația Node-RED poate fi de tip web și atunci domeniul asociat aplicației se va transforma într-un portal web conectat la sistemul nostru IoT. În cazul exemplului de față vom realiza o aplicație ce va prelua datele primite de serviciul Watson și va transmite periodic valoare indexului UV ca postare pe Twitter.

12

Vom șterge toate diagramele predefinite – aplicația conține un flux Node-RED predefinit (o mică aplicație demonstrativă) – și vom realiza următoarea aplicație:

13

în care vom utiliza următoarele următoarele blocuri funcționale:

14

Nod de tip ibmiot ce ne va furniza datele provenite de la serviciul Watson. Trebuie configurat cu tipul și numele dispozitivului IoT.

15

 

16

Nod de tip function ce va extrage valoarea indexului UV din mesajul json transmis de dispozitivul IoT.

17

 

18

Nod de tip rbe ce va lăsa să treacă mai departe fluxul de informații doar dacă indexul UV se modifică – facem acest lucru pentru a nu posta mesaje duplicat pe Twitter.

19

 

20

Nod de tip function ce va contrui textul postării pe Twitter.

21

 

22

Nod de ieșire ce va trasmite datele către Twitter. Trebuie configurat cu credențialele de acces ale unui cont valid Twitter.

23

Nod de ieșire pentru depanarea aplicației. Va afișa în fereastra de debug ieșirile nodurilor conectate la el. Nu este esențial în funcționarea aplicației.

După construirea aplicației și după ce vom activa (Deploy) aplicația vom putea deja să vedem pe Twitter primele postări.

24

Facilitățile platformei Cloud IBM BlueMixTM prezentate în acest proiect acoperă într-o foarte mică măsură funcționalitățile acesteia. Platforma pune la dispoziție limbaje multiple de programare pentru dezvoltarea de aplicații cloud, diverse tipuri de baze de date și o multitudine de servicii conexe extrem de interesante (machine learning, analiză de imagini, analiză lexicală ș.a.m.d.). Sperăm doar să vă fi trezit interesul și în acest sens dăm ca exemplu și:

IBM Bluemix, IoT, and Star Wars Droids

https://youtu.be/_pMG6TL04Q0

A sample project to control BB-8 Droid using Bluemix IoTF and MQTT

https://github.com/shamimshossain/bb8-bluemix

How sunny is the Blue? (partea I)

8

În cadrul proiectului de față vom prezenta implementarea unui sistem de tip IoT (Internet of Things) ce supraveghează radiațiile solare (intensitate luminoasă, factor radiații UV, temperatură ambientală generată) și utilizează serviciul cloud IBM BlueMixTM. Serviciul IBM BlueMixTM este un serviciu comercial dar care oferă posibilitatea de evaluare pentru o perioadă de 30 de zile sau, pentru studenții și profesorii din unele instituții de învățământ superior, accesul este gratuit. Platforma Cloud IBM BlueMixTM pune la dispoziția utilizatorilor un serviciu IoT specializat și anume IBM Watson IoT Platform. Accesul la acest serviciu face parte din serviciile puse la dispoziție de platforma cloud. Primul pas pentru accesarea acestui serviciu este înregistrarea unui cont trial – spre deosebire de alte servicii similare (Microsoft Azure, Google Cloud Platform sau Amazon Web Services) înregistrarea nu necesită introducerea de informații legate de un card bancar:

Sign up for IBM Bluemix

https://console.ng.bluemix.net/registration/

După înregistrare și conectare la platformă se va naviga în zona de aplicații și se va crea o aplicație nouă (Create Application) de tipul Boilerplates / Internet of Things Platform Starter:

2

Se va alege un nume pentru aplicație (în cadrul lecției se va utiliza numele sundetector dar numele aplicației trebuie să fie unic) și se va da comanda (Create) de alocare de resurse cloud pentru această aplicație nouă.

3

Alocarea de resurse poate dura câteva minute sau zeci de minute. Finalizarea operației este marcată de schimbarea stării aplicației în Running.

4

Pentru a putea conecta dispozitivul la aplicația nou creată trebuie să mergem în Dashboard-ul de administrare a serviciului sundetector-iotf-service (Connect your devices / Launch dashboard). Comanda ne va direcționa către portalul IBM Watson IoT Platform unde vom crea un nou dispozitiv (Devices / Add Device). Nu trebuie să completăm decât tipul dipozitivului (în exemplul nostru Adafruit_Feather) și numele dispozitivului (în exemplul nostru WICED). La finalizarea adăugării noului dispozitiv trebuie să notăm informațiile de autentificare furnizate de platformă pentru a putea să le folosim în programul dispozitivului (Organization ID, Device Type, Device ID, Authentication Method și Authentication Token).

Este posibilă utilizarea platformei IBM Watson IoT Platform și fără autentificare utilizator (fără a înregistra un cont trial pe IBM BlueMixTM), ca și Demo User, dar nu vom utiliza această variantă deoarece nu oferă nici un fel de securitate sau garanție de funcționare a serviciilor – această variantă este denumită Playground (loc de joacă). Dacă se dorește totuși efecturarea unor teste rapide adresa de conectare este:

Play with the IBM Watson IoT Platform dashboard

https://play.internetofthings.ibmcloud.com/dashboard/#/boards/

Pentru mai multe informații despre utilizarea și configurarea serviciului IBM Watson IoT Platform se poate consulta documentația oficială:

Getting started with Watson IoT Platform

https://console.ng.bluemix.net/docs/services/IoT/index.html

Pentru construirea dispozitivului IoT de supraveghere a radiațiilor solare vom utiliza o placă de dezvoltare Adafruit Feather WICED WiFi – cea mai nouă și mai puternică placă WiFi din gama Adafruit Feather ce combină un microcontroler STM32F205RG ARM Cortex M3 ce rulează la 120MHz cu modulul WiFi BCM43362 802.11b/G/N și care poate fi totuși programată cu mediul Arduino IDE.

5

https://www.robofun.ro/wireless/wireless-wifi/adafruit-wiced-wifi-feather-stm32f205-with-broadcom-wiced-wifi

Pentru mai multe informații despre instalarea (procedura de instalare sub mediul Arduino IDE necesită puțină mai multă atenție decât alte plăci Adafruit Feather) și utilizarea plăcii Adafruit Feather WICED WiFi se poate consulta:

Introducing the Adafruit WICED Feather WiFi | Adafruit Learning System

https://learn.adafruit.com/introducing-the-adafruit-wiced-feather-wifi/

Pentru partea de achiziție a parametrilor propuși vom utiliza doi senzori digitali (I2C):

Senzorul de lumină și radiații UV Si1145

6

https://www.robofun.ro/senzori/lumina/si1145-digital-uv-index-ir-sensor

Senzorul de temperatură TMP102

7

https://www.robofun.ro/senzori/vreme/senzor_temperatura_tmp102

Schema de interconectare între senzori și placa de dezvoltare este tipică pentru o magistrală multi-slave I2C:

8

Atenție!!! Conectarea pinului ADD0 la masă (GND), pentru senzorul TMP102, este necesară doar pentru varianta mai veche (cu pini pe două părți), varianta mai nouă (cu toți cei șase pini pe o singură parte) trage acest pin la masă prin intermediul unui contact intern.

Pentru implementarea software vom utiliza două biblioteci externe mediului Arduino IDE:

Arduino MQTT – pentru implementarea protocolului MQTT

https://github.com/256dpi/arduino-mqtt

Adafruit SI1145 – pentru utilizarea senzorului SI1145

https://github.com/adafruit/Adafruit_SI1145_Library

#include <adafruit_feather.h>

AdafruitTCP net;

#include <MQTTClient.h>

MQTTClient client;

#include <Wire.h>

#define tmp102Address 0x48

#include “Adafruit_SI1145.h”

Adafruit_SI1145 uv = Adafruit_SI1145();

#define WLAN_SSID            “……………

#define WLAN_PASS            “……………

Trebuie configurate valorile WLAN_SSID și WLAN_PASS în concordanță cu rețeaua WiFi prin care dispozitivul se va conecta la Internet.

În cadrul secțiunii setup() se va inițializa conexiunea cu platfotma Watson. Procedura client.begin trebuie personalizată cu parametrul Organization ID iar procedura client.connect cu: Organization ID, Device Type, Device ID și Authentication Token.

O inițializare corectă a dispozitivului va afișa în consola serială ceva similar cu următoarea captură de ecran:

9

void setup() {

  Serial.begin(9600);

  while (!Serial) { delay(10); }

  if (! uv.begin()) {

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

    while (1);  }

  Feather.printVersions();

  while ( !connectAP() )  { delay(500);  }

  Feather.printNetwork();

  client.begin(“OrgID.messaging.internetofthings. \

ibmcloud.com”, 1883, net);

  Serial.print(“Connecting to BlueMix”);

   while (!client.connect(“d:OrgID:DeviceT:DeviceID“, \

“use-token-auth”,”AuthenticationToken“)) {

      Serial.print(“.”);

      delay(1000);

  }

  Serial.println();

  Serial.println(“Connected to BlueMix.”);

}

Secțiunea loop() va fi responsabilă cu citirea parametriilor (temperatură de la senzorul TMP102; intensitate lumină și index radiații ultraviolete de la senzorul Si1145) și cu postarea acestora către serviciul IBM Watson IoT. Publicarea datelor achiziționate se va face o dată pe minut.

void loop() {

  client.loop();

  float temperature = getTemperature();

  Serial.print(“Temperature: “);

  Serial.println(temperature);

  int light = uv.readVisible();

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

  float UVindex = uv.readUV();

  UVindex /= 100.0; 

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

  client.publish(“iot-2/evt/status/fmt/json”, \

  “{\”d\”:{\”myName\”: \”SunDetector\” \

  ,\”Temperature\”: \”” + String(temperature, 2) + “\” \

  ,\”Light\”: \”” + String(light,DEC) + “\” \

  ,\”UVIndex\”: \”” + String(UVindex, 2) + “\”}}”);

  delay(60000);

}

Procedura messageReceived() este necesară pentru a respecta caracterul bidirecțional al protocolului MQTT chiar dacă sistemul nostru nu va prelua date sau comenzi de la platforma IBM Watson IoT.

void messageReceived(String topic, String payload, \

char * bytes, unsigned int length) {

  Serial.print(“incoming: “);

  Serial.print(topic);

  Serial.print(” – “);

  Serial.print(payload);

  Serial.println(); }

Procedura connectAP() este folosită în secțiunea loop() pentru conectarea la rețeaua WiFi.

bool connectAP(void)

{Serial.print(“Please wait while connecting to: ‘” \

 WLAN_SSID “‘ … “);

  if ( Feather.connect(WLAN_SSID, WLAN_PASS) )

  { Serial.println(“Connected!”); }

  else  {

    Serial.printf(“Failed! %s (%d)”, Feather.errstr(),\

             Feather.errno());

    Serial.println();

  }

  Serial.println();

  return Feather.connected(); }

Având în vedere că pentru utilizarea senzorului TMP102 nu utilizăm nici o bibliotecă software, funcția getTemperature() este utilizată pentru a prelua valoarea temperaturii măsurate de senzor prin intermediul protocolului I2C.

float getTemperature()

{byte MSB = 0x00;

  byte LSB = 0x00;

  int TempCitita = 0;

  float TempCelsius = 0.0;

  Wire.beginTransmission(tmp102Address);

  Wire.write(0x00);

  Wire.endTransmission();

  Wire.requestFrom(tmp102Address,2);

  Wire.endTransmission();

  MSB = Wire.read();

  LSB = Wire.read();

  TempCitita = ((MSB << 8) | LSB) >> 4;

  TempCelsius = TempCitita * 0.0625;

  return TempCelsius; }

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.6.12, Adafruit WICED 0.6.2, MQTT 1.10.1 și Adafruit Si1145 1.0.0.

După punerea în funcțiune a sistemului în cadrul consolei de administrare IBM Watson IoT (dashboard) se va observa schimbarea stării dispozitivului înregistrat anterior.

10

Printr-o simplă inspecție a proprietăților dispozitivului se pot vedea datele trimise de acesta:

11

În partea a doua a proiectului vom utiliza informațiile furnizate de sistem pentru a genera grafice de evoluție și alerte. Tot pe baza informațiilor primite de platforma IBM Watson IoT se pot construi și aplicații specifice serviciului cloud IBM BlueMixTM, aplicații ce pot prelucra aceste informații în diverse scopuri (statistice, decizionale).

Platforma propusă de această lecție nu este singura variantă hardware de implementare, se pot vedea și alte soluții în următoarele proiecte:

Heart Rate Monitor using IBM Watson IoT Platform + Arduino MKR1000 + Pulse Sensor + NodeRED – developerWorks Recipes

https://developer.ibm.com/recipes/tutorials/heart-rate-monitor-using-ibm-watson-iot-platform-arduino-mkr1000-pulse-sensor-nodered/

Connect an ESP8266 with the Arduino SDK to the IBM Watson IoT Platform

https://espressif.com/en/media_overview/articles/connect-esp8266-arduino-sdk-ibm-watson-iot-platform

Arduino + Xbee + Bluemix = Connect Devices to the Cloud

http://www.paasmag.com/2015/05/13/arduino-xbee-bluemix-connect-devices-to-the-cloud/