RoboNews: Ce ar putea fi mai fun decât o platformă IoT Arduino?

Piața platformelor IoT este în continuă creștere. Probabil ai auzit de IoT pentru că anul trecut s-au dezvoltat peste 450 de platforme de acest gen, estimându-se ca în acest an numărul lor să depășească 1000. Internet of Things (IoT) System este o platfor mă care simplifică administrarea la scară largă a dispozitivelor și obiectelor conectate la rețea. De fapt, aceasta oferă o infrastructură care este proiectată să gestioneze sisteme de mari dimensiuni cu trafic intens generat de diverse dispozitive și platforme.

Platformele IoT sunt software-ul de suport care pun laolaltă totul într-un singur sistem. O platformă IoT facilitează comunicarea, fluxul de date, gestionarea dispozitivelor și funcționalitatea aplicațiilor. Datorită acestor lucruri, platformele IoT sunt de un real ajutor în sprijinul companiilor care vor să depășească provocările tehnice fără a avea nevoie de resurse suplimentare pentru a gestiona echipe de ingineri specializați în diverse domenii.

De exemplu, un business ar putea să fie foarte bun în tehnica de hardware, dar în locul procesului scump și de durată de a angaja dezvoltatori de software pentru a construi totul in house, platforma IoT este o soluție rapidă și mai eficientă din punct de vedere al costurilor.

Facem o trecere în revistă a celor mai noi domenii în care se folosesc cu succes platformele IoT Arduino și cum poate fi folosită o platformă IoT:

EyeScan AT3D Max – senzorul cu scanare 3D cu cea mai rapidă și cea mai înaltă definiție a laserului

Laserul este o tehnologie revoluționară cu o influență extraordinară în multe domenii. Îl găsim în imprimantele de la calculatoare, în CD sau DVD-playere, în spitale pentru operaţiile chirurgicale asistate de laser, în aparatele pentru măsurat distanţe, în tehnologiile pentru comunicaţiile pe fibră optică, în sudură, tăierea sau prelucrarea materialelor ce necesită înaltă precizie. EyeScan AT 3D Max este cel mai rapid și cel mai mare senzor de deplasare a rezoluției de pe piață. Senzorul de poziție poate măsura la viteză foarte mare distanța dintre un obiect și un punct de referință sau modificări în lungime. Senzorul The EyeScan AT 3D Max poate scana 3D chiar si cele mai mici componente ale unei piese ajungand la o rezoluție de măsurare de un micrometru.

Cum se întâmplă acest lucru? Senzorul își proiectează linia laser pe obiectul ce urmează să fie inspectat. Acest obiect se va deplasa prin dreptul senzorului pentru a inspecta toata suprafața acestuia, iar după ce obiectul este scanat în întregime se generează o imagine 3D. Rezoluția imaginii obținute cât și viteza de scanare face acest senzor ideal pentru măsurarea și inspectarea pieselor foarte mici, cum ar fi componentele electronice, chiar dacă acestea au zone întunecate sau strălucitoare.

Acest senzor EyeScan AT 3D Max se poate interconecta la o mare varietate de sisteme folosind interfețele UR Robot și Profinet Stack.

Unitatea utilizează propriul software EyeVision care realizează evaluări 3D utile pentru industria auto sau electronică, precum și evaluări pentru industria alimentară și a băuturilor. (Sursa)

Accesul la comunicațiile cloud simplifică dezvoltarea aplicațiilor IoT

Pasionat de Arduino? Atunci suntem siguri că ești în căutarea unei soluții care să-ți permită dezvoltarea și gestionarea aplicațiilor IoT într-o manieră cât mai accesibilă. Versiune publică beta a cloudului Arduino IoT, cu generarea automată a dashboard-ului, suport pentru webhooks unde se poate modifica comportamentul unei aplicații web dar și a protocolului securizat TLS (Transport Layer Security) reprezintă un avantaj major pentru utilizatorii de arduino. Arduino Cloud IoT permite, de asemenea, și alte metode de interacțiune, inclusiv API-ul HTTP REST, MQTT, tool-uri linie de comandă, JavaScript și WebSocket-uri.

Ușurința și flexibilitatea de a programa în Arduino au fost considerate concepte cheie pentru cloudul Arduino IoT fără a mai obliga utilizatorii să le programeze prin Arduino Sketch.

Pentru a sublinia modul în care Arduino IoT Cloud ar lucra în tandem cu familia MKR într-o soluție reală, Massicot Banzi – expert in tehnologia Arduino,  oferă un exemplu pentru domeniul agriculturii, în care opțiunile de alimentare optimă cu energie a componentelor și alternative de conectivitate sunt esențiale: “Să presupunem că dorim să construim o seră IoT, obiectivul fiind acela de a controla această seră de la distanță, adică să pornim și să oprim luminile, să pornim sistemul de irigații și să citim și să reglăm temperatura din seră, fără intervenția umană. Sistemul complet poate fi automatizat și controlat utilizând o placă Arduino MKR WIFI 1010 împreună cu cloudul Arduino IoT. Trebuie doar să atașați senzorii relevanți (de exemplu, senzorii de temperatură, lumină și umiditate), dispozitivele de acționare (de exemplu, pompa de irigare) și comutatoarele (luminile și ventilatoarele) pe placă. Încărcați software-ul (Arduino Sketch) și va fi gata în câteva minute pentru a controla automat proprietățile elementelor actionate (de exemplu, activați ventilatoarele de ventilație atunci când există prea multă umiditate în seră) printr-o interfață web simplă.” (Sursa)

Viața plantelor, monitorizată cu ajutorul unui dispozitiv Raspberry Pi

Pasionată de viața plantelor și de procesul de creștere al acestora, de la stadiul de germinarea până la stadiul de plantă adultă, Nicole He, artist și programator, a studiat timp de 2 ani un ficus din propria ei casă. Nicole a programat interfața Raspberry pentru a posta zilnic pe Twitter câte o fotografie cu propria ei plantă. Ea a folosit un aparat de fotografiat alimentat de o placă Raspberry Pi, pentru a se documenta cu privire la creșterea lentă a plantei Ficus Lyrata. De asemenea, a folosit un Logitech HD WebCam C310, pe care l-a conectat prin USB la o placă Raspberry Pi, un monitor extern, o tastatură și o conexiune Wi-Fi pentru a putea trimite zilnic poza pe Internet.

Astfel, timp de doi ani, acumulând zi de zi poze cu stadiul de creștere lentă a plantei, Nicole He a compilat toate pozele într-un mic filmuleț intitulat  “meditație asupra naturii și tehnologiei”. (Sursa)

Industria producătoare de semiconductori, îmbunătățiri majore datorită aplicațiilor care utilizează tehnologia cloud

APEC (Asia-Pacific Economic Cooperation) anunță dezvoltarea platformei Strata Developer Studio care oferă o modalitate utilizată de ingineri de a lucra plăcile de evaluare și dezvoltare, oferind cea mai recentă documentație, informații despre produse, note de proiectare precum și fișiere de referință direct pe calculator. Toate plăcile noi de evaluare a semiconductorilor vor fi în viitor “Strata-Ready”, ceea ce înseamnă că vor fi automat recunoscute de platforma Strata Developer Studio când sunt conectate la computer. Această platformă oferă echipei de proiectare o interfață intuitivă pentru un control direct al parametrilor de configurare și feedback-ul vizual al funcționalității placii de evaluare. În același timp, Strata va descărca toate informațiile de proiectare necesare unui inginer pentru a începe evaluarea sau proiectarea. Strata Developer Studio este furnizat ca o aplicație recunoscuta de Microsoft care se conectează la platforma SaaS a companiei. Dispune de autentificare securizată, de transfer de date și de izolare completă a informațiilor, utilizând baze de date criptate ce respectă Regulamentul UE privind protecția generală a datelor (GDPR). Toate informațiile și securitatea respectă regulamentul Institutului Național de Standardizare și Tehnologie (NIST). (Sursa)

Soluțiile IoT devin inevitabil mai complexe și mai dinamice cu trecerea timpului. Acestea implică ecosisteme mai mari de dispozitive și se dezvoltă mult mai repede decât software-ul tradițional de aplicații pentru întreprinderi. Odată cu dezvoltarea tuturor tipurilor de interacțiuni de la distanță între dispozitive și oameni, soluțiile IoT reprezintă o nouă paradigmă pentru experiența digitală orientată spre client. Complexitatea lor poate părea intimidantă la început, dar, de fapt, avantajele platformelor IoT sunt fezabile, fără a reinventa roata. În acest scop, o platformă IoT este noua roată.

Arduino Zombification

În ciuda simplității modului de programare oferit de mediul Arduino IDE și de familia de plăci Arduino există implementată o soluție ce permite utilizarea plăcilor de dezvoltare Arduino ca simple periferice USB fără a fi nevoie a înțelege modul de funcționare și programare a acestora. Prin încărcarea unui program gata scris placa Arduino se transformă într-un echipament „zombie” ce execută instrucțiunile primite prin conexiunea USB conform unui protocol standard.

Protocolul de zombificare a unei plăci Arduino se numește Firmata și este integrat ca suport software (bibliotecă + exemple) în Arduino IDE. Pentru instalare și utilizare puteți consulta materialul „Arduino: Installing Standard Firmata”. După încărcarea exemplului StandardFirmata.ino pe orice placă de dezvoltare Arduino, aceasta se va comporta ca un periferic USB pe care îl putem accesa de pe un sistem de calcul (PC sau chiar Raspberry Pi). Accesul intermediat de protocolul Firmata face disponibile toate perifericele hardware ale plăcii de dezvoltare (pini I/O, convertor analog/numeric, magistrale I2C, SPI, pini de comandă PWM) programelor ce rulează pe sistemul de calcul la care este conectată placa. Biblioteca Firmata oferă exemple pentru majoritatea limbajelor de programare: .NET, Java, Perl, Python, PHP, Processing, Flash etc. Firmata reprezintă o soluție extrem de simplă pentru extinderea funcționalităților unei plăci Raspberry Pi prin conectarea la o placă Arduino (a se vedea și proiectul „Access GPIO of Arduino from Raspberry Pi”).

2

Versiunile recente ale bibliotecii Firmata extind posibilitatea de zombificare și a altor plăci precum ChipKIT (exemplul din bibliotecă: StandardFirmataChipKIT.ino) dar și utilizând alte modalități de interconectare între placa de dezvoltare și sistemul de calcul:

  • Utilizând exemplul ino putem utiliza de la distanță o placă Arduino prin intermediul unei conexiuni bluetooth. Exemplul funcționează pe plăci ce integrează modul de comunicație BLE (de exemplu Arduino 101) sau pe orice placă Arduino cu un modul BLE atașat (de exemplu Adafruit Bluefruit nRF8001).
  • Exemplul ino permite, bineînțeles, controlul de la distanță prin intermediul unei conexiuni WiFi. Este posibilă utilizarea mai multor tipuri de plăci precum Arduino MKR1000 sau plăci de dezvoltare bazate pe circuitul ESP8266 (de exemplu Adafruit Feather HUZZAH). Această variantă de zombificare este utilizată de multe limbaje de control la distanță precum Gobot [13] sau Johny-Five.

3

O altă formă de zombificare prin intermediul unei conexiuni WiFi este oferită de placa de dezvoltare Arduino Yun. Există două variante de control la distanță a perifericelor integrate în microcontrolerul ATmega32U4 aflat pe placa de dezvoltare:

  • Prin intermediul serviciilor web de tip API REST adică prin intermediul unor URL-uri ce pot accesa diverse resurse hardware ale microcontrolerului. Acestea pot fi configurate astfel încât accesul să fie protejat de o parolă. Accesând IP-ul plăcii și calea /arduino putem configura, de exemplu, pinii I/O (pe Arduino Yun vom avea încărcat exemplul ino al bibliotecii Bridge):

4

http://myArduinoYun.local/arduino/digital/13 : calls digitalRead(13);

http://myArduinoYun.local/arduino/digital/13/1 : calls digitalWrite(13,1);

http://myArduinoYun.local/arduino/analog/9/123 : analogWrite(9,123);

http://myArduinoYun.local/arduino/analog/2 : analogRead(2);

http://myArduinoYun.local/arduino/mode/13/input : pinMode(13, INPUT);

http://myArduinoYun.local/arduino/mode/13/output : pinMode(13, OUTPUT);

  • Ultimele versiuni de plăci Arduino Yun ce rulează LininoOS permit programarea automată a microcontrolerului ATmega32U4 si utilizarea acestuia ca un periferic sub sistemul de operare. Programarea se face cu ajutorul comenzii:

/usr/bin/lininoio start

5

Utilizarea perifericelor se poate face direct din script bash:

echo 1 > /sys/class/gpio/TXLD/value

sau din alte limbaje de programare, de exemplu Node.JS:

var board = new require(‘ideino-linino-lib’).Board();

var led = 1;

board.connect( function(){

    board.pinMode(“D13”, “OUTPUT”);

    setInterval(function(){

        board.digitalWrite(“D13”, led);

        led = 1 – led;

    },500);

});

O soluție de zombificare pentru plăcile de dezvoltare echipate cu circuitul ESP8266 este ESPEasy. Prin încărcare acestui software pe o placă bazată pe ESP8266 vom putea configura foarte simplu atât partea de conectivitate WiFi (credențialele de acces la Internet) cât și perifericele conectate precum și rolul îndeplinit de sistem (configurare conexiune servicii IoT sau Home Automation) – totul prin intermediul unei interfețe web foarte simple.

6

7

Utilizarea bibliotecii V-USB

V-USB este o componentă software ce implementează comunicația USB (low-speed USB / USB 1.1) pentru orice microcontroler din familia Atmel AVR – cu alte cuvinte permite comunicația USB pentru microcontrolerele din această familie chiar dacă nu au un port USB hardware (similar cu biblioteca SoftwareSerial ce permite utilizarea oricăror doi pini ai plăcii Arduino pentru comunicația UART). Prin intermediul acestei biblioteci putem utiliza orice microcontroler Atmel AVR pentru o conexiune directă USB fără a fi nevoie de un circuit suplimentar de conversie UART – USB (FTDI sau microcontroler cu port hardware USB – 8U2 sau 16U2). Singurele restricții sunt ca circuitul microcontroler să aibă cel puțin 2kB memorie flash, 128 bytes memorie RAM și să funcționeze la cel puțin 12MHz – condiții îndeplinite fără probleme de microcontrolerul ATmega328P ce echipează placa de dezvoltare Arduino Uno. O aplicație imediată a acestei biblioteci o reprezintă plăcile de dezvoltare compatibile Arduino ce nu dețin circuite suplimentare față de microcontroler (nu au circuit de conversie UART – USB și implicit au un cost mai mic), de exemplu placa de dezvoltare Adafruit Pro Trinket. Placa Adafruit Pro Trinket este echipată cu un microcontroler ATmega328P, la fel ca și placa Arduino Uno, are dimensiuni și cost apropiate de o placă de dezvoltare Arduino Pro Mini dar nu necesită programator extern FTDI pentru încărcarea programelor. La fel ca și celelalte plăci de dezvoltare Arduino, placa Pro Trinket funcționează pe baza unui bootloader rezident în memoria flash a microcontrolerului ce permite transferarea programului de pe USB în memoria program internă. Bootloader-ul plăcii Pro Trinket se bazează pe biblioteca V-USB și funcționează în mod similar cu bootloader-ele altor plăci Arduino. Singurul dezavantaj al unei astfel de soluții este procedura mai greoaie de upload (de încărcare a programului). Circuitele suplimentare prezente pe plăcile Arduino se ocupau cu transferul programului USB – memorie internă program lansând în execuție bootloader-ul intern printr-o operație de reset a microcontrolerului. Din cauza absenței circuitului care să declanșeze operația de reset această operație trebuie efectuată manual – înainte de operația de upload (încărcare a programului) trebuie apăsat butonul de reset și operația de încărcare trebuie efectuată într-un interval de 10 secunde (atâta timp cât placa se află în Bootloader Mode).

V-USB for Arduino

Aplicabilitatea bibliotecii V-USB nu se rezumă doar la dezvoltarea de bootloadere ce permit încărcarea programului în memoria internă a microcontrolerului. Prin intermediul bibliotecii V-USB putem dezvolta periferice USB bazate pe microcontrolere Atmel AVR de tip HID (Human Interface Device – tastatură, mouse), CDC (Communications Device Class – modemuri, mass storage) sau chiar MIDI (Musical Instrument Digital Interface) fără a fi limitați la clasa de dispozitive USB de tip USB-to-serial (USB Serial Converter) oferite de driverul obișnuit al plăcilor de dezvoltare Arduino. Site-ul V-USB oferă o colecție semnificativă de exemple de proiecte diverse de astfel de dispozitive.

Chiar dacă biblioteca V-USB este scrisă în limbajul C nu poate fi folosită direct în mediul Arduino IDE fiind dezvoltată sub mediul WinAVR. Din fericire există o portare parțială a bibliotecii V-USB sub forma unei biblioteci specifice Arduino IDE și anume V-USB for Arduino. Prin intermediul acestei biblioteci o placă Arduino Uno se poate transforma într-un dispozitiv USB personalizat. Biblioteca este format din trei componente independente: UsbDevice (permite implementarea unui dispozitiv USB generic), UsbKeyboard (permite implementarea unui dispozitiv USB HID de tip tastatură), UsbStream (permite implementarea unui dispozitiv de comunicație / transfer de date).

Biblioteca V-USB for Arduino poate fi utilizată fără nici un fel de problemă sub versiunile Arduino IDE 1.0.x dar necesită o mică corecție sub versiunile mai recente (1.5.x, 1.6.x): declarațiile realizare în memoria program (PROGMEM) trebuie să fie de tip constantă (const) – în toate fișierele .c și .h declarațiile de tip PROGMEM trebuie modificate în PROGMEM const.

Realizarea unui dispozitiv de tip „Carte de vizită”

În cadrul acestei secțiuni vom realiza un periferic de tip HID (mai exact tastatură) ce va completa în mod automat datele de contact ale deținătorului (proiect inspirat de (*)). Sistemul va fi format dintr-o placă de dezvoltare Arduino Uno, un buton (plus o rezistență de 10Kohm) și partea de interfațare electrică cu conexiunea USB (2 diode Zener 3.6V maxim 0.5W, 2 rezistențe 68ohm și 1 rezistență 1.5Kohm). La apăsarea butonului sistemul va trimite pe USB textul de semnătură (carte de vizită) ca și cum ar fi tastat.

Butonul este conectat la pinul digital 10, acesta este ținut la Vcc (+5V) prin intermediul unei rezistențe de 10Kohm. Apăsarea butonului trage pinul digital în ”0” logic (0V). Conexiunea electrică USB presupune ca liniile D+, D- să aibă o rezistență de 68ohm în serie și câte o diodă Zener de 3.6V la masă (pentru adaptarea nivelului logic de 5V la 3.6V). Linia D+ necesită și o rezistență de pull-up de 1.5Kohm comandată de pinul digital 5. Linia D- se conectează la pinul digital 4 și linia D+ la pinul digital 2. Liniile conexiunii USB Vcc și GND se interconectează la pinii 5V și GND ai plăcii Arduino asigurând alimentarea sistemului în modul de funcționare periferic USB de tip HID.  Schema de interconectare este următoarea:

2

Programul ce va rula pe placa de dezvoltare va fi încărcat utilizând Arduino IDE și conexiunea USB a plăcii.

#include “UsbKeyboard.h”

#include <util/delay.h>

#define BUTTON_PIN 10

String mesaj;

void setup() {

  pinMode(BUTTON_PIN, INPUT);

  TIMSK0&=!(1<<TOIE0);

}

void loop() {

  UsbKeyboard.update();

  if (digitalRead(BUTTON_PIN) == 0) {

    mesaj = “ING. POPESCU ION”;

    KeyStrokeAlpNum(mesaj);

    mesaj = “DIRECTOR TEHNIC EMBEDDED DEVICES SRL”;

    KeyStrokeAlpNum(mesaj);

    mesaj = “MOBIL 0789.000.233”;

    KeyStrokeAlpNum(mesaj);

    mesaj = “FIX 021.456.30.03”;

    KeyStrokeAlpNum(mesaj);

    UsbKeyboard.sendKeyStroke(KEY_ENTER);

    _delay_ms(200);   }

}

După încărcarea programului conexiunea USB cu placa de dezvoltare se va deconecta și se va utiliza conexiunea USB prin intermediul mufei de pe breadboard.

În cadrul programului este necesară includerea bibliotecii UsbKeyboard.h. În secțiunea setup se va configura pinul digital 10 ca intrare (pin utilizat pentru buton) și se va dezactiva timerul 0 (utilizat de mediul Arduino IDE pentru funcțiile de temporizare) pentru a nu interfera cu temporizarea utilizată în biblioteca V-USB. Secțiunea loop va conține un apel periodic al procedurii UsbKeyboard.update() – apel necesar pentru a efectua operații obligatorii în cadrul comunicației USB, operații invocate de procedura usbpool() a bibliotecii V-USB; trimiterea de caractere prin intermediul conexiunii USB este condiționată de apăsarea butonului (digitalRead(BUTTON_PIN) == 0) – trimiterea efectivă a codului unei taste se realizează prin intermediul funcțiilor UsbKeyboard.sendKeyStroke(cod_tasta) pentru o singură tastă și KeyStrokeAlpNum(mesaj) pentru un șir de taste.

void KeyStrokeAlpNum(String Sc){

    int sPoint = Sc.length();         

    for (int x = 0; x < sPoint; x++){

      int y = x + 1;

      if (Sc.substring(x, y) == “H”){ 

          UsbKeyboard.sendKeyStroke(KEY_H, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “L”){

          UsbKeyboard.sendKeyStroke(KEY_L, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == ” “){

          UsbKeyboard.sendKeyStroke(KEY_SPACE);

          }

       else if (Sc.substring(x, y) == “1”){

          UsbKeyboard.sendKeyStroke(KEY_1);

          }

       else if (Sc.substring(x, y) == “2”){

          UsbKeyboard.sendKeyStroke(KEY_2);

          }

       else if (Sc.substring(x, y) == “3”){

          UsbKeyboard.sendKeyStroke(KEY_3);

          }

       else if (Sc.substring(x, y) == “4”){

          UsbKeyboard.sendKeyStroke(KEY_4);

          }

       else if (Sc.substring(x, y) == “5”){

          UsbKeyboard.sendKeyStroke(KEY_5);

          }

       else if (Sc.substring(x, y) == “6”){

          UsbKeyboard.sendKeyStroke(KEY_6);

          }

       else if (Sc.substring(x, y) == “7”){

          UsbKeyboard.sendKeyStroke(KEY_7);

          }

       else if (Sc.substring(x, y) == “8”){

          UsbKeyboard.sendKeyStroke(KEY_8);

          }

       else if (Sc.substring(x, y) == “9”){

          UsbKeyboard.sendKeyStroke(KEY_9);

          }

       else if (Sc.substring(x, y) == “0”){

          UsbKeyboard.sendKeyStroke(KEY_0);

          }

       else if (Sc.substring(x, y) == “.”){

          UsbKeyboard.sendKeyStroke(55);

          }

       else if (Sc.substring(x, y) == “-“){

          UsbKeyboard.sendKeyStroke(45);

          }

       else if (Sc.substring(x, y) == “A”){

          UsbKeyboard.sendKeyStroke(KEY_A, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “B”){

          UsbKeyboard.sendKeyStroke(KEY_B, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “C”){

          UsbKeyboard.sendKeyStroke(KEY_C, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “D”){

          UsbKeyboard.sendKeyStroke(KEY_D, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “E”){

          UsbKeyboard.sendKeyStroke(KEY_E, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “F”){

          UsbKeyboard.sendKeyStroke(KEY_F, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “G”){

          UsbKeyboard.sendKeyStroke(KEY_G, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “I”){

          UsbKeyboard.sendKeyStroke(KEY_I, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “J”){

          UsbKeyboard.sendKeyStroke(KEY_J, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “K”){

          UsbKeyboard.sendKeyStroke(KEY_K, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “M”){

          UsbKeyboard.sendKeyStroke(KEY_M, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “N”){

          UsbKeyboard.sendKeyStroke(KEY_N, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “O”){

          UsbKeyboard.sendKeyStroke(KEY_O, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “P”){

          UsbKeyboard.sendKeyStroke(KEY_P, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “Q”){

          UsbKeyboard.sendKeyStroke(KEY_Q, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “R”){

          UsbKeyboard.sendKeyStroke(KEY_R, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “S”){

          UsbKeyboard.sendKeyStroke(KEY_S, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “T”){

          UsbKeyboard.sendKeyStroke(KEY_T, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “U”){

          UsbKeyboard.sendKeyStroke(KEY_U, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “V”){

          UsbKeyboard.sendKeyStroke(KEY_V, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “W”){

          UsbKeyboard.sendKeyStroke(KEY_W, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “X”){

          UsbKeyboard.sendKeyStroke(KEY_X, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “Y”){

          UsbKeyboard.sendKeyStroke(KEY_Y, MOD_SHIFT_LEFT);

          }

       else if (Sc.substring(x, y) == “Z”){

          UsbKeyboard.sendKeyStroke(KEY_Z, MOD_SHIFT_LEFT);

          }

      }

      UsbKeyboard.sendKeyStroke(KEY_ENTER);

}

Realizarea unui dispozitiv de tip mouse

De această dată vom realiza un sistem bazat pe placa de dezvoltare Arduino Pro Mini 5V  (pentru a reduce costurile și dimensiunea sistemului) plecând de la exemplul hid-mouse pus la dispoziție de biblioteca V-USB. Compilarea exemplului necesită instalarea mediului de dezvoltare WinAVR iar încărcarea lui pe placa de dezvoltare necesită un programator ISP (de exemplu Arduino ISP sau Pocket AVR). Schema de interconectare a componentelor (placă de dezvoltare și componente de interfațare USB – similare cu proiectul precedent) este:

3

Pentru încărcarea programului se urmează următorii pași:

  • Se instalează mediul de dezvoltare WinAVR.
  • Se actualizează utilitarul avrdude (avrdude.exe și avrdude.conf) din directorul de instalare al mediului WinAVR (uzual C:\WinAVR-20100110\bin) pentru a putea lucra cu microcontrolerul ATmega328P.
  • Se conectează programatorul ISP pe pinii RST, MOSI (pinul 11), MISO (pinul 12), SCK (pinul 13), GND, 5V ai plăcii de dezvoltare Arduino Pro Mini.
  • Se deschide o fereastră de comandă de tip consolă (click-dreapta cu tasta shift apăsată) pentru directorul hid-mouse (vusb-20121206\examples).
  • În fereastra de comandă se tastează make hex pentru a compila exemplul și a obține fișierul binar hex ce urmează a fi încărcat în memoria microcontrolerului.
  • În fereastra de comandă se tastează comanda

avrdude -c usbtiny -p m328p -U hfuse:0xDE:m -U lfuze:w:0xFF:m

pentru a inițializa biții de fuse ai microcontrolerului; se consideră utilizarea

unui programator USBtinyISP (precum Pocket AVR).

  • În fereastra de comandă se tastează comanda

avrdude -c usbtiny -p m328p –U flash:w:main.hex:i

pentru a încărca programul în memoria internă a microcontrolerului.

  • Se deconectează programatorul ISP și se conectează sistemul prin intermediul conexiunii USB.

Sistemul odată conectat se va comporta ca un dispozitiv de tip mouse (descriptor dispozitiv în imaginea următoare) – cursorul de mouse se va mișca pe ecran pe o traiectorie de tip cerc. Proiectul poate constitui un bun punct de plecare pentru dezvoltarea unor dispozitive de tip mouse – de exemplu se poate încerca dezvoltarea unui sistem care să miște cursorul de mouse cu ajutorul a patru butoane (sus, jos, dreapta, stânga).

4

Ce putem face cu un telefon vechi Android?

Chiar dacă îndrăgim telefonul inteligent pe care îl avem în prezent și chiar dacă el nu are nici o problemă de funcționare, totuși, la un moment dat, el va trebui schimbat cu unul nou – apar aplicații ce au nevoie de mai multe resurse de calcul, suntem sclavii modei în permanență schimbare, apar noi standarde de comunicație GSM (3G/4G) – nu contează motivul înlocuirii telefonului dar înlocuirea în sine la o perioadă din ce în ce mai scurtă de timp este o certitudine. În urma acestui proces de îmbunătățire continuă a dispozitivelor de comunicație mobilă rămân disponibile telefoane mobile pe care le uităm printr-un colț al dulapului sau pe care le ducem direct la centrul de reciclare. În ambele cazuri valoarea recuperată este zero. Există mai multe modalități prin care putem pune în valoare mult mai bine aceste dispozitive modificându-le scopul principal de funcționare – nu trebuie să uităm că un telefon mobil inteligent este un sistem de calcul puternic cu mult mai multe resurse hardware decât majoritatea plăcilor de dezvoltare cu care lucrăm (Arduino sau Raspberry Pi). Proiectul de față face referire la telefoanele mobile inteligente ce rulează sistemul de operare Android și dă ca exemplu trei situații în care putem pune în valoare componentele hardware ale telefonului mobil în alte scopuri decât cel pentru care a fost proiectat în ciuda arhitecturii Android total neprietenoase cu modificările la nivel funcțional.

Utilizarea unui telefon mobil Android ca și cameră de supraveghere IP (WiFi sau GSM)

Telefoanele mobile inteligente, chiar și de generație mai veche, dețin camere video performante ce pot servi foarte bine ca și camere de supraveghere. Conectivitatea de rețea (WiFi sau GSM) oferită de arhitectura unui telefon mobil inteligent contribuie excelent la scopul propus în acest prim exemplu. În acest mod transformăm un obiect inutil, un telefon mobil disponibilizat, într-un dispozitiv util și, echivalent, foarte scump. Pentru a face acest lucru este necesar să instalăm un software specializat. Există mai multe astfel de programe de acest gen dar vă recomandăm IP Webcam:

2

https://play.google.com/store/apps/details?id=com.pas.webcam

Aplicația IP Webcam permite transmiterea în rețea a imaginilor preluate de la camera video a  telefonului (oricare dintre camerele telefonului). Accesarea transmisiei on-line se poate face de pe orice client cu un browser web, inclusiv un alt telefon mobil, accesând IP-ul telefonului mobil pe portul 8080. Printre alte facilități ale aplicației putem enumera: înregistrarea video, preluarea unui singur cadru (fotografie), pornirea blitz-ului, filmarea pe timp de noapte, controlul focusului și a zoom-ului și chiar și afișarea valorilor citite de la senzorii telefonului mobil (accelerometru, senzorul de lumina, senzorul de proximitate, senzorul de temperatura și nivel de încărcare a bateriei). Aplicația poate fi configurată să pornească automat la inițializarea telefonului mobil astfel încât funcționalitatea de cameră de supraveghere să nu fie afectată de repornirea accidentală a dispozitivului. Toate aceste funcționalități pot fi accesate prin intermediul conexiunii WiFi dar și printr-o conexiune de date mobilă GSM pentru supravegherea unor spații izolate. Accesul la cameră se poate proteja prin parolă.

3

În cazul în care dorim să accesăm dispozitivul dintr-o altă rețea decât cea din care face parte (supraveghere la distanță prin Internet) se poate înregistra un cont gratuit pe serviciul cloud Ivideon ce permite accesul de oriunde la camerele înregistrate în serviciul cloud. Mai mult decât atât serviciul cloud permite și stocarea înregistrărilor video, detecția mișcării și notificări diverse. Pentru o conexiune WiFi nu este nevoie ca telefonul mobil să aibă cartelă SIM GSM.

4

Cloud Video Surveillance | Ivideon

https://www.ivideon.com/

O alternativă la instalarea unui software specializat de transmisie video este instalarea pe telefonul mobil a unui software de control la distanță ce permite accesul la toate funcționalitățile mobilului inclusiv accesul la camerele video ale acestuia. Accesul la toate funcționalitățile telefonului mobil poate deschide noi oportunități funcționale cum ar fi, de exemplu, transformarea telefonului mobil în dispozitiv de urmărire GPS. Un software foarte cunoscut este TeamViewer.

5

https://www.teamviewer.com/

Pe telefonul ce urmează a fi controlat la distanță se instalează versiunea Host a aplicației TeamViewer:

TeamViewer Host

https://play.google.com/store/apps/details?id=com.teamviewer.host.market

Controlul la distanță se poate realiza dintr-o interfață web sau instalând versiunea Viewer a aplicației (disponibilă pe Windows dar și pe telefonul mobil). Controlul la distanță a dispozitivului Android necesită înregistrare dar utilizarea este gratuită pentru scop personal. Aplicația Host pornește în mod automat o dată cu sistemul de operare Android și permite atât controlul complet al interfeței utilizator dar și supravegherea la distanță a parametriilor de funcționare.

6

Utilizarea unui telefon mobil Android ca și modem GSM / placă de rețea WiFi

Este foarte bine cunoscută posibilitatea telefoanelor mobile de a se transforma în hot-spoturi WiFi mobile pentru a partaja conexiunea la Internet cu alte dispozitive (laptop-uri sau alte telefoane mobile) – facilitatea de tethering:

https://en.wikipedia.org/wiki/Tethering

Aceiași facilitate poate fi utilizată pentru diverse plăci de dezvoltare (Raspberry Pi sau Arduino Yun) pentru a oferi acestora conectivitate Internet prin intermediul rețelei GSM sau prin intermediul unei rețele WiFi (este cazul plăcilor Raspberry Pi mai vechi ce nu au interfață WiFi integrată). În acest fel se utilizează un dispozitiv disponibil (un telefon mobil vechi) în locul unor shield-uri sau dispozitive scumpe (shield GSM, modem GSM). Este de preferat ca tethering-ul să se facă prin intermediul conexiunii USB deoarece asigură o viteză mare de transfer, nu ocupă intefața WiFi sau bluetooth a plăcii de dezvoltare și asigură și alimentarea telefonului mobil.

7

Configurarea plăcii de dezvoltare este identică pentru o conexiune de rețea GSM sau una WiFi. Pentru o placă Raspberry Pi, după conectarea fizică la portul USB al plăcii de dezvoltare a telefonului mobil se poate verifica recunoașterea hardware a acestuia prin instrucțiunea dmesg (în exemplificare s-a utilizat un telefon mobil Orange Zilo, Android 4.2.2, produs în 2014 și o placă de dezvoltare Raspberry Pi rulând Raspbian GNU/Linux 8 (jessie), kernel 4.4.43-v7+)  :

8

Instalarea lui ca dispozitiv USB cu ajutorul comenzii lsusb:

9

Și configurația de rețea asociată cu ajutorul comenzii ifconfig:

10

Configurarea dispozitivului se realizează automat în cazul configurației dată ca exemplu. Pentru detalii legate de configurația manuală se pot consulta proiectele următoare:

How to use an Android tablet as a Raspberry Pi console terminal and internet router

http://elinux.org/How_to_use_an_Android_tablet_as_a_Raspberry_Pi_console_terminal_and_internet_router

Raspberry Pi USB Tethering (using an Android phone)

https://www.youtube.com/watch?v=x_yhJ_QBfaU

Android USB Tethering to Connect a Raspberry Pi to the Internet

http://mobilesociety.typepad.com/mobile_life/2015/03/android-usb-tethering-to-connect-a-raspberry-pi-to-the-internet.html

Sau pentru utilizarea unei plăci Arduino Yun:

Configure Arduino Yun for Android Tethering

https://www.youtube.com/watch?v=wqvwG2xD-_g

Connect Arduino Yun to 3g 4g Mobile Networks

http://selfbuilt.net/wiki/doku.php?id=arduino_yun_mobile_networks

Use 3g/UMTS USB Dongle for WAN connection

https://wiki.openwrt.org/doc/recipes/3gdongle

Utilizarea unui telefon mobil Android ca și ecran tactil pentru o placă Arduino

Cu toții ne-am lovit de problema realizării unei interfețe utilizator compacte și multifuncționale pentru sistemele dezvoltate cu ajutorul plăcilor Arduino – ecrane alfanumerice sărăcăcioase, butoane ce trebuie integrate solid în carcasa sistemului sau ecrane tactile color scumpe și care consumă imediat memoria internă a plăcii de dezvoltare. Acesta este motivul pentru ce de a treia propunere de utilizare a unui telefon mobil Android vechi. Putem reutiliza telefonul mobil și îl putem transforma într-un ecran tactil color pentru un sistem Arduino fără a cheltui suplimentar și fără a epuiza memoria internă a plăcii de dezvoltare. Mai mult decât atât, dacă se combină interfațarea cu accesul la distanță – prezentat în prima parte a proiectului – vom obține un sistem cu o interfață grafică color dar și controlabil de oriunde din Internet. Conexiunea între telefonul mobil și placa de dezvoltare se realizează prin USB și există două posibilități:

Utilizând modul accesoriu bazat pe extensia Android ADK – este necesară utilizarea unei plăci Arduino Mega ADK:

11

https://www.robofun.ro/arduino/arduino_mega_adk

sau a unui shield USB Host împreună cu o placă Arduino Uno sau Arduino Mega:

12

https://www.robofun.ro/shields/usb_host_shield

A se vedea și:

Arduino ADK – Running Examples in Accessory Mode

http://labs.arduino.cc/ADK/AccessoryMode

Pentru implementare este necesară dezvoltarea aplicației Arduino dar și realizarea unei aplicații Android care să definească interfața utilizator. Există mai multe proiecte ce pot fi utilizate ca punct de plecare în implementarea acestei variante:

Arduino ADK LED Lighting

http://www.instructables.com/id/Arduino-ADK-LED-Lighting/

mover-bot – Android-based Mobile Robotics Platform

https://code.google.com/archive/p/mover-bot/

AndroidADKLED

https://sites.google.com/site/arduinosite/exercise/androidadkled/

Handbag™ for Android

http://handbagdevices.com/

Din păcate această variantă necesită un telefon mobil Android ce include în distribuția sistemului de operare extensia ADK, a se vedea și:

Android ADK supported devices

http://stackoverflow.com/questions/10186760/android-adk-supported-devices

Utilizând modul bridge (ADB: Android Development Bridge Mode) ce permite conectarea directă între telefonul mobil și o placă de dezvoltare prin intermediul unei conexiuni USB (utilizând un USB Host shield sau nu). A se vedea și:

Mega ADK – Running Examples over the ADB

http://labs.arduino.cc/ADK/ADB

Această variantă necesită ca telefonul mobil să suporte o conexiune USB OTG de tip Host și este nevoie de un adaptor de conectare USB OTG între telefonul mobil și cablul USB clasic al plăcii de dezvoltare. Dificultatea acestei variante vine din implementarea programului Android și din necesitatea ca dispozitivul Android să suporte USB OTG Host. Câteva exemple de proiecte bazate pe modul bridge:

USB_BRIDGE_ANDROID_OTG App Inventor 2

https://github.com/S2I71/usb_otg_bridge_app_inventor/

ProcessingAdb

https://github.com/agoransson/processingadb

Control an Arduino from Android device

http://solderer.tv/control-an-arduino-from-your-android-device/

Android + Arduino + USB Host + Simple Digital Output

http://mitchtech.net/android-arduino-usb-host-simple-digital-output/

În cazul în care cele două variante de implementare prezentate mai sus vi se par prea complicate există și posibilitatea de conectare a plăcii Arduino la telefonul Android prin intermediul unei conexiuni Bluetooth. Câteva exemple:

How to control arduino board using an android phone and a bluetooth module

http://www.instructables.com/id/How-control-arduino-board-using-an-android-phone-a/

Connect Arduino Uno to Android via Bluetooth

http://www.instructables.com/id/Connect-Arduino-Uno-to-Android-via-Bluetooth/

Control an Arduino with Bluetooth

http://www.allaboutcircuits.com/projects/control-an-arduino-using-your-phone/

Arduino Bluetooth Interfacing – Simplest tutorial on Bluetooth Basics

https://diyhacking.com/arduino-bluetooth-basics/

Proiect Închisoarea lui Bachus

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

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

Î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.