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