Conectarea unor dispozitive antiefracție la platforma OpenHab

Utilizând o instalare standard a platformei OpenHab vom adăuga sistemului de tip Home Automation o serie de dispozitive antiefracție îmbogățind astfel funcționalitatea sistemului. Cele mai simple și ieftine dispozitive de securitate sunt furnizate de sistemele de alarmă fără fir domestice: senzor de deschidere a ușii, senzor de mișcare (PIR), senzor de vibrație pentru protecția ferestrelor, senzor de fum sau chiar de inundație. Avantajul acestor dispozitive este costul scăzut, disponibilitatea de a fi achiziționate separat de un sistem de securitate complet (ca piese de schimb sau componente de extindere a sistemelor de securitate existente) și de ce nu, avantajul unor dispozitive gata realizate și ușor de integrat într-un sistem personalizat propriu.

1

Un material interesant despre integrarea acestui tip de dispozitive în cadrul unei sistem de alarmă bazat pe platforma Arduino este proiectul Home Watch din cadrul cărții ”10(zece) proiecte cu Arduino”:

https://books.google.ro/books?id=aMB8BgAAQBAJ

Dispozitivele de securitate de acest tip funcționează pe baza comunicației radio în bandă ISM de 433MHz modulație ASK și pot fi ”interceptate” utilizând un receptor radio foarte ieftin și ușor de utilizat atât în combinație cu platforma Arduino cât și cu placa de dezvoltare Raspberry Pi:

2

https://www.robofun.ro/wireless/wireless-433/receptor_radio

 Conectarea receptorului radio la placa de dezvoltarea Raspberry Pi necesită realizarea a trei conexiuni:

  • Pinul de GND al modulului radio la pinul 6 (GND) al plăcii Raspberry Pi;
  • Pinul Data al modului radio la pinul 11 al plăcii Raspberry Pi;
  • Pinul Vcc al modului radio la pinul 2 (5V) al plăcii Raspberry Pi. 3

 

Pentru mai multe detalii legate de conectarea modului radio la placa Raspberry Pi se pot consulta și următoarele resurse on-line:

pi-switch: Send and receive 433MHZ signals with a Raspberry Pi

http://lexruee.ch/2015/07/31/pi-switch:-Send-and-receive-433MHZ-signals-with-a-Raspberry-Pi.html

Decode 433 MHz signals w/ Raspberry Pi & 433 MHz Receiver

http://www.princetronics.com/how-to-read-433-mhz-codes-w-raspberry-pi-433-mhz-receiver/

 

Pentru implementarea comunicației între modulul radio și placa de dezvoltare Raspberry Pi vom instala suita de utilitare 433Utils bazată pe biblioteca rc-switch. Pentru acest lucru vom rula următoarele comenzi (se presupune că avem instalat utilitarul git, dacă nu vom rula și instrucțiunea sudo apt-get install git-core):

cd /opt

sudo git clone –recursive git://github.com/ninjablocks/433Utils.git

cd 433Utils/RPi_utils/

sudo make

sudo ./RFSniffer

Rularea utilitarului RFSniffer ne va permite să vizualizăm codurile transmise de dispozitivele antiefracție cu care dorim să lucrăm:

4

Pentru a putea face legătura între utilitarul RFSniffer (între codurile radio transmise de dispozitivele de securitate) și platforma OpenHab trebuie să transformăm utilitarul într-un serviciu al sistemului de operare – să-l facem să pornească odată cu sistemul și să ruleze în fundal în mod continuu.

Primul pas este modificarea codului sursă al utilitarului (RFSniffer.cpp) după cum urmează:

linia 20:

printf(“Received %i\n”, mySwitch.getReceivedValue() );

se va modifica în

printf(“%i\n”, mySwitch.getReceivedValue() );

iar înainte de linia 28 (instrucțiunea mySwitch.resetAvailable();) vom insera instrucțiunea:

fflush(stdout);

La final vom recompila utilitarul cu ajutorul comenzii make prezentă în succesiunea de comenzi anterioară apoi vom crea un director în care vom muta utilitarul RFSniffer și vom crea scripturile de legătură cu platforma OpenHab.

cd /opt

sudo mkdir 433

sudo cp /opt/433Utils/RPi_utils/RFSniffer /opt/433

sudo chmod -R 755 433

Pentru a porni în mod automat vom crea în directorul /etc/init.d/ fișierul RFSniffer cu următorul conținut:

#! /bin/sh

# /etc/init.d/RFSniffer

 

### BEGIN INIT INFO

# Provides:     RFSniffer

# Required-Start: $all

# Required-Stop:  $all

# Default-Start: 2 3 4 5

# Default-Stop: 0 1 6

# Short-Description: RFSniffer log

# Description:  RFSniffer log

### END INIT INFO

 

case “$1” in

    start)

        echo “Starting RFSniffer”

        /opt/433/RFSniffer > /opt/433/sniff.txt &

        ;;

    stop)

        echo “Stopping RFSniffer”

        killall RFSniffer

        ;;

    *)

        echo “Usage: /etc/init.d/RFSniffer  {start|stop}”

        exit 1

        ;;

esac

și vom integra acest script în sistemul de inițializare a sistemului de operare:

sudo chmod 755 /etc/init.d/RFSniffer

sudo update-rc.d RFSniffer defaults

Acum, la repornirea sistemului, utilitarul RFSniffer va rula în fundal în mod automat și va trimite toate codurile radio primite în fișierul /opt/433/sniff.txt .

Pentru exemplificare vom integra cu platforma OpenHab doi senzori de ușă. Un astfel de senzor, bazat pe un red-switch – un întrerupător de proximitate, emite un anumit cod radio în poziția deschis semnalizând astfel deschidere ușii pe care a fost montat.

5

