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, 28 grudnia 2016

Raspberry PI i dodatkowe piny GPIO na kilku układach mcp23017 oraz przełącznik na tranzystorze

Jakiś czas temu doszedłem do wniosku że system sterowania automatyką domową który zrobiłem jest zbyt skomplikowany. Mam obecnie raspberry PI + arduino + ethernet shield + dodatkowa płytka do złączy. Arduino razem z ethernet shield czasami sprawia problemy, szczególnie po zanikach energii ma problemy z ponownym uruchomieniem się i wymaga manualnego restartu. Jest to zatem element którego chcę się pozbyć. Wydaje się że samo raspberry PI powinno być zdecydowanie wystarczające. Ogranicza jedynie liczba pin'ów GPIO i wydajność prądowa. Na szczęście da się to obejść i rozpocząłem już projektowanie płytki która po podłączeniu do raspberry dostarczy nam dodatkowe piny oraz możliwość załączania/wyłączania bardziej prądożernych urządzeń. Aby zyskać dodatkowe piny najłatwiej skorzystać z układów mcp23017 które podłączamy do raspberry PI za pomocą magistrali I2C. Każdy taki układ dostarczy nam 16 dodatkowych pin'ów. Układy można ze sobą łączyć, zatem tych pinów można mieć zdecydowanie więcej. Obliczyłem że na moje potrzeby dwa takie układy wystarczą. W sieci znaleźć można mnóstwo przykładów podłączania mcp23017 do raspberry, jednak działających przykładów podpięcia kilku układów jednocześnie już zbyt wiele nie ma. Dodatkowe założenie jest takie, że chcę mieć możliwość włączania/wyłączania urządzeń o większym napięciu niż 5V dostarczane przez raspberry PI. To możemy zrobić za pomocą klucza na tranzystorze N-MOSFET. Poniżej przedstawiam schemat podłączenia do raspberry PI dwóch układów mcp23017 oraz wpięcie do nich dwóch kluczy tranzystorowych. Jeden (podpięty do pierwszego MCP) steruje diodą LED, drugi steruje modułem przekaźnikowym (do którego dalej możemy podłączyć dowolne urządzenie 220V). W moim przykładzie dodatkowe zewnętrzne źródło zasilania to nadal 5V (takiego napięcia potrzebuje zarówno moduł przekaźnikowy jak i dioda LED), ale nic nie stoi na przeszkodzie aby podłączyć do układu napięcie 12V lub 24V (lub wyższe - ograniczenie wynika z możliwości zastosowanego tranzystora) i sterować urządzeniami wymagającymi wyższego napięcia wpinając je do układu analogicznie.


Aby układ zadziałał poprawnie musimy w raspberry PI aktywować obsługę magistrali I2C. 
Opis jak to zrobić znaleźć można na przykład tutaj:


Każdy układ mcp23017 który podłączamy musi mieć oddzielny adres na magistrali I2C.


Za adresowanie odpowiadają piny zaznaczone na rysunku. Adres zawsze zaczyna się od 0x2. Ostatnia cyfra w adresie zależna jest od sposobu w jaki podłączymy piny adresowe. Każdy z nich musi być podłączony albo do masy albo do VCC. Na podanym przykładzie pierwszy układ wszystkie piny podłączone ma do GND, odczytując je binarnie mamy zero, czyli ostatnia cyfra adresu to 0.
Pierwszy układ ma zatem adres 0x20.
Drugi układ środkowy pin podłączony ma do VCC, czyli 010 binarnie daje nam 2 szesnastkowo, zatem adres drugiego układu to 0x22. Podpięcie wszystkich pinów do VCC dałoby nam 111 binarnie, czyli 7 szesnastkowo, adres byłby wtedy 0x27.

Po podpięciu układu możemy sprawdzić jego działanie.
Logujemy się do raspberry Pi (ja korzystam z raspbiana, w którym całe oprogramowanie do I2C jest zainstalowane - w innych dystrybucjach może być konieczność doinstalowania dodatkowych pakietów). 

