Pokazywanie postów oznaczonych etykietą OpenHab. Pokaż wszystkie posty
Pokazywanie postów oznaczonych etykietą OpenHab. Pokaż wszystkie posty

sobota, 11 marca 2017

"Inteligentny" dom na Raspberry PI

Jakiś czas temu opisywałem moje rozwiązanie automatyki domowej oparte na arduino i Raspberry PI
Polegało to mniej więcej na tym, że wszystkie przekaźniki którymi chciałem sterować, przełączniki z których odbierałem sygnały oraz czujniki temperatury z których korzystałem, podłączone były do arduino mega z ethernet shieldem. Za przechowywanie stanów poszczególnych urządzeń odpowiadało arduino. Na Raspberry PI zainstalowany miałem serwer MQTT. Arduino wysyłało wszystkie sygnały do MQTT skąd pobierał je sobie OpenHAB i udostępniał je użytkownikowi poprzez GUI web'owe lub aplikację mobilną. Dodatkowo OpenHab mógł przesyłać zdalne polecenia użytkownika do MQTT skąd odbierało je arduino i aktualizowało stan urządzeń domowych.

Rozwiązanie to miało jedną podstawową zaletę: działało :)
W trakcie użytkowania pojawiło się jednak kilka problemów o których już wspominałem w poprzednich postach. Były to między innymi:


  • skomplikowana architektura - w przypadku problemów było sporo miejsc do weryfikacji. 
  • problemy przy zanikach energii - w przypadku arduino z ethernet shield'em pojawiają się problemy z poprawnym wznowieniem pracy po zaniku energii. System potrafił zawieszać się przy starcie i konieczne było ręczne odłączenie od zasilania i ponowne uruchomienie. Czasami kilkukrotne. W internecie pojawiają się opisy takich przypadków. Niektórzy doradzają wrzucenie dodatkowego kondensatora pomiędzy PIN reset i GND (o ile dobrze pamiętam :) ), ale w moim przypadku niewiele to pomogło
  • samoczynne załączanie/wyłączanie urządzeń przy skokach napięcia. Tutaj przyczyny nie udało mi się namierzyć. Próbowałem podpinać urządzenia do dodatkowych stabilizatorów, ale nic to nie dało. Nie było to jakoś mocno uciążliwe, bo zdarzało się stosunkowo rzadko, ale jednak była to dość spora rysa na stabilności całego rozwiązania
  • niewygodne podłączanie urządzeń do arduino - podłączanie czujników i przekaźników bezpośrednio do PIN'ów arduino w przypadku "produkcyjnego" rozwiązania to generalnie bardzo słabe rozwiązanie. Co prawda rzadko po podłączeniu czegokolwiek się dotyka, ale arduino miałem w szafie razem z innymi urządzeniami do których co jakiś czas zaglądam i o rozpięcie czegoś było bardzo łatwo. Dorobiłem sobie co prawda dodatkową płytkę ze złączami śrubowymi do których wpiąłem urządzenia, ale i tak nie było to rozwiązanie komfortowe
  • problematyczne wprowadzanie zmian do systemu - dodanie nowego czujnika oprócz podpięcia sprzętu wymagało zmian w kodzie arduino, przenoszenia laptopa do garażu gdzie był hardware, podpinania po USB do arduino, programowania układu, testowania i w przypadku błędu powtarzania wszystkiego kilkukrotnie - niefajne :)
Po ponad dwóch latach korzystania z takiego systemu zacząłem zastanawiać się jak uprościć całą architekturę tak aby większość z powyższych problemów wyeliminować. Podświadomie czułem, że w tej sytuacji arduino jest zupełnie zbędne, że do wszystkiego w zupełności powinno wystarczyć Raspberry PI. Problemem jest jednak ograniczona liczba PIN'ów GPIO. 

W poprzednim wpisie Raspberry PI i dodatkowe piny GPIO na kilku układach mcp23017 oraz przełącznik na tranzystorze opisałem w jaki sposób można te problemy obejść. Pozostało jedynie zaprojektowanie odpowiedniego układu który spełniał będzie wszystkie moje wymagania, zapewniał elastyczność i możliwość dalszej rozbudowy, oraz płytki na której możliwe będzie wygodne  podpinanie urządzeń do Raspberry. Zdefiniowałem następujące wymagania:
  1. 16 cyfrowych wejść (obsługa do 16-tu przełączników)
  2. 16 cyfrowych wyjść (obsługa 16-tu urządzeń na zasadzie włącz/wyłącz)
  3. obsługa magistrali One Wire
  4. obsługa LIRC (sterowanie pilotem na podczerwień)
  5. łatwe i trwałe połączenie z Raspberry PI
  6. łatwe i trwałe podłączanie urządzeń i czujników
  7. dostęp do pozostałych PIN'ów GPIO
  8. możliwość obsługi urządzeń zasilanych różnym napięciem
Zadanie było dość czasochłonne, ale myślę że założony efekt udało mi się osiągnąć. Zrobiłem schemat i projekt w Eagle, zdecydowałem jednak że nie będę sam trawił płytki. Zamówiłem w jednej z firm oferujących taką usługę. Takie oto płytki otrzymałem:




To pierwszy prototyp, jak widać jeszcze nie do końca polutowany. 
Płytka zaprojektowana jest pod 40-pinowe złącze GPIO dostępne od Raspberry Pi 2.
W tym przypadku podłączenie jest bardzo wygodne i trwałe - za pośrednictwem 40-żyłowej taśmy wpinanej do Raspberry i do płytki.
Nic nie stoi jednak na przeszkodzie żeby podłączyć ją do starszej wersji RPI gdzie złącze było 26-cio pinowe. W tym przypadku jednak podłączenie musi być inne - na przykład przewodami female-female:


Podłączenie jest proste, ponieważ złącze na płytce odpowiada  portowi GPIO w Raspberry.

Płytka zawiera wszystkie elementy o których pisałem  w wymaganiach:

Teraz kilka słów wyjaśnienia i opis działania.
Płytkę należy podłączyć do portu GPIO Raspberry PI. Oprócz tego, należy podłączyć dodatkowe źródło zasilania DC. Zdecydowałem się na takie rozwiązanie ponieważ RPI ma zbyt małą wydajność prądową aby obsłużyć 16 urządzeń zewnętrznych które mogą mieć różne wymagania. Jak widać na zdjęciu na płytce mamy 16 tranzystorów. Wszystkie wyjścia zaprojektowane są jako klucze tranzystorowe. Układy MCP23017 załączają poszczególne tranzystory podając zewnętrzne zasilanie na poszczególne wyjścia. Z tego wynika bardzo ciekawa cecha - w zależności od tego jakie napięcie podamy jako zewnętrzne źródło zasilania, takie urządzenia będziemy mogli podpinać do wyjść. Przykładowo, podpinając płytkę do +5V będziemy mogli sterować przekaźnikami które wymagają 5V, podpinając płytkę do +12V będziemy na wyjścia mogli podpinać urządzenia 12-voltowe, na przykład taśmy LED. Jest tutaj jednak ograniczenie - wszystkie wyjścia muszą działać na tym samym napięciu. Kolejna cecha płytki pozwala jednak obejść to ograniczenie. Jak widać na płytce jest dodatkowe wyjście GPIO do którego teoretycznie można podpiąć drugą  taką samą płytkę. Wtedy jedną płytkę podpinamy do +5V a drugą do +12V. Mamy wtedy 16 wyjść +5V i 16 wyjść +12V. I tak dalej.... Do drugiej możemy podpiąć trzecią, do trzeciej czwartą :). Na każdej płytce trzeba jedynie za pomocą zworek zmienić adresowanie układów MCP23017. Ograniczeniem jest jedynie liczba adresów - 3 bity, czyli możemy obsłużyć 7 układów MCP - z czwartej płytki musielibyśmy wyjąć jeden układ MCP - są w podstawkach, więc nie ma problemu. Nie testowałem jeszcze takiego rozwiązania - nie mam tylu płytek :), ale teoria mówi że takie rozwiązanie powinno działać. Pozostało mi jeszcze do zbadania ograniczenie prądowe wszystkich podpiętych urządzeń - to jeszcze przede mną. Ze wstępnych obliczeń wynika, że do 2A powinno działać bez ryzyka przegrzania - to jeszcze będę badał.

Kolejna uwaga - na wyjścia można podpinać jedynie urządzenia które da się załączyć za pośrednictwem dwóch przewodów (plus i minus). Pozwala to na przykład załączać przekaźniki, ale tylko jednokanałowe. Mają one 3 piny. Podpinamy  minus do minusa, a plus z płytki jednocześnie do plusa i sygnału na przekaźniku. Dla mnie takie rozwiązanie jest wystarczające. Steruję jednokanałowymi przekaźnikami ukrytymi w puszkach ściennych. Sterowanie wielokanałowymi modułami przekaźnikowymi może być problematyczne, ponieważ mają one wspólne zasilanie dla wszystkich kanałów. Nad rozwiązaniem tego ograniczenia być może jeszcze popracuję, ale na razie nie widzę jakiejś większej potrzeby.

Na płytce jest 16 wejść cyfrowych. Są to zwykłe 2-pinowe złącza. Zwarcie pinów powoduje podanie napięcia +5V na odpowiedni kanał układu MCP23017 i stamtąd możemy odczytać stan przycisku.

Dodatkowo na płytce umieściłem 3-PIN'owe złącze LIRC, do którego można bezpośrednio podpiąć odbiornik TSOP. Złącze podpięte jest do napięcia 3,3V z RPI więc działały będą jedynie układy TSOP obsługujące takie napięcie. Osobiście sprawdzałem na TSOP4836 i działa bez zarzutu.

Do płytki można wpiąć bezpośrednio 10 urządzeń OneWire. Każde wejście ma 3 PIN'y (+5V, GND, SIGNAL). Urządzenia wpinamy bezpośrednio, bez dodatkowego rezystora, który umieściłem już na płytce. 

To już chyba wszystkie funkcje płytki. U mnie płytka zastąpiła poprzednią konfigurację około miesiąc temu i jak dotąd działa bez zarzutu. Praktycznie wszystkie z wymienionych na początku wpisu wad zostały usunięte. 

No i największa zaleta - to w jaki sposób wykorzystamy płytkę, w czym napiszemy oprogramowanie zależy już tylko od nas. Można skorzystać z pythona, javy, c, czy nawet pisać skrypty w bash'u. Ogranicza nas praktycznie tylko wyobraźnia. Wszystko można wygodnie testować logując się na RPI po ssh i uruchamiając programy. Nie trzeba za każdym razem programować arduino :)

Ja postanowiłem że nadal pozostanę przy OpenHab uruchomionym na RPI.

Do OpenHab 1.x jest "binging" obsługujący układy MCP23017. Prawdopodobnie da się z niego skorzystać. Ja przy okazji zmiany architektury przesiadłem się również na OpenHab 2.0. 
Niestety binding nie działał, musiałem zatem napisać swój. Kod oczekuje na "code review". Jeśli go przejdzie prawdopodobnie znajdzie się w oficjalnym wydaniu OpenHab 2.1.

Niecierpliwi znajdą go tutaj:

Do obsługi czujników temperatury podpiętych do złącz OneWire również nie było binding'u. Tutaj również musiałem napisać swój. Również oczekuje na code review. 

Kod znajdziecie tutaj:
Konfiguracja OpenHab to już jednak temat na oddzielny wpis.
 
Podsumowując: 
 całe rozwiązanie zajęło mi mnóstwo czasu, począwszy od prototypu na płytce stykowej, poprzez schemat i projekt w eagle, lutowanie układu, pisanie oprogramowania, ale zdecydowanie było warto. Całość działa dużo stabilniej niż poprzednie rozwiązanie, a co najważniejsze jest dużo wygodniejsze i elastyczniejsze. Jestem w stanie sobie wyobrazić dużo więcej zastosowań takiej płytki niż tylko automatyka domowa. 
U mnie obecnie płytka obsługuje:

  • 7 przekaźników do sterowania oświetleniem lub gniazdkami
  • przełączniki do obsługi przekaźników
  • 7 czujników temperatury One Wire DS18B20
  • sterowanie przekaźnikami za pomocą pilota
  • do jednego wejścia podłączyłem zamiast przełącznika kontaktron i mam stały podgląd stanu bramy garażowej (zamknięta/otwarta)

Wszystko to na jednym Raspberry PI i opisywanej płytce :)

W trakcie prac przygotowałem trzy prototypy płytki. Jeden działa produkcyjnie, jeden mam do dalszych testów i jeden został "wolny". Jeśli ktoś będzie zainteresowany mogę go odsprzedać. 
Cena - 150 zł. Dość wysoka, ale wykorzystane części nie są tanie (głównie tranzystory i układy MCP), trawienie płytki też trochę kosztowało a i pracy włożyłem sporo. 
Chętnych proszę o kontakt na priv. Mogę wystawić aukcję na allegro.

Jeśli zainteresowanie będzie większe przygotuję jeszcze kilka takich płytek.

Z tego też powodu niestety nie zamieszczę na razie projektu w eagle. Natomiast nie ma tam żadnej wiedzy tajemnej i na podstawie mojego poprzedniego wpisu gdzie załączyłem diagram połączeń MCP, oraz ogólno dostępnej w internecie wiedzy, każdy zainteresowany powinien być w stanie takie rozwiązanie przygotować.
  
 

środa, 29 października 2014

OpenHab - sterowanie za pomocą poleceń głosowych

Aplikacja OpenHab na Androida (habDroid) ma bardzo ciekawą i użyteczną funkcjonalność sterowania głosem. Mając już działającą konfigurację OpenHab należy do naszego pliku *.items dopisać:

String VoiceCommand

dokładnie w takiej postaci.

W momencie rozpoznania głosu habDroid do elementu o nazwie VoiceCommand wysyła rozpoznaną treść.
Przykładowy plik zawierający jeden przełącznik o nazwie salonLed z możliwością sterowania głosem powinien wyglądać następująco:

OpenHab posiada możliwość definiowania tzw. reguł (rules). Reguły muszą znajdować się w katalogu

configurations/rules

w pliku o rozszerzeniu

*.rules

W celu określenia jaka  jaka akcja powinna być wykonana po otrzymaniu zdefiniowanej komendy głosowej należy utworzyć odpowiednią regułę. Załóżmy że chcemy sterować elementem salonLed. Należy wtedy utworzyć plik z regułą, np.

voice.rules 

o następującej treści:
Jak widać reguły definiowane są w prostym i dość czytelnym języku skryptowym.
Aby sterować kolejnymi urządzeniami trzeba po prostu dodać nowe elementy w pliku *.items oraz nowe reguły dla nich w pliku *.rules

To praktycznie cała konfiguracja, jak widać jest banalnie prosta. Zastosowań można znaleźć wiele, na przykład jedną komendą głosową można otworzyć bramę wjazdową, bramę garażową i zapalić halogen na podjeździe. Można wtedy zapomnieć o pilotach :)
Dla miłośników IPhone'ów mam niestety złą wiadomość. Sterowanie głosowe działa wyłącznie na Androidzie.

Na koniec przykładowy film z działania funkcjonalności:



niedziela, 26 października 2014

OpenHab, arduino i mqtt binding

Klon arduino możesz zakupić tanio  na aliexpres. Poniższy link to link afiliacyjny. Skorzystanie z niego Ciebie nic dodatkowo nie kosztuje a ja otrzymam niewielką prowizję która wspomoże rozwój tego bloga. Dzięki!

http://ali.pub/2hk8rp

Jak już pisałem wcześniej komunikacja arduino z OpenHab za pomocą TCP nie sprawdziła się w praktyce. Za to z czystym sumieniem mogę stwierdzić że komunikacja za pomocą MQTT działa znakomicie.

Przy takim rozwiązaniu dochodzi jednak dodatkowa warstwa pośrednia - broker.
W uproszczeniu można powiedzieć że broker zajmuje się rozprowadzaniem komunikatów do zainteresowanych klientów.

Rozwiązanie to działa na zasadzie mechanizmu Publish - subscribe.
Odpowiednie urządzenia mogą publikować (Publish) komunikaty w danym temacie (TOPIC). Klienci podłączają się do brokera informując go że są zainteresowani (subscribe) komunikatami z danego tematu.

Przenosząc to na płaszczyznę automatyki domowej ja zastosowałem następującą architekturę:

Na Raspberry PI zainstalowałem broker MQTT. Najpopularniejszym brokerem obecnie jest chyba Mosquitto.

Aby zainstalować mosquitto należy wykonać następujące polecenie:

sudo apt-get install mosquitto mosquitto-clients

Po instalacji pojawi się katalog:

/etc/mosquitto

w którym znajduje się plik konfiguracyjny brokera

mosquitto.conf

Wystarczy bardzo prosta konfiguracja:

Jak widać z powodu bezpieczeństwa wyłączyłem anonimowy dostęp do brokera. W tym przypadku należy utworzyć plik

 /etc/mosquitto/password_file

,w którym zapiszemy login i hasło do brokera z którego  będą korzystać Arduino i OpenHab.
Plik powinien zawierać wpis w postaci:

login:hasło

Teraz należy zrestartować broker poleceniem:

/etc/init.d/mosquitto restart

Następnie można przetestować działanie brokera. Dostępne są dwa programy:

mosquitto_sub 

do obsługi subskrypcji oraz

mosquitto_pub 

do obsługi publikowania.

Na początku należy uruchomić polecenie:


mosquitto_sub -h localhost -u login -P hasło -t /house

co oznacza że utworzyliśmy klienta który podłączył się do brokera na serwerze localhost przy użyciu loginu "login" i hasła "hasło" (zdefiniowanych w pliku password_file). Klient subskrybował wszystkie wiadomości w temacie (TOPIC) /house.

Po wykonaniu polecenia klient oczekuje na komunikaty.

W drugiej konsoli należy uruchomić polecenie:

mosquitto_pub -h localhost -u login -P hasło -t /house -m test

Oznacza to że na brokerze pod adresem localhost opublikowaliśmy wiadomość o treści "test" w temacie /house

Jeśli wszystko wykonaliśmy poprawnie na konsoli na której uruchomiliśmy mosquitto_sub powinna pojawić się zawartość wiadomości, czyli "test"

Dla eksperymentu można uruchomić kilka klientów mosquitto_sub nasłuchujących dany "topic". Na wszystkich jednocześnie powinna pojawić się treść opublikowanego komunikatu


Mając działający broker można przystąpić do konfiguracji OpenHab.

W tym celu należy przekopiować plik jar o nazwie

org.openhab.bindings.mqtt-1.5.0.jar (numer wersji może być inny)

 do katalogu addons serwera openhab.
W pliku konfiguracyjnym

configuration/openhab_default.cfg

należy dopisać następujące linie:


Załóżmy że chcemy sterować halogenem. W tym przypadku plik

configurations/items/house.items

powinien wyglądać następująco:

Oznacza to że w naszej konfiguracji mamy jeden przełącznik odpowiadający za załączanie halogena.
Załączenie przełącznika OPUBLIKUJE wiadomość o treści "halogen#1" na brokerze mqtt w topic'u "/house". Wyłączenie przełącznika OPUBLIKUJE wiadomość o treści "halogen#0" na brokerze mqtt również w topic'u "/house"
Dodatkowo obsługa tego przełącznika SUBSKRYBUJE topic /houseIn na tym samym brokerze.
W pliku

transform/halogen.map 

powinno znaleźć się mapowanie treści otrzymanej wiadomości na stan przełącznika.
Plik powinien mieć następującą zawartość:

halogen#1=ON
halogen#0=OFF

Nasłuchiwanie służy do aktualizacji stanu przełącznika. Pamiętajmy że halogen można zapalić również zwykłym przełącznikiem na ścianie. Wówczas OpenHab powinien się o tym dowiedzieć aby wyświetlić odpowiedni stan przełącznika.

To cała konfiguracja po stronie OpenHab. Należy tylko zrestartować usługę.

Pozostaje jeszcze obsługa po stronie mikrokontrolera.
Bibliotek do obsługi mqtt na arduino jest kilka. Ja wykorzystałem bibliotekę PubSubClient którą znalazłem pod adresem:
http://knolleary.net/arduino-client-for-mqtt/

Poniżej przedstawiam fragmenty kodu które obrazują zasadę działania:
Nie jest to kompletny kod, ponieważ całość wraz z obsługą wszystkich przekaźników które mam obecnie jest zbyt duża żeby wklejać je na bloga. Większe fragmenty publikowane były już w poprzednich wpisach. Myślę że osoby obeznane z tematem bez problemu powinny poradzić sobie z wykorzystaniem podanych fragmentów. W przypadku pytań  piszcie w komentarzach.

Jedyny fragment który sprawiał problemy to okolice wiersza 45. Po  pewnym czasie od momentu restartu arduino przy wciskaniu przełączników sprzętowych przestawały dochodzić potwierdzenia do OpenHab. Okazało się że z jakichś nieokreślonych powodów było zrywane połączenie między Arduino a MQTT. Dodanie sprawdzania stanu i ponownego połączenia w przypadku gdy połączenie nie było aktywne rozwiązało problem.

Po tych zmianach cały układ działa bardzo stabilnie i myślę że można stwierdzić że można go z powodzeniem wykorzystywać w warunkach produkcyjnych



poniedziałek, 7 kwietnia 2014

Inteligentny dom oparty na OpenHab - wstęp

OpenHab to oprogramowanie dzięki któremu możemy połączyć urządzenia domowe oparte na różnych technologiach i protokołach w jeden sprawnie działający system inteligentnego budynku.
Główną częścią OpenHab jest tzw. OpenHab Runtime. Jest to aplikacja webowa napisana w całości w Javie, działająca pod kontrolą serwera Jetty.

OpenHab Runtime działa w oparciu o zestaw plików konfiguracyjnych. Są to niestety pliki tekstowe, brak jest jakichkolwiek narzędzi do graficznej konfiguracji. Autorzy zapewnili jednak narzędzie o nazwie OpenHabDesigner bazujące na Eclipse IDE, które zapewni nam podświetlanie błędów, oraz kolorowanie i uzupełnianie składni plików konfiguracyjnych co jest dość dużą pomocą. Dodatkowo dość czytelne przykłady i nie najgorsza dokumentacja sprawiają że konfigurowanie nie jest takie straszne.

Dostępne są również aplikacje na iOS oraz na Androida pozwalające na sterowanie automatyką z poziomu telefonu lub tabletu.

Całość wydana jest na licencji Eclipse Public Licence, co oznacza że mamy pełny dostęp do kodu źródłowego.

Generalnie w instalacjach inteligentnych budynków dużym problemem jest niezgodność protokołów transmisji pomiędzy dostawcami poszczególnych rozwiązań. Mamy chociażby standardy KNX, z-Wave, Fritz i wiele innych.
Gdy zdecydujemy się na jedno z rozwiązań stajemy się na stałe przywiązani do jednej firmy, która zwykle każe sobie słono płacić za każde dodatkowe elementy.

OpenHab jest próbą rozwiązania tego problemu.
Spójrzmy najpierw na architekturę (schemat pobrany ze strony http://www.openhab.org/)

Jak widać na schemacie, podstawowym elementem systemu jest szyna zdarzeń (Event Bus). która jak sama nazwa wskazuje zarządza zdarzeniami zachodzącymi w systemie.
Generalnie wyróżnić należy dwa typy zdarzeń: commands - czyli komendy wydawane przez użytkownika (lub inne źródła), oraz state change czyli zdarzenie zmiany statusu danego elementu systemu.

Tworząc własną konfigurację przygotowujemy tzw. Sitemap'ę czyli plik w którym opisujemy interfejs użytkownika. Co ciekawe interfejs ten wygląda później identycznie na wszystkich urządzeniach - w przeglądarce, na telefonie lub tablecie.
Dodatkowo definiujemy listę elementów (items) kontrolujących nasz system. Mogą to być przełączniki, suwaki, pola tekstowe wyświetlające stan elementów systemu - na przykład temperaturę w pomieszczeniu i kilka innych. Dla każdego z tych elementów w konfiguracji określamy sposób komunikacji z odpowiednim urządzeniem (binding) - czy to będzie KNX, połączenie szeregowe, bluetooth, czy też połączenie TCP. Obecnie dostępnych jest kilkadziesiąt różnych protokołów. Istnieje również możliwość dopisywania nowych, dostosowanych do własnych potrzeb. Każdy z elementów ma zdefiniowane komendy sterujące (np dla elementu typu Switch komendy to ON oraz OFF). W konfiguracji umieścić należy dodatkowo mapowanie poleceń wysyłanych lub odbieranych z urządzenia zewnętrznego na odpowiednie komendy elementu OpenHab.

System daje nam  dużą dowolność jeśli chodzi o sposób zapisu zdarzeń  w systemie. Może być to proste logowanie w pliku tekstowym, ale też zapisywanie stanu czujników w bazie danych, oraz generowanie wykresów na podstawie wyników.

Możliwości konfiguracji OpenHab'a są na prawdę olbrzymie. Myślę że warto zapoznać się z konfiguracją demo którą można uruchomić bez instalowania aplikacji u siebie.

Ja dopiero zaczynam poznawać jego możliwości i w miarę postępów postaram się opisać tutaj moje doświadczenia. W pierwszej części pojawi się komunikacja z Arduino za pomocą TCP, która niestety nie okazała się bezproblemowa.