Vom utiliza doi senzori pentru a prinde atât poziția de deschis cât și cea de închis – ușa închisă va declanșa un senzor iar ușa deschisă va declanșa celălalt senzor. Cu alte cuvinte vom avea două coduri radio pe care le vom interpreta în platforma OpenHab.

Pentru a face acest lucru vom crea fișierul sniff în directorul /opt/433/ cu următorul conținut:

aux=$(tail -n 1 /opt/433/sniff.txt);

if [ $aux == “6049804” ]; then

    echo “OPEN”;

elif [ $aux == “6049984” ]; then

    echo “CLOSE”;

fi

Acest fișier script are rolul de a transforma codurile numerice (6049804 – codul transmis de senzorul ce indică ușă deschisă, 6049984 – senzorul ce indică ușă închisă) în cuvintele cheie OPEN și CLOSE. Acest script va fi apelat de fișierele de configurare ale platformei OpenHab. Astfel în fișierul /etc/openhab/configurations/items/casamea.items vom adăuga următoarea linie:

String    USA       “Usa intrare [%s]” 

{exec=”<[/bin/bash@@-c@@/opt/433/sniff:3000:REGEX((.*?))]”}

iar în fișierul /etc/openhab/configurations/sitemaps/casamea.sitemap :

Frame label=”Securitate” {

                Text item=USA icon=”door-closed”

        }

Pentru ca apelul scriptului extern să funcționeze este necesară instalarea componentei suplimentare binding-exec specifică platformei OpenHab:

sudo apt-get install openhab-addon-binding-exec

La accesarea interfeței OpenHab noul element (USA) se va regăsi sub forma următoare:

6

7

După același principiu se pot integra și alte tipuri de senzori specifici sistemelor de alarmă domestice ce funcționează în bandă radio ISM.

Bineînțeles, posibilitățile funcționale ale platformei OpenHab nu se limitează la această simplă aplicație dar sperăm că prezentarea acestui exemplu să trezească interesul pentru această platformă extrem de puternică. Câteva exemple de alte proiecte ce utilizează platforma OpenHab:

Building a Home Automation System with OpenHAB to Control LEDs Wirelessly

http://makezine.com/projects/building-a-home-automation-system-with-openhab-to-control-leds-wirelessly/

$20 Wireless Arduino Home Automation w/ OpenHAB

https://hackaday.io/project/1720-20-wireless-arduino-home-automation-w-openhab

Home automation using RF mesh network and arduino

https://hackaday.io/project/5691-home-automation-using-rf-mesh-network-and-arduino

Arduino openHAB Garage Door Control

https://hackaday.io/project/4027-arduino-openhab-garage-door-control

Hacking the Wink Hub to be more user-friendly for use with OpenHab and other home automation stacks

https://hackaday.io/project/4368-winkhub-integration

MQTT WiFi controlled mains halogen dimmer

https://hackaday.io/project/9093-mqtt-wifi-controlled-mains-halogen-dimmer

My openHAB Raspberry Pi Arduino XBee Led Zeppelin

https://hackaday.io/project/8487-my-openhab-raspberry-pi-arduino-xbee-led-zeppelin

A story of home automation with openHAB, Z-Wave, and MQTT

http://jpmens.net/2014/01/14/a-story-of-home-automation/

5 Open Source Home Automation Projects We Love

https://www.fastcompany.com/3038442/elasticity/5-open-source-home-automation-projects-we-love

Realizarea unui sistem de tip Home Automation (Partea a IV-a)

Instalarea și configurarea platformei OpenHab pe un sistem Raspberry Pi

 

Platforma OpenHab este compatibilă cu sistemele de operare Linux și poate fi instalată pe un sistem de tip Raspberry Pi. Avantajul instalării platformei OpenHab pe un dispozitiv integrat, precum Raspberry Pi, este înlocuirea unui sistem de calcul de uz general (desktop, server) ce consumă mai mult și are necesități specifice de funcționare (alimentare, climatizare, spațiu etc.).

1

Raspberry Pi 2 Model B

https://www.robofun.ro/raspberry-pi-si-componente/raspberry-pi-v2

 2

Raspberry Pi 3 Model B

https://www.robofun.ro/raspberry-pi-si-componente/raspberry-pi-v3

 

O altă posibilitate interesantă oferită de instalarea platformei OpenHab pe un sistem Raspberry Pi este construirea unui centru de control al unei case inteligente complet autonom adăugând plăcii de dezvoltare Raspberry Pi un ecran tactil – rezultatul va putea forma o consolă de comandă a întregii case.

3

Display 7” Raspberry Pi – Touch Screen Capacitive Touch

https://www.robofun.ro/raspberry-pi-si-componente/raspberry-pi-lcd/raspberry_pi_7_display_touch

 

Explicațiile următoare au fost testate pe o placă Raspberry Pi 2 Model B rulând Raspbian 4.1.17 cu toate update-urile la zi (java 1.8.0_65-b17) dar nu ar trebui să existe probleme cu modelul Raspberry Pi 3 Model B sau cu alte versiuni mai noi ale sistemului de operare Raspbian.

https://www.raspberrypi.org/downloads/raspbian/

Primul pas este importul cheii repositorului OpenHab:

wget -qO – ‘https://bintray.com/user/downloadSubjectPublicKey?username=openhab&#8217; | sudo apt-key add –

și adăugarea acestuia la lista de surse de instalare:

echo “deb http://dl.bintray.com/openhab/apt-repo stable main” | sudo tee /etc/apt/sources.list.d/openhab.list

Pentru a putea vedea pachetele de instalare vom face un update la lista de pachete:

sudo apt-get update

și vom instala nucleul platformei OpenHab:

sudo apt-get install openhab-runtime

Pentru pornirea/oprirea/repornirea platformei avem la dispoziție următoarele comenzi:

sudo systemctl start openhab

sudo systemctl stop openhab

sudo systemctl restart openhab

La rularea următoarei instrucțiuni ar trebui să vedem platforma OpenHab pornită:

ps axf

4

Pentru configurarea pornirii automate a platformei OpenHab vom da următoarele comenzi:

sudo systemctl daemon-reload

sudo systemctl enable openhab

Pentru instalarea de componente suplimentare (add-ons / bindings) vom utiliza comanda:

sudo apt-get install openhab-addon-${addon-type}-${addon-name}

de exemplu (pentru extensia NTP):

sudo apt-get install openhab-addon-binding-ntp

Pentru instalarea unor componente ce nu fac parte din platformă (precum componenta de legătură cu MySensors) vom naviga în directorul de instalare /usr/share/openhab/addons/ și vom copia manual componenta:

cd /usr/share/openhab/addons/

sudo wget http://bkl.linux.dk/org.openhab.binding.mysensors-1.8.0-SPANSHOT.jar

Pașii următori sunt similari cu pașii de configurare efectuați sub sistemul de operare Microsoft Windows.

Mergem în directorul de configurare a platformei /etc/openhab/configurations și redenumim fișierul openhab_default.cfg în openhab.cfg :

cd /etc/openhab/configurations/

sudo mv openhab_default.cfg openhab.cfg

Adăugăm la sfărșitul fișierului openhab.cfg:

################### MySensors ######################

mysensors:port=/dev/ttyUSB0

pentru un sistem gateway conectat pe portul USB (ttyUSB0) sau pentru un gateway ethernet:

################### MySensors ######################

mysensors:type=ethernet

mysensors:host=192.168.100.7

mysensors:port=5003

unde host este adresa IP a sistemului gateway.

În directorul /etc/openhab/configurations/sitemaps/ creăm fișierul casamea.sitemap cu următorul conținut (în cazul în care nu sunteți familiari cu editoare specifice mediului Linux gen vi puteți folosi mcedit – sudo mcedit casamea.sitemap):

sitemap casamea label=”Meniu Principal” {

    Frame label=”Senzori de temperatura”  {

                Text item=Temperature0 icon=”temperature”

                 Text item=Temperature1 icon=”temperature”

    }

    Frame label=”Lumina”  {

                Switch item=Relay icon=”switch”

    }

    Frame label=”Data calendaristica” {

                 Text item=Date icon=”calendar”

    }

}

Iar în directorul /etc/openhab/configurations/items/ creăm fișierul casamea.items cu următorul conținut:

Number            Temperature0      “Temperatura interioara [%s °C]”  

<temperature>   {mysensors=”10;0;V_TEMP”}

Number            Temperature1     “Temperatura exterioara [%s °C]”    

<temperature>   {mysensors=”10;1;V_TEMP”}

Switch            Relay             “Lampa”                           

    {mysensors=”20;0;V_STATUS”}

DateTime          Date              “Date [%1$tA, %1$td.%1$tm.%1$tY]” 

<calendar> 

Repornim platforma OpenHab:

sudo systemctl restart openhab

și putem accesa interfața definită la adresa:

http://192.168.100.9:8080/openhab.app?sitemap=casamea

unde 192.168.100.9 este adresa sistemului pe care s-a efectuat instalarea dacă se accesează după un alt sistem .

5

sau dacă se accesează din interfața locală (de pe ecranul tactil al sistemului):

6

http://localhost:8080/openhab.app?sitemap=casamea

Sistemul este instalat și configurat și poate fi folosit de sine stătător sau ca server pentru alți clienți (sisteme desktop, telefoane mobile sau tablete).

 

Configurarea de operații automate – automatizarea platformei OpenHab

 

Cel mai simplu mod de a defini operații automate este definirea de scripturi (Scripts). Să presupunem că sistemul de acționare construit în lecția anterioară nu comandă un bec ci un ventilator pe care dorim să îl pornim când temperatura interioară depășește o anumită valoare. Vom crea în directorul /etc/openhab/configurations/scripts/ un fișier casamea.script cu următorul conținut:

if (Temperature0.state > 30) {

    sendCommand(Relay,ON)

}

Pentru a rula acest script este necesar să definim un fișier de reguli (Rules). În directorul /etc/openhab/configurations/rules/ creăm fișierul casamea.rules cu următorul conținut:

rule overheat

when

    Item Temperature0 changed

then

    callScript(“casamea”)

end

Astfel la fiecare modificare de temperatură trimisă de senzorul interior de temperatură se va executa scriptul definit anterior ce va verifica dacă temperatura a depășit pragul de 30 de grade Celsius și în caz afirmativ va trimite comandă de deschidere către elementul de acționare de tip releu.

Ca acțiuni în cadrul unei reguli se mai pot defini, pe lângă scripturi, și acțiuni (Actions) – programe scrise în Java și care pot fi apelate din fișierele de reguli și chiar din fișierele de scripturi.

Pentru mai multe detalii legate de funcționarea mecanismelor de automatizare în platforma OpenHab puteți consulta:

Automation · openhab/openhab Wiki

https://github.com/openhab/openhab/wiki/Automation

Un instrument important în configurarea platformei OpenHab îl reprezintă openHAB Designer – program ce permite editarea centralizată a fișierelor de configurare ale unui site OpenHab. Există versiuni atât pentru sistemul de operare Microsoft Windows cât și pentru OS X și Linux.

http://www.openhab.org/getting-started/downloads.html

7

O facilitate extrem de ”prețioasă” a acestui program este partea de ”autocomplete” și verificare sintactică în partea de scriere a fișierelor de configurare și a fișierelor de acțiuni automate.

Realizarea unui sistem de tip Home Automation (Partea a III-a)

Instalarea și configurarea platformei OpenHab pe un sistem Microsoft Windows

Platforma OpenHab este un produs open-source de tip Home Automation, dezvoltat în Java, compatibil cu majoritatea sistemelor de operare actuale: Microsoft Windows, Linux, OS X. OpenHab permite monitorizarea și controlul centralizat ale tuturor echipamentelor inteligente din locuință (senzori, echipamente anti-efracție, sisteme de acționare, sisteme multimedia, sisteme de climatizare) fiind independent de un standard proprietar de comunicație sau de un anume tip de dispozitiv.

1http://www.openhab.org/

În cadrul proiectului de față vom exemplifica conectarea cu o rețea de elemente MySensors.

Interfața utilizator a platformei este disponibilă în format web dar și sub forma de aplicații native Android și iOs.

2

Instalarea sub platforma Microsoft Windows necesită instalarea prealabilă a mediului de execuție Java:

http://java.com

după care se copiază ultima versiune (stabilă de preferat) a OpenHab Runtime Core:

http://www.openhab.org/getting-started/downloads.html

se dezarhivează în rădăcina unuia dintre drive-urile sistemului de calcul (de exemplu C:\) sub directorul openhab (de exemplu C:\openhab). Instalarea este gata, urmează partea de configurare. Este posibilă copierea unui set de configurații demo (Demo setup – conține un set complet de configurații ca exemplu) dar este recomandată configurarea treptată de la zero.

Acești pași de instalare și configurare au fost testați pe un sistem desktop Microsoft Windows 10 x64 având instalat pachetul Oracle Java 8 Update 101 și utilizând versiunea OpenHab 1.8.3.

Primul pas de configurare presupune ca în subdirectorul configurations se redenumește fișierul openhab_default.cfg în openhab.cfg . Acest fișier conține toate setările serviciului OpenHab. Pentru a funcționa în conjuncție cu o rețea MySensors se adaugă la sfârșitul fișierului o secțiune nouă:

################### MySensors ######################

mysensors:port=COMXX

pentru funcționarea în conjuncție cu un gateway serial (unde COMXX este portul pe care este conectat gateway-ul serial) sau:

################### MySensors ######################

mysensors:type=ethernet

mysensors:host=192.168.100.7

mysensors:port=5003

pentru un gateway ethernet (unde host este adresa IP a sistemului gateway).

Comunicația între platforma OpenHab și protocolul serial specific rețelei MySensors este asigurată de o componentă software de legătură (binding add-on) ce trebuie copiată în subdirectorul addons al instalării de la adresa:

http://bkl.linux.dk/org.openhab.binding.mysensors-1.8.0-SNAPSHOT.jar

Există o colecție implicită de astfel de componente software ce fac legătura cu diverse alte sisteme. Ea se copiază de la aceiași adresă ca și Runtime Core – componenta Addons. Nu este recomandată copierea tuturor componentelor în subdirectorul instalării efectuate anterior deoarece o colecție mare de componente încărcate la pornirea platformei OpenHab îngreunează funcționarea. Pentru început vom copia doar org.openhab.binding.ntp-1.8.3.jar – componentă ce ne va permite afișarea orei și datei preluate de un server NTP.

Următorul pas este realizarea fișierului de configurație al ”centrului de comandă” pe care dorim să îl creăm. În subdirectorul configurations\sitemaps creăm un fișier casamea.sitemap (unde casamea poate fi înlocuit cu ce denumire dorim). Cu ajutorul unui editor text decent (se recomandă Notepad++) se editează acest fișier și se completează:

sitemap casamea label=”Meniu Principal” {

    Frame label=”Senzori de temperatura”  {

            Text item=Temperature0 icon=”temperature”

             Text item=Temperature1 icon=”temperature”

    }

    Frame label=”Data calendaristica” {

             Text item=Date icon=”calendar”

     }

}

Interfața creată în cadrul acestui fișier de configurare va avea două secțiuni: Senzori de temperatura (în care vom afișa datele primite de la cei doi senzori ai sistemului construit în lecția anterioară) și Data calendaristica (în care vom afișa data). Pentru a putea afișa aceste informații trebuie să creăm un fișier casamea.items în subdirectorul configurations\items ce va conține următoarele definiții:

Number  Temperature0    “Temperatura interioara [%s °C]”     

{mysensors=”10;0;V_TEMP”}

Number  Temperature1     “Temperatura exterioara [%s °C]”     

{mysensors=”10;1;V_TEMP”}

DateTime    Date              “Date [%1$tA, %1$td.%1$tm.%1$tY]”                                                    {ntp=”Europe/Bucharest:ro_RO”}

În acest moment sistemul este gata de utilizare. Se pornește platforma utilizând fișierul start.bat din directorul de instalare. Se va deschide o fereastră de forma:

3

Pentru ca platforma OpenHab să pornească automat la pornirea sistemului trebuie copiat un shortcut al fișierului start.bat în directorul startup al utilizatorului dorit sau se poate defini un scheduled task.

Accesarea interfeței OpenHab se face dintr-un browser web accesând pagina:

http://192.168.100.2:8080/openhab.app?sitemap=casamea

unde 192.168.100.2 este adresa sistemului pe care s-a efectuat instalarea sau

http://localhost:8080/openhab.app?sitemap=casamea

dacă se accesează de pe același sistem. Captură de ecran cu fereastra de browser:

4

Alternativ interfața se poate accesa prin intermediul unei aplicații mobile Android sau iOs configurând adresa platformei OpenHab în aplicație. Capturi de ecran cu setarea aplicației Android și cu interfața ”Meniu Principal”:

5

6

 

Construirea și integrarea unui element de acționare

Explicațiile de până în acest moment au arătat cum se poate integra un element de achiziție format din doi senzori de temperatură cu platforma OpenHab. Vom continua cu construirea și integrarea unui element de acționare bazat pe un releu ce acționează un bec de 12V (o lampă de birou). Pentru acest lucru vom conecta la sistemul de bază (Arduino Uno  + SparkFun Transceiver Breakout – nRF24L01+) o placă releu SPDT 5VDC. Conexiunea între placa de dezvoltare și placa releu se va realiza prin intermediul pinului digital D3 al plăcii de dezvoltare conectat la pinul EN al plăcii releu.

7

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

Schema sistemului va arăta precum în diagrama următoare:

8

Atenție, placa releu nu este proiectată pentru tensiuni mari – utilizarea la tensiuni mai mari de 12V este extrem de periculoasă!

Programul va utiliza biblioteca MySensors 2.0.0:

#define MY_DEBUG

#define MY_RADIO_NRF24

#define MY_REPEATER_FEATURE

#define MY_NODE_ID 20

#define MY_BAUD_RATE  9600

 #include

#include

Exemplul este gândit pentru a funcționa cu un număr mai mare de relee (număr limitat doar de numărul de pini digitali ai plăcii de dezvoltare). Se pot conecta mai multe relee pe următori pini digitali D4, D5…, D8.

#define RELAY_1  3

#define NUMBER_OF_RELAYS 1

#define RELAY_ON 1

#define RELAY_OFF 0

Secțiunea before() este specifică bibliotecii MySensors 2.0.0 și se execută înainte inițializarea mecanismelor interne bibliotecii. În cadrul acestei secțiuni se vor inițializa pinii digitali ca ieșiri de comandă și se va restaura starea precedentă a pinilor – salvată în memoria EEPROM în secțiunea receive() – mecanism util în cazul unor reporniri neprogramate ale elementului de acționare.

void before() {

for (int sensor=0, pin=RELAY_1; sensor<NUMBER_OF_RELAYS; sensor++, pin++) {

pinMode(pin, OUTPUT);

digitalWrite(pin,

loadState(sensor)?RELAY_ON:RELAY_OFF); }

}

În cadrul secțiunii presentation() (specifică bibliotecii, se realizează prezentarea elementului de acționare către sistemul gateway) se va transmite numele, versiunea și funcționalitatea elementului de acționare.

void presentation()  {

sendSketchInfo(“Relay”, “1.0”);

for (int sensor=1, pin=RELAY_1;

sensor<=NUMBER_OF_RELAYS; sensor++, pin++) {

present(sensor, S_LIGHT);  }    }

Secțiunile setup() și loop(), tipice pentru program Arduino, nu conțin nici o instrucțiune. Întregul mecanism de control al releului se realizează în secțiunea receive() – secțiune apelată în mod automat de mecanismele interne ale bibliotecii MySensors la primirea unui mesaj radio.

void setup() {

}

void loop() {

}

void receive(const MyMessage &message) {

if (message.type==V_STATUS) {

digitalWrite(message.sensor+RELAY_1,

message.getBool()?RELAY_ON:RELAY_OFF);

saveState(message.sensor, message.getBool());

Serial.print(“Incoming change for sensor:”);

Serial.print(message.sensor);

Serial.print(“, New status: “);

Serial.println(message.getBool());

}

}

Integrarea noului sistem în cadrul platformei OpenHab presupune următoarele completări în fișierele de configurare:

9

  • în fișierul items vom adăuga:

Switch   Relay    “Lampa”  {mysensors=”20;0;V_STATUS”}

  • în fișierul sitemap vom adăuga:

Frame label=”Lumina”  {

Switch item=Relay icon=”switch”

}

În urma acestor modificări interfața de comandă a rețelei MySensors va arăta:

10

Realizarea unui sistem de tip Home Automation (Partea a II-a)

Unul dintre cele mai comune sisteme de măsurare este cel de măsurare a temperaturii. El este utilizat atât din considerente de evaluare a confortului personal (temperatura din locuință) cât și din considerente legate de funcționare a sistemului de climatizare sau considerente legate de supravegherea funcționării altor echipamente electronice – avertizare în caz de supra încălzire. În cadrul acestei proiect vom implementa un sistem de măsurare a temperaturii cu mai multe zone utilizând senzorul digital de temperatură DS18B20 produs de Maxim Integrated:

1

https://datasheets.maximintegrated.com/en/ds/DS18B20.pdf

https://www.robofun.ro/senzori/vreme/senzor-temperatura-DS18B20

Acest senzor are o plajă de măsurare de -55°C / +125°C și o acuratețe de 0.5°C. Pentru interconectarea cu placa de dezvoltare acest senzor utilizează protocolul 1-Wire:

https://www.maximintegrated.com/en/products/digital/one-wire.html

permițând încascadarea mai multor senzori pe aceiași linie de comunicație – lucru ce facilitează implementarea funcționalității de măsurare a temperaturii în mai multe zone.

Deoarece magistrala de comunicație necesită o rezistență de pull-up, primul senzor din rețea va fi de tip brick, modul ce include rezistența necesară funcționării corecte a comunicației.

2

https://www.robofun.ro/senzori/vreme/senzor-temperatura-inlantuibil-brick-DS18B20-motherboard

Soluția bazată pe comunicația 1-Wire a fost aleasă pentru distanța mare la care pot fi plasați senzorii față de placa de dezvoltare (aproximativ 200 de metri) și a unui număr mare de senzori care pot fi conectați simultan (având în vedere faptul că fiecare senzor are o adresă proprie din fabricație pe 64 de biți nu există o limitare de protocol privind numărul de senzori dintr-o rețea). A se vedea și:

Guidelines for Reliable Long Line 1-Wire Networks

http://www.maximintegrated.com/en/app-notes/index.mvp/id/148

Prin intermediul rețelei de senzori DS18B20 proiectul va putea monitoriza din punct de vedere al măsurării temperaturii un număr nelimitat de zone. Conectarea cu placa de dezvoltare implică conectarea componentei brick în felul următor: pinul GND al modulului la unul din pinii de GND ai plăcii de dezvoltare, pinul 5V la unul din pinii de 5V ai plăcii de dezvoltare și pinul DQ al modulului la pinul D3 al plăcii de dezvoltare. Următorii senzori atașați în rețea se vor conecta la modulul brick prin intermediul conectorului cu șurub respectând semnificația pinilor.

3

Schema sistemului (diagramă anterioară) se bazează pe schema din proiectul precedent (Arduino Uno + SparkFun Transceiver Breakout – nRF24L01+) dar, dacă se dorește realizarea unui sistem portabil alimentat de la baterii, se poate înlocui placa de dezvoltarea Arduino Uno cu o una din variantele mai mici ca dimensiuni: Arduino Pro Mini 5V sau 3.3V:

https://www.robofun.ro/platforme/arduino_dev/arduino_pro_mini_328_8mhz

https://www.robofun.ro/platforme/arduino_dev/arduino_pro_mini_328_16mhz

Programul sistemului utilizează bibliotecile MySensors 2.0.0, OneWire 2.3.2 și DallasTemperature 3.7.6:

https://github.com/mysensors/MySensors/tree/master

https://github.com/PaulStoffregen/OneWire

https://github.com/milesburton/Arduino-Temperature-Control-Library

Inițializările necesare comunicației radio se fac înainte de includerea bibliotecii MySensors deoarece biblioteca conține instanțierea obiectelor de lucru:

#define MY_DEBUG

#define MY_RADIO_NRF24

#define MY_NODE_ID 10

#define MY_BAUD_RATE  9600

#include

#include

#define SKETCH_NAME “Temperature Sensors”

#define SKETCH_VERSION “v0.1”

#define LONG_WAIT 500

#define SHORT_WAIT 50

unsigned long SLEEP_TIME = 900000;

boolean metric = true;

MyMessage msg_S_TEMP(0,V_TEMP);

#define ONE_WIRE_BUS 3

#define MAX_ATTACHED_DS18B20 10

OneWire oneWire(ONE_WIRE_BUS);

DallasTemperature sensors(&oneWire);

int numSensors=0;

În cadrul secțiunii setup() se va realiza inițializarea comunicației OneWire:

void setup() {

  sensors.begin();

  wait(LONG_WAIT);

}

Secțiunea presentation() este specifică bibliotecii MySensors și conține partea de inițializare a comunicației radio cu sistemul gateway (prezentare denumire și versiune sistem, solicitare metrică gateway, prezentare senzori atașați sistemului):

void presentation()  {

  Serial.print(“Send Sketch Info: “);

  sendSketchInfo(SKETCH_NAME, SKETCH_VERSION);

  Serial.print(SKETCH_NAME);

  Serial.println(SKETCH_VERSION);

  wait(LONG_WAIT);

  Serial.print(“Get Config: “);

  metric = getConfig().isMetric;

  Serial.println(metric ? “Metric”:”Imperial”);

  wait(LONG_WAIT);

  Serial.println(“Presenting Nodes”);

  Serial.println(“________________”);

  Serial.println(”  S_TEMP”);

  numSensors = sensors.getDeviceCount();

  for (int i=0; i

i++) {  

    char sensorname[9];

    sprintf(sensorname,”Sensor %i”,i);

    present(i,S_TEMP, sensorname);

    wait(SHORT_WAIT);

  }

  Serial.println(“________________”);

}

În cadrul secțiunii loop() se va realiza citirea senzorilor de temperatură atașați sistemului și se va transmite radio către sistemul gateway a valorilor măsurate:

void loop() {

  sensors.requestTemperatures();

  wait(SHORT_WAIT);

    for (int i=0; i

i++) {

    float temperature = static_cast

(static_cast((getConfig().isMetric?sensors.get TempCByIndex(i):sensors.getTempFByIndex(i)) * 10.))/10.;

    send(msg_S_TEMP.setSensor(i).set(temperature,1));

  }

  sleep(SLEEP_TIME); }

La începutul programului se pot observa directivele ce influențează în mod esențial funcționarea comunicației radio și a mecanismelor interne ale bibliotecii MySensors:

#define MY_DEBUG – permite vizualizarea pe consola serială a mesajelor de depanare;

#define MY_RADIO_NRF24 – indică utilizarea modulelor radio nRF24L01;

#define MY_NODE_ID 10 – stabilește adresa sistemului (Node ID);

#define MY_BAUD_RATE  9600 – stabilește viteza de comunicație serială, în cadrul programului nu este necesară inițializarea comunicației seriale prin instrucțiunea Serial.begin(…).

Este interesantă testarea directivei:

#define MY_RF24_ENABLE_ENCRYPTION

ce permite cifrarea comunicației între nodurile rețelei radio – trebuie inclusă și în sursa program a sistemului gateway.

Comunicația între sistemul de măsurare și sistemul gateway poate fi examinată cu ajutorul aplicație MYSController. Sistemul de măsurare testat avea instalați doi senzori de temperatură ce pot fi observați ca elemente înregistrate distinct (0 – Sensor 0, 1 – Sensor 1) aparținând nodului 10 – Temperature Sensors v0.1.

4

Pentru o listă completă a mecanismelor de configurare ale bibliotecii MySensors se poate consulta:

MySensors Arduino Library (v2.0.x)

https://www.mysensors.org/download/sensor_api_20

Pentru mai multe exemple de sisteme de achiziție și acționare compatibile cu platforma MySensors se poate consulta secțiunea Build a paginii MySensors:

https://www.mysensors.org/build/

sau secțiunea MySensors în cadrul platformei OpenHardware:

https://www.openhardware.io/explore?search=MySensors

Realizarea unui sistem gateway ethernet – Sistemul gateway prezentat în proiectul anterior, sistem gateway serial, prezintă dezavantajul necesității conectării directe (prin cablu USB) la un sistem de calcul ce rulează o aplicație de interpretare a mesajelor sau, cum vom vedea în lecțiile viitoare, o aplicație specializată de tip Home Automation. Biblioteca MySensors pune la dispoziție și o altă modalitate de retransmisie a mesajelor radio către un sistem de calcul prin intermediul unei rețele ethernet.

Există două exemple în biblioteca MySensors ce pot fi utilizate în acest sens:

GatewayW5100 – implementează un sistem gateway de retransmisie ethernet a mesajelor radio bazat pe elemente hardware ce utilizează controlerul ethernet Wiznet 5100 precum shield-ul Arduino Ethernet Shield sau placa Arduino Ethernet.

GatewayESP8266 – implementează un sistem gateway de retransmisie ethernet WiFi utilizând placa de dezvoltare NodeMCU bazată pe controlerul WiFi ESP8266 – soluție exemplificată în cele ce urmează.

5

https://www.robofun.ro/wireless/wireless-wifi/NodeMCUv2-ESP8266

Interconectarea între placa de dezvoltare NodeMCU și SparkFun Transceiver Breakout – nRF24L01+ este ilustrată în diagrama următoare:

6

Conexiunile dintre cele două componente sunt: VCC – 3v3, CE – D2, CSN – D8, SCK – D5, MOSI – D7, MISO – D6 și GND – GND.

Sistemul GatewayESP8266 poate fi utilizat atât ca și gateway serial cât și ca gateway ethernet WiFi– ambele configurații pot fi utilizate în configurarea comunicației cu sistemul de calcul de control – avantajul utilizării variantei ethernet WiFi este decuplarea fizică a sistemului gateway de sistemul de control.

7

Realizarea unui sistem de tip Home Automation (Partea I)

Prin noțiunea de Home Automation se înțelege implementarea unui sistem de automatizare și control centralizat al echipamentelor electronice de automatizare dintr-o locuință. Automatizarea presupune două aspecte importante: monitorizarea și comanda automată. Monitorizarea se realizează prin intermediul unor echipamente electronice de tip senzori și traductoare ce pot măsura diverși parametrii specifici ambientului din locuință (temperatură, umiditate, luminozitate, calitate aer) sau diverși parametrii de funcționare a echipamentelor electronice (consum electric, stare pornit / oprit, căldură degajată, presiune sau debit apă etc.). Partea de comandă presupune capacitatea sistemului de a reacționa și de a interacționa cu echipamentele electronice și electrocasnice (aparate de climatizare, sisteme de securitate, sisteme multimedia, sisteme de alimentare cu energie electrică) prin intermediul unor elemente de acționare. Conexiunea dintre parametrii măsurați și comenzile automate se face prin intermediul unui sistem de comandă centralizat care poate acționa la comanda manuală a utilizatorului sau poate avea comportamente de comandă predefinite (dacă temperatura în cameră depășește 35 de grade Celsius pornește aerul condiționat).

Astfel, arhitectura unui sistem de tip Home Automation implică următoarele subsisteme:

  • Elemente de achiziție de tip senzori (sensors);
  • Elemente de acționare (actuators);
  • Sistem central de comandă (controller);

Legătura dintre elementele de achiziție, elementele de acționare și sistemul de comandă implică o rețea de comunicație. La momentul actual majoritatea sistemelor utilizează o rețea de comunicație fără fir datorită comodității de instalare și operare. Există mai multe produse comerciale ce oferă soluții complete de Home Automation dar acestea sunt incompatibile între ele (nu se poate folosi un senzor de tipul X cu un sistem de comandă de tipul Y) și au un cost destul de ridicat.

Exemple de soluții comerciale de Home Automation:

Insteon

http://www.insteon.com/

Z-Wave Home control | Z-Wave Smart Home

http://www.z-wave.com/

Nest

https://nest.com/

 

În cadrul ”Realizarea unui sistem de tip Home Automation” vom prezenta o alternativă la soluțiile comerciale utilizând doar elemente open-source (atât hardware cât și software) care asigură un cost mult mai scăzut și o inter-operabilitate mult mai bună cu sisteme similare (open-source sau comerciale).

În cadrul materialului de față vom prezenta o soluție de rețea de interconectare fără fir pentru elementele de achiziție bazată pe platforma MySensors:

https://www.mysensors.org/

1

Platforma MySensors este un proiect open-source bazat pe hardware și software compatibil Arduino ce își propune să ofere o soluție completă pentru realizarea de la zero a elementelor de achiziție, a elementelor de acționare și a rețelei radio fără fir între elementele acestea și un element central de comandă. Proiectul nu include partea software de comandă centralizată dar este compatibil cu alte proiecte open-source ce implementează această parte: OpenHab (pe care îl vom prezenta într-un material viitor), MyController.org, MyNodes.NET etc.

Proiectul poate utiliza pentru transmisia radio fără fir două tipuri de module radio (cele două tipuri de module nu pot fi mixate în aceiași rețea):

Module radio bazate pe circuitul nRF24L01+ de la Nordic Semiconductors în bandă ISM de 2.4GHz modulație GFSK – aceste module vor fi utilizate în cadrul implementării de față.

2 https://www.robofun.ro/wireless/wireless-2-4/transceiver_nRF24L01_antena

 

Module radio bazate pe circuitul RFM69HCW de la HopeRF Electronics în bandă ISM de 433MHz sau 868MHz modulație FSK/GFSK/MSK/GMSK/OOK.

3

https://www.robofun.ro/wireless/wireless-433/sparkfun-rfm69-breakout-434mhz-

 

Pentru implementarea soluție de rețea fără fir vom avea nevoie de două plăci Arduino Uno sau similare și două module radio nRF24L01+. Ca și plăci de dezvoltare putem utiliza orice variantă de placă Arduino Uno:

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

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

https://www.robofun.ro/platforme/arduino_dev/arduino-industrial

 

Conexiunea dintre modulul radio și placa de dezvoltare se realizează prin magistrala SPI și presupune următoarele conexiuni: Vcc – 5V, CE – D9, CSN – D10, SCK – D13, MOSI – D11, MISO – D12, GND – GND.

 

4

 

După realizarea celor două montaje vom trece la programarea acestora. Vom folosi Arduino IDE 1.6.9 împreună cu biblioteca software MySensors 2.0.0 (ultima versiune apărută pe 9 iulie 2016).

https://github.com/mysensors/MySensors/tree/master

 

Din cadrul librăriei vom utiliza două exemple pe care le vom încărca pe cele două montaje realizate: MockMySensors și GatewaySerial.

 

MockMySensors – este un exemplu ce simulează toate tipurile de senzori și elemente de acționare definite în cadrul bibliotecii; îl vom utiliza pentru testarea comunicației radio și pentru înțelegerea modului de funcționare a instrumentelor puse la dispoziție de aceasta. Acest exemplu este un bun punct de plecare în implementarea oricărui tip de element de măsurare sau de acționare. Execuția sa (cu directiva #define MY_DEBUG comentată) va avea următorul efect în consola serială:

5

Comportamentul implicit al exemplului este mixt: senzor de ușă – S_DOOR  (open/closed) și element de acționare încuietoare – S_ARMED (armed/disarmed). Operațiile efectuate de sistem sunt următoarele: INIȚIALIZARE COMUNICAȚIE: trimite numele și versiunea de sistem (MockMySensors v0.5) către sistemul gateway, solicită configurația metrologică: metrică sau imperială, prezintă către sistemul gateway facilitățile în nodul de comunicație (S_DOOR, S_ARMED); TRANSMITERE/RECEPȚIONARE PERIODICĂ INFORMAȚII: trimite nivelul bateriei (generat aleatoriu), solicită timpul de la sistemul gateway, trimite starea ușii și a sistemului de închidere.

GatewaySerial – este un exemplu ce permite transformarea mesajelor radio în mesaje pe interfața serială (USB); îl vom utiliza pentru a testarea comunicației radio și pentru conectarea ulterioară la un sistem de comandă centralizat. Execuția sa (cu directiva #define MY_DEBUG comentată) va avea următorul efect în consola serială:

6

Informațiile afișate în consola serială a sistemului gateway respectă următorul format de mesaj:

adresă nod; adresă senzor; tip mesaj; confirmare; subtip mesaj; mesaj \n

Astfel primul mesaj:

0;255;3;0;14;Gateway startup  complete.

provine de la sistemul gateway (adresă 0), subsistem broadcast (255) – mesaj către toată rețeaua; este un mesaj de tip intern (3) subtip I_GATEWAY_READY (14); nu se solicită confirmare de primire(0); mesaj: Gateway startup complete.

Un mesaj provenit de la sistemul MockMySensor este de exemplu:

254;1;1;0;15;1

unde adresa sistemului este 254, senzor intern 1 – ușă; mesaj de informare asupra valorii unui sensor (1) subtip V_ARMED (15), fără confirmare de primire (0), mesaj: 1 – adică încuietoare închisă.

Pentru mai multe informații legate de formatul mesajelor puteți consulta:

MySensors Serial Protocol (2.0)

https://www.mysensors.org/download/serial_api_20

 

Bineînțeles, aceste mesaje nu sunt concepute pentru a fi citite și interpretate de utilizator. Cea mai simplă modalitate de interpretare, în lipsa unui sistem de comandă centralizată, este utilizarea software-ului MYSController:

Windows GUI/Controller for MySensors

https://forum.mysensors.org/topic/838/windows-gui-controller-for-mysensors/2

Acesta este gratuit, rulează sub sisteme de operare Microsoft Windows și nu necesită instalare. Primul pas în utilizarea acestui program este identificarea legăturii cu sistemul gateway. Din meniul Settings / Gateway se va selecta Serial și numărul portului serial pe care este conectată placa Arduino ce rulează exemplul GatewaySerial.

7

După configurare se va da comanda de Connect și în interfața aplicației se vor putea observa mesajele radio primite / transmise de sistemul gateway într-o formă mult mai ușor de înțeles și urmărit. Captura de ecran din pagina următoare prezintă aceiași succesiune de mesaje ca și captura serială a sistemului gateway din pagina anterioară. Se poate observa că pe lângă zona de ”decodificare” a mesajelor, interfața aplicației mai oferă și o listă a tuturor nodurilor (sistemelor) din rețea precum și o topologie a rețelei (indică dacă conexiunea este directă între nodul de achiziție și nodul gateway sau mesajul a fost retransmis prin intermediul altor noduri). Aplicația mai permite și transmiterea de mesaje către noduri de achiziție / acționare (partea de jos a interfeței) – în cazul exemplului nostru se poate selecta elementul de acționare 1 – Outside Door și completa ca Subtype: V_ARMED și ca Payload: 0 (Unarmed). După comanda de Send se va putea observa o succesiune de 3 mesaje: mesajul de comandă către nodul de acționare (Mode: TX, Node: 254 – MockMySensor) și 2 mesaje ce raportează starea actuală a celor două subsisteme ale nodului (Mode: RX, Node: 254 – MockMySensor, Subtype: V_TRIPPED – status ușă și V_ARMED: status încuietoare):

8

9

 

Pe baza exemplului MockMySensors se pot experimenta și alte tipuri de senzori și elemente de acționare specifice bibliotecii MySensors. Acest lucru se poate realiza comentând în sursa exemplului cele două funcționalități implicite (S_ARMED și S_DOOR) și decomentând alte funcționalități (S_MOTION, S_SMOKE, S_LIGHT etc.).

#define ID_S_ARMED             0 

#define ID_S_DOOR              1

//#define ID_S_MOTION          2

//#define ID_S_SMOKE           3

//#define ID_S_LIGHT           4