wykonujemy polecenie

sudo bash

aby nadać sobie uprawnienia roota (dzięki temu przed każdym poleceniem nie będziemy musieli dodawać "sudo")

Następnie wydajemy polecenie:

i2cdetect -y 1

w przypadku raspberry pi 1 będzie to:

i2cdetect -y 0

Po wykonaniu polecenia powinniśmy otrzymać:




Widać że na magistrali mamy dwa urządzenia z adresami 20 i 22

Sterowanie magistralą odbywa się za pomocą polecenia i2cset.

Na początku ustawiamy piny GPA0-7 obydwu układów aby pracowały jako wyjścia.

w tym celu wykonujemy polecenia:


i2cset -y 1 0x20 0x00 0x00

i2cset -y 1 0x22 0x00 0x00


1 - numer szyny i2c

0x20, 0x22 - adresy układów MCP


0x00 - numer rejestru układu MCP, akurat rejestr 0x00 to IODIRA (zgodnie ze specyfikacją układu MCP), który odpowiada za sposób działania pinów GPA0-7. Piny układów w MCP sterowane są niezależnie po 8 - osobno GPA07 i GPB0-7. Aby ustawić tryby działania dla pinów GPB0-7 musielibyśmy wpisać wartości do rejestru IODIRB, którego adres to 0x01

0x00 - wartość wpisywana do odpowiedniego rejestru - ustawiamy w tryb wyjścia 8 pinów. 0 binarne odpowiada wyjściu, 1 binarne odpowiada wejściu. ustawiamy wszystkie piny jako wyjścia, czyli binarnie 00000000, szesnastkowo 0x00.

Po ustawieniu trybów działania pinów, możemy na wyjściach ustawić stan wysoki, co załączy nasz klucz tranzystorowy i uruchomi przekaźnik diodę. Dioda podłączona jest do pinu GPA1 układu o adresie 0x20.

Binarnie zatem chcemy mieć stan 00000010 na wyjściach GPA0-7, daje nam to 0x02 szesnastkowo

Aby ją załączyć wydajemy polecenie:

i2cset -y 1 0x20 0x14 0x02
0x14 - adres rejestru OLATA, który odpowiada za ustawianie wartości na pinach GPA0-7

Aby wyłączyć diodę będzie to polecenie:

i2cset -y 1 0x20 0x14 0x00

Dla przekaźnika będą to odpowiednio polecenia:

i2cset -y 1 0x22 0x14 0x02

i2cset -y 1 0x22 0x14 0x00


W ten sposób możemy zarządzać 32 dodatkowymi wyjściami z Raspberry PI, które mogą załączać zewnętrznie zasilane urządzenia. W razie potrzeby możemy dodawać więcej układów zmieniając jedynie adresację. Daje nam to na prawdę bardzo szerokie możliwości.


Układy MCP23017 można zasilać również napięciem 3,3V.

Wtedy na wyjściach stan wysoki to również 3,3V

Jako że do układu zastosowałem tranzystory IRF540N, których minimalne napięcie załączenia to około 4V ja musiałem podłączyć je do 5V.

Docelowo planuję wytrawić płytkę z 32 wyjściami, którą zastąpię arduino oraz ethernet shield co powinno znacznie uprościć cały układ mojej domowej automatyki. Dodatkowo dodanie jakichkolwiek urządzeń dodatkowych nie będzie wymagało przeprogramowywania arduino, co jest dość uciążliwe. Będzie można to zrobić zdalnie przez SSH logując się jedynie do raspberry PI.



niedziela, 27 listopada 2016

"Ambilight" własnej roboty na Raspberry PI

Kodi


To rozwiązanie działa u mnie już od prawie roku, tylko jakoś nie mogłem się zebrać żeby je opisać i nagrać film z prezentacją działania.

Zacznijmy zatem od filmu, żeby wiadomo było o co chodzi w temacie:


Technologia Ambilight podobała mi się od dawna. Od dawna szukałem też  rozwiązań które pozwalałyby ten efekt osiągnąć  "domowymi" metodami. Na początku pojawiły się opisy urządzeń, ale działających wyłącznie dla filmów odtwarzanych z komputera, co nie było do końca satysfakcjonujące.
Jakiś czas temu natrafiłem w internecie na opis jak zrobić kompleksowe rozwiązanie, w którym oświetlenie działa dla każdego źródła wideo, podłączonego do telewizora za pośrednictwem przewodu HDMI.
Rozwiązanie oparte jest na platformie Raspberry PI i oprogramowaniu Hyperion.
Bardzo mi to odpowiadało, ponieważ miałem już Raspberry podłączone do telewizora i działające jako "centrum multimedialne", z aplikacją Kodi. Wystarczyło tylko podłączyć parę diód :D

Potrzebna do tego jest taśma LED RGB z chip'ami ws2801, dzięki którym każda dioda może być sterowana niezależnie, a co za tym idzie może świecić innym kolorem. 

Oświetlenie możemy zamontować w dowolnej konfiguracji, na jednym, dwóch, trzech, lub czterech bokach telewizora. Ja zdecydowałem się na opcję maksymalną :)

Jako że oświetlenie chciałem zamontować na 60'cio calowym telewizorze, potrzebowałem ponad 4 metry taśmy, musiałem zatem kupić całą 5-cio metrową rolkę. 

Po zakupie taśmy zabrałem się do naklejania jej na telewizor:







Naklejając taśmę, należy pamiętać, żeby naklejać ją przeciwnie do ruchu wskazówek zegara patrząc od tyłu telewizora. Zalecane jest aby zaczynać od prawego dolnego rogu (patrząc z tyłu), ja jednak zacząłem od lewego dolnego, ponieważ akurat tak pasowały mi podłączenia przewodów. Taka zmiana nie jest problemem, można to wszystko potem wykalibrować programowo.

Od taśmy odchodzą cztery przewody:
  1. VCC+
  2. CI
  3. DI
  4. GND
Wszystkie cztery musimy doprowadzić do Raspberry PI.
Problem jest jednak taki, że Raspberry PI nie ma odpowiedniej wydajności prądowej na wyjściach VCC+ i GND, zatem potrzebujemy dodatkowego źródła zasilania dla taśmy LED. Dlatego też do przewodów VCC+ i GND dolutowałem dodatkowe standardowe gniazdo zasilające, do którego podłączyłem zewnętrzny zasilacz DC 5V:




 Po odpowiednim przylutowaniu gniazda, można podłączyć przewody do złącza GPIO w Rasberry PI.
Schemat podłączenia wygąda następująco:



U mnie po podłączeniu wygląda to następująco:


W tym miejscu miałem sporo problemów. Podłączałem na podstawie opisu, który znalazłem w internecie. Okazało się że było tam napisane żeby podłączyć do pin'u SCL a nie do SCLK. Przez długi czas nie mogłem dojść dlaczego diody nie chcą się świecić :) W każdym razie, jeśli coś nie działa, upewnijcie się że jest dobrze podłączone do GPIO :)

I to jest praktycznie wszystko od strony sprzętowej co potrzebujemy, aby mieć działające oświetlenie dla wideo wyświetlanego z Kodi na Raspberry Pi. Pozostała kwestia oprogramowania.

Na moim Raspberry Pi zainstalowaną mam dystrybucję OSMC.
Aby na nim zainstalować Hyperiona, trzeba zalogować się po ssh, przejść na konto root'a poleceniem:

sudo bash

i wykonać następujące polecenia:

apt-get update

apt-get install libqtcore4 libqtgui4 libqt4-network libusb-1.0-0 libprotobuf9 ca-certificates

wget -N https://raw.github.com/tvdzwan/hyperion/master/bin/install_hyperion.sh

sh ./install_hyperion.sh

/etc/init.d/hyperion stop

Mamy już zainstalowanego hyperiona na naszym Raspberry PI.
Teraz trzeba przygotować plik konfiguracyjny.
Służy do tego aplikacja HyperCon, którą należy pobrać spod adresu:

https://sourceforge.net/projects/hyperion-project/files/hypercon/HyperCon.jar

Aplikacja napisana jest w Javie, więc do jej uruchomienia potrzebujemy JDK.

uruchamiamy ją poleceniem:

java -jar HyperCon.jar 

W aplikacji Hyperion wybieramy liczbę diód w poziomie, liczbę w pionie, oraz offset pierwszej diody. Generalnie po każdej zmianie w polach liczbowych odświeża nam się widok diod na rysunku telewizora i musimy pilnować żeby było to zgodne ze sposobem w jaki naklejaliśmy taśmę, pamiętając że  dioda numer zero to pierwsza  dioda przy złączce. U mnie wyszło 130 diod. 42 w poziomie i 23 w pionie:

Na zakładce Grabber, zaznaczamy Internal Frame Grabber":



Na zakładce "External" zaznaczamy "Kodi Checker"


Klikamy "Create Hyperion Configuration" i otrzymujemy plik "hyperion.config.json", który musimy przekopiować do katalogu /etc na Raspberry PI.

Należy jeszcze wystartować Hyperiona komendą:

/etc/init.d/hyperion start

i to wszystko... Filmy odtwarzane z Kodi powinny pięknie świecić :)

Przejdźmy teraz do wersji trochę bardziej rozbudowanej, pozwalającej na działanie oświetlenia dla każdego źródła wideo.

Do tego celu potrzebujemy dodatkowo:

konwertera HDMI2AV, splitera HDMI (rozdziela jedno źródło HDMI na dwa wyjścia)


oraz grabbera Video



Taki grabber można kupić za około 30 złotych, trzeba jednak zwrócić uwagę na chipset jaki posiada. Generalnie najłatwiej je wyszukać jako EasyCap Grabber, ale najlepiej żeby działał na chipsecie UTV007 (Fushicai), ponieważ taki działa na raspberry praktycznie "out of the box". Z innymi mogą być problemy.


Schemat połączenia w moim przypadku wygląda następująco:


Po podłączeniu w ten sposób należy jeszcze zmodyfikować konfigurację hyperiona. Można do zrobić ponownie za pomocą programu HyperCon, ale szybciej jest odnaleźć we wcześniej wygenerowanym pliku sekcję:

"grabber-v4l2" :
    {
        "device" : "/dev/video0",
        "input" : 0,
        "standard" : "PAL",
        "width" : 640,
        "height" : 480,
        "frameDecimation" : 2,
        "sizeDecimation" : 8,
        "priority" : 1000,
        "mode" : "2D",
        "cropLeft" : 36,
        "cropRight" : 37,
        "cropTop" : 30,
        "cropBottom" : 30,
        "redSignalThreshold" : 0.0,
        "greenSignalThreshold" : 0.0,
        "blueSignalThreshold" : 0.0
    },
i ją odkomentować,
następnie znaleźć w pliku sekcję:

"framegrabber" : 
{
"width" : 64,
"height" : 64,
"frequency_Hz" : 10.0
}

i ją zakomentować.

Pozostaje jeszcze restart hyperiona (a najlepiej całego Raspberry PI) i oświetlenie powinno działać dla wszystkich źródeł wideo.

Generalnie w telegraficznym skrócie to już wszystko, aczkolwiek temat jest dużo bardziej rozległy. Jest mnóstwo opcji konfiguracyjnych w samym HyperCon'ie, mamy bardzo szerokie możliwości kalibrowania oświetlenia, dostępne są opcje wykrywania czarnych ramek wokół obrazu i wiele, wiele innych. Warto również pobrać aplikację Hyperion na telefon, dzięki której możemy sterować oświetleniem (przykład pokazałem na filmie). Jest wiele miejsc w których można utknąć, natrafić na różnego rodzaju problemy, ale w sieci jest mnóstwo przykładów i poradników jak z takimi problemami sobie radzić.

Światełka działają u mnie już ponad rok i są praktycznie bezawaryjne. Sporadycznie zdarza się jakieś "zawieszenie" samego hyperiona, ale wtedy wystarcza komenda "/etc/init.d/hyperion restart" i wszystko wraca do normy.

Czy warto? Według mnie zdecydowanie tak. Satysfakcja ze zrobienia tego samemu jest na prawdę duża a i otrzymany efekt jest rewelacyjny.

Może na koniec spróbuję podsumować koszty:

W moim przypadku było to:
5m taśmy LED - kupiłem na znanym chińskim portalu :) - około 180 zł. Można kupić w Polsce, ale koszt 1 metra to około 60 zł, czyli 300 zł za 5m. Wg mnie warto poczekać na przesyłkę z Chin :)

Zasilacz 5V akurat miałem w domu, jeśli ktoś nie ma, to pewnie jakieś 20 zł.

Ja Raspberry PI już miałem działające... Jeśli ktoś nie ma, to pewnie za komplet około 200 zł (Rasbperry + obudowa + karta pamięci + zasilacz micro USB)

Do wersji "podstawowej", czyli odtwarzanie tylko z Kodi to wystarczy.

jeśli chcemy mieć światełka ze wszystkich źródeł video to dodatkowo:

30 zł za grabber
32 zł za splitter HDMI (w Chinach, w Polsce pewnie drożej)
31 zł za konwerter HDMI2AV - również w Chinach

czyli około 100 zł dodatkowo.

sobota, 26 listopada 2016

Lustro do makijażu



Niedawno żona zgłosiła zapotrzebowanie na toaletkę z lustrem do makijażu... Zaczęliśmy rozglądać się jakie rozwiązania są w ogóle dostępne, ale po tym jak zobaczyliśmy ceny samych luster, trochę miny nam zrzedły :)

Koszt samego lustra z odpowiednim oświetleniem w jakimś sensownym rozmiarze to minimum 600 - 700 zł.
Zacząłem trochę się nad tym zastanawiać i doszedłem do wniosku że zrobienie takiego lustra własnoręcznie nie powinno być jakoś szczególnie skomplikowane. Generalnie najtrudniejsze wydawało się zdobycie / zrobienie ramy w jakiejś akceptowalnej cenie. Po przeanalizowaniu różnych opcji doszedłem do wniosku że najprostsze i zarazem najtańsze będzie zrobienie całości z płyty MDF.

Zdecydowaliśmy, że rozmiar samej tafli lustra będzie miał 60x40 cm.

Dodatkowo wokół lustra będzie obramowanie w którym umieszczone zostaną żarówki. Założyłem że ramka będzie miała 10 cm z każdej strony.

Potrzebowałem zatem płyty MDF o wymiarach 80x60 cm.
Oprócz samej płyty na której umieszczone zostanie lustro potrzebowałem fragmentów płyty z których zrobiona zostanie tylna rama lustra, aby zakryć oprawki żarówek oraz przewody elektryczne.

Z tego co udało mi się ustalić, najłatwiej (i chyba nawet najtaniej) iść do marketu budowlanego, gdzie od razu dotną nam płyty na wymiar z dość dużą dokładnością (ja podawałem wymiary z dokładnością do 1 mm i praktycznie nic nie musiałem już w domu korygować).

Ja zrobiłem to akurat w Leroy Merlin, ale pewnie inne markety też mają taką usługę. W Leroy mieli akurat płytę o grubości 18mm która wydawała mi się rozsądnym rozwiązaniem.

Po docięciu płyty wyglądały tak:


Ustaliłem z żoną, że optymalne będzie umieszczenie w lustrze 10 żarówek - po 3 na dłuższych bokach i po dwie na krótszych. Nie chciałem żeby otwory i żarówki były zbyt wielkie, zdecydowałem się zatem na oprawki E14. Średnica oprawek które kupiłem to 28 mm. Rozmierzyłem dokładnie miejsca na oprawki i  łopatkowym wiertłem do drewna wywierciłem otwory o takiej średnicy:


Po wywierceniu otworów przystąpiłem do klejenia tylnej ramy. Jako że płyty były dokładnie przycięte, wystarczyło wszystko "poskładać do kupy" :)


Tak poskładaną ramę zostawiłem na 24h do wyschnięcia. Następnego dnia dodatkowo wzmocniłem konstrukcję blaszanymi kątownikami i wkrętami:


Jako że toaletka będzie stała w sypialni gdzie wszystkie meble mamy w kolorze wenge, w takim kolorze będzie również lustro. Kupiłem odpowiednią okleinę i razem z żoną przystąpiliśmy do dzieła. Tutaj zdecydowanie polecam kogoś do pomocy, ponieważ jednej osobie ciężko jest równo nałożyć okleinę. Efekt wyglądał następująco:


Okleina potrzebuje około 24h aby klej "złapał". Następnego dnia przystąpiłem do montażu oprawek.
Niestety wchodziły w otwory zbyt luźno. Okleiłem je po obwodzie czarną taśmą izolacyjną, i wtedy mogłem je montować "na wcisk", bez konieczności klejenia.
Po montażu całość wyglądała następująco:


Po zamontowaniu oprawek zabrałem się za okablowanie. Tutaj jedna istotna uwaga. Pamiętać należy, żeby żarówki montować równolegle, a nie szeregowo. Wtedy ewentualne przepalenie jednej żarówki nie spowoduje że całe lustro przestanie świecić. Po montażu przewodów całość wyglądała tak:


I teraz kwestia samego lustra. Tutaj miałem sporo problemów. Znaleźliśmy w Leroy'u gładkie lustro 60x40 z frezowanymi krawędziami za około 50 zł, doszliśmy do wniosku że to dobra cena, więc je kupiliśmy. Dopiero w domu zorientowałem się że to lustro ma z tyłu przyklejone uchwyty do powieszenia go na ścianie, których nijak w prosty sposób nie dało się usunąć. Znaleźliśmy różne metody w internecie, próbowaliśmy nawet żyłką wędkarską, ale miałem zbyt cienką i co chwilę się przerywała :). W końcu stanęło na tym że najlepiej rozgrzać trochę te uchwyty suszarką i próbować dość mocno podcinać klej pomiędzy wieszakiem a lustrem starą kartą płatniczą, albo jakąś inną plastikową :) Trzeba jednak robić to bardzo czujnie, ponieważ łatwo zarysować tylną powłokę lustra. Ja niestety zrobiłem jedną rysę. Szczęście w nieszczęściu, że rysa jest bardzo mała i już mamy pomysły na jej zamaskowanie :) Zastanawiam się czy nie lepszym rozwiązaniem byłoby znalezienie lokalnego szklarza i zamówienie takiej tafli lustra na wymiar... Może następnym razem :)

Gdy już uporaliśmy się z uchwytami, przystąpiłem do klejenia lustra. Na początku nakleiłem lustro bezpośrednio na okleinę. Okazało się jednak że klej który miałem nie trzymał się dobrze i pomimo że czekałem 2 dni nie zasechł odpowiednio i tafla lustra się przesuwała. Odkleiłem ją, wyciąłem prostokątny fragment okleiny w miejscu na lustro tak, żeby lustro przylegało bezpośrednio do płyty MDF i nakleiłem lustro ponownie. Teraz klej trzyma zdecydowanie lepiej. Myślę że to również może zależeć od rodzaju zastosowanego kleju.

Wahaliśmy się czy postawić lustro na biurku/toaletce, czy też powiesić na ścianie. Po przymiarkach wygrała druga opcja. Przykręciłem zatem haczyki, podłączyłem przewód z przełącznikiem:


Pozostała jeszcze kwestia żarówek. Podobno do tego typu luster najlepsze jest światło o barwie naturalnej. Wybór takich żarówek jest zdecydowanie mniejszy, ale da się je znaleźć. Są to żarówki o barwie od 4000k do 4500k. Ja zdecydowałem się na "kulki" LED'owe o mocy 4W każda.

Po powieszeniu lustra i wkręceniu żarówek efekt końcowy jest taki:





Na koniec czas na podsumowanie kosztów lustra:


  • Płyta MDF razem z wycięciem 26 zł
  • kątowniki metalowe do wzmocnienia ramy - 9 zł
  • okleina - 30 zł z przesyłką
  • oprawki E14 10 sztuk z przesyłką - 22 zł
  • żarówki LED E14 4W 4000k z przesyłką - 70 zł za 12 sztuk (2 zapasowe)
  • Lustro 50 zł
  • Przewód z przełącznikiem 15 zł
  • moja praca - bezcenna :D
Razem daje to  222 zł. 

Nie liczę kosztów przewodu, kleju, haczyków, które miałem w warsztacie, ale one nie mają jakiegoś większego wpływu na koszt całościowy.

Reasumując, koszt całości wyszedł całkiem znośnie, efekt - pewnie kwestia gustu, żonie się podoba, a wiadomo że jak żona zadowolona to i mąż ma w życiu łatwiej :)

Co bym poprawił... Być może zwęziłbym trochę boczną ramę. Teraz ma 10 cm, myślę że zupełnie wystarczyłoby 5-6 cm, Boczną ramę można zrobić z cieńszego MDF, 10mm chyba by wystarczyło. Zmniejszyłoby trochę wagę lustra, bo cała konstrukcja jest dość ciężka. Z drugiej strony klej pewnie trzymałby słabiej, więc nie wiem czy warto. W każdym razie ogólnie z efektu jestem zadowolony :).


ś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


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



wtorek, 23 września 2014

Sterownik oświetlenia schodów na ATMEGA328P - wdrożenie produkcyjne

Ostatnio bardzo dużo się u mnie działo w temacie przeprowadzki do nowego domu, przez co niestety zaniedbałem trochę bloga. Mam jednak nadzieję że teraz znajdę trochę więcej czasu na nowe wpisy. Udało się produkcyjnie odpalić sterowanie oświetleniem za pomocą arduino i OpenHab. Wrażeniami z tego rozwiązania podzielę się jednak w kolejnych wpisach.
Dzisiaj chciałem pochwalić się działaniem sterownika oświetlenia schodów, o którym pisałem jakiś czas temu. Płytka leżała sobie od tego czasu w szufladzie i czekała aż schody będą gotowe.
Teraz już mogę pokazać końcowy rezultat. Warstwa sprzętowa pozostała bez zmian. Gruntownie zostało zmienione oprogramowanie. Wcześniejsza wersja nie przyjmowała żadnych sygnałów w trakcie zapalania / gaszenia oświetlenia. Obecnie nie ma już tego ograniczenia.
W projektach tego typu świetne jest to, że mając jedno rozwiązanie sprzętowe można zmieniać działanie układu jedynie modyfikując oprogramowanie układu ATMEGA.
Przykładowo - w trakcie korzystania z oświetlenia pojawiła się potrzeba zapalania światła na stałe, bez automatycznego gaszenia. W prosty sposób udało się osiągnąć efekt jedynie zmieniając program.
Fajne... :)



Jeśli macie jakieś pytania lub uwagi, piszcie w komentarzach
Pod tym adresem znajdziecie pliki Eagle ze schematem i płytką (pamiętajcie że płytkę trzeba "oblać masą" przed wydrukiem):

https://drive.google.com/file/d/0BzJpXXOh01BRcTc4YXRyOUJnR00/view?usp=sharing
EDIT: Załączam aktualny kod źródłowy: