Jak podłączyć dom do chmury, czyli Domoticz i Arduino

dodał 30 września 2019 o 07:10 w kategorii HowTo  z tagami: • • • •
Jak podłączyć dom do chmury, czyli Domoticz i Arduino

Jak sterować swoim domem? Poniżej znajdziecie instrukcję wdrożenia krok po kroku własnego rozwiązania ,,inteligentnego domu” sterowanego z chmury – z wykorzystaniem instancji Aruba Cloud oraz platform Domoticz i Arduino.

Komputery otaczają nas wszędzie. W naszym codziennym życiu praktycznie na każdym kroku zderzamy się z ,,inteligentną elektroniką”. Od dziesiątek lat przedmioty codziennego użytku są wyposażane w mikrokomputery. To, co jednak spowodowało, że na nowo zaczęliśmy definiować ich możliwości, to fakt masowego podłączania przedmiotów codziennego użytku do ogólnodostępnej sieci Internet. Generalizując, możemy wręcz powiedzieć, że do chmury podłączane są już całe domy. Bierzmy się zatem do roboty!

Nowa przygoda z mikrokontrolerami, czyli ,,Arduino Starter Kit”

Arduino jest otwartą platformą programistyczną dla gotowego systemu wbudowanego o tej samej nazwie, ale występującego w różnych wersjach. Najpopularniejszą z nich jest odmiana UNO, aktualnie na rynku dostępna jest już trzecia jej rewizja, bazująca na 8-bitowym mikrokontrolerze Atmel AVR (Automatic Voltage Regulator) – ATMega 328P. Układ ten posiada 32 KB pamięci flash, 2 KB pamięci SRAM i 1 KB pamięć EEPROM. Arduino UNO to gotowa płytka drukowana i w cenie około 20 € poza samym mikrokontrolerem otrzymujemy:

  • 14 złączy wejścia/wyjścia (cyfrowych),
  • możliwość wykorzystania do 6 złączy wejścia/wyjścia (z 14 cyfrowych) jako kanały PWM (Pulse Width Modulation),
  • 6 wejść analogowych,
  • obsługa magistrali komunikacyjnych: USART, I2C, SPI.

Z wykorzystaniem magistrali komunikacyjnych możemy zarówno sterować zewnętrznymi układami (wyświetlacz LCD na magistrali I2C), jak i odbierać/wysyłać dane do komputera.

W realiach świata IoT najbardziej optymalnym rozwiązaniem jest realizowanie komunikacji w oparciu o transmisję bezprzewodową. Najczęściej spotykanym rozwiązaniem jest wykorzystanie częstotliwości 433 MHz, powszechnie używanej w różnego rodzaju rozwiązaniach takich jak: czujniki parametrów środowiskowych (stacje pogody / termometry bezprzewodowe), systemy zdalnego sterowania (piloty do bram, zabawki), systemy przemysłowe (transmisja szeregowa). Zaletą komunikacji wykorzystującej tę częstotliwość jest większy niż w przypadku pasm 2.4/5 GHz zasięg działania i lepsza odporność na zakłócenia. Jest to możliwe dzięki stosunkowo wąskiemu kanałowi komunikacyjnemu (25 kHz), przez co przepustowość transmisji danych jest znacznie ograniczona. Przez wzgląd na to, że powszechne w użyciu zarówno w środowiskach domowych, jak i przemysłowych, są sieci WLAN, rozwiązania IoT są coraz częściej wyposażane w odpowiednie moduły Wi-Fi. Dla każdego początkującego, chcącego zgłębić tajniki mikrokontrolerów i myślącego o zbudowaniu własnego rozwiązania ,,Internetu Rzeczy”, polecamy gotowe zestawy startowe. Są wyposażone we wszystko, co jest na początku potrzebne do zbudowania własnego prostego rozwiązania. Dla potrzeb niniejszego artykułu zbudowaliśmy jeden z takich układów – system kontroli dostępu RFID sterujący elektrozamkiem (sterowanie silnikiem krokowym). Z efektem końcowym prac tego układu możecie zaznajomić się na poniższym wideo:

Zbudowanie i zaprogramowanie całego układu zajęło nam nie więcej niż 20 minut, przy czym skorzystaliśmy tutaj z gotowego, ogólnodostępnego kodu takiego rozwiązania pobranego z GitHuba, przerabiając go tylko nieznacznie na własne potrzeby.

Oczywiście na sam początek sugerujemy zacząć od prostych rozwiązań, takich jak np. czujnik temperatury czy czujnik ruchu / dźwięku. Zbudowanie takiego układu stanowi też bardzo dobry początek dla tych z Was, którzy myślą o uczynieniu swojego domu / mieszkania coraz bardziej ,,inteligentnym”.

Domoticz

Domoticz stanowi otwartą, uniwersalną i otartoźródłową platformę do zarządzania funkcjami inteligentnego domu. W zależności od potrzeb i posiadanych rozwiązań, może być uruchomiony na platformach Linux (x86/x86_64), Windows czy ARM (x32/x64). Jeśli posiadamy już gotowe rozwiązanie działające w oparciu o Arduino, teraz najistotniejszą kwestią jest zbieranie z niego danych i zapewnienie bezpiecznego dostępu do nich – bez względu na naszą (jako użytkownika systemu) lokalizację. Sam Domoticz może działać np. na naszym Raspberry Pi – w takim wypadku musimy zapewnić dla niego bezpieczny dostęp do zarządzania. Bardzo często nie jest to zadanie łatwe, zwłaszcza w przypadku domów zlokalizowanych w oddaleniu od dużych miast. Zazwyczaj wtedy pozostaje nam możliwość wykorzystania łącza radiowego lub usługi transmisji danych zapewnianej przez operatora komórkowego. W przypadku planów i taryf dla użytkowników domowych uzyskanie własnego publicznego adresu IP czy też możliwość realizacji połączeń ,,ze świata” nie jest po prostu możliwe.

W takim wypadku Arduino możemy doposażyć w moduł sieciowy – Ethernet (bezpieczniej i stabilniej) lub WLAN (np. Arduino WiFi Shield), a następnie wysyłać wszystkie informacje do naszego serwera Domoticz zlokalizowanego w chmurze. Oczywiście w takim wypadku zachęcamy do zabezpieczenia połączenia z wykorzystaniem bezpiecznego tunelu VPN.

W dalszej części artykułu skupimy się właśnie na takim scenariuszu i zainstalujemy oraz skonfigurujemy pakiet Domoticz w ramach systemu CentOS jako instancji Aruba Cloud VPS. Jeżeli jeszcze takiego serwera nie posiadacie i go nie wdrażaliście, to – jak zawsze – odsyłamy do naszych poprzednich artykułów.

Ponadto – co zakładamy w naszym scenariuszu – komunikację pomiędzy siecią LAN (gdzie znajduje się Arduino) a serwerem Aruba realizujemy w oparciu o tunel IPSec VPN. Co prawda, sam panel Domoticza możemy uruchomić na protokole HTTPS, to jednak dane będziemy przesyłać z wykorzystaniem protokołu HTTP. Po podłączeniu do świeżo wdrożonej instancji Cloud VPS zaczynamy od zaktualizowania systemu operacyjnego oraz sklonowania repozytoriów z GitHuba zawierających kod źródłowy Domoticza: 

yum -y install epel-release
yum -y update && yum -y upgrade

Kolejno instalujemy wymagane pakiety: 

yum -y install git '@Development tools' wget libusb.x86_64 perl-core zlib-devel mlocate systemd-devel libgudev1-devel libssh.x86_64 python34-devel.x86_64 python34 python3-devel glibc-static libstdc++-static curl curl-devel libuv libuv-devel bash-completion

Instalujemy cmake w odpowiedniej wersji: 

sudo yum -y install cmake3
ln -s /usr/bin/cmake3 /usr/bin/cmake

Pobieramy i kompilujemy biblioteki OpenSSL ze źródeł: 

cd /usr/local/src/
wget https://www.openssl.org/source/openssl-1.0.2t.tar.gz
tar xzvf openssl-1.0.2t.tar.gz && cd openssl-1.0.2t
./config --prefix=/usr/local/ssl --openssldir=/usr/local/ssl shared zlib
make
make test
make install
cd /etc/ld.so.conf.d/
echo ' /usr/local/ssl/lib ' > openssl-1.0.2t.conf
ldconfig -v
mv /bin/openssl /bin/openssl.BAK

Tworzymy skrypt, który pozwoli nam zdefiniować nowe zmienne środowiskowe dla OpenSSL: vim /etc/profile.d/openssl.sh. Zawartość: 

OPENSSL_PATH="/usr/local/ssl/bin"
export OPENSSL_PATH
PATH=$PATH:$OPENSSL_PATH
export PATH

Nadajemy uprawnienia i ustawiamy zmienne: 

chmod +x /etc/profile.d/openssl.sh
source /etc/profile.d/openssl.sh

Sprawdzamy ścieżkę i wersję OpenSSL:

which openssl
openssl version -a

Wynik poleceń powinien być zgodny z poniższym zrzutem:

Następnie pobieramy i instalujemy biblioteki boost: 

mkdir /opt/boost && cd $_ && \
wget https://dl.bintray.com/boostorg/release/1.71.0/source/boost_1_71_0.tar.gz && \
tar xzvf boost_1_71_0.tar.gz && cd boost_1_71_0 && ./bootstrap.sh && ./b2 stage threading=multi link=static --with-thread --with-date_time --with-system --with-atomic --with-chrono --with-regex --with-iostreams --with-python && ./b2 install threading=multi link=static --with-thread --with-date_time --with-system --with-atomic --with-chrono --with-regex --with-iostreams --with-python

Jako ostatni krok przed instancją Domoticza – dogrywamy biblioteki OpenZWave, również kompilowane ze źródeł: 

cd /opt/ && git clone https://github.com/OpenZWave/open-zwave open-zwave-read-only && cd open-zwave-read-only/ && git pull && make && make install

Finalnie przystępujemy do instalacji Domoticz: 

cd /opt && git clone https://github.com/domoticz/domoticz.git domoticz && cd domoticz && cmake -DOPENSSL_ROOT_DIR=/usr/local/ssl -DOPENSSL_LIBRARIES=/usr/local/ssl/lib -DCMAKE_BUILD_TYPE=Release CMakeLists.txt

CONF_SWAPFILE=1024 make

Po pomyślnie ukończonej instalacji po raz pierwszy w celach testowych uruchamiamy Domoticza jako proces: 

./domoticz

Oczywiście ręczne uruchamianie rozwiązania za każdym razem nie wchodzi w grę, dlatego musimy skonfigurować i utworzyć nową usługę dla Domoticza. Najpierw tworzymy odpowiedniego użytkownika: 

useradd domoticz && chown -R domoticz /opt/domoticz

Następnie tworzymy plik: /etc/systemd/system/domoticz.service. Uzupełniamy go poniższą zawartością i zapisujemy: 

[Unit]
Description=domoticz_service
[Service]
User=domoticz
Group=domoticz
ExecStart=/opt/domoticz/domoticz -www 8080 -sslwww 8443
WorkingDirectory=/opt/domoticz
[Install] 
WantedBy=multi-user.target

Włączamy i uruchamiamy usługę: 

systemctl enable domoticz
systemctl start domoticz

Na koniec tworzymy odpowiednie reguły FirewallD: 

firewall-cmd --add-port=8080/tcp --permanent
firewall-cmd --add-port=8443/tcp --permanent
firewall-cmd --reload

Konfiguracja

W celu wysyłania informacji do naszego chmurowego Domoticza nasz zestaw Arduino musieliśmy wyposażyć w moduł Wi-Fi. Wykorzystany został tutaj dedykowany układ Arduino WiFi Shield. Sam przykładowy kod skonfigurowania połączenia do sieci WPA2 został udokumentowany na stronie z opisami bibliotek: https://www.arduino.cc/en/Tutorial/ConnectWithWPA

Kolejnym elementem, jaki ,,dobudowujemy” do naszego rozwiązania, jest mechanizm wysyłania żądań HTTP z wykorzystaniem wspomnianego wcześniej modułu, który również został uwzględniony w dokumentacji projektu Arduino: https://www.arduino.cc/en/Tutorial/WiFiWebClient. Standardowo do interfejsu Domoticza logujemy się z wykorzystaniem przeglądarki. Powita nas ekran startowy (Dashboard) wraz z informacją o braku zdefiniowania ulubionych urządzeń:

W zasadzie to żadne urządzenie nie jest dodane i ten proces musimy dopiero zrealizować. Domoticz jako platforma zainstalowana na RaspberryPi wspiera obsługę złączy GPIO. My jednak system wdrożyliśmy w oparciu o instancję chmurową Aruba. W związku z tym obsługa urządzenia może być realizowana tylko z wykorzystaniem komunikacji sieciowej. Domoticz wspiera przekazywanie parametrów z wykorzystaniem API działającego w oparciu o JSON. Zasadniczo więc nasze rozwiązanie, takie jak czujnik temperatury, musi wysyłać właściwie skonstruowane żądania HTTP GET do Domoticza. Dla parametru typu temperatura takie żądanie będzie miało następującą składnię: 

/json.htm?type=command&param=udevice&idx=IDX&nvalue=0&svalue=TEMP

gdzie:

IDX = ID naszego urządzenia (czujnika temperatury),

TEMP = wartość temperatury.

Jeżeli macie potrzebę skonfigurowania przekazywania zupełnie innych parametrów (np. wilgotność, ciśnienie atmosferyczne lub wysyłanie dowolnego komunikatu tekstowego), to opis wszystkich możliwości znajdziecie dokładnie w TEJ SEKCJI dokumentacji. Potrzebujemy zatem naszego parametru IDX. W tym celu musimy skonfigurować nowe urządzenie. W głównym panelu Domoticza rozwijamy opcję Setup i przechodzimy do sekcji Hardware:

Następnie dodajemy urządzenie typu Dummy, które zasadniczo nic nie robi, ale pozwoli nam na dodanie wirtualnych czujników (komunikujących się właśnie z wykorzystanie API JSON). Nadajemy nazwę dla naszego urządzenia, z listy rozwijanej wybierając Dummy i klikając na Add:

Po dodaniu urządzenia będziemy je od razu widzieli i poprzez kliknięcie na opcję Create Virtual Sensor możemy wybrać typ czujnika i nadać mu nazwę:

Gdy czujnik jest już dodany, przechodzimy do menu Setup -> Devices, gdzie będziemy mogli podejrzeć status naszych urządzeń. W naszym projekcie poza czujnikiem temperatury dodatkowo skonfigurowaliśmy odczyt informacji nt. zamka otwieranego pastylką RFID (zapisy GRANTED/DENIED):

Nasza platforma jest już gotowa. Na razie oczywiście pełni bardzo podstawowe funkcje, ale możliwości jej rozbudowy zarówno po stronie tego, co może wspierać Domoticz, jak i możliwości Arduino są w zasadzie ograniczone budżetem i czasem potrzebnym na dalsze zgłębianie tajników mikrokontrolerów AVR.

Za opracowanie i opublikowanie tego artykułu otrzymujemy wynagrodzenie.

Podobne wpisy