Faceți cunoștință cu LoRa

Termenul de LoRa (sau tehnologie LoRa) se referă la o categorie de comunicații radio caracterizate de distanță mare de transmisie (Long Range) cu un consum mic de energie (Low Power). Spre deosebire de tehnologiile de transmisie radio digitale clasice, tehnologiile LoRa au capabilitatea de a comunica date la distanțe de câțiva kilometri sau chiar zeci de kilometri având aplicabilitate extraordinară în rețele de senzori wireless (fără fir), internetul obiectelor (IoT) și crearea de rețele de dispozitive inteligente. În spatele termenului de LoRa se află de fapt o multitudine de tehnologii proprietar sau deschise, similare ca funcționalitate dar total incompatibile ca implementare – domeniul de comunicații digitale radio la distanțe mari fiind la momentul actual într-o fază de pionierat în care stabilitatea oferită de standardizare și metode de interconectare tehnologică sunt un deziderat destul de îndepărtat. Alți termeni utilizați pentru a referi rețelele radio digitale cu raza mare de transmisie sunt: LoRaWAN (LoRa Wide Area Network), LPWAN (Low Power Wide Area Network), 6LowPAN (IPv6 Low-power Personal Area Network), LPN (Low Power Network) – unii dintre acești termeni sunt înregistrați ca mărci aparținând unor anumite companii sau consorții fiind folosiți pentru a identifica o anumită tehnologie LoRa (chiar și termenul de LoRa este marcă înregistrată a companiei Semtech).

Există foarte multe materiale care încearcă să clarifice asemănările / deosebirile și avantajele / dezavantajele oferite de fiecare tehnologie LoRa în parte, în acest sens vă recomandăm:

dar în cadrul materialului de față ne vom limita să prezentăm cele mai cunoscute tehnologii de transmisie radio la distanță mare la momentul actual precum și diverse dispozitive radio disponibile pe piață pentru implementarea acestor tehnologii (dispozitive aflate la un nivel decent de cost și complexitate pentru a le putea folosi în dezvoltarea unor sisteme proprii).

Tehnologii de transmisie radio la distanță mare  și dispozitive radio compatibile

LoRa –  Tehnologie radio ce utilizează benzi de frecvență radio ISM sub-Ghz pentru a transmite datele la distanțe mari cu un consum foarte mic de energie.

2

Este o tehnologie proprietar și este dezvoltată de compania Semtech. Specifică nivelul fizic de comunicație (modulația radio). Este implementată în circuitele integrate radio din seria SX1xxx produse de Semtech sau în circuitele RFM9x produse de HopeRF (care a cumpărat licența pentru nucleul radio LoRa). Cele două familii de circuite radio sunt compatibile deoarece implemetează același nucleu electronic de comunicație radio. Există mai multe plăci de dezvoltare și module de comunicație radio bazate pe circuitele din cele două familii:

  • Seeeduino LoRaWAN – placă de dezvoltare bazată pe un microcontroler ARM Cortex-M0+ ATSAMD21G18 (la fel ca și placa Arduino M0, placa este compatibilă cu mediul Arduino IDE) și un modul de comunicație radio RHF76-052 bazat pe circuitul SX1276 (compatibil LoRa).

3

  • Dragino LoRa Shield – shield Arduino bazat pe circuitul radio RFM98W (compatibil LoRa). Integrează un senzor de temperatură și indicator de baterie. Compatibil cu Arduino Uno, Leonardo, Mega.

4

  • Raspberry Pi LoRa/GPS HAT – shield (hat) pentru placa Raspberry Pi 2/3. Bazat pe un modul RFM92 (compatibil LoRa). Include un receptor GPS.

5

  • Adafruit Feather 32U4 / M0 RFM9x precum și shield-ul LoRa Radio Feather bazate pe module RFM9x și compatibile cu mediul Arduino IDE. Plăci de dezvoltare de mici dimensiuni, compacte și cu posibilitatea de alimentare de la un acumulator LiPo de 3.7V.

6

  • Modul radio Adafruit RFM96W ce permite utilizarea modului radio de la HopeRF împreună cu diverse plăci de dezvoltare inclusiv plăcile de dezvoltare Arduino.

7

LoRaWAN (LoRa Wide Area Network) – set de specificații deschise de tipul LPWAN (Low Power Wide Area Network) dezvoltate de consorțiul LoRa Alliance.

8

Completează tehnologia LoRA cu nivelul MAC. Chiar dacă este un set de specificații deschise la care contribuie o serie de companii importante (CISCO, IBM, ST, Renesas, ZTE, Microchip…) se bazează în totalitate pe nivelul fizic proprietar LoRa. Totuși, există o comunitate mare de utilizatori care și-au propus construirea unei rețelei globale LoRaWAN (The Thing Network) – în prezent puteți găsi acoperire TTN la noi în țară în București și Timișoara.

9

Sigfox – tehnologie LPWAN dezvoltată de compania franceză Sigfox. Utilizează modulație radio UNB (Ultra Narrow Band) și frecvențe radio ISM sub-GHz. Acoperire aproapre totală în circa 30 de țări.

10

Multiplii producători pentru circuite radio compatibile: Microchip, Texas Instruments, NXP sau ON Semiconductors și numeroase plăci de dezvoltare din care trebuie să menționăm placa de dezvoltare:

  • Arduino MKR FOX 1200 echipată cu un microcontroler ARM Cortex-M0+ SAMD21 (la fel ca și placa Arduino M0) și un circuit radio ATAB8520E (compatibil Sigfox).

11

6LowPAN (IPv6 Low-power Personal Area Network) este un set de specificații realizate de o comisie, cu același nume, a IETF (Internet Engineering Task Force). Specificațiile își propun extinderea seturilor de protocoale Internet pentru diferite metode de comunicație IoT (implementarea protocoalelor Internet în dispozitive specializate simple cu un consum redus de energie) și au influențat diverse tehnologii proprietar din domeniul LPWAN precum Thread dând naștere la diverse derivații funcționale pentru protocoalele radio existente precum IPv6 over BLE.

12

Controlere USB

Controlerele USB sunt circuite integrate ce permit interfațarea unui sistem electronic cu un port USB. Controlerele USB se pot configura dar nu pot executa un program (nu sunt programabile) putând efectua doar sarcini simple de conversie între diverse protocoale seriale sau paralele și comunicația USB. Aceste circuite pot înlocui un microcontroler într-un sistem simplu de achiziție, comandă sau comunicație scăzând prețul și complexitatea sistemului. Exemple de astfel de circuite:

  • Familia de circuite FTDI FT-X ce include convertoare USB-to-UART, USB-to-SPI sau USB-to-I2C. Circuitul FT232RL a echipat plăcile de dezvoltare Arduino Duemilanove (plăci Arduino de generație mai veche) pentru conversia USB-to-UART fiind înlocuite ulterior cu microcontrolerele ATmega16U2/8U2 pentru plăcile Arduino Uno și Arduino Mega. Modulele necesare programării plăcilor de dezvoltare Arduino Ethernet și Arduino Pro Mini se bazează pe același circuit FT232RL. Adafruit FT232H Breakout (imagine de mai jos) este un exemplu de modul capabil să ofere simultan conectivitate UART, I2C și SPI prin intermediul unei conexiuni USB.

1

  • Seria de circuite Smart I/O a companiei Prolific conține diverse circuite (PL-2303xx) pentru conversia USB-to-UART, acestea fiind regăsite pe majoritatea clonelor de plăci Arduino sau pe diverse module ieftine de conversie USB-to-RS232 sau USB-to-UART.

2

  • Controlerul USB Microchip MCP2221 este un circuit cu facilități de configurare extrem de flexibile putând fi utilizat simultan pentru conversia USB-UART, USB-I2C, USB-parallel și chiar și pentru achiziția analogică prin intermediul conexiunii USB. Datorită prețului scăzut și al facilităților oferite vom utiliza acest controler pentru cele două exemple din cadrul lecției.

3

Controlerul USB MCP2221

Unul dintre avantajele controlerului MCP2221 este disponibilitatea în format THT (PDIP14) permițând astfel realizarea de montaje pe breadboard fără a fi nevoie de un modul de tip breakout, în plus circuitul nu necesită sursă de oscilație (cuarț) extern sau alte componente suplimentare (cu alte cuvinte este utilizabil la un cost minimal). Pinii circuitului au următoarele semnificații și funcționalități:

  • VDD, VSS (5V, GND) sunt pinii de alimentare a circuitului și trebuie conectați la pinii de alimentare a conexiunii USB;
  • D+, D- sunt pinii de comunicație USB, se conectează la pinii corespondenți ai conexiunii USB;
  • SCL, SDA sunt cele două linii de comunicație ale magistralei I2C;
  • /RST pin de resetare a circuitului;
  • Vusb pin de alimentare la 3.3V în cazul în care nu se dorește alimentarea oferită de conexiunea USB (nu se utilizează pinii VDD și VSS);
  • URx, UTx sunt pinii de comunicație UART;
  • GP0, GP1 – pini I/O de uz general; pot fi folosiți și ca pini de comandă pentru LED-urile de activitate RX, TX pentru comunicația serială; pinul GP1 poate fi folosit ca și pin de achiziție analogică sau ca linie de întrerupere externă.
  • GP2 – pin I/O de uz general; poate fi folosit ca pin de intrare analogică, pin de ieșire analogică sau pin de stare a conexiunii USB (USBCFG);
  • GP3 – pin I/O de uz general; poate fi folosit ca pin de intrare analogică, pin de ieșire analogică sau comandă pentru LED-ul de activitate magistrală I2C.

4

După cum se poate observa funcționalitatea oferită de controlerul USB MCP2221 este una diversă: convertor USB-to-UART, convertor USB-to-I2C, achiziție analogică prin USB, comandă digitală prin USB, comandă analogică prin USB. Pentru configurarea controlerului se utilizează programul MCP2221 Utility (captură de ecran de mai jos).

5

Prin intermediul acestui program se poate modifica:

  • Descriptorul USB al controlerului:
    • VID / PID ce identifică în mod unic dispozitivul USB și pe baza cărora sistemul de operare instalează driverele corecte – modificarea acestora conduce la probleme de instalare a driverelor implicite Microchip;
    • Curentul necesar funcționării dispozitivului (între 100mA și 500mA);
    • Dacă se alimentează din conexiunea USB sau se alimentează în mod autonom;
    • Informații descriptive (pot fi modificate fără probleme pentru personalizarea descrierii perifericului USB): descriere, producător, număr serial.
  • Funcționalitatea și configurația celor patru pini GPIO (GP0-GP3):
    • GP0: pin I/O (direcție, stare inițială), SSPND (USB state) sau LED_URx;
    • GP1: pin I/O (direcție, stare inițială), generator semnal de ceas (CLK_OUT), pin achiziție analogică (tensiune referință), linie de întrerupere externă (tip declanșare) sau LED_UTx;
    • GP2: pin I/O (direcție, stare inițială), USBCFG, pin de achiziție analogică (tensiune referință) sau pin de comandă analogică (tensiune referință);
    • GP3: pin I/O (direcție, stare inițială), LED_I2C, pin de achiziție analogică (tensiune referință) sau pin de comandă analogică (tensiune referință);

Datorită facilităților diverse oferite de controlerul MCP2221 se pot realiza proiecte embedded variate în care microcontrolerul să fie înlocuit de circuitul MCP2221. În cadrul acestei lecții vom exemplifica utilizarea circuitului MCP2221 prin două sisteme simple: un ceas USB și un termometru USB.

Sistem de tip Ceas USB

Controlerul MCP2221 este văzut de sistemul de operare ca două dispozitive USB distincte: un dispozitiv CDC prin care se realizează conversia USB-to-UART (un port serial) și un dispozitiv HID prin care se realizează comunicația cu restul de componente (pini I/O, magistrală I2C, pini analogici). Pentru proiectul Ceas USB ne vom folosi de facilitatea de convertor USB-to-UART a circuitului MCP2221 pentru a comanda afișarea orei pe un LCD grafic serial de rezoluție 128×64 pixeli. Schema de interconectare este foarte simplă:

6Pinii D+ și D- ai conexiunii USB vor fi conectați direct la controlerul USB. Pinii de alimentare ai conexiunii USB vor asigura funcționarea a controlerului și a ecranului LCD. Comunicația serială între controler și afișaj va fi unidirecțională și va folosi o singură linie: pinul 6 (UTx) al controlerului va fi conectat la pinul RX al afișajului.

7

Pentru ca sistemul să funcționeze, pe PC va rula un program ce va prelua ora de pe sistemul PC și va transmite comenzile de afișare pe portul serial către afișaj (controlerul USB va fi o componentă transparentă pentru program). Programul va necesita o parte de inițializare:

  • Dacă dispozitivul USB cu ID-ul xxxxxxx este conectat:
    • Identifică portul serial asociat cu dispozitivul USB cu ID-ul xxxxxxx;
    • Transmite pe portul serial comandă de ștergere a ecranului: 0x7C,0x00

și o buclă infinită în care:

  • Transmite pe portul serial comandă de poziționare pe X: 0x7C, 0x18, … și pe Y: 0x7C, 0x19, …;
  • Preia ora de pe sistemul PC și transmite ora pe portul serial.

Sistem de tip Termometru USB

Sistemul Termometru USB își propune citirea unui senzor de temperatură I2C conectat la controlerul MCP2221. Temperatura citită poate fi ulterior afișată pe ecranul PC-ului. Senzorul utilizat va fi TMP102 dar se poate utiliza orice alt senzor I2C sau analogic. Schema de interconectare a celor două componente este:

8

Deoarece senzorul TMP102 funcționează la 3.3V va fi alimentat prin intermediul pinului Vusb al controlerului MCP2221 (controlerul are inclus un regulator de tensiune 5V->3.3V – imagine de mai jos).

9

Liniile magistralei I2C (SCL și SDA) se vor conecta la pinii 10 și 9 ai controlerului. Din punct de vedere al programului ce va rula pe PC, comunicația cu magistrala I2C se va realiza prin intermediul unei biblioteci software puse la dispoziție de Microchip: MCP2221 DLL. Pentru a realiza achiziția de temperatură de la senzor este necesar să utilizăm următoarele funcții ale bibliotecii (directorul bibliotecii include exemple de utilizare pentru mai multe limbaje de programare):

  • DllInit() – pentru inițializarea comunicației;
  • GetConnectionStatus() – pentru a verifica dacă dispozitivul este conectat;
  • SelectDev(ID) – pentru a selecta dispozitivul;

ReadI2C() – ce va avea ca parametrii adresa senzorului I2C și numărul de octeți citiți.

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