Utilizarea bibliotecii LUFA

LUFA (Lightweight USB Framework for AVRs) este o bibliotecă ce implementează stiva USB pentru microcontrolerele Atmel AVR ce dețin un port hardware USB (AVR USB Controller) permițând implementarea de dispozitive USB variate: Android Accessory Host, Audio In Device, MIDI Device, Generic HID Device, Joystick Device, Keyboard Device, Printer Host, Virtual Serial Device etc. Biblioteca LUFA este componenta software care stă la baza funcționării majorității plăcilor Arduino: în cazul Arduino Uno / Arduino Mega biblioteca este utilizată de firmware-ul ce permite microcontrolerelor ATmega8U2/16U2 să realizeze comunicația USB-to-serial și să încarce programul în memoria microcontrolerului central; în cazul Arduino Leonardo / Arduino Micro, plăci echipate cu un microcontroler ATmega32U4, biblioteca este utilizată direct de bootloader-ul plăcii permițând atât comunicația USB-to-serial cât și încărcarea programului.

Plăcile de dezvoltare Arduino nu sunt singurele aplicații embedded ce utilizează biblioteca LUFA, mai jos sunt trecute în revistă câteva dintre multele proiecte bazate pe această bibliotecă:

The Smart Card Detective este un sistem ce permite interceptarea, înregistrarea și modificarea comunicației dintre un smartcard și un cititor de carduri (inclusiv de tip EMV).

1

RFM12B USB light – Stick un dispozitiv de comunicație pentru PC-uri bazat pe microcontrolerul ATmega32U4 și modulul radio FSK RFM12B.

The Finch este un robot educațional gândit pentru a fi folosit în explicarea timpurie a noțiunilor de programare, robotică, sisteme de automatizare.

AD9833-based USB Function Generator este un sistem programabil ce permite generarea unor semnale analogice.

FlySight este un sistem ce permite înregistrarea pe un card de memorie a coordonatelor GPS corelate cu viteza și accelerația pe 3 axe.

2

În cadrul materialului de față vă propunem detalierea a două sisteme bazate pe biblioteca LUFA: (1) transformarea unei plăci Arduino Uno într-un dispozitiv MIDI prin reprogramarea microcontrolerului 16U2 și (2) un cititor de carduri bazat pe microcontrolerul ATmega32U4.

Realizarea unui dispozitiv de tip MIDI

Dispozitivele MIDI sunt dispozitive digitale capabile să genereze sunete sau să transmită comenzi de generare a acelor sunete către alte dispozitive digitale (putem vorbi de un sintetizator sau de o claviatură conectată la un sistem de calcul ce rulează un software de sinteză a notelor). În cadrul proiectului nostru vom transforma o placă de dezvoltare Arduino Uno într-un dispozitiv ce se va conecta la PC prin intermediul unei conexiuni USB și va transmite comenzi specifice MIDI către un software specializat. Pentru a putea modifica comportamentul USB al plăcii (tipul de periferic USB văzut de sistemul de operare) este necesar să modificăm firmware-ul microcrontrolerului 16U2 (prezent pe Uno R3, versiunile anterioare se bazează pe microcontrolerul 8U2). Pentru a reprograma microcontrolerul 16U2 există două posibilități:

3

  • prin intermediul conexiunii USB utilizând un software de programare DFU;
  • utilizând portul ICSP al microcontrolerului 16U2/8U2 (imaginea de mai sus surprinde poziția portului ICSP la diverse variante de plăci Arduino Uno) utilizând un programator ISP (USBtiny – modalitate utilizată în explicațiile următoare – sau USBasp) sau o altă placă Arduino Uno pe post de programator ISP.

Firmware-ul microcontrolerului 16U2/8U2 va fi rescris cu Moco for LUFA, software ce va transforma placa Arduino Uno într-un dispozitiv MIDI – se va download-a arhiva MocoLUFA-110123.tgz și se va utiliza binarul MIDI.hex din directorul HEX. Binarul este compilat pentru microcontrolerul 8U2 dar poate fi utilizat și pentru 16U2 (va funcționa pe orice variantă de placă Arduino Uno). Utilizând utilitarul avrdude se va încărca binarul utilizând comanda (programator USBtinyISP, placă de dezvoltare Arduino Uno R3 echipată cu varianta 16U2):

avrdude -c usbtiny -p m16u2 -U flash:w:MIDI.hex

După încărcare noului firmware, la conectarea plăcii sistemul de operare o va identifica ca dispozitiv MIDI (captură de ecran pe pagina următoare) și va instala driverul implicit (nu este necesar un driver special).

4

Atenție!!! După modificarea firmware-urului microcontrolerului 16U2/8U2 placa Arduino Uno va funcționa doar ca dispozitiv MIDI, nu va mai fi posibilă utilizarea ca o placă de dezvoltare obișnuită – nu va mai fi posibilă reprogramarea acesteia. Pentru revenirea la funcționalitatea inițială se va reîncărca firmware-ul original al plăcii pe microcontrolerul 16U2/8U2 utilizând comanda (firmware-ul original se găsește în directorul de instalare al mediului Arduino IDE în subdirectorul hardware\arduino\avr\firmware\atmegaxxu2):

avrdude -c usbtiny -p m16u2 \

-U flash:w:Arduino-COMBINED-dfu-usbserial-atmega16u2-Uno-Rev3.hex

Din aceste motiv încărcarea programului pe placa Arduino trebuie făcută înainte de modificarea firmware-ului pentru microcontrolerul 16U2/8U2. Programul utilizat va trimite pe serială diverse note conform protocolului MIDI – exemplu preluat din [*]:

void setup() {

Serial.begin(31250);

}

void loop() {

for (int note = 0x1E; note < 0x5A; note ++) {

noteOn(0x90, note, 0x45);

delay(100);

noteOn(0x90, note, 0x00);

delay(100); }

}

void noteOn(int cmd, int pitch, int velocity) {

Serial.write(cmd);

Serial.write(pitch);

Serial.write(velocity);}

Pentru a verifica funcționarea dispozitivului MIDI se poate utiliza orice software specializat, de exemplu: MIDI-OX – utilitar MIDI gratuit. Captura de ecran următoare prezintă modul de configurare a dispozitivului MIDI și captura comenzilor emise de dispozitivul MIDI Arduino utilizând MIDI-OX.

5

 

Plăci de dezvoltare bazate pe microcontrolerul ATmega32U4

Următoarea generație de plăci de dezvoltare Arduino înlocuiește combinația de microcontroler AVR (ATmega328P – Arduino Uno/Ethernet/Mini/Nano sau ATmega2560 – Arduino Mega) și microcontroler AVR cu suport USB (ATmega16U2 sau ATmega8U2), utilizat pentru conversia USB-to-serial necesară programării, cu un singur microcontroler ce include atât performanțele necesare funcționării plăcii de dezvoltare cât și conectivitatea necesară conexiunii USB. Noua generație de plăci de dezvoltare Arduino utilizează microcontrolerul ATmega32U4 pentru realizarea ambelor sarcini, un exemplu de astfel de placă de dezvoltare este Arduino Leonardo – placă de dezvoltare cu formă și performanțe similare cu placa Arduino Uno dar care este echipată cu un singur microcontroler ATmega32U4 ce rulează atât bootloader-ul de încărcare USB cât și programul scris de utilizator. La fel ca și în cazul microcontrolerului ATmega16U2/8U2 (ce echipează Arduino Uno) firmware-ul ce rulează pe microcontrolerul ATmega32U4 se bazează pe biblioteca LUFA. Din acest motiv placa de dezvoltare Arduino Leonardo permite utilizatorului, spre deosebire de placa Arduino Uno, să scrie programe utilizând mediul Arduino IDE care să transforme placa de dezvoltare într-un dispozitiv de tip tastatură sau mouse fără a suprascrie firmware-ul original al plăcii (facilitatea de a se comporta ca un dispozitiv HID USB este deja inclusă în firmware).

Placa Arduino Leonardo nu este singura placă din familia Arduino care este echipată cu microcontrolerul ATmega32U4, alte exemple de astfel de plăci sunt: Arduino Micro, Arduino Yun, Arduino Robot, Arduino Esplora. O placă dezvoltare ce trebuie de asemenea menționată este Teensy 2.0 deoarece este una dintre cele mai mici plăci de dezvoltare bazate pe ATmega32U4 fiind alegerea cea mai bună pentru proiectele ce au constrângeri legate de dimensiune și din care placa de dezvoltare nu se mai recuperează. Un alt avantaj major al acestei plăci de dezvoltare este dat de componentele software suplimentare față de o placă de dezvoltare Arduino Leonardo dar compatibile cu mediul Arduino IDE. Pe baza acestei plăci vom prezenta realizarea dispozitivul următor.

7

 

Realizarea unui dispozitiv de tip Cititor de Carduri

Dispozitivul prezentat este bazat pe exemplul de la adresa. Plecând de la exemplul Mass Storage conținut în biblioteca LUFA, sistemul implementează un dispozitiv USB de citire a unui card de memorie SD (un card reader) combinând exemplul cu biblioteca de lucru cu un card de memorie. Schema de interconectare a componentelor este prezentată în imaginea alăturată. Pentru compilarea / recompilarea proiectului este necesară instalarea mediului WinAVR și se realizează prin comanda make all în consolă de comandă în directorul LowLevelMassStorage+SD al proiectului. Fișierul MassStorage.hex rezultat în urma compilării proiectului se încarcă în memoria microcontrolerului ATmega32U4 utilizând un programator ICSP (inclusiv o placă Arduino Uno pe post de programator ISP). După încărcarea noului firmware, placa de dezvoltare va fi văzută de sistemul de operare ca un dispozitiv de stocare și se vor putea efectua operațiile de bază cu cardul de memorie (citire, scriere, formatare).

8

Un proiect similar (o placă Teensy 2.0 programată să se comporte ca un dispozitiv de stocare) se găsește la adresa. Acest proiect utilizează exact același program ca și exemplul precedent dar explică în mod detaliat modul de conectare a unui adaptor SD (Teensy SD adaptor) și modul în care tot ansamblul de componente poate fi integrat într-o carcasă USB astfel încât să rezulte o formă finală elegantă (imagine alăturată). O idee interesantă lansată de acest proiect este posibilitatea de a realiza dispozitive mixte (HID+MassStorage) ce pot fi utilizate în lansarea unor atacuri informatice (un mouse sau o tastatură ce conține un virus în memoria internă – un troian hardware).

9

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

Automatizarea utilizării dispozitivelor radio ASK

Pornind de la sistemul prezentat în proiectul “Convertor ASK USB” putem dezvolta o funcționalitate foarte simplă dar utilă în cazul utilizării mai multor dispozitive radio în bandă ISM de 433MHz modulație ASK – mai ales dacă vorbim de de dispozitive de la producători diverși, incompatibile nativ între ele. Această nouă funcționalitate a sistemului ne va permite să automatizăm diverse operații simple ca de exemplu: ”la declanșarea unui senzor de prezență sau de deschidere a ușii să se aprindă lumina într-o anumită cameră„ sau ”la declanșarea unui senzor de gaz să pornească alarma sistemului antiefracție„ etc. Sistemul nostru va face legătura între componente radio ce fac parte din dispozitive complet diferite și va putea fi utilizat indiferent indiferent dacă componentele respective mai fac sau nu mai fac parte din dispozitivele inițiale (senzorii și elementele de acționare vor funcționa cu sau fără componenta bază originală).

Vom utiliza aceleași componente ca și în lecția precedentă: placă de dezvoltare Arduino Pro Micro cu un microcontroler ATmega 32U4 la 16MHz / 5V, un transmițător radio și un receptor radio – ambele în bandă de 433MHz modulație ASK. Schema de interconectare este de asemenea la fel (transmițătorul conectat la pinul 10, receptorul la pinul 3):

2

Programul, dezvoltat și testat utilizând Arduino IDE 1.8.1, extensia Arduino AVR Boards 1.6.19 și bibilioteca rc-switch 2.6.2, este puțin diferit:

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

void setup() {

  while (!Serial);

  Serial.begin(115200);

  mySwitch.enableTransmit(10);

  mySwitch.setRepeatTransmit(3);

  mySwitch.enableReceive(0); }

void loop() {

   if (mySwitch.available()) {

     int value = mySwitch.getReceivedValue();

     if (value != 0) {

      switch (mySwitch.getReceivedValue()) {

        case 6083408:

          Serial.println(“ON command received.”);

          mySwitch.setProtocol(2);

          mySwitch.send(2474994176,32);

          break;

        case 6049984:

          Serial.println(“OFF command received.”);

          mySwitch.setProtocol(2);

          mySwitch.send(2743429632,32);

          break;

        default:

          Serial.print(“Unknown command, received “);

          Serial.print( mySwitch.getReceivedValue() );

          Serial.print(” / “);

          Serial.print( mySwitch.getReceivedBitlength() );

          Serial.print(“bit “);

          Serial.print(“Protocol: “);

          Serial.println( mySwitch.getReceivedProtocol() );

          break;

      }

    }

    mySwitch.resetAvailable();

  }

}

Se poate observa că în cadrul secțiunii loop() se execută o buclă infinită care așteaptă primirea unui cod radio. În funcție de codul radio primit (instrucțiunea switch(mySwitch.getReceivedValue())) se va trimite un alt cod radio ca efect al acțiunii dorite.

3

În cazul exemplului dat s-a utilizat un senzor de deschidere a ușii și o telecomandă radio (ambele făcând parte dintr-un sistem de securitate a locuinței) ca intrări și o priză Conrad RSL ca element de acționare. Pentru mai multe informații legate de diverse dispozitive radio de securitate se poate parcurge și proiectul ”HomeWatch” din cartea ”10(zece) proiecte cu Arduino” și pentru mai multe informații legate de dispozitivele din gama Conrad RSL se pot parcurge și materialele ”Cloud’s Lights” și ”Local Area Power Plugs”.

Codul 6083408 este transmis de senzorul de deschidere a ușii și declanșează deschiderea prizei – cod radio transmis 2474994176. Putem considera că priza alimentează o veioză, o sonerie sau o cameră video de securitate.

4

5

Codul 6049984 este transmis de butonul de armare al telecomenzii radio și va declanșa transmiterea codului radio 2743429632 de închidere a prizei. Orice alt cod radio, necunoscut, va avea ca efect afișarea în consola serială a mesajului Unknown command urmat de codul numeric propriu-zis, acest lucru permite aflarea codurilor ce dorim a fi introduse în program.

6

Funcționarea sistemului nu este limitată la dispozitive radio prefabricate. Putem cu ușurință să dezvoltăm sisteme simple de supraveghere a parametrilor de mediu sau sisteme de acționare pentru diverse sarcini casnice. Un bun exemplu este prezentat în cadrul proiectului ”HomeWatch” din cartea ”10(zece) proiecte cu Arduino” – este vorba de un senzor de bucătărie ce permite avertizarea în caz de inundație sau în cazul unor scurgeri de gaze. Senzorul se bazează pe o placă de dezvoltare Arduino Pro Mini, un modul senzor de gaz metan MQ4 și un transmițător radio 433MHz ASK.

Senzorul de bucătărie poate detecta două evenimente neplăcute ce pot apărea într-o locuință în zona bucătăriei: scurgeri de gaz, senzorul va trimite codul radio 3333310 la apariția acestui eveniment, și scurgeri de apă la nivelul podelei, senzorul va trimite codul radio 3333311 la apariția acestui eveniment. Acest sistem de tip senzor poate fi utilizat cu ușurință împreună cu sistemul de automatizare prezentat putând declanșa o alarmă sonoră sau, de ce nu, un sistem de deschidere a ferestrelor. Schema și codul necesar sunt prezentate în cele ce urmează.

7

Programul a fost testat utilizând Arduino IDE 1.8.1, extensia Arduino AVR Boards 1.6.19 și bibilioteca rc-switch 2.6.2.

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

volatile unsigned long alarma_apa = 0;

volatile unsigned long alarma_gaz = 0;

const unsigned long interval = 60000;

const unsigned int pin_rf = 10;

const unsigned int pin_gaz = A0;

const unsigned int pin_apa = A1;

const unsigned long cod_gaz = 3333310;

const unsigned long cod_apa = 3333311;

void setup() {

  mySwitch.enableTransmit(pin_rf);

  mySwitch.setRepeatTransmit(10);

  pinMode(pin_apa,INPUT_PULLUP); }

void loop() {

  if (analogRead(pin_gaz)>500)

  {   if (alarma_gaz == 0)

      {

         mySwitch.send(cod_gaz,24);

         delay(3000);

         alarma_gaz = millis();

      }

      else

        if ((millis() – alarma_gaz) > interval)

        {

          mySwitch.send(cod_gaz,24);

          delay(2000);

          alarma_gaz = millis();

        }

   }

   else

     if ((alarma_gaz != 0) && ((millis() – alarma_gaz) > interval) )

     {

       alarma_gaz = 0;

     }

   if (analogRead(pin_apa)<500)

   {

      if (alarma_apa == 0)

      {

         mySwitch.send(cod_apa,24);

         delay(3000);

         alarma_apa = millis();

      }

      else

        if ((millis() – alarma_apa) > interval)

        {

          mySwitch.send(cod_apa,24);

          delay(2000);

          alarma_apa = millis();

        }

   }

   else

     if ((alarma_apa != 0) && ((millis() – alarma_apa) > interval) )

     { alarma_apa = 0; }

}

Proiect Convertor ASK / USB

Multe dintre dispozitivele casnice fără fir funcționează prin comunicație radio în bandă ISM de 433MHz modulație ASK. Cele mai des întâlnite astfel de dispozitive sunt sistemele de securitate fără fir, prizele sau soclurile de bec comandate de la distanță și chiar sistemele meteo cu senzori fără fir. Toate aceste sisteme oferă dispozitive fără fir gata construite, ieftine și foarte ușor de folosit în sisteme de comandă personalizate. Dacă sistemul de comandă este bazat pe o placă de dezvoltare de tipul Arduino nu este nici un fel de problemă deoarece există module radio ASK în bandă de 433MHz cu un cost mic și ușor de folosit. Dacă sistemul de comandă are o complexitate mai mare și necesită utilizarea unui PC sau a unei plăci de tipul Raspberry Pi lucrurile se complică puțin. În cadrul acestui proiect ne propunem să realizăm un sistem ieftin și de mici dimensiuni care să realizeze legătura între comunicația radio în bandă de 433MHz modulație ASK și portul USB prezent în sistemele de calcul de uz general (PC-uri, laptop-uri, plăci de dezvoltare bazate pe microprocesoare). Astfel de dispozitive există deja dar au un preț destul de mare (a se vedea (*)).

Sistemul nostru se va baza pe o placă de dezvoltare Arduino Pro Micro cu un microcontroler ATmega 32U4 la 16MHz / 5V, un transmițător radio și un receptor radio – ambele în bandă de 433MHz modulație ASK. Componentele au fost alese astfel încât să asigure un cost total cât mai scăzut și posibilitatea de a fi integrate într-o carcasă de mici dimensiuni (aproximativ cât o baterie USB externă, imagine alăturată, astfel de carcase se găsesc de cumpărat pe Internet la prețuri de circa 2$).

2

Dispozitivul rezultat va fi văzut de sistemul de calcul în cadrul căruia va fi utilizat ca un dispozitiv serial ce va transmite către sistem codurile radio primite și va transmite radio codurile primite de la sistem – va fi realiza conversia dintre comunicația serială (over USB) și comunicația radio ASK în bandă de 433MHz.

 

Interconectarea componentelor

Interconectarea dintre placa de dezvoltare și cele două module radio este reprezentată în diagrama următoare:

3

Transmițătorul radio va avea linia de date conectată la pinul 10 al plăcii de dezvoltare iar receptorul radio va avea linia de date conectată la pinul 4 al plăcii de dezvoltare (pinul de întrerupere 0). Ambele module se vor alimenta la 5V prin intermediul pinilor VCC / GND ai plăcii de dezvoltare.

Pentru mai multe detalii despre instalarea și operarea plăcii Sparkfun Pro Micro se recomandă parcurgerea materialului ”Pro Micro & Fio V3 Hookup Guide” .

 

Programarea sistemului

Programul a fost dezvoltat și testat utilizând Arduino IDE 1.8.1 cu extensia Arduino AVR Boards 1.6.19 instalată și bibilioteca rc-switch 2.6.2.

 

#include <string.h>

#include <RCSwitch.h>

RCSwitch mySwitch = RCSwitch();

void setup() {

  while (!Serial);

  Serial.begin(115200);

  mySwitch.enableTransmit(10);

  mySwitch.setRepeatTransmit(3);

  mySwitch.enableReceive(0);

}

void loop() {

  char inData[80];

  int index = 0;

  while(Serial.available() > 0)

  {

     char aChar = Serial.read();

     if(aChar == ‘\n’)

     {

        inData[index] = NULL;

        index = -1;

     }

     else

     {

        inData[index] = aChar;

        index++;

        inData[index] = ‘\0’;

     }

  }

  char * number;

  unsigned long number1, number2, number3;

  if (index==-1) {

    number = strtok(inData,”,”);

    number1 = atol(number);

    number = strtok(NULL,”,”);

    if(number!=NULL) { number2=atoi(number); }

    number = strtok(NULL,”,”);

    if(number!=NULL) { number3=atoi(number); mySwitch.setProtocol(number3);}

    mySwitch.send(number1,number2);

  }

  if (mySwitch.available()) {

     int value = mySwitch.getReceivedValue();

        if (value == 0) {

      Serial.print(“Unknown encoding”);

    } else {

      Serial.print( mySwitch.getReceivedValue() );

      Serial.print(“,”);

      Serial.print( mySwitch.getReceivedBitlength() );

      Serial.print(“,”);

      Serial.println( mySwitch.getReceivedProtocol() );

    }

    mySwitch.resetAvailable();

  }

}

Comunicația dintre sistemul de calcul și dispozitivul USB construit va avea mesajele de forma COD,DIMENSIUNE,VERSIUNEPROTOCOL .

De exemplu, în consola serială, apăsarea butoanelor unei telecomenzi radio ce face parte dintr-un sistem de securitate a locuinței va avea următorul efect (se observă codul butonului de dimensiune 24 biți, protocol radio versiunea 1).

4

5

Pentru mai multe informații legate de diverse dispozitive radio de securitate se poate parcurge și proiectul ”HomeWatch” din cartea ”10(zece) proiecte cu Arduino”.

În cazul în care dorim să dăm o comandă radio vom tasta în consola serială cei trei parametrii necesari transmisiei. De exemplu: 2474994176,32,2 (cod de deschidere pe 32 de biți, protocol versiunea 2, specific unei prize radio din gama Conrad RSL).

6

Pentru mai multe informații legate de dispozitivele din gama Conrad RSL se pot parcurge și materialele ”Cloud’s Lights” și ”Local Area Power Plugs”.

Bineînțeles, dispozitivul prezentat nu își găsește utilitatea majoră în comanda sau supravegherea manuală în consola serială. Utilizarea lui trebuie integrată într-o aplicație specifică platformei la care este conectat (o aplicație Windows sau un script de automatizare sub platforma Linux) și sub care pot fi predefinite codurile de comandă pentru diverse dispozitive cunoscute.

O aplicație utilă poate fi utilizarea dispozitivului în conjuncție cu o platfotmă de automatizare a locuinței, de exemplu OpenHAB. În acest scop se pot vedea și materialele ”Realizarea unui sistem de tip Home Automation” și ”Conectarea unor dispozitive antiefracție la platforma OpenHab”.

Proiect Termometru Simfonic

În cadrul proiectului de față vom prezenta o soluție de achiziție (ca exemplificare vom face achiziția temperaturii și umidității mediul ambiant) cu raportare IoT prin GPRS (rețea de telefonie mobilă). Soluția propusă este una simplă și vine în întâmpinarea unei probleme extrem de actuală: supravegherea de la distanță a unor parametrii de mediu în locații izolate unde nu dispunem de infrastructură de rețea Internet – în loc de temperatură și umiditate putem face achiziția unor parametrii ai solului (aplicații pentru agricultură inteligentă) sau achiziția unor parametrii de proximitate și integritate (aplicații de securitate).

Soluția propusă se bazează pe placa de dezvoltare Adafruit Feather 32U4 FONA, placă ce combină un microcontroler ATmega32U4 la 8MHz / 3.3V și un controler GSM SIM800 quad-band (850/900/1800/1900MHz). Placa necesită alimentarea de la un acumulator LiPo extern de minim 500mAh (se pot utiliza (*), (*), (*)) și o antenă GSM uFL.

2

Pentru achiziția parametrilor temperatură și umiditate vom utiliza un senzor digital I2C Si7021 ce are o precizie mare de măsurare și se poate interfața foarte ușor cu placa de dezvoltare utilizată.

3

Funcționarea sistemului necesită o cartelă GSM 2G cu capabilități de transfer de date. Pentru acest lucru vă propunem utilizarea unui SIM Simfony Mobile M2M – cartelă GSM ce oferă exclusiv servicii mobile de date.

4

Cartela este disponibilă gratuit prin comandă pe site-ul companiei Simfony Mobile SRL  sau împreună cu un produs din gama GSM pe site-ul Robofun. Cartela necesită înregistrarea și introducerea codului promoțional pentru activare și oferă gratuit 10MB de date mobile valabile 3 luni. Ulterior costurile de funcționare sunt de 0.25EURO, 0.5EURO, 1EURO pentru 1MB, 5MB respectiv 10MB trafic de date. Chiar dacă traficul inclus are valori modice pentru un sistem de raportare IoT este suficient iar costurile sunt rezonabile. O caracteristică importantă a cartelei SIM Simfony este indepența de un operator de telefonie anume, dispozitivul GSM ce utilizează cartela Simfony poate utiliza orice operator de telefonie mobilă în funcție de zona în care se află chiar și afara României.

 

Interconectarea componentelor

Interconectarea dintre senzorul Si7021 și placa Feather 32U4 FONA este reprezentată în diagrama următoare:

5

Pentru mai multe detalii despre operarea plăcii Adafruit Feather 32U4 FONA se recomandă parcurgerea materialului ”Adafruit Feather 32u4 FONA – Take your Feather anywhere in the world”.

 

Programarea sistemului

Pentru realizarea și testarea sistemului s-a utilizat Arduino IDE 1.8.1 cu extensia Adafruit AVR Boards 1.4.9 instalată precum și bibliotecile Adafruit FONA 1.3.2, Adafruit Si7021, Sleep_n0m1 1.1.1.

 

#include “Adafruit_FONA.h”

#define FONA_RX  9

#define FONA_TX  8

#define FONA_RST 4

#define FONA_RI  7

#define FONA_DTR 5

#define apn “internet.simfony.net”

#define apnusername “” 

#define apnpassword “” 

char replybuffer[255];

#include <SoftwareSerial.h>

SoftwareSerial fonaSS = SoftwareSerial(FONA_TX, FONA_RX);

SoftwareSerial *fonaSerial = &fonaSS;

Adafruit_FONA fona = Adafruit_FONA(FONA_RST);

uint8_t type;

#include <Sleep_n0m1.h>

Sleep sleep;

#include <Adafruit_Si7021.h>

Adafruit_Si7021 sensor = Adafruit_Si7021();

 

Dacă se dorește supravegherea funcționării sistemului pe serială se va adăuga următoarea linie, în funcționarea propriu-zisă nu este necesară:

 

#define debug

 

În cadrul secțiunii setup() se va realiza inițializarea modulului GSM și a senzorului Si7021:

 

void setup() {

  #ifdef debug

    while (!Serial);

    Serial.begin(115200);

    Serial.println(“Initializing…”);

  #endif

  digitalWrite(FONA_DTR,LOW);

  fonaSerial->begin(4800);

  if (! fona.begin(*fonaSerial)) {

    #ifdef debug

      Serial.println(F(“Couldn’t find FONA”));

    #endif

    delay(1);

    while (1);

  }

  #ifdef debug

    type = fona.type();

    Serial.println(F(“FONA is OK”));

    Serial.print(F(“Found “));

    switch (type) {

      case FONA800L:

        Serial.println(F(“FONA 800L”)); break;

      case FONA800H:

        Serial.println(F(“FONA 800H”)); break;

      case FONA808_V1:

        Serial.println(F(“FONA 808 (v1)”)); break;

      case FONA808_V2:

        Serial.println(F(“FONA 808 (v2)”)); break;

      case FONA3G_A:

        Serial.println(F(“FONA 3G (American)”)); break;

      case FONA3G_E:

        Serial.println(F(“FONA 3G (European)”)); break;

      default:

        Serial.println(F(“???”)); break;

    }

   #endif

  #ifdef debug

    char imei[15] = {0};

    uint8_t imeiLen = fona.getIMEI(imei);

    if (imeiLen > 0) {

      Serial.print(“Module IMEI: “); Serial.println(imei);

    }

  #endif

  fona.getSIMCCID(replybuffer); 

  #ifdef debug

    Serial.print(F(“SIM CCID = “));

Serial.println(replybuffer);

  #endif

  if (!fona.enableNetworkTimeSync(true)) {

     #ifdef debug

      Serial.println(F(“Failed to enable NTS”));

     #else

      ;

     #endif

  }

  delay(5000);

  fona.setGPRSNetworkSettings(F(apn),F(apnusername),F(apnpassword));

  uint8_t n=0;

  #ifdef debug

    Serial.print(“Connecting to network.”);

  #endif

  while (n!=5) {

    n = fona.getNetworkStatus();

    #ifdef debug

      Serial.print(“.”);

    #endif

    delay(1000);

  }

  #ifdef debug

    Serial.println(“OK”);

  #endif

  #ifdef debug

    n = fona.getRSSI();

    int8_t r;

    if (n == 0) r = -115;

    if (n == 1) r = -111;

    if (n == 31) r = -52;

    if ((n >= 2) && (n <= 30)) { r = map(n, 2, 30, -110, -54); }

    Serial.print(r); Serial.println(F(“dBm”));

  #endif

  sensor.begin();

  delay(5000);

}

 

Sistemul va raporta către serviciul IoT ThingSpeak valorile achiziționate (temperatură și umiditate) precum și voltajul și procentul de încărcare a acumulatorului ce alimentează sistemul. Secțiunea loop() implementează atât partea de achiziție cât și partea de transmisie de rețea prin intermediul comunicației mobile. În cadrul codului trebuie personalizată valoarea parametrului key ce se obține în urma înregistrării gratuite pe site-ul ThingSpeak. Achiziția și raportarea se realizează la un interval de o oră (3600000ms), în intervalul de inactivitate atât modulul GSM cât și microcontrolerul 32u4 se află în mod de consum redus.

 

void loop() {

while (!fona.enableGPRS(true)) {

#ifdef debug

Serial.println(F(“Failed to turn on GPRS”));

#endif

delay(5000);

}

uint16_t vbat;

uint16_t pbat;

#ifdef debug

if (fona.getBattVoltage(&vbat)) { Serial.print(F(“VBat = “)); Serial.print(vbat);

Serial.println(F(” mV”)); }

if (fona.getBattPercent(&pbat)) { Serial.print(F(“VPct = “)); Serial.print(pbat);

Serial.println(F(“%”));   }

Serial.println(“——————————————————“);

#else

fona.getBattVoltage(&vbat);

fona.getBattPercent(&pbat);

#endif

float temperature, humidity;

temperature = sensor.readTemperature();

humidity = sensor.readHumidity();

#ifdef debug

Serial.print(“Humidity:    “);

Serial.print(humidity, 2);

Serial.print(“\tTemperature: “);

Serial.println(temperature, 2);

#endif

String temp = “api.thingspeak.com/update?key=…&field1=” + String(vbat/1000.0F,2) + “&field2=” + String(pbat) + “&field3=” + String(temperature,2) + “&field4=” + String(humidity,2);

uint16_t statuscode;

int16_t length;

char url[100];

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

#ifdef debug

Serial.println(url);

if (!fona.HTTP_GET_start(url, &statuscode, (uint16_t *)&length)) Serial.println(“Failed

read HTTP!”);

#else

fona.HTTP_GET_start(url, &statuscode, (uint16_t *)&length);

#endif

while (length > 0) {

while (fona.available()) {

char c = fona.read();

#ifdef debug

Serial.write(c);

#endif

length–;

if (! length) break;

}

#ifdef debug

Serial.println();

#endif

break;

}

fona.HTTP_GET_end();

delay(100);

#ifdef debug

Serial.println(“——————————————————“);

if (!fona.enableGPRS(false)) Serial.println(F(“Failed to turn off GPRS”));

#else

fona.enableGPRS(false);

#endif

delay(100);

digitalWrite(FONA_DTR,HIGH);

#ifdef debug

delay(3600000);

#else

sleep.pwrDownMode();

sleep.sleepDelay(3600000);

#endif

digitalWrite(FONA_DTR,LOW);

delay(100);

}

 

Configurarea sistemului de raportare IoT

Sistemul nostru este un sistem tipic IoT ce utilizează platforma on-line ThingSpeak. Utilizarea platformei necesită înregistrare dar aceasta este gratuită.

6

Platforma ThingSpeak este una dintre cele mai cunoscute platforme IoT ce oferă servicii de stocare, prelucrare și vizualizare a datelor. Unul dintre avantajele majore ale platformei este posibilitatea de execuție de programe scrise în limbajul Matlab.

După înregistrare se va defini un nou canal înregistrare a datelor (My Channels / New Channel). Definirea canalului va genera și cheia (Write API Key) ce trebuie utilizată în program.

7

În cadrul acestui canal vom defini patru câmpuri Vbat, Vperc, Temperature și Humidity ce vor stoca efectiv datele trimise de dispozitivul nostru.

8

După punerea în funcțiune a sistemului se vor putea vedea și datele trimise de dispozitiv (secțiunea PrivateView).

9