Download as pdf or txt
Download as pdf or txt
You are on page 1of 292

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.

com G0105202497
Tytuł oryginału: Programming Your Home: Automate with Arduino, Android, and Your Computer

Tłumaczenie: Mikołaj Szczepaniak

ISBN: 978-83-246-5678-3

© Helion 2013.
All rights reserved.

Copyright © 2012 The Pragmatic Programmers, LLC.


All rights reserved.

No part of this publication may be reproduced, stored in a retrieval system, or transmitted,


in any form, or by any means, electronic, mechanical, photocopying, recording, or otherwise,
without the prior consent of the publisher.

Many of the designations used by manufacturers and sellers to distinguish their products
are claimed as trademarks. Where those designations appear in this book, and The Pragmatic
Programmers, LLC was aware of a trademark claim, the designations have been printed in initial
capital letters or in all capitals. The Pragmatic Starter Kit, The Pragmatic Programmer, Pragmatic
Programming, Pragmatic Bookshelf, PragProg and the linking g device are trademarks of The
Pragmatic Programmers, LLC.

Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu


niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną,
fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje
naruszenie praw autorskich niniejszej publikacji.

Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi


ich właścicieli.

Wydawnictwo HELION dołożyło wszelkich starań, by zawarte w tej książce informacje były
kompletne i rzetelne. Nie bierze jednak żadnej odpowiedzialności ani za ich wykorzystanie,
ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Wydawnictwo
HELION nie ponosi również żadnej odpowiedzialności za ewentualne szkody wynikłe
z wykorzystania informacji zawartych w książce.

Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)

Pliki z przykładami omawianymi w książce można znaleźć pod adresem:


ftp://ftp.helion.pl/przyklady/intdom.zip

Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/intdom_ebook
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.

Printed in Poland.

• Poleć książkę na Facebook.com • Księgarnia internetowa


• Kup w wersji papierowej • Lubię to! » Nasza społeczność
• Oceń książkę

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Opinie o książce Inteligentny dom.
Automatyzacja mieszkania za pomocą
platformy Arduino, systemu Android
i zwykłego komputera
Mike ma bogate doświadczenie w świecie technologii i wykorzystał umie-
jętności z różnych dziedzin do przygotowania tych niezwykłych projektów.
To niesamowite, jak łatwo i tanio można tworzyć tak ciekawe rozwiązania.
Radzę przeczytać tę książkę od deski do deski, aby nie przeoczyć żadnego
pomysłu.
Michael Bengtson, konsultant
Moja rodzina na co dzień korzysta z wygody i bezpieczeństwa oferowa-
nych przez projekt internetowego włącznika światła; ten sam projekt po-
szerzył moją wiedzę na temat komunikacji za pośrednictwem interfejsu
RS-232. To wspaniałe, że mogę sterować oświetleniem domu, nie wstając
z ulubionego fotela. Projekt ćwierkającego karmnika dla ptaków otworzył
mi oczy na zupełnie nowe zastosowania komunikacji radiowej w domu
(wcześniej korzystałem tylko z technologii Wi-Fi). Projekt pozwolił mi też
znacznie skuteczniej włączyć się w akcję ochrony gatunków ptaków poszu-
kujących pokarmu i bezpiecznych siedlisk.
Bob Cochran, specjalista IT
W tej książce Mike Riley wykorzystał potencjał mikrokontrolera Arduino
w sposób, który przypadnie do gustu zarówno nowicjuszom, jak i bardziej
doświadczonym miłośnikom technologii automatyzacji domu.
Sven Davies, wiceprezes ds. aplikacji
Ten doskonały podręcznik powinien trafić na biurko każdego miłośnika
technik „zrób to sam”. Jestem przekonany, że tak jak inżynierowie opro-
gramowania mówią o „książce o wzorcach bandy czworga”, tak w przy-
szłości konstruktorzy hobbyści będą mówili o „książce o automatyzacji
domu Rileya”.
Jon Kurz, prezes firmy Dycet, LLC

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Każda technologia jest tyle warta, ile warte są rozwiązania tworzone przy
jej użyciu. Mike zaopatrzył się w kilka tanich części elektronicznych, płyt-
kę Arduino i trochę kodu źródłowego, aby za pomocą tych prostych kom-
ponentów sprawić, że nasze domy będą dużo ciekawsze i wygodniejsze.
Precyzyjny, jasny sposób prezentacji projektów powoduje, że wszystkie
proponowane rozwiązania są przydatne i sprawiają konstruktorom mnó-
stwo radości.
Maik Schmidt, programista,
autor książki Arduino: A Quick-Start Guide
Jeszcze nigdy nie bawiłem się równie dobrze podczas poznawania nowych
języków, systemów i gadżetów jak podczas lektury tej książki!
James Schultz, programista
Automatyzacja domu to świetna zabawa, a książka Inteligentny dom Mike’a
Rileya pozwoli każdemu od razu zacząć przygodę z odpowiednimi tech-
nologiami. Dzięki tej książce i łatwo dostępnym (za darmo lub za niewy-
górowane kwoty) urządzeniom sprzętowym i programom praktycznie każ-
dy może realizować te świetne projekty.
Tony Williamitis, starszy inżynier systemów wbudowanych
To wspaniałe przeżycie przekonać się, jak urządzenia elektroniczne mogą
oddziaływać na otaczający nas świat (począwszy od naszego własnego
domu)!
John Winans, starszy architekt oprogramowania

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Książkę dedykuję Billowi, Eileen i Josie.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497
0e6f6f1d43742eedec5157bda515121f
0
Spis treści

Podziękowania .................................................................................... 13

Słowo wstępne .................................................................................... 15


Kto powinien przeczytać tę książkę ................................................................... 16
Co znajduje się w tej książce ............................................................................. 16
Arduino, Android, iPhone… mój Boże! .......................................................... 17
Przykłady kodu i stosowane konwencje ............................................................. 20
Zasoby dostępne w internecie .......................................................................... 21

Część I. Przygotowania ............................................23


Rozdział 1. Pierwsze kroki ................................................................. 25
1.1. Czym jest automatyzacja domu? ................................................................ 25
1.2. Gotowe rozwiązania dostępne na rynku ..................................................... 26
1.3. Rozwiązania typu „zrób to sam” ............................................................... 27
1.4. Uzasadnienie inwestycji ............................................................................ 28
1.5. Przygotowywanie warsztatu ....................................................................... 30
1.6. Zapisywanie pomysłów w formie szkiców ................................................... 31
1.7. Zapisywanie, łączenie i testowanie ............................................................ 33
1.8. Dokumentowanie pracy ............................................................................ 34

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
8  Inteligentny dom

Rozdział 2. Potrzebne elementy ........................................................ 37


2.1. Znajomość sprzętu ................................................................................... 38
2.2. Znajomość oprogramowania ..................................................................... 45
2.3. Bezpiecznej zabawy! ................................................................................. 46

Część II. Projekty ......................................................49


Rozdział 3. System powiadamiania o poziomie wody .................... 51
3.1. Czego potrzebujemy ................................................................................. 53
3.2. Budowa rozwiązania ................................................................................ 55
3.3. Łączenie .................................................................................................. 55
3.4. Tworzenie szkicu ...................................................................................... 56
3.5. Implementacja aplikacji internetowej wysyłającej pocztę elektroniczną .......... 64
3.6. Dodanie modułu sieciowego ...................................................................... 67
3.7. Łączenie wszystkich elementów ................................................................. 71
3.8. Następne kroki ......................................................................................... 73

Rozdział 4. Elektryczny pies stróżujący .......................................... 77


4.1. Czego potrzebujemy ................................................................................. 78
4.2. Budowa rozwiązania ................................................................................ 80
4.3. System elektronicznego psa stróżującego .................................................... 82
4.4. Szkolenie psa ........................................................................................... 85
4.5. Testowanie .............................................................................................. 89
4.6. Spuszczamy psa ....................................................................................... 90
4.7. Następne kroki ......................................................................................... 91

Rozdział 5. Ćwierkający karmnik dla ptaków ................................. 93


5.1. Czego potrzebujemy ................................................................................. 95
5.2. Budowa rozwiązania ................................................................................ 98
5.3. Czujnik grzędy ......................................................................................... 98
5.4. Czujnik ziarna ........................................................................................ 102
5.5. Komunikacja bezprzewodowa ................................................................. 106
5.6. Ćwierkanie w Pythonie ........................................................................... 113
5.7. Kończenie projektu ................................................................................. 121
5.8. Następne kroki ....................................................................................... 123

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Spis treści  9

Rozdział 6. Wykrywacz dostarczania paczek ................................ 125


6.1. Czego potrzebujemy ............................................................................... 127
6.2. Budowa rozwiązania .............................................................................. 128
6.3. Łączenie sprzętu .................................................................................... 129
6.4. Pisanie kodu .......................................................................................... 131
6.5. Szkic systemu wykrywania dostarczonych paczek ...................................... 132
6.6. Testowanie szkicu wykrywającego dostarczanie paczek ............................. 133
6.7. Skrypt przetwarzający komunikaty o przesyłkach ...................................... 134
6.8. Tworzenie bazy danych systemu wykrywania przesyłek ............................. 135
6.9. Instalacja niezbędnych pakietów Pythona ................................................. 137
6.10. Pisanie skryptu ...................................................................................... 139
6.11. Testowanie skryptu przetwarzającego komunikaty o paczkach ................... 144
6.12. Instalacja systemu .................................................................................. 145
6.13. Następne kroki ...................................................................................... 146

Rozdział 7. Internetowy włącznik światła .................................... 149


7.1. Czego potrzebujemy ............................................................................... 150
7.2. Budowa rozwiązania .............................................................................. 153
7.3. Łączenie ................................................................................................ 154
7.4. Pisanie kodu klienta w formie aplikacji internetowej .................................. 158
7.5. Testowanie klienta aplikacji internetowej .................................................. 161
7.6. Pisanie kodu klienta dla systemu Android ................................................ 162
7.7. Testowanie aplikacji klienckiej dla systemu Android ................................. 167
7.8. Następne kroki ....................................................................................... 169

Rozdział 8. Automatyzacja działania zasłony ............................... 173


8.1. Czego potrzebujemy ............................................................................... 174
8.2. Budowa rozwiązania .............................................................................. 177
8.3. Stosowanie silnika krokowego .................................................................. 178
8.4. Programowanie silnika krokowego ........................................................... 179
8.5. Dołączanie czujników ............................................................................. 181
8.6. Pisanie szkicu ........................................................................................ 182
8.7. Instalacja sprzętu .................................................................................... 187
8.8. Następne kroki ....................................................................................... 190

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
10  Inteligentny dom

Rozdział 9. Zamek do drzwi sterowany przez Androida .............. 193


9.1. Czego potrzebujemy ............................................................................... 194
9.2. Budowa rozwiązania .............................................................................. 197
9.3. Sterowanie zamkiem z poziomu Androida ............................................... 202
9.4. Pisanie kodu serwera dla systemu Android .............................................. 207
9.5. Pisanie aplikacji klienckiej dla systemu Android ....................................... 220
9.6. Testy i instalacja .................................................................................... 225
9.7. Następne kroki ....................................................................................... 226

Rozdział 10. Dajmy przemówić naszemu domowi ........................ 229


10.1. Czego potrzebujemy .............................................................................. 230
10.2. Konfiguracja głośników .......................................................................... 231
10.3. Wsłuchajmy się w głos systemu ............................................................... 234
10.4. Kalibracja mikrofonu bezprzewodowego ................................................. 238
10.5. Programowanie mówiącego systemu ........................................................ 240
10.6. Rozmowa z własnym domem ................................................................. 249
10.7. Następne kroki ...................................................................................... 250

Część III. Przewidywana przyszłość ....................253


Rozdział 11. Przyszłe projekty ......................................................... 255
11.1. Przyszłość na wyciągnięcie ręki ............................................................... 256
11.2. Prognoza długoterminowa ...................................................................... 260
11.3. Dom przyszłości .................................................................................... 262

Rozdział 12. Więcej pomysłów na projekty ................................... 267


12.1. Wykrywacz bałaganu ............................................................................. 267
12.2. Monitor zużycia energii elektrycznej ........................................................ 268
12.3. Elektryczny strach na wróble .................................................................. 269
12.4. Pilot systemu domowej rozrywki ............................................................. 269
12.5. Wyłącznik urządzeń domowych na czas snu ............................................ 270
12.6. Sterowanie nawadnianiem za pomocą czujnika wilgotności ....................... 270
12.7. Czujniki dymu przystosowane do komunikacji sieciowej ........................... 271
12.8. Zbliżeniowy mechanizm otwierania bramy garażowej ............................... 272
12.9. Inteligentny sterownik klimatyzacji i wentylacji ......................................... 272

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Spis treści  11

12.10. Inteligentna skrzynka na listy ............................................................... 273


12.11. Inteligentne oświetlenie ....................................................................... 273
12.12. Monitorowanie źródeł energii
zasilanych promieniami słonecznymi i wiatrem ..................................... 273

Dodatki ....................................................................275
Dodatek A. Instalacja bibliotek platformy Arduino .................... 277
A.1.1. System Apple OS X ......................................................................... 277
A.1.2. System Linux ..................................................................................... 278
A.1.3. System Windows ................................................................................ 278

Dodatek B. Bibliografia .................................................................... 281

Skorowidz .......................................................................................... 283

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
12  Inteligentny dom

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Podziękowania

O
dkąd pamiętam, uwielbiam majsterkować. Doskonale pamiętam, jak
rozłożyłem na najdrobniejsze elementy zepsuty magnetofon mojego
ojca — te pierwsze doświadczenia nauczyły mnie szacunku dla
technologii stosowanej do produkcji tego i podobnych urządzeń. Od tamtego
czasu zestawy małego konstruktora, kolejki elektryczne i programowalne
kalkulatory zostały zastąpione przez komputery osobiste, urządzenia mobilne
i mikrokontrolery. Przez lata z pasją poznawałem nie tylko zasady działa-
nia części elektronicznych, ale także techniki ich łączenia w celu budowy
zaskakujących rozwiązań, które nierzadko dawały mi mnóstwo satysfakcji
i napawały mnie dumą. Właśnie dlatego pisanie tej książki sprawiło mi
tyle radości.
Jednym z najważniejszych celów tej książki (obok świetnej zabawy) jest
pomaganie innym w dostrzeganiu potencjału drzemiącego w pozornie po-
spolitych konstrukcjach i mechanizmach — rzeczach, które po zastosowa-
niu przemyślanej technologii mogą ułatwić nam życie. Mimo to powstanie
tej książki nie byłoby możliwe bez wsparcia osób, które pomogły mi wy-
brać i właściwie zaprezentować najciekawsze pomysły. Jestem winien tym
osobom ogromną wdzięczność za wsparcie podczas prac nad tą książką.
Wielkie podziękowania należą się redaktor tej książki, Jackie Carter, która
spędziła długie godziny na poprawianiu mojego tekstu, aby cały materiał
był dostatecznie jasny i precyzyjny. Korektorka językowa, Molly McBeath,
dokonywała cudów, znajdując dobrze ukryte (przynajmniej z mojej per-
spektywy) literówki i błędy gramatyczne. Jestem też winien podziękowania

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
14  Inteligentny dom

Susannah Pfalzer za jej zaraźliwy entuzjazm i niespotykane zdolności moty-


wacyjne. Dziękuję także Maikowi Schmidtowi, który jest ekspertem w dzie-
dzinie platformy Arduino, moim kolegą i autorem zatrudnionym w tym
samym wydawnictwie. To jego wcześniejsze sukcesy utorowały drogę dla tej
książki.
Dziękuję także Johnowi Winansowi, technologicznemu geniuszowi, który
udoskonalił kod maszyny stanów używany w wielu projektach. Na moją
wdzięczność zasłużyły także następujące osoby za pomoc w dopracowywa-
niu technicznych aspektów tej książki i pracę na rzecz doprowadzenia tego
zadania do szczęśliwego końca: Sven Davies, Mike Bengtson, Jon Bearscove,
Kevin Gisi, Michael Hunter, Jerry Kuch, Preston Patton i Tony Williamitis.
Dziękuję także Jonowi Eriksonowi i Jonowi Kurzowi za ich entuzjazm i sku-
teczne zachęty do prac nad tą książką. Chciałbym też wyrazić wdzięczność
Bobowi Cochranowi i Jimowi Schultzowi za bezcenną pomoc podczas prac
nad wczesnymi wersjami tej książki. Dziękuję też Philipowi Aabergowi za
stworzenie muzyki, przy której każda praca jest przyjemnością. Jestem też
wdzięczny twórcom i uczestnikom projektów Arduino i Fritzing — to
dzięki nim świat zmienia się na lepsze.
Największe podziękowania należą się jednak mojej żonie, Marinette, i całej
rodzinie za akceptację i wsparcie w czasie, gdy niemal nie wychodziłem ze
swojego pokoju podczas prac nad tą książką. Nie potrafię wyrazić swojej
wdzięczności także dla córki, która przygotowała doskonałe ilustracje do
tej książki. Jestem z Ciebie taki dumy, Marielle!
I wreszcie jestem szczerze wdzięczny Dave’owi Thomasowi i Andy’emu
Huntowi za ich pasję i wizję. Jesteście doskonali.

Mike Riley
Adres e-mail: mike@mikeriley.com
Naperville, grudzień 2011

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Słowo wstępne

W
itam we wspaniałym świecie automatyzacji domu, w którym wszyst-
ko jest możliwe! Każdy, kto kiedykolwiek marzył o domu, który
będzie oferował coś więcej niż schronienie przed zjawiskami
pogodowymi i który udostępni domownikom nowoczesne rozwiązania cyfro-
we, znajdzie w tej książce wskazówki, jak stworzyć odpowiednie mechanizmy.
Dzięki opisanym tutaj łatwym w budowie projektom czytelnik opanuje umie-
jętności potrzebne do planowania i realizacji własnych niepowtarzalnych
projektów automatyzacji domu.
Głównym celem tej książki jest zainteresowanie czytelnika metodami auto-
matyzacji domu i wskazanie ogromnego potencjału drzemiącego w prostych
i niedrogich urządzeniach. Chciałbym też, aby każdy nabrał pewności siebie
i wiary we własne umiejętności, aby w przyszłości realizować własne pomysły.
Opisane projekty mogą też być doskonałym sposobem spędzania czasu
z dziećmi, a gotowe rozwiązania z pewnością będą powodem do dumy dla
naszych małych konstruktorów. Kto wie? Być może nasze dzieła automa-
tyzujące funkcjonowanie domu zmienią świat i będą zaczątkiem jakiegoś
wielkiego biznesu (jeśli na przykład ludzie zainteresują się naszym oszczę-
dzającym czas i pieniądze rozwiązaniem).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
16  Inteligentny dom

Kto powinien przeczytać tę książkę


Książka Inteligentny dom jest przeznaczona przede wszystkim dla konstrukto-
rów, programistów i majsterkowiczów, którzy lubią spędzać wolny czas na
budowie nowoczesnych rozwiązań automatyzujących pewne czynności i ro-
biących wrażenie na znajomych i przyjaciołach. Książka jest adresowana
przede wszystkim do osób zainteresowanych tworzeniem niestandardowych
technologii i rozwiązań elektronicznych na własne potrzeby.
Podczas realizacji projektów opisanych w tej książce sporym ułatwieniem
będzie podstawowa znajomość platformy Arduino i takich języków pro-
gramowania jak Ruby czy Python, jednak znajomość tych technologii nie
jest wymagana. W książce pokazano, jak łączyć te technologie w ramach
niepowtarzalnych konfiguracji eliminujących konieczność wielokrotnego
powtarzania uciążliwych czynności lub zwiększających efektywność zarzą-
dzania domem.
Oprócz skryptów języka Python i usług sieciowych na bazie frameworku
Ruby on Rails w wielu projektach opisanych w tej książce wykorzystano
platformę Android firmy Google do gromadzenia danych o zdarzeniach,
wizualizacji informacji i generowania pewnych działań. Znajomość pod-
staw pakietu Android SDK jest o tyle ważna, że projekty implementowa-
ne z myślą o systemie operacyjnym Android można uruchamiać na popu-
larnych smartfonach.
Dla osób, które wolą coś własnoręcznie zbudować zamiast kupić gotowe
rozwiązanie, ta książka będzie dodatkową motywacją do wykorzystania uzy-
skanej wiedzy jako punktu wyjścia dla dalszych prac nad doskonaleniem
i optymalizacją rozwiązań we własnym domu. Mimo że część projektów wy-
maga łączenia wielu programów i rozwiązań sprzętowych, budowa propono-
wanych mechanizmów nie powinna sprawić nikomu problemów ani wyma-
gać dużych nakładów finansowych. Najważniejszym zadaniem tych projektów
jest jednak pokazanie, że kilka prostych pomysłów pozwala przekształcić sta-
tyczne, analogowe środowisko w inteligentny, cyfrowy dom i że budowa
tych rozwiązań może być świetną zabawą.

Co znajduje się w tej książce


Po wprowadzeniu podstawowych zagadnień związanych z automatyza-
cją domu i omówieniu dostępnych narzędzi skoncentrujemy się w książce
na sposobach konstruowania i programowania ośmiu niepowtarzalnych

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Słowo wstępne  17

projektów, które zwiększą wygodę mieszkańców i umożliwią bardziej efek-


tywne spędzanie wolnego czasu. Każdy projekt wymaga użycia niedrogich
czujników, urządzeń wykonawczych i mikrokontrolerów, a każde z tych urzą-
dzeń cechuje się własnymi niepowtarzalnymi funkcjami. Będziemy łączyć
urządzenia sprzętowe i tworzyć oprogramowanie odpowiedzialne za wiele
różnych funkcji, jak włączanie i wyłączanie przełączników za pośrednictwem
telefonu, wykrywanie dostarczonych paczek i wysyłanie powiadomień w for-
mie wiadomości poczty elektronicznej, publikowanie na Twitterze wpisów
informujących o konieczności dosypania ziarna w karmniku dla ptaków oraz
podnoszenie i opuszczanie zasłon w zależności od natężenia światła i tempe-
ratury w pokoju.
Ponieważ zbiór polecanych umiejętności, które będą przydatne podczas
realizacji tych projektów, obejmuje między innymi programowanie, w tej
książce można znaleźć wiele odwołań do opublikowanych wcześniej nakła-
dem wydawnictwa Pragmatic Bookshelf tytułów. Czytelników zainteresowa-
nych opanowaniem umiejętności programowania platformy Arduino bądź
pisania skryptów języków Ruby lub Python gorąco zachęcam do lektury ksią-
żek wymienionych w dodatku B zatytułowanym „Bibliografia”.
Każdy projekt rozpoczyna się od ogólnego wprowadzenia, po którym nastę-
puje podrozdział „Czego potrzebujemy” zawierający listę potrzebnych urzą-
dzeń. Następny podrozdział (zatytułowany „Budowa rozwiązania”) za-
wiera szczegółowy opis sposobu łączenia elementów sprzętowych projektu.
W zdecydowanej większości projektów (choć nie we wszystkich) opisanych
w książce Inteligentny dom będziemy się posługiwali platformą Arduino. Po
skonstruowaniu i połączeniu urządzeń sprzętowych możemy zaprogramować
nowy system tak, aby podejmował automatyczne działania. Będziemy stoso-
wali bardzo różne programy — od kodu dla kontrolerów Arduino po
skrypty wykonywane na komputerach w celu sterowania urządzeniami oraz
gromadzenia i przetwarzania danych przesyłanych przez elementy sprzętowe.
W ostatnich dwóch rozdziałach tej książki zawarłem własne prognozy roz-
woju automatyzacji domu oraz dodatkowe pomysły na wykorzystanie sprzętu
i oprogramowania użytego we właściwych ośmiu projektach.

Arduino, Android, iPhone… mój Boże!


Błyskawiczny wzrost popularności urządzeń mobilnych spowodował, że
w słowniku technologicznym na stałe zagościł termin „era post-PC”.
Jestem wielkim zwolennikiem postępu i zmian technologicznych, ale też

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
18  Inteligentny dom

żyję dostatecznie długo (przeżyłem trzy wielkie rewolucje polegające odpo-


wiednio na popularyzacji komputerów PC, pojawieniu się internetu i przej-
ściu od komputerów PC do urządzeń mobilnych), by stwierdzić, że zmiany
nie następują tak szybko, jak się o nich mówi. Dopóki aplikacji mobilnych nie
będzie można tworzyć na samych urządzeniach mobilnych (tak jak teraz
są tworzone aplikacje dla komputerów PC na komputerach z systemem Li-
nux, Windows czy Mac), komputer pozostanie najważniejszym narzędziem
w pracy programistów aplikacji mobilnych. To samo dotyczy programowania
platformy Arduino.
Mimo wszystkich tych zastrzeżeń trudno nie zauważyć dynamicznych zmian.
Oddział Microsoft Research był jednym z pierwszych dostawców systemów
operacyjnych dla telefonów komórkowych, który opracowywał rdzenne
aplikacje mobilne bezpośrednio na urządzeniach docelowych (w środowisku
TouchStudio). Damon Kohler, inżynier zatrudniony w firmie Google, opra-
cował technologię Scripting Layer for Android (SL4A), która umożliwia
użytkownikom systemu Android pisanie dość rozbudowanych programów
za pomocą edytora tekstu zainstalowanego w ich telefonach. Płytka IOIO
(czyt. jo-jo) firmy Sparkfun to z kolei dobry przykład pierwszych, zapewne
niedoskonałych prób budowy rozwiązań, które w przyszłości pozwolą zastąpić
komputery PC.
Skoro i tak potrzebujemy komputera z systemem Mac, Linux lub Windows
do programowania platformy Arduino i aplikacji mobilnych opisanych
w tej książce, ten sam komputer można wykorzystać także w roli serwera dla
programów interpretujących i przetwarzających dane wysyłane przez urzą-
dzenia mobilne. Czytelnicy dysponujący tylko jednym komputerem, który
w dodatku ma postać laptopa regularnie zabieranego z domu, powinni roz-
ważyć zakup taniego komputera z systemem Linux lub Mac do roli domowe-
go serwera. Dzięki temu będziemy dysponowali nie tylko dedykowanym ser-
werem monitorującym aplikacje w trybie 24/7/365, ale też serwerem pamięci
masowej NAS (od ang. Network Attached Storage).
Jestem oddanym wyznawcą idei sprzętu i oprogramowania open source. Wła-
śnie dlatego wszystkie projekty opisane w tej książce zbudowano na bazie
takich produktów. Staram się też unikać nadmiernego przywiązywania się
do tej czy innej technologii, producenta sprzętu czy języka programowania.
Kod napisany na potrzeby tej książki można by równie dobrze napisać
w językach C# i Perl, jednak zdecydowałem się na języki Ruby i Python
z uwagi na ich przenośność i szerokie wsparcie open source (także ze strony
licznej społeczności programistów). W roli serwera i systemu wytwarzania

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Słowo wstępne  19

oprogramowania mógłbym wykorzystać komputer z systemem operacyjnym


Windows lub Linux, jednak wybrałem system Mac, w którym języki Ruby
i Python są wstępnie instalowane — oznacza to, że korzystanie z tych języ-
ków jest możliwe bez konieczności instalacji, konfiguracji i rozwiązywania
problemów (a więc dodatkowych nakładów czasu).
Właśnie ze względu na filozofię open source zdecydowałem się prezento-
wać przykłady aplikacji mobilnych opracowanych wyłącznie dla systemu
operacyjnego Android. Mimo że sam wolę urządzenia z systemem iOS
w roli platformy mobilnej, dodatkowe nakłady niezbędne do tworzenia apli-
kacji dla tego systemu stanowią niemały problem. Oprócz konieczności
opanowania języka Objective-C i wielu frameworków oraz ręcznego imple-
mentowania mechanizmów zarządzania pamięcią wdrażanie aplikacji sys-
temu iOS wymaga albo dostępu do odpowiednio przebudowanego urzą-
dzenia, albo wykupienia rocznego konta usługi sieci programistów urzą-
dzeń iPhone. Zupełnie inaczej jest w przypadku pakietu SDK systemu
Android, gdzie wdrażanie aplikacji jest darmowe i ma otwarty charakter.
Programy dla systemu Android dodatkowo oferują większe możliwości
w zakresie wielozadaniowości niż aplikacje systemu iOS. Wymienione za-
lety oczywiście zwiększają ryzyko dla bezpieczeństwa systemu i mogą pro-
wadzić do nieefektywnego używania dostępnych zasobów. Mimo to zachę-
cam czytelników, którzy z różnych względów wolą tworzyć i uruchamiać
programy na innych platformach niż Android, do przenoszenia prostych
aplikacji klienckich opisanych w tej książce do ulubionych systemów ope-
racyjnych i do dzielenia się swoimi dziełami ze społecznością czytelników
książki Inteligentny dom.
Innym terminem, który coraz częściej pojawia się w prasie technicznej, jest
określenie „internet rzeczy” (ang. Internet of Things). To określenie odnosi
się do ciekawej koncepcji, zgodnie z którą rosnąca popularność mikrokon-
trolerów sprawi, że liczba niewielkich urządzeń komunikujących się po-
między sobą za pośrednictwem internetu z czasem przekroczy liczbę ludzi
korzystających z sieci. O ile w przypadku samego wysyłania żądań opisany
warunek być może już teraz jest spełniony, o tyle nawiązywanie komunikacji
w przeciwnym kierunku (z samymi urządzeniami) wciąż stwarza poważne
problemy. Nie wystarczy wiedza techniczna potrzebna do skonfigurowania
dynamicznego adresu serwera DNS i bezpiecznego ustawienia przekazy-
wania portów — zdarza się, że operatorzy internetu blokują porty wycho-
dzące, aby uniemożliwić klientom instalowanie serwerów dedykowanych
na popularnych portach, jak FTP, HTTP (i HTTPS) czy SMTP.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
20  Inteligentny dom

Projekty opisane w tej książce powinny doskonale działać w domowej sieci


lokalnej. Okazuje się jednak, że uzyskanie wskazań czujnika poza siecią lo-
kalną nie jest takie proste. Czy można w czasie rzeczywistym sprawdzać od-
czyty termometru bez konieczności otwierania i przekazywania portów przez
router (nie wspominając o potencjalnych zagrożeniach dla bezpieczeństwa
sieci)?
Okazuje się, że wiele firm opracowuje i intensywnie promuje platformy do-
stępne za pośrednictwem prostych interfejsów API usług sieciowych, które
pozwalają skutecznie omijać te utrudnienia. Do platform tego typu, które
w ostatnim czasie notują dynamiczny wzrost popularności, należą między
innymi Pachube, Exosite i Yaler1. Konfigurowanie tych usług i korzystanie
z oferowanych rozwiązań jest zadziwiająco proste. Zachęcam do odwiedzenia
tych serwisów i przekonania się, jak oferowane mechanizmy przesyłania
komunikatów można wykorzystać we własnych projektach.

Przykłady kodu i stosowane konwencje


Kod opracowany na potrzeby tej książki składa się z programów języka
C/C++ dla platformy Arduino, kodu Javy dla systemu Android, skryptów
języka Ruby dla warstwy pośredniej aplikacji internetowych oraz skryptów
Pythona dla tradycyjnych programów. Większość przykładów kodu została
zaprezentowana w całości (wyjątkiem są rozbudowane biblioteki zewnętrzne
używane w programach dla systemu Android i skryptach na bazie frame-
worku Ruby on Rails). W przykładach kodu we wszystkich tych językach
wyróżniono odpowiednio elementy składniowe, a znaczna część kodu została
dodatkowo opatrzona zarówno standardowymi komentarzami, jak i dodat-
kowymi punktami wskazującymi najważniejsze miejsca listingów.
Specjalne wyróżnienia i dodatkowe ramki są stosowane w tej książce spora-
dycznie, ponieważ zależy mi na możliwie sprawnym i płynnym przekazywa-
niu informacji.

1
Patrz odpowiednio http://www.pachube.com, http://www.exosite.com i http://
www.yaler.org.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Słowo wstępne  21

Zasoby dostępne w internecie


Polecam serwisy internetowe poświęcone technikom „zrób to sam”, w tym
strony Makezine i Instructables2, na których można się wymieniać doświad-
czeniami z liczną społecznością innych hobbystów konstruktorów i maj-
sterkowiczów.
Istnieje także wiele kanałów IRC w serwisie freenode.net oraz specjalistycz-
nych forów w ramach Grup Google poświęconych tym zagadnieniom. Wiele
spośród tych grup koncentruje się na szczegółowych aspektach projekto-
wania gadżetów, automatyzacji domu i eksperymentowania ze sprzętem3.
Wystarczy już tych wstępów. Przejdźmy wreszcie do budowy czegoś poży-
tecznego!

2
Patrz odpowiednio http://www.makezine.com i http://www.instructables.com.
3
http://groups.google.com/group/comp.home.automation/topics

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
22  Inteligentny dom

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Część I
Przygotowania

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
24  Inteligentny dom

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 1.
Pierwsze kroki

Z
anim przystąpimy do łączenia sprzętu i pisania kodu, warto przy-
najmniej na chwilę pochylić się nad podstawami i zastanowić się, co
właściwie rozumiemy przez automatyzację domu, jakie rozwiązania
były dostępne na rynku w przeszłości i dlaczego konstruowanie własnych
rozwiązań ma sens (teraz i w przyszłości).
Przeanalizujemy też kilka zalecanych praktyk projektowych i konstruktor-
skich, które będziemy konsekwentnie stosowali podczas realizacji projek-
tów opisanych w tej książce.
Zaczniemy od zdefiniowania, co rozumiemy przez automatyzację domu.
W dalszej części rozdziału omówimy kilka gotowych rozwiązań dostęp-
nych na rynku, po czym dokonamy krótkiego przeglądu wybranych, naj-
bardziej popularnych urządzeń i programów. Na końcu tego rozdziału
zaprezentuję kilka narzędzi i praktyk, które ułatwiły mi budowę projektów
na potrzeby tej książki oraz wielu innych projektów, które trudno zaliczyć
do kategorii automatyzacji domu.

1.1. Czym jest automatyzacja domu?


Co dokładnie oznacza termin „automatyzacja domu”? Na najprostszym
poziomie automatyzacja jest produktem lub usługą wzbogacającą dom
o działanie, komunikat lub dowolne inne zdarzenie generowane bez bez-
pośredniego udziału właściciela. Przykładem urządzenia automatyzacji
domu jest budzik. Innym przykładem jest czujnik dymu. Problem w tym, że

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
26  1.2. Gotowe rozwiązania dostępne na rynku

wymienione urządzenia są w pełni autonomiczne i nie używają standardo-


wego protokołu komunikacji sieciowej, zatem nie mogą się ze sobą komu-
nikować w sposób zbliżony do komputerów połączonych siecią.
Jednym z najstarszych przykładów automatyzacji domu był przelewowy au-
tomatyczny ekspres do kawy Mr. Coffee wprowadzony na rynek na początku
lat siedemdziesiątych ubiegłego wieku. To proste urządzenie kuchenne
sprawiło prawdziwą radość moim rodzicom, którzy uwielbiali kawę. Świa-
domość, że zaraz po przebudzeniu będą mogli sięgnąć po filiżankę świeżo
zaparzonej kawy, była dla nich czymś wspaniałym. Kto by pomyślał, że to
proste połączenie koncepcji ekspresu do kawy z budzikiem może zmienić
świat?
Obecnie, w dwudziestym pierwszym wieku zwykłe ekspresy do kawy są
przerabiane przez majsterkowiczów, którzy wzbogacają je o karty sieciowe,
czujniki temperatury i mikrokontrolery — tak przebudowane urządzenia
parzą kawę we właściwym momencie i w odpowiedniej temperaturze, po
czym wysyłają wiadomość tekstową informującą właściciela o gotowym na-
poju. Skoro elektronicy hobbyści robią to od lat, zastosowanie tych tanich
elementów elektronicznych w masowo produkowanych urządzeniach jest
tylko kwestią czasu. Okazuje się jednak, że wciąż nie udało się rozwiązać
problemu standardowego protokołu komunikacji pomiędzy urządzeniami
tego typu. Wielu producentów automatyki domowej podejmuje próby
rozwiązania tego problemu i stworzenia niezbędnego protokołu.

1.2. Gotowe rozwiązania dostępne


na rynku
Próby standaryzacji protokołów komunikacji automatycznych urządzeń do-
mowych są podejmowane niemal od czasu wprowadzenia na rynek ekspresu
do kawy Mr. Coffee. Jednym z pierwszych ważnych graczy w tej dziedzi-
nie była firma X10, która nadal oferuje podstawowe i stosunkowo niedrogie
elementy automatyzacji domów. Rozwiązania firmy X10 wykorzystują ist-
niejące okablowanie elektryczne domu. Firma wykorzystała prosty protokół
wysyłania impulsów do przekazywania komunikatów przez stację bazową
X10 lub komputera połączonego z interfejsem komunikacyjnym X10. Tech-
nologia była jednak narażona na problemy związane ze spadkiem jakości
sygnału, obsługą sum kontrolnych i potwierdzaniem otrzymywania komu-
nikatów. Co więcej, dość duże urządzenia X10 i sterowanie przepływem

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 1. • Pierwsze kroki  27

prądu za pomocą przełączników relay switch utrudniało szerokie stosowanie


tych rozwiązań.
Inne firmy co prawda podejmowały próby wyznaczenia standardów komu-
nikacji urządzeń domowych, jak CEBus czy Insteon, jednak żadne z tych
rozwiązań nie zyskało szerokiej akceptacji. Brak jednego powszechnie sto-
sowanego standardu po części wynika z problemu jajka i kury — skoro
elektronika i urządzenia domowe są jednocześnie projektowane i wytwarzane
przez różnych producentów, trudno stwierdzić, która strona powinna dosto-
sowywać swoje produkty do rozwiązań drugiej strony.
Ostatnio firma Google podjęła próbę popularyzacji systemu operacyjnego
Android jako oprogramowania wbudowanego dla inteligentnych urządzeń
instalowanych w całym domu. Czas pokaże, czy Google osiągnie sukces tam,
gdzie poległo wiele innych przedsiębiorstw — historia dotychczasowych
prób nie napawa optymizmem.
Zamiast czekać kolejne dwadzieścia lat na pojawienie się nowego standardu,
który zrewolucjonizuje ten rynek, warto zwrócić uwagę na istniejące pod-
zespoły komputerowe wykorzystujące protokół TCP/IP do komunikacji
z innymi komputerami. Odpowiedni sprzęt kosztuje dzisiaj zaledwie ułamek
tego, ile trzeba było wydać na analogiczne rozwiązania jeszcze kilka lat temu.
Skoro niezbędne komponenty sprzętowe są dostępne dosłownie na wycią-
gnięcie ręki, odpowiedzialność za rozwój tej dziedziny spada na programi-
stów, miłośników automatyki domowej i majsterkowiczów, którzy będą
projektowali i implementowali własne rozwiązania. Garstce szczęśliwców
uda się stworzyć efektywne kosztowo, atrakcyjne rozwiązania, które pewne-
go dnia zawojują rynek i przyczynią się do trwałej zmiany naszych domo-
wych przyzwyczajeń.

1.3. Rozwiązania typu „zrób to sam”


Producenci rozwiązań z kategorii „zrób to sam” są obecnie bardziej aktywni
niż kiedykolwiek wcześniej. Dostępność niedrogiej elektroniki i tanich
komputerów powoduje, że ten rodzaj produktów stał się wyjątkowo atrak-
cyjny. Istnieją też inne czynniki decydujące o atrakcyjności rozwiązań tego
typu. W przeciwieństwie do opatentowanych produktów komercyjnych
projekty realizowane w tym trybie nie mają postaci tajemniczych czarnych
skrzynek. Dysponujemy kodem źródłowym. Dysponujemy wiedzą. Dyspo-
nujemy pomiarami, wskaźnikami i metodami.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
28  1.4. Uzasadnienie inwestycji

Nie dość, że wiemy, jak zbudować odpowiednie rozwiązania, to jeszcze po-


trafimy eliminować usterki, naprawiać te urządzenia i konstruować ewen-
tualne rozszerzenia. Żadne z gotowych rozwiązań dostępnych na rynku
z natury rzeczy nie może w pełni odpowiadać na nasze potrzeby. Produ-
cenci rozwiązań z dziedziny automatyzacji domu starają się tworzyć uni-
wersalne produkty, które będą atrakcyjne dla szerszej bazy klientów. Takie
rozwiązanie wyklucza jednak możliwość tworzenia niepowtarzalnych roz-
wiązań w odpowiedzi na konkretne potrzeby jednego klienta. Okazuje się
jednak, że wystarczy podstawowa wiedza i doświadczenie w realizacji
podobnych projektów, aby opanować sztukę projektowania i budowy roz-
wiązań w pełni pasujących do naszych specyficznych wymagań.
Na przykład w pierwszym projekcie opisanym w tej książce zbudujemy
mechanizm powiadamiania dla zbiornika na wodę, który będzie wysyłał
wiadomości poczty elektronicznej w momencie osiągnięcia pewnego poziomu
w zbiorniku. O ile systemy dostępne na rynku oferują alarmy dźwiękowe,
nie spotkałem się jeszcze (przynajmniej w lokalnym sklepie) z produktem,
który wysyłałby podobne komunikaty za pośrednictwem poczty elektronicznej.
Jeśli chcemy zmodyfikować ten projekt (na przykład poprzez dodanie migają-
cych diod LED, które będą dodatkowo informowały o przekroczeniu stanu
alarmowego), nie musimy kupować nowego gotowego zestawu dostępnego
na rynku.
Zachęcam do spaceru wokół domu. Warto przeanalizować nieefektywne
lub powtarzalne czynności, które doprowadzają nas do szału (tak jak Geor-
ge’a Baileya niezmiennie denerwowało urwane wykończenie poręczy scho-
dów w jego domu). Zanotujmy, co można poprawić dzięki odrobinie po-
mysłowości i automatycznym rozwiązaniom. Będziesz zaskoczony liczbą
pomysłów, które w krótkim czasie przyjdą Ci do głowy.

1.4. Uzasadnienie inwestycji


Bądźmy szczerzy. Wydawanie dodatkowych pieniędzy na części, które mogą,
ale nie muszą prawidłowo działać, nie jest dobrą inwestycją, szczególnie
w zestawieniu z zakupem tańszych, gotowych urządzeń, które oferują te
same lub szersze funkcje od projektowanego systemu. Wiedza i doświadcze-
nie zdobyte podczas samodzielnej budowy tego rozwiązania, radość czerpana
z konstruowania własnego systemu i satysfakcja odczuwana podczas obser-
wowania działającego mechanizmu oczywiście także mają swoją wartość.
Próby usprawiedliwienia takiej inwestycji na przykład przed żoną wyczuloną

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 1. • Pierwsze kroki  29

na punkcie niepotrzebnych wydatków mogą być dość trudne, a argumenty


zaliczane do kategorii „satysfakcja” mogą nie wystarczyć.
Podczas analizowania wszelkich nowych koncepcji projektowych warto pod-
jąć próbę znalezienia scenariusza zapewniającego optymalne wykorzystanie
czasu, wymagającego możliwie niewielkich inwestycji w potrzebne urzą-
dzenia i cechującego się jak największym potencjałem poznawczym. Być
może trzeba będzie wielu eksperymentów i iteracji, zanim wybrany sprzęt
i oprogramowanie zaczną działać zgodnie z naszym pierwotnym wyobraże-
niem. Jeśli jednak nie poddamy się zbyt pochopnie, nasza wytrwałość zosta-
nie wynagrodzona. Takie ograniczenia nie tylko pozwalają wypracować roz-
wiązania niewielkim kosztem, ale też wymuszają na konstruktorze jeszcze
większą kreatywność. Właśnie dlatego starałem się zrealizować wszystkie
projekty opisane w tej książce w warunkach dość ograniczonego budżetu
i konsekwentnie zachęcam do wykorzystywania starych części elektronicznych
i niepotrzebnych materiałów.
Każdy konstruktor powinien odrobić lekcje. Należy sprawdzić w internecie,
czy przypadkiem ktoś nie próbował już zbudować czegoś podobnego. Czy
ta próba skończyła się pomyślnie? Czy warto było zainwestować pieniądze
i czas w realizację tej koncepcji? Czy na rynku są dostępne jakieś gotowe
alternatywne rozwiązania?
Po stwierdzeniu, że pomysł jest unikatowy, warto podjąć próbę oszacowania
kosztów związanych zarówno z czasem poświęcanym na projekt, jak i z mate-
riałami, które będziemy musieli zakupić. Musimy też uwzględnić koszt wszel-
kich narzędzi, które będziemy musieli kupić w celu skonstruowania i przete-
stowania planowanego systemu. Nie należy zaniedbywać tych dodatkowych
wydatków, szczególnie jeśli dopiero zaczynamy swoją przygodę z projektami
„zrób to sam”. Kiedy bardziej zaangażujemy się w realizację tego rodzaju
projektów, szybko odkryjemy, że najtańsza lutownica i kawałek drutu nie
wystarczy — że potrzebujemy wysokiej jakości miernika lub nawet oscylo-
skopu. Jedną z zalet budowy własnych rozwiązań jest możliwość realizacji
projektu w miejscu zamieszkania. Każdy początkujący majsterkowicz szybko
poznaje innych miłośników tej formy spędzania wolnego czasu w swojej
okolicy — w ten sposób zyskujemy jednocześnie kompanów do rozmowy,
znajomych, od których możemy pożyczać przydatny sprzęt, źródła cennych
wskazówek i towarzyszy zachęcających do ustawicznego rozwoju.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
30  1.5. Przygotowywanie warsztatu

1.5. Przygotowywanie warsztatu


Warunkiem tworzenia dobrych produktów jest właściwe projektowanie.
Realizacja projektów w środowisku, które nie będzie u nas powodowało
frustracji, z pewnością ułatwi przestrzeganie przyjętych procedur i pozwoli
zachować zdrowie psychiczne.
Należy pracować w dobrze oświetlonym i wentylowanym pomieszczeniu.
Spełnienie tych warunków jest szczególnie ważne podczas lutowania. Warto
otworzyć okno i zainstalować niewielki wentylator, który będzie wyciągał
opary na zewnątrz. Jeśli otwarcie okna jest niemożliwe, należy przynajmniej
użyć wyciągu oparów lutowniczych.
Jeśli przestrzeń robocza na to pozwala, warto zadbać o duży stół, na którym
będzie można swobodnie rozłożyć używane części elektroniczne. Stół na-
leży oczywiście umieścić blisko gniazdek elektrycznych, a na samym stole
warto umieścić listwę zasilającą, aby zapewnić możliwie łatwy dostęp.
Używane części należy umieścić w niewielkich pojemnikach, słoikach, opa-
kowaniach po lekach i puszkach — we wszystkim, co pomoże uporządkować
kondensatory, rezystory, diody LED, przewody, osłony, silniki i czujniki oraz
śledzić zapasy potrzebnych części.
Warto postawić komputer albo w bezpośrednim sąsiedztwie tak przygoto-
wanego warsztatu, albo wręcz na stole warsztatowym. Najwygodniejszym
rozwiązaniem będzie oczywiście laptop. W przypadku komputera stacjo-
narnego należy tak rozplanować położenie monitora, myszy i klawiatury
(dwóch ostatnich najlepiej bezprzewodowych), aby zajmowały możliwie
niewielką część przestrzeni roboczej.
Należy konsekwentnie unikać bałaganu zarówno na stole, jak i pod nim
i wokół niego. Porządek nie tylko ogranicza ryzyko pożaru, ale też ułatwia
znajdowanie używanych komponentów, które staczają się ze stołu w nie-
znane zawsze wtedy, gdy są najbardziej potrzebne.
I wreszcie należy dbać o zachowanie pierwotnego charakteru przestrzeni
roboczej — wyznaczone miejsce powinno służyć właśnie do realizacji pro-
jektu. Niektóre projekty przypominają układanie skomplikowanych puzzli.
Często potrzebujemy miejsca do przechowywania częściowo złożonych
elementów budowanego systemu i jednocześnie przestrzeni do dalszych
prac. Właśnie możliwość przystąpienia do pracy w każdej chwili (zamiast
każdorazowego zaczynania od wypakowywania przewodów i części z wiel-
kiej torby) sprawia, że projekty są źródłem radości, nie frustracji.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 1. • Pierwsze kroki  31

1.6. Zapisywanie pomysłów


w formie szkiców
W przypływie inspiracji nic nie może zastąpić tradycyjnego ołówka i kartki
papieru, dzięki którym można błyskawicznie utrwalić nowe pomysły. Kon-
struktorzy, którzy wolą zapisywać swoje projekty na komputerze, mają do
dyspozycji wiele darmowych narzędzi open source dostępnych dla wszystkich
platform. Sam używam tych narzędzi do opisywania swoich pomysłów
i dokumentowania zrealizowanych projektów:
 Narzędzie Freemind doskonale nadaje się do organizowania pomy-
słów, celów i zależności1. Ta dojrzała aplikacja do odwzorowywania
pomysłów znacznie ułatwia przenoszenie pomysłów z głowy do kom-
putera i analizowanie zależności pomiędzy tymi pomysłami. Narzę-
dzie pozwala oszczędzać czas i pieniądze, ponieważ ułatwia od-
krywanie najważniejszych pomysłów, eliminuje nadmiarowe elementy
i umożliwia nadawanie priorytetów poszczególnym zadaniom.
 Fritzing to aplikacja do rysowania diagramów, którą zaprojektowa-
no przede wszystkim z myślą o dokumentowaniu układów na plat-
formie Arduino2. Narzędzie nie jest jednak gotowe i wymaga jeszcze
wielu poprawek. Wiele popularnych czujników wciąż nie jest repre-
zentowanych przez odpowiednie ikony, ale biblioteka obiektów stale
rośnie, a w sam projekt angażuje się coraz więcej programistów. Sam
używam tej aplikacji wyłącznie do dokumentowania projektów na bazie
platformy Arduino — właśnie dlatego schematy połączeń prezen-
towane w tej książce są generowane za pomocą narzędzia Fritzing.
 Inkscape to prosty w użyciu program do rysowania grafiki wektorowej,
który ułatwia zapisywanie w komputerze rozmaitych koncepcji (także
tych niezwiązanych z platformą Arduino)3. Mimo że aplikacja Inksca-
pe jest adresowana przede wszystkim do grafików, dostępne w jej ra-
mach precyzyjne narzędzia pomiarowe wprost doskonale nadają się do
weryfikacji wstępnych założeń i szkicowania pomysłów na realizację
projektów.

1
http://freemind.sourceforge.net
2
http://fritzing.org/
3
http://inkscape.org

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
32  1.6. Zapisywanie pomysłów w formie szkiców

Warto pamiętać o jeszcze innej opcji — o tabletach i czytnikach, które coraz


częściej przejmują zadania zastrzeżone wcześniej dla papierowych notatek.
Nie zdziwiłbym się, gdyby okazało się, że także ta książka jest teraz czytana
na tablecie iPad czy czytniku Kindle. Oprócz poszukiwania informacji ta-
blety wprost idealnie nadają się do zapisywania pomysłów i sporządzania
wstępnych szkiców dla planowanych projektów. iPad (lub tablet z systemem
Android) ustawiony na odpowiedniej podstawie może być używany jako
wygodny podręcznik i notatnik. Takie urządzenie może służyć do szkico-
wania projektów, śledzenia postępu, ustalania priorytetów i sporządzania
notatek w trakcie prac.
Oto moje ulubione aplikacje dla iPada, których używam podczas realizacji
swoich projektów:
 Elektor Electronic Toolbox to leksykon części elektronicznych obejmują-
cy wiele przydatnych kalkulatorów i narzędzi do konwersji jednostek4.
 iCircuit to symulator układów elektronicznych, który znacznie ułatwia
rozumienie i interpretację układów w porównaniu ze statycznymi
schematami drukowanymi na papierze5.
 iThoughts HD to aplikacja stworzona z myślą o zapisywaniu pomy-
słów projektanta. Aplikacja oferuje możliwość importowania i eks-
portowania plików narzędzia Freemind6.
 Narzędzie miniDraw to program do rysowania grafiki wektorowej,
którą można eksportować w formacie SVG. Oznacza to, że schematy
rysowane w tym programie można importować w aplikacji Inkscape7.
Opisane aplikacje nie służą tylko do projektowania i dokumentowania pro-
jektów — w wielu dobrze przemyślanych i prawidłowo realizowanych pro-
jektach można używać tych aplikacji także do prowadzenia precyzyjnych
pomiarów i weryfikowania założeń za pomocą odpowiednich testów.

4
http://www.creating-your-app.de/electronic_toolbox_features.html?&L=1
5
http://icircuitapp.com/
6
http://ithoughts.co.uk
7
http://minidraw.net/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 1. • Pierwsze kroki  33

1.7. Zapisywanie, łączenie i testowanie


Nie istnieje niestety dobry programowy emulator platformy Arduino. Oka-
zuje się jednak, że programy tworzone dla tej platformy zwykle są na tyle
proste i realizują na tyle konkretne zadania, że cykle kompilacji, uruchamia-
nia i diagnozowania nie są zbyt długie. Dobre techniki kodowania i testo-
wania znacznie ułatwiają budowę rozwiązań wysokiej jakości. To samo
dotyczy konstruowania i łączenia fizycznych systemów, w tym rozwiązań
elektronicznych.
Mimo że niemal wszystkie projekty opisane w tej książce były konstruowa-
ne bez użycia lutownicy, warto pamiętać, że trwałe konstrukcje wymagają
dobrych technik lutowania, które zagwarantują właściwe przewodzenie prądu.
Najlepszym rozwiązaniem jest konsekwentne sprawdzanie wszystkich połą-
czeń (na przykład za pomocą uniwersalnych płytek montażowych) przed
trwałym zlutowaniem łączeń.
Warto też stosować dobre, sprawdzone techniki testowania kodu. Nieza-
leżnie od tego, czy chodzi o kod mikrokontrolera dla platformy Arduino,
czy o skrypty języka Ruby lub Python wykonywane na serwerze, warto
stosować metodykę wytwarzania sterowanego testami (ang. Test-Driven
Development — TDD). Istnieje wiele dobrych frameworków testowych
i książek poświęconych temu zagadnieniu. Polecam artykuł Iana Deesa zaty-
tułowany „Testing Arduino Code” (wydany w numerze PragPub z kwietnia
2011 roku) oraz książkę Continuous Testing: with Ruby, Rails, and
JavaScript [RC11]8.
Podczas pisania skryptów języka Python warto przygotowywać i stosować
testy jednostkowe (na przykład przy użyciu narzędzia py.test). Podczas
kodowania w języku Ruby i tworzenia internetowego interfejsu użytkownika
na bazie frameworku Rails warto rozważyć użycie narzędzia RSpec (więcej
informacji na temat tego narzędzia można znaleźć w książce The RSpec
Book [CADH09]). Także aplikacje tworzone dla systemu Android należy
testować za pomocą odpowiedniego frameworku9. Nawet podczas pracy
nad małymi aplikacjami stosowanie sprawdzonych metodyk testowania
znacznie ułatwia podnoszenie jakości kodu i jednocześnie pozwala zachować
zdrowie psychiczne.

8
http://www.pragprog.com/magazines/2011-04/testing-arduino-code
9
http://developer.android.com/guide/topics/testing/testing_android.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
34  1.8. Dokumentowanie pracy

Warto opanować umiejętność korzystania z multimetru. Podobnie jak pro-


gramowy debuger, multimetr może być bardzo przydatny podczas prób oceny
wewnętrznego działania budowanego systemu — na przykład do znajdowa-
nia miejsca, w którym dochodzi do zwarcia. Oprócz wykrywania proble-
mów multimetr jest przydatny także podczas mierzenia parametrów prądu
elektrycznego. Za pomocą tego urządzenia możemy na przykład określić, czy
bateria słoneczna dostarcza wystarczająco dużo energii elektrycznej (w nie-
przerwany sposób), aby zasilić siłownik sterowany przez mikrokontroler.
Czytelnicy, którzy nie wiedzą, jak używać multimetru, mogą wpisać w ulu-
bionej wyszukiwarce internetowej wyrażenie voltmeter tutorial video. W inter-
necie opublikowano mnóstwo filmów instruktażowych.

1.8. Dokumentowanie pracy


Ręcznie rysowane bazgroły są dobrym punktem wyjścia, jednak z czasem
wiele projektów komplikuje się i wymaga uważnego zarządzania dostępnymi
(ale ograniczonymi) zasobami oraz analizy sprzętu, który nie działa zgodnie
z pierwotnymi założeniami. Ostateczny projekt może się zasadniczo różnić
od oryginalnego. Właśnie dlatego dysponowanie precyzyjną, czytelną i zwię-
złą dokumentacją na końcu projektu jest takie ważne, szczególnie jeśli ta
dokumentacja ma być udostępniana innym konstruktorom.
Takie aplikacje jak Fritzing mogą bardzo ułatwić generowanie czytelnych,
kolorowych schematów połączeń. W ten sposób można dużo lepiej udoku-
mentować dokładną strukturę projektu. Nie ma niczego gorszego od wpa-
trywania się w rozmazane, zrobione pod niewłaściwym kątem zdjęcia
w serwisie Flickr lub nagrania w serwisie YouTube prezentujące przewody
podłączone do słabo widocznej płytki, zwłaszcza jeśli jest to najważniejszy
element dokumentacji. Dokumentacja fotograficzna lub w formie nagrań wi-
deo jest ciekawym uzupełnieniem, jednak dobrze zaprojektowany system powi-
nien być udokumentowany także w formie czytelnych schematów połączeń.
Kod źródłowy powinien zawierać opisowe komentarze, nawet jeśli cały
projekt składa się z prostych skryptów i szkiców. W ten sposób można nie
tylko ułatwić interpretację poszczególnych funkcji w kodzie przez innych
programistów czy konstruktorów — dobre komentarze mogą dokumentować
stan naszej wiedzy i rozmaite koncepcje przede wszystkim dla nas samych.
A jeśli dodatkowo udostępniamy swój kod w publicznych repozytoriach, jak
Github czy Sourceforge, dobre komentarze będą świadczyły o naszym pro-
fesjonalizmie i sprawią, że zyskamy uznanie wśród innych autorów i twórców.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 1. • Pierwsze kroki  35

Po tych wszystkich zaleceniach chciałbym podkreślić, że największą warto-


ścią projektów opisanych w tej książce jest radość z ich realizacji. Doświad-
czenie zdobyte podczas prac nad tymi projektami powinno być zachętą do
rozwijania proponowanych koncepcji i dostosowywania ich do niepowta-
rzalnych potrzeb i celów projektowych każdego czytelnika.
W następnym rozdziale omówię sprzęt i oprogramowanie, którego będziemy
używali podczas realizacji projektów. Zasugeruję też optymalne konfiguracje
poszczególnych elementów.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
36  1.8. Dokumentowanie pracy

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 2.
Potrzebne elementy

Z
anim przystąpimy do właściwej realizacji projektów opisanych w tej
książce, musimy przeanalizować materiały i zalecane metodyki, które
będziemy stosowali podczas budowy tych rozwiązań.
Najważniejszą zasadą, którą stosowałem podczas przygotowywania tej
książki, było zachowanie prostoty i możliwie niewielkich kosztów w przy-
padku wszystkich prezentowanych projektów. Konstruowanie rozwiązań
podobnych do konstrukcji Rube’a Goldberga, kosztujących tysiące złotych
i używanych do otwierania puszek z zupą, oczywiście może sprawić twór-
cy mnóstwo radości, jednak nieporównanie bardziej praktycznym wyjściem
będzie kupienie otwieracza za zaledwie kilka złotych. Robiłem, co w mojej
mocy, aby najlepiej wykorzystać pieniądze i czas poświęcany każdemu pro-
jektowi. Zaledwie kilka spośród tych projektów wymaga nakładów prze-
kraczających dwieście złotych i zajmuje więcej niż godzinę.
Dobrym rozwiązaniem jest wielokrotne wykorzystywanie tych samych
elementów. Wielokrotne stosowanie gotowych rozwiązań jest oczywiście
prostsze w przypadku oprogramowania, ale także wiele elementów sprzę-
towych stwarza taką możliwość. Właśnie dlatego tak dużą popularnością
cieszą się niedrogie płytki mikrokontrolerów (na przykład Arduino), które
stanowią serce wielu takich projektów1. Aby jak najskuteczniej oszczędzać
pieniądze i ograniczać inwestycje w sprzęt, warto podjąć próbę rozpoczę-
cia dwóch projektów równocześnie, aby po pierwszych próbach (ale przed

1
http://arduino.cc/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
38  2.1. Znajomość sprzętu

zakupem na przykład tuzina płytek Arduino) zdecydować, który z nich ma


większe szanse powodzenia. Po zrealizowaniu najciekawszych projektów warto
rozwijać zbudowane konstrukcje, doskonalić je i łączyć w dowolny sposób.
Czytelników, którym uda się stworzyć coś naprawdę ciekawego, zachęcam
do dzielenia się swoimi odkryciami na oficjalnym forum tej książki.
Wymagania większości projektów polegających na tworzeniu oprogramo-
wania są stosunkowo niewielkie — wystarczy dostęp do komputera oraz
wybór języka programowania i frameworków potrzebnych do działania
aplikacji. Jeśli jednak projekt wymaga użycia sprzętowych czujników, sil-
ników, nadajników radiowych i kontrolerów, przebieg procesów projekto-
wania i konstruowania systemu jest nieco bardziej złożony. Każdy projekt
składa się w istocie z dwóch podstawowych składników: zbioru fizycznych
elementów oraz oprogramowania, które interpretuje i przetwarza dane gro-
madzone przez urządzenia sprzętowe. Przeanalizujmy teraz elementy skła-
dające się na te dwa najważniejsze aspekty realizacji projektów.

2.1. Znajomość sprzętu


Płytki Arduino, czujniki i silniki (nazywane też urządzeniami wykonaw-
czymi — ang. actuators) używane podczas realizacji projektów można kupić
w wielu sklepach internetowych (sam zaopatruję się w sklepach Adafruit
Industries i Sparkfun)2. Najbardziej oszczędni konstruktorzy mogą zna-
leźć potrzebne urządzenia na aukcjach internetowych. Kupowanie używa-
nych części od sprawdzonych sprzedawców jest szczególnie korzystne, jeśli
z różnych względów potrzebujemy starszych elementów platformy An-
droid lub kontrolerów X10. Kupujący powinien jednak zachować ostrożność
— czas na sprawdzenie kupionego urządzenia od momentu jego zakupu
i dostarczenia jest krótki i zwykle obejmuje zaledwie kilka dni. Okazuje się,
że niektóre firmy (na przykład Adafruit i Sparkfun) dbają o swoją reputację
`do tego stopnia, że ich działy obsługi klienta akceptują praktycznie wszystkie
uzasadnione żądania wymiany towaru.
Każdy projekt opisany w tej książce obejmuje podrozdział „Czego potrze-
bujemy”, w którym wymieniono komponenty sprzętowe i programowe
potrzebne do budowy danego rozwiązania. Znalezienie i zakupienie niezbęd-
nego sprzętu w internecie nie powinno stanowić najmniejszego problemu,

2
Patrz odpowiednio http://www.adafruit.com i http://www.sparkfun.com.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 2. • Potrzebne elementy  39

a w niektórych projektach dodatkowo wykorzystano skrawki materiałów czy


popularne sprzęty domowe, np. suszarki do ubrań. Poniżej wymieniłem
wszystkie elementy elektroniczne potrzebne do realizacji projektów pre-
zentowanych w tej książce wraz z przybliżonymi cenami:
 Arduino Uno, Duemilanove lub Diecimila: 80 zł;
 moduł sieciowy (ang. Ethernet shield): 110 zł;
 moduł dźwiękowy (ang. wave shield) z głośnikiem, przewodem i kartą
SD: 100 zł;
 pasywny czujnik ruchu na podczerwień (PIR): 40 zł;
 czujnik ugięcia: 50 zł;
 rezystancyjny czujnik siły nacisku: 40 zł;
 analogowy czujnik temperatury TMP36: 5 zł;
 fotorezystor CdS (powszechnie znany jako fotokomórka): 2 zł;
 standardowy serwomotor (silnik wykonawczy): 50 zł;
 rygiel elektryczny zasilany prądem stałym 12 V firmy Smarthome:
120 zł;
 dwa moduły XBee z adapterami: 230 zł;
 przejściówka FTDI: 50 zł;
 ładowarka słoneczna z wbudowanym akumulatorem: 100 zł;
 interfejs szeregowy X10 CM11A firmy ActiveHome: 150 zł;
 standardowy przełącznik ścienny X10 PLW01: 40 zł;
 konwerter port szeregowy – USB: 50 zł;
 komputer domowy (najlepiej z systemem Linux lub Mac): od 700 do
7000 zł w zależności od modelu;
 bezprzewodowy głośnik Bluetooth: 250 zł;
 telefon G1 z systemem Android: od 120 do 400 zł (w zależności od
stanu);
 smartfon z systemem Android: od 50 do 600 zł w zależności od
funkcji telefonu i rodzaju umowy;
 płyta Sparkfun IOIO ze złączem JST, złącze barrel jack-JST (2-pin)
oraz zasilacz prądu stałego 5 V: 180 zł;
 przewód z męską końcówką USB i męską końcówką mini-USB:
10 zł;
 przewód z żeńską końcówką barrel jack 2.1 mm: 10 zł;

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
40  2.1. Znajomość sprzętu

 szpula przewodu (22 AWG powinien wystarczyć): 10 zł;


 rezystor 10 kΩ: 0,50 zł;
 rezystor 10 MΩ: 0,50 zł;
 mała uniwersalna płytka montażowa: 15 zł;
 taśma izolacyjna lub wąż termokurczliwy: 15 zł;
 9-woltowy zasilacz prądu stałego: 15 zł;
 12-woltowy zasilacz impulsowy 5A: 75 zł;
 PowerSwitch Tail II z rezystorem 1 kΩ oraz tranzystor NPN 4222 A:
60 zł;
 silnik krokowy: 45 zł.
Każdy z tych elementów może być wielokrotnie stosowany we wszystkich
projektach opisanych w tej książce. Jeśli efekt któregoś z tych projektów
zostanie trwale zainstalowany w domu konstruktora, trzeba będzie uzu-
pełnić zapas części użytych do budowy tego systemu. Realizacja projektów
z kategorii „zrób to sam” (ang. do it yourself — DIY) jest, podobnie jak
pisanie kodu, zajęciem dającym mnóstwo satysfakcji i silnie uzależniającym.
Musimy się liczyć ze wzrostem wydatków na części elektryczne wraz z rosną-
cym zaufaniem we własne możliwości.
Spośród wszystkich elementów używanych w tej książce trzy produkty będą
wspominane szczególnie często: smartfony z systemem Android, platforma
Arduino oraz radia XBee. Wszystkie te elementy zostaną krótko omówione
w poniższych punktach. Czytelników zainteresowanych dodatkowymi zasto-
sowaniami tej przydatnej elektroniki zachęcam do lektury tytułów poświę-
conych systemowi Android, platformie Arduino i modułom XBee, które
wymieniłem w dodatku B. Zaproponowane tam książki zawierają mnó-
stwo informacji na temat tych niezwykłych, stale ewoluujących technologii.

Programowanie dla systemu Android


System operacyjny Android utrzymuje gwałtowny wzrost popularności
(a w niektórych przypadkach wręcz dominacji) na rynkach telekomunika-
cyjnych i systemów wbudowanych. Firma Google ogłosiła też rozpoczęcie
projektu Android@Home i zaczęła zachęcać programistów i producen-
tów elektroniki konsumenckiej do rozważenia opcji stosowania systemu
Android jako technologii bazowej dla systemów inteligentnych domów.
Wielu producentów elektroniki wprowadza na rynek urządzenia zgodne

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 2. • Potrzebne elementy  41

z pakietem Android Open Accessory Development Kit (ADK) i wyko-


rzystujące interfejsy zaprojektowane przez firmę Google3.
Na potrzeby tej książki wybrałem płytkę IOIO firmy Sparkfun do roli
płytki zgodnej z ADK. W czasie kiedy ta książka trafiała do druku, ob-
sługa standardu ADK przez płytkę IOIO wciąż znajdowała się w fazie beta,
a ładowanie oprogramowania z obsługą tego standardu było dość kłopotliwe.
W rozdziale 9. zatytułowanym „Zamek do drzwi sterowany przez An-
droida” zostanie omówione alternatywne rozwiązanie — projekt korzy-
stający z tradycyjnych wywołań pakietu SDK systemu Android i niestan-
dardowej biblioteki sprzętowej obsługiwanej obecnie przez płytkę IOIO.
Malejące koszty sprzętu potrzebnego do budowy oprogramowania na bazie
pakietu ADK stwarzają programistom i producentom nowe możliwości, które
wcześniej były nieosiągalne ekonomicznie. Na razie używany telefon z syste-
mem Android pierwszej generacji połączony z płytką IOIO wciąż oferuje
większe możliwości i jest nieporównanie tańszy niż platforma ADK oferująca
podobne funkcje (aparat, GPS, Bluetooth, Wi-Fi), na przykład w formie
smartfonu. Do czasu, aż urządzenia zgodne ze standardem ADK stanieją
i zyskają na popularności, zdobędziemy ogromną przewagę nad konkurencją
— opanujemy ekosystem wytwarzania aplikacji dla systemu Android.
Niektóre projekty tworzone dla systemu Android wymagają budowy za-
równo klienta działającego w tym systemie, jak i aplikacji serwera. Mimo
że aplikacje klienckie można pisać we frameworkach aplikacji internetowych
niezależnych od urządzeń, jak jQuery Mobile4, warto rozumieć i mieć na
uwadze wartość aplikacji natywnych. Budowa oprogramowania od początku
na bazie natywnych mechanizmów w przyszłości znacznie ułatwi korzy-
stanie z zaawansowanych funkcji telefonu (część tych funkcji jest niedo-
stępna dla interfejsu standardowych aplikacji internetowych). Co więcej,
aplikacje natywne zwykle są szybciej ładowane i szybciej reagują na pole-
cenie niż ich odpowiedniki działające w przeglądarkach internetowych.
Mimo że wcześniejsze doświadczenie w tworzeniu aplikacji dla systemu
Android nie jest niezbędne do budowy programów na potrzeby przykładów
z tej książki, znajomość pakietu Android SDK z pewnością będzie sporym
ułatwieniem5.

3
http://developer.android.com/guide/topics/usb/adk.html
4
http://jquerymobile.com/
5
http://developer.android.com/sdk

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
42  2.1. Znajomość sprzętu

Programowanie platformy Arduino


Czytelnicy, którzy programowali wcześniej w języku C lub C++, poczują się
jak w domu, pisząc kod dla mikrokontrolera ATMega 168/328 platformy
Arduino. Pisanie programów dla platformy Arduino (określanych mianem
szkiców — ang. sketch) jest dość proste, jeśli tylko opanujemy podstawową
strukturę tych aplikacji.
Przeanalizujmy teraz podstawową strukturę szkicu platformy Arduino. Po-
dobnie jak programy języka C, szkice tej platformy rozpoczynają się od wyra-
żeń #include importujących niezbędne biblioteki kodu. Po tych wyrażeniach
następują konstrukcje inicjalizujące zmienne i obiekty globalne, które zwy-
kle są używane w ciele funkcji setup() danego szkicu. Funkcja setup()
zwykle jest używana do odwoływania się do fizycznych punktów połączeń
(nazywanych wtykami — ang. pin) oraz do przypisywania wartości zmien-
nym globalnym zdefiniowanym w sekcji inicjalizacji. Przykładem takiego
przypisania może być wyrażenie int onboard_led = 13; zdefiniowane przed
funkcją setup(). W ten sposób instruujemy platformę Arduino, że ma użyć
wtyku nr 13 (miejsca instalacji diody LED), tak aby był dostępny w ko-
dzie szkicu. Wtyk można następnie przypisać w ciele funkcji setup() za
pomocą następującego wiersza: pinMode(onboard_led, OUTPUT).
Po przetworzeniu wyrażeń przypisujących wartości zmiennym i zakończeniu
inicjalizacji programu przez setup() szkic rozpoczyna wykonywanie głów-
nej funkcji loop(). Ciało tej funkcji jest wykonywane w nieskończoność.
To tutaj szkic czeka na wystąpienie określonego zdarzenia lub wielokrot-
nie wykonuje zdefiniowaną czynność. Do omawiania tej struktury oraz
procesu pisania, kompilowania i uruchamiania programów platformy Ar-
duino wrócimy przy okazji analizy pierwszego projektu — systemu po-
wiadamiania o poziomie wody.
Do pisania szkiców można używać dowolnego edytora tekstu. Największe
uznanie wśród programistów zyskało darmowe, zintegrowane środowisko
wytwarzania Arduino Integrated Development Environment (IDE) do-
stępne na stronie internetowej platformy Arduino. To napisane w Javie
środowisko programowania oferuje wszystkie elementy potrzebne do kom-
pilowania szkiców na rozkazy maszynowe mikrokontrolera ATMega. Do
środowiska są dołączone dziesiątki przykładowych szkiców, które ułatwiają
szybkie opanowanie składni i dobrze ilustrują bogactwo czujników i silników
obsługiwanych na platformie Arduino. Opisane środowisko programowa-
nia napisano w Javie, zatem działa identycznie na komputerach z systemami
Windows, Mac i Linux.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 2. • Potrzebne elementy  43

Jaś pyta...
Czy środowisko Arduino IDE zawiera wirtualny
emulator?
Inaczej niż w przypadku większości środowisk wytwarzania aplikacji
dla komputerów i urządzeń mobilnych, nie istnieje oficjalny emulator
platformy Arduino. Symulowanie działania wielu różnych fizycznych
czujników i silników obsługiwanych przez platformę Arduino byłoby
bardzo trudne. Wielu niezależnych producentów i programistów
próbowało stworzyć takie narzędzie, jednak wszystkie te rozwiązania
albo działają w wybranych systemach operacyjnych, albo emulują
układ ATMega zamiast całej platformy Arduino. Użytkownicy sys-
temu operacyjnego Windows mają do wyboru emulatory Virtual
Breadboard i Emulare6 — polecam zwłaszcza program Virtual Bread-
board z uwagi na jego wirtualną reprezentację sprzętowej platformy
Arduino. Środowisko Virtual Breadboard dodatkowo udostępnia
ograniczony zbiór emulowanych czujników i innych urządzeń, które
można łączyć na ekranie z wirtualną reprezentacją płytki Arduino.
Zważywszy na dość niski koszt samej platformy Arduino, niewielu
konstruktorów używa emulatora do innych zadań niż testy jednost-
kowe lub jako wygodnej, przenośnej reprezentacji platformy sprzę-
towej. Zamiast tracić czas na eksperymenty z emulatorami lepiej wy-
dać pieniądze na właściwą platformę sprzętową. Szkice są krótkie,
a okno danych szeregowych środowiska Arduino IDE jest na tyle wy-
godne i pomocne, że można na tej podstawie bez trudu diagnozo-
wać i doskonalić kod wykonywany na prawdziwym sprzęcie.

Programowanie modułów XBee


Inną ważną technologią, której będziemy używali w wielu projektach pre-
zentowanych w tej książce, jest urządzenie radiowe na bazie specyfikacji
łączności bezprzewodowej IEEE 802.15.4 (znanej szeroko jako XBee).
Komunikacja radiowa XBee wprost idealnie nadaje się do realizacji projek-
tów bezprzewodowych na bazie platformy Arduino z uwagi na niski koszt,

6
Patrz odpowiednio http://www.virtualbreadboard.net i http://emulare.sourceforge.
net/.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
44  2.1. Znajomość sprzętu

niewielki pobór energii oraz prostą w użyciu komunikację za pomocą in-


terfejsu szeregowego. Moduły XBee niewielkiej mocy są używane przede
wszystkim do komunikacji na poziomie znaków. Moduły XBee nie mogą
się znajdować w odległości większej niż 15 metrów (około 50 stóp).
We wszystkich projektach omawianych w tej książce, w których zastosowano
komunikację XBee – XBee, użyto albo pojedynczych znaków, albo krótkich
łańcuchów opisujących zmianę stanu w wyniku zdarzenia wykrytego przez
czujnik. Każda taka zmiana jest następnie bezprzewodowo rozgłaszana
w celu przekazania do drugiego modemu XBee, który zwykle jest połączony
z komputerem lub systemem wbudowanym odpowiedzialnym za przetworze-
nie otrzymanego sygnału. Sam preferuję rozwiązanie polegające na zapi-
sywaniu danych przed właściwym przetworzeniem, ponieważ rejestrowanie
zdarzeń w ten sposób znacznie ułatwia diagnozowanie systemu. Po zapisaniu
otrzymanych danych komputer może przekazać sygnał dalej, tłumacząc go
na komunikat usługi sieciowej, wiadomość poczty elektronicznej, ruch ser-
womotoru lub dowolne inne działanie.
Najbardziej czasochłonnymi i wymagającymi zadaniami związanymi ze sto-
sowaniem modułów XBee jest właściwa instalacja sprzętu i tzw. parowanie
(ang. pairing) dwóch modułów. Niezbędna procedura nie jest co prawda
trywialna, ale też nie jest zbyt trudna. Na szczęście Limor „Ladyada” Fried,
założyciel firmy Adafruit Industries i jeden z najważniejszych propagatorów
otwartych standardów inżynierii elektrycznej, opracował i udostępnił na
swojej stronie internetowej wyjątkowo przydatny podręcznik, w którym wy-
jaśnił krok po kroku, jak łączyć zestawy adapterów XBee oraz moduły ra-
diowe XBee. Wrócimy do tego zagadnienia podczas omawiania pierwszego
użycia modułów XBee (w czasie prac nad projektem systemu karmienia
ćwierkającego ptaka).
Warto przy tej okazji wspomnieć o firmie Digi International, która produkuje
urządzenia XBee — firma zapowiedziała ostatnio wprowadzenie na rynek
urządzeń zgodnych ze standardami 802.11 b/g/n (Wi-Fi), które nie będą
wymagały łączenia drugiego urządzenia XBee z docelowym komputerem
PC za pośrednictwem przewodu FTDI. Okazuje się jednak, że koszt tego
wygodnego rozwiązania będzie zauważalnie wyższy niż koszt konfiguracji
stosowanej w tej książce. Czytelników zainteresowanych wygodniejszym roz-
wiązaniem zachęcam do lektury strony poświęconej modułom XBee Wi-Fi
w serwisie firmy Digi7.

7
http://www.digi.com/xbeewifi

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 2. • Potrzebne elementy  45

Podstawy elektroniki, programowanie platformy Arduino i budowę sieci


bezprzewodowych omówiono w wielu książkach (na przykład Building Wire-
less Sensor Networks [Fal10]) i poradnikach dostępnych w internecie. Ten
podrozdział jest co najwyżej przeglądem technik niezbędnych do pracy ze
sprzętem, którego będziemy używali w projektach prezentowanych w tej książ-
ce. W następnym podrozdziale przeanalizujemy oprogramowanie, które będzie
nam potrzebne do ożywienia opisanych powyżej elementów sprzętowych.

2.2. Znajomość oprogramowania


Oprócz znajomości składni języka C/C++ obowiązującej podczas progra-
mowania szkiców platformy Arduino sporym ułatwieniem będzie choćby
podstawowa znajomość takich języków programowania jak Java, Ruby czy
Python. Dużym ułatwieniem będzie również doświadczenie w pracy z fra-
meworkiem Ruby on Rails. Czytelników, którzy chcieliby pogłębić swoją
wiedzę na ten temat, zachęcam do lektury dodatku B zatytułowanego
„Bibliografia”, gdzie można znaleźć wiele doskonałych tytułów poświęconych
tym językom i frameworkom.
Nawet czytelnicy, którzy nie mają zbyt dużej wiedzy na temat tych języków, nie
powinni mieć problemów z budową i uruchamianiem kodu na potrzeby pre-
zentowanych projektów (i wprowadzaniem drobnych modyfikacji niezbędnych
w przypadku komputerów z systemami Linux i Macintosh). Użytkownicy
systemów Windows będą musieli zainstalować wybrane dystrybucje języ-
ków Python i Ruby, środowisko wykonawcze Javy oraz kilku programów
użytkowych używanych w tej książce (należy pamiętać, że większość tych
programów jest tworzona z myślą o systemach operacyjnych z rodziny
Unix, zatem nie wszystkie narzędzia są dostępne dla systemu Windows).
Warto więc rozważyć instalację wybranej dystrybucji systemu Linux, a do
obsługi systemu OS X wprost doskonale nadaje się komputer Mac Mini.
Ten domowy serwer powinien stanowić stosunkowo niedrogi składnik kolek-
cji sprzętu zakupionego na potrzeby projektów opisanych w tej książce.
Znajomość Javy będzie szczególnie przydatna podczas pisania aplikacji
klient-serwer dla systemu operacyjnego Android (w dalszej części tej książki).
Także doświadczenie w pracy z językami Python i Ruby będzie sporym
ułatwieniem. Język Python jest wstępnie instalowany w systemie Mac i niemal
wszystkich dystrybucjach systemu Linux. Zdecydowana większość skryptów
strony serwera opisanych w tej książce została napisana właśnie w Pythonie.
Programiści języków Java, Perl, PHP i Ruby, którzy z różnych względów

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
46  2.3. Bezpiecznej zabawy!

nie chcą rezygnować ze swoich ulubionych technologii, nie powinni mieć


większych problemów z przetłumaczeniem aplikacji strony serwera na wybra-
ny przez siebie język. Zachęcam wszystkich czytelników zainteresowanych
przenoszeniem kodu opisanego w tej książce na inne języki do opisania swoich
prób za pośrednictwem strony internetowej tej książki — być może zdobyte
doświadczenia ułatwią pracę pozostałym czytelnikom.

2.3. Bezpiecznej zabawy!


Projekty prezentowane w tej książce celowo zostały tak zaplanowane, aby
ograniczyć do minimum lub wręcz wyeliminować ryzyko rażenia prądem.
Starałem się także zminimalizować niebezpieczeństwo uszkodzenia ciała lub
wyrządzenia szkód materialnych w wyniku nieprzewidzianych zdarzeń. Każ-
dy czytelnik powinien jednak pamiętać o zasadach bezpieczeństwa podczas
prac nad każdym projektem wymagającym łączenia urządzeń sprzętowych.
Ani autor tej książki, ani jej wydawca nie może odpowiadać za ewentual-
ne szkody i negatywne skutki budowy i uruchamiania opisanych systemów
(nie możemy też odpowiadać za nieprawidłowe działanie sprzętu użytego
przez czytelników do modyfikacji tych projektów — więcej informacji na
ten temat można znaleźć w ramce „Realizujesz projekty na własne ryzyko.
Ostrzegałem!”). Na każdym kroku podkreślam i ostrzegam — jeśli nie
jesteś elektrykiem z uprawnieniami, hydraulikiem czy stolarzem i jeśli nie dys-
ponujesz pełną wiedzą z danej dziedziny, nie próbuj niczego zmieniać nawet
w podstawowych elementach instalacji elektrycznych lub wodno-kanalizacyjnych
w swoim domu. Lepszym rozwiązaniem jest wezwanie doświadczonego fa-
chowca, elektryka z odpowiednimi uprawnieniami. Zaufaj mi. Umiejętność
planowania działań i doświadczenie są najlepszym zabezpieczeniem przed
błędami — zatrudniając specjalistę, oszczędzisz pieniądze i unikniesz ryzyka
utraty zdrowia. Zlecanie tych podstawowych aspektów fachowcom powoduje
dodatkowo, że mamy więcej czasu na implementację i optymalizację wyjąt-
kowo wciągających i budzących zazdrość systemów inteligentnego domu.
Wystarczy już tych wymagań i ostrzeżeń. W następnym rozdziale przystąpi-
my wreszcie do konstruowania i kodowania ciekawych i niepowtarzalnych
projektów automatyzacji domu!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 2. • Potrzebne elementy  47

Realizujesz projekty na własne ryzyko. Ostrzegałem!


Każdy czytelnik sam odpowiada za swoje bezpieczeństwo. Wszelkie
instrukcje i sugestie zawarte w tej książce czytelnik wykonuje na
własne ryzyko. Autor i wydawca tej książki nie ponoszą żadnej odpo-
wiedzialności za uszkodzenia, obrażenia ani koszty powstałe w wy-
niku prawidłowego lub nieprawidłowego używania informacji za-
wartych w tej książce.
To do czytelnika należy odpowiedzialność za sprawdzenie, czy po-
dejmowane czynności są zgodne z odpowiednimi przepisami pra-
wa i czy nie wymagają stosownych licencji. Regulacje i ograniczenia
narzucane przez producentów urządzeń i oprogramowania stale
ewoluują, ponieważ zmieniają się same produkty i technologie.
Oznacza to, że część projektów prezentowanych w tej książce może
nie działać w opisany sposób bądź może naruszać bieżące prawa,
regulacje lub umowy licencyjne. Co więcej, w skrajnych przypad-
kach proponowane rozwiązania mogą powodować uszkodzenia
albo w inny sposób wpływać na użyte urządzenia lub otoczenie.
Elektronarzędzia, urządzenia elektryczne i inne elementy używane
w opisanych projektach mogą być niebezpieczne, jeśli są używane
w niewłaściwy sposób, wbrew zaleceniom producenta i (lub) bez
należytej odzieży ochronnej (należy pamiętać, że część zdjęć i opi-
sów narusza zasady bezpiecznego stosowania sprzętu i procedur,
aby lepiej prezentować istotę budowanych rozwiązań). Każdy czy-
telnik musi sam opanować zasady prawidłowego i bezpiecznego
używania potrzebnych narzędzi. To do czytelnika należy ocena, czy
dysponuje umiejętnościami i wiedzą potrzebnymi do realizacji opi-
sanych projektów i wykonywania sugerowanych czynności. Wszyst-
kie projekty zostały opracowane z myślą o osobach dorosłych.
Przed przystąpieniem do realizacji każdego projektu należy spraw-
dzić, czy godzimy się na ryzyko związane z tym przedsięwzięciem.
Jeśli na przykład obawiasz się pracy z prądem o napięciu 220 V, powi-
nieneś zrezygnować z realizacji projektów wymagających takiego
zasilania. Autor tej książki z natury rzeczy nie zna lokalnych zarzą-
dzeń obowiązujących w miejscu realizacji projektów przez czytelni-
ka, zatem przed przystąpieniem do pracy należy sprawdzić, czy po-
dejmowane działania nie naruszają tych reguł. W razie wątpliwości
warto skontaktować się z lokalnym specjalistą z danej dziedziny.
Czytelnik powinien budować tylko te projekty, w których przypad-
ku godzi się wziąć na siebie pełną odpowiedzialność za skutki po-
dejmowanych czynności.
Powodzenia i dobrej zabawy!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
48  2.3. Bezpiecznej zabawy!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Część II
Projekty

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
50  Inteligentny dom

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3.
System
powiadamiania
o poziomie wody

K
ażdy mieszkaniec Środkowego Zachodu Stanów Zjednoczonych
(w tym ja) był świadkiem wielu ulewnych deszczów i doskonale wie,
jak po takiej nawałnicy wygląda piwnica domu. Dramatyczne relacje
o zalaniach i awariach pomp w czasie najbardziej ulewnych deszczów często
kończą się stwierdzeniem: „gdybym wiedział, jak szybko podnosi się poziom
wody w osadniku, miałbym więcej czasu na wyniesienie najcenniejszych rze-
czy z piwnicy”.
Wyobraźmy sobie jeszcze inny scenariusz, w którym do usuwania wilgoci
z piwnicy jest używany osuszacz. Niedrogie osuszacze często przestają działać
w momencie, w którym poziom wody w zbiorniku osiąga określony poziom.
Niektóre modele emitują wtedy sygnał dźwiękowy lub włączają migającą
diodę, jednak ten sposób komunikowania wypełnienia zbiornika jest o tyle
nieefektywny, że osuszacze z reguły są instalowane w rzadko odwiedzanych
pomieszczeniach.
Czyż nie lepszym i bardziej wygodnym rozwiązaniem byłoby otrzymywa-
nie wiadomości poczty elektronicznej w momencie przekroczenia określonego
progu w zbiorniku, tak aby właściciel mógł podjąć stosowne działania?
(Patrz rysunek 3.1 zatytułowany „Niech dom wysyła do swojego właściciela

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
52  3.1. Czego potrzebujemy

wiadomości”). Przejdźmy więc do mokrej roboty i zbudujmy system, który


będzie wysyłał do nas powiadomienia w awaryjnych sytuacjach.

Rysunek 3.1. Niech dom wysyła do swojego właściciela wiadomości, kiedy


poziom wody osiągnie próg alarmowy, aby mieszkańcy mieli
więcej czasu na zabezpieczenie dobytku przed zalaniem.
Projekt może służyć także do monitorowania poziomów
wody w osuszaczach, klimatyzatorach i innych podobnych
urządzeniach

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  53

3.1. Czego potrzebujemy


Najważniejszym elementem potrzebnym do realizacji tego projektu jest
tzw. czujnik ugięcia (ang. flex sensor). Rosnący poziom wody spowoduje
wygięcie tego czujnika. Ponieważ czujnik może być wyginany w obie stro-
ny, bieżące wskazania będą odpowiednio rosły lub malały. Stan czujnika
można odczytywać za pomocą prostego programu platformy Arduino, a sam
czujnik może być zasilany za pośrednictwem wtyków Arduino 3,3- lub 5-
woltowych.
Oto kompletna lista potrzebnych elementów (komponenty używane w tym
projekcie pokazano też na rysunku 3.2 zatytułowanym „Części systemu
powiadamiania o poziomie wody”):
1. Arduino Uno,
2. moduł sieciowy (Ethernet shield)1,
3. czujnik ugięcia2,
4. rezystor 10 kΩ3,
5. jednocalowy spławik wędkarski,
6. trzy przewody (zasilanie, masa i wtyk analogowy 0) przycięte do
odpowiedniej długości,
7. 9-woltowy zasilacz dla platformy Arduino i modułu sieciowego
(po odłączeniu przewodu USB),
8. listwa lub deska, do której zostanie przymocowany czujnik ugięcia,
9. serwer WWW obsługujący skrypty języka PHP 4.3 lub nowszej
wersji (serwer nie został pokazany na rysunku).
Realizacja tego projektu będzie dodatkowo wymagała standardowego prze-
wodu USB A-B (brak na rysunku), aby połączyć platformę Arduino
z komputerem, oraz przewodu Ethernet (którego także nie pokazano na
rysunku) potrzebnego do połączenia modułu sieciowego z siecią.

1
http://www.adafruit.com/index.php?main_page=product_info&cPath=
17_21&products_id=201
2
http://www.sparkfun.com/products/8606
3
http://www.makershed.com/ProductDetails.asp?ProductCode=JM691104

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
54  3.1. Czego potrzebujemy

Rysunek 3.2. Części systemu powiadamiania o poziomie wody

Ponieważ platforma Arduino i moduł sieciowy będą używane w wielu pozo-


stałych projektach, koszty sprzętu potrzebnego do realizacji tego projektu
(liczone bez tych dwóch elementów) nie powinny przekroczyć 40 złotych.
Zważywszy na spokój, który zyskamy dzięki temu systemowi, i możliwości
rozbudowy tego systemu, niezbędne nakłady są stosunkowo nieduże.

Platforma Arduino i sieć Ethernet


Część czytelników zapewne wolałaby dysponować platformą Ar-
duino Uno i modułem sieciowym tej platformy w ramach jednego
urządzenia. W takim przypadku warto rozważyć zakup płytki Arduino
Uno Ethernet4. Warto jednak pamiętać, że także w tym przypadku
cyfrowe wtyki 10 – 13 są zarezerwowane dla modułu sieciowego (po-
dobnie jak w konfiguracji złożonej z odrębnej płytki Arduino i do-
datkowego modułu sieciowego). Co więcej, platforma Arduino Uno
Ethernet wymaga przewodu FTDI do połączenia z komputerem
(zamiast bardziej popularnego przewodu USB A-B)5. Największą
zaletą tej platformy jest możliwość łączenia mechanizmów na bazie
sieci Ethernet z innym modułem platformy Arduino, o ile ten inny
moduł nie wymaga tych samych wtyków co zintegrowany moduł
sieciowy.

4
http://www.adafruit.com/products/418
5
https://www.adafruit.com/products/70

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  55

3.2. Budowa rozwiązania


Zanim system powiadamiania o poziomie wody będzie mógł wysyłać swoje
ostrzeżenia, musimy wykonać następujące zadania:
1. Musimy połączyć przewody i rezystory z jednej strony czujnika
ugięcia oraz zamocować spławik wędkarski z drugiej strony tego
czujnika.
2. Musimy podłączyć czujnik ugięcia do analogowego wtyku platformy
Arduino.
3. Musimy napisać program (tzw. szkic) platformy Arduino, który
będzie monitorował zmiany wartości odczytywanych przez czujnik
ugięcia. Program powinien generować zdarzenie w momencie wy-
krycia odpowiednio dużej zmiany względem wartości początkowej.
4. Należy połączyć platformę Arduino z modułem sieciowym, tak
aby szkic mógł się komunikować z serwerem WWW, na którym
będzie działał odpowiedni skrypt PHP.
5. Należy napisać skrypt PHP, który będzie otrzymywał wartości
wysyłane przez platformę Arduino. W razie zmiany poziomu wo-
dy skrypt powinien sformatować i wysłać wiadomość poczty elek-
tronicznej, która zaalarmuje adresata — odbiorca tej wiadomości
będzie mógł szybko zareagować na to ostrzeżenie!
Zaczniemy od połączenia elementów sprzętowych i przetestowania wskazań
czujnika ugięcia.

3.3. Łączenie
Zacznijmy od sprawdzenia, czy czujnik ugięcia działa zgodnie z naszymi
oczekiwaniami. Końcówkę dodatnią czujnika należy połączyć z 5-woltowym
wtykiem na płytce Arduino za pomocą przewodu. Końcówka dodatnia to
ta połączona z paskiem ciągnącym się wzdłuż całej długości czujnika. Koń-
cówka ujemna to ta połączona z częścią czujnika przypominającą drabinę.
Końcówkę ujemną należy podłączyć do analogowego wtyku 0 za pomocą
drugiego przewodu. Na końcu należy zmostkować analogowy wtyk 0 z wty-
kiem uziemienia przy użyciu rezystora 10 kΩ, aby obniżyć natężenie prądu
w układzie. Warto przeanalizować rysunek 3.3 zatytułowany „Diagram
połączeń systemu powiadamiania o poziomie wody”, aby upewnić się, że
przewody i rezystor zostały połączone z właściwymi wtykami.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
56  3.4. Tworzenie szkicu

Rysunek 3.3. Diagram połączeń systemu powiadamiania o poziomie wody

Na drugim końcu czujnika ugięcia należy zamontować spławik. Większość


spławików jest oferowana z odczepianym haczykiem, który można przymoco-
wać do plastikowej końcówki czujnika. W razie problemów z przymoco-
waniem spławika do czujnika można użyć kleju termotopliwego lub węża
termokurczliwego, aby spławik dobrze trzymał się czujnika. Warto przy
tym zachować ostrożność, aby podczas łączenia ze spławikiem na gorąco
nie uszkodzić czujnika. Alternatywnym (i bezpiecznym) rozwiązaniem jest
użycie mocnej taśmy klejącej, jednak należy pamiętać, że z czasem siła
kleju może być słabsza.
Użyte przewody powinny być na tyle długie, aby można było bezpiecznie
zainstalować platformę Arduino i źródło zasilania z dala od zbiornika z wo-
dą. Płytka Arduino, której używam do monitorowania mojego osadnika,
została zamontowana w skrzynce półtora metra wyżej, zatem każdy z pary
przewodów prowadzących do czujnika ugięcia ma około 2 metry długości.
Skoro platforma Arduino jest już prawidłowo połączona z czujnikiem, mo-
żemy przystąpić do pracy nad logiczną warstwą tego rozwiązania. Zaczniemy
od opracowania prostego programu testowego, który sprawdzi, czy czujnik
ugięcia jest prawidłowo podłączony i czy działa zgodnie z założeniami.

3.4. Tworzenie szkicu


Zanim przystąpimy do pisania właściwego kodu, musimy się upewnić, że
prawidłowa komunikacja z płytką Arduino jest możliwa. Zaraz potem omó-
wię sposoby uzyskiwania i przetwarzania na poziomie programu (nazywanego

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  57

szkicem przez społeczność programistów platformy Arduino) danych wy-


syłanych przez czujnik ugięcia.
Nasz pierwszy szkic będzie wykrywał ewentualne zmiany wskazań czujnika
ugięcia. Jeśli zmiana będzie odpowiednio duża (czyli jeśli wzrost poziomu
wody spowoduje wygięcie czujnika), program wyśle żądanie do skryptu PHP
na serwerze, który przetworzy otrzymane dane. Działanie tego skryptu
sprowadza się do wysłania wiadomości poczty elektronicznej z informacją
o zmianie poziomu wody.
Niezbędny szkic będziemy budowali w sposób przyrostowy — zaczniemy od
połączenia czujnika ugięcia z płytką Arduino oraz pobrania wartości dla
wyprostowanego czujnika oraz czujnika w pozycjach wygiętych w obu kierun-
kach. Po zidentyfikowaniu tych wartości napiszemy wyrażenia warunkowe,
które będą wywoływały funkcje wysyłające żądania GET protokołu HTTP
z danymi do wysłania w alarmowej wiadomości poczty elektronicznej.

Konfiguracja platformy Arduino


Do napisania, skompilowania i pobrania naszego kodu na platformę Arduino
użyjemy środowiska programowania Arduino IDE. Czytelnikom zaintere-
sowanym bardziej wyczerpującym wprowadzeniem do programowania plat-
formy Arduino polecam doskonałą książkę Maika Schmidta zatytułowaną
Arduino: A Quick Start Guide [Sch11].
Czytelnicy, którzy znają już tę platformę lub którzy chcą od razu zacząć swoją
przygodę z programowaniem tego systemu, mogą już teraz uruchomić środo-
wisko Arduino IDE. Wystarczy upewnić się, że platforma jest połączona
z komputerem za pomocą przewodu USB oraz że została rozpoznana i wy-
brana na jednym z portów szeregowych zidentyfikowanych w menu Tools/
Serial Port środowiska Arduino IDE. Konfigurację można błyskawicznie
przetestować, korzystając z przykładowego programu LED Blink dostęp-
nego w środowisku Arduino IDE po wyborze opcji File/Examples/1.Basics/
Blink. Wystarczy wysłać ten program na platformę Arduino i sprawdzić,
czy jest prawidłowo wykonywany.
W razie niepowodzenia należy sprawdzić, czy płytka Arduino jest prawi-
dłowo połączona z komputerem i czy jest odpowiednio zasilana przez port
USB. Jeśli tak, należy sprawdzić, czy w samym środowisku Arduino IDE
wybrano właściwy port szeregowy, oraz zaznaczyć właściwy typ płytki
Arduino w oknie Tools/Board. Problem można zwykle rozwiązać za po-
mocą zaledwie kilku kliknięć myszą.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
58  3.4. Tworzenie szkicu

Szkic dla czujnika ugięcia


Skoro platforma Arduino jest już podłączona i przetestowana, możemy
przystąpić do pisania szkicu, który sprawdzi i zinterpretuje wartość opi-
sującą ugięcie czujnika. Zacznijmy od zdefiniowania kilku stałych, których
będziemy używali w dalszej części programu.
Ponieważ musimy uwzględnić możliwość wyginania czujnika w obu kierun-
kach, zdefiniujemy dwie stałe nazwane, które będą wyznaczały górny i dolny
próg generowania zdarzenia.
Obie stałe należy umieścić na początku szkicu, tak aby w przyszłości można
je było łatwo zlokalizować (na przykład w razie konieczności zmiany progów).
Zgodnie z konwencją stałe zdefiniowane zapisuje się samymi wielkimi literami,
dzięki czemu można je łatwo identyfikować w kodzie źródłowym. Wspo-
mniane stałe nazwiemy FLEX_TOO_HIGH i FLEX_TOO_LOW. Przedział wyznaczany
przez ten górny i dolny próg będzie zależał od kąta wygięcia czujnika właści-
wego w konkretnym scenariuszu. Zwykle stosuję tolerancję na poziomie
plus/minus pięciu jednostek, aby przed wygenerowaniem zdarzenia powia-
domienia było możliwe pewne ugięcie czujnika. Pewna tolerancja (choćby na
zaproponowanym przeze mnie poziomie) umożliwi uwzględnianie takich
zjawisk jak lekki powiew wiatru czy niewielkie wibracje.
Musimy też mieć na uwadze diodę LED wbudowaną na płytce Arduino
oraz analogowy wtyk, do którego podłączono czujnik ugięcia.
 Stała FLEX_TOO_HIGH określa wartość przypisanego analogowego wtyku
w czasie, gdy czujnik ugięcia jest wygięty przed ten próg.
 Stała FLEX_TOO_LOW określa wartość przypisanego analogowego wtyku
w czasie, gdy czujnik ugięcia jest wygięty za ten próg.
 Stała ONBOARD_LED jest przypisana do wbudowanej diody LED na płyt-
ce Arduino w miejscu wtyku nr 13. Użyjemy tej diody w roli wizual-
nego wskaźnika sygnalizującego odchylenie czujnika ugięcia w stop-
niu powodującym wysłanie wiadomości alarmowej. Takie rozwią-
zanie umożliwia nam wykorzystanie wbudowanej diody LED w roli
wizualnego debugera, który będzie w czytelny sposób potwierdzał
wykrycie zdarzenia ugięcia.
 Stała FLEX_SENSOR jest powiązana z analogowym wtykiem na płytce
Arduino, do którego podłączono czujnik ugięcia. W tym przypadku
stała ma wartość 0, ponieważ rezystor podłączono do wtyku nr 0.
Wszystkie te stałe zostaną zdefiniowane na początku szkicu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  59

Plik WaterLevelNotifier/WaterLevelSensor.pde

#define FLEX_TOO_HI 475


#define FLEX_TOO_LOW 465
#define ONBOARD_LED 13
#define FLEX_SENSOR 0

Utworzymy teraz dwie zmienne reprezentujące zmieniającą się wartość i stan


czujnika ugięcia. Obu zmiennym początkowo przypiszemy wartość zero.
 Zmienna bend_value będzie reprezentowała zmieniające się, analogowe
wskazania czujnika ugięcia (zmiany tych wartości wynikają właśnie
z jego zginania).
 Zmienna bend_state będzie reprezentowała binarny stan tego czuj-
nika. Jeśli czujnik jest prosty, zmienna ma wartość zero. Jeśli czujnik
jest zgięty w jednym z dwóch kierunków, zmienna reprezentująca stan
tego czujnika ma wartość jeden.
Zmienne zostaną umieszczone w pliku za opisanymi wcześniej wyrażeniami
#define.
Plik WaterLevelNotifier/WaterLevelSensor.pde

int bend_value = 0;
byte bend_state = 0;

Po zdefiniowaniu stałych i zainicjalizowaniu niezbędnych zmiennych musimy


jeszcze skonfigurować port szeregowy pod kątem monitorowania ciągłego
strumienia wartości uzyskiwanych w głównej pętli programu. Konfiguracji
wymaga także wbudowana dioda LED, tak abyśmy mogli obserwować jej
zapalanie i gaszenie zależnie od wartości zmiennej bend_state (reprezentującej
stan czujnika ugięcia).
Plik WaterLevelNotifier/WaterLevelSensor.pde

void setup()
{
// na potrzeby komunikatów diagnostycznych w oknie portu szeregowego
Serial.begin(9600);
// ustawia wtyk dla wbudowanej diody LED
pinMode(ONBOARD_LED, OUTPUT);
}

Skoro zdefiniowaliśmy górny i dolny próg ugięcia czujnika, musimy jeszcze


opracować funkcję, która sprawdzi, czy któryś z tych progów nie został prze-
kroczony. W razie przekroczenia progu program włączy diodę LED wbu-
dowaną na płytce Arduino. Po powrocie czujnika ugięcia do pozycji wy-
prostowanej funkcja wyłączy tę diodę LED.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
60  3.4. Tworzenie szkicu

Plik WaterLevelNotifier/WaterLevelSensor.pde

void SendWaterAlert(int bend_value, int bend_state)


{
digitalWrite(ONBOARD_LED, bend_state ? HIGH : LOW);
if (bend_state)
Serial.print("Poziom wody przekroczył próg, bend_value=");
else
Serial.print("Poziom wody wrócił do normalnego stanu bend_value=");
Serial.println(bend_value);
}

Warto zwrócić szczególną uwagę na pierwszy wiersz tego bloku kodu:


digitalWrite(ONBOARD_LED, bend_state ? HIGH : LOW);. Ta trójargumentowa
operacja sprawdza bieżący stan czujnika ugięcia na podstawie wartości
(0 lub 1) przekazanej na wejściu tej funkcji. Zdefiniowane poniżej wyrażenie
warunkowe wysyła odpowiedni komunikat w oknie portu szeregowego środo-
wiska Arduino IDE. Jeśli zmienna bend_state ma wartość 1 (HIGH), czujnik
ugięcia został wygięty poza zdefiniowane przez nas wartości progowe. Innymi
słowy, poziom wody przekroczył przyjęty próg. Jeśli ta zmienna ma wartość
0 (LOW), czujnik ugięcia jest wyprostowany (stan wody nie przekracza po-
ziomu progowego).
Pozostaje nam już tylko napisanie głównej pętli programu. Stan wtyku
FLEX_SENSOR (zdefiniowanego jako wtyk analogowy nr 0) jest co sekundę
sprawdzany pod kątem wzrostu lub spadku wartości. W razie wykrycia zda-
rzenia ugięcia wartość zmiennej bend_value jest wysyłana do portu szeregowe-
go, zatem możemy ją sprawdzić w oknie portu szeregowego środowiska
Arduino IDE.
Plik WaterLevelNotifier/WaterLevelSensor.pde

void loop()
{
// czeka sekundę w każdej iteracji pętli
delay(1000);
// sprawdza napięcie na wtyku FLEX_SENSOR
bend_value = analogRead(FLEX_SENSOR);

// wysyła wartość zmiennej bend_value do portu szeregowego w celu wyznaczenia


// wartości bazowej
// ten wiersz należy zamienić w komentarz po wyznaczeniu wartości bazowej
// limity zostały zdefiniowane
Serial.print("bend_value=");
Serial.println(bend_value);

switch (bend_state)
{
case 0: // wartość zmiennej bend_value nie przekracza górnego ani dolnego progu
if (bend_value >= FLEX_TOO_HI || bend_value <= FLEX_TOO_LOW)
{

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  61

bend_state = 1;
SendWaterAlert(bend_value, bend_state);
}
break;
case 1: // wartość zmiennej bend_value przekracza górny lub dolny próg
if (bend_value < FLEX_TOO_HI && bend_value > FLEX_TOO_LOW)
{
bend_state = 0;
SendWaterAlert(bend_value, bend_state);
}
break;
}
}

Główna pętla tego szkicu sprawdza wartość czujnika ugięcia w jednosekun-


dowych odstępach. Wyrażenie switch sprawdza stan tego czujnika repre-
zentowany przez zmienną bend_state. Jeśli w poprzedniej iteracji czujnik
był wyprostowany (case 0:), program sprawdza, czy czujnik nie jest teraz
wygięty poza górny lub dolny próg. Jeśli tak, odpowiednio zmieniamy
wartość zmiennej bend_state i wywołujemy funkcję SendWaterAlert. I odwrotnie
— jeśli w poprzedniej iteracji czujnik był wygięty (case 1:), program
sprawdza, czy teraz nie jest wyprostowany. Jeśli tak, przypisujemy zmien-
nej bend_state wartość zero i przekazujemy nowy stan na wejściu funkcji
SendWaterAlert.

W zależności od rodzaju czujnika ugięcia i modułu sieciowego, a także od


użytego wtyku napięcia wartości bazowe mogą różnić się od tych zarejestro-
wanych przeze mnie. Mój czujnik ugięcia sygnalizował wartość równą 470.
Warto zwrócić uwagę na sposób stosowania średników oznaczających
koniec wierszy z wyrażeniami oraz nawiasów klamrowych wyznaczających
bloki wyrażeń warunkowych. Warto teraz zapisać ten plik. Przed przystą-
pieniem do dalszych działań warto też rozważyć umieszczenie tego i pozo-
stałych plików z kodem źródłowym w wybranym systemie kontroli wersji.
Polecam system Git6, jednak także pozostałe systemy, jak Mercurial czy
Subversion, z pewnością będą lepsze od braku jakiegokolwiek systemu kon-
troli wersji.
W dalszej części tego rozdziału zmienimy funkcję SendWaterAlert tak, aby
wywoływała inną funkcję, która będzie nawiązywała połączenie ze skryp-
tem PHP na wskazanym serwerze WWW. Wspomniany skrypt wyśle
wiadomość poczty elektronicznej z ostrzeżeniem dotyczącym monitorowa-
nej zmiennej bend_value. Zanim jednak przejdziemy do implementacji tych

6
http://git-scm.com/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
62  3.4. Tworzenie szkicu

rozwiązań, warto sprawdzić, czy nasz test przekroczenia progów działa pra-
widłowo — w tym celu przeanalizujemy komunikaty wyświetlane w oknie
portu szeregowego środowiska Arduino IDE.

Uruchamianie szkicu
Po zapisaniu szkicu należy kliknąć przycisk Verify na pasku narzędzi środo-
wiska Arduino IDE. Kliknięcie tego przycisku spowoduje skompilowanie
szkicu i sprawdzenie ewentualnych błędów składowych. Po potwierdzeniu
braku błędów należy wysłać szkic na platformę Arduino, klikając przycisk
Upload dostępny na pasku narzędzi. Wbudowana dioda LED na płytce
Arduino powinna przez pewien czas migać, aby zasygnalizować otrzymywa-
nie szkicu. Kiedy dioda przestanie migać, wysłany szkic powinien działać.
Warto teraz otworzyć okno Serial Monitor środowiska Arduino IDE. Jeśli
wyrażenie Serial.print("bend_value="); w głównej pętli szkicu do tej pory
nie zostało umieszczone w komentarzu, możemy obserwować liczby stale
wyświetlane w oknie monitora portu szeregowego (z częstotliwością około
jednej nowej wartości na sekundę). Jeśli znaki wyświetlane w tym oknie są
nieczytelne, należy sprawdzić, czy zastosowano prawidłową szybkość transmisji
(w tym przypadku należy zastosować wartość 9600). Bieżące ustawienia moż-
na sprawdzić na liście rozwijanej widocznej w prawym dolnym rogu okna
tego monitora portu szeregowego. Należy zanotować wskazania czujnika
ugięcia w czasie, gdy jest wyprostowany, wygięty w jedną stronę i wygięty
w drugą stronę.
W zależności od parametrów opornika i rodzaju zastosowanych urządzeń
należy zaktualizować wartości stałych FLEX_TOO_HIGH i FLEX_TOO_LOW zgodnie
z odczytami widocznymi w oknie monitora portu szeregowego. Po zapisa-
niu odpowiednich wartości progowych należy zapisać program i ponownie
wysłać go na platformę Arduino, stosując taką samą procedurę jak poprzed-
nio. Zdefiniowanie górnego i dolnego progu potrzebnych do prawidłowego
wykrywania stanu wygięcia czujnika może wymagać dwóch lub trzech prób.
Po zmodyfikowaniu górnego i dolnego progu tak, aby najlepiej pasowały do
danej konfiguracji, należy obserwować wbudowaną diodę LED na płytce
Arduino, aby mieć pewność, że dioda zapala się w momencie odpowiednio
mocnego wygięcia czujnika w jedną lub drugą stronę oraz gaśnie w momen-
cie przywrócenia oryginalnego położenia (po wyprostowaniu czujnika).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  63

Testowanie szkicu
Po dopracowaniu konfiguracji sprzętowej i sprawdzeniu, czy wysłany szkic
platformy Arduino działa prawidłowo, możemy wreszcie przeprowadzić
prosty test wody — wystarczy nalać wodę do miski i jednocześnie zanurzyć
spławik w wodzie, trzymając kciukiem i palcem wskazującym drugi koniec
czujnika ugięcia. Łączenia obu przewodów z czujnikiem ugięcia należy oczy-
wiście zabezpieczyć za pomocą wodoodpornej taśmy izolacyjnej. Sugeruję
zastosowanie wielu warstw taśmy, aby nie tylko dysponować solidnym uchwy-
tem czujnika, ale też ochronić go przed przypadkowymi kroplami wody.
Po prawidłowym i bezpiecznym przygotowaniu testu należy sprawdzić, czy
wypieranie przez wodę spławika przymocowanego do czujnika ugięcia spo-
woduje na tyle duże wygięcie w jednym z kierunków, że będzie powodo-
wało zapalanie diody LED.
Należy uważać, aby nie zalać odsłoniętego czujnika ugięcia. Mimo że
natężenie prądu przepływającego przez płytkę Arduino jest stosunkowo
niewielkie, połączenie wody i elektryczności może mieć fatalne skutki.
Wszystkie elektroniczne elementy, w tym czujnik ugięcia i dołączony spławik,
należy umieścić w szczelnej torbie foliowej (oczywiście w sposób umożli-
wiający zginanie czujnika). Należy zachować daleko idącą ostrożność, aby
wykluczyć ryzyko zamoczenia odkrytych przewodów lub połączeń elek-
trycznych. Woda może nie tylko uszkodzić sprzęt, ale także doprowadzić
do niebezpiecznego porażenia prądem.
Podstawowe elementy systemu powiadamiania o poziomie wody są już kom-
pletne. Na tym etapie sygnalizacja przekroczenia alarmowego poziomu
wody ogranicza się jednak do zapalenia miniaturowej diody LED na płytce
Arduino. Takie rozwiązanie być może wystarczy w przypadku projektów
akademickich lub konstruktorów pracujących w bezpośrednim sąsiedztwie
platformy Arduino monitorującej zbiornik wodny, jednak w naszym przypad-
ku konieczne będzie znalezienie innego sposobu powiadamiania o rosnącym
poziomie wody.
Dużo lepszym rozwiązaniem będzie otrzymywanie powiadomień w formie
wiadomości poczty elektronicznej, szczególnie jeśli system mierzący poziom
wody znajduje się w rzadko odwiedzanym pomieszczeniu. System może na-
wet działać w zupełnie innym miejscu — może na przykład monitorować
poziom wody w osadniku w domku letniskowym w trakcie ulewnych deszczy.
Realizacja tego zadania będzie wymagała dołączenia do platformy Ar-
duino modułu sieciowego i napisania kodu, który po przekroczeniu progu

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
64  3.5. Implementacja aplikacji internetowej wysyłającej pocztę

ugięcia czujnika wyśle odpowiednią wiadomość poczty elektronicznej. Zanim


jednak wzbogacimy ten projekt o dodatkowy sprzęt, musimy przygotować
aplikację odpowiedzialną za wysyłanie powiadomień pocztą elektroniczną.
Aplikacja będzie używana przez nasz szkic platformy Arduino za każdym
razem, gdy trzeba będzie wysłać ostrzeżenie.

3.5. Implementacja aplikacji


internetowej wysyłającej
pocztę elektroniczną
3.5. Implementacja aplikacji internetowej wysyłającej pocztę

Istnieje coraz więcej bibliotek umożliwiających wysyłanie wiadomości


poczty elektronicznej bezpośrednio z poziomu szkiców platformy Arduino.
Wszystkie te biblioteki wymagają jednak autonomicznego, dedykowanego
serwera poczty elektronicznej, który udostępnia niezbędną bramę pocztową.
Oznacza to, że nawet jeśli kod wysyłający tego rodzaju wiadomości można
skompilować do postaci szkicu platformy Arduino, warunkiem jego działania
(i wysyłania przez platformę Arduino wiadomości poczty elektronicznej
adresowanej do wybranych adresatów) jest korzystanie z pomocy odpowied-
niej usługi pośredniczącej.
Czytelnicy, którzy mają dostęp do serwera poczty SMTP i mogą wykorzy-
stać ten serwer do przekazywania wiadomości wychodzących, mogą znaleźć
odpowiednie instrukcje w książce Maika Schmidta zatytułowanej Arduino:
A Quick Start Guide [Sch11]. Książka zawiera niezbędny kod i szcze-
gółowy opis procedury opracowania odpowiedniego rozwiązania. W razie
braku dostępu do dedykowanej bramy SMTP możemy skorzystać z jednej
z wielu ofert hostingu obejmujących możliwość wysyłania wiadomości poczty
elektronicznej z poziomu skryptów języka PHP.
Na potrzeby tego projektu wybrałem popularny, wstępnie skonfigurowany
serwer WWW z obsługą języka PHP i bramą wychodzącą protokołu, czyli
konfigurację oferowaną między innymi przez tak popularne firmy hostingowe
jak Dreamhost.net czy Godaddy.com.
Skrypt języka PHP używany do wysyłania wiadomości poczty elektronicznej
składa się z zaledwie kilku prostych wierszy kodu. W pierwszym kroku
przekazujemy na serwer dwa parametry: rodzaj wysyłanego powiadomie-
nia oraz zarejestrowaną wartość czujnika ugięcia. W dalszej części skryptu
konstruujemy wiadomość poczty elektronicznej złożoną z adresu odbiorcy,
tematu i właściwej treści powiadomienia. Po wykonaniu tych kroków mo-
żemy wysłać wiadomość.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  65

Plik WaterLevelNotifier/wateralert.php

<?php
// Uzyskuje rodzaj powiadomienia do wysłania
// oraz bieżącą wartość czujnika ugięcia.
$alertvalue = $_GET["alert"];
$flexvalue = $_GET["flex"];

$contact = 'your@emailaddress.com';

if ($alertvalue == "1") {
$subject = "Alarm czujnika poziomu wody";
$message = "Rosnący poziom wody spowodował, że czujnik ugięcia
osiągnął wartość " . $flexvalue . ".";
mail($contact, $subject, $message);
echo("<p>Ostrzeżenie o poziomie wody zostało wysłane.</p>");
} elseif ($alertvalue == "0") {
$subject = "Poziom wody mieści się w normie";
$message = "Poziom wody nie przekracza progów alarmowych.
Czujnik ugięcia ma wartość " . $flexvalue . ".";
mail($contact, $subject, $message);
echo("<p>Informacja o bezpiecznym poziomie wody została wysłana.</p>");
}
?>

Dlaczego w tym projekcie użyto serwera WWW z obsługą PHP?


To proste — ponieważ obsługa skryptów języka PHP należy do naj-
bardziej popularnych elementów konfiguracji oferowanych przez
firmy hostingowe. Mimo że sam wolę bardziej nowoczesne frame-
worki aplikacji internetowych, jak Django czy Ruby on Rails dostęp-
ne na wirtualnych serwerach prywatnych (ang. virtual private server —
VPS), technologie tego typu nie są tak powszechnie obsługiwane
przez firmy hostingowe jak obsługa skryptów PHP. Brak odpowied-
nich usług w ofercie hostingowej nie stanowiłby problemu, gdyby-
śmy skonfigurowali serwer WWW w ramach własnej sieci (zastosu-
jemy takie rozwiązanie w rozdziale 7. zatytułowanym „Internetowy
włącznik światła”) lub gdybyśmy mieli dostęp do serwera wirtual-
nego VPS. Jeśli jednak weźmiemy pod uwagę koszty konfiguracji
serwera WWW i serwera poczty elektronicznej, który będzie prawi-
dłowo przekazywał wiadomości SMTP, prostszym rozwiązaniem jest
zastosowanie opcji z naszego pierwszego projektu.
Do wysyłania wiadomości poczty elektronicznej z poziomu skryptu
języka PHP wystarczy jeden plik tego języka zawierający zaledwie jeden
wiersz kodu. Zainteresowani czytelnicy mogą oczywiście podjąć
próby opracowania odpowiednich rozwiązań w swoich ulubionych
frameworkach aplikacji internetowych. W razie sukcesu zachęcam do
podzielenia się swoimi odkryciami i doświadczeniami z pozostałymi
czytelnikami na oficjalnym forum tej książki.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
66  3.5. Implementacja aplikacji internetowej wysyłającej pocztę

Skrypt wywołuje wbudowaną funkcję mail języka PHP, która otrzymuje


na wejściu trzy wymagane parametry: odbiorcę lub odbiorców, tytuł oraz
właściwą treść wiadomości. Tak, to naprawdę takie proste.
Kod należy zapisać w pliku nazwanym wateralert.php i umieszczonym
w katalogu głównym serwera PHP. Skrypt można przetestować, otwierając
przeglądarkę internetową i wpisując adres http://NAZWA_SERWERA_
PHP/wateralert.php?alert=1&flex=486. Strona powinna wyświetlić
komunikat Ostrzeżenie o poziomie wody zostało wysłane., a odpowiednia
wiadomość poczty elektronicznej powinna trafić do skrzynki odbiorczej
adresata. Jeśli komunikat nie zostanie wyświetlony lub jeśli skrypt nie wy-
śle wiadomości poczty elektronicznej, należy sprawdzić ustawienia serwera
PHP pod kątem poprawności konfiguracji serwera WWW i działania
bramy poczty. Jeśli mimo to test wysyłania wiadomości wykazuje błąd,
należy się skontaktować z dostawcą usługi hostingowej, aby upewnić się,
że serwer został prawidłowo skonfigurowany z myślą o wysyłaniu wiado-
mości z poziomu kodu języka PHP.
Wyodrębnienie mechanizmu wysyłania wiadomości poza logikę właściwe-
go kodu wykonywanego na platformie Arduino ułatwia modyfikowanie
listy adresatów i treści powiadomień.
Skoro dysponujemy już działającą bramą komunikatów, możemy połączyć
platformę Arduino z modułem sieciowym, aby umożliwić komunikację czuj-
nika ugięcia ze światem zewnętrznym.

Zabezpieczanie powiadomień
Jeśli opisany skrypt ma na stałe pełnić funkcję usługi przekazywania
wiadomości generowanych przez platformę Arduino, warto rozważyć
dodanie warstwy zabezpieczeń sygnału transmisyjnego, tak aby tylko
nasz system sprawdzania poziomu wody mógł wysyłać ostrzeżenia.
Usługę można zabezpieczyć albo za pomocą tak prostego (ale też
słabego) mechanizmu jak przekazywanie hasła w ramach parame-
trów GET protokołu HTTP, albo stosując bezpieczny token transak-
cyjny wymieniany pomiędzy serwerem WWW a platformą Arduino
podczas uwierzytelniania. Mimo że analiza dobrych mechanizmów
zabezpieczeń wykraczałaby poza zakres tematyczny tej książki, warto
rozważyć takie rozwiązanie, aby uniknąć sytuacji, w której publicznie
dostępny skrypt przekazujący PHP pocztę elektroniczną zostanie wyko-
rzystany przez nieproszonych gości.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  67

3.6. Dodanie modułu sieciowego


Moduł sieciowy należy połączyć z płytką Arduino w taki sposób, aby gniazdo
Ethernet znajdowało się na górze i było skierowane w tym samym kierunku
co gniazdo USB samej platformy Arduino. Po zamontowaniu modułu sie-
ciowego należy przełączyć przewody, tak aby zamiast odpowiednich wtyków
na płytce Arduino były teraz połączone z wtykiem 5-woltowym i wtykiem
analogowym nr 0 (A0) modułu sieciowego.
To samo należy zrobić z rezystorem 10 kΩ użytym do zmostkowania wtyków
uziemienia (Gnd) i A0. Warto teraz ponownie uruchomić testowy program
i zsprawdzić wyświetlone wartości. W moim przypadku odczytana wartość
bazowa (dla wyprostowanego czujnika) była inna niż w konfiguracji platfor-
my Arduino bez modułu sieciowego, zatem warto to sprawdzić. Ponieważ
interesują nas bardziej odchylenia względem tej wartości bazowej (nie
kalibracja wskazań czujnika), musimy zapisać wartość dla wyprostowanego
czujnika i określić w kodzie źródłowym, jakie ugięcia (w obu kierunkach),
czyli jakie odchylenia względem wartości bazowej będą akceptowane, zanim
szkic wyśle powiadomienie.
Skoro nasz sprzęt jest już przygotowany do komunikacji sieciowej, możemy
przystąpić do uzupełnienia naszego szkicu o kod wysyłający dane o stanie
czujnika ugięcia na serwer PHP.

Kodowanie modułu sieciowego


Dane będą wysyłane programowo za pośrednictwem modułu sieciowego.
Najpierw jednak musimy dołączyć do naszego szkicu referencję zarówno
do biblioteki Arduino Ethernet, jak i do powiązanej z nią biblioteki inter-
fejsu SPI (od ang. Serial Peripheral Interface)7. Te dwie biblioteki zawie-
rają kod potrzebny do zainicjalizowania modułu sieciowego i umożliwiają
nam określenie niezbędnych szczegółów komunikacji sieciowej. Obie bi-
blioteki są dołączane do instalacji środowiska Arduino IDE, zatem nasze
zadanie sprowadza się do zaimportowania bibliotek SPI.h i Ethernet.h za
pomocą odpowiednich wyrażeń #include. Oba wyrażenia należy umieścić
na początku szkicu:

7
Patrz odpowiednio strony http://arduino.cc/en/Reference/Ethernet i http://www.
arduino.cc/playground/Code/Spi.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
68  3.6. Dodanie modułu sieciowego

Plik WaterLevelNotifier/WaterLevelNotifier.pde

#include <SPI.h>
#include <Ethernet.h>

Po dołączeniu bibliotek potrzebnych do obsługi modułu sieciowego możemy


przypisać temu modułowi unikatowe adresy MAC (od ang. Media Access
Control) i IP. Mimo że istnieją biblioteki implementujące protokół DHCP
opracowane przez społeczność programistów platformy Arduino, prostszym
rozwiązaniem jest przypisanie modułowi sieciowemu stałego adresu IP.
Jeśli na przykład sieć domowa używa adresu bramy 192.168.1.1, należy przy-
pisać modułowi sieciowemu wysoki adres IP, na przykład 192.168.1.230.
Jeśli ten adres ma być na stałe używany jako statyczny adres IP tego modułu,
warto sprawdzić w dokumentacji domowego routera, jak ustawić przedział
statycznych adresów IP w sieci, w której jest stosowany protokół DHCP.
Plik WaterLevelNotifier/WaterLevelNotifier.pde

// konfiguracja parametrów modułu sieciowego


byte MAC[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xEF };

// ten adres IP modułu sieciowego należy zastąpić adresem


// należącym do przedziału dostępnego w danej sieci
byte IPADDR[] = { 192, 168, 1, 230 };

// ten adres należy zastąpić adresem bramy (routera)


byte GATEWAY[] = { 192, 168, 1, 1 };

// ten adres należy zastąpić maską podsieci


byte SUBNET[] = { 255, 255, 255, 0 };

// ten adres IP należy zastąpić adresem IP serwera PHP


byte PHPSVR[] = {???, ???, ???, ???};

// inicjalizuje obiekt typu Client i przypisuje go do adresu IP


// serwera PHP (zastosowano standardowy port nr 80 protokołu HTTP)
Client client(PHPSVR, 80);

W pierwszym kroku definiujemy stałe reprezentujące statyczne adresy MAC


i IP, które będą używane przez konfigurowany moduł sieciowy. Stałej
GATEWAY należy przypisać adres routera z dostępem do internetu, a stałej SUBNET
należy przypisać maskę podsieci (w większości sieci domowych maska ma
postać 255.255.255.0). Przed funkcją setup() tego szkicu zadeklarowali-
śmy także adres IP serwera, na którym działa nasz skrypt języka PHP.
Po zadeklarowaniu potrzebnych stałych możemy przystąpić do inicjalizacji
modułu sieciowego w ciele funkcji setup() tego szkicu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  69

Plik WaterLevelNotifier/WaterLevelNotifier.pde

void setup()
{
// na potrzeby komunikatów diagnostycznych w oknie portu szeregowego
Serial.begin(9600);

// konfiguruje wbudowaną diodę LED na wtyku nr 13


pinMode(ONBOARD_LED, OUTPUT);

// inicjalizuje moduł sieciowy przy użyciu zdefiniowanych wcześniej adresów MAC i IP


Ethernet.begin(MAC, IPADDR, GATEWAY, SUBNET);
// czeka na inicjalizację modułu sieciowego
delay(1000);
}

Środowisko Arduino IDE w systemie Linux


i biblioteka modułu sieciowego
W przypadku korzystania ze środowiska Arduino IDE w wersji dla
systemu Linux stosowanie biblioteki referencyjnej modułu siecio-
wego może powodować pewne problemy. Problem można łatwo
wykryć, ponieważ dane wysyłane za pośrednictwem modułu sie-
ciowego są nieczytelne. Na szczęście istnieje i jest dostępna do po-
brania alternatywna wersja biblioteki Ethernet nazwana Ethernet28.
Więcej informacji na ten temat można znaleźć w dodatku A zaty-
tułowanym „Instalacja bibliotek platformy Arduino”. Po zainstalowa-
niu biblioteki Ethernet2 należy zmienić odwołanie do nagłówka Ether-
net.h w oryginalnym wyrażeniu #include, stosując w jego miejsce
wyrażenie #include Ethernet2.h.

Warto zwrócić uwagę na sposób użycia obiektu Ethernet w wywołaniu


Ethernet.begin(MAC, IPADDR, GATEWAY, SUBNET);. Właśnie w tym wierszu moduł
sieciowy jest inicjalizowany przy użyciu przekazanych adresów MAC i IP.
Dysponujemy teraz działającym połączeniem sieciowym. Możemy wresz-
cie przystąpić do następnego kroku, czyli implementacji mechanizmu wy-
syłania żądań na serwer PHP w momencie przekroczenia wyznaczonego
progu przez czujnik ugięcia.

8
http://code.google.com/p/tinkerit/source/browse/trunk/Ethernet2+library/Ethernet2/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
70  3.6. Dodanie modułu sieciowego

DNS i DHCP a moduł sieciowy


Biblioteka Ethernet nie oferuje wbudowanej obsługi systemu DNS
ani protokołu DHCP. Odpowiednie rozwiązania najprawdopodobniej
zostaną zaimplementowane w najbliższym wydaniu platformy Ar-
duino. Do tego czasu nie możemy identyfikować serwerów za po-
mocą nazw domen, np. www.mojswietnyprojektwykrywaniapoziomu-
wody.pl — musimy się posługiwać adresami IP przypisanymi do
odpowiednich serwerów.
Okazuje się jednak, że dzięki jednemu z miłośników platformy Ar-
duino, George’owi Kaindlowi, korzystanie z systemu DNS i proto-
kołu DHCP jest możliwe już teraz. Czytelnicy, którzy wolą oszczę-
dzić cenne miejsce w pamięci platformy Arduino, powinni zapoznać
się z dokumentacją bibliotek modułu sieciowego tej platformy,
gdzie znajdą więcej szczegółów9.

Wysyłanie komunikatu
Do tej pory używaliśmy platformy Arduino do odczytywania wartości
analogowych generowanych przez czujnik ugięcia. Zainicjalizowaliśmy też
moduł sieciowy w celu połączenia tej platformy z lokalną siecią komputerową.
W kodzie naszego szkicu wyznaczyliśmy także miejsce dla funkcji niezbędnej
do wywołania skryptu PHP na serwerze WWW. Możemy teraz przystąpić
do implementacji tej funkcji. Funkcja zostanie nazwana ContactWebServer.
Funkcja ContactWebServer otrzyma na wejściu te same dwa parametry, które
przekazywaliśmy na wejściu funkcji SendWaterAlert, czyli band_value i bend_
state. Na końcu funkcji SendWaterAlert należy dodać wiersz ContactWebServer
(bend_value, bend_state);, ponieważ nasz program będzie nawiązywał komu-
nikację z wyznaczonym serwerem PHP za każdym razem, gdy czujnik ugięcia
zmieni swój stan.
Nasz system jest prawie gotowy. Pozostaje nam już tylko napisanie ciała
funkcji ContactWebServer. Kod tej funkcji będzie odpowiadał za nawiązanie
połączenia ze skryptem PHP na serwerze WWW i za wysłanie na ten ser-
wer odpowiednio sformatowanego żądania GET protokołu HTTP. Wysyłany
łańcuch musi zawierać wartości zmiennych bend_state i bend_value. Łańcuch
przygotowany na poziomie szkicu zostanie następnie przetworzony po stronie
serwera przez odpowiednią funkcję języka PHP.

9
http://gkaindl.com/software/arduino-ethernet

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  71

Plik WaterLevelNotifier/WaterLevelNotifier.pde

void ContactWebServer(int bend_value, int bend_state)


{
Serial.println("Nawiązywanie połączenia z serwerem WWW celu wysłania ostrzeżenia...");

if (client.connect())
{
Serial.println("Połączono z serwerem PHP");
// generuje żądanie protokołu HTTP
client.print("GET /wateralert.php?alert=");
client.print(bend_state);
client.print("&flex=");
client.print(bend_value);
client.println(" HTTP/1.0");
client.println();
client.stop();
}
else
{
Serial.println("Próba połączenia z serwerem WWW zakończyła się niepowodzeniem");
}
}

Musimy jeszcze przetestować gotowy szkic. Należy wysłać program na


platformę Arduino, otworzyć w środowisku programowania okno monitora
portu szeregowego, wygiąć czujnik ugięcia i obserwować komunikaty. Warto
też śledzić zawartość wybranej skrzynki odbiorczej pod kątem odpowiednich
wiadomości poczty elektronicznej. Czy na wskazany adres dotarły wiadomo-
ści zatytułowane Alarm czujnika poziomu wody i Poziom wody mieści się
w normie oraz czy te wiadomości odpowiadają powiadomieniom wyświe-
tlanym w oknie monitora portu szeregowego? Jeśli nie, warto sprawdzić, czy
platforma Arduino jest połączona z siecią domową — w tym celu wystar-
czy wysłać sygnał ping na adres IP przypisany tej platformie.
Warto sprawdzić adres URL usługi wysyłania wiadomości (odpowiedniego
skryptu PHP) i upewnić się, że otrzymujemy wiadomość po wpisaniu
w przeglądarce internetowej adresu http://MÓJSERWERphp/wateralert.
php?alert=1&flex=486. Jeśli wszystko działa zgodnie z oczekiwaniami,
możemy przystąpić do ostatnich korekt tego projektu, aby zapewnić jego
pełną funkcjonalność.

3.7. Łączenie wszystkich elementów


Jesteśmy już bardzo blisko szczęśliwego końca. Na tym etapie system sprawdza-
nia poziomu wody powinien wyglądać tak jak na rysunku 3.4 zatytułowanym

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
72  3.7. Łączenie wszystkich elementów

„Gotowy system powiadamiania o poziomie wody”. Pozostaje nam już tylko


trwałe i bezpieczne zamontowanie czujnika ugięcia w miejscu, w którym ma
być monitorowany poziom cieczy i w którym będzie możliwe swobodne zgi-
nanie tego czujnika.

Rysunek 3.4. Gotowy system powiadamiania o poziomie wody

Punkt, w którym dwa przewody połączono z końcówkami czujnika ugięcia,


musi być na tyle stabilnie zamocowany, aby nie zmienił położenia w razie
podniesienia się poziomu wody i uniesienia spławika. Jeśli to mocowanie
nie będzie dość sztywne, czujnik ugięcia pozostanie wyprostowany, a odpo-
wiedni szkic platformy Arduino nie wyśle powiadomienia o rosnącym pozio-
mie wody. Podstawa czujnika musi więc być stabilna i zabezpieczona przed
obracaniem.
Polecam zastosowanie kleju, węża termokurczliwego lub mocnej taśmy kleją-
cej. Jeśli mimo zastosowanych środków podstawa czujnika wciąż nie jest
dość stabilna, warto dodatkowo zastosować drewniane listwy. Podstawę czuj-
nika (końcówkę, do której podłączono przewody) należy umieścić pomiędzy
listwami. Całość należy wielokrotnie okleić taśmą izolacyjną. Tak usztywnioną
końcówkę czujnika można teraz przymocować do drewnianego słupka (np.
o przekroju 2×4 cm), który zostanie zainstalowany w zbiorniku na wodę.
W przypadku osadnika w piwnicy konieczne będzie zdjęcie pokrywy, zmie-
rzenie wewnętrznej średnicy zbiornika i poproszenie stolarza lub sprzedawcy
w sklepie z materiałami budowlanymi o przycięcie drewna do odpowiedniego
kształtu. Warto przyciąć listwę w taki sposób, aby była o centymetr dłuższa,
niż wynosi średnica zbiornika — dzięki temu cała konstrukcja będzie sztyw-
niejsza.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  73

Podobne rozwiązanie można zastosować w osuszaczu. Zamiast dużego ka-


wałka drewna używanego w roli podstawy dla czujnika ugięcia wystarczy
użyć cienkiej listwy (na przykład fragmentu drewnianego wieszaka) przy-
ciętej do średnicy zbiornika na wodę zbieraną przez osuszacz. Usztywnioną
końcówkę czujnika ugięcia należy zamontować w środku głównej listwy.
W zależności od głębokości zbiornika osuszacza być może trzeba będzie
przenieść tę listwę nieco wyżej, tak aby czujnik ugięcia nie wysyłał ostrzeżeń
zbyt wcześnie, na przykład po zapełnieniu połowy zbiornika.
Po uzyskaniu zadowalającej stabilności czujnika ugięcia należy zamontować
spławik i sam czujnik w niewielkiej plastikowej torbie, na przykład w szczel-
nym woreczku śniadaniowym. Dzięki temu czujnik pozostanie suchy i odpo-
wiednio zabezpieczony na wypadek wzrostu poziomu wody. Przewody pod-
łączone do czujnika należy wyprowadzić co najmniej metr ponad miejsce
instalacji czujnika i podłączyć do panelu Arduino lub modułu sieciowego.
Platformę Arduino należy podłączyć do 9-woltowego zasilacza, a do modułu
Ethernetu należy podłączyć przewód sieciowy. Po kilku sekundach od
podłączenia platformy Arduino do prądu należy przeprowadzić krótki test
ugięcia. Jeśli w wyniku testu na skrzynkę poczty elektronicznej trafią od-
powiednie powiadomienia, nasz system działa prawidłowo!
Możemy teraz ponownie zainstalować przykrywę monitorowanego zbior-
nika na wodę i czekać na powiadomienie o rosnącym poziomie wody.

3.8. Następne kroki


Gratuluję pomyślnej realizacji pierwszego projektu automatyzacji domu przy
użyciu platformy Arduino. Podczas prac nad tym projektem miałeś okazję
opanować wiele umiejętności, które będą przydatne w pozostałych projek-
tach. Miałeś okazję programować platformę Arduino, pobierać i przetwa-
rzać dane generowane przez czujnik ugięcia oraz wysyłać wiadomości poczty
elektronicznej za pośrednictwem modułu sieciowego platformy Arduino
i skryptu PHP na serwerze WWW. Wszystkie te techniki będziemy stoso-
wali w części pozostałych projektów prezentowanych w tej książce.
Jedną z największych zalet projektowania i budowy własnych projektów
jest możliwość dostosowywania tworzonych rozwiązań do indywidualnych,
niepowtarzalnych potrzeb. Przekroczenie wyznaczonego poziomu wody ma
powodować umieszczenie wpisu na Twitterze zamiast wysłania wiadomości
poczty elektronicznej? To żaden problem. Wystarczy zastąpić fragment kodu

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
74  3.8. Następne kroki

odpowiedzialny za wysyłanie wiadomości poczty elektronicznej kodem za-


czerpniętym z projektu „Ćwierkający karmnik dla ptaków” opisanego w dal-
szej części tej książki. A może wolisz zastąpić elektroniczne wiadomości ja-
kimś wizualnym wskaźnikiem, na przykład w formie migającej czerwonej
lampy, aby poczuć się jak bohaterowie filmów akcji? To proste. Lampę moż-
na włączać i wyłączać w stałych odstępach czasu za pomocą kodu zaczerp-
niętego z projektu „Internetowy włącznik światła”.
Oto kilka innych pomysłów na wykorzystanie i rozbudowę systemu złożo-
nego z czujnika ugięcia:
 Zmienne dane analogowe generowane przez czujnik ugięcia można
z powodzeniem wykorzystać nie tylko do oceny stanu czujnika, ale
też do badania kąta ugięcia. Tę ciekawą właściwość czujnika można
wykorzystać w systemie śledzącym i rejestrującym intensywność
opadów deszczu (na podstawie rosnącego poziomu wody w zbiorniku
reprezentowanego przez stopień ugięcia czujnika z przymocowanym
spławikiem).
 Warto rozważyć dodanie do szkicu mechanizmu wysyłania komuni-
katów w stałych odstępach czasu (np. co godzinę) i opracowanie
funkcji PHP odpowiedzialnej za otrzymywanie tych komunikatów.
Wysyłane komunikaty powinny obejmować bieżące wskazania czujnika
ugięcia. Zarejestrowane wartości należy przeanalizować pod kątem
anomalii, na przykład braku wartości (czyli wartości równej 0 w wyni-
ku jakiegoś uszkodzenia) lub wartości większych niż 999 (wskutek
krótkiego spięcia). Każde wykrycie takiej wartości progowej powin-
no powodować wysłanie stosownej wiadomości poczty elektronicznej.
Co więcej, w razie braku komunikatów wysłanych przez platformę
Arduino w ciągu dwóch godzin skrypt PHP powinien poinformować
użytkownika o prawdopodobnej awarii. Ten rozszerzony mecha-
nizm monitorowania poinformuje nas o ewentualnych problemach
sprzętowych wymagających naszej interwencji.
 Na kalibrację czujnika ugięcia mogą mieć wpływ zmiany temperatury.
System można uzupełnić o czujnik temperatury, tak aby wartości pro-
gowe były dobierane dynamicznie zależnie od temperatury otoczenia.
 Obawiasz się szkód powodowanych przez silne wiatry (na przykład
uszkodzenia dachu)? Wystarczy zastąpić spławik anemometrem po-
dobnym do tych sprzedawanych wraz ze stacjami pogody, zainstalo-
wać ten czujnik na zewnątrz budynku i czekać na wiadomości poczty
elektronicznej generowane w czasie silnego wiatru.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 3. • System powiadamiania o poziomie wody  75

 Jeśli zamontowałeś drzwiczki dla swojego psa lub kota, możesz za-
montować czujnik ugięcia ponad drzwiczkami i tak skierować drugi
koniec czujnika, aby swobodnie ślizgał się po powierzchni drzwiczek
i jednocześnie wychylał się wraz z tymi drzwiczkami. Tak zamontowa-
ny czujnik można połączyć z kamerą internetową, aby sprawdzić,
czy rzeczywiście nasze zwierzę korzysta z dodatkowego wejścia, czy
raczej nasz dom jest odwiedzany przez nieproszonych gości.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
76  3.8. Następne kroki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4.
Elektryczny
pies stróżujący

P
amiętasz, jak ostatni raz odwiedziłeś znajomych, którzy mają wielkie-
go psa? Czy donośne szczekanie niskim tonem, które rozległo się
zaraz po naciśnięciu dzwonka, nie wywołało u Ciebie niepokoju przed
wejściem do mieszkania? Większość właścicieli psów docenia czujność
swoich czworonożnych przyjaciół. Psy potrafią błyskawicznie reagować na
ruch i natychmiast przystępować do działania, które najczęściej polega na
szczekaniu, wychylaniu pysków zza zasłon w oknach i innych czynnościach
niezbędnych do sprawdzenia, co dzieje się na zewnątrz.
Elektryczny pies stróżujący oferuje bardzo podobne korzyści w sferze bezpie-
czeństwa i jednocześnie nie ma wad prawdziwych psów, choćby w postaci
wszechobecnej sierści (patrz rysunek 4.1 zatytułowany „Odstraszanie nie-
chcianych gości za pomocą elektrycznego psa stróżującego”).
Projekt wymaga połączenia platformy Arduino, modułu dźwiękowego, pa-
sywnego czujnika ruchu na podczerwień (ang. Passive InfraRed — PIR)
oraz silnika wykonawczego. Po zaprogramowaniu i aktywowaniu system
będzie naśladował wściekłego psa, który tylko czeka na okazję, żeby rzucić się
na niepożądanego gościa. Niewielki pręt przymocowany do ramion silnika
wykonawczego będzie naśladował ruchy zdenerwowanego, skaczącego psa.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
78  4.1. Czego potrzebujemy

Rysunek 4.1. Odstraszanie niechcianych gości za pomocą elektrycznego


psa stróżującego

Fragmenty ubrań doczepione na drugim końcu tego kija będą ustawione


w taki sposób, aby powodować ruch zasłony lub firany w oknie. Wykrycie
ruchu będzie uruchamiało serwomotor, który spowoduje ruch kija w górę
i w dół. Fragmenty ubrań doczepione na końcu tego kija będą powodowały
falowanie zasłony w oknie, a z głośnika połączonego z modułem dźwiękowym
będzie się wydobywało głośne, losowo generowane szczekanie i warczenie.
Połączenie dźwięku i ruchu będzie przypominało głośnego psa próbującego
za wszelką cenę wystawić pysk za zasłonę.
Gotowy system będzie w pełni przenośny, ponieważ elektryczny pies stróżu-
jący może być ustawiany w drzwiach, przy oknie lub nawet w pomieszczeniu,
które chcemy chronić przed wizytami niepożądanych gości.

4.1. Czego potrzebujemy


Projekt wymaga zaledwie kilku komponentów. Łączny koszt wszystkich czę-
ści nie powinien przekroczyć czterystu złotych. Ponieważ jednak wszystkie
te elementy można wykorzystać także w pozostałych projektach opisanych
w tej książce (oraz we własnych inicjatywach typu zrób to sam), wspomniane

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4. • Elektryczny pies stróżujący  79

wydatki można traktować jako usprawiedliwioną inwestycję. Do skonstru-


owania elektrycznego psa stróżującego będziemy potrzebowali następujących
elementów (patrz rysunek 4.2 zatytułowany „Części elektrycznego psa stró-
żującego”):
1. Arduino Uno;
2. pakiet rozszerzający platformę Arduino o obsługę muzyki i dźwięku
dostępny w sklepie Adafruit (pakiet obejmuje moduł sieciowy, gło-
śnik, przewód i kartę SD)1;
3. standardowy serwomotor z wysokim momentem obrotowym2;
4. pasywny czujnik ruchu na podczerwień (PIR);
5. 9-woltowy zasilacz dla platformy Arduino (potrzebny do zasilania
systemu po odłączeniu przewodu USB);
6. twardy drewniany kij ze skrawkami materiału lub gumy przyczepio-
nymi na jednym końcu (potrzebnymi do poruszania firaną lub za-
słoną);
7. przewód, drut w plastikowej osłonce lub gumki do przymocowania
drewnianego kija do silnika.

Rysunek 4.2. Części elektrycznego psa stróżującego

1
http://www.adafruit.com/products/175
2
http://www.adafruit.com/products/155

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
80  4.2. Budowa rozwiązania

Podczas budowy tego projektu będziemy potrzebowali także standardowego


przewodu USB A-B do połączenia platformy Arduino z komputerem. Ser-
womotor można kupić w lokalnym sklepie dla majsterkowiczów, natomiast
czujniki ruchu na podczerwień są dostępne w wielu zwykłych sklepach z czę-
ściami elektronicznymi, a także w sklepach internetowych.
Zacznijmy od połączenia trzech najważniejszych elementów tego projektu,
aby mogły współdziałać i naśladować agresywne zwierzę.

4.2. Budowa rozwiązania


To będzie jeden z najprostszych projektów opisanych w tej książce, ponieważ
ograniczymy się wyłącznie do platformy Arduino, gotowego modułu rozsze-
rzającego tę platformę, jednego czujnika i jednego silnika. Gotowy zmonto-
wany system powinien przypominać konstrukcję pokazaną na rysunku 4.3
zatytułowanym „Elektryczny pies stróżujący”. Proces budowy tego systemu
będzie się składał z następujących kroków:
1. Połączenie platformy Arduino z modułem dźwiękowym.
2. Podłączenie czujnika ruchu PIR do wtyku zasilania, wtyku uziemie-
nia i jednego z dostępnych wtyków cyfrowych modułu dźwiękowego.
3. Podłączenie silnika do wtyku zasilania, wtyku uziemienia i jednego
z pozostałych wtyków cyfrowych modułu dźwiękowego.
4. Pobranie dodatkowych bibliotek platformy Arduino niezbędnych
do sterowania działaniem modułu dźwiękowego i unikania kon-
fliktów zasobów w związku z jednoczesnym wysyłaniem rozkazów
do serwomotoru.
5. Napisanie szkicu, który w reakcji na wykrycie ruchu przez czujnik
PIR będzie powodował losowe ruchy serwomotoru i odtwarzał
fragment pliku dźwiękowego.
Czytelnicy, którzy do tej pory nie mieli okazji łączyć ani testować modułu
dźwiękowego, powinni zapoznać się z materiałami dostępnymi na stronie
Ladyady3. Po sprawdzeniu działania tego modułu można przystąpić do podłą-
czania czujnika ruchu na podczerwień oraz urządzenia wykonawczego (w tym
przypadku serwomotoru) do dostępnych wtyków tego modułu.

3
http://www.ladyada.net/make/waveshield/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4. • Elektryczny pies stróżujący  81

Rysunek 4.3. Elektryczny pies stróżujący

Jaś pyta...
Czy istnieje jakiś moduł platformy Arduino
odtwarzający pliki MP3?
Tak! W sklepie internetowym Sparkfun można znaleźć rozszerzenie
platformy Arduino nazwane modułem MP3 i przypominające stan-
dardowy moduł dźwiękowy firmy Adafruit4. Z uwagi na różnice
dzielące niezbędne biblioteki w tym rozdziale skoncentruję się na
implementacji modułu dźwiękowego. Zainteresowanych czytelników
zachęcam do samodzielnych eksperymentów z alternatywnym mo-
dułem MP3 firmy Sparkfun. Czytelników, którzy potrzebują modułu
dźwiękowego zdolnego do odtwarzania plików w dodatkowych
formatach, jak Windows Media Audio, MIDI czy Ogg Vorbis, z pew-
nością zainteresuje moduł Seeed Music Shield dostępny w sklepie
Maker Shed — Seeed Music Shield jest przykładem doskonałej in-
tegracji funkcji odtwarzania plików audio ze świetnie zaprojekto-
wanym modułem platformy Arduino5.

4
http://www.sparkfun.com/products/9736
5
http://www.makershed.com/ProductDetails.asp?ProductCode=MKSEEED14

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
82  4.3. System elektrycznego psa stróżującego

4.3. System elektrycznego


psa stróżującego
Warto teraz przyjrzeć się połączeniom na rysunku 4.4 zatytułowanym
„Schemat połączeń w systemie elektrycznego psa stróżującego”. Schemat
ilustruje sposób łączenia przewodów z modułem dźwiękowym. Sam moduł
dźwiękowy należy umieścić na płytce Arduino. Należy pamiętać, że moduł
dźwiękowy używa wielu wtyków do samej komunikacji z platformą Ardu-
ino, stąd nie wszystkie wtyki są dostępne dla szkicu tworzonego w ramach
tego projektu. Wystarczy postępować ściśle według tego schematu, a połą-
czenie całego systemu nie powinno sprawić najmniejszego problemu.

Rysunek 4.4. Schemat połączeń w systemie elektrycznego psa stróżującego

Dodatnią końcówkę czujnika ruchu PIR należy połączyć z wtykiem 3,3 V


na płytce modułu dźwiękowego. Ujemną końcówkę tego czujnika należy
połączyć z jednym z wtyków uziemienia modułu dźwiękowego. Przewód
sterujący (środkowy wtyk lub środkową końcówkę czujnika PIR) należy na-
stępnie połączyć z cyfrowym wtykiem nr 12 modułu dźwiękowego.
W następnym kroku należy połączyć dodatnią końcówkę serwomotoru z 5-
woltowym wtykiem modułu dźwiękowego. Ujemną końcówkę silnika należy
połączyć z drugim dostępnym wtykiem uziemienia na płytce modułu dźwię-

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4. • Elektryczny pies stróżujący  83

kowego. Na końcu należy podłączyć końcówkę sterującą do wtyku cyfro-


wego nr 11 na płytce modułu dźwiękowego.
Na potrzeby testów można dołączyć do przewodów końcówki męskie, po
czym podłączyć je bezpośrednio do odpowiednich gniazd modułu dźwię-
kowego. Docelowo należy oczywiście zastosować bardziej niezawodne
połączenia w formie gotowych wtyczek męskich lub żeńskich. Odpowiednie
wtyczki są dostępne w sklepach oferujących platformy i moduły Arduino.
Jeśli moduł dźwiękowy ma być używany wyłącznie do tego projektu, warto
rozważyć trwałe przylutowanie przewodów do wtyków tego modułu, aby
zagwarantować możliwie najbardziej trwałe połączenia elektryczne.
Przed przystąpieniem do pisania szkicu można wykonać jeszcze jeden krok.
Musimy albo nagrać i zapisać w cyfrowej formie szczekanie i warczenie
jakiegoś psa (najlepiej w wielu wersjach), albo pobrać (z legalnego źró-
dła) gotowe próbki takich dźwięków.
Pierwsze rozwiązanie zajmie więcej czasu i będzie wymagało dostępu do
psa, który umie szczekać i warczeć na komendę. Co więcej, warunkiem na-
grania odpowiednich dźwięków będzie trzymanie mikrofonu bezpośrednio
obok pyska i kłów rozjuszonego zwierzęcia! To rozwiązanie wymaga co
prawda dodatkowej pracy, jednak uzyskany efekt najprawdopodobniej
będzie bardziej realistyczny i przekonujący. Ponieważ źródłem nagrania
jest prawdziwy, znany nam pies, możemy być pewni, że efekt będzie wy-
starczająco wiarygodny.
Drugie rozwiązanie, polegające na znalezieniu w internecie różnych pró-
bek dźwięków wydawanych przez rozjuszone psy, jest wygodniejsze, ale
też rzadko pozwala uzyskać równie przekonujący i wiarygodny efekt. Pro-
blem dotyczy szczególnie próbek szczekania i warczenia przez psy różnych
ras. Czy to możliwe, aby jeden pies warczał jak wściekły doberman, aby
minutę później ujadać jak mały pudelek? Co więcej, pobierając gotowe próbki
dźwięków z internetu, musimy mieć na uwadze prawa autorskie twórców
tych plików. Polecam serwis internetowy Freesound Project6, w którym moż-
na znaleźć mnóstwo próbek dźwięków dostępnych na zasadach opisanych
w licencji Creative Commons Sampling Plus.

6
http://www.freesound.org

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
84  4.3. System elektrycznego psa stróżującego

Jaś pyta...
Jak działa czujnik ruchu PIR?
Czujnik PIR wykrywa ruch, porównując dwie próbki promieniowania
podczerwonego emitowanego przez poruszające się ciało, które
jest cieplejsze od środowiska za nim. W momencie, w którym jed-
na strona czujnika odczyta wyższą wartość od drugiej strony, czujnik
wysyła do cyfrowego wtyku sygnał o wykryciu ruchu. Czujnik pod-
czerwony będący sercem czujnika ruchu PIR jest zwykle pokryty sfe-
ryczną soczewką, która ułatwia koncentrowanie światła i tym samym
wykrywanie zmian w obrazie podczerwonym (a więc także ruchu).
Szczegółowe wyjaśnienie zasad działania czujników ruchu PIR wraz
z niezbędnymi podstawami teoretycznymi można naleźć na odpo-
wiedniej stronie internetowej serwisu Ladyady7.

Po uzyskaniu pięciu plików dźwiękowych (niezależnie od ich źródła) należy


przekonwertować je na format, który będzie prawidłowo interpretowany
przez moduł dźwiękowy. Zgodnie z instrukcjami dostępnymi na witrynie
internetowej Ladyady8 próbki powinny mieć format PCM (WAV), a ich
parametry nie mogą przekraczać wartości 22 kHz, 16-bit, mono. W tym
przypadku powinniśmy stosować pliki możliwie najwyższej jakości, a prze-
strzeń dostępna na karcie SD z pewnością nie stanowi poważnego ograni-
czenia. Żaden z wybranych plików dźwiękowych nie powinien trwać dłużej
niż pięć sekund, tak aby generowany dźwięk sprawiał wrażenie lepiej zsyn-
chronizowanego z ruchami powodowanymi przez serwomotor.
Do zaimportowania, konwersji i zapisania plików dźwiękowych w odpowied-
nim formacie można użyć edytora audio, na przykład programu Audacity9.
Aby upewnić się, że tak przygotowane pliki są rzeczywiście zgodne z wyma-
ganiami modułu dźwiękowego, wystarczy skopiować te pliki na kartę SD,
umieścić tę kartę w gnieździe modułu i uruchomić szkic dap_hc.pde (dostęp-
ny w serwisie internetowym Ladyady)10. Warto zwrócić uwagę na pewną

7
http://www.ladyada.net/learn/sensors/pir.html
8
http://www.ladyada.net/make/waveshield/convert.html
9
http://audacity.sourceforge.net/
10
http://www.ladyada.net/make/waveshield/libraryhc.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4. • Elektryczny pies stróżujący  85

zmianę, którą wprowadzimy w demonstracyjnym szkicu Ladyady opracowa-


nym dla modułu dźwiękowego. Zamiast nowszej biblioteki wavehc, której
użyto w oryginalnym szkicu, zastosujemy nieco starszą bibliotekę AF_Wave.
Dzięki temu będziemy mogli użyć biblioteki MediaPlayer autorstwa użyt-
kownika avandalen, członka społeczności programistów platformy Arduino11
— biblioteka znacznie upraszcza operowanie na plikach wave przy użyciu
modułu dźwiękowego. Wspomniana biblioteka (oraz biblioteki opracowane
przez innych członków społeczności programistów platformy Arduino dla
serwomotoru) zostanie omówiona w następnym podrozdziale.

4.4. Szkolenie psa


Szkic, który opracujemy w tym podrozdziale, będzie odpowiadał za monito-
rowanie czujnika PIR pod kątem zdarzeń powodowanych przez ruch w za-
sięgu tego czujnika. W razie wykrycia ruchu moduł odtworzy losowo jeden
z pięciu różnych plików dźwiękowych zapisanych na karcie SD tego mo-
dułu. W tym samym czasie serwomotor wykonuje obroty o maksymalnie 150
stopni (w zależności od odtwarzanego dźwięku). Drewniany kij należy w taki
sposób przymocować do serwomotoru, aby obroty tego silnika powodowały
ruch kija w górę i w dół. Umieszczenie kija za zasłoną lub firaną stworzy
wrażenie, że groźny pies próbuje przełożyć pysk bliżej drzwi lub okna, aby
sprawdzić, kto zbliża się do domu.
Musimy najpierw dołączyć plik nagłówkowy MediaPlayer.h wraz z dwoma
plikami zależnymi (pgmspace.h, który jest częścią biblioteki zarządzania pa-
mięcią dołączanej do standardowej instalacji platformy Arduino, oraz util.h,
który jest częścią oryginalnej biblioteki AF_Wave modułu dźwiękowego).
Ponieważ klasy biblioteki MediaPlayer używają elementów biblioteki AF_Wave,
musimy pobrać i rozpakować plik tej biblioteki, a następnie skopiować wypa-
kowany folder AF_Wave do folderu libraries platformy Arduino12.
Musimy następnie uruchomić środowisko Arduino IDE i utworzyć nowy
szkic nazwany ElectricGuardDog. Bibliotekę MediaPlayer można pobrać
ze strony internetowej tzw. placu zabaw platformy Arduino13. Pobrany plik
należy następnie rozpakować, a otrzymane w ten sposób pliki MediaPlayer.h,

11
http://www.arduino.cc/playground/Main/Mediaplayer
12
http://www.ladyada.net/media/wavshield/AFWave_18-02-09.zip
13
http://www.arduino.cc/playground/Main/Mediaplayer

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
86  4.4. Szkolenie psa

MediaPlayer.pde i MediaPlayerTestFunctions.pde należy umieścić w folderze


ElectricGuardDog, który został utworzony przez środowisko Arduino IDE
podczas tworzenia pliku ElectricGuardDog.pde. Czytelnicy, którzy pobrali
pliki projektu udostępnione dla tej książki, powinni już teraz dysponować
wszystkimi plikami niezbędnymi do działania biblioteki Mediaplayer. Bi-
blioteka Mediaplayer znacznie ułatwia zarządzanie odtwarzaniem plików
dźwiękowych.
Musimy użyć jeszcze jednej biblioteki niestandardowej, aby sterować ser-
womotorem. Próba kompilacji tego szkicu przy użyciu standardowej klasy
Servo platformy Arduino zakończyłaby się niepowodzeniem i wyświetleniem
następującego komunikatu o błędzie:
Servo/Servo.cpp.o: In function `__vector_11':
/Applications/Arduino.app/Contents/Resources/Java/libraries/Servo/Servo.cpp:103:
multiple definition of `__vector_11'

AF_Wave/wave.cpp.o:/Applications/Arduino.app/
Contents/Resources/Java/libraries/AF_Wave/wave.cpp:33: first defined here

Z czego wynika ten błąd? Biblioteka AF_Wave przejmuje to samo przerwa-


nie wektorowe co biblioteka standardowa Servo. Na szczęście jeden z człon-
ków społeczności programistów platformy Arduino, Michael Margolis,
napisał bibliotekę, która umożliwia tej platformie sterowanie maksymalnie
ośmioma serwomotorami jednocześnie. Wspomniana biblioteka eliminuje
przy okazji problem powtarzających się zasobów, który występował w orygi-
nalnej bibliotece Servo (podczas stosowania łącznie z modułem dźwiękowym).
Po pobraniu biblioteki ServoTimer214 należy rozpakować i skopiować za-
wartość spakowanego pliku do folderu ServoTimer2 w ramach folderu libraries
platformy Arduino. Warto pamiętać, że po dodaniu każdej nowej biblioteki
do folderu libraries platformy Arduino należy ponownie uruchomić środowi-
sko Arduino IDE, tak aby kompilator avr-gcc platformy Arduino miał moż-
liwość rozpoznania nowej biblioteki.
Po zapewnieniu dostępu do biblioteki AF_Wave modułu dźwiękowego
i biblioteki ServoTimer2 serwomotoru należy umieścić na początku szkicu
następujące odwołania:
Plik ElectricGuardDog/ElectricGuardDog.pde

#include <avr/pgmspace.h>
#include "util.h"
#include "MediaPlayer.h"
#include <ServoTimer2.h>

14
http://www.arduino.cc/playground/uploads/Main/ServoTimer2.zip

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4. • Elektryczny pies stróżujący  87

Musimy teraz utworzyć kilka zmiennych potrzebnych do przypisania wtyków


platformy Arduino i wartości początkowych czujnika i urządzenia wyko-
nawczego (silnika).
Plik ElectricGuardDog/ElectricGuardDog.pde

int ledPin = 13; // wbudowana dioda LED


int inputPin = 12; // wtyk wejściowy dla czujnika ruchu PIR
int pirStatus = LOW; // wartość LOW reprezentuje próg braku wykrytego ruchu
int pirValue = 0; // zmienna używana do przechowywania odczytanego statusu
// wtyku inputPin
int servoposition = 0; // początkowe położenie serwomotoru

Należy teraz utworzyć dwa obiekty skonstruowane na podstawie bibliotek


MediaPlayer i ServoTimer2, aby łatwiej sterować serwomotorem i modułem
dźwiękowym.
Plik ElectricGuardDog/ElectricGuardDog.pde

ServoTimer2 theservo; // tworzy obiekt theservo klasy ServoTimer2


MediaPlayer mediaPlayer; // tworzy obiekt mediaPlayer
// klasy MediaPlayer

Utworzone zmienne należy teraz przypisać do trybów wtyków platformy Ar-


duino (odpowiednie wyrażenia należy umieścić w funkcji setup() tworzonego
szkicu). Warto teraz nawiązać połączenie z oknem portu szeregowego środo-
wiska Arduino IDE, aby monitorować zdarzenia związane z wykrywa-
niem ruchu i odtwarzaniem dźwięku. W tej części kodu wywołujemy też
funkcję randomSeed() platformy Arduino, aby określić wartość początkową
generatora liczb losowych. Pobierając wartość z wtyku analogowego nr 0
na płytce Arduino, możemy dość skutecznie wygenerować liczbę pseudo-
losową zależną od szumu elektrycznego na tym wtyku.
Plik ElectricGuardDog/ElectricGuardDog.pde

void setup() {
pinMode(ledPin, OUTPUT); // ustawia tryb pinMode OUTPUT dla wbudowanej diody LED
pinMode(inputPin, INPUT); // ustawia tryb INPUT dla wtyku inputPin
// (czujnika ruchu PIR)
theservo.attach(7); // łączy cyfrowe wyjście serwomotoru z wtykiem nr 7
randomSeed(analogRead(0)); // przekazuje wartość początkową dla generatora liczb
// losowych platformy Arduino
Serial.begin(9600);
}

Skoro dysponujemy już niezbędnymi bibliotekami, zmiennymi, obiektami


i kodem inicjalizującym, możemy przystąpić do implementacji głównej pętli
szkicu. W największym uproszczeniu musimy w jednosekundowych odstępach
monitorować czujnik ruchu PIR pod kątem zmiany stanu. W razie wykrycia
ruchu czujnik PIR wyśle sygnał HIGH na wtyk nr 12. Po spełnieniu tego wa-

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
88  4.4. Szkolenie psa

runku nasz szkic powinien zapalić wbudowaną diodę LED i wysłać komuni-
kat o wykryciu ruchu do okna portu szeregowego środowiska Arduino IDE.
Możemy teraz wygenerować liczbę losową z przedziału od 1 do 5 na pod-
stawie utworzonej wcześniej wartości początkowej generatora. Uzyskaną
w ten sposób wartość wykorzystujemy do odtworzenia jednego z plików
dźwiękowych i wymuszenia na serwomotorze określonej liczby obrotów.
Po wykonaniu tej operacji nasz program czeka jedną sekundę, przywraca
ustawienie początkowe serwomotoru i wykonuje całą pętlę od początku. Jeśli
czujnik PIR nie wykryje ruchu (jeśli sygnał na wtyku nr 12 jest równy LOW),
wyłączamy wbudowaną diodę LED, wysyłamy do okna monitorowania portu
szeregowego komunikat Brak ruchu, zatrzymujemy odtwarzanie dźwięku
i przywracamy wartość LOW we fladze pirStatus.
Plik ElectricGuardDog/ElectricGuardDog.pde

void loop(){
pirValue = digitalRead(inputPin); // sprawdza wartość czujnika PIR
if (pirValue == HIGH) { // jeśli wykryto ruch
digitalWrite(ledPin, HIGH); // włącza wbudowaną diodę LED
if (pirStatus == LOW) { // wymusza ruch serwomotoru
Serial.println("Wykryto ruch");
// generuje liczbę losową z przedziału od 1 do 5, aby wybrać przypadkowy
// plik dźwiękowy,
// po czym odtwarza ten plik i wymusza obrót serwomotoru o liczbę stopni
// zależną od wylosowanej wartości
switch (random(1,6)) {
case 1:
Serial.println("Odtwarzanie pliku 1.WAV");
theservo.write(1250);
mediaPlayer.play("1.WAV");
break;
case 2:
Serial.println("Odtwarzanie pliku 2.WAV");
theservo.write(1400);
mediaPlayer.play("2.WAV");
break;
case 3:
Serial.println("Odtwarzanie pliku 3.WAV");
theservo.write(1600);
mediaPlayer.play("3.WAV");
break;
case 4:
Serial.println("Odtwarzanie pliku 4.WAV");
theservo.write(1850);
mediaPlayer.play("4.WAV");
break;
case 5:
Serial.println("Odtwarzanie pliku 5.WAV");
theservo.write(2100);
mediaPlayer.play("5.WAV");

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4. • Elektryczny pies stróżujący  89

break;
}

delay(1000); // czeka sekundę


theservo.write(1000); // przywraca początkową pozycję serwomotoru
pirStatus = HIGH; // ustawia wartość HIGH flagi pirStatus, aby zatrzymać
// działanie mechanizmu
}
} else {
digitalWrite(ledPin, LOW); // wyłącza wbudowaną diodę LED
if (pirStatus == HIGH){
Serial.println("Brak ruchu");
mediaPlayer.stop();
pirStatus = LOW; // ustawia wartość LOW flagi pirStatus, aby
// czujnik był przygotowany na zdarzenie ruchu
}
}
}

Po zapisaniu tego kodu w pliku ElectricGuardDog.pde należy otworzyć


nowo utworzony folder ElectricGuardDog (w którym powinien znajdować
się plik źródłowy ElectricGuardDog.pde). W katalogu ElectricGuardDog
należy umieścić także rozpakowane pliki biblioteki MediaPlayer. Warto
też raz jeszcze sprawdzić, czy rozpakowane pliki biblioteki ServoTimer2
znajdują się w katalogu libraries platformy Arduino.
Należy ponownie uruchomić środowisko Arduino IDE, załadować plik
ElectricGuardDog.pde i kliknąć dostępną na pasku narzędzi ikonę Verify.
Jeśli wszystko zostanie skompilowane bez żadnych błędów, możemy być
pewni, że kod został wpisany prawidłowo, a niezbędne pliki bibliotek znaj-
dują się w odpowiednich katalogach. W przeciwnym razie należy przeanali-
zować komunikaty o błędach pod kątem informacji o brakujących bibliotekach
i uzupełnić ewentualne braki.
Po pomyślnym skompilowaniu szkicu możemy przystąpić do testowania i do-
strajania naszego kodu.

4.5. Testowanie
Czujnik ruchu PIR należy umieścić w miejscu, które umożliwi wygodne te-
stowanie wykrywania ruchu. Po zainstalowaniu czujnika warto pobrać gotowy
szkic i otworzyć okno portu szeregowego środowiska Arduino IDE.
Aby wyzwolić sygnał czujnika ruchu, wystarczy pomachać przed nim ręką.
Nasz elektryczny pies stróżujący powinien zareagować na ten ruch odtworze-
niem pliku dźwiękowego i ruchem serwomotoru. Jeśli uznamy, że obrót

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
90  4.6. Spuszczamy psa

serwomotoru powinien być nieco inny, powinniśmy zmodyfikować wywo-


łania metody theservo.write() (na jej wejściu należy przekazywać wartości
z przedziału od 1000 do 2200). Sugerowany przedział wartości wejściowych
wynika z tego, że biblioteka ServoTimer2 operuje na mikrosekundach, nie
na kątach wyrażonych w stopniach (jak w przypadku oryginalnej biblioteki
Servo). W tej sytuacji wyznaczenie właściwego kąta obrotu wymaga prze-
prowadzenia odpowiednich eksperymentów. Po wybraniu wartości pasu-
jących do parametrów używanego serwomotoru należy przeprowadzić
testy, aby liczba i zakres obrotów tego silnika były możliwie naturalne.
Skoro przetestowaliśmy i dobraliśmy odpowiednie wartości (i zsynchroni-
zowaliśmy ruch serwomotoru z odtwarzanymi plikami dźwiękowymi),
możemy przystąpić do montażu gotowego systemu.

4.6. Spuszczamy psa


Warto dobrze przemyśleć miejsce instalacji czujnika ruchu PIR. Umiesz-
czenie czujnika wewnątrz, za szybą okna uniemożliwi śledzenie ruchu na
zewnątrz budynku, ponieważ czujnik nie może analizować obrazu pod-
czerwonego przez szybę. W idealnych warunkach czujnik ruchu na pod-
czerwień ma przed sobą wolną przestrzeń do monitorowania. Jeśli czujnik
ma być zamontowany nad drzwiami wejściowymi, przewody połączone
z czujnikiem należy doprowadzić do platformy Arduino (połączonej z mo-
dułem dźwiękowym) zamontowanej w skrzynce wewnątrz domu.
Warto też poeksperymentować z poziomem głośności. Niewielki głośnik do-
łączany do pakietu muzyki i dźwięku firmy Adafruit być może sprawdzi się
podczas testów, ale z pewnością nie będzie dość głośny, aby zwrócić uwa-
gę osób w sąsiednim pokoju (nie mówiąc o intruzach na zewnątrz budynku).
Warto użyć gniazda słuchawek modułu dźwiękowego i podłączyć do systemu
jakieś wzmocnione głośniki, na przykład magnetofon lub wieżę stereo. Należy
ustawić głośność na takim poziomie, aby każdy gość słyszał donośne
szczekanie.
Jeden koniec drewnianego kija należy przymocować do koła serwomotoru
za pomocą drutu, drutu w plastikowej otoczce lub gumki. Na drugim końcu
kija należy przytwierdzić stare ubranie, skrawki materiału lub gumową osłonę,
aby zabezpieczyć powierzchnię, przy której ten gumowy kij będzie wyko-
nywał ruchy przypominające rozzłoszczonego psa. Efekt wizualny można
dodatkowo wzmocnić, montując na końcu kija plastikowy pysk psa, który

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 4. • Elektryczny pies stróżujący  91

można kupić na przykład w sklepie z przebraniami dla dzieci. Możemy


puścić wodze fantazji! Musimy jednak uważać, aby elementy na końcu kija
nie były zbyt ciężkie dla momentu obrotowego serwomotoru (aby zbyt duża
waga nie utrudniała wykonywania odpowiednich ruchów).
Część systemu obejmującą serwomotor i drewniany kij z odpowiednim za-
kończeniem należy umieścić bezpośrednio przy zasłonie w oknie, najlepiej
w miejscu dobrze widocznym dla osób zbliżających się do drzwi wejściowych.
W momencie wykrycia ruchu przez czujnik PIR rozlegnie się głośne szczeka-
nie (odtwarzane przez moduł dźwiękowy), a końcówka drewnianego kija
stworzy iluzję psiego pyska poruszającego się za zasłoną. Z perspektywy
osoby zbliżającej się do drzwi całość będzie przypominała rozzłoszczone
zwierzę, które tylko czeka, aby rzucić się na nieproszonego gościa. Dostoso-
wanie wszystkich parametrów tak, aby system działał w pełni prawidłowo,
wymaga trochę czasu, jednak po prawidłowym skonfigurowaniu tego me-
chanizmu połączenie dźwięku i ruchu powinno być bardzo przekonujące!

4.7. Następne kroki


Poniżej opisałem kilka własnych pomysłów na dodatkowe rozwinięcie tego
projektu:
 Próbki dźwięku szczekającego psa można zastąpić próbkami klaksonu
samochodowego, dzwonka alarmowego lub dźwięków samodestrukcji
zaczerpniętych z filmów science fiction. Plastikowy pysk psa przymo-
cowany do ramienia serwomotoru można zastąpić ruchomym wskaźni-
kiem laserowym wycelowanym w drzwi wejściowe. Wyobraźmy sobie,
że nasze drzwi wejściowe są zabezpieczone jak chronione przejście
z jakiegoś thrillera science fiction!
 System można uzupełnić o dalmierz ultradźwiękowy, tak aby reak-
cja w formie dźwięku i ruchu była uzależniona od odległości intruza
od domu. Im bliżej domu znajdzie się nieproszony gość, tym gło-
śniejsze będą odgłosy szczekania i bardziej intensywne ruchy „psa”
za zasłoną. To naturalne, że bliskość intruza wzmaga złość elek-
trycznego psa stróżującego.
 System elektrycznego psa stróżującego można rozbudować i przekształ-
cić w ogromnego stracha na wróble zabezpieczonego przed warun-
kami atmosferycznymi. Wystarczy użyć więcej serwomotorów podłą-
czonych do mocniejszego, zewnętrznego źródła zasilania. Możemy

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
92  4.7. Następne kroki

przygotować model samych siebie w skali 1:1, stosując stary kom-


binezon i rury z PCV połączone z silnikami krokowymi za pomocą
drutów przypominających sznurki marionetki — w ten sposób można
wymuszać ruchy rąk i nóg modelu.
 System elektrycznego psa stróżującego można z powodzeniem wyko-
rzystać w Halloween. Wystarczy przykryć system napędzany serwomoto-
rem prześcieradłem lub zainstalować trupią czaszkę z ruchomą
szczęką, która będzie witała gości straszliwym głosem i nienaturalnymi
ruchami.
 System elektrycznego psa stróżującego można połączyć z pozostałymi
projektami opisanymi w tej książce, aby w razie wykrycia ruchu włą-
czyć światła, wysłać wiadomość poczty elektronicznej bądź otworzyć
lub zamknąć zamek w drzwiach wejściowych.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5.
Ćwierkający
karmnik dla ptaków

M
am dwójkę dzieci, które wprost uwielbiają ptaki. Już jako małe dzie-
ci miały swoje pierwsze papużki. Lubiły też obserwować dzikie
ptaki konstruujące gniazda i posilające się w karmniku zamontowa-
nym przy oknie sypialni. Dokarmianie ptaków wiąże się jednak z pewnym
problemem — dzieci ciągle zapominają o uzupełnianiu nasion dla ptaków
w karmnikach. Zdarzało się, że z rozmaitych powodów w karmniku brako-
wało nasion przez całe dnie, a nawet tygodnie. Czyż nie byłoby prościej,
gdyby sam karmnik informował nas o konieczności uzupełnienia karmy?
Historia pustego karmnika była inspiracją dla tego projektu. Czy można sobie
wyobrazić lepszą formę powiadamiania o konieczności dosypania nasion niż
„ćwierkanie” na Twitterze? Zainteresowani znajomi i krewni mogą śledzić
konto karmnika, aby wiedzieć, kiedy karmnik jest odwiedzany przez ptaki,
kiedy wymaga uzupełnienia karmy i czy nasiona zostały dosypane. (Patrz
rysunek 5.1 zatytułowany „Wysyłanie powiadomień przez karmnik dla
ptaków za pośrednictwem Twittera”).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
94  5.1. Czego potrzebujemy

Rysunek 5.1. Wysyłanie powiadomień przez karmnik dla ptaków


za pośrednictwem Twittera (w czasie, gdy karmnik jest
odwiedzany przez ptaki, oraz w sytuacji, gdy wymaga
uzupełnienia nasion)

Skoro planujemy śledzić na Twitterze komunikaty o konieczności uzupeł-


nienia karmnika, warto rozbudować ten mechanizm o własny czujnik in-
stalowany na grzędzie, który będzie rejestrował wizyty ptaków w karmniku
i analizował czas ich przebywania na grzędzie. Przed publikacją wpisów
na Twitterze będziemy rejestrować te zdarzenia w bazie danych, aby umożli-
wić wizualne prezentowanie wzorców karmienia ptaków w czasie.
Czy w kwietniu ptaki są bardziej wygłodniałe niż na przykład w lipcu? Czy
ptaki częściej zaglądają do karmnika rano, czy popołudniami? Ile wynosi
średni czas przebywania ptaków na grzędzie w karmniku? Ile czasu mija
pomiędzy kolejnymi wizytami ptaków? Jak często musimy uzupełniać na-
siona w karmniku? Ćwierkający karmnik dla ptaków umożliwia nam pro-
wadzenie ciekawych badań w poszukiwaniu odpowiedzi na te i inne wzorce
zachowań ptaków. Czas wzbić się w powietrze!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  95

5.1. Czego potrzebujemy


Ponieważ ćwierkający karmnik będzie naszym pierwszym projektem reali-
zowanym na zewnątrz, koszty niezbędnego sprzętu z kilku powodów będą
nieco wyższe. Po pierwsze, jeśli nie chcemy wiercić dziur przez całą grubość
ścian zewnętrznych domu ani prowadzić przewodów sieciowych przez otwarte
drzwi czy okna, musimy znaleźć sposób wysyłania zdarzeń notowanych
przez czujniki przy użyciu technik bezprzewodowych. Na szczęście istnieją
niskonapięciowe i stosunkowo tanie urządzenia w formie nadajników radio-
wych XBee. Początkowa konfiguracja tych urządzeń wymaga dodatkowych
nakładów i większego wysiłku, jednak wspomniane urządzenia są dość nie-
zawodne, całkiem łatwo nawiązują połączenia, a raz zainstalowane nie wy-
magają naszej uwagi.
Po drugie, mimo że moglibyśmy zastosować standardową platformę Ar-
duino Uno (tak jak na schematach połączeń prezentowanych w tym roz-
dziale), wymiary tej płytki mogą się okazać zbyt duże dla typowego karm-
nika dla ptaków. W tej sytuacji zachęcam do wydania minimalnie większej
kwoty na zakup płytki Arduino Nano. Instalacja platformy Nano z pew-
nością będzie prostsza, zważywszy na ograniczoną przestrzeń w karmniku.
Niewątpliwą zaletą płytki Nano jest niemal identyczna konfiguracja wtyków
i układ elementów sprzętowych jak w przypadku większego brata. Płytka
Nano oferuje wszystkie możliwości tradycyjnej platformy Arduino, tyle że
zajmuje dużo mniej miejsca.
Po trzecie, mimo że zasilanie tych części elektronicznych za pośrednic-
twem długiego przewodu podłączonego do zewnętrznego gniazdka (zain-
stalowanego z myślą o dekoracjach świątecznych) jest możliwe, tak zapro-
jektowany system nie będzie wystarczająco autonomiczny. Co więcej, sys-
tem karmnika dla ptaków to wprost doskonała okazja do zastosowania
ekologicznego źródła energii.
I wreszcie w związku z koniecznością ochrony elektroniki musimy zadbać
o dobre zabezpieczenie systemu przed niesprzyjającymi warunkami atmosfe-
rycznymi. Oto kompletna lista zakupów (komponenty używane w tym pro-
jekcie pokazano też na rysunku 5.2 zatytułowanym „Części systemu ćwierka-
jącego karmnika dla ptaków”):
1. Platforma Arduino Uno lub Arduino Nano1.

1
http://www.makershed.com/ProductDetails.asp?ProductCode=MKGR1

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
96  5.1. Czego potrzebujemy

Rysunek 5.2. Części systemu ćwierkającego karmnika dla ptaków

2. Dwa moduły XBee z zestawami adapterów oraz przewód FTDI2.


3. Fotokomórka.
4. Kawałek folii aluminiowej.
5. Przewód.
6. Niewielki panel słoneczny z wbudowanym akumulatorem i prze-
wodem USB (na przykład podobny do tego oferowanego w sklepie
Solio)3.
7. Jeden rezystor 10 kΩ i jeden rezystor 10 MΩ — warto sprawdzić
kolorowe paski na stosowanych rezystorach: rezystor 10 kΩ powinien
być oznaczony paskami brązowym, czarnym, pomarańczowym i złotym,
natomiast rezystor 10 MΩ powinien być oznaczony paskami brązo-
wym, czarnym, niebieskim i złotym. Potrzebne rezystory pokazano
na rysunku 5.3 zatytułowanym „Rezystory używane w projekcie
ćwierkającego karmnika dla ptaków”. Na zdjęciu widać również foto-
komórkę (nazywaną także fotorezystorem CdS).
8. Karmnik dla ptaków z otworem na nasiona, w którym zmieści się
platforma Nano i moduł XBee (zabezpieczone przed czynnikami
pogodowymi).

2
http://www.adafruit.com
3
http://www.solio.com/chargers/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  97

Rysunek 5.3. Rezystory używane w projekcie ćwierkającego karmnika


dla ptaków

9. Komputer (nie ma go na zdjęciu), najlepiej z systemem Linux lub


Mac OS oraz zainstalowanym kompilatorem języka Python 2.6
lub nowszym (na potrzeby skryptu przetwarzającego komunikaty
wysyłane przez karmnik dla ptaków).
W razie decyzji o użyciu płytki Arduino Nano zamiast tradycyjnej płytki
Arduino Uno trzeba będzie dodatkowo zakupić standardowy przewód
USB A-mini B (nie ma go na zdjęciu), aby połączyć płytkę Arduino
Nano z komputerem. Co więcej, ponieważ na platformie Arduino Nano
zastosowano wtyki męskie zamiast wtyków żeńskich (stosowanych w przy-
padku płytki Arduino Uno), zamiast standardowych przewodów będzie-
my potrzebowali odpowiednich końcówek żeńskich (których także nie
pokazano na zdjęciu). Odpowiednie końcówki ułatwią łączenie przewo-
dów z wtykami na płytce Nano bez konieczności ich trwałego lutowania.
Projekt jest bardziej złożony niż system powiadamiania o poziomie wody,
a najtrudniejszym krokiem procesu budowy tego rozwiązania będzie za-
pewnienie niezawodnej pracy modułów XBee. Mimo to projekt jest wart
niezbędnych nakładów — w jego wyniku będziemy dysponowali nie tylko
supernowoczesnym karmnikiem na miarę XXI wieku, ale też skonfiguro-
wanym systemem obejmującym moduły komunikacji radiowej XBee, który
będzie nam potrzebny w wielu pozostałych projektach. Gotowy zakasać
rękawy? Do dzieła!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
98  5.3. Czujnik grzędy

5.2. Budowa rozwiązania


Połączenie wszystkich elementów tak, aby pasowały do wnętrza karmnika,
może wymagać pewnej pomysłowości, szczególnie jeśli zbiornik na ziarno
nie oferuje dostatecznie dużo przestrzeni. Zanim przystąpimy do upycha-
nia elektroniki w karmniku, musimy upewnić się, że wszystkie komponenty
działają zgodnie z naszymi oczekiwaniami.
1. Zaczniemy od najprostszego kroku, czyli połączenia z płytką Ar-
duino czujnika pojemnościowego z folii aluminiowej oraz napisania
funkcji, która w momencie zmiany stanu tego czujnika będzie wy-
syłała komunikat do okna monitorowania portu szeregowego (a do-
celowo do modułu XBee podłączonego do tego portu).
2. W dalszej kolejności musimy podłączyć do płytki Arduino fotoko-
mórkę i napisać kod reagujący na zmiany stanu tego czujnika.
3. Zaraz potem przystąpimy do łączenia pary modułów radiowych XBee,
tak aby informacje o wspomnianych zdarzeniach były przekazywane
pomiędzy nadajnikiem XBee połączonym z płytką Arduino a odbior-
nikiem XBee połączonym z komputerem za pośrednictwem prze-
wodu FTDI USB.
4. I wreszcie musimy napisać skrypt języka Python, który pobierze dane
z bazy danych SQLite, sformatuje je i wyśle w formie gotowego wpisu
do publikacji w serwisie Twitter.
Po dopracowaniu i połączeniu wszystkich komponentów będziemy dyspo-
nowali systemem złożonym z płytki Arduino (najlepiej w wersji Nano),
modułu XBee, czujnika grzędy i fotokomórki — całość będzie zabezpie-
czona przed czynnikami atmosferycznymi i zainstalowana w karmniku dla
ptaków. Po sprawdzeniu, czy wszystko działa prawidłowo, należy wyjść
na dwór i przetestować ten system w warunkach polowych.

5.3. Czujnik grzędy


Karmniki dla ptaków maja różne kształty i wymiary. Zdecydowałem się za-
stosować wyjątkowo proste rozwiązanie w celu wykrywania zdarzeń lądowa-
nia ptaków na grzędzie karmnika. Mimo że skonstruowanie mechanizmu
wykrywającego nacisk na grzędzie z pewnością byłoby możliwe, czas potrzeb-
ny na opracowanie tego rozwiązania i jego koszty byłyby stosunkowo duże,
a przecież naszym jedynym celem jest wykrycie, czy coś nie usiadło na grzędzie.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  99

Alternatywnym rozwiązaniem jest monitorowanie zmian pojemności elek-


trycznej.
Wystarczy owinąć grzędę karmnika folią aluminiową oraz połączyć tę folię
z cyfrowymi wtykami na płytce Arduino przy użyciu rezystora. Na podstawie
wartości bazowych i zmian wykrywanych przez ten czujnik w momencie lądo-
wania ptaka możemy wyznaczyć wartość progową, której przekroczenie po-
winno powodować wygenerowanie i wysłanie komunikatu o lądującym ptaku.

Budowa czujnika
Budowa i testowanie czujnika grzędy to najprostszy element tego projektu.
Wystarczy użyć kawałka folii aluminiowej wielkości połowy opakowania
od listka gumy do żucia i owinąć grzędę. Należy następnie połączyć jeden
koniec rezystora 10 MΩ z wtykiem cyfrowym nr 7 na płytce Arduino oraz
drugi koniec z wtykiem nr 10. Przewód połączony z folią aluminiową należy
połączyć z końcówką rezystora podłączoną do wtyku cyfrowego nr 7. Od-
powiedni schemat połączeń pokazano na rysunku 5.4 zatytułowanym „Spo-
sób podłączenia czujnika pojemnościowego”.

Rysunek 5.4. Sposób podłączenia czujnika pojemnościowego

Programowanie czujnika
Należy teraz połączyć platformę Arduino z komputerem, po czym uruchomić
środowisko Arduino IDE w celu napisania kodu obsługującego czujnik.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
100  5.3. Czujnik grzędy

Podobnie jak w przypadku projektu systemu powiadamiania o poziomie


wody musimy napisać kod realizujący następujące zadania:
1. Wyświetli wartości odczytane przez czujnik pojemnościowy w oknie
monitora portu szeregowego środowiska Arduino IDE.
2. Zidentyfikuje wartość bazową tego czujnika.
3. Dostosuje natężenie prądu w momencie dotykania czujnika palcem.
4. Zarejestruje nową wartość używaną w roli wartości progowej gene-
rującej powiadomienie.
Aby ułatwić sobie wykrywanie zmian natężenia prądu elektrycznego w mo-
mencie dotknięcia folii palcem lub wylądowania ptaka, skorzystamy z rozwią-
zania opracowanego przez jednego z miłośników platformy Arduino —
Paula Badgera. Paul napisał bibliotekę Arduino, dzięki której mierzenie
zmian wartości przekazywanych przez czujniki pojemnościowe (podob-
nych do folii używanej w tym projekcie) jest dziecinnie proste. Biblioteka
nazwana Capacitive Sensing4 umożliwia programistom platformy Arduino
przekształcenie dwóch (lub większej liczby) wtyków na płytce Arduino
w czujnik pojemnościowy, który może służyć do wykrywania pojemności
elektrycznej ludzkiego ciała. Ciało człowieka cechuje się znacznie więk-
szą pojemnością niż ciało ptaka, stąd dotknięcie czujnika powoduje dużo
większą zmianę wartości. Ponieważ jednak także pojemność elektryczną
ptaka można zmierzyć, wystarczy odpowiednio dostroić wartość progową
stosowaną przez nasz program.
Należy pobrać tę bibliotekę, rozpakować jej zawartość i skopiować pliki
biblioteki do folderu libraries platformy Arduino. Więcej informacji na ten
temat można znaleźć w dodatku A zatytułowanym „Instalacja bibliotek plat-
formy Arduino”.
W następnym kroku musimy utworzyć nowy projekt platformy Arduino
i użyć wyrażenia #include CapSense.h;.
Z powodu dużo mniejszej wielkości samego ciała i powierzchni styku ciała
z folią aluminiową wartości dla ptaka będą zasadniczo różniły się od wartości
dla człowieka. Jeśli to możliwe, warto zmierzyć te różnice przy pomocy
prawdziwego ptaka. Z radością odkryłem, że papużki moich dzieci są na tyle
łakome, że ochoczo uczestniczą w testach, pod warunkiem że grzęda z czujni-
kiem pozwoli im się dostać do ziaren w karmniku. Moje testowe pomiary

4
http://www.arduino.cc/playground/Main/CapSense

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  101

wykazały, że właściwa wartość bazowa powinna mieścić się w przedziale


od 900 do 1400 oraz że pojemność elektryczna ciała ptaka zwiększa tę war-
tość do ponad 1500. Na podstawie tych wartości możemy opracować iden-
tyczny kod warunkowy jak w przypadku systemu powiadamiania o poziomie
wody, tak aby program zmieniał stan w odpowiedzi na powiadomienia o lądo-
waniu i odlatywaniu ptaków.
Zacznijmy od napisania kodu, który załaduje bibliotekę CapSense i bę-
dzie wyświetlał odczytywane wartości pojemności w oknie monitora portu
szeregowego.
Plik TweetingBirdFeeder/BirdPerchTest.pde

#include <CapSense.h>

#define ON_PERCH 1500


#define CAP_SENSE 30
#define ONBOARD_LED 13

CapSense foil_sensor = CapSense(10,7); // czujnik pojemnościowy


// rezystor mostkujący wtyki cyfrowe nr 10 i 7
// przewód połączony z rezystorem od strony
// wtyku nr 7
int perch_value = 0;
byte perch_state = 0;

void setup()
{
// na potrzeby komunikatów diagnostycznych w oknie portu szeregowego
Serial.begin(9600);

// ustawia wtyk dla wbudowanej diody LED


pinMode(ONBOARD_LED, OUTPUT);
}

void SendPerchAlert(int perch_value, int perch_state)


{
digitalWrite(ONBOARD_LED, perch_state ? HIGH : LOW);
if (perch_state)
Serial.print("Zdarzenie lądowania na grzędzie, perch_value=");
else
Serial.print("Zdarzenie opuszczenia grzędy, perch_value=");
Serial.println(perch_value);
}

void loop() {
// czeka sekundę w każdej iteracji pętli
delay(1000);

// pobiera wartość czujnika pojemnościowego


perch_value = foil_sensor.capSense(CAP_SENSE);

switch (perch_state)

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
102  5.4. Czujnik ziarna

{
case 0: // żaden ptak nie siedzi obecnie na grzędzie
if (perch_value >= ON_PERCH)
{
perch_state = 1;
SendPerchAlert(perch_value, perch_state);
}
break;
case 1: // jakiś ptak siedzi teraz na grzędzie
if (perch_value < ON_PERCH)
{
perch_state = 0;
SendPerchAlert(perch_value, perch_state);
}
break;
}
}

Warto zwrócić uwagę na wartość stałej ON_PERCH (równą 1500), którą porów-
nujemy z zarejestrowaną wartością zmiennej perch_value. Z uwagi na róż-
nice dotyczące przewodnictwa elektrycznego zastosowanej folii i samej po-
wierzchni czujnika każdy powinien dostosować wartość progową reprezento-
waną przez stałą ON_PERCH (tak jak dostosowywaliśmy odpowiednie progi
w projekcie systemu powiadamiania o poziomie wody). Należy też zwrócić
uwagę na wartość 30 przypisaną stałej CAP_SENSE. Ta wartość określa licz-
bę pobrań próbnych wartości w jednym cyklu mierzenia pojemności.
Skoro dysponujemy już działającym czujnikiem grzędy dla ptaków, czas opra-
cować mechanizm wykrywający niski poziom ziarna. Jak to zrobić? Warto
zastosować fotokomórkę.

5.4. Czujnik ziarna


Fotokomórka mierzy intensywność światła — większa intensywność prze-
kłada się na wyższe natężenie prądu; słabsze światło powoduje spadek
tego natężenia. Szczegółowe wyjaśnienie działania fotokomórek i prze-
wodnik na temat ich stosowania można znaleźć na stronie internetowej
Ladyady5. Umieszczenie fotokomórki poniżej normalnego poziomu ziaren
wsypanych do karmnika umożliwi nam wykrywanie zdarzenia polegające-
go na spadku poziomu karmy poniżej czujnika — do fotokomórki będzie
wówczas docierało więcej światła, a nasz system będzie mógł wygenerować
komunikat o konieczności uzupełnienia ziaren.

5
http://www.ladyada.net/learn/sensors/cds.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  103

Przed wywierceniem dziur w karmniku i zainstalowaniem fotokomórki


musimy jeszcze napisać odpowiedni kod i przetestować go w podobny sposób
jak w przypadku własnoręcznie skonstruowanego czujnika pojemnościowego.
Jedną końcówkę fotokomórki należy połączyć z wtykiem 5-woltowym na
płytce Arduino; drugą końcówkę należy połączyć z wtykiem analogowym
nr 0. Wtyk analogowy nr 0 na płytce Arduino należy następnie zmostko-
wać z wtykiem uziemienia za pomocą rezystora 10 kΩ (patrz rysunek 5.5
zatytułowany „Schemat połączenia fotokomórki”). Czy opisany schemat
połączeń nie wygląda znajomo? Tak — identyczną konfigurację stosowali-
śmy już dla innych czujników łączonych z platformą Arduino. Jest to dość
typowy wzorzec łączenia wielu typów czujników z płytką Arduino.

Rysunek 5.5. Schemat połączenia fotokomórki

Po podłączeniu fotokomórki należy połączyć płytkę Arduino z kompute-


rem (za pomocą przewodu szeregowego USB) i uruchomić środowisko
Arduino IDE. Możemy teraz zastosować tę samą technikę co w przypadku
czujnika pojemnościowego, aby prześledzić wartości dla wtyku analogo-
wego nr 0 (wyświetlane w oknie monitora portu szeregowego środowiska
Arduino IDE) i na tej podstawie wyznaczyć wartości bazowe — określić
wartość dla odsłoniętej fotokomórki. Warto teraz zasłonić czujnik palcem,
aby zablokować dopływ światła. Należy też zanotować, jak zmieniła się
wartość odczytana z fotokomórki.
Tak jak w przypadku testów czujnika pojemnościowego, musimy opraco-
wać pewne procedury i wyrażenia warunkowe, które sprawdzą progi natę-
żenia światła. W praktyce możemy nawet skopiować i wkleić kod testujący

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
104  5.4. Czujnik ziarna

czujnik pojemnościowy i ograniczyć się do dostosowania nazw zmiennych


oraz przypisania odpowiednich wtyków.
Plik TweetingBirdFeeder/SeedPhotocellTest.pde

#define SEED 500


#define ONBOARD_LED 13
#define PHOTOCELL_SENSOR 0
int seed_value = 0;
byte seed_state = 0;
void setup()
{
// na potrzeby komunikatów diagnostycznych w oknie portu szeregowego
Serial.begin(9600);

// ustawia wtyk dla wbudowanej diody LED


pinMode(ONBOARD_LED, OUTPUT);
}

void SendSeedAlert(int seed_value, int seed_state)


{
digitalWrite(ONBOARD_LED, seed_state ? HIGH : LOW);
if (seed_state)
Serial.print("Uzupełnij ziarno, seed_value=");
else
Serial.print("Karma uzupełniona, seed_value=");
Serial.println(seed_value);
}

void loop() {
// czeka sekundę w każdej iteracji pętli
delay(1000);

// sprawdza wartość fotokomórki śledzącej poziom ziarna


seed_value = analogRead(PHOTOCELL_SENSOR);

switch (seed_state)
{
case 0: // pojemnik na ziarno został napełniony
if (seed_value >= SEED)
{
seed_state = 1;
SendSeedAlert(seed_value, seed_state);
}
break;
case 1: // pojemnik na ziarno jest pusty
if (seed_value < SEED)
{
seed_state = 0;
SendSeedAlert(seed_value, seed_state);
}
break;
}
}

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  105

Zmierzenie i ustalenie odpowiedniej wartości progowej dla fotokomórki


(reprezentowanej przez stałą SEED) jest dużo prostsze niż w przypadku czujni-
ka pojemnościowego, a uzyskana wartość jest bardziej wiarygodna. Mimo
że fotokomórkę można zasłonić palcem, aby zmierzyć wartość w warunkach
braku dopływu światła, lepszym rozwiązaniem będzie zasypanie czujnika
prawdziwym ziarnem. Jeśli z jakiegoś powodu nie chcemy wiercić dziur
w karmniku dla ptaków, aby zainstalować fotokomórkę, możemy umieścić
czujnik na dnie papierowego kubka.
Tak jak podczas kalibrowania wartości progowych czujnika w systemie po-
wiadamiania o poziomie wody, należy dodać następujące wiersze za wierszem
seed_value = analogRead(PHOTOCELL_SENSOR); w głównej pętli programu:
Serial.print("seed_value=");
Serial.println(seed_value);

Należy zapisać wartość początkową zmiennej seed_value, po czym wypełnić


pojemnik ziarnem i zmierzyć nową wartość. Na podstawie tych wartości
należy określić wartość początkową i wartość progową dla fotokomórki.
Jeśli zasłonięcie fotokomórki nie powoduje żadnej zmiany wartości, warto
raz jeszcze sprawdzić wszystkie połączenia. W przypadku mojej fotokomórki
wartość bazowa mieściła się w przedziale od 450 do 550. Zasłonięcie
czujnika palcem powodowało natychmiastowy spadek tej wartości poniżej
100. Każdy powinien zastosować wartości progowe dobrane na podstawie
własnych testów. Musimy też pamiętać o konieczności ponownej kalibracji
czujnika już po zamontowaniu w karmniku dla ptaków.
Skoro dysponujemy już działającymi mechanizmami monitorowania czujnika
grzędy i fotokomórki, musimy znaleźć sposób sygnalizowania przekroczenia
wartości progowych przyjętych dla tych czujników. Prowadzenie przewo-
du sieciowego od domowego koncentratora do gałęzi drzewa na zewnątrz
budynku byłoby niepraktyczne. Sporym wyzwaniem byłaby także instala-
cja platformy Arduino z dołączonym modułem sieciowym w bardzo ogra-
niczonej przestrzeni karmnika dla ptaków. W tej sytuacji warto zastosować
wygodny mechanizm komunikacji bezprzewodowej (wymagający stosun-
kowo niewiele mocy elektrycznej), który w zupełności wystarczy do prze-
syłania powiadomień o przekroczeniu wartości progowych przez wskaza-
nia czujników. Po nawiązaniu komunikacji bezprzewodowej możemy użyć
większej mocy obliczeniowej i większych zasobów pamięciowych do przetwa-
rzania i analizy gromadzonych danych.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
106  5.5. Komunikacja bezprzewodowa

5.5. Komunikacja bezprzewodowa


Mimo że istnieją moduły platformy Arduino obsługujące wszechobecny
standard Wi-Fi (802.11b/g), na przykład WiFly Shield firmy Sparkfun,
w przypadku tej platformy do komunikacji bezprzewodowej częściej sto-
suje się moduły XBee. Początkowe nakłady związane z zakupem zestawu
urządzeń XBee mogą być dość wysokie. Duże koszty wynikają z koniecz-
ności zakupu (oprócz pary modułów XBee) przewodu FTDI USB po-
trzebnego do połączenia jednego z tych modułów z komputerem, tak aby
pełnił funkcję bezprzewodowego portu szeregowego.
Drugi moduł XBee najczęściej jest łączony z platformą Arduino. Istnieją
też dodatkowe zestawy upraszczające łączenie tych elementów — umożli-
wiające instalowanie modułów XBee przy użyciu specjalnych wtyczek i wy-
świetlanie stanu transmisji danych za pomocą wbudowanych diod LED.
Takie wizualne wskaźniki mogą być dość przydatne podczas diagnozowa-
nia połączenia pary modułów XBee i usuwania ewentualnych błędów.
Mimo wszystkich trudności możliwości oferowane przez moduły XBee
(niski pobór prądu i stosunkowo duży zasięg — maksymalnie 50 metrów)
czynią z tych urządzeń wprost doskonałą technologię komunikacji bezprze-
wodowej na potrzeby tego projektu.
Z myślą o uproszczeniu łączenia modułów XBee firma Adafruit zaprojekto-
wała zestaw adapterów, który jednak wymaga przylutowania kilku niewiel-
kich komponentów do płytki Arduino. Adaptery należy stosować zgodnie
z instrukcjami dostępnymi na stronie internetowej Ladyady6.
Po połączeniu modułów XBee konfiguracja i nawiązanie komunikacji po-
między parą tych modułów nie są trudne. Warto jednak pamiętać, że jedno
z najbardziej przydatnych narzędzi ułatwiających konfigurację tych mo-
dułów działa tylko w systemie Windows.
Zgodnie z instrukcjami opisującymi schemat łączenia modułów XBee w topo-
logii punkt – punkt dostępnymi na stronie Ladyady7 należy połączyć wtyki
zasilania, uziemienia (Gnd), odbioru (RX) i transmisji (TX) jednego
modułu XBee z zamontowanym adapterem odpowiednio do wtyków 5V,
Gnd, cyfrowego nr 2 i cyfrowego nr 3 na płytce Arduino. Płytkę Arduino
należy następnie połączyć z komputerem, umieścić na platformie program

6
http://www.ladyada.net/make/xbee/
7
http://ladyada.net/make/xbee/point2point.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  107

testowy, otworzyć okno monitora portu szeregowego środowiska Arduino


IDE i upewnić się, że jest ustawiona odpowiednia szybkość transmisji
(9600). Należy następnie (jeszcze przed odłączeniem platformy Arduino)
połączyć komputer z drugim modułem XBee za pośrednictwem przewodu
FTDI USB. W następnym kroku musimy otworzyć sesję terminala portu
szeregowego: program Hyperterminal w systemie Windows, polecenie screen
w systemie Mac lub rozmaite programy do obsługi komunikacji szeregowej
dostępne dla systemu Linux, na przykład Minicom8.
Po nawiązaniu połączenia szeregowego wystarczy wpisać kilka znaków w
oknie danych wejściowych użytej aplikacji. Jeśli oba moduły XBee zostały
prawidłowo skonfigurowane, wpisane znaki powinny zostać wyświetlone
w oknie monitora portu szeregowego środowiska Arduino IDE.

Korzystanie z narzędzia screen


Aplikacja screen jest wygodnym narzędziem do monitorowania por-
tu szeregowego dostępnym dla platform na bazie systemu Unix,
czyli systemów Mac OS X i Linux. Aby użyć tego programu w systemie
OS X, należy określić port szeregowy, do którego podłączono przewód
FTDI USB — można to zrobić za pomocą środowiska Arduino IDE.
Z menu Tools tego środowiska należy wybrać opcję Serial Port, aby zi-
dentyfikować przypisany port szeregowy.
W moim przypadku połączenie adaptera FTDI USB z XBee jest ozna-
czone jako urządzenie /dev/tty.usbserial-A6003SHc, jednak na innym
komputerze to samo połączenie może być reprezentowane w inny
sposób (w zależności od pozostałych urządzeń podłączonych do
komputera). Po otwarciu aplikacji terminala należy wpisać polecenie
screen /dev/tty.YOURDEVICE 9600. W wyniku tego polecenia zostanie
otwarty port szeregowy i uzyskamy możliwość wpisywania i otrzymy-
wania znaków z szybkością transmisji 9600. Aby zamknąć narzędzie,
należy nacisnąć kolejno kombinacje klawiszy Ctrl+A oraz Ctrl+\.

Jeśli do połączenia modułów XBee z płytką Arduino i przewodem FTDI


użyto odpowiednich adapterów, w czasie bezprzewodowej transmisji znaków
pomiędzy modułami XBee powinny migać diody LED (zielona podczas
wysyłania danych i czerwona podczas odbioru danych).

8
http://alioth.debian.org/projects/minicom/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
108  5.5. Komunikacja bezprzewodowa

Jeśli w oknie odbieranych danych nie widać żadnych znaków, należy jeszcze
raz sprawdzić przewody łączące moduł XBee z odpowiednimi wtykami na
płytce Arduino. Warto też zamienić te moduły miejscami, aby sprawdzić, czy
oba urządzenia są rozpoznawane po połączeniu z komputerem za pomocą
przewodu FTDI USB. W oknie terminala aplikacji portu szeregowego
należy wpisać polecenie AT i sprawdzić, czy w odpowiedzi otrzymamy po-
twierdzenie OK.
Jeśli moduły XBee wciąż nie mogą nawiązać połączenia, warto poprosić
o pomoc sprzedawcę, u którego zakupiono ten sprzęt.
Po udanej próbie nawiązania komunikacji przez parę modułów XBee mo-
żemy ponownie podłączyć fotokomórkę i czujnik pojemnościowy do płytki
Arduino i połączyć kod obsługujący ten moduł z kodem analizującym warunki
progowe obu czujników. Kompletny schemat połączeń tego systemu pokaza-
no na rysunku 5.6 zatytułowanym „Ćwierkający karmnik dla ptaków z czuj-
nikami i modułem XBee podłączonymi do platformy Arduino”.

Rysunek 5.6. Ćwierkający karmnik dla ptaków z czujnikami i modułem


XBee podłączonymi do platformy Arduino

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  109

Warto rozważyć użycie uniwersalnej płytki montażowej lub zlutowanie


czujników, użytych przewodów i odpowiednich wtyków na płytce Arduino.
Czytelnicy, którzy do testów wolą używać płytki uniwersalnej, muszą pamię-
tać, że taka płytka najprawdopodobniej nie zmieści się w karmniku, zatem
przewody łączące elementy systemu trzeba będzie przylutować dopiero po
instalacji w miejscu docelowym. W zależności od położenia i orientacji
płytki Arduino Uno lub Nano wewnątrz karmnika być może będziemy
musieli użyć dla adaptera XBee prostych wtyków zamiast standardowych
wtyków wygiętych w prawo. Naszym celem jest umieszczenie wszystkich
potrzebnych elementów wewnątrz karmnika w sposób gwarantujący bez-
pieczeństwo i jednocześnie możliwość konserwacji systemu. Warto przy tym
pamiętać, że w przeciwieństwie do płytki Arduino Uno płytka Arduino Na-
no stosuje męskie wtyki. Oznacza to, że aby lepiej połączyć męskie wtyki na
płytce Nano, należy zastosować przewody z żeńskimi końcówkami.

Kończenie szkicu
Musimy odczytywać wartości obu czujników — czujnika pojemnościowe-
go z folii aluminiowej oraz fotokomórki. Początkowo odczytywane warto-
ści będą trafiały do okna monitora portu szeregowego środowiska Arduino
IDE, a docelowo (po wprowadzeniu drobnej zmiany w kodzie) będą wy-
syłane przez moduł XBee. Na tym etapie naszym celem jest połączenie
kodu sprawdzającego wyznaczone wcześniej wartości progowe dla czujni-
ka pojemnościowego i fotokomórki z kodem wysyłającym do modułu
XBee ostrzeżenia o przekroczeniu tych wartości. Po dodaniu tej logiki do
napisanego wcześniej kodu testującego stan grzędy i pojemnika na nasiona
możemy zakończyć pracę nad szkicem dla tego projektu.
Plik TweetingBirdFeeder/TweetingBirdFeeder.pde

#include <CapSense.h>;
#include <NewSoftSerial.h>

#define ON_PERCH 1500


#define SEED 500
#define CAP_SENSE 30
#define ONBOARD_LED 13
#define PHOTOCELL_SENSOR 0

// ustawia wtyki cyfrowe na potrzeby szeregowego wysyłania/odbioru danych


// przez moduł XBee
NewSoftSerial XBeeSerial = NewSoftSerial(2, 3);
CapSense foil_sensor = CapSense(10,7); // czujnik pojemnościowy
// rezystor mostkujący wtyki cyfrowe
// nr 10 i 7

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
110  5.5. Komunikacja bezprzewodowa

// przewód połączony z rezystorem


// od strony wtyku nr 7
int perch_value = 0;
byte perch_state = 0;
int seed_value = 0;
byte seed_state = 0;

void setup()
{
// na potrzeby komunikatów diagnostycznych w oknie portu szeregowego
Serial.begin(9600);

// na potrzeby transmisji danych za pośrednictwem modułu XBee


XBeeSerial.begin(9600);

// ustawia wtyk dla wbudowanej diody LED


pinMode(ONBOARD_LED, OUTPUT);
}

void SendPerchAlert(int perch_value, int perch_state)


{
digitalWrite(ONBOARD_LED, perch_state ? HIGH : LOW);
if (perch_state)
{
XBeeSerial.println("przylot");
Serial.print("Zdarzenie lądowania na grzędzie, perch_value=");
}
else
{
XBeeSerial.println("odlot");
Serial.print("Zdarzenie opuszczenia grzędy, perch_value=");
}
Serial.println(perch_value);
}

void SendSeedAlert(int seed_value, int seed_state)


{
digitalWrite(ONBOARD_LED, seed_state ? HIGH : LOW);
if (seed_state)
{
XBeeSerial.println("dosyp");
Serial.print("Uzupełnij ziarno, seed_value=");
}
else
{
XBeeSerial.println("ziarnoWNormie");
Serial.print("Karma uzupełniona, seed_value=");
}
Serial.println(seed_value);
}

void loop() {
// czeka sekundę w każdej iteracji pętli
delay(1000);

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  111

// sprawdza wartość czujnika pojemnościowego na grzędzie


perch_value = foil_sensor.capSense(CAP_SENSE);

// sprawdza wartość fotokomórki śledzącej poziom ziarna


seed_value = analogRead(PHOTOCELL_SENSOR);

switch (perch_state)
{
case 0: // żaden ptak nie siedzi na grzędzie
if (perch_value >= ON_PERCH)
{
perch_state = 1;
SendPerchAlert(perch_value, perch_state);
}
break;
case 1: // jakiś ptak siedzi teraz na grzędzie
if (perch_value < ON_PERCH)
{
perch_state = 0;
SendPerchAlert(perch_value, perch_state);
}
break;
}

switch (seed_state)
{
case 0: // pojemnik na ziarno został napełniony
if (seed_value >= SEED)
{
seed_state = 1;
SendSeedAlert(seed_value, seed_state);
}
break;
case 1: // pojemnik na ziarno jest pusty
if (seed_value < SEED)
{
seed_state = 0;
SendSeedAlert(seed_value, seed_state);
}
break;
}
}

Warto zwrócić uwagę na odwołania do biblioteki obsługującej czujnik pojem-


nościowy i nowej biblioteki obsługującej komunikację za pośrednictwem
portu szeregowego na początku tego szkicu. Zmienne, które będą używały
odwołań do tych bibliotek, zainicjalizowano w tym samym miejscu, w którym
ustawiono wartości zmiennych progowych. W dalszej części kodu konfigu-
rujemy połączenia z oknem monitora portu szeregowego i modułem XBee,
a także z wbudowaną diodą LED na płytce Arduino (wtyk nr 13). Po za-
kończeniu inicjalizacji program uruchamia pętlę i czeka na przekroczenie
wartości progowych dla czujników grzędy i (lub) ziarna. W razie wykrycia

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
112  5.5. Komunikacja bezprzewodowa

zmiany warunków szkic wyśle odpowiednie komunikaty zarówno do okna


monitorowania portu szeregowego w środowisku Arduino IDE, jak i do
modułu komunikacji radiowej XBee.
Jeśli zarówno czujnik pojemnościowy, jak i fotokomórka prawidłowo prze-
kazują wartości, należy przekierować dane z okna monitorowania portu
szeregowego środowiska Arduino IDE do modułu XBee połączonego
z platformą Arduino. Warto jeszcze otworzyć okno aplikacji testującej port
szeregowy w trybie śledzenia modułu XBee podłączonego za pomocą
przewodu FTDI i sprawdzić, czy wszystko działa prawidłowo — jeśli tak,
dane wyświetlane w oknie monitora portu szeregowego środowiska Arduino
IDE powinny być widoczne także w aplikacji portu szeregowego na kom-
puterze, do którego podłączono przewód FTDI. Czyż komunikacja bez-
przewodowa nie jest wspaniała?
Na tym etapie sprzęt potrzebny do realizacji tego projektu jest prawidłowo
połączony i przetestowany — cała konstrukcja powinna przypominać
karmnik mojego autorstwa pokazany na rysunku 5.7 zatytułowanym „Pa-
pużka może pomóc w testowaniu i diagnozowaniu wartości progowych
czujnika grzędy dla zdarzeń lądowania i odlatywania ptaków”.

Rysunek 5.7. Papużka może pomóc w testowaniu i diagnozowaniu


wartości progowych czujnika grzędy dla zdarzeń lądowania
i odlatywania ptaków

Zanim jednak przystąpimy do instalowania tego sprzętu w karmniku dla pta-


ków, musimy zbudować jeszcze jeden ważny komponent. Użyjemy języka

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  113

programowania Python do napisania krótkiego programu, który będzie na-


słuchiwał komunikatów o lądujących ptakach, sprawdzał stan pojemnika
z nasionami i publikował stosowne wpisy na Twitterze. Przejdźmy więc do
pisania odpowiedniego kodu.

5.6. Ćwierkanie w Pythonie


Istnieje wiele języków programowania, w których można zaimplementować
mechanizm monitorowania i interpretacji komunikatów przychodzących
do konsoli portu szeregowego oraz wysyłania komunikatów za pośrednic-
twem portu szeregowego. Istnieje też wiele bibliotek Twittera dla różnych
języków programowania.
Wybrałem język Python dla tego i wielu innych skryptów prezentowanych
w tej książce, ponieważ język ten ma łatwą w interpretacji składnię, jest do-
myślnie instalowany wraz z systemami operacyjnymi Linux i Mac OS X
oraz oferuje wiele przydatnych bibliotek (na przykład SQLite) w swojej
podstawowej dystrybucji, zatem nie wymaga doinstalowywania tych kom-
ponentów. Czytelnikom, którzy chcą się nauczyć programowania w języku
Python, polecam książkę Python. Wprowadzenie [LA03].
W tym projekcie będziemy potrzebowali prostego skryptu o nazwie twe-
etingbirdfeeder.py, który będzie realizował następujące zadania:
1. Rejestrowanie zdarzeń (wraz z datą i godziną) lądowania i odlo-
tów ptaków na podstawie komunikatów wysyłanych przez czujnik
grzędy. Dane mają być zapisywane w tabeli birdfeeding bazy da-
nych tweetingbirdfeeder.
2. Rejestrowanie daty i godziny zdarzeń polegających na wykryciu
braku ziaren i uzupełnieniu pojemnika na karmę. Dane mają być
zapisywane w tabeli seedstatus, która także należy do bazy danych
tweetingbirdfeeder.
3. Nasłuchiwanie danych przychodzących i wysyłanie komunikatów
za pośrednictwem nadajnika XBee połączonego z komputerem przy
użyciu przewodu FTDI. Reagowanie na zdarzenia poprzez zapisy-
wanie danych wraz z datami, godzinami i rejestrowanymi warunkami.
4. Nawiązywanie połączenia z Twitterem za pośrednictwem usługi
uwierzytelniania OAuth i wysyłanie wpisów na temat karmienia pta-
ków i poziomu ziaren w karmniku.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
114  5.6. Ćwierkanie w Pythonie

Na potrzeby tego projektu będziemy musieli zainstalować tylko dwie do-


datkowe biblioteki Pythona: pyserial i python-twitter.
Oprócz publikowania wpisów na wybranym koncie na Twitterze warto
zadbać o odpowiednią wizualizację trendów opisywanych w tych wpisach,
na przykład częstotliwości wizyt ptaków w karmniku, liczby tych odwie-
dzin według dat i godzin oraz średniego czasu pomiędzy uzupełnianiem
karmy. Takie rozwiązanie umożliwi nam śledzenie trendów na podstawie
danych zarejestrowanych w ciągu godziny, doby, miesiąca i roku. Warunkiem
prezentacji tego rodzaju statystyk jest gromadzenie danych w odpowiednim
formacie.

Konfiguracja bazy danych


Ponieważ począwszy od wersji 2.5, język Python oferuje wbudowaną obsługę
baz danych SQLite i ponieważ nasze dane nie wymagają wyszukanego,
autonomicznego serwera bazy danych, baza SQLite jest wprost idealnym
rozwiązaniem dla tego projektu. Mimo że wartości można by zapisywać
w zwykłym pliku CSV (z danymi oddzielonymi przecinkami), użycie bazy
danych SQLite ma dwie zasadnicze zalety. Po pierwsze, ten sposób prze-
chowywania danych ułatwi wykonywanie zapytań analitycznych w przyszło-
ści. Po drugie, baza danych oferuje większą elastyczność w zakresie gro-
madzenia danych o różnych rodzajach zdarzeń i zarządzania tymi danymi
— w wielu przypadkach wystarczy tylko dodać odpowiednie kolumny do
tabeli.
Do utworzenia bazy danych w formacie pliku sqlite3 należy użyć polecenia
wiersza poleceń sqlite3. Narzędzie jest domyślnie instalowane wraz z syste-
mem Mac OS X. W większości systemów Linux należy pobrać to narzędzie
z repozytorium aplikacji właściwego danej dystrybucji. W dystrybucjach syste-
mu Linux na bazie Debiana, na przykład w systemie Ubuntu, instalacja apli-
kacji wymaga użycia polecenia sudo apt-get install sqlite3 libsqlite3-dev.
Użytkownicy systemu Windows będą musieli pobrać narzędzie sqlite3.exe
z witryny internetowej bazy danych SQLite9.
Po zainstalowaniu systemu bazy danych należy wpisać polecenie sqlite3
w oknie terminala. Polecenie spowoduje wyświetlenie komunikatów podob-
nych do tych pokazanych poniżej:

9
http://www.sqlite.org/download.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  115

SQLite version 3.7.6


Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

Instalacja systemu SQLite na komputerze czytelnika oczywiście może mieć


inny numer wersji.
Musimy teraz wpisać wyrażenie języka SQL tworzące nową bazę danych.
W tym celu należy opuścić powłokę poleceń sqlite, wpisując kolejno znaki
.q i naciskając klawisz właściwy znakowi powrotu karetki. Zaraz potem nale-
ży ponownie uruchomić narzędzie sqlite3, tym razem podając nazwę bazy
danych, która ma zostać otwarta.
Bazę danych dla tego projektu nazwiemy tweetingbirdfeeder, a jej dane
będą przechowywane w pliku nazwanym tweetingbirdfeeder.sqlite. Ponieważ
wspomniana baza danych jeszcze nie istnieje, system SQLite automatycznie
utworzy odpowiedni plik. Plik bazy danych zostanie utworzony w katalogu,
z którego uruchomiono narzędzie sqlite3. Jeśli na przykład polecenie sqlite3
wpisaliśmy z poziomu katalogu home, plik nowej bazy danych zostanie
utworzony właśnie w tym katalogu.
W bazie danych tweetingbirdfeeder.sqlite należy teraz utworzyć nową tabelę
nazwaną birdfeeding. Strukturę tej tabeli pokazano poniżej:

Nazwa Typ Klucz Automatyczne Dopuszczalne Unikatowa?


kolumny danych główny? zwiększanie? wartości puste?

id INTEGER TAK TAK NIE TAK


time DATETIME NIE NIE NIE NIE
event TEXT NIE NIE NIE NIE

Odpowiednią tabelę możemy utworzyć, wpisując następujące wyrażenie języ-


ka SQL w wierszu poleceń narzędzia sqlite:
[~]$ sqlite3 tweetingbirdfeeder.sqlite
SQLite version 3.7.6
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> CREATE TABLE "birdfeeding" ("id" INTEGER PRIMARY KEY NOT NULL UNIQUE,
"time" DATETIME NOT NULL,"event" TEXT NOT NULL);

Po utworzeniu tabeli birdfeeding potrzebujemy jeszcze jednej tabeli o po-


dobnej strukturze. Nowa tabela, nazwana seedstatus, będzie należała do tej
samej bazy danych:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
116  5.6. Ćwierkanie w Pythonie

Nazwa Typ Klucz Automatyczna Dopuszczalne Unikatowa?


kolumny danych główny? inkrementacja? wartości puste?

id INTEGER TAK TAK NIE TAK


time DATETIME NIE NIE NIE NIE
event TEXT NIE NIE NIE NIE

Tak jak w przypadku tabeli birdfeeding, utworzenie nowej tabeli seedstatus


wymaga wpisania odpowiedniego wyrażenia języka SQL w wierszu poleceń
narzędzia sqlite:
[~]$ sqlite3 tweetingbirdfeeder.sqlite
SQLite version 3.7.6
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> CREATE TABLE "seedstatus" ("id" INTEGER PRIMARY KEY NOT NULL,
"time" DATETIME NOT NULL ,"event" TEXT NOT NULL );

Dodatek SQLite Manager


Mimo że narzędzia systemu SQLite obsługiwane z poziomu wiersza
poleceń oferują wszystkie elementy niezbędne do tworzenia baz da-
nych i zarządzania tymi bazami, w pewnych przypadkach prostszym
rozwiązaniem jest korzystanie z aplikacji oferującej graficzny inter-
fejs użytkownika. Aplikacje z takim interfejsem są szczególnie przydat-
ne, jeśli musimy przewijać dużą liczbę wierszy w jednym oknie. Istnieje
wiele aplikacji open source umożliwiających przeglądanie baz danych
SQLite i oferujących graficzny interfejs użytkownika. Użytkowników prze-
glądarki internetowej Mozilla Firefox zachęcam do instalacji dodatku SQ-
Lite Manager, który można stosować na wielu różnych platformach10.
Instalacja tego dodatku jest bardzo prosta. Z menu przeglądarki Fire-
fox należy wybrać opcję Dodatki, po czym znaleźć dodatek SQLite Ma-
nager i kliknąć przycisk Zainstaluj. Po zainstalowaniu dodatku należy
otworzyć zakładkę Rozszerzenia w oknie dodatków i kliknąć przycisk Opcje
dla dodatku SQLite Manager. Utworzenie nowej bazy danych sprowa-
dza się do kliknięcia ikony New Database na pasku narzędzi dodatku
SQLite Manager. Równie proste jest zapisywanie i otwieranie plików
baz danych SQLite.

10
https://addons.mozilla.org/en-US/firefox/addon/sqlite-manager/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  117

Dysponujemy już gotową bazą danych, zatem możemy przystąpić do pracy


nad kodem importującym tę bazę oraz wspomniane wcześniej biblioteki Se-
rial i Twitter. Musimy też przygotować skrypt nasłuchujący zdarzeń przesy-
łanych za pośrednictwem portu szeregowego i rejestrujący te dane (wraz ze
znacznikami czasowymi) w odpowiedniej tabeli bazy danych.
Procedura przechwytywania zdarzenia powinna się zakończyć publikacją
wpisu na Twitterze. Zanim jednak będziemy mogli wysyłać takie wpisy
z poziomu programu, musimy utworzyć konto na Twitterze i zarejestrować
się, aby uzyskać klucz interfejsu Twitter API wraz z powiązanymi danymi
uwierzytelniającymi standardu OAuth. Przejdźmy więc do procesu uzyski-
wania klucza do wspomnianego interfejsu API.

Dane uwierzytelniające interfejsu API Twittera


Zanim będziemy mogli umieszczać wpisy na Twitterze, musimy oczywiście
założyć konto w tym serwisie. Co więcej, zanim będziemy mogli wysyłać wpisy
z poziomu naszego programu, a konkretnie funkcji lub bibliotek języka
programowania obsługujących standard uwierzytelniania OAuth11, musimy
utworzyć identyfikator aplikacji przypisany do odpowiedniego konta na
Twitterze. Mimo że można wykorzystać do tego celu istniejące konto na
Twitterze, moim zdaniem lepszym rozwiązaniem jest utworzenie zupełnie
nowego konta specjalnie na potrzeby tego projektu. Dzięki temu użytkownicy
śledzący moje dotychczasowe konto nie będą niepokojeni eksperymentalnymi
powiadomieniami w związku z tworzonymi projektami. Takie rozwiązanie
umożliwia też bardziej selektywny wybór odbiorców postów publikowanych
przez tworzoną aplikację. Po rozważeniu wszystkich argumentów należy
utworzyć nowe konto i uzyskać identyfikator aplikacji wygenerowany spe-
cjalnie dla projektu ćwierkającego karmnika dla ptaków.
Musimy teraz otworzyć stronę dev.twitter.com, zalogować się przy użyciu
nowych danych uwierzytelniających i wybrać opcję Create an app. Na otwar-
tej stronie Create an application należy podać unikatową nazwę nowej
aplikacji, opis złożony z co najmniej dziesięciu znaków oraz adres strony in-
ternetowej rejestrowanej aplikacji. Czytelnicy, którzy nie dysponują własnymi
witrynami internetowymi oferującymi możliwość pobrania aplikacji, mogą
wpisać jakiś tymczasowy adres. Należy następnie zaznaczyć pole Client under
Application Type i wybrać opcję Read & Write z menu Default Access

11
http://oauth.net/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
118  5.6. Ćwierkanie w Pythonie

Type. Można też wskazać niestandardową ikonę aplikacji, jednak ten krok
nie jest wymagany. Po wpisaniu tekstu zabezpieczenia CAPTCHA na-
leży kliknąć przycisk Create your Twitter application na dole strony. Przed
przejściem do następnego kroku należy jeszcze zapoznać się z warunkami
korzystania z interfejsu Twitter API i zaakceptować proponowane zapisy.
Po zaakceptowaniu żądania wygenerowany zostanie unikatowy klucz API,
klucz konsumenta standardu OAuth oraz klucz tajny konsumenta. Aby
uzyskać dostęp do tokenu dostępu (oauth_token) i klucza tajnego tokenu
dostępu (oauth_token_secret), należy kliknąć opcję My Access Token wi-
doczną po lewej stronie. Obie wartości należy skopiować i zapisać w bez-
piecznym, odpowiednio chronionym pliku. Obie wartości będą potrzebne
do komunikacji z nowym kontem na Twitterze z poziomu kodu programu.
Oczywiście należy zadbać o zachowanie tych wartości w ścisłej tajemnicy!
Nie chcemy przecież, aby jakiś złośliwy, pozbawiony skrupułów użytkownik
przejął nasz tajny token, wykorzystywał go do wysyłania spamu do naszych
przyjaciół i doprowadzał do pasji całą społeczność użytkowników Twittera.
Skoro dysponujemy już kontem na Twitterze i poprawnym kluczem interfejsu
API tego serwisu, możemy wykorzystać uzyskane dane uwierzytelniające
w kodzie aplikacji języka Python napisanej dla naszego ćwierkającego karm-
nika dla ptaków.

Biblioteka Python-Twitter
Mimo że mamy dostęp do Twittera za pośrednictwem interfejsu API, wciąż
nie dysponujemy mechanizmem komunikacji z Twitterem z poziomu skryp-
tów języka Python. Warto wykorzystać do tego celu rozwiązania dostępne
w bibliotece Python-Twitter12. Aby zainstalować obie biblioteki potrzebne
do realizacji tego projektu, czyli Pyserial i Python-Twitter, należy pobrać
najnowsze wersje tych bibliotek i użyć standardowego polecenia sudo python
setup.py install. W przypadku instalowania tych bibliotek w systemie Mac
OS X 10.6 (Snow Leopard) lub nowszym można skorzystać z już zainsta-
lowanego narzędzia instalacyjnego Pythona nazwanego easy_install. Aby
jednak uniknąć problemów związanych z 64-bitowymi wersjami bibliotek,
odpowiednie polecenie należy poprzedzić flagą architektury i386, aby zain-
stalować bibliotekę Python-Twitter bez żadnych błędów. Kompletne polece-
nie dla tej biblioteki powinno mieć następującą postać: sudo env ARCHFLAGS="-
arch i386" easy_install python-twitter.

12
http://code.google.com/p/python-twitter/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  119

Na tym etapie wszystkie niezbędne konta są skonfigurowane, a biblioteki


— zainstalowane. Możemy więc dokończyć projekt, czyli napisać skrypt języ-
ka Python odpowiedzialny za nasłuchiwanie komunikatów za pośrednictwem
modułu XBee podłączonego do portu szeregowego, zapisywanie tych komu-
nikatów w bazie danych i publikowanie odpowiednich postów na Twitterze.
Spróbujmy więc napisać skrypt Python implementujący ten złożony proces.
Plik TweetingBirdFeeder/tweetingbirdfeeder.py

# importuje biblioteki Pythona: DateTime, Serial, SQLite3 i Twitter


from datetime import datetime
import serial
import sqlite3
import twitter

# importuje moduł os w celu wyczyszczenia okna terminala i uruchomienia programu


# w systemie Windows należy użyć polecenia "cls"; w systemach Linux i OS X należy
użyć polecenia "clear"
import os

if sys.platform == "win32":
os.system("cls")
else:
os.system("clear")

# nawiązuje połączenie z portem szeregowym; nazwę URZĄDZENIE_SZEREGOWE należy zastąpić


# nazwą portu szeregowego, do którego podłączono moduł XBee (za pomocą przewodu FTDI)
XBeePort = serial.Serial('/dev/tty.URZĄDZENIE_SZEREGOWE', \
baudrate = 9600, timeout = 1)

# nawiązuje połączenie z bazą danych SQLite


sqlconnection = sqlite3.connect("tweetingbirdfeeder.sqlite3")

# tworzy kursor bazy danych


sqlcursor = sqlconnection.cursor()

# inicjalizuje obiekt interfejsu Twitter API


api = twitter.Api('klucz_konsumenta_OAuth', 'klucz_tajny_konsumenta_OAuth', \
'token_dostępu_OAuth', 'klucz_tajny_tokenu_dostępu_OAuth')

def transmit(msg):
# uzyskuje i odpowiednio formatuje bieżącą datę i godzinę
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

# sprawdza rodzaj komunikatu i przypisuje odpowiednie parametry odpowiedzi


if msg == "przylot":
tweet = "Jakiś ptak wylądował na grzędzie!"
table = "birdfeeding"
if msg == "odlot":
tweet = "Ptak odleciał z grzędy!"
table = "birdfeeding"
if msg == "dosyp":
tweet = "Pojemnik na ziarno dla ptaków jest pusty."

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
120  5.6. Ćwierkanie w Pythonie

table = "seedstatus"
if msg == "ziarnoWNormie":
tweet = "Ziarno w karmniku zostało uzupełnione."
table = "seedstatus"

print "%s - %s" % (timestamp.strftime("%Y-%m-%d %H:%M:%S"), tweet)

# zapisuje odpowiednie zdarzenie w bazie danych SQLite


try:
sqlstatement = "INSERT INTO %s (id, time, event) \
VALUES(NULL, \"%s\", \"%s\")" % (table, timestamp, msg)
sqlcursor.execute(sqlstatement)
sqlconnection.commit()
except:
print "Nie można zapisać zdarzenia w bazie danych."
pass

# publikuje informację na Twitterze


try:
status = api.PostUpdate(msg)
except:
print "Nie można opublikować postu na Twitterze"
pass

# główna pętla programu


try:
while 1:
# nasłuchuje znaków przychodzących (wysyłanych przez moduł radiowy XBee
# zainstalowany w karmniku)
message = XBeePort.readline()

# w zależności od rodzaju otrzymanego komunikatu


# rejestruje odpowiednie zdarzenie w bazie danych i publikuje post na Twitterze
if "przylot" in message:
transmit("przylot")
if "odlot" in message:
transmit("odlot")
if "dosyp" in message:
transmit("dosyp")
if "ziarnoWNormie" in message:
transmit("ziarnoWNormie")

except KeyboardInterrupt:
# przerywa program w momencie wykrycia naciśnięcia kombinacji klawiszy Ctrl+C
print("\nProgram nasłuchujący komunikatów ćwierkającego karmnika dla ptaków kończy pracę.\n")
sqlcursor.close()
pass

Po załadowaniu niezbędnych bibliotek datetime, serial, sqlite i twitter


czyścimy okno terminala (za pomocą polecenia cls w systemie Windows
lub polecenia clear w pozostałych systemach operacyjnych) i nawiązujemy
połączenie z modułem XBee (połączonym z portem szeregowym kompu-
tera za pomocą przewodu FTDI). Zaraz potem nawiązujemy połączenie

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  121

z utworzonym wcześniej plikiem bazy danych tweetingbirdfeeder.sqlite3 i roz-


poczynamy wykonywanie nieskończonej pętli while do momentu naciśnię-
cia kombinacji klawiszy Control-C, która powoduje zamknięcie programu.
Jeśli moduł XBee otrzyma i prawidłowo rozpozna komunikat, skrypt wywoła
funkcję def transmit(msg), która odpowiada za analizę składniową zmiennej
msg, dodanie opisu danego zdarzenia, zapisanie odpowiedniego komunikatu
w bazie danych oraz opublikowanie postu na Twitterze.
Jeśli platforma Arduino jest uruchomiona i jeśli para modułów XBee nawią-
zała połączenie i jest zasilana, możemy przetestować wykrywanie przekra-
czania wartości progowych, kilkukrotnie dotykając czujnik grzędy i zasłaniając
fotokomórkę, tak aby system wysłał kilka sygnałów o tych zdarzeniach. Jeśli
w oknie terminala nie zostały wyświetlone żadne błędy związane z wykony-
waniem tego skryptu, warto otworzyć plik tweetingbirdfeeder.sqlite3 w oknie
Browse and Search narzędzia SQLite Manager i sprawdzić, czy informacje
o zdarzeniach dotyczących obu czujników zostały zarejestrowane i oznaczone
odpowiednimi znacznikami czasowymi. Jeśli wszystkie te mechanizmy za-
działały prawidłowo, warto jeszcze zalogować się na Twitterze (do konta
używanego do publikowania komunikatów o tych zdarzeniach) i sprawdzić,
czy wszystkie posty zostały opublikowane we właściwej kolejności.
Nasz system jest prawie gotowy. Pozostało nam już tylko kilka usprawnień
elementów sprzętowych.

5.7. Kończenie projektu


Aby zapewnić pełną funkcjonalność tego projektu, musimy jeszcze zabezpie-
czyć niezbędne urządzenia (w tym przypadku płytkę Arduino połączoną
z modułem XBee) przed warunkami atmosferycznymi i zainstalować w karm-
niku dla ptaków, zamontować fotokomórkę blisko podstawy karmnika, wsy-
pać ziarno do karmnika, połączyć płytkę Arduino i moduł XBee ze źródłem
zasilania oraz umieścić całość na zewnątrz budynku, ale w zasięgu drugiego
modułu XBee (podłączonego do komputera).
Każdy, kto nie mieszka w strefie klimatycznej z rzadkimi opadami deszczu,
powinien dobrze zabezpieczyć urządzenia elektryczne przed działaniem wody.
W moich testów wynika, że umieszczenie tych elementów elektronicznych
w dwóch szczelnych workach w zupełności wystarczy do zabezpieczenia płyt-
ki Arduino i modułu XBee przed deszczem. Jeśli jednak nie planujemy
zasilania tych komponentów za pomocą 9-woltowej baterii, którą można by

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
122  5.7. Kończenie projektu

umieścić wraz z elektroniką w workach (takie rozwiązanie sprawdziłoby się


w przypadku krótkich sesji gromadzenia danych, jednak nasz system bar-
dzo szybko wyczerpałby baterię), musimy doprowadzić do płytki Arduino
przewód zapewniający stały dopływ energii.
Aby doprowadzić przewód zasilający, wystarczy zrobić niewielki otwór
w workach foliowych, jednak takie rozwiązanie narazi cały system na działa-
nie wilgoci. Aby zminimalizować ryzyko zalania elementów elektronicznych,
warto zabezpieczyć miejsce łączenia worków z przewodem mocno naciągniętą
folią spożywczą, tak aby szczelnie zamknąć worek i zabezpieczyć łączenie
przed poluzowaniem lub wyślizgnięciem się wskutek zmieniającej się pogody.
Stosowanie odpowiednio zabezpieczonego przewodu zasilającego (na przy-
kład przewodu sprzedawanego z myślą o zasilaniu lampek w okresie świąt
Bożego Narodzenia) będzie tańsze i łatwiejsze do testowania. Konstruktorzy
szczególnie dbający o środowisko naturalne mogą jednak zainwestować
nieco większe środki w alternatywne rozwiązanie — w technologię energii
odnawialnej w formie fotowoltaicznego systemu zasilania.
Przed zakupem odpowiedniego przenośnego systemu zasilania energią sło-
neczną warto sprawdzić, czy produkt generuje napięcie 5 V, jest odpo-
wiednio wytrzymały i zawiera wbudowany akumulator, który będzie groma-
dził energię. Dobrym przykładem stosunkowo niedrogich rozwiązań tego
typu są zasilacze z serii Solio Bolt13.
Czytelnicy, którzy wolą systemy fotowoltaiczne zawierające akumulatory
o większych pojemnościach, muszą być przygotowani na nieco większe koszty.
Takie firmy jak Sunforce Products mają w ofercie rozmaite rozwiązania pod-
trzymujące napięcie, układy ładowania akumulatorów i sterowniki projek-
towane z myślą o większym obciążeniu14.
Panel słoneczny należy zamontować w odpowiedniej odległości od karmnika,
tak aby był wystawiony na promienie słoneczne. Jeśli to możliwe, panel należy
zamontować pod kątem dziewięćdziesięciu stopni do promieni słonecznych,
aby uzyskać jak najwięcej energii. W zależności od strefy klimatycznej i śred-
niego poziomu nasłonecznienia być może trzeba będzie poszukać alternatyw-
nych lub uzupełniających rozwiązań, jak ładowarka zasilana przez turbinę
wiatrową lub nawet dynamo napędzane siłą mięśni.

13
http://www.solio.com/chargers/
14
http://www.sunforceproducts.com/results.php?CAT_ID=1

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 5. • Ćwierkający karmnik dla ptaków  123

W ramach tego projektu udało nam się osiągnąć całkiem sporo zupełnie no-
wych celów — od zastosowania fotokomórki i własnoręcznie zbudowanego
czujnika pojemnościowego, przez opanowanie sztuki łączenia w pary modu-
łów XBee i nawiązywania komunikacji bezprzewodowej między nimi, po
napisanie skryptu rejestrującego dane w ustrukturyzowanej bazie danych,
reagującego na zdarzenia i publikującego posty na Twitterze za pośrednic-
twem interfejsu API tego serwisu. Zastosowaliśmy także autonomiczny sys-
tem zasilania płytki Arduino i modułu XBee oraz zabezpieczyliśmy te wraż-
liwe komponenty elektroniczne przed szkodliwym działaniem warunków
atmosferycznych.
Te cenne lekcje z pewnością wykorzystamy przynajmniej w projektach
realizowanych w części pozostałych rozdziałów.

5.8. Następne kroki


Czujnik pojemnościowy i fotokomórkę można wykorzystać w najróżniejszych
projektach automatyzacji domu. Poniżej opisałem zaledwie kilka pomysłów,
które warto rozważyć:
 Płytkę Arduino z podłączonymi fotokomórką i modułem XBee można
umieścić (wraz z bateriami) w lodówce lub zamrażarce, aby wykry-
wać, jak często i jak długo drzwi lodówki są otwarte. Na podstawie
zgromadzonych danych można obliczyć energię traconą w poszczegól-
nych miesiącach w związku ze zbyt częstym zaglądaniem do lodówki.
W razie stwierdzenia, że koszty traconej w ten sposób energii są zbyt
wysokie, system może wysłać wiadomości poczty elektronicznej lub
powiadomienia na Twitterze przypominające domownikom o gazach
cieplarnianych i globalnym ociepleniu.
 Jeśli uznamy, że szukanie włącznika światła w ciemnościach jest zbyt
kłopotliwe, być może powinniśmy zastosować czujnik pojemnościowy
z folii aluminiowej i zainstalować ten „włącznik” na ścianie przy
wejściu do piwnicy lub garażu bądź na poziomej powierzchni stołu
na wprost wejścia.
 Na podstawie wartości analogowych odczytywanych z fotokomórki
można mierzyć cykle dni i nocy oraz poziom nasłonecznienia, aby
w ten sposób zgromadzić dane przydatne na przykład w ogrodnictwie.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
124  5.8. Następne kroki

Czy sadzenie określonych gatunków kwiatów, owoców lub warzyw


w odpowiednio wybranym okresie pozwoli przyspieszyć lub opóźnić
wzrost roślin? Jak długo rośliny były wystawione na pełne słońce,
a przez ile dni niebo było zachmurzone?
Oprócz wymienionych pomysłów istnieje jeszcze mnóstwo sposobów ana-
lizowania danych gromadzonych na podstawie zdarzeń dotyczących na-
szego karmnika dla ptaków. Możemy użyć biblioteki języka Python gene-
rującej wykresy (na przykład CairoPlot) do wizualizacji średniego czasu
przebywania ptaka w karmniku15. Ile czasu zajęło ptakom zjedzenie całego
ziarna? Jaki wpływ na godziny przylotów i czas przebywania w karmniku
miała pogoda na zewnątrz? Czy zmiana rodzaju ziarna wpłynęła na czas
przebywania ptaków w karmniku i częstotliwość przylotów?
Warto rozważyć udostępnienie wpisów na Twitterze innym entuzjastom pta-
ków, aby zbudować szeroką sieć społecznościową użytkowników czytających
i przekazujących dalej dane generowane przez nasz karmnik. Być może wzor-
ce zaobserwowane w jednym karmniku będą nieco inne niż w przypadku
karmników zamontowanych na innych obszarach geograficznych — znajomi
z serwisu społecznościowego być może będą zainteresowani wspólną ana-
lizą trendów dotyczących populacji ptaków, cykli migracyjnych i pozostałych
czynników wpływających na zachowania naszych upierzonych przyjaciół.

15
http://cairoplot.sourceforge.net/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6.
Wykrywacz
dostarczania paczek

K
ażdy, kto po całym dniu pracy wraca do domu i odkrywa, że czeka na
niego jakaś ważna przesyłka kurierska, wie, jakie to przyjemne uczu-
cie. Nawet jeśli uważnie śledziliśmy paczkę w internecie i spodzie-
waliśmy się jej tego dnia, po stwierdzeniu, że przesyłka bezpiecznie do-
tarła do naszego domu, czujemy się trochę jak po otrzymaniu prezentu uro-
dzinowego.
Jeszcze lepszym rozwiązaniem byłoby informowanie adresata o dostarcze-
niu przesyłki nie tyle w momencie jej pozostawienia w domu odbiorcy, co
w chwili potwierdzenia tego zdarzenia przez kuriera. (Patrz rysunek 6.1
zatytułowany „Otrzymywanie wiadomości poczty elektronicznej po dostar-
czeniu przesyłki”). Co będzie, jeśli kurier zostawi przesyłkę pod niewłaści-
wym adresem? Bez obaw. System wykrywania dostarczania paczek wyśle
wiadomość poczty elektronicznej w momencie pozostawienia paczki przed
drzwiami. Takie powiadomienia można bez trudu filtrować, tak aby od-
powiednie wiadomości pozostawały aktywne do momentu potwierdzenia
odbioru przesyłki na stronie internetowej.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
126  6.1. Czego potrzebujemy

Rysunek 6.1. Otrzymywanie wiadomości poczty elektronicznej


po dostarczeniu przesyłki

W tym projekcie użyjemy elementów, które stosowaliśmy wcześniej w roz-


dziale 5. zatytułowanym „Ćwierkający karmnik dla ptaków”, oraz mecha-
nizmu monitorowania i powiadamiania podobnego do rozwiązania z roz-
działu 4. zatytułowanego „Elektryczny pies stróżujący”. Zamiast używać
czujnika ruchu na podczerwień (PIR) nasz wykrywacz paczek będzie się
kierował wskazaniami czujnika nacisku. W momencie umieszczenia na mo-
nitorowanym miejscu dla paczek (na przykład na wycieraczce) przedmiotu
o wadze zbliżonej do niewielkiej przesyłki (czyli ważącej około pół kilo-
grama) czujnik wysyła powiadomienie za pośrednictwem modułu XBee
podłączonego do portu szeregowego. Odpowiednie powiadomienie jest na-
stępnie przetwarzane przez skrypt języka Python, który rejestruje w dzienniku
zdarzeń informację o paczce i wysyła wiadomość poczty elektronicznej.
Warto też rozważyć implementację bardziej niezawodnego rozwiązania,
które odczeka godzinę i potwierdzi zgłoszenie dostawy na stronie interne-
towej firmy kurierskiej, aby na tej podstawie wysłać sprawdzoną wiado-
mość o paczce.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  127

6.1. Czego potrzebujemy


Większość elementów potrzebnych do budowy tego projektu stosowaliśmy
już we wcześniejszych projektach opisanych w tej książce — wyjątkiem jest
czujnik siły nacisku (który bywa błędnie nazywany czujnikiem ciśnienia).
Warto przeanalizować kompletną listę niezbędnych komponentów (potrzebne
części pokazano też na rysunku 6.2 zatytułowanym „Części systemu wy-
krywania dostarczonych paczek”.

Rysunek 6.2. Części systemu wykrywania dostarczonych paczek

1. platforma Arduino Diecimila, Nano lub Uno;


2. para modułów radiowych XBee oraz odpowiedni przewód FTDI;
3. rezystor 10 kΩ;
4. czujnik siły nacisku1, na przykład podobny do tego pokazanego na
rysunku 6.3 (zatytułowanym „Rezystory projektu wykrywacza do-
starczonych paczek”) wraz z rezystorem 10 kΩ2;
5. 9-woltowy zasilacz dla platformy Arduino (potrzebny do zasilania
systemu po odłączeniu przewodu USB);

1
http://www.adafruit.com/products/166
2
Firma Sparkfun ma w ofercie kwadratowy czujnik o jeszcze większej powierzchni:
http://www.sparkfun.com/products/9376.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
128  6.2. Budowa rozwiązania

Rysunek 6.3. Rezystory projektu wykrywacza dostarczonych paczek

6. dwie drewniane lub plastikowe płytki (najlepiej połączone);


7. komputer (nie ma go na zdjęciu), najlepiej z systemem Linux lub
Mac OS oraz zainstalowanym kompilatorem języka Python 2.6
lub nowszym (na potrzeby skryptu przetwarzającego przychodzące
komunikaty i korzystania z usług sieciowych oferowanych przez po-
pularne firmy logistyczne).
W zależności od typu płytki Arduino wybranego dla tego projektu będziemy
dodatkowo potrzebowali standardowego przewodu USB z końcówkami
A-B lub A-mini B, aby połączyć platformę Arduino z komputerem.
Czytelnicy, którzy realizowali projekty opisane w dotychczasowych rozdzia-
łach, nie powinni mieć najmniejszych problemów ze skonstruowaniem wy-
krywacza dostarczonych paczek. Projekt prezentowany w tym rozdziale jest
w istocie zmodyfikowaną wersją systemu ćwierkającego karmnika dla pta-
ków. Zamiast czujnika natężenia światła (fotokomórki) w tym projekcie
użyjemy czujnika nacisku zainstalowanego w odpowiednim miejscu. Rozbu-
dujemy też skrypt języka Python z poprzedniego projektu, tak aby uzyski-
wał dane z serwisów internetowych popularnych firm kurierskich. Spraw-
dzanie stanu przesyłek na stronach firm kurierskich pozwoli dodatkowo
potwierdzić komunikaty o doręczeniach. Do dzieła!

6.2. Budowa rozwiązania


Konstrukcja rozwiązań sprzętowych na potrzeby tego projektu bardzo przy-
pomina rozwiązania zbudowane w ramach projektu ćwierkającego karmni-
ka dla ptaków. Także tym razem użyjemy języka Python do opracowania
skryptu działającego na serwerze, jednak w tym przypadku skrypt będzie

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  129

zawierał wiele niestandardowych pakietów potrzebnych do komunikacji


z usługami sieciowymi wybranych firm kurierskich — na potrzeby tego pro-
jektu zaimplementowałem mechanizmy współpracujące z serwisami popu-
larnych w Stanach Zjednoczonych firm Federal Express (FedEx) i United
Parcel Service (UPS). Realizacja tego projektu wymaga następujących
kroków:
1. Należy podłączyć czujnik siły nacisku do dostępnego wtyku analogo-
wego na płytce Arduino i zidentyfikować wartość progową dla od-
powiedniej siły działającej na ten czujnik.
2. Należy podłączyć moduł XBee do płytki Arduino i (po wykryciu
przekroczenia wartości progowej wybranej dla czujnika siły nacisku)
przesłać komunikat do innego modułu XBee połączonego z kom-
puterem.
3. Po otrzymaniu komunikatu o zdarzeniu przekroczenia wartości pro-
gowej skrypt wstrzymuje działanie na dziesięć minut, aby dać czas
na aktualizację bazy danych w systemie śledzenia przesyłek firmy
kurierskiej. Skrypt musi następnie przeszukać tabelę bazy danych pod
kątem znanych numerów przesyłek kurierskich firm FedEx i UPS.
Należy użyć usług sieciowych firm FedEx i UPS do sprawdzenia,
czy informacja o dostarczeniu przesyłki została potwierdzona.
4. W razie znalezienia dopasowania należy zaktualizować odpowiedni
wiersz w lokalnej bazie danych, tak aby zawierał potwierdzenie do-
starczenia przesyłki oraz datę i godzinę tego zdarzenia.
5. Należy wysłać (za pośrednictwem bramy Gmail SMTP firmy
Google) wiadomość poczty zawierającą godzinę wykrycia dostar-
czenia przesyłki i numery paczek, których status został prawidłowo
potwierdzony w serwisie firmy kurierskiej. W razie braku pasującego
numeru przesyłki musimy zasygnalizować problem w ciele tej wia-
domości.
Zacznijmy od połączenia elementów sprzętowych tego układu. Tworzeniem
niezbędnego oprogramowania zajmiemy się w dalszej części tego rozdziału.

6.3. Łączenie sprzętu


Czytelnicy, którzy zrealizowali projekt ćwierkającego karmnika dla ptaków,
wiedzą już, jak połączyć moduł XBee i czujnik do płytki Arduino. W razie
potrzeby przypomnienia sobie odpowiednich rozwiązań warto wrócić do

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
130  6.3. Łączenie sprzętu

podrozdziału 5.5 zatytułowanego „Komunikacja bezprzewodowa”. Za-


miast podłączać do wtyku analogowego na płytce Arduino czujnik natężenia
światła wraz z rezystorem 10 kΩ, tym razem podłączymy czujnik siły naci-
sku. (Patrz rysunek 6.4 zatytułowany „Schemat połączeń systemu wykry-
wania dostarczonych paczek”). Jedną końcówkę czujnika należy połączyć
z wtykiem zasilania 3,3 V. Drugą końcówkę należy połączyć z wtykiem ana-
logowym nr 0. Wtyk analogowy nr 0 należy następnie zmostkować z wtykiem
uziemienia za pomocą rezystora 10 kΩ.

Rysunek 6.4. Schemat połączeń systemu wykrywania dostarczonych paczek

Moduł XBee należy podłączyć do płytki Arduino w taki sam sposób jak
w projekcie ćwierkającego karmnika dla ptaków. Końcówkę zasilania mo-
dułu XBee należy połączyć z wtykiem zasilania 5,5 na płytce Arduino.
Końcówkę uziemienia modułu XBee należy połączyć z drugim dostępnym
wtykiem uziemienia na płytce Arduino. Końcówkę danych przychodzą-
cych tego modułu należy połączyć z wtykiem cyfrowym nr 2, a końcówkę
danych wychodzących — z wtykiem cyfrowym nr 3. Po połączeniu wszyst-
kich elementów nasz system powinien wyglądać tak jak rozwiązanie poka-
zane na rysunku 6.5 zatytułowanym „Wykrywacz dostarczonych paczek”.
Musimy jeszcze połączyć komputer z portem URL platformy Arduino,
aby nie tylko zapewnić zasilanie całego układu, ale też umożliwić napisa-
nie, uruchomienie i przetestowanie szkicu utworzonego dla tego projektu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  131

Rysunek 6.5. Wykrywacz dostarczonych paczek

6.4. Pisanie kodu


Projekt obejmuje dwa komponenty kodu źródłowego. Pierwszym takim
komponentem będzie szkic monitorujący stan czujnika siły nacisku pod kątem
położenia na nim czegoś, czego waga przekracza przyjętą wartość progową.
W takim przypadku szkic musi wysłać zdarzenie wraz z wartością odczytaną
przez ten czujnik za pośrednictwem portu szeregowego i podłączonego do
niego modułu XBee.
Drugim komponentem programowym będzie skrypt języka Python oczeku-
jący na zdarzenie przekroczenia wartości progowej zidentyfikowanej dla
czujnika siły nacisku. Jeśli wartość progowa została przekroczona, skrypt
musi zarejestrować wartość przesłaną przez czujnik (wraz z datą i godziną
tego zdarzenia) w bazie danych SQLite. Jeśli baza danych zawiera listę
znanych numerów śledzonych przesyłek, skrypt powinien przeszukać te
numery i sprawdzić usługi sieciowe firm kurierskich FedEx i UPS pod
kątem pasujących wartości. Program musi następnie wysłać wiadomość
poczty elektronicznej zawierającą informację o zdarzeniu dostarczenia paczki
i ewentualne potwierdzenie tego zdarzenia pobrane z serwisu firmy kurierskiej.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
132  6.5. Szkic systemu wykrywania dostarczonych paczek

6.5. Szkic systemu wykrywania


dostarczonych paczek
Kod tego szkicu jest w istocie zmienioną wersją programu, który napisaliśmy
dla projektu ćwierkającego karmnika dla ptaków. Jedną z największych zalet
projektów budowanych na bazie platformy Arduino jest możliwość wielo-
krotnego stosowania raz napisanych szkiców operujących na czujnikach
czy urządzeniach wykonawczych. Podstawowe zasady działania czujników
i urządzeń wykonawczych są takie same — zmienia się tylko rodzaj czujnika
czy silnika oraz konkretne wartości (odczytywane przez czujnik i sterujące
silnikiem).
Ponieważ zdecydowaną większość kodu tego szkicu omówiłem już przy okazji
analizy projektu ćwierkającego karmnika dla ptaków, nie będziemy tracić
czasu na ponowną analizę wszystkich aspektów tego rozwiązania. Warto
jednak zwrócić uwagę na jedną zmienną zastosowaną w nowym szkicu:
force_value. Tak jak w przypadku wszystkich czujników stosowanych w pozo-
stałych projektach, czujnik siły nacisku wymaga kalibracji pod kątem określo-
nej konfiguracji (konkretnego typu czujnika, rodzaju zastosowanych przewo-
dów, napięć występujących w układzie i sposobu instalacji samego czujnika).
Plik PackageDeliveryDetector/PackageDeliveryDetector.pde

#include <NewSoftSerial.h>

#define FORCE_THRESHOLD 400


#define ONBOARD_LED 13
#define FORCE_SENSOR 0

// ustawia wtyki cyfrowe na potrzeby szeregowego wysyłania/odbioru danych


// przez moduł XBee
NewSoftSerial XBeeSerial = NewSoftSerial(2, 3);
int force_value = 0;
byte force_state = 0;

void setup()
{
// na potrzeby komunikatów diagnostycznych w oknie portu szeregowego
Serial.begin(9600);

// na potrzeby transmisji danych za pośrednictwem modułu XBee


XBeeSerial.begin(9600);

// ustawia wtyk dla wbudowanej diody LED


pinMode(ONBOARD_LED, OUTPUT);
}
void SendDeliveryAlert(int force_value, int force_state)
{
digitalWrite(ONBOARD_LED, force_state ? HIGH : LOW);

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  133

if (force_state)
Serial.print("Dostarczono przesyłkę, force_value=");
else
Serial.print("Zabrano przesyłkę, force_value=");
Serial.println(force_value);
XBeeSerial.println(force_value);
}
void loop()
{
// czeka sekundę w każdej iteracji pętli
delay(1000);

// sprawdza napięcie na wtyku FORCE_SENSOR


force_value = analogRead(FORCE_SENSOR);

switch (force_state)
{
case 0: // sprawdza, czy dostarczono paczkę
if (force_value >= FORCE_THRESHOLD)
{
force_state = 1;
SendDeliveryAlert(force_value, force_state);
}
break;
case 1: // sprawdza, czy zabrano paczkę
if (force_value < FORCE_THRESHOLD)
{
force_state = 0;
SendDeliveryAlert(force_value, force_state);
}
break;
}
}

Mimo że dysponujemy już podstawowym szkicem, wciąż musimy przetesto-


wać ten kod na konkretnej płytce Arduino i sprawdzić, czy czujnik siły naci-
sku prawidłowo reaguje na zdarzenia zmiany wagi. Musimy też zadbać
o prawidłową komunikację radiową pary modułów XBee, czyli o prawidłowe
przekazywanie wartości odczytywanych przez czujnik siły nacisku (za pośred-
nictwem wtyku analogowego nr 0) oraz komunikatu o wadze.

6.6. Testowanie szkicu wykrywającego


dostarczanie paczek
Po zainstalowaniu i uruchomieniu tego szkicu na platformie Arduino należy
otworzyć okno monitorowania portu szeregowego w środowisku Arduino
IDE i ścisnąć czujnik siły nacisku kciukiem i palcem wskazującym. Zdarzenie
dostarczenia paczki powinno zostać zasygnalizowane w oknie monitora portu

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
134  6.7. Skrypt przetwarzający komunikaty o przesyłkach

szeregowego. Należy teraz puścić czujnik siły nacisku i odczekać kilka se-
kund. W oknie monitora portu szeregowego powinna zostać wyświetlona
wartość mniejsza niż 400 wraz z komunikatem o braku paczki. W razie bra-
ku odpowiednich komunikatów warto raz jeszcze sprawdzić wszystkie połą-
czenia. Być może będziemy musieli zwiększyć lub zmniejszyć wartość pro-
gową force_sensor_value, aby wyeliminować wpływ przypadkowych od-
czytów analogowych czujnika wskutek drgań lub nieoczekiwanych wahań.
Należy również sprawdzić, czy moduły radiowe XBee są prawidłowo połą-
czone i czy komunikują się ze sobą. Warto też użyć polecenia screen (opi-
sanego już w rozdziale 5. zatytułowanym „Ćwierkający karmnik dla pta-
ków”) do obserwacji komunikatów wysyłanych przez czujnik siły nacisku
w reakcji na jego ściskanie palcami. Przesyłane w ten sposób informacje po-
winny być takie same jak te wyświetlane w oknie monitora portu szeregowego
w ramach środowiska Arduino IDE. Po sprawdzeniu wszystkich elementów
możemy przystąpić do pisania skryptu języka Python, który będzie odpo-
wiadał za nasłuchiwanie komunikatów przychodzących do docelowego
modułu XBee (połączonego z komputerem za pomocą przewodu FTDI)
i na tej podstawie podejmował odpowiednie działania.

6.7. Skrypt przetwarzający komunikaty


o przesyłkach
Także tym razem wykorzystamy kod napisany na potrzeby projektu ćwierka-
jącego karmnika dla ptaków (opisanego w rozdziale 5.). Oprócz skopio-
wania rozwiązań odpowiedzialnych za monitorowanie portu szeregowego
i nawiązywanie połączeń z bazą danych SQLite musimy jeszcze rozszerzyć
ten skrypt o dodatkowe elementy. Po pierwsze, musimy dodać mechanizm
przeszukiwania bazy danych pod kątem znanych, śledzonych numerów prze-
syłek. Po otrzymaniu powiadomienia za pośrednictwem modułu XBee
podłączonego do portu szeregowego (za pomocą przewodu FTDI) skrypt
odczeka kilka minut, po czym przeszuka numery śledzonych paczek w celu
identyfikacji właściwej przesyłki. W niektórych firmach kurierskich aktualiza-
cja systemu i wprowadzenie informacji o dostarczeniu paczki może zająć
nawet ponad godzinę. W przypadku Poczty Stanów Zjednoczonych taka
aktualizacja zajmuje nawet dobę, zatem sprawdzanie stanu zwykłych paczek
pocztowych w ten sposób nie ma większego sensu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  135

Po przeszukaniu tabeli bazy danych i uzyskaniu numerów śledzonych paczek


za pośrednictwem usług sieciowych firm kurierskich możemy dodać infor-
mację o potwierdzeniu stanu przesyłki do generowanej wiadomości poczty
elektronicznej. Wiadomość poczty elektronicznej powinna zawierać stosowną
informację także w razie wystąpienia błędu podczas poszukiwania numeru
przesyłki lub w przypadku braku potwierdzenia dostarczenia paczki w syste-
mie firmy kurierskiej.
Na koniec użyjemy usługi Gmail do wysłania wiadomości do właściwego
adresata. Czytelnicy, którzy nie dysponują kontem usługi Gmail, będą musieli
utworzyć takie konto na potrzeby tego projektu. Alternatywnym rozwiąza-
niem jest użycie innego serwera poczty elektronicznej z obsługą wiadomości
wychodzących SMTP — wystarczy zastąpić bramę SMTP usługi Gmail
adresem dowolnego innego serwera. Zanim jednak będziemy mogli przy-
stąpić do pisania kodu języka Python, musimy przygotować strukturę bazy
danych, w której będziemy zapisywali zdarzenia związane z dostarczaniem
przesyłek, numery śledzonych przesyłek, opisy paczek i potwierdzenia
dostarczenia.

6.8. Tworzenie bazy danych systemu


wykrywania przesyłek
Na potrzeby tego projektu musimy utworzyć dwie tabele. Pierwsza tabela
będzie zawierała zarówno historię zdarzeń wykrywanych przez czujnik siły
nacisku (w momencie kładzenia i podnoszenia paczek), jak i zarejestro-
wane wartości przekraczające przyjęty próg. Druga tabela będzie zawierała
znane numery śledzonych przesyłek wraz z polem reprezentującym datę
i godzinę potwierdzenia doręczenia przez kuriera (w systemie firmy kurier-
skiej). Podobne rozwiązanie stosowaliśmy już w projekcie ćwierkającego
karmnika dla ptaków (opisanym w rozdziale 5.), zatem podczas tworzenia
bazy danych o paczkach użyjemy tych samych technik.
Plik bazy danych utworzymy za pomocą narzędzia sqlite3. Do tak utwo-
rzonej bazy danych packagedelivery dodamy dwie opisane powyżej tabele.
Jak już wspomniałem, w pierwszej tabeli będziemy przechowywać infor-
macje o zdarzeniach zarejestrowanych przez czujnik siły nacisku oraz daty
i godziny występowania tych zdarzeń. Strukturę odpowiedniej tabeli bazy
danych pokazano poniżej:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
136  6.8. Tworzenie bazy danych systemu wykrywania przesyłek

Nazwa Typ Klucz Automatyczna Dopuszczalne Unikatowa?


kolumny danych główny? inkrementacja? wartości puste?

id INTEGER TAK TAK NIE TAK


time DATETIME NIE NIE NIE NIE
event TEXT NIE NIE NIE NIE

Czy ta tabela nie wygląda znajomo? Tak — tabela bardzo przypomina


strukturę utworzoną podczas realizacji projektu ćwierkającego karmnika
dla ptaków. Ogólne zasady działania obu mechanizmów są takie same,
ponieważ w obu projektach musimy uzyskiwać sygnał o zdarzeniu i zapi-
sywać informacje na jego temat w ustrukturyzowanej formie. Tym razem
zdarzenie reprezentuje otrzymanie przesyłki.
Odpowiednią tabelę możemy utworzyć, wpisując następujące wyrażenie języ-
ka SQL w wierszu poleceń narzędzia sqlite:
[~]$ sqlite3 packagedelivery.sqlite
SQLite version 3.7.6
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> CREATE TABLE "deliverystatus" ("id" INTEGER PRIMARY KEY NOT NULL UNIQUE,
"time" DATETIME NOT NULL,"event" TEXT NOT NULL);

Musimy jeszcze utworzyć tabelę o nazwie tracking, która będzie zawierała


numery śledzonych przesyłek, opisy zawartości poszczególnych paczek,
status procesu dostarczania tych przesyłek oraz datę dostarczenia potwier-
dzoną na podstawie danych systemu firmy kurierskiej. Tabela powinna
mieć następującą strukturę:
Nazwa Typ Klucz Automatyczna Dopuszczalne Unikatowa?
kolumny danych główny? inkrementacja? wartości puste?

id INTEGER TAK TAK NIE TAK


tracking_ TEXT NIE NIE NIE NIE
number

description TEXT NIE NIE NIE NIE


delivery_ BOOLEAN NIE NIE NIE NIE
status

delivery_ DATETIME NIE NIE NIE NIE


date

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  137

Aby utworzyć tę tabelę w bazie danych packagedelivery, należy wpisać


następujące wyrażenie języka SQL w wierszu poleceń narzędzia sqlite3:
[~]$ sqlite3 packagedelivery.sqlite
SQLite version 3.7.6
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite> CREATE TABLE "tracking" ("id" INTEGER PRIMARY KEY NOT NULL UNIQUE,
"tracking_number" TEXT NOT NULL, "description" TEXT NOT NULL,
"delivery_status" BOOL NOT NULL, "delivery_date" DATETIME);

Skoro dysponujemy już tabelami bazy danych, możemy przejść do następne-


go kroku, czyli pobrania pakietów języka Python potrzebnych do opracowa-
nia skryptu przetwarzającego komunikaty o paczkach.

6.9. Instalacja niezbędnych pakietów


Pythona
Aby uprościć śledzenie paczek dostarczanych przez firmy kurierskie FedEx
i UPS, użyjemy pakietu języka Python o nazwie packagetrack. Wspomniany
pakiet jest w istocie opakowaniem ułatwiającym analizę składniową da-
nych w formacie XML udostępnianych przez usługi sieciowe firm kurier-
skich — dzięki temu pakietowi implementacja mechanizmów przetwarza-
nia danych jest nieporównanie prostsza. Mimo że można by użyć do tego
celu jednej z bibliotek Pythona przetwarzających kod stron internetowych
(na przykład biblioteki Beautiful Soup), takie rozwiązanie nie byłoby
niezawodne. Największe firmy kurierskie (jak FedEx czy UPS) udostępniają
interfejsy API swoich usług sieciowych między innymi po to, aby zniechęcić
programistów do przetwarzania zwykłych stron internetowych i powodo-
wania nadmiernego obciążenia serwerów WWW. Przed przystąpieniem
do instalacji biblioteki packagetrack należy skorzystać z istniejących kont
klienta firm UPS i FedEx do uzyskania dostępu do odpowiednich inter-
fejsów API. Czytelnicy, którzy nie dysponują jeszcze numerem konta i nazwą
użytkownika, muszą odwiedzić strony internetowe wybranych firm kurierskich
i utworzyć nowe konta. Proces tworzenia konta wymaga podania prawidło-
wego numeru karty kredytowej (podana karta będzie w przyszłości służyła
do rozliczania wysyłanych paczek).
Po uzyskaniu prawidłowej nazwy użytkownika, hasła i numeru konta wystar-
czy odwiedzić strony internetowe przeznaczone dla programistów i zareje-
strować się w celu uzyskania klucza interfejsu API usługi sieciowej (w przy-
padku FedEx) lub numeru licencji (w przypadku UPS). W odpowiedzi na

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
138  6.9. Instalacja niezbędnych pakietów Pythona

żądanie klucza na stronie firmy FedEx zostaną dodatkowo wygenerowane


dane uwierzytelniające. Uzyskane w ten sposób wartości będą potrzebne
podczas wywołań interfejsów API usług sieciowych wybranych firm ku-
rierskich.
Możemy teraz przystąpić do instalacji najnowszej wersji pakietu packagetrack.
Zamiast uzyskać ten pakiet za pośrednictwem polecenia easy_install,
czyli prostego narzędzia do pobierania i instalacji pakietów Pythona, po-
lecam użycie polecenia git, aby skopiować odgałęzienie tego projektu utwo-
rzone przez Michaela Stellę3. Oprócz pakietu packagetrack w wersji roz-
wijanej przez Michaela należy pobrać także niezbędny pakiet dodatkowy
przystosowany do współpracy z tą wersją, czyli pakiet python-fedex rozwiązu-
jący problem analizy składniowej danych udostępnianych przez firmę FedEx
w formacie XML4. Sam pakiet python-fedex dodatkowo używa pewnej
biblioteki języka Python nazwanej suds. Wspomniana biblioteka jest prostą
implementacją protokołu SOAP (od ang. Simple Object Access Protocol)
dla języka Python — pakiet python-fedex używa jej do analizy składniowej
danych udostępnianych przez usługę sieciową firmy FedEx w formacie XML.
Aby automatycznie pobrać i zainstalować pakiet suds, należy użyć polecenia
sudo easy_install suds.

Musimy następnie zainstalować oba pakiety (python-fedex i packagetrack)


za pomocą polecenia sudo python setup.py install użytego w oknie terminala.
Aby upewnić się, że oba pakiety zostały prawidłowo zainstalowane, wy-
starczy uruchomić interpreter Pythona, wpisując polecenie python w oknie
terminala. Po wyświetleniu znaków zachęty >>> należy wpisać polecenie import
packagetrack i nacisnąć klawisz Return. Jeśli nie zostanie wyświetlony żaden
komunikat o błędzie, możemy być pewni, że oba pakiety zostały prawidłowo
zainstalowane.
Wszystkie pozostałe pakiety, których będziemy używali w skrypcie wykry-
wacza dostarczonych przesyłek, są dołączane do standardowych dystrybucji
języka Python 2.5 i nowszych. Po spełnieniu wymagań związanych z biblio-
teką packagetrack i niezbędnymi kluczami dostępu do interfejsu API usługi
sieciowej firmy kurierskiej możemy przystąpić do pisania skryptu odpowie-
dzialnego za monitorowanie przesyłek.

3
https://github.com/alertedsnake/packagetrack
4
https://github.com/alertedsnake/python-fedex

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  139

6.10. Pisanie skryptu


Skrypt monitorujący dostarczanie paczek musi wykonywać wiele funkcji
— musi nasłuchiwać zdarzeń wysyłanych przez sprzęt monitorujący poja-
wianie się paczek, reagować na te zdarzenia poprzez wysyłanie wiadomo-
ści poczty elektronicznej oraz wykonywać wszystkie operacje pomocnicze.
Mówiąc dokładniej, skrypt musi podejmować następujące działania:
1. Powinien nasłuchiwać zdarzeń przekroczenia wartości progowej (czyli
zdarzeń wskazujących na położenie lub zabranie paczki) wysłanych
przez oprogramowanie obsługujące komunikację z modułem radio-
wym XBee (za pośrednictwem portu szeregowego).
2. Skrypt powinien też dołączać znaczniki czasowe do zdarzeń wyge-
nerowanych przez czujnik siły nacisku oraz umieszczać kompletne
dane w tabeli deliverystatus.
3. W razie otrzymania wysokiej wartości (czyli w przypadku dostarcze-
nia paczki) skrypt musi przeszukać numery śledzonych przesyłek
zapisane w tabeli bazy danych. W razie otrzymania niskiej wartości
(czyli w przypadku zabrania paczki z czujnika) skrypt powinien wy-
słać wiadomość poczty elektronicznej informującą o tym fakcie, po
czym wrócić do stanu nasłuchiwania zdarzeń dostarczenia paczki.
4. W razie otrzymania wysokiej wartości skrypt powinien odczekać
pewien czas, po czym sprawdzić tabelę śledzonych przesyłek —
dzięki temu kurier będzie miał czas na aktualizację odpowiednich
rekordów w systemie firmy kurierskiej.
5. Skrypt musi iteracyjnie przeszukać numery śledzonych przesyłek
i sprawdzić w systemie firmy kurierskiej (za pośrednictwem odpo-
wiedniej usługi sieciowej), czy dostarczenie paczki zostało potwier-
dzone przez kuriera.
6. Jeśli wynik zwrócony przez usługę sieciową firmy kurierskiej potwier-
dza dostarczenie przesyłki, skrypt powinien zmienić status w rekor-
dzie odpowiedniej paczki w tabeli lokalnej bazy danych na 1 (czyli
wartość logiczną oznaczającą, że paczka trafiła do adresata).
7. Skrypt powinien wysłać wiadomość poczty elektronicznej za pośred-
nictwem bezpiecznej bramy SMTP usługi Gmail. Ciało tej wiadomo-
ści musi zawierać informację o stanie przesyłki. Musimy pamiętać,
że warunkiem prawidłowego funkcjonowania tego mechanizmu jest
dysponowanie dostępem do aktywnego konta usługi Gmail.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
140  6.10. Pisanie skryptu

8. Skrypt powinien wrócić do stanu oczekiwania na następne zdarze-


nia dostarczania paczek.
Poniżej pokazano kompletny skrypt implementujący wymienione kroki.
Plik PackageDeliveryDetector/packagedeliverydetector.py

from datetime import datetime


import packagetrack
from packagetrack import Package
import serial
import smtplib
import sqlite3
import time
import os
import sys
# Nawiązuje połączenie z portem szeregowym
XBeePort = serial.Serial('/dev/tty.URZĄDZENIE_SZEREGOWE', \
baudrate = 9600, timeout = 1)

def send_email(subject, message):


recipient = 'ADRESAT_POCZTY@DOMENA.PL'
gmail_sender = 'NAZWA_KONTA_GMAIL@gmail.com'
gmail_password = 'HASŁO_DO_KONTA_GMAIL'

# Nawiązuje bezpieczne połączenie TLS z bramą SMTP usługi Gmail


gmail_smtp = smtplib.SMTP('smtp.gmail.com',587)
gmail_smtp.ehlo()
gmail_smtp.starttls()
gmail_smtp.ehlo

# Loguje się do usługi Gmail


gmail_smtp.login(gmail_sender, gmail_password)

# Formatuje wiadomość
mail_header = 'To:' + recipient + '\n' + 'From: ' + gmail_sender + '\n' \
+ 'Subject: ' + subject + '\n'
message_body = message
mail_message = mail_header + '\n ' + message_body + ' \n\n'

# Wysyła sformatowaną wiadomość


gmail_smtp.sendmail(gmail_sender, recipient, mail_message)
print("Wiadomość została wysłana")

# Zamyka połączenie
gmail_smtp.close()

def process_message(mg):
try:
# Należy pamiętać o konieczności użycia prawidłowej ścieżki do pliku
# packagedelivery.sqlite
connection = sqlite3.connect("packagedelivery.sqlite")
cursor = connection.cursor()

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  141

# Uzyskuje i odpowiednio formatuje bieżącą datę i godzinę


timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
sqlstatement = "INSERT INTO delivery (id, time, event) \
VALUES(NULL, \"%s\", \"%s\")" % (timestamp, msg)
cursor.execute(sqlstatement)
connection.commit()
cursor.close()
except:
print("Wystąpił problem podczas próby dostępu do tabeli delivery " \
+ "w bazie danych packagedelivery")

if (msg == "Delivery"):

# Czeka 5 minut (300 sekund) przed sprawdzeniem stanu przesyłki


# w systemach firm kurierskich
time.sleep(300)

try:
connection = sqlite3.connect("packagedelivery.sqlite")
cursor = connection.cursor()
cursor.execute('SELECT * FROM tracking WHERE '\
+ 'delivery_status=0')
results = cursor.fetchall()
message = ""

for x in results:
tracking_number = str(x[1])
description = str(x[2])
print tracking_number

package = Package(tracking_number)
info = package.track()
delivery_status = info.status
delivery_date = str(info.delivery_date)

if (delivery_status.lower() == 'delivered'):
sql_statement = 'UPDATE tracking SET \
delivery_status = "1", delivery_date = \
"' + delivery_date + \
'" WHERE tracking_number = "' \
+ tracking_number + '";'
cursor.execute(sql_statement)
connection.commit()
message = message + description \
+ ' paczka oznaczona numerem ' \
+ tracking_number \
+ ' została dostarczona dnia ' \
+ delivery_date +'\n\n'

# Zamyka kursor
cursor.close()

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
142  6.10. Pisanie skryptu

# Potwierdzono dostarczenie przesyłki, można wysłać wiadomość poczty


# elektronicznej
if (len(message) > 0):
print message
send_email('Potwierdzenie dostarczenia przesyłki', message)
else:
send_email('Wykryto dostarczoną przesyłkę', 'System ' \
+ 'wykrył zdarzenie dostarczenia paczki, ' \
+ 'jednak dla żadnej ze śledzonych przesyłek z niepotwierdzonym ' \
+ 'numerem (zarejestrowanych w bazie danych) ' \
+ 'nie potwierdzono dostarczenia do adresata ' \
+ 'w systemie firmy kurierskiej.')

except:
print("Wystąpił problem podczas próby dostępu do tabeli tracking " \
+ "w bazie danych packagedelivery")

else:
send_email('Zabrano paczkę', 'Wykryto zdarzenie zabrania paczki.')

if sys.platform == "win32":
os.system("cls")
else:
os.system("clear")

print("Wykrywacz dostarczonych paczek czeka na zdarzenia...\n")


try:
while 1:
# Nasłuchuje znaków przychodzących do modułu radiowego XBee
XBee_message = XBeePort.readline()

# W zależności od rodzaju otrzymanego komunikatu


# rejestruje zdarzenie w bazie danych i przeszukuje śledzone przesyłki
if "Delivery" in XBee_message:
# Uzyskuje i odpowiednio formatuje bieżącą datę i godzinę
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print("Wykryto zdarzenie dostarczenia paczki - " + timestamp)
process_message("Delivery")

if "Empty" in XBee_message:
# Uzyskuje i odpowiednio formatuje bieżącą datę i godzinę
timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
print("Wykryto zdarzenie zabrania paczki - " + timestamp)
process_message("Empty")

except KeyboardInterrupt:
print("\nWykrywacz dostarczonych paczek kończy działanie.\n")
pass

Działanie skryptu rozpoczyna się od zaimportowania pakietów po-


trzebnych do działania niestandardowej biblioteki packagetrack i zaim-
portowania standardowych bibliotek Pythona: serial, smtplib, sqlite3,
time, os i sys.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  143

Skrypt identyfikuje port szeregowy, do którego podłączono moduł ra-


diowy XBee. Wspomniany moduł radiowy będzie nasłuchiwał komu-
nikatów przychodzących wysyłanych przez drugi moduł XBee (połą-
czony z płytką Arduino, z którą połączono czujnik siły nacisku). Łań-
cuch '/dev/tty.URZĄDZENIE_SZEREGOWE' należy zastąpić właściwą ścieżką
do modułu XBee podłączonego do portu szeregowego komputera.
Funkcja send_mail jest używana w ciele funkcji process_message, zatem musi
być zadeklarowana jako pierwsza. Łańcuchy ADRESAT_POCZTY@DOMENA.PL, NA-
ZWA_KONTA_GMAIL i HASŁO_DO_KONTA_GMAIL należy zastąpić prawidłowymi
danymi uwierzytelniającymi dla stosowanego konta usługi Gmail.
Większość działań realizowanych przez ten skrypt jest wykonywana
w ciele funkcji process_message. Funkcja nawiązuje połączenie z bazą
danych packagedelivery.sqlite systemu SQLite i zapisuje w odpowiedniej
tabeli rodzaj otrzymanego zdarzenia. W przypadku otrzymania komuni-
katu o dostarczeniu paczki skrypt czeka pięć minut, po czym wysyła
żądania do usług sieciowych firm kurierskich FedEx i UPS, aby dać
kurierowi czas na zmianę statusu przesyłki na centralnych serwerach tych
firm. Funkcja wykonuje następnie zapytanie na tabeli tracking bazy
danych packagedelivery.sqlite, aby uzyskać numery wszystkich śledzonych,
ale jeszcze niedostarczonych przesyłek. Znalezione numery są kolejno
wysyłane do odpowiednich usług sieciowych. W razie otrzymania po-
twierdzenia dostarczenia przesyłki pozytywna odpowiedź systemu firmy
kurierskiej jest rejestrowana w bazie danych wraz z datą tego potwier-
dzenia, a generowana wiadomość poczty elektronicznej jest uzupełniana
o stosowny dopisek (sama wiadomość jest następnie wysyłana za po-
mocą funkcji send_email).
To jest główna pętla tego skryptu. Działanie pętli rozpoczyna się od
wyczyszczenia ekranu, oczekiwania na komunikat "Delivery" lub "Empty"
wysłany przez moduł XBee połączony z płytką Arduino i wywołania
funkcji process_message w celu przetworzenia tego komunikatu.
Wykrycie naciśnięcia kombinacji klawiszy Ctrl-C powoduje przerwanie
wykonywania skryptu.
Skrypt należy zapisać w pliku packagedelivery.py i uruchomić za pomocą
polecenia python packagedelivery.py. W razie wystąpienia błędów należy
sprawdzić składnię i wcięcia w kodzie, ponieważ w języku Python formato-
wanie ma wpływ na interpretację kodu. Jeśli skrypt zostanie uruchomiony
bez żadnych problemów, możemy przystąpić do jego testowania.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
144  6.11. Testowanie skryptu przetwarzającego komunikaty o paczkach

6.11. Testowanie skryptu


przetwarzającego komunikaty
o paczkach
Skoro dysponujemy już gotowym skryptem Pythona, kontem klienta firmy
FedEx i (lub) UPS oraz zarejestrowanymi kluczami dostępu do interfejsów
API usług sieciowych tych firm kurierskich, możemy przystąpić do testów
funkcjonalnych szkicu i wspomnianego skryptu. W tabeli trackingstatus
bazy danych packagedelivery należy umieścić prawidłowe, aktualne numery
śledzonych przesyłek wysłanych za pośrednictwem firmy FedEx lub UPS.
Możemy użyć do tego celu wtyczki SQLite Manager dla przeglądarki in-
ternetowej Firefox, którą wcześniej wykorzystaliśmy także do tworzenia tabel
tej bazy danych. Wystarczy wybrać wtyczkę SQLite Manager z menu
Narzędzia przeglądarki Firefox, po czym otworzyć plik packagedelivery.sqlite.
W lewej kolumnie należy kliknąć tabelę trackingstatus, po czym zaznaczyć
zakładkę Browse & Search. Należy następnie kliknąć przycisk Edit, aby
dodać lub zmienić rekordy reprezentujące numery śledzonych przesyłek.
Jeśli wolimy korzystać z szybszego (ale też mniej atrakcyjnego wizualnie)
narzędzia wiersza poleceń sqlite3, numery śledzonych paczek możemy
dodać za pomocą następującego wyrażenia języka SQL (identyfikator
NUMER_ŚLEDZONEJ_PRZESYŁKI oczywiście należy zastąpić prawidłowym nume-
rem przesyłki dostarczanej przez firmę FedEx lub UPS):
sqlite> INSERT INTO tracking("tracking_number","description","delivery_status")\
VALUES ("NUMER_ŚLEDZONEJ_PRZESYŁKI", "Śledzona paczka","0");

Warto jeszcze sprawdzić, czy nowy rekord rzeczywiście został prawidłowo


dodany do tabeli tracking — wystarczy użyć następującego wyrażenia select:
sqlite> select * from tracking;
1|NUMER_ŚLEDZONEJ_PRZESYŁKI|Śledzona paczka|0|

Aby przetestować iteracyjne wyszukiwanie danych w tabeli przez skrypt języ-


ka Python, warto dodać ewentualne dodatkowe numery przesyłek dostar-
czanych przez firmy FedEx i UPS. Podczas testów można stosować wy-
myślone numery, które nie reprezentują paczek aktualnie występujących
w systemach śledzenia przesyłek firm kurierskich. W praktyce najlepszym
rozwiązaniem (przynajmniej z perspektywy testów) będzie umieszczenie
w bazie zarówno paczek w wysyłce, jak i przesyłek już dostarczonych —
dzięki temu będziemy mogli sprawdzić, czy skrypt prawidłowo aktualizuje
rekordy dla przesyłek, których odbiór został odpowiednio potwierdzony.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  145

Nadeszła chwila prawdy. Należy włączyć zasilanie płytki Arduino z podłą-


czonym modułem XBee. Musimy się też upewnić, że docelowy moduł XBee
jest połączony z komputerem za pomocą przewodu FTDI. Po sprawdzeniu
wszystkich połączeń możemy użyć polecenia python packagedelivery.py.
Należy teraz delikatnie nacisnąć czujnik siły nacisku i poczekać, aż skrypt
przetworzy zapytania dotyczące numerów przesyłek. Jeśli wszystko działa
prawidłowo, powinniśmy otrzymać wiadomość poczty elektronicznej z konta
usługi Gmail, które wybraliśmy do roli bramy SMTP. Wiadomość powinna
zawierać informacje o dostarczonych przesyłkach. Możemy ponownie użyć
zapytania select * from tracking; w wierszu poleceń narzędzia sqlite3, aby
sprawdzić, czy wartość w polu zmieniła się z dotychczasowej liczby 0 (false)
na wartość 1 (true) i czy odpowiedni znacznik czasowy (określający moment
właściwego dostarczenia paczki) został prawidłowo zarejestrowany w polu
deliver_time.

W razie błędu podczas działania tego skryptu lub w razie braku odpowiednich
wartości w bazie danych należy przywrócić oryginalny stan tabeli tracking
i zastosować dostępne metody diagnozowania tego skryptu (najprostszą
z nich jest umieszczenie w odpowiednich miejscach kodu wywołań funkcji
print()), aby sprawdzić, które miejsca kodu powodują problemy.

Po wielokrotnym udanym wykonaniu testów możemy przystąpić do instalacji


elementów sprzętowych tego systemu w wygodnym miejscu przed domem
(najlepiej położonym możliwie blisko gniazdka elektrycznego).

6.12. Instalacja systemu


Musimy najpierw wybrać właściwe miejsce dla płytki, pod którą zainstalujemy
czujnik siły nacisku. Pracownicy większości amerykańskich firm kurierskich
pozostawiają przesyłki przed drzwiami domu adresata, z lewej lub prawej
strony, tak aby nie blokować wejścia. Aby zasugerować kurierowi zostawianie
paczek w wybranym przez nas miejscu, wystarczy umieścić w widocznym
miejscu strzałkę lub inny znak wskazujący prostokątną płytkę, pod którą
umieściliśmy czujnik siły nacisku.
Jeszcze lepszym rozwiązaniem będzie zakup lub budowa specjalnego pojem-
nika na paczki z czujnikiem siły nacisku zainstalowanym na dnie. Istnieje
wiele niedrogich, wytrzymałych i wodoodpornych pojemników, które po
zamknięciu pokrywy mogą nawet pełnić funkcję ławy do siedzenia. Wy-
starczy odrobina dodatkowej pracy, aby także płytkę Arduino z modułem

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
146  6.13. Następne kroki

radiowym XBee umieścić w bezpiecznej, wodoodpornej obudowie, która


zostanie zamontowana wewnątrz pojemnika na paczki.
Elementy elektroniczne należy oczywiście zainstalować z boku, tak aby wci-
skanie większych paczek do właściwego pojemnika nie powodowało uszko-
dzeń. Warto też przygotować notatkę dla kurierów z prośbą o umieszczanie
przesyłek w tak przygotowanym pojemniku. W zależności od częstotliwości
otrzymywania paczek kurierzy operujący na danym terenie powinni dość
szybko przyzwyczaić się do nietypowej formy pozostawiania paczek.
Ponieważ wykrywacz paczek znajduje się w bezpośrednim sąsiedztwie głów-
nego wejścia, znalezienie w pobliżu zewnętrznego gniazdka elektrycznego
nie powinno stanowić żadnego problemu. Jeśli system znajduje się w miejscu
narażonym przez większość dnia na bezpośrednie działanie słońca, warto
nawet rozważyć zasilanie elementów elektronicznych baterią słoneczną
(tak jak w przypadku projektu ćwierkającego karmnika dla ptaków).
Jeśli wszystkie elementy są prawidłowo zainstalowane i zasilane, warto samo-
dzielnie przetestować wykrywacz. Należy wypróbować działanie systemu
dla paczek o różnych kształtach, wymiarach i wagach, aby sprawdzić, jak
nasza konfiguracja reaguje w poszczególnych scenariuszach. Zapewnienie
spójnego działania systemu może wymagać przesunięcia czujnika siły nacisku
w inne miejsce. Skuteczność wykrywania można znacznie poprawić, dodając
jeden lub nawet dwa dodatkowe czujniki siły nacisku (poprawa będzie
szczególnie widoczna w przypadku mniejszych paczek, które nie zawsze
będą trafiały na środek płytki).
Wykrywacz dostarczonych przesyłek jest teraz kompletny i gotowy do prze-
twarzania informacji o paczkach. Przy najbliższej okazji będziemy mogli
się przekonać, jak wygodny może być system informujący nas o długo wycze-
kiwanej przesyłce, która właśnie trafiła pod drzwi naszego domu.

6.13. Następne kroki


Wykrywacz paczek można dość łatwo rozbudować o elementy rozszerzające
jego możliwości poza powiadamianie o przychodzących przesyłkach ku-
rierskich. Oto kilka pomysłów na dalszy rozwój tego systemu.
 Bieżący projekt przygotowano z myślą o pojedynczej paczce — przed
przetworzeniem następnej paczki system musi wyzerować swój stan.
Szkic i skrypt języka Python można rozszerzyć o obsługę wielu pa-
czek dostarczanych przez wielu kurierów. Jeśli na przykład jeden

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 6. • Wykrywacz dostarczania paczek  147

kurier dostarcza paczkę, powodując przekroczenie wartości progowej,


wystarczy ustalić nową wartość progową, tak aby kolejna przesyłka
była przetwarzana i sprawdzana jeszcze przed zabraniem przez ad-
resata pierwszej paczki.
 W momencie przekroczenia wartości progowej czujnika siły nacisku
system może robić zdjęcie przesyłki i wysyłać je w formie załącznika do
wiadomości poczty elektronicznej z odpowiednim powiadomieniem.
 Bazę danych używaną przez skrypt Pythona można rozszerzyć o moż-
liwość przechowywania wyników zapytań adresowanych do usług
sieciowych firm kurierskich. Warto też rozważyć użycie frameworku
Django do stworzenia interfejsu użytkownika umożliwiającego analizę
danych o przesyłkach śledzonych i dostarczonych w przeszłości.
 Jeśli umieścimy czujnik siły nacisku pod wycieraczką, będziemy otrzy-
mywali informację o gościach jeszcze przed naciśnięciem dzwonka.
Aby zdalnie otwierać drzwi przed zaufanymi gośćmi, system należy
uzupełnić o kamerę internetową i elektryczny zamek (patrz rozdział 9.
zatytułowany „Zamek do drzwi sterowany przez Androida”).
 Czytelnicy, którzy szczególnie często otrzymują paczki, mogą zasto-
sować alternatywne formy powiadomień (poza pocztą elektroniczną
i Twitterem). Wystarczy zaimplementować usługę dostarczania po-
wiadomień dla systemu Android lub aplikację przystosowaną do
współpracy z usługą iMessage dla systemu iOS, która będzie na-
tychmiast powiadamiała o dostarczonych paczkach.
 Wymiary wykrywacza można łatwo zmniejszyć, stosując konfigurację
płytki Arduino Nano i modułu XBee opisaną w rozdziale 5. zatytu-
łowanym „Ćwierkający karmnik dla ptaków”. Wystarczy zastąpić
czujnik siły nacisku czujnikiem ruchu PIR, aby otrzymywać powia-
domienia o umieszczeniu listów w skrzynce pocztowej.
 Wykrywacz paczek można połączyć z systemem psa stróżującego z roz-
działu 4. zatytułowanego „Elektryczny pies stróżujący”. Wskazania
czujnika siły nacisku można wykorzystać w roli sygnału dla psa stróżu-
jącego do szczekania i nerwowych ruchów za zasłoną. Po połącze-
niu tego systemu z laserem i dalmierzem precyzyjnie określającym po-
łożenie celu dysponowalibyśmy mechanizmem witania gości na bazie
najnowszych technologii.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
148  6.13. Następne kroki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7.
Internetowy
włącznik światła

W
yobraźmy sobie, że po długim dniu w pracy wracamy do domu
i włączamy światła, telewizję i wszystkie urządzenia jednocze-
śnie, korzystając z aplikacji zainstalowanej na naszym telefonie
komórkowym. System może obejmować wszystkie urządzenia elektryczne
zasilane przez standardowe gniazdka.
W tym rozdziale spróbujemy urzeczywistnić to marzenie przy użyciu kompu-
tera podłączonego do internetu, aplikacji internetowej na bazie frameworku
Ruby on Rails, aplikacji zainstalowanej na smartfonie z systemem Android
oraz dużo starszej technologii znanej jako X10. Zbudujemy aplikację
zdalnego włącznika światła dla systemu Android, która umożliwi nam włą-
czanie i wyłączanie światła za pośrednictwem ekranu dotykowego smartfonu
(patrz rysunek 7.1 zatytułowany „Łatwe sterowanie oświetleniem domu
i urządzeniami elektrycznymi”). Po zakończeniu tego projektu będziemy
mogli sterować urządzeniami domowymi nie tylko z dowolnego miejsca
w domu, ale także z każdego miejsca, w którym będziemy mieli dostęp do
internetu (o ile serwer z aplikacją na bazie frameworku Rails będzie pu-
blicznie dostępny).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
150  7.1. Czego potrzebujemy

Rysunek 7.1. Łatwe sterowanie oświetleniem domu i urządzeniami


elektrycznymi… za pośrednictwem własnej aplikacji
dla smartfonów

7.1. Czego potrzebujemy


X10 to nazwa firmy, która od wielu lat sprzedaje własne zastrzeżone włącz-
niki elektryczne. Co ciekawe, technologia stosowana podczas produkcji tych
włączników nie uległa zasadniczym zmianom od wprowadzenia na rynek
tych produktów ponad trzydzieści lat temu. Mimo swojego wieku włączniki
elektryczne X10 wciąż stanowią jedną z najważniejszych technologii au-
tomatyzacji domów — o ich popularności decyduje niska cena i możliwość
wysyłania i planowania sygnałów włączania i wyłączania zasilania za po-
mocą komputera.
Zamiast używać niewygodnej oryginalnej aplikacji do sterowania urządze-
niami X10 dla systemu Windows, skorzystamy z dostępnego za darmo na-
rzędzia open source nazwanego Heyu. Narzędzie Heyu (stworzone i roz-
wijane przez Daniela Suthersa i Charlesa Sullivana) oferuje interfejs wier-
sza poleceń do monitorowania i wysyłania rozmaitych poleceń protokołu

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  151

X10 do interfejsu CM11A. Odpowiednie rozkazy są następnie przeka-


zywane do wskazanych włączników X10.
Do realizacji tego projektu najlepiej nadaje się system operacyjny Linux lub
Mac, ponieważ w obu tych systemach można łatwo kompilować kod źródło-
wy bez konieczności wprowadzania dodatkowych modyfikacji. Nie istnieje
wersja narzędzia Heyu przeniesiona do systemu Windows i w najbliższej
przyszłości nie należy oczekiwać powstania takiej wersji. Czytelnicy korzy-
stający z systemu Windows powinni rozważyć uruchomienie jakiejś dys-
trybucji systemu Linux na maszynie wirtualnej za pomocą odpowiedniego
programu, na przykład VirtualBox1.
Do budowy tego projektu będą potrzebne następujące elementy (patrz
rysunek 7.2 zatytułowany „Części internetowego włącznika światła”):

Rysunek 7.2. Części internetowego włącznika światła

1. Interfejs komputerowy X10 CM11A2 — należy pamiętać, że


w przeciwieństwie do starszego interfejsu CM11A, który korzystał
z portu szeregowego, model X10 CM15A łączy się z komputerem
za pośrednictwem portu USB i jako taki nie współpracuje z opro-
gramowaniem Heyu. Więcej informacji na ten temat można znaleźć
w sekcji pytań i odpowiedzi produktu Heyu3.

1
https://www.virtualbox.org/
2
http://www.x10.com
3
http://www.heyu.org/heyu_faq.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
152  7.1. Czego potrzebujemy

2. Standardowy włącznik ścienny X10 PLW01.


3. Przewód łączący port szeregowy z portem USB.
4. Telefon lub tablet z systemem operacyjnym Android (na tym
urządzeniu będzie uruchamiana aplikacja kliencka projektu inter-
netowego włącznika światła).
5. Komputer (nie ma go na zdjęciu), najlepiej z systemem Linux lub
Mac OS oraz zainstalowanym językiem Ruby 1.8.7 lub nowszym.
Podczas realizacji tego projektu będziemy jeszcze potrzebowali następują-
cego oprogramowania:
 narzędzia Heyu 2.9.3 lub nowszego4,
 frameworku Ruby on Rails 3.0 lub nowszego5,
 środowiska programowania Eclipse6,
 zestawu narzędzi Android SDK 1.5 lub nowszego7,
 wtyczki Android Development Tools (ADK) dla środowiska Eclipse8.

Sercem konfiguracji złożonej z urządzeń X10 sterowanych komputerowo


jest moduł sterownika. Moduł udostępnia interfejs niezbędny do przesyłania
rozkazów do urządzeń X10 oraz informacji zwrotnych (na przykład o wykry-
ciu ruchu) przez urządzenia X10 oferujące odpowiednie rozwiązania. Istnieje
wiele interfejsów tego typu, na przykład X10 Firecracker (znany także
jako CM17A) oraz oryginalny interfejs komputerowy X10 oznaczony sym-
bolem CM11A. Większość dostępnych obecnie programów open source
do sterowania urządzeniami X10 obsługuje oba wymienione interfejsy
(i wiele innych interfejsów), jednak z mojego doświadczenia wynika, że ob-
sługa interfejsu CM11A jest zdecydowanie najbardziej popularna. Właśnie
dlatego na potrzeby tego projektu polecam stosowanie interfejsu CM11A.
Dysponujemy już niezbędnym sprzętem i oprogramowaniem, zatem możemy
przystąpić do analizy technik łączenia wszystkich tych elementów, tak aby
było możliwe włączanie i wyłączanie światła z poziomu aplikacji systemu
Android działającej na smartfonie.

4
http://heyu.org
5
http://www.rubyonrails.com
6
http://eclipse.org
7
http://developer.android.com/sdk
8
http://developer.android.com/sdk/eclipse-adt.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  153

Jak działają urządzenia X10?


Podstawową zasadą działania urządzeń X10 jest wysyłanie unika-
towych impulsów za pośrednictwem istniejących przewodów elek-
trycznych do urządzeń zdolnych do interpretacji otrzymywanych
kodów i właściwego reagowania na te sygnały. Każde urządzenie
ma przypisywany własny unikatowy kod (reprezentujący dany dom
i samo urządzenie — na przykład H8). Warunkiem aktywacji włącznika
zasilania X10 jest wysłanie tego unikatowego identyfikatora przez
interfejs sterujący podłączony do gniazdka elektrycznego. Zastosowa-
nie istniejącej instalacji elektrycznej sprawia, że sterowanie urządze-
niami sprowadza się do wysyłania (za pośrednictwem interfejsu ste-
rującego) sekwencji impulsów trafiających do właściwych urządzeń
przez te przewody. Docelowe urządzenie X10 rozpoznaje adreso-
wane do siebie impulsy na podstawie unikatowego kodu adresata.
Kod funkcji może mieć postać prostego rozkazu włączenia lub wy-
łączenia, który przełącza stan docelowego modułu X10. Zmiana te-
go stanu powoduje z kolei włączenie lub wyłączenie zasilania lampy
lub innego urządzenia podłączonego do tego modułu. Oprócz pod-
stawowych kodów włączania i wyłączania zasilania istnieje możliwość
wysyłania wielu innych rozkazów, które mogą na przykład powodo-
wać przyciemnienie światła do 25 procent maksymalnego natężenia
czy nawet jednoczesne włączenie lub wyłączenie wszystkich urzą-
dzeń X10. Bardziej szczegółowe wyjaśnienie możliwych rozwiązań
wraz z listą dostępnych kodów można znaleźć na stronie interne-
towej narzędzia Heyu9.

7.2. Budowa rozwiązania


Warunkiem zdalnego sterowania lampami kontrolowanymi przez urządzenia
X10 jest przystosowanie do wspólnego działania wielu bardzo różnych
technologii. Zastosujemy następujące rozwiązania:
1. Przetestujemy interfejs komputerowy i moduły technologii X10 za
pomocą aplikacji Heyu.

9
http://www.heyu.org/docs/protocol.txt

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
154  7.3. Łączenie

2. Opracujemy aplikację na bazie frameworku Ruby on Rails, która


będzie pełniła funkcję internetowego interfejsu użytkownika dla
wybranego podzbioru poleceń narzędzia Heyu.
3. Utworzymy aplikację mobilną dla systemu Android, która będzie
komunikowała się z aplikacją na bazie frameworku Rails w celu
włączania i wyłączania światła za pomocą przełącznika dostępne-
go na ekranie dotykowym smartfonu lub tabletu.
Zacznijmy od połączenia elementów sprzętowych technologii X10 i spraw-
dzenia, czy możemy sterować tymi urządzeniami za pośrednictwem apli-
kacji Heyu.

7.3. Łączenie
Interfejs X10 CM11A należy podłączyć do gniazdka elektrycznego nie-
daleko komputera, tak aby przewód tego interfejsu sięgał komputera. Po-
nieważ interfejs CM11A używa 9-wtykowego złącza szeregowego i wymaga
zastosowania adaptera USB – port szeregowy wraz z odpowiednim ste-
rownikiem (patrz rysunek 7.3 zatytułowany „Interfejs X10 CM11A ste-
rujący internetowym włącznikiem światła”). Użytkownicy komputerów
z systemem operacyjnym Mac OS X 10.6 lub nowszym mogą pobrać ste-
rownik PL-2303 z witryny internetowej Prolific10. Komputery z najnowszymi
dystrybucjami systemu Linux nie powinny mieć najmniejszych problemów
z identyfikacją interfejsu PL-2303 i nawiązywaniem połączenia z tym in-
terfejsem.
Należy teraz podłączyć adapter USB – port szeregowy do komputera i do
interfejsu CM11A (podłączonego wcześniej do prądu). Musimy jeszcze
określić urządzenie reprezentujące port szeregowy (urządzenie przypisane
do tego interfejsu przez system operacyjny). W tym celu należy znaleźć od-
powiednie urządzenie tty w katalogu /dev za pomocą polecenia ls /dev/tty*
wpisanego w oknie terminala. Jeszcze prostszym rozwiązaniem jest uru-
chomienie środowiska Arduino IDE i wybranie opcji Tools/Serial Port.

10
http://www.prolific.com.tw/eng/downloads.asp?ID=31l

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  155

Rysunek 7.3. Interfejs X10 CM11A sterujący internetowym włącznikiem


światła

W moim przypadku interfejs CM11A jest reprezentowany przez urzą-


dzenie /dev/tty.usbserial (patrz rysunek 7.4 zatytułowany „Adapter USB
– port szeregowy widoczny w menu Tools środowiska Arduino IDE”).
Warto zwrócić uwagę na ścieżkę do nowego urządzenia — ścieżka będzie
nam potrzebna w odwołaniach do tego urządzenia w pliku konfiguracyjnym
narzędzia Heyu.

Rysunek 7.4. Adapter USB – port szeregowy widoczny w menu Tools


środowiska Arduino IDE

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
156  7.3. Łączenie

Skoro interfejs CM11A jest już podłączony do komputera i prawidłowo


rozpoznawany przez system operacyjny, możemy pobrać kod źródłowy
narzędzia Heyu z witryny internetowej Heyu.org i rozpakować plik .tar za
pomocą polecenia tar -zxvf heyu-2.9.3.tar.gz. W następnym kroku należy
wykonać cykl poleceń ./Configure; make; make install, aby zainstalować
skompilowaną aplikację. Przed przystąpieniem do dalszych kroków użyt-
kownicy systemu Mac muszą zainstalować narzędzia programistyczne tego
systemu11. Użytkownicy systemu Linux powinni się upewnić, że dysponują
niezbędnym kompilatorem gcc i narzędziem make. Na przykład w przypadku
dystrybucji Linuksa na bazie systemu Debian (jak Ubuntu) należy użyć
polecenia sudo apt-get install build-essential w oknie terminala, aby
pobrać i zainstalować narzędzia kompilatora i linkera. Po zainstalowaniu
potrzebnych elementów wystarczy zastosować standardową sekwencję poleceń
./Configure, make i sudo make install, aby skompilować kod źródłowy i zain-
stalować plik wykonywalny heyu wraz z niezbędnymi bibliotekami.
Oprócz pliku wykonywalnego heyu w katalogu /etc/heyu zostanie zainstalo-
wany także plik konfiguracyjny x10.conf. Należy teraz otworzyć ten plik
w trybie edycji (na przykład za pomocą polecenia sudo vi /etc/heyu/x10.conf).
Plik konfiguracyjny x10.conf zawiera wiele ciekawych opcji, jednak z na-
szego punktu widzenia najważniejsza jest zidentyfikowana wcześniej ścieżka
do portu szeregowego, do którego podłączono interfejs CM11A.
# Port szeregowy, do którego podłączono interfejs CM11A.
# Ścieżką domyślną jest /dev/ttyS0.
TTY /dev/tty.usbserial

Wartość reprezentującą port szeregowy, do którego podłączono urządzenie


CM11A, można ustawić za pomocą ulubionego edytora tekstu. Po wprowa-
dzeniu zmiany należy zapisać plik i sprawdzić ustawienia, uruchamiając silnik
narzędzia Heyu w oknie terminala za pomocą następującego polecenia:
> heyu engine

Jeśli nie zostaną zgłoszone żadne błędy, jesteśmy na dobrej drodze —


demon silnika znalazł odpowiednie urządzenie i prawidłowo działa w tle.
Możemy też użyć polecenia heyu info, aby uzyskać więcej informacji na
temat konfiguracji narzędzia Heyu. Warto teraz wpisać w tym samym oknie
terminala następujące polecenie:
> heyu monitor

11
http://developer.apple.com/technologies/tools/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  157

W ten sposób możemy monitorować komunikację interfejsu CM11A


z pozostałymi urządzeniami X10. Jeśli dla włącznika ściennego PLW01
ustawiono kod domu H3, wystarczy teraz wpisać następujące polecenie:
> heyu on h3

Polecenie powinno włączyć ten włącznik i zamknąć obwód obejmujący wy-


brane urządzenie elektryczne (na przykład lampę zawieszoną pod sufi-
tem). Także w oknie terminala, w którym uruchomiliśmy wcześniej proces
monitorowania narzędzia Heyu, powinny zostać wyświetlone następujące
komunikaty:
07/25 12:45:34 sndc addr unit 3 : hu H3 (_no_alias_)
07/25 12:45:34 sndc func On : hc H

Włącznik można teraz wyłączyć, wysyłając polecenie off do urządzenia H3:


> heyu off h3
07/25 12:50:17 sndc addr unit 3 : hu H3 (_no_alias_)
07/25 12:50:18 sndc func Off : hc H

Jeśli wymienione polecenia nie włączą ani nie wyłączą światła, warto spraw-
dzić inny moduł X10, na przykład AM486 Appliance. Jeśli także ten
moduł nie zadziała prawidłowo, należy spróbować umieścić interfejs kom-
puterowy X10 bliżej włącznika ściennego (najlepiej w taki sposób, aby oba
elementy były podłączone do przewodów w tym samym pomieszczeniu).
Zdecydowana większość problemów, które napotykałem podczas realizacji
projektów na bazie technologii X10, miała bezpośredni związek z charakte-
rem samego protokołu X10, gdzie obowiązuje zasada „odpal i zapomnij”.
Jeśli podejrzewamy, że źródłem problemu może być niewłaściwe działanie
urządzeń X10, warto wymienić wybrane urządzenia i sprawdzić, czy nowe
elementy cokolwiek zmieniły. Być może warto poprosić o pomoc elektryka,
który sprawdzi ewentualne zakłócenia i inne problemy z instalacją elek-
tryczną mogące utrudniać przekazywanie impulsów protokołu X10 po-
między interfejsem CM11A a stosowanymi modułami X10.
Po sprawdzeniu, czy komputer komunikuje się z interfejsem CM11A za
pośrednictwem wiersza poleceń narzędzia Heyu, możemy zaimplementować
dostępne rozkazy w ramach aplikacji internetowej. Odpowiednio zapro-
jektowana aplikacja internetowa zapewni łatwy dostęp do punktów koń-
cowych technologii X10 z poziomu przeglądarki internetowej (a docelowo
także z poziomu aplikacji dla systemu Android).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
158  7.4. Pisanie kodu klienta w formie aplikacji internetowej

Problemy związane z technologią X10


Mimo że X10 jest najczęściej stosowaną (i najintensywniej reklamo-
waną) technologią spośród niedrogich rozwiązań w zakresie automa-
tyzacji domów, warto pamiętać o ograniczeniach tej technologii.
Oprócz problemów wynikających z zasady „odpal i zapomnij” obo-
wiązującej w protokole X10 (urządzenie, które wysyła sygnały, nie
może sprawdzać, czy te sygnały dotarły do adresata i czy żądane dzia-
łania zostały zrealizowane) jednym z najważniejszych problemów jest
przesyłanie sygnałów za pośrednictwem domowej sieci elektrycznej.
Domowe instalacje elektryczne są narażone na zakłócenia, a jakość
przesyłania impulsów z czasem spada. Na skuteczność modułów
X10 mogą mieć wpływ także popularne listwy antyprzepięciowe
i inne zabezpieczenia, które traktują impulsy generowane przez te
urządzenia tak jak inne zakłócenia i próbują filtrować zniekształcenia,
przywracając oryginalne parametry instalacji. W zależności od od-
ległości, na którą musimy przesyłać sygnały protokołu X10, możemy
stanąć przed koniecznością instalacji dodatkowych modułów X10,
które zagwarantują prawidłowe dostarczanie rozkazów do właściwych
odbiorców. Mimo tych utrudnień standard X10 wciąż pozostaje
najbardziej efektywną kosztowo i najprostszą w implementacji tech-
nologią automatyzacji domu. Chociaż od wprowadzenia technologii
X10 na rynek minęło ponad trzydzieści lat i w tym czasie opracowano
wiele konkurencyjnych rozwiązań, żadne z nich nie może się równać
z tą technologią w kwestii kosztów i łatwości instalacji.

7.4. Pisanie kodu klienta


w formie aplikacji internetowej
Internetowy włącznik światła wymaga utworzenia prostej aplikacji na ba-
zie frameworku Ruby on Rails, która będzie zapewniała odpowiedni in-
terfejs użytkownika (początkowo za pośrednictwem przeglądarki interne-
towej). Ponieważ docelowym rozwiązaniem będzie obsługa włącznika za
pośrednictwem aplikacji dla systemu Android, nie będziemy tracić zbyt
dużo czasu na opracowywanie interfejsu użytkownika w formie aplikacji
internetowej.
Sam framework Rails najlepiej działa na komputerach z systemami Mac
i Linux (jest nawet domyślnie instalowany w systemie Mac OS X 10.6).
Warto jednak pamiętać, że wraz z systemem operacyjnym nie jest instalo-

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  159

wana najnowsza wersja tego frameworku. Ponieważ ten projekt wymaga


frameworku Rails 3.0 lub nowszego, poniższe instrukcje i wskazówki nie
sprawdzą się w przypadku starszych wersji tego frameworku. Aby pobrać
i skonfigurować najnowszą wersję frameworku Ruby on Rails na lokalnym
komputerze, należy postępować zgodnie z instrukcjami zawartymi na stro-
nie internetowej tego frameworku.
Po zainstalowaniu frameworku aplikacji sieciowych Rails należy utworzyć
nowy katalog, przejść do tego katalogu i utworzyć nowy projekt na bazie
frameworku Rails za pomocą następujących poleceń:
> mkdir ~/projects/ruby/rails/homeprojects/
> cd ~/projects/ruby/rails/homeprojects
> rails new x10switch
create
create README
create Rakefile
create config.ru
create .gitignore
create Gemfile
create app
create app/controllers/application_controller.rb
create app/helpers/application_helper.rb
create app/mailers
create app/models
...
create vendor/plugins
create vendor/plugins/.gitkeep

Należy teraz przejść do nowego katalogu x10switch i utworzyć nowy kon-


troler o nazwie command zawierający akcję nazwaną cmd() — za pomocą
tej akcji będziemy zarządzali interakcją pomiędzy interfejsem aplikacji
internetowej a aplikacją terminala Heyu.
> cd x10switch
> rails generate controller Command cmd

create app/controllers/command_controller.rb
route get "command/cmd"
invoke erb
create app/views/command
create app/views/command/cmd.html.erb
invoke test_unit
create test/functional/command_controller_test.rb
invoke helper
create app/helpers/command_helper.rb
invoke test_unit
create test/unit/helpers/command_helper_test.rb

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
160  7.4. Pisanie kodu klienta w formie aplikacji internetowej

Należy teraz znaleźć plik app/controllers/command_controller.rb — w pliku


tym należy umieścić kod sprawdzający parametry on i off oraz podejmujący
odpowiednie działania:
class CommandController < ApplicationController
def cmd
@result = params[:cmd]

if @result == "on"
%x[/usr/local/bin/heyu on h3]
end

if @result == "off"
%x[/usr/local/bin/heyu off h3]
end
end
end

Konstrukcja %x służy do uruchamiania aplikacji z argumentami wiersza


poleceń. Oznacza to, że wyrażenie %x[/usr/local/bin/heyu on h3] powoduje
wysłanie przez narzędzie Heyu kodu rozkazu on do włącznika X10 ozna-
czonego kodem H3. Podobnie konstrukcja %x[/usr/local/bin/heyu off h3]
powoduje wyłączenie tego samego włącznika.
Musimy jeszcze otworzyć do edycji plik app/views/command/cmd.html.erb
i umieścić w odpowiednim miejscu następujący wiersz (jest to wbudowany
kod języka Ruby wyświetlający wynik żądania On i Off):
Światło powinno teraz być w stanie <%= @result %>.

Aplikację na bazie frameworku Rails można by oczywiście rozszerzyć


o atrakcyjny, przyjazny interfejs użytkownika dostępny za pośrednictwem
pliku public/index.html oraz o bardziej wyczerpujące komunikaty opisujące
skutki podejmowanych działań — implementację odpowiednich rozwiązań
pozostawiam zainteresowanym czytelnikom. Ponieważ włącznik docelowo
ma być kontrolowany za pośrednictwem klienckiej aplikacji mobilnej, nie
ma sensu inwestowanie czasu w budowę wyszukanego interfejsu użytkownika
aplikacji internetowej, której praktycznie w ogóle nie będziemy używali.
Należy jeszcze zmodyfikować plik config/routes.rb i zastąpić wiersz get
"command/cmd"następującą konstrukcją:
match "/command/:cmd", :to => 'command#cmd'

W ten sposób wymuszamy na aplikacji na bazie frameworku Rails właściwy


sposób interpretacji żądań przychodzących jako rozkazów włączania i wyłą-
czania. Po zapisaniu tego pliku możemy wreszcie przystąpić do pierwszych
testów!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  161

Podczas konfigurowania nowszej wersji frameworku Ruby on Rails (na


przykład Rails 3.1) w systemie operacyjnym Linux być może będziemy
musieli zainstalować kilka dodatkowych pakietów (w terminologii języka
Ruby nazywanych klejnotami — ang. gem) potrzebnych do uruchomienia
tego frameworku. W tym celu należy otworzyć do edycji plik Gemfile wy-
generowany w katalogu x10switch i dodać następujące wiersze:
gem 'execjs'
gem 'therubyracer'

Po zapisaniu zmian należy wpisać następujące polecenie:


> bundle install

Polecenie spowoduje pobranie i instalację dodatkowych plików używa-


nych przez silnik JavaScriptu w ramach frameworku Rails 3.1. Po udanej
instalacji obu klejnotów możemy przystąpić do uruchamiania i testowania
naszej aplikacji X10switch na bazie frameworku Rails.

7.5. Testowanie klienta


aplikacji internetowej
Po połączeniu interfejsu komputerowego X10 z portem szeregowym kom-
putera i przygotowaniu niezbędnej konfiguracji możemy uruchomić serwer
i aplikację na bazie frameworku Rails 3 za pomocą następujących poleceń:
> cd ~/projects/ruby/rails/homprojects/x10switch
> rails s

=> Booting WEBrick


=> Rails 3.0.5 application starting in development on http://0.0.0.0:3000
=> Call with -d to detach
=> Ctrl-C to shutdown server
[2011-03-18 16:49:31] INFO WEBrick 1.3.1
[2011-03-18 16:49:31] INFO ruby 1.8.7 (2009-06-12) [universal-darwin10.0]
[2011-03-18 16:49:31] INFO WEBrick::HTTPServer#start: pid=10313 port=3000

Należy teraz otworzyć przeglądarkę internetową na lokalnym komputerze


i wpisać następujący adres:
http://localhost:3000/command/on

Jeśli wszystko działa prawidłowo, w oknie przeglądarki powinien zostać


wyświetlony komunikat „Światło powinno teraz być w stanie on” (patrz
rysunek 7.5 zatytułowany „Strona wyświetlona w przeglądarce internetowej
powinna informować o bieżącym stanie światła”).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
162  7.6. Pisanie kodu klienta dla systemu Android

Rysunek 7.5. Strona wyświetlona w przeglądarce internetowej powinna


informować o bieżącym stanie światła

Jeszcze ważniejsze jest wysłanie przez narzędzie Heyu polecenia do urzą-


dzenia X10, któremu przypisano kod H3. Innymi słowy, w wyniku tego
testu powinno się włączyć odpowiednie światło. Aby wyłączyć to światło,
wystarczy wpisać w polu adresu przeglądarki następujące polecenie:
http://localhost:3000/command/off

Jeśli światło zgasło, możemy być z siebie naprawdę dumni! Prawidłowe


włączanie i wyłączanie światła oznacza, że wszystko zostało odpowiednio
połączone i zaprogramowane. Jeśli zdecydujemy się rozbudować aplikację
Rails o obsługę dodatkowych poleceń, wystarczy w kodzie klasy CommandCon-
troller dodać więcej wyrażeń if @result == ... zawierających polecenia,
które mają być wysyłane za pośrednictwem narzędzia Heyu. Dodatkowe
polecenia mogą polegać na ściemnianiu światła do 30% maksymalnej
jasności, włączaniu urządzeń elektrycznych na pewien czas oraz zarządza-
niu wieloma różnymi kombinacjami włączania i wyłączania urządzeń.
Czytelników zainteresowanych lepszym poznaniem technik programowa-
nia aplikacji internetowych przy użyciu frameworku Ruby on Rails zachęcam
do lektury książki Programming Ruby: The Pragmatic Programmer’s Guide
[TFH09].
Skoro serwer aplikacji internetowej działa prawidłowo, czas przystąpić do
budowy mobilnego klienta.

7.6. Pisanie kodu klienta


dla systemu Android
Część czytelników zapewne zastanawia się, jaki jest sens budowy aplikacji
klienckiej dla systemu Android, skoro możemy użyć napisanej aplikacji inter-
netowej za pośrednictwem przeglądarki dostępnej w tym systemie. Jeśli
jedynym celem budowanego systemu jest włączanie i wyłączanie światła,
dodatkowy klient w formie aplikacji systemu Android rzeczywiście nie jest
potrzebny. Interfejs aplikacji internetowej w dotychczasowej formie spełnia

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  163

swoją funkcję i może być dodatkowo rozbudowany o elementy technologii


AJAX i atrakcyjne efekty wizualne HTML5/CSS3. Jeśli jednak aplikacja
ma oferować dodatkowe funkcje, na przykład włączać zasilanie na podstawie
odległości od telefonu lub uruchamiać usługę systemu Android monitorującą
przychodzące zdarzenia X10 (na przykład zdarzenia wykrycia ruchu) i od-
twarzać dźwięk alarmowy na telefonie, sama dynamiczna strona internetowa
nie wystarczy.
Czytelnicy, którzy jeszcze tego nie zrobili, powinni teraz pobrać, zainstalować
i skonfigurować środowisko programowania Eclipse, najnowszy pakiet narzędzi
Android SDK oraz wtyczkę ADK dla środowiska Eclipse. Szczegółowe
instrukcje można znaleźć na stronie internetowej pakietu narzędzi Android
SDK12.
Musimy jeszcze utworzyć urządzenie wirtualne systemu Android (ang. An-
droid Virtual Device — AVD), które umożliwi nam testowanie aplikacji
klienckiej w emulatorze Androida przed wysłaniem tego programu na wła-
ściwe urządzenie z tym systemem13. Zachęcam do utworzenia systemu AVD
emulującego system operacyjny Android 1.5 (API Level 3), czyli wersję
zainstalowaną na największej liczbie telefonów z systemem Android.
Po uruchomieniu środowiska programowania Eclipse należy wybrać opcję
File/New/Android Project. W zależności od stosowanej wersji środowiska
Eclipse odpowiednia opcja Android Project może być dostępna po wybraniu
opcji File/New/Other/Android. Projekt należy nazwać LightSwitch, a z listy
Build Target należy wybrać system operacyjny Android 1.5. W zależności
od poziomu urządzenia z systemem Android, na którym chcemy wdrożyć
budowaną aplikację, możemy wybrać wyższą wersję Androida. Ponieważ
jednak program LightSwitch będzie dość prosty, system Android 1.5 powi-
nien w zupełności wystarczyć w roli platformy dla tej przykładowej aplikacji.
W obszarze Properties należy wpisać nazwę aplikacji (w tym przypadku Light
Switch) oraz nazwę pakietu (w tym przypadku com.mysampleapp.lightswitch).
Należy też zaznaczyć pole wyboru Create Activity i wpisać nazwę Light-
Switch. Istnieje możliwość określenia minimalnej wersji pakietu SDK
(w polu Min SDK Version), jednak w tym przypadku tworzymy aplikację
dla jednej z najbardziej popularnych wersji Androida, zatem możemy bez
obaw pozostawić to pole puste. Przed przystąpieniem do dalszych zadań

12
http://developer.android.com/sdk
13
http://developer.android.com/guide/developing/devices/managing-avds.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
164  7.6. Pisanie kodu klienta dla systemu Android

należy sprawdzić, czy zawartość okna dialogowego New Android Project


wygląda tak jak na rysunku 7.6 zatytułowanym „Okno dialogowe nowego
projektu dla systemu Android z ustawionymi parametrami”.

Rysunek 7.6. Okno dialogowe nowego projektu dla systemu Android


z ustawionymi parametrami

Bardziej doświadczeni programiści aplikacji dla systemu Android, którzy


wypracowali odpowiednie praktyki testowania swoich rozwiązań, zapewne
klikną teraz przycisk Next, aby skonfigurować zasoby na potrzeby odpowied-
niego projektu testowego. Z uwagi na ograniczenia czasu i miejsca przystą-
pimy do realizacji właściwego projektu i od razu klikniemy przycisk Finish.
Po wygenerowaniu szkieletu kodu aplikacji Light Switch przez wtyczkę An-
droid Development Tools Eclipse należy dwukrotnie kliknąć plik main.xml
w folderze res/layout, aby otworzyć ten plik w edytorze formularzy Androida.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  165

Należy przeciągnąć kontrolkę ToggleButton z palety widgetów formularza


(Form Widgets) na układ graficzny pliku main.xml. Na tym etapie nie musimy
się martwić o idealne położenie kontrolki. W tym przypadku działanie aplika-
cji po kliknięciu tego przycisku jest dużo ważniejsze niż wygląd programu.
Ponieważ aplikacja nie wymaga żadnych dodatkowych elementów poza pod-
stawowymi funkcjami znanymi już z wcześniejszych wydań systemu opera-
cyjnego Android, możemy zmienić wersję tego systemu, wybierając opcję
Android 1.5 z listy rozwijanej widocznej w prawym górnym rogu edytora
formularza. Możemy oczywiście usunąć domyślny element Hello world
typu TextView z projektowanego układu. Po zakończeniu projektowania ukła-
du jego struktura powinna przypominać tę pokazaną na rysunku 7.7 zatytu-
łowanym „Układ graficznego formularza aplikacji Light Switch”. Należy
teraz zapisać plik main.xml.

Rysunek 7.7. Układ graficznego formularza aplikacji Light Switch

Należy teraz rozwinąć węzeł src/com.mysampleapp.lightswitch i dwukrotnie


kliknąć plik LightSwitch.java. Ponieważ chcemy użyć widgetu ToggleSwitch,
musimy najpierw zaimportować klasę android.widget.ToggleButton.
Musimy następnie dodać biblioteki java.net.URL i java.io.InputStream,
ponieważ będziemy tworzyli obiekty klasy URL przekazywane do obiektu
klasy InputStream języka Java. Sekcja wyrażeń importujących niezbędne
biblioteki w pliku LightSwitch.java powinna mieć następującą postać:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
166  7.6. Pisanie kodu klienta dla systemu Android

package com.mysampleapp.lightswitch;
import android.app.Activity;
import android.os.Bundle;
import android.widget.ToggleButton;
import android.view.View;
import java.net.URL;
import java.io.InputStream;

Możemy teraz przystosować klasę LightSwitch do obsługi kontrolki typu


ToggleSwitch — w tym celu musimy znaleźć odpowiedni obiekt według
identyfikatora dla zdarzenia OnCreate klasy LightSwitch i dodać metodę moni-
torującą zdarzenia włączania i wyłączania tego włącznika:
public class LightSwitch extends Activity {
/** Metoda wywoływana podczas pierwszego tworzenia obiektu czynności. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
final String my_server_ip_address_and_port_number =
"192.168.1.100:3344";
final ToggleButton toggleButton =
(ToggleButton) findViewById(R.id.toggleButton1);
toggleButton.setOnClickListener(new View.OnClickListener()
{
public void onClick(View v) {
if (toggleButton.isChecked()) {
try {
final InputStream is = new URL("http://"+
adres_ip_i_numer_portu_serwera +"/command/on").openStream();
}
catch (Exception e) {
}
} else {
try {
final InputStream is = new URL("http://"+
adres_ip_i_numer_portu_serwera +"/command/off").openStream();
}
catch (Exception e) {
}
}
}
});
}
}

Łańcuch adres_ip_i_numer_portu_serwera należy oczywiście zastąpić adresem


IP i numerem portu, na którym została wdrożona aplikacja na bazie frame-
worku Rails napisana w podrozdziale 7.4 „Pisanie kodu klienta w formie
aplikacji internetowej”. To wszystko! Warto teraz uruchomić tę aplikację
w emulatorze systemu Android, aby upewnić się, że może być prawidłowo
kompilowana i prawidłowo wyświetla formularz na ekranie.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  167

7.7. Testowanie aplikacji klienckiej


dla systemu Android
Najwyższy czas przetestować tę aplikację z prawdziwym włącznikiem światła
X10. Jeśli aplikacja internetowa na bazie frameworku Rails działa zgod-
nie z naszymi założeniami, wystarczy uruchomić serwer tej aplikacji w tej
samej sieci lub podsieci, w której działa emulator systemu Android (patrz
rysunek 7.8 zatytułowany „Uruchamianie aplikacji Light Switch”).

Rysunek 7.8. Uruchamianie aplikacji Light Switch

Należy użyć tego samego numeru portu, który zdefiniowano w ramach


łańcucha adres_ip_i_numer_portu_serwera w kodzie aplikacji dla systemu
Android. Jeśli na przykład zastosowano łańcuch 192.168.1.100:3344, adres
IP serwera ma postać 192.168.1.100, zaś numer portu jest równy 3344.
Podczas uruchamiania serwera z aplikacją na bazie frameworku Rails należy
przekazać następujący parametr wiersza poleceń:
> rails s -p3344

Skoro serwer z aplikacją na bazie frameworku Rails działa na porcie 3344


i czeka na żądania przychodzące (wysyłane w ramach tej samej sieci lokalnej
co emulator systemu Android lub urządzenie z tym systemem), możemy
teraz nacisnąć przycisk przełącznika On/Off.
Hm, nic się nie dzieje. Dlaczego?

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
168  7.7. Testowanie aplikacji klienckiej dla systemu Android

Okazuje się, że do prawidłowego działania aplikacji Light Switch potrzebne


jest ustawienie jeszcze jednej ważnej opcji. Musimy mieć na uwadze model
bezpieczeństwa aplikacji systemu Android i zasygnalizować, że nasza aplika-
cja będzie używała połączenia z internetem (połączenie jest niezbędne do
przekazywania wychodzących żądań protokołu HTTP do świata zewnętrz-
nego). W tym celu należy dwukrotnie kliknąć plik AndroidManifest.xml
i dodać następujący wiersz przed znacznikiem zamykającym </manifest>:
<uses-permission android:name="android.permission.INTERNET">
</uses-permission>

Cały plik AndroidManifest.xml powinien teraz mieć następującą postać:


<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.mysampleapp.lightswitch"
android:versionCode="1"
android:versionName="1.0">
<application android:icon="@drawable/icon"
android:label="@string/app_name">
<activity android:name=".LightSwitch"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<uses-permission android:name="android.permission.INTERNET">
</uses-permission>
</manifest>

Należy ponownie skompilować aplikację Light Switch z nowymi uprawnie-


niami, po czym kliknąć przycisk przełącznika. Jeśli wszystko działa zgodnie
z planem, aplikacja serwera na bazie frameworku Rails powinna zwrócić
następujący komunikat o otrzymaniu prawidłowego żądania:
Started GET "/command/on" for 192.168.1.101 at Sat Mar 21 19:48:10 -0500 2011
Processing by CommandController#cmd as HTML
Parameters: {"cmd"=>"on"}
Rendered command/cmd.html.erb within layouts/application (11.7ms)
Completed 200 OK in 53ms (Views: 34.7ms | ActiveRecord: 0.0ms)

Naciśnięcie przycisku powinno też spowodować włączenie światła! Warto


teraz ponownie nacisnąć przycisk przełącznika. Tym razem powinniśmy
otrzymać podobny komunikat dla polecenia off:
Started GET "/command/off" for 192.168.1.101 at Sat Mar 26 19:52:30 -0500 2011
Processing by CommandController#cmd as HTML
Parameters: {"cmd"=>"off"}
Rendered command/cmd.html.erb within layouts/application (13.2ms)
Completed 200 OK in 1623ms (Views: 40.0ms | ActiveRecord: 0.0ms)

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  169

Tym razem naciśnięcie przycisku powinno spowodować wyłączenie światła.


W niektórych, dość rzadkich przypadkach próba instalacji aplikacji Light
Switch na telefonie z systemem Android może powodować wyświetlenie
komunikatu o wygaśnięciu ważności klucza diagnostycznego. Model bez-
pieczeństwa systemu Android wyklucza możliwość uruchamiania kodu
bez podpisanego klucza. Podpisany klucz powinien zostać automatycznie
wygenerowany i skonfigurowany podczas instalacji zestawu narzędzi An-
droid SDK; jeśli jednak otrzymamy komunikat o wygaśnięciu ważności
tego klucza, powinniśmy przeprowadzić procedurę generowania nowego
klucza (opisaną w dokumentacji zestawu narzędzi Android SDK)14.
Więcej informacji na temat procedur instalacji oprogramowania tworzone-
go w środowisku Eclipse na urządzeniach z systemem Android można
znaleźć w dokumentacji zestawu narzędzi Android SDK (w części doty-
czącej uruchamiania aplikacji na emulatorze i właściwych urządzeniach)15.

7.8. Następne kroki


Gratulacje! Skoro możemy już sterować lampą lub dowolnym innym urzą-
dzeniem elektrycznym za pośrednictwem graficznego przełącznika na ekranie
dotykowym telefonu z systemem Android, mamy przed sobą zupełnie nowe
możliwości w zakresie automatyzacji domu.
Aplikację kliencką dla systemów mobilnych można rozbudować o mechani-
zmy sterowania wieloma włącznikami X10 w możliwie łatwy i elegancki spo-
sób (na przykład z uwzględnieniem pory dnia, współrzędnych odczytywa-
nych przez wbudowany moduł GPS, tak aby światło na ganku zapalało
się po zapadnięciu ciemności i tylko wtedy, gdy znajdujemy się w promie-
niu pięciu metrów od drzwi wejściowych). Mimo że w tej książce nie bę-
dziemy tworzyli podobnej aplikacji uwzględniającej położenie użytkowni-
ka, dysponujemy już wszystkimi elementami składowymi takiego systemu,
zatem każdy czytelnik może sam spróbować zrealizować odpowiedni pro-
jekt. Zainteresowanych czytelników zachęcam do lektury książki Hello,
Android Eda Burnette’a [Bur10], w której można znaleźć kilka naprawdę
przydatnych przewodników. Ciekawe pomysły i dokumentację projektów
warto też zgłaszać na oficjalnej stronie internetowej tej książki!

14
http://developer.android.com/guide/publishing/app-signing.html
15
http://developer.android.com/guide/developing/building/building-eclipse.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
170  7.8. Następne kroki

Opisaną konfigurację można udoskonalić na wiele innych sposobów, aby


system sterowania był bardziej niezawodny i przyjazny dla użytkownika.
Poniżej opisano kilka pomysłów na rozbudowę tego projektu:
 Warto rozważyć poprawienie mechanizmu przechwytywania błę-
dów i generowania odpowiednich komunikatów. Zdarzenia stan-
dardu X10 mają charakter „odpal i zapomnij”, zatem żądania nie
powodują zwracania żadnych odpowiedzi informujących o sukcesie
lub porażce. W tej sytuacji istnieje spora przestrzeń dla udoskona-
leń usługi sieciowej, tak aby uwzględniała niemal wszystkie poten-
cjalne problemy przynajmniej do momentu wysłania właściwego
polecenia protokołu X10. Przed wysłaniem komunikatu należałoby
przechwycić i zgłosić ewentualne błędy połączenia interfejsu kom-
puterowego X10. Świadomość niewłaściwego działania interfejsu
X10 jest nieporównanie bardziej przydatna niż samo odkrycie, że
użycie włącznika nie powoduje żadnej zmiany (bez wyjaśnienia przy-
czyn tego stanu rzeczy).
 Warto zainwestować w dodatkowe moduły X10, w tym moduły lamp
(dwukierunkowy LM14A oraz tzw. Socket Rocket — LM15A),
gniazdo ścienne (SR227) i moduły obciążonych urządzeń (HD243).
Narzędzie Heyu może wysyłać zdarzenia do wielu urządzeń X10
jednocześnie. Można na przykład użyć jednego wywołania metody
do włączenia światła w kuchni, włączenia tostera, uruchomienia eks-
presu do kawy i wentylatora sufitowego. Co więcej, aplikacja kliencka
na telefonie komórkowym może otrzymać powiadomienie o gotowej
kawie i opieczonej bagietce.
 Czytelnicy, którzy wolą lżejsze frameworki aplikacji internetowych
języka Ruby, powinni rozważyć zastąpienie serwera Ruby on Rails
frameworkiem Sinatra16. Mimo że Sinatra wciąż nie cieszy się taką
popularnością jak framework Rails, z pewnością warto sprawdzić
możliwości tego wyjątkowo zgrabnego rozwiązania.
 Interfejsy użytkownika aplikacji mobilnych można wzbogacić o bar-
dziej elegancką i funkcjonalną część frontową, która będzie obej-
mowała wiele przełączników, symboli urządzeń, przycisków otwie-
rających bramę garażową itp.

16
http://www.sinatrarb.com/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 7. • Internetowy włącznik światła  171

 Rozwiązania opisane w tym rozdziale można wykorzystać do rozsze-


rzenia funkcji rozmaitych innych systemów (na przykład do wzbo-
gacenia telefonu o funkcje pilota telewizyjnego) lub projektów opi-
sanych w tej książce (na przykład projektu z rozdziału 8. zatytuło-
wanego „Automatyzacja działania zasłony” lub z rozdziału 9. zatytu-
łowanego „Zamek do drzwi sterowany przez Androida”).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
172  7.8. Następne kroki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8.
Automatyzacja
działania zasłony

J
ednym z najbardziej popularnych efektów w filmach science fiction jest
automatyczne otwieranie i zamykanie rozmaitych przegród, a także
podnoszenie i opuszczanie zasłon w oknach. Okazuje się, że to, co
kiedyś było wyobrażeniem o przyszłości, nie jest dzisiaj niczym szczególnym
i stale zyskuje na popularności. W tym projekcie skonstruujemy system,
który będzie podnosił i opuszczał zasłony w zależności od natężenia świa-
tła i temperatury. Zasłony są podnoszone w reakcji na rosnącą temperatu-
rę, a opuszczane po wykryciu światła słonecznego (patrz rysunek 8.1 za-
tytułowany „Automatyczne zasłony okienne”).
Podstawowym elementem sprzętowym potrzebnym do realizacji tego pro-
jektu będzie silnik krokowy — to sterowane przez płytkę Arduino urzą-
dzenie będzie wykonywało określoną liczbę obrotów w kierunku zgodnym
z ruchem wskazówek zegara i w kierunku przeciwnym do tego ruchu. Od-
powiednie połączenie wału silnika krokowego do linki systemu podnosze-
nia i opuszczania zasłon umożliwi sterowanie zasłonami zależnie od sy-
gnałów wysyłanych przez płytkę Arduino.
Przeanalizujmy teraz pozostałe elementy składowe niezbędne do budowy
tego projektu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
174  8.1. Czego potrzebujemy

Rysunek 8.1. Automatyczne zasłony okienne... podnoszone i opuszczane


zależnie od nasłonecznienia i temperatury

8.1. Czego potrzebujemy


Części potrzebne do realizacji tego projektu są dość proste. Do najważniej-
szych komponentów należą czujniki światła i temperatury, silnik krokowy
i płytka Arduino. Reszta elementów jest potrzebna do odpowiedniego
zamontowania i zasilania tego systemu. Wymagane komponenty pokazano
na rysunku 8.2 zatytułowanym „Części systemu automatycznej zasłony
okiennej”. Potrzebne nam są następujące elementy:
1. cztery dwucalowe kątowniki do zamontowania silnika krokowego;
2. dwubiegunowy silnik krokowy zasilany napięciem 12 V1;
3. moduł silnika platformy Arduino2;
4. zasilacz 12 V3;

1
https://www.adafruit.com/products/324
2
http://www.adafruit.com/products/81
3
https://www.adafruit.com/products/352

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  175

Rysunek 8.2. Części systemu automatycznej zasłony okiennej

5. dwustronna taśma piankowa redukująca wibracje zamontowanego


silnika krokowego;
6. gumowe, rowkowe koło pasowe do nawijania linki zasłony;
7. przewód łączący czujniki i silnik krokowy z modułem silnika;
8. analogowy czujnik temperatury TMP36 (powiększone zdjęcie
fotokomórki i czujnika temperatury pokazano na rysunku 8.3 za-
tytułowanym „Czujniki potrzebne do budowy systemu automa-
tycznej zasłony”)4;
9. rezystor 10 kΩ (takie rezystory oznacza się zwykle brązowym,
czarnym, pomarańczowym i złotym paskiem);
10. fotokomórka (tego samego typu co w rozdziale 5. zatytułowanym
„Ćwierkający karmnik dla ptaków”);
11. Arduino Uno;
12. mała płytka uniwersalna, na której zostaną zamontowane fotokomór-
ka i czujnik temperatury;
13. standardowy przewód USB A-B (nie ma go na rysunku) do połą-
czenia platformy Arduino z komputerem.

4
https://www.adafruit.com/products/165

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
176  8.1. Czego potrzebujemy

Rysunek 8.3. Czujniki potrzebne do budowy systemu automatycznej zasłony

W tym projekcie zakładam, że czytelnik dysponuje już zawieszonymi za-


słonami oraz systemem ich podnoszenia i opuszczania. Czytelnicy, którzy
nie dysponują jeszcze roletami, mogą skorzystać z porad publikowanych
w wielu serwisach internetowych, które dokładnie wyjaśniają, jak prawi-
dłowo zawiesić zasłony i jak zamontować system ich regulacji. Ten projekt
najlepiej sprawdza się w przypadku zasłon zawieszonych na karniszach
i podnoszonych za pomocą jednej nieprzerwanej linki. Pociągnięcie linki
z lewej strony powoduje podciągnięcie prawej strony zasłony (i odwrotnie).
Należy tak dobrać średnicę koła pasowego, aby najlepiej pasowało do konfi-
guracji zasłony. W przypadku pojedynczej zasłony zawieszonej z prostym
systemem podnoszenia rowkowe koło pasowe o średnicy jednego cala powin-
no w zupełności wystarczyć. Koła pasowe w różnych rozmiarach często moż-
na znaleźć wśród elementów wyjętych z rozmaitych urządzeń, części samo-
chodowych, a nawet w niektórych sklepach dla zakładów rzemieślniczych.
W idealnej konfiguracji środkowy otwór koła pasowego powinien być dobrze
dopasowany do wału silnika krokowego, tak aby koło nie zsuwało się i nie
ślizgało się na wale w czasie działania silnika. Czytelnicy, którzy mieszkają
blisko sklepu z takimi urządzeniami, powinni zabrać ze sobą wiele różnych
kół pasowych, aby na miejscu dopasować silnik krokowy (w ten sposób
można oszczędzić sporo czasu i nerwów). Po znalezieniu najlepszego
silnika i dopasowaniu koła pasowego możemy przystąpić do łączenia ele-
mentów projektu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  177

8.2. Budowa rozwiązania


Realizacja tego projektu wymaga wykonania wielu zadań. Po pierwsze,
musimy przetestować silnik krokowy za pomocą szkicu na bazie biblioteki
AFMotor firmy Adafruit. Zakładam, że dysponujesz już odpowiednio skon-
struowanym modułem silnika. Szczegółowe informacje na temat budowy
i stosowania takiego modułu można znaleźć na stronie internetowej firmy
Adafruit5.
Po sprawdzeniu działania silnika krokowego (wał silnika powinien obra-
cać się w obie strony zależnie od rozkazów wysyłanych przez szkic plat-
formy Arduino) możemy przystąpić do podłączania fotokomórki. W tym
projekcie zastosujemy ten sam schemat obsługi fotokomórki, który z po-
wodzeniem był używany w projekcie ćwierkającego karmnika dla ptaków.
W momencie, w którym fotokomórka wykrywa natężenie światła przekra-
czające ustalony przez nas próg, wał silnika krokowego obraca się określo-
ną liczbę razy w kierunku zgodnym z ruchem wskazówek zegara. Po wy-
kryciu spadku natężenia światła poniżej ustalonej wartości progowej wał
silnika krokowego wykonuje tyle samo obrotów w przeciwnym kierunku.
Obrót wału wprowadza w ruch koło pasowe, co z kolei powoduje podno-
szenie i opuszczanie zasłony okiennej.
Oprócz natężenia światła musimy jeszcze uwzględnić temperaturę w po-
koju, na wypadek gdyby przekroczyła wyznaczoną wartość progową. Jeśli
w pomieszczeniu robi się zbyt gorąco, warto wymusić obroty wału silnika
w kierunku przeciwnym do ruchu wskazówek zegara, aby opuścić zasłonę,
mimo że na dworze jest jasno. Po wykryciu spadku temperatury do kom-
fortowego poziomu wał silnika powinien wykonać odpowiednią liczbę
obrotów w kierunku zgodnym z ruchem wskazówek zegara, aby ponownie
podnieść zasłonę.
Po uruchomieniu i przetestowaniu obu czujników należy zamontować koło
pasowe na wale silnika krokowego. Po nawinięciu linki sterującej zasło-
nami możemy wskazać właściwe miejsce montażu silnika (wraz z kołem
pasowym) na ścianie. Należy tak dobrać miejsce instalacji silnika kroko-
wego, aby linka sterująca zasłonami była odpowiednio naciągnięta i aby
nie ślizgała się po obracanym kole pasowym. Pozostaje nam jeszcze kali-
bracja liczby obrotów wału silnika krokowego potrzebnych do podniesienia
i opuszczenia zasłony. Po wyznaczeniu odpowiednich wartości możemy

5
http://www.ladyada.net/make/mshield/make.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
178  8.3. Stosowanie silnika krokowego

jeszcze określić szybkość działania silnika krokowego (liczbę obrotów na


minutę), aby zasłona była podnoszona i opuszczana w odpowiednim tempie.
Po omówieniu tych kroków możemy wreszcie przystąpić do pisania szkicu
odpowiedzialnego za sterowanie silnikiem krokowym.

8.3. Stosowanie silnika krokowego


Działanie silników elektrycznych polega na wprawianiu w ruch central-
nych wałów przez pole elektromagnetyczne. Zmiany pola magnetycznego
wokół cewek otaczających wał powodują zmianę sił wprawiających wał
w ruch obrotowy (w jednym albo drugim kierunku). Silniki krokowe dodat-
kowo podnoszą precyzję sterowania obrotami wału, ponieważ wprowadzają
pojęcie kroku, czyli dokładnie określonego kąta obrotu. Ta cecha silników
krokowych czyni z tych urządzeń doskonały wybór wszędzie tam, gdzie
jest wymagana precyzyjna kontrola.
Silniki krokowe stosuje się w drukarkach atramentowych, ploterach i dyskach
twardych; urządzenia tego typu można spotkać także w rozmaitych systemach
przemysłowych.
Na potrzeby tego projektu zostanie użyty popularny dwubiegunowy silnik
krokowy zasilany prądem 12 V, 350 mA. Pełen obrót podzielono na 200
kroków. Silnik powinien oferować moment obrotowy niezbędny do podnie-
sienia niemal wszystkich rodzajów zasłon (poza tymi najcięższymi). Skoro
wybrany silnik ma być zasilany prądem 12 V, musimy zaopatrzyć się
w 12-woltowy zasilacz (napięcie 5 V dostarczane przez samą płytkę Arduino
w tym przypadku nie wystarczy). Okazuje się, że płytka Arduino dysponuje
elektroniką potrzebną do bezpiecznego podłączenia zasilacza 12-woltowego,
który będzie zasilał zarówno tę płytkę, jak i moduł silnika oraz sam silnik
krokowy.
Poniżej opisałem kroki potrzebne do przygotowania silnika krokowego do
właściwego programowania (zakładam, że dysponujesz już działającym mo-
dułem silnika firmy Adafruit):
1. Należy podłączyć cztery przewody 12-woltowego, dwubiegunowe-
go silnika krokowego. W przypadku silnika krokowego zalecanego
przez firmę Adafruit przewody powinny tworzyć następującą se-
kwencję: czerwony, żółty, zielony, brązowy. Odpowiedni przykład
pokazano na rysunku 8.4 zatytułowanym „Sposób łączenia dwu-
biegunowego silnika krokowego”.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  179

Rysunek 8.4. Sposób łączenia dwubiegunowego silnika krokowego

2. Należy umieścić moduł silnika na płytce Arduino Uno.


3. Do gniazda zasilania płytki Arduino należy podłączyć zasilacz
12-woltowy.
4. Należy połączyć płytkę Arduino z komputerem za pomocą prze-
wodu USB.
Skoro dysponujemy już połączonym sprzętem, możemy się skoncentrować
na pisaniu szkicu platformy Arduino, który będzie sterował pracą silnika
krokowego.

8.4. Programowanie silnika krokowego


Aby silnik krokowy działał zgodnie z naszymi oczekiwaniami, musimy zaim-
portować bibliotekę, która znacznie upraszcza sterowanie przyrostowym
obracaniem wału tego silnika w wybranym kierunku i z określoną szybkością.
Okazuje się, że sterowanie silnikiem krokowym jest bardzo proste dzięki
bibliotece modułu silnika AFMotor firmy Adafruit6. Jak w przypadku większości
bibliotek tej firmy, należy rozpakować pobrany plik ZIP, zmienić nazwę
wypakowanego folderu (AFMotor) i umieścić ten folder w folderze libraries
środowiska Arduino IDE. Więcej informacji na ten temat można znaleźć
w dodatku A zatytułowanym „Instalacja bibliotek platformy Arduino”.

6
https://github.com/adafruit/Adafruit-Motor-Shield-library

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
180  8.4. Programowanie silnika krokowego

Po zainstalowaniu biblioteki AFMotor należy uruchomić środowisko progra-


mowania Arduino IDE. Spróbujmy napisać szkic, który przetestuje dzia-
łanie silnika krokowego. Kod tego szkicu będzie wykonywał następujące
zadania:
1. Załaduje bibliotekę AFMotor.
2. Utworzy obiekt silnika krokowego biblioteki AFMotor, po czym ustawi
połączenie i określi liczbę kroków na obrót (czyli w praktyce szybkość
obracania wału tego silnika).
3. Obróci wał w kierunku zgodnym z ruchem wskazówek zegara i w kie-
runku przeciwnym do tego ruchu, korzystając z dwóch cewek. Opi-
sane działanie, które określa się mianem aktywacji dwucewkowej
(ang. double-coil activation), zapewnia wyższy moment obrotowy
niż stosowanie jednej cewki. Dodatkowy moment obrotowy z pew-
nością przyda się podczas nawijania linki sterującej zasłonami.
Kompletny kod opisanego szkicu pokazano poniżej:
Plik CurtainAutomation/StepperTest.pde

#include <AFMotor.h>

AF_Stepper motor(48, 2);

void setup() {
Serial.begin(9600);
Serial.println("Początek testu silnika krokowego...");
// Za pomocą funkcji setSpeed można ustawić szybkość obracania wału silnika
motor.setSpeed(20);
}

void loop() {
// funkcja step()
motor.step(100, FORWARD, DOUBLE);
motor.step(100, BACKWARD, DOUBLE);
}

Warto pamiętać, że ten kod testowy jest w istocie fragmentem przykładowego


kodu dostępnego na stronie internetowej Ladyady poświęconej modułowi
silnika7.
Szkic należy teraz zapisać i wysłać na platformę Arduino. Jeśli wszystko za-
działa prawidłowo, silnik krokowy powinien obracać się zgodnie z kierun-
kiem ruchu wskazówek zegara i przeciwnie do tego ruchu aż do momentu
odcięcia zasilania lub wysłania nowego szkicu. Jeśli wał silnika krokowego

7
http://www.ladyada.net/make/mshield/use.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  181

nie obraca się, należy najpierw sprawdzić przewody łączące silnik z modułem
silnika. Warto też sprawdzić, czy płytka Arduino na pewno jest podłą-
czona do zasilacza 12-woltowego, ponieważ warunkiem działania silnika
jest dostarczenie odpowiedniego napięcia. W razie problemów z określeniem
kierunku obrotów silnika wystarczy przymocować do wału kawałek wstążki.
Obracająca się wstążka powinna ułatwić jednoznaczne stwierdzenie, czy
wał rzeczywiście obraca się w obu kierunkach.
Dysponujemy już działającym silnikiem krokowym, zatem możemy przystąpić
do uzupełnienia systemu o czujniki temperatury i światła, tak aby ten sil-
nik mógł działać w reakcji na zmieniającą się sytuację.

8.5. Dołączanie czujników


Możemy teraz połączyć działający silnik krokowy z fotokomórką, którą stoso-
waliśmy już w projekcie ćwierkającego karmnika dla ptaków. Wskazania
fotokomórki będą odczytywane w jednosekundowych odstępach. W zależności
od natężenia światła na zewnątrz czujnik będzie powodował podniesienie
lub opuszczenie zasłony. Zastosujemy także czujnik temperatury, aby uniknąć
podnoszenia zasłony w sytuacji, gdy w pomieszczeniu jest zbyt gorąco, lub aby
opuścić zasłonę, jeśli temperatura w pokoju przekracza wyznaczony poziom.
Na szczęście moduł krokowy nie używa żadnych wtyków analogowych na
płytce Arduino — to dla nas o tyle ważne, że wtyki analogowe będą nam
potrzebne do mierzenia natężenia światła i temperatury za pomocą odpo-
wiednich czujników. W tej sytuacji możemy podłączyć jedną końcówkę
fotokomórki do wtyku zasilania 5 V oraz drugą końcówkę do wtyku analogo-
wego nr 0. Tak jak podczas realizacji projektu ćwierkającego karmnika dla
ptaków, musimy zmostkować wtyk analogowy nr 0 z uziemieniem za pomocą
rezystora 10 kΩ. W tym przypadku najprostszym rozwiązaniem będzie
podłączenie czujników za pośrednictwem płytki uniwersalnej. Zaletą płytki
jest także możliwość stabilnego zamocowania fotokomórki i skierowania jej
w stronę okna (w celu sprawdzania natężenia światła na zewnątrz).
Czujnik temperatury ma trzy końcówki: pierwszą końcówkę należy połączyć
z wtykiem zasilania 5 V, środkową końcówkę z wtykiem analogowym nr 5,
natomiast trzecią (prawą) końcówkę z wtykiem uziemienia. Dzięki modułowi
silnika połączenie wszystkich elementów jest znacznie prostsze. Schemat
niezbędnych połączeń pokazano na rysunku 8.5 zatytułowanym „Schemat
połączeń silnika krokowego i czujników na potrzeby automatycznej zasłony”.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
182  8.6. Pisanie szkicu

Warto pamiętać, że chociaż schemat przedstawia płytkę Arduino, w rzeczy-


wistości przewody są podłączone do modułu silnika zamontowanego ponad
tą płytką (właśnie dlatego przewody łączące płytkę z silnikiem krokowym
oraz przewody prowadzące do wtyku analogowego nr 5 i wtyków zasilania
5 V podłączono po prawej stronie układu).

Rysunek 8.5. Schemat połączeń silnika krokowego i czujników na potrzeby


automatycznej zasłony

Wartości odczytywane przez te dwa czujniki będą sprawdzane co sekundę.


Ewentualna reakcja na zmieniające się warunki będzie podejmowana tylko
w razie przekroczenia wyznaczonych wartości progowych. Spróbujmy napisać
szkic, który zrealizuje opisane działania.

8.6. Pisanie szkicu


W szkicu na potrzeby tego projektu zostaną zastosowane rozwiązania i pomysły
zaczerpnięte z dwóch innych projektów. Obsługa danych odczytywanych
przez czujniki pochodzi z projektu ćwierkającego karmnika dla ptaków, na-
tomiast maszyna stanów obejmująca status podniesionej i opuszczonej za-
słony pochodzi z systemu powiadamiania o poziomie wody. Kompletny szkic
pokazano poniżej.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  183

Plik CurtainAutomation/CurtainAutomation.pde

#include <AFMotor.h>
#define LIGHT_PIN 0
#define LIGHT_THRESHOLD 800
#define TEMP_PIN 5
#define TEMP_THRESHOLD 72
#define TEMP_VOLTAGE 5.0
#define ONBOARD_LED 13

int curtain_state = 1;
int light_status = 0;
double temp_status = 0;

boolean daylight = true;


boolean warm = false;

AF_Stepper motor(100, 2);

void setup() {
Serial.begin(9600);
Serial.println("Konfigurowanie systemu automatycznej zasłony...");
// ustawia szybkość obrotów wału silnika krokowego na poziomie 100 obrotów na minutę
motor.setSpeed(100);
// inicjalizacja silnika
// motor.step(100, FORWARD, SINGLE);
// motor.release();
delay(1000);
}

void Curtain(boolean curtain_state) {


digitalWrite(ONBOARD_LED, curtain_state ? HIGH : LOW);
if (curtain_state) {
Serial.println("Podnoszenie zasłony...");
// Warto sprawdzić w działaniu wartości SINGLE, DOUBLE, INTERLEAVE i MICROSTOP
motor.step(800, FORWARD, SINGLE);
} else {
Serial.println("Opuszczanie zasłony...");
motor.step(800, BACKWARD, SINGLE);
}
}

void loop() {

// sprawdza wartość fotokomórki


light_status = analogRead(LIGHT_PIN);
delay(500);

// wysyła wartość zmiennej light_status do portu szeregowego


Serial.print("Wartość fotokomórki = ");
Serial.println(light_status);
Serial.println("");

// sprawdza temperaturę
int temp_reading = analogRead(TEMP_PIN);

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
184  8.6. Pisanie szkicu

delay(500);

// przelicza odczytane napięcie na stopnie Celsjusza i Fahrenheita


float voltage = temp_reading * TEMP_VOLTAGE / 1024.0;
float temp_Celsius = (voltage - 0.5) * 100 ;
float temp_Fahrenheit = (temp_Celsius * 9 / 5) + 32;
// wysyła wartość zmiennej temp_status do portu szeregowego
Serial.print("Temperatura (w stopniach Celsjusza) = ");
Serial.println(temp_Celsius);
Serial.print("Temperatura (w stopniach Fahrenheita) = ");
Serial.println(temp_Fahrenheit);
Serial.println("");

if (light_status > LIGHT_THRESHOLD)


daylight = true;
else
daylight = false;

if (temp_Fahrenheit > TEMP_THRESHOLD)


warm = true;
else
warm = false;

switch (curtain_state)
{
case 0:
if (daylight && !warm)
// podnosi zasłonę
{
curtain_state = 1;
Curtain(curtain_state);
}
break;
case 1:
if (!daylight || warm)
// opuszcza zasłonę
{
curtain_state = 0;
Curtain(curtain_state);
}
break;
}
}

Referencja do biblioteki AFMotor używanej do sterowania silnikiem kro-


kowym, który połączono z modułem silnika firmy Adafruit.
W początkowej sekcji szkicu zdefiniowano wiele wartości. Takie roz-
wiązanie znacznie ułatwi zmianę wartości stałych LIGHT_THRESHOLD
i TEMP_THRESHOLD, tak aby wyznaczały lepsze progi uruchamiania silnika
krokowego.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  185

Zmienne reprezentujące stan zasłony (a także wartości odczytane


przez fotokomórkę i czujnik temperatury oraz zmienne logiczne daylight
i warm) są wykorzystane w wyrażeniach warunkowych głównej pętli do
określania, czy na dworze jest jasno i czy temperatura w pomieszczeniu
jest odpowiednia. W tej części szkicu dodatkowo tworzymy obiekt motor
klasy AF_Stepper, ustawiając przy okazji liczbę kroków w każdym obrocie
(w tym przypadku będzie to 100 kroków) oraz port modułu, do które-
go podłączono ten silnik (w tym przypadku port nr 2).
W tym miejscu inicjalizujemy port szeregowy, za którego pośrednictwem
wartości odczytywane przez czujnik natężenia światła i temperatury będą
wysyłane do okna monitora portu szeregowego w ramach środowiska
Arduino IDE. W tej części kodu określono także szybkość działania
silnika (w tym przypadku na poziomie 100 obrotów na minutę).
Funkcja Curtain zostanie wywołana w momencie przekroczenia wartości
progowej natężenia światła lub temperatury. Stan zasłony (podniesiona
lub opuszczona) jest reprezentowany w odpowiedniej zmiennej, dzięki
czemu nie ma potrzeby uruchamiania silnika co sekundę nawet w razie
przekroczenia wartości progowej. Skoro zasłona została już podniesiona,
jej ponowne podnoszenie nie miałoby żadnego sensu. Co więcej, takie
działanie naraziłoby na uszkodzenie silnik krokowy, koło pasowe lub linkę
sterującą zasłoną.
Jeśli funkcja Curtain otrzymuje wartość true za pośrednictwem argu-
mentu curtain_state, silnik krokowy wykonuje obroty w kierunku prze-
ciwnym do ruchu wskazówek zegara, aby podnieść zasłonę. Wartość
false przekazana za pośrednictwem tego parametru powoduje obrót
silnika w kierunku zgodnym z ruchem wskazówek zegara i tym samym
opuszczenie zasłony.
Do wizualizacji stanu zasłony użyjemy dodatkowo diody LED na płytce
Arduino. Jeśli zasłona jest uniesiona, dioda pozostaje zapalona. W prze-
ciwnym razie dioda gaśnie. Ponieważ moduł silnika zasłania górną część
płytki Arduino, wbudowana dioda LED nie jest zbyt dobrze widoczna,
ale w zupełności wystarczy do celów diagnostycznych.
Większość działań jest podejmowana w głównej pętli tego szkicu. Program
odczytuje wskazania fotokomórki i czujnika temperatury co sekundę,
konwertuje napięcie przekazywane przez czujnik temperatury na stopnie
Celsjusza i Fahrenheita (dla osób, które nie są przyzwyczajone do systemu
metrycznego). Jeśli wartość przekazana przez czujnik natężenia światła
przekracza wartość progową LIGHT_THRESHOLD (określoną w sekcji #define

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
186  8.6. Pisanie szkicu

tego szkicu), przyjmujemy, że jest dzień (daytime = true). Nie chcemy


jednak podnosić zasłony, jeśli w pomieszczeniu jest gorąco, ponieważ
światło słoneczne dodatkowo nagrzewałoby wnętrze. Jeśli więc odczytana
temperatura przekracza wartość progową TEMP_THRESHOLD, zasłony pozo-
stają opuszczone do czasu ochłodzenia powietrza w pomieszczeniu. Po
sprawdzeniu stanu zmiennej curtain_state możemy przekazać nowy
stan na wejściu funkcji Curtain, aby (zależnie od sytuacji) podnieść lub
opuścić zasłonę.
Szkic należy teraz sprawdzić, pobrać i uruchomić na platformie Arduino.
Na tym etapie warto pozostawić płytkę Arduino połączoną z komputerem
i otworzyć okno monitora portu szeregowego środowiska Arduino IDE,
aby sprawdzić wartości odczytywane przez czujniki światła i temperatury.
Możemy teraz sprawdzić, czy przekroczenie wartości progowych powo-
duje oczekiwane działania, tj. aktywuje silnik krokowy (patrz rysunek 8.6
zatytułowany „Test szkicu automatycznej zasłony”).

Rysunek 8.6. Test szkicu automatycznej zasłony

Aby przetestować działanie szkicu automatycznej zasłony, warto najpierw


zasłonić palcem fotokomórkę i sprawdzić, czy silnik krokowy obraca wał
w kierunku przeciwnym do ruchu wskazówek zegara. Po odsłonięciu foto-

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  187

komórki wał powinien wykonać tyle samo obrotów w kierunku zgodnym


z ruchem wskazówek zegara. Należy teraz skierować strumień ciepłego po-
wietrza (na przykład za pomocą suszarki do włosów) na czujnik temperatury.
Przekroczenie progu powinno spowodować włączenie silnika krokowego
i obroty w kierunku zgodnym z ruchem wskazówek zegara. Takie działanie
docelowo będzie powodowało opuszczenie zasłony. Przed usunięciem
źródła ciepła należy ponownie zasłonić palcem fotokomórkę. Dopiero po
zasłonięciu czujnika światła należy usunąć źródło ciepła. Silnik krokowy
nie powinien się uruchomić.
Możemy teraz odsłonić fotokomórkę. Jeśli powietrze otaczające czujnik tem-
peratury zdążyło się schłodzić, wał silnika powinien zacząć się obracać
w kierunku przeciwnym do ruchu wskazówek zegara. Jeśli silnik nie zostanie
włączony, należy skierować na czujnik temperatury strumień chłodnego po-
wietrza — system powinien zareagować zaraz po wykryciu spadku tempe-
ratury poniżej przyjętego progu. Na tej podstawie możemy sprawdzić, czy
szkic prawidłowo reaguje na przekroczenie wartości progowych natężenia
światła i temperatury. W wyniku tych testów być może będziemy musieli
nieznacznie zmienić te wartości progowe, aby system właściwie reagował na
natężenie światła i temperaturę w pomieszczeniu. Niewykluczone, że będzie-
my musieli wyznaczyć pewne przedziały wskazań czujników światła i tem-
peratury. W przeciwnym razie silnik krokowy będzie wielokrotnie podnosił
i opuszczał zasłonę w związku z następującymi po sobie wzrostami i spad-
kami wartości powyżej i poniżej progu.
Po sprawdzeniu, czy czujniki prawidłowo przesyłają swoje wartości i czy wał
silnika krokowego obraca się zaraz po przekroczeniu wartości progowych,
możemy zainstalować oba czujniki na parapecie okiennym oraz silnik kro-
kowy na ścianie obok zasłony. Po sprawdzeniu działania systemu możemy
przełożyć czujniki w inne miejsce — warto przetestować różne położenie czuj-
ników (jedynym ograniczeniem jest długość przewodów łączących te czujniki
z płytką Arduino). Warto też upewnić się, że przewody i czujniki nie są
zainstalowane w miejscach, w których mogą zostać przypadkowo nadepnięte
lub spowodować potknięcie się domownika.

8.7. Instalacja sprzętu


Podczas instalacji czujników w docelowym miejscu można zastosować tę samą
płytkę uniwersalną, której używaliśmy podczas testów szkicu systemu auto-
matycznej zasłony. Do umieszczenia tej płytki w wybranym miejscu użyłem

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
188  8.7. Instalacja sprzętu

dwustronnej pianki. Płytka z czujnikami skierowanymi w stronę okna wyglą-


da trochę jak supernowoczesna doniczka z kwiatami. Warto też pamiętać
o problemie nagrzewania się działającego silnika krokowego — dla bezpie-
czeństwa silnik należy zamontować w odpowiedniej odległości od łatwo-
palnych materiałów. Silnik krokowy nie powinien się znajdować zwłaszcza
w bezpośrednim sąsiedztwie podnoszonej i opuszczanej zasłony!
Należy zmierzyć odległość dzielącą planowane miejsce instalacji płytki z czuj-
nikami na parapecie od miejsca instalacji płytki Arduino z modułem silnika.
Płytkę Arduino można zamontować na stole, w obudowie lub nawet bez-
pośrednio na ścianie. Polecam przycięcie przewodów w taki sposób, aby mieć
pewien zapas w razie konieczności przeniesienia płytki Arduino w inne miej-
sce. Musimy też mieć na uwadze miejsce instalacji zasilacza 12-woltowego
i możliwość doprowadzenia przewodu elektrycznego zasilającego płytkę
Arduino, moduł silnika oraz sam silnik krokowy.
Rowkowe koło pasowe należy zainstalować na wale silnika krokowego. Na to
koło należy następnie nawinąć linkę sterującą zasłoną. Silnik krokowy
należy umieścić na tyle nisko, aby linka była odpowiednio naciągnięta na
kole pasowym. Przed trwałym zamontowaniem silnika krokowego należy
przytwierdzić ten silnik do czterech kątowników (za pomocą dwustronnej
taśmy piankowej). Taśma pozwoli też czasowo przymocować silnik do
ściany przed ostatecznym przykręceniem kątowników. Taśma piankowa ma
też za zadanie wytłumić wibracje przenoszone na ścianę i wyciszyć silnik
krokowy w czasie obracania wałem. Warto wykorzystać możliwość tymczaso-
wego przymocowania silnika krokowego do ściany, aby sprawdzić, czy wy-
brane miejsce nie spowoduje zbyt dużego lub zbyt małego naprężenia linki
naciągniętej na koło pasowe. Linka nie może być zbyt napięta — w zu-
pełności wystarczy naprężenie zapobiegające swobodnemu ślizganiu się tej
linki na kole pasowym.
Przed ostatecznym przykręceniem kątowników do ściany warto dla pew-
ności wykonać jeszcze kilka testów. Należy przede wszystkim sprawdzić,
czy linka naciągnięta na koło pasowe jest odpowiednio naciągnięta i czy tarcie
podczas pracy silnika krokowego wystarczy do podnoszenia i opuszczania
zasłony. Po wybraniu najlepszego miejsca montażu silnika krokowego
należy przykręcić kątowniki do ściany.
Musimy jeszcze skalibrować szybkość działania silnika krokowego i liczbę
obrotów, które ten silnik musi wykonać, aby w pełni podnieść lub opuścić
zasłonę. Warto na początku wprowadzać drobne poprawki (należy przy
tym pamiętać, aby stosować tę samą liczbę obrotów zarówno dla ruchu

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  189

w kierunku zgodnym z ruchem wskazówek zegara, jak i dla ruchu w prze-


ciwnym kierunku). Liczbę obrotów potrzebnych do podniesienia i opusz-
czenia zasłony można oszacować, mierząc odległość pokonywaną przez
linkę sterującą podczas każdego obrotu koła pasowego. Uzyskaną wartość
należy podzielić przez łączną odległość pokonywaną przez zasłonę podczas
pełnej operacji podnoszenia lub opuszczania. W ten sposób otrzymamy
łączną liczbę obrotów wału silnika krokowego, które należy zapisać w pro-
gramie, aby w pełni podnieść lub opuścić zasłonę.
Podczas jednego obrotu wału silnika krokowego zasłona pokonuje odległość
´5 centymetrów.
Łączna odległość, jaką zasłona musi pokonać podczas pełnego podniesienia
´lub opuszczenia, wynosi 90 centymetrów.
90 cm / 5 cm = 18 obrotów

Po skalibrowaniu systemu warto oznaczyć linkę sterującą zasłoną w miejscach,


w których ta linka dotyka koła pasowego po całkowitym podniesieniu i opusz-
czeniu zasłony. Takie oznaczenie powinno bardzo ułatwić ponowną kali-
brację linki w razie jej przesunięcia się po pewnym czasie funkcjonowania
systemu. Tak skonfigurowany system może wyglądać podobnie do rozwiąza-
nia pokazanego na rysunku 8.7 zatytułowanym „Zainstalowany i skali-
browany system automatycznej zasłony”.

Rysunek 8.7. Zainstalowany i skalibrowany system automatycznej zasłony

System należy kilkakrotnie przetestować, zakrywając fotokomórkę i sztucznie


ocieplając powietrze wokół czujnika temperatury (chuchając na ten czujnik
lub kierując strumień powietrza z suszarki do włosów). Warto zwrócić
uwagę na moment uruchomienia procedury podnoszenia lub opuszczania

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
190  8.8. Następne kroki

zasłony. Jeśli system jest zbyt czuły i na przykład podnosi zasłonę w reakcji na
wewnętrzne światło odbijane od szyby, być może trzeba będzie umieścić
fotokomórkę w innym miejscu. Sam zamontowałem ten czujnik w rogu okna
za pomocą czarnej taśmy izolacyjnej. W ten sposób ograniczyłem ryzyko
interpretowania światła zapalanego wewnątrz pomieszczenia jako coraz
jaśniej świecącego słońca.
Warto pozwolić temu systemowi swobodnie działać przez kilka dni, obser-
wując reakcje zasłony na światło słoneczne i temperaturę w pomieszczeniu.
Na tej podstawie będzie można dostosować wartości progowe czujników
temperatury i natężenia światła. Po prawidłowym skonfigurowaniu wszystkich
ustawień będziemy mogli się ograniczyć do sprawdzania co kilka tygodni
położenia linki sterującej i ewentualnej ponownej kalibracji systemu. Po
pewnym czasie automatyczne zasłony nie będą już wymagały żadnych
interwencji. Kiedy goście po raz pierwszy zobaczą automatycznie podnoszone
i opuszczane zasłony, z pewnością będą pod ogromnym wrażeniem.

8.8. Następne kroki


Moduł silnika może obsługiwać maksymalnie dwa silniki krokowe jedno-
cześnie. Możliwości tego modułu mogą być przydatne w większych po-
mieszczeniach z dodatkowymi oknami. Także systemy sterowania zasłonami
można łączyć, tak aby pojedynczy silnik krokowy mógł jednocześnie pod-
nosić i opuszczać wiele zasłon. Kombinację silników krokowych i modułów
silników można z powodzeniem stosować w wielu innych projektach au-
tomatyzacji domu.
 Koło pasowe silnika krokowego można połączyć z bardziej wyrafino-
wanymi systemami zasłaniania okna obejmującymi zarówno rolety
zamontowane bezpośrednio przy oknie, jak i zainstalowane nieco dalej
zasłony rozsuwane na boki. Szkic tego systemu można by tak zapro-
jektować, aby silnik krokowy najpierw podnosił lub opuszczał roletę,
a następnie rozsuwał lub zasuwał dekoracyjną zasłonę. W konfiguracji
tego systemu należałoby uwzględnić temperaturę i światło (na przy-
kład w ciepły, słoneczny dzień należałoby rozsunąć zasłonę, ale po-
zostawić opuszczoną roletę).
 System można by także rozbudować o czujnik ruchu PIR podłą-
czony do płytki Arduino z modułem silnika, tak aby zasłony były
podnoszone i opuszczane po wykryciu ruchu w pomieszczeniu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 8. • Automatyzacja działania zasłony  191

 System automatycznego sterowania zasłonami można wzbogacić o ob-


sługę sieci — zastosowanie modułu sieciowego Arduino pozwoli pod-
nosić i opuszczać zasłony za pomocą smartfonu. Warto też rozważyć
napisanie skryptu, który będzie podnosił i opuszczał zasłony w wy-
znaczonych godzinach.
 Jeśli nie odłączymy płytki Arduino z modułem silnika od komputera
(na czas konfiguracji oba urządzenia były połączone przewodem USB),
będziemy mogli zdalnie sterować zasłonami dzięki komunikacji USB
– port szeregowy. Oznacza to, że możemy opracować aplikację serwera
udostępniającą metody podnoszenia i opuszczania zasłony w formie
usług sieciowych, które będą wywoływane z poziomu aplikacji klienc-
kiej uruchamianej na smartfonie. Rozszerzenie tego rozwiązania o skrypt
działający na serwerze, który będzie podnosił i opuszczał zasłonę
w określonych dniach i o określonych godzinach nie będzie stanowiło
żadnego problemu.
 System można dość łatwo przebudować z myślą o Halloween — wy-
starczy zastąpić fotokomórkę i czujnik temperatury czujnikiem ruchu.
Do linki sterującej można przyczepić wielkie papierowe pająki, które
będą się poruszały w górę i w dół w momencie wykrycia ruchu.
Silnik krokowy można wykorzystać do skonstruowania systemu wieszania
i przechowywania ubrań w garderobie z unikatowym znacznikiem RFID
przypisanym do każdego wieszaka. Ubrania można zawiesić albo w przy-
padkowy sposób, albo uporządkować według pory dnia, miesiąca lub pory
roku oraz bieżącej temperatury na zewnątrz. Po zbudowaniu fizycznego
systemu warto opracować aplikację dla smartfonu lub tabletu, która umożliwi
użytkownikowi wybór właściwego ubrania (na przykład w formie przewija-
nych zdjęć), tak aby po otwarciu szafy odpowiedni element garderoby wisiał
w środku i na pierwszym planie.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
192  8.8. Następne kroki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9.
Zamek do drzwi
sterowany
przez Androida

M
asz dosyć noszenia przy sobie tradycyjnych metalowych kluczy
do swojego domu? Zapewne nie rozstajesz się ze swoim smartfo-
nem. Czyż nie byłoby wygodniej, gdyby drzwi wejściowe do domu
można było otwierać za pośrednictwem aplikacji działającej na tym smartfo-
nie? Czy nie warto pomyśleć o dodatkowym zabezpieczeniu polegającym
na fotografowaniu (za pomocą tej samej aplikacji) osób otwierających drzwi
i wysyłaniu tych zdjęć do właściciela domu w formie załączników poczty
elektronicznej? (Patrz rysunek 9.1 zatytułowany „Bezprzewodowe otwie-
ranie drzwi wejściowych za pomocą smartfonu”).
W tym projekcie użyjemy niedrogiego telefonu z systemem Android pierwszej
generacji. Smartfon zostanie połączony z płytką IOIO (czyt. jo-jo) firmy
Sparkfun i przełącznikiem przekaźnikowym sterującym ryglem elektrycznym.
Telefon z systemem Android pierwszej generacji będzie pełnił funkcję
serwera reagującego na żądania odblokowania drzwi wysyłane za pośrednic-
twem drugiego telefonu z systemem Android, na którym będzie działała od-
powiednia aplikacja kliencka. Po otrzymaniu żądania odblokowania zam-
ka telefon występujący w roli serwera robi zdjęcie za pomocą wbudowanego
aparatu i wysyła fotografię jako załącznik wiadomości poczty elektronicznej.
Do dzieła!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
194  9.1. Czego potrzebujemy

Rysunek 9.1. Bezprzewodowe otwieranie drzwi wejściowych


za pomocą smartfonu

9.1. Czego potrzebujemy


Początkowo planowałem wykorzystać w tym projekcie własnoręcznie skon-
struowany przełącznik przekaźnikowy (przy użyciu popularnych części). Tak
zbudowany przełącznik miał służyć do włączania i wyłączania zasilania elek-
trycznego rygla drzwi wejściowych. Po przeanalizowaniu potencjalnych za-
grożeń związanych z niewłaściwym podłączeniem przewodów i złym za-
bezpieczeniem całego obwodu zdecydowałem jednak o wyborze bezpiecz-
niejszego, nieco mniej ambitnego rozwiązania.
Zamiast ryzykować porażenie prądem elektrycznym, użyjemy gotowego pro-
duktu, który zaprojektowano specjalnie z myślą o tego rodzaju zastosowaniach.
Urządzenie nazwane PowerSwitch Tail II to prosty przełącznik zawierający
przekaźnik umożliwiający sterowanie standardowymi urządzeniami elektrycz-
nymi. Przekaźnik może być sterowany sygnałami 5 V generowanymi przez
wtyk cyfrowy dostępny na płytce mikrokontrolera (na przykład Arduino) lub
— jak w tym przypadku — przez płytkę IOIO na bazie mikrokontrolera
PIC. Wykorzystanie obwodu przekaźnika w ramach przełącznika Power-

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  195

Switch Tail jest nieporównanie prostsze i bezpieczniejsze od budowy własne-


go układu tego typu, a koszty gotowego produktu są porównywalne z kosz-
tami części potrzebnych do samodzielnego skonstruowania przełącznika
przekaźnikowego.
Zamiast korzystać z płytki Arduino podłączonej do komputera, do prze-
twarzania danych użyjemy telefonu z systemem Android połączonego z płyt-
ką IOIO firmy Sparkfun. Opisane urządzenia będą realizowały te same
zadania co płytka Arduino połączona z komputerem PC, jednak będą
zajmowały zdecydowanie mniej miejsca, będą lżejsze i nie będą potrzebowały
tyle energii elektrycznej co stale włączone komputer i platforma Arduino.
Czym właściwie jest płytka IOIO? Jest to most sprzętowy umożliwiający ko-
munikację telefonów z systemem Android z dowolnymi czujnikami i silnikami
podłączonymi do tej płytki. Płytka IOIO łączy się z telefonem, korzystając
z mechanizmów diagnostycznych systemu Android dostępnych za pośred-
nictwem portu USB. W ten sposób można wysyłać i otrzymywać sygnały
do i z procesora PIC zamontowanego na płytce IOIO.
Ytai Ben-Tsvi (inżynier oprogramowania z firmy Google) zaprojektował co
prawda płytkę IOIO jeszcze przed wydaniem przez Google oficjalnej spe-
cyfikacji Open Accessory Protocol (ADK)1, jednak pracuje nad jej dostoso-
waniem do specyfikacji ADK. Specyfikacja ADK jest częścią szerszego
projektu Android@Home firmy Google. Inwestycja w zakup tej płytki nie
tylko ułatwi realizację projektu prezentowanego w tym rozdziale, ale też
przyda się w przyszłości, podczas budowy rozwiązań na bazie interfejsów
API projektu Android@Home. Co jeszcze ważniejsze, płytka IOIO do-
skonale sprawdza się w przypadku niestandardowych projektów (w tym
projektu, który zbudujemy w tym rozdziale).
Poniższa lista zawiera wszystkie części potrzebne do skonstruowania zamka
do drzwi sterowanego przez Androida (patrz rysunek 9.2 zatytułowany
„Części potrzebne do budowy zamka sterowanego przez Androida (w tym
gotowe produkty)”):
1. Przełącznik PowerSwitch Tail II (PN 80135)2.
2. Przewód z żeńską końcówką barrel jack 2,1 mm potrzebny do bez-
piecznego podłączenia 12-woltowego zasilacza do elektrycznego rygla3.

1
http://accessories.android.com
2
http://www.sparkfun.com/products/10747
3
http://www.adafruit.com/products/327

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
196  9.1. Czego potrzebujemy

Rysunek 9.2. Części potrzebne do budowy zamka sterowanego


przez Androida (w tym gotowe produkty)

3. Zasilacz DC 5 V, 1 A4.
4. Zasilacz impulsowy 12 V, 5 A do zasilania elektrycznego rygla5.
5. Trzy przewody.
6. Smartfon z systemem operacyjnym Android i wbudowanym apa-
ratem fotograficznym (najlepiej oryginalny telefon Android G1).
Odpowiednie urządzenie można bez trudu znaleźć na aukcjach
internetowych w cenie poniżej 300 zł. Warto przy tym pamiętać, że
nie wszystkie telefony z systemem Android są zgodne z płytką IOIO.
Szczegółowe informacje można znaleźć na grupach dyskusyjnych
poświęconych płytce IOIO6.
7. Przewód barrel jack-JST (2-pin), który zostanie podłączony do złącza
kątowego JST na płytce IOIO7.

4
http://www.sparkfun.com/products/8269
5
http://www.adafruit.com/products/352
6
https://groups.google.com/group/ioio-users?pli=1
7
http://www.sparkfun.com/products/8734

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  197

8. Płyta Sparkfun IOIO Board i złącze kątowe JST8.


9. Rygiel elektryczny firmy Smarthome zasilany prądem stałym 12 V9.
10. Standardowy przewód USB A-Mini B potrzebny do połączenia
telefonu G1 Android z portem USB na płytce IOIO.
Będziemy potrzebowali także drugiego urządzenia z systemem Android
(telefonu, tabletu itp.), na którym będzie działała aplikacja kliencka Door
Lock. Do opracowania niezbędnego oprogramowania wykorzystamy środo-
wisko programowania Eclipse IDE, pakiet Android SDK 1.5 lub nowszy
oraz wtyczkę Android Development Tools (ADK) dla środowiska Eclipse.
Więcej informacji na temat elementów potrzebnych do wytwarzania opro-
gramowania dla systemu Android można znaleźć w rozdziale 7. zatytuło-
wanym „Internetowy włącznik światła”.
Ten projekt należy co prawda do najbardziej kosztownych przedsięwzięć
opisanych w tej książce, ale jest także jednym z najbardziej elastycznych
rozwiązań (szczególnie w kontekście możliwości ponownego wykorzysta-
nia i rozbudowy zakupionych elementów). Dopiero po opanowaniu sztuki
sterowania płytką IOIO z poziomu telefonu z systemem Android zrozu-
miemy entuzjazm towarzyszący pracownikom firmy Google opisującym
potencjał projektu Android@Home. W tym rozdziale dowiemy się także,
jak łatwo budować nowe kategorie aplikacji automatyzacji domu potrzebne do
implementowania własnych niepowtarzalnych pomysłów. Zanim jednak bę-
dziemy mogli przystąpić do realizacji tych ambitnych projektów, musimy
dobrze zrozumieć podstawy. Właśnie wprowadzeniu podstaw zostanie
poświęcony następny podrozdział.

9.2. Budowa rozwiązania


Ten projekt jest dość skomplikowany — jego realizacja z pewnością będzie
największym wyzwaniem w tej książce. Zdecydowaną większość czasu
poświęcimy na łączenie i testowanie elementów sprzętowych składających
się na ten projekt. Po przetestowaniu sprzętu przystąpimy do programowania
telefonu z systemem Android, tak aby komunikował się z płytką IOIO,

8
Patrz odpowiednio http://www.sparkfun.com/products/10748 i http://www.
sparkfun.com/products/8612.
9
http://www.smarthome.com/5192/Electric-Door-Strike-Mortise-Type/p.aspx

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
198  9.2. Budowa rozwiązania

wbudowanym aparatem fotograficznym oraz modułem sieci bezprzewo-


dowej. W następnym kroku napiszemy prostą aplikację kliencką dla urzą-
dzeń z systemem Android, która będzie uruchamiana na innym telefonie
lub tablecie w celu wysłania do płytki IOIO sygnału o konieczności włą-
czenia przełącznika PowerSwitch Tail (który z kolei uruchomi elektryczny
rygiel, aby odblokować drzwi). Poniżej opisano kroki składające się na
proces łączenia elementów, programowania i wdrażania zamka do drzwi
sterowanego przez Androida:
1. Należy podłączyć złącze JST do płytki Sparkfun IOIO w taki spo-
sób, aby było możliwe zasilanie tej płytki za pomocą 5-woltowego
zasilacza.
2. Należy podłączyć do płytki IOIO telefon Android G1 za pomocą
przewodu USB.
3. Elektryczny rygiel firmy Smarthome (zasilany prądem stałym 12 V)
należy podłączyć do 12-woltowego zasilacza za pomocą przewodu
z żeńską końcówką barrel jack 2,1 mm.
4. Przełącznik PowerSwitch Tail należy podłączyć do płytki IOIO
za pomocą trzech przewodów połączonych ze złączami zasilania,
sterowania i uziemienia.
5. Musimy zaprogramować telefon z systemem Android, aby wysyłał
sygnał do przełącznika PowerSwitch Tail za pośrednictwem płytki
IOIO.
6. W momencie wysyłania sygnału do przełącznika PowerSwitch Tail
aplikacja musi dodatkowo zrobić zdjęcie za pomocą wbudowanego
aparatu fotograficznego.
7. Uzyskany w ten sposób obraz należy przesłać na wskazany adres
poczty elektronicznej (w formie załącznika do wiadomości).
8. Musimy napisać aplikację kliencką dla drugiego urządzenia z sys-
temem Android, która będzie służyła do odblokowywania elektrycz-
nego rygla.
9. Należy zainstalować elektryczny rygiel do drzwi w ościeżnicy i po-
prowadzić przewód zasilający do najbliższego gniazdka.
10. Elementy sterujące (przełącznik PowerSwitch Tail i płytkę IOIO)
należy umieścić w łatwo dostępnej, montowanej na ścianie skrzynce,
którą będzie można otworzyć na wypadek konieczności wymiany
jakiegoś komponentu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  199

11. Musimy zamontować telefon z systemem Android, który będzie


pełnił funkcję serwera tego systemu, blisko wejścia i skierować obiek-
tyw wbudowanego aparatu na drzwi, aby fotografować wchodzące
osoby.

Następca płytki IOIO?


Firma Sparkfun zapowiedziała nową płytkę, która będzie zgodna ze
specyfikacją ADK i która zostanie zbudowana na bazie pakietu Ar-
duino Mega ADK korzystającego z protokołu Open Accessory firmy
Google. Nowa płytka, nazwana Electric Sheep10, oferuje dodatkowo
wbudowane złącze FTDI i gniazdo zasilania DC, co wyklucza koniecz-
ność stosowania dodatkowych elementów (jak w przypadku trady-
cyjnej płytki IOIO). Warto jednak podkreślić, że nowa płytka jest
dwukrotnie droższa od płytki IOIO i zużywa więcej energii. Zaletą
płytki Electric Sheep jest duża liczba analogowych i cyfrowych wtyków
oraz możliwość programowania przy użyciu zestawu narzędzi ADK
firmy Google i oprogramowania Arduino Android Handbag11. Należy
oczekiwać, że większy potencjał i lepsze przystosowanie do projektu
Android@Home z czasem doprowadzi do zastąpienia płytki IOIO.

Najbardziej czasochłonnym zadaniem będzie przylutowanie złącza kątowego


JST do płytki IOIO i podłączenie wszystkich przewodów łączących płytkę
IOIO z przełącznikiem PowerSwitch Tail. Wszystkie pozostałe zadania
sprowadzają się do umieszczania końcówek przewodów w odpowiednich
gniazdach. W szczególności należy podłączyć wtyki zasilania 5 V do płytki
IOIO; wtyki telefonu z systemem Android do płytki IOIO za pośrednictwem
przewodu USB; przełącznik PowerSwitch Tail (sterowany przez płytkę
IOIO) do gniazdka ściennego z jednej strony i 12-woltowego zasilacza
z drugiej strony oraz elektryczny rygiel do 12-woltowego zasilacza.
Musimy najpierw przylutować złącze kątowe JST do płytki IOIO. Z per-
spektywy klientów korzystających z urządzeń firmy Sparkfun byłoby oczy-
wiście dużo prościej, gdyby to złącze znajdowało się już na płytce. Może-
my jednak potraktować to zadanie jako jeden z odprężających aspektów
tego projektu (o ile nie popełnimy jakiegoś fatalnego błędu i przypadkowo
nie spalimy elektroniki na płytce). Lutowanie tego złącza na szczęście nie

10
http://www.sparkfun.com/products/10745
11
http://handbagdevices.com/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
200  9.2. Budowa rozwiązania

jest zbyt trudne, a po zakończeniu tego zadania zasilanie płytki i telefonu


z systemem Android będzie nieporównanie prostsze.
Po przylutowaniu złącza JST do płytki IOIO należy podłączyć do tej
płytki przewód barrel jack-JST (2-pin) oraz 5-woltowy zasilacz. Musimy
następnie połączyć płytkę IOIO z telefonem Android G1 za pomocą prze-
wodu USB. Połowa pracy za nami!
Należy teraz połączyć przewód dodatni i przewód ujemny elektrycznego
rygla odpowiednio do dodatniej i ujemnej końcówki przewodu z wtykiem
żeńskim barrel jack 2,1 mm. Przewody dodatnie są oznaczone białym
paskiem wzdłuż izolacji. Odsłonięte części tych przewodów należy zabezpie-
czyć za pomocą taśmy izolacyjnej lub (to rozwiązanie będzie lepsze) wężem
termokurczliwym. Przewód z końcówką barrel jack musimy jeszcze podłączyć
do 12-woltowego zasilacza.
Rygiel można przetestować, podłączając 12-woltowy zasilacz do standardo-
wego gniazdka elektrycznego. Zaraz po włączeniu zasilania powinna się
zapalić dioda na zasilaczu, a sam rygiel powinien wydawać charakterystyczne
dźwięki. Łatwo zauważyć, że w tym czasie zapadka sprężynowa zamka nie
jest blokowana przez rygiel (drzwi można otwierać i zamykać bez większe-
go oporu). Po wyciągnięciu 12-woltowego zasilacza z gniazdka rygiel powi-
nien wrócić do pierwotnego stanu, w którym jest nieruchomy. Po unieru-
chomieniu rygla zapadka zamka jest skutecznie blokowana.
Możemy teraz połączyć przełącznik PowerSwitch Tail z płytką IOIO. Nale-
ży podłączyć przewody zgodnie ze schematem pokazanym na rysunku 9.3
zatytułowanym „Schemat połączeń systemu zamka otwieranego przez An-
droida”. Przewód połączony z wtykiem uziemienia na płytce IOIO należy
połączyć z ujemną końcówką przełącznika PowerSwitch Tail.
Środkową końcówkę (sterowania) przełącznika PowerSwitch Tail należy
połączyć z wtykiem cyfrowym nr 3 na płytce IOIO. Dlaczego nie z wty-
kiem nr 0, 1 lub 2? Ponieważ nie wszystkie płytki IOIO mogą obsługiwać
sygnały 5 V potrzebne do zasilania przekaźnika w ramach przełącznika
PowerSwitch Tail. Pobieranie takiego prądu z wtyku, który nie jest przy-
stosowany do napięcia 5 V, może spowodować uszkodzenie płytki IOIO.
Warto poszukać niezbędnych informacji w serwisie wiki płytki IOIO lub
po prostu obrócić płytkę i znaleźć odpowiednio oznaczone wtyki12. Białe
kółko wokół wtyku oznacza, że dany wtyk może obsługiwać sygnały 5 V.

12
https://github.com/ytai/ioio/wiki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  201

Rysunek 9.3. Schemat połączeń systemu zamka otwieranego przez Androida

Po połączeniu wszystkich przewodów płytka IOIO powinna wyglądać tak jak


na rysunku 9.4 zatytułowanym „Schemat połączenia płytki IOIO z prze-
łącznikiem przekaźnikowym”.

Rysunek 9.4. Schemat połączenia płytki IOIO z przełącznikiem


przekaźnikowym

I wreszcie należy połączyć przewodem dodatnią końcówkę przełącznika


PowerSwitch Tail z dowolnym spośród trzech pinów 5 V w lewym dolnym
narożniku płytki IOIO. Obwód jest teraz kompletny.
Na tym etapie nic się nie wydarzy do momentu zaprogramowania niezbęd-
nych rozkazów włączających i wyłączających wtyk nr 3 (i wysyłających odpo-
wiednie sygnały do przełącznika PowerSwitch Tail). Warto więc przystąpić

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
202  9.3. Sterowanie zamkiem z poziomu Androida

do napisania prostego programu dla systemu Android — program będzie


wyświetlał na ekranie przełącznik, którego naciśnięcie spowoduje odpo-
wiednią zmianę stanu wtyku nr 3.

9.3. Sterowanie zamkiem


z poziomu Androida
Zanim przystąpimy do pisania rozbudowanej aplikacji serwera dla telefo-
nu z systemem Android, musimy napisać program testowy, który sprawdzi
obwód skonstruowany w poprzednim podrozdziale.
Musimy najpierw upewnić się, że na komputerze zainstalowane są środo-
wisko programowania Eclipse z wtyczką dla zestawu narzędzi Android
SDK oraz narzędzia Android Development Tools. Szczegółowy opis
procedury konfiguracji tego zestawu SDK i środowiska IDE można zna-
leźć w rozdziale 7. zatytułowanym „Internetowy włącznik światła”. Mo-
żemy następnie pobrać projekt demonstracyjny o nazwie HelloIOIO (projekt
jest dostępny na stronie internetowej z materiałami pomocniczymi dla płytki
IOIO)13. Projekt HelloIOIO jest prostą aplikacją włączającą i wyłączającą
diodę LED na płytce IOIO. Na potrzeby tego projektu zmodyfikujemy tę
prostą aplikację poprzez zadeklarowanie dodatkowego obiektu ToggleButton
w pliku układu main.xml. Musimy też dodać do pliku MainActivity.java
cztery wiersze kodu opisujące nową akcję (nazwaną ToggleButton) skojarzoną
z wtykiem cyfrowym nr 3 na płytce IOIO.
Aby zaimportować projekt HelloIOIO firmy Sparkfun do środowiska Eclipse,
należy wybrać opcję File/Import/Existing Projects. Alternatywnym rozwią-
zaniem jest załadowanie już zmodyfikowanego projektu HelloIOIO-PTS
(dostępnego wraz z kodem źródłowym dla tej książki), który zawiera już
wszystkie modyfikacje opisane w tym podrozdziale.
Wszystkie projekty dla płytki IOIO są tworzone na bazie biblioteki niestan-
dardowej IOIOLib. Oznacza to, że wspomnianą bibliotekę należy dodać
do każdego projektu dla płytki IOIO. W tym celu należy wykonać nastę-
pujące kroki:
1. Należy zaimportować pakiet IOIOLib do środowiska Eclipse, wy-
bierając opcję File/Import/Existing Projects into Workspace.

13
http://www.sparkfun.com/tutorials/280

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  203

2. W panelu Eclipse Package Explorer należy zaznaczyć projekt Hello-


IOIO.
3. Należy teraz wybrać opcję Properties z menu Project środowiska
Eclipse.
4. W lewej kolumnie wyświetlonego okna dialogowego Properties
należy wybrać pozycję Android.
5. Należy teraz kliknąć przycisk Add. Na ekranie powinno zostać wy-
świetlone okno dialogowe Project Selection z listą obejmującą projekt
IOIOLib. Należy zaznaczyć pozycję IOIOLib i kliknąć przycisk OK.
Jeśli biblioteka IOIOLib została prawidłowo zaimportowana, w sekcji Library
okna dialogowego Properties powinien pojawić się zielony znak akceptacji
(patrz rysunek 9.5 zatytułowany „Prawidłowo zaimportowana i wskazywana
biblioteka IOIOLib”).

Rysunek 9.5. Prawidłowo zaimportowana i wskazywana biblioteka IOIOLib

Po ustawieniu prawidłowej referencji do biblioteki IOIOLib możemy przy-


stąpić do edycji pliku /res/layout/main.xml należącego do projektu HelloIOIO.
Do już istniejącego układu należy dodać obiekt ToggleButton, kopiując
gotowy opis elementu TextView, który obejmuje opis kontrolki przełącznika

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
204  9.3. Sterowanie zamkiem z poziomu Androida

ToggleButton potrzebnej do włączania i wyłączania diody LED na płytce


IOIO. Dodatkowy element należy wkleić za oryginalną sekcją TextView.
Wartość identyfikatora skopiowanego przycisku przełącznika należy zmie-
nić na android:id="@+id/powertailbutton". Identyfikator będzie nam po-
trzebny w odwołaniach w kodzie zmodyfikowanej klasy MainActivity.
Zmieniony plik main.xml powinien teraz mieć następującą postać:
Plik AndroidDoorLock/HelloIOIO-PTS/res/layout/main.xml

<?xml version="1.0" encoding="utf-8"?>


<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent">
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/txtLED"
android:id="@+id/title"/>
<ToggleButton android:text="ToggleButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/button">
</ToggleButton>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/txtPowerTail"
android:id="@+id/title"/>
<ToggleButton android:text="ToggleButton"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:id="@+id/powertailbutton">
</ToggleButton>
</LinearLayout>

Musimy jeszcze dodać do klasy MainActivity kod drugiego przycisku, któ-


ry będzie włączał i wyłączał sygnał adresowany do przełącznika Power-
Switch Tail. Pierwszym dodatkowym elementem jest wiersz powertailbutton_
= (ToggleButton) findViewById(R.id.powertailbutton);, który kojarzy obiekt
powertailbutton_ z przyciskiem przełącznika powertailbutton zdefiniowanym
w pliku main.xml.
Możemy teraz dodać referencję do obiektu nowego przycisku sterującego
przełącznikiem PowerSwitch Tail (i dodanego do interfejsu użytkownika
aplikacji) — odpowiedni zapis należy umieścić w kodzie klasy MainActivity
w pliku /src/ioio/examples/hello/pts/MainActivity.java:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  205

Plik AndroidDoorLock/HelloIOIO-PTS/src/ioio/examples/hello/pts/MainActivity.java

private ToggleButton button_;


private ToggleButton powertailbutton_;

Obiekt powertailbutton_ należy skonstruować w metodzie OnCreate klasy


MainActivity:
Plik AndroidDoorLock/HelloIOIO-PTS/src/ioio/examples/hello/pts/MainActivity.java

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
button_ = (ToggleButton) findViewById(R.id.button);
powertailbutton_ = (ToggleButton) findViewById(R.id.powertailbutton);
}

Oznacza to, że po utworzeniu głównego okna aplikacji przycisk sterujący


przełącznikiem PowerSwitch Tail będzie dostępny za pośrednictwem klasy
MainActivity. Pozostaje nam już tylko napisanie kodu nasłuchującego akcji
związanych z przyciskiem powertailbutton_ (czyli zdarzeń włączania i wyłą-
czania tego przycisku):
Plik AndroidDoorLock/HelloIOIO-PTS/src/ioio/examples/hello/pts/MainActivity.java

class IOIOThread extends AbstractIOIOActivity.IOIOThread {


/** Wbudowana dioda LED. */
private DigitalOutput led_;
private DigitalOutput powertail_;
/**
* Metoda wywoływana podczas nawiązywania każdego połączenia z płytką IOIO.
* Metoda zwykle służy do otwierania wtyków.
*
* @throws ConnectionLostException
* W razie utraty połączenia z płytką IOIO.
* @see ioio.lib.util.AbstractIOIOActivity.IOIOThread#setup()
*/
@Override
protected void setup() throws ConnectionLostException {
led_ = ioio_.openDigitalOutput(0, true);
powertail_ = ioio_.openDigitalOutput(3,true);
}
/**
* Metoda wielokrotnie wywoływana w czasie, gdy połączenie z płytką IOIO
* jest aktywne.
*
* @throws ConnectionLostException
* W razie utraty połączenia z płytką IOIO.
*
* @see ioio.lib.util.AbstractIOIOActivity.IOIOThread#loop()
*/
@Override
protected void loop() throws ConnectionLostException {
led_.write(!button_.isChecked());

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
206  9.3. Sterowanie zamkiem z poziomu Androida

powertail_.write(!powertailbutton_.isChecked());
try {
sleep(10);
} catch (InterruptedException e) {
}
}
}

Inicjalizacja obiektu powertail_ klasy DigitalOutput.


Przypisuje obiekt powertail_ do wtyku cyfrowego nr 3 na płytce IOIO.
Włącza lub wyłącza sygnał cyfrowy (zmienia stan na wysoki lub niski)
wtyku nr 3 na płytce IOIO w odpowiedzi na włączenie lub wyłączenie
widocznego na ekranie telefonu przycisku dla przełącznika przekaźni-
kowego PowerSwitch Tail.
Włączenie przycisku dla przełącznika PowerSwitch Tail powoduje, że obiekt
powertailbutton_ wysyła sygnał 5 V za pośrednictwem wtyku cyfrowego nr 3.
Wysłanie tego sygnału powoduje z kolei włączenie zasilania przełącznika
przekaźnikowego i tym samym zwolnienie elektrycznego rygla zasilanego
12-woltowym zasilaczem.
Należy teraz zapisać zmiany, skompilować aplikację systemu Android oraz
zainstalować zmodyfikowany program HelloIOIO w telefonie. Warto też
jeszcze raz sprawdzić, czy obwód łączący wszystkie urządzenia z elektrycz-
nym ryglem jest prawidłowo zainstalowany i zasilany. Możemy następnie
połączyć telefon z płytką IOIO za pomocą przewodu USB i uruchomić
zmodyfikowany program HelloIOIO na telefonie z systemem Android.
Jeśli naciśnięcie przycisku niczego nie zmieni, należy sprawdzić, czy w telefo-
nie włączono tryb diagnostyczny (USB Debugging). Warto też sprawdzić, czy
wszystkie przewody są prawidłowo podłączone. Czytelnicy, którzy mają
dostęp do multimetru lub oscyloskopu, mogą dodatkowo sprawdzić, czy
po włączeniu widocznego na ekranie telefonu przycisku dla przełącznika Po-
werSwitch Tail napięcie na cyfrowym wtyku nr 3 rzeczywiście wynosi 5 V.
Jeśli napięcie wyjściowe jest niższe, sygnał od pytki IOIO do przełącznika
przekaźnikowego PowerSwitch Tail będzie zbyt słaby, zatem zasilanie
elektrycznego rygla nie zostanie włączone.
Skoro wszystkie elementy sprzętowe działają prawidłowo, możemy przystąpić
do dostosowywania zamka do otwierania za pośrednictwem internetu (po-
przez żądanie odpowiedniego adresu URL serwera WWW). Kod serwera
musimy dodać do zmodyfikowanego programu HelloIOIO.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  207

9.4. Pisanie kodu serwera


dla systemu Android
Czas przystąpić do pisania serwera systemu zamka do drzwi. Zamiast uru-
chamiać skrypty języka Python (odpowiedzialne za przetwarzanie żądań
przychodzących) na komputerze PC, w tym projekcie wykorzystamy moc
obliczeniową samego smartfonu z systemem Android. Nawet starsze telefony
z systemem Android oferują większą moc obliczeniową od tradycyjnych
komputerów z czasów poprzedzających wydanie systemu operacyjnego
Android o zaledwie kilka lat.
Zastosowanie telefonu z systemem Android, który będzie pełnił funkcję
serwera projektu, ma jeszcze kilka innych zalet:
 Zużycie energii elektrycznej jest nieporównanie niższe niż w przypad-
ku komputera stacjonarnego, zatem cały system jest bardziej przyjazny
dla środowiska.
 Telefon dysponuje wbudowanym modułem komunikacji bezprzewo-
dowej Wi-Fi, zatem można go umieścić w dowolnym miejscu w za-
sięgu punktu dostępowego.
 Telefon dysponuje wbudowanym aparatem fotograficznym, który
można zaprogramować przy użyciu standardowych wywołań zestawu
SDK, aby robić zdjęcia i przetwarzać otrzymywane w ten sposób
obrazy.
 Telefon dysponuje też innymi mechanizmami, jak moduł Bluetooth
czy syntezator mowy, które wykorzystamy w projekcie systemu na-
dającego głos naszemu domowi.
Aplikacja serwera WWW działająca na serwerze musi wykonywać nastę-
pujące operacje:
1. Musi uruchomić instancję standardowej usługi sieciowej i nasłuchi-
wać żądań przychodzących na określony adres URL.
2. Po otrzymaniu żądania wysłanego na ten adres URL program przez
pięć sekund wysyła sygnał w celu zasilania wtyku nr 3 na płytce
IOIO. Sygnał powinien spowodować zwolnienie elektrycznego
rygla na czas potrzebny do otwarcia drzwi.
3. Po pięciu sekundach program powinien użyć aparatu wbudowanego
w urządzenie serwera do zrobienia zdjęcia osoby wchodzącej przez
odblokowane drzwi.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
208  9.4. Pisanie kodu serwera dla systemu Android

Jaś pyta...
Czym jest intencja systemu Android?
Zgodnie z dokumentacją systemu Android dla programistów intencja
to „abstrakcyjny opis operacji do wykonania”14. W największym skró-
cie intencje służą do wysyłania i odbierania komunikatów przekazy-
wanych pomiędzy działaniami i usługami systemu Android. Inten-
cje umożliwiają także wysyłanie komunikatów do tej samej aplika-
cji, która je generuje, jednak zdecydowanie częściej służą do wy-
syłania komunikatów z jednej aplikacji (na przykład przeglądarki
internetowej, która pobrała plik audio) do innej aplikacji (na przykład
odtwarzacza muzycznego).
Jeśli zarejestrowano wiele aplikacji otrzymujących określone komuni-
katy, na ekranie może być wyświetlane okno dialogowe z prośbą
o wybór właściwej aplikacji, do której ma być adresowany dany
komunikat. Każdy doświadczony użytkownik urządzenia z systemem
Android wielokrotnie miał do czynienia ze wspomnianym oknem
dialogowym. System operacyjny Android umożliwia użytkowni-
kom zaznaczenie w tym oknie dialogowym pola wyboru aplikacji
domyślnej, tak aby podobne pytania nie były ponownie wyświe-
tlane i nie denerwowały właściciela telefonu.
Konieczność proszenia użytkownika o wskazanie docelowej apli-
kacji powoduje, że w przypadku w pełni autonomicznych operacji
(na przykład wysyłania wiadomości poczty elektronicznej) mecha-
nizm intencji jest dalece nieoptymalny. Problem w tym, że aplikacja
wysyłająca tego rodzaju komunikaty (w tym przypadku aplikacja
poczty elektronicznej) może wymagać od użytkownika wykonania
dodatkowych czynności (na przykład kliknięcia przycisku Wyślij w pro-
gramie poczty elektronicznej, aby ostatecznie wysłać wiadomość
poczty elektronicznej wygenerowaną przez program źródłowy).

4. Uzyskany w ten sposób plik graficzny należy wysłać w formie załącz-


nika do wiadomości poczty elektronicznej wysyłanego do wskazanego
adresata.

14
http://developer.android.com/reference/android/content/Intent.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  209

5. Oprogramowanie serwera powinno wrócić do stanu bezczynności


i czekać na następne prawidłowo sformatowane żądanie przychodzące,
aby od nowa rozpocząć cały ten cykl.
Aby skonstruować ten serwer WWW, wykorzystamy fragmenty kodu pro-
jektu open source GNU GPLv3 Android Web Server dostępnego w serwi-
sie Google Code15. Posłużymy się także gotowym kodem (dzięki uprzejmości
Jona Simona) do wysyłania wiadomości poczty elektronicznej z załącznikami
z poziomu aplikacji systemu Android bez konieczności stosowania intencji16.
Ponieważ większość intencji wymaga dodatkowych czynności użytkownika,
opisany mechanizm nie zda egzaminu w przypadku autonomicznego serwe-
ra WWW. Połączenie tych dwóch projektów z kodem obsługującym płytkę
IOIO umożliwi naszemu programowi autonomiczne nasłuchiwanie żądań
odblokowania drzwi i reagowanie na te żądania. W tym projekcie wykorzy-
stamy także fragmenty kodu programu Camera Sample napisanego przez
Krishnaraja Varmę — kod pobiera zdjęcie z modułu aparatu i zapisuje je
na karcie SD włożonej do urządzenia z systemem Android17. Właśnie ten
plik graficzny wyślemy w formie załącznika do wiadomości poczty elektro-
nicznej. Zanim jednak przystąpimy do pracy nad programem dla systemu
Android, który połączy te wszystkie elementy, musimy opracować mecha-
nizm dostępu do adresu IP przypisanego do danego telefonu.

Ustawianie statycznego adresu IP


Konwersja adresu IP wbudowanego modułu Wi-Fi telefonu z dynamicznego
na statyczny znacznie ułatwi powtarzalne lokalizowanie telefonu w lokalnej,
domowej sieci bezprzewodowej. Czytelnicy, którzy do tej pory nie utwo-
rzyli przedziału statycznych adresów IP w konfiguracji swojego routera,
mogą albo zdefiniować taki przedział, albo ustawić adres telefonu większy
niż 200 (o ile sieć domowa nie obejmuje dużej liczby urządzeń żądających
adresów IP od serwera DHCP w ramach routera bezprzewodowego).

15
http://code.google.com/p/android-webserver/
16
http://www.jondev.net/articles/Sending_Emails_without_User_Intervention_
%28no_Intents%29_in_Android
17
http://code.google.com/p/krvarma-android-samples/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
210  9.4. Pisanie kodu serwera dla systemu Android

Dostęp do konfiguracji większości telefonów z systemem Android można


uzyskać, wybierając ikonę Ustawienia i przechodząc do menu Komunikacja.
Należy następnie wybrać opcję Ustawienia Wi-Fi i nacisnąć przycisk menu
samego telefonu, aby wyświetlić menu z opcjami Skanuj i Zaawansowane.
Należy teraz kliknąć opcję Zaawansowane. Na ekranie zostaną wyświe-
tlone opcje umożliwiające modyfikację wielu ustawień sieciowych, w tym
pole wyboru Użyj statycznego adresu. Należy zaznaczyć to pole wyboru,
aby umożliwić ustawienie adresu IP, adresu bramy i maski podsieci (patrz
rysunek 9.6 zatytułowany „Konfiguracja urządzenia z systemem Android
ustawiająca statyczny adres IP”). Opcje należy dostosować do konfiguracji
routera sieci bezprzewodowej. Jeśli na przykład router sieci bezprzewodowej
udostępnia przedział adresów, począwszy od 192.168.1.2, najprawdopo-
dobniej będziemy mogli zastosować następujące ustawienia:
 adres IP: 192.168.1.230,
 brama: 192.168.1.1,
 maska sieci: 255.255.255.0.

Rysunek 9.6. Konfiguracja urządzenia z systemem Android ustawiająca


statyczny adres IP

Należy jeszcze ustawić wartości opcji DNS1 i DNS2, przypisując im adresy


wybranych serwerów DNS (w mojej konfiguracji wykorzystałem publiczne
serwery DNS firmy Google), jednak najlepiej użyć w tej roli tych samych
serwerów nazw domen, które są stosowane przez pozostałe urządzenia
w danej sieci (w ten sposób ułatwimy sobie konserwację sieci lokalnej). Po
wpisaniu wszystkich statycznych adresów należy kliknąć przycisk Menu
urządzenia z systemem Android i wybrać opcję Zapisz.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  211

Warto jeszcze przetestować statyczny adres IP telefonu, wysyłając na ten


adres sygnał ping za pośrednictwem innego komputera w tej sieci. Po prawi-
dłowym ustawieniu adresu IP polecenie ping powinno potwierdzić po-
prawność konfiguracji. W razie problemów warto raz jeszcze sprawdzić
wszystkie ustawienia i upewnić się, że zmiany zostały zapisane. Po potwier-
dzeniu poprawności konfiguracji adresu IP możemy przystąpić do pisania
i testowania kodu serwera WWW działającego w systemie Android.

Tworzenie serwera WWW dla systemu Android


W systemie Android działa zmodyfikowana wersja wirtualnej maszyny Javy
(JVM), zatem mamy do dyspozycji wiele bibliotek standardowych Javy.
Dostęp do tych bibliotek jest dla nas o tyle ważny, że jedna z nich znacznie
ułatwia tworzenie i uruchamianie serwera WWW za pomocą zaledwie kilku
wierszy kodu.
Żeby nie tracić miejsca w tej książce na prezentację zawartości dziesiątek
plików składających się na kompletny kod tego programu, udostępniony zo-
stał do pobrania plik DoorLockServer.zip. Po pobraniu i rozpakowaniu
tego pliku należy zaimportować odpowiedni projekt do środowiska Eclipse
ze skonfigurowanym zestawem narzędzi Android SDK (za pomocą opcji
File/Import). Podczas analizy plików zawartych w tym archiwum łatwo za-
uważyć plik nazwany AndroidDoorLockServerActivity.java. Warto zwrócić
uwagę na dwa wiersze kodu w ciele metody private void startServer(int
port), w których wykorzystano adres IP, numer portu i domyślny mecha-
nizm komunikatów systemu Android do uruchomienia serwera WWW na
telefonie.
server = new Server(ipAddress,port,mHandler);
server.start();

Przytoczone wyrażenia importują referencję do obiektu klasy ServerSocket


i wymuszsają na systemie Android nasłuchiwanie na porcie nr 80 usta-
wionego wcześniej statycznego adresu IP. Zarządzanie serwerem wymaga
oczywiście wielu dodatkowych operacji, jak uruchamianie i zatrzymywanie
serwera za pośrednictwem interfejsu użytkownika, przekształcenie serwera
w usługę systemu Android, która będzie działała w tle, unikanie przecho-
dzenia telefonu w tryb uśpienia, przetwarzanie żądań przychodzących czy
obsługa błędów.
Skoro dysponujemy już podstawowymi wymaganiami dotyczącymi serwera
WWW działającego na urządzeniu z systemem Android, możemy przystąpić

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
212  9.4. Pisanie kodu serwera dla systemu Android

do łączenia istniejących rozwiązań z funkcjami płytki IOIO opracowanymi


w podrozdziale 9.3 zatytułowanym „Sterowanie zamkiem z poziomu An-
droida”.

Serwer WWW i płytka IOIO


Sytuacja robi się dość interesująca. Połączenie aplikacji testowej dla płytki
IOIO, którą napisaliśmy w podrozdziale 9.3 zatytułowanym „Sterowanie
zamkiem z poziomu Androida”, z serwerem WWW opracowanym w po-
przednim punkcie umożliwi włączanie zasilania wtyku nr 3 na płytce IOIO
za pośrednictwem żądania protokołu HTTP. W ten sposób nasz system
będzie sygnalizował przełącznikowi PowerSwitch Tail konieczność włą-
czenia zasilania elektrycznego rygla. W największym skrócie przeniesiemy
odpowiednią funkcję obsługującą płytkę IOIO do kodu odpowiedzialnego
za obsługę żądań protokołu HTTP po stronie serwera WWW. Elek-
tryczny rygiel będzie zasilany (umożliwiając otwarcie drzwi) na przykład
poprzez wywołanie adresu URL http://192.168.1.230.
Nie chcemy jednak, by drzwi były otwarte na stałe (taki byłby wynik pozosta-
wienia włączonego wtyku nr 3), zatem po pewnym czasie nasz system wyłączy
zasilanie. Na potrzeby naszych testów pięć sekund powinno w zupełności
wystarczyć. Do wstrzymania wykonywania programu na określony czas uży-
jemy funkcji Thread.sleep() systemu Android. Doświadczeni programiści
aplikacji dla systemu Android doskonale wiedzą, że ten sposób wstrzymywa-
nia wykonywania programu jest dalece niedoskonały, ponieważ uniemoż-
liwia właściwe reagowanie interfejsu użytkownika. Ponieważ jednak w tym
przypadku urządzenie z systemem Android będzie używany w roli serwera,
nie klienta, nie musimy tracić czasu na optymalizację interfejsu użytkowni-
ka. Ustawiłem pięciosekundowe opóźnienie (Thread.sleep(5000)), jednak
równie dobrze można zmienić tę wartość, aby rygiel był blokowany nieco
szybciej lub później (zależnie od przebiegu testów).
Tak jak w poprzednim punkcie warto przeanalizować kod zawarty w pliku
DoorLockServer.zip. Po otwarciu tego projektu w środowisku Eclipse warto
zwrócić uwagę na klasę AndroidDoorLockServerActivity. Z naszego punktu
widzenia szczególnie interesujący jest blok try aktywujący zasilanie przełącz-
nika PowerSwitch Tail na pięć sekund i wywołujący funkcję camerasurface.
startTakePicture(), która robi zdjęcie za pomocą wbudowanego aparatu
w urządzeniu z systemem Android.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  213

Plik AndroidDoorLock/DoorLockServer/src/com/mysampleapp/
androiddoorlockserver/AndroidDoorLockServerActivity.java

@Override
protected void loop() throws ConnectionLostException {

if (mToggleButton.isChecked()) {
if (LockStatus.getInstance().getLockStatus()) {
try {
powertail_.write(false);
// wstrzymuje działanie na 5 sekund
// (przez ten czas zamek jest otwarty)
sleep(5000);
powertail_.write(true);
LockStatus.getInstance().setMyVar(false);
// Robi zdjęcie i wysyła je w formie załącznika
// do wiadomości e-mail
camerasurface.startTakePicture();
} catch (InterruptedException e) {
}
}else {
try {
sleep(10);
} catch (InterruptedException e) {
}
}
} else {
powertail_.write(true);
}
}

Możemy teraz skompilować i uruchomić projekt DoorLockServer na


urządzeniu z systemem Android. Musimy jeszcze uruchomić serwer WWW
na tym urządzeniu. Warto raz jeszcze sprawdzić, czy urządzenie jest prawi-
dłowo połączone z płytką IOIO i czy ta płytka jest prawidłowo podłączona
do przełącznika PowerSwitch Tail. Możemy teraz wpisać adres IP naszego
serwera WWW w dowolnej przeglądarce internetowej z dostępem do sieci
lokalnej. Jeśli wszystko poszło zgodnie z planem, elektryczny rygiel powinien
zostać odblokowany na kilka sekund, po czym ponownie zablokowany. Super!
Mamy za sobą dwie trzecie zadań składających się na ten projekt. Ostatni
komponent tego systemu będzie odpowiadał za robienie zdjęć — implemen-
tacja tego rozwiązania jest możliwa, ponieważ większość urządzeń z sys-
temem Android (przynajmniej większość telefonów z tym systemem) zawiera
wbudowany aparat. Wykorzystamy dostępne urządzenia sprzętowe do robie-
nia zdjęcia osoby wchodzącej do domu kilka sekund po żądaniu otwarcia
drzwi (i odblokowaniu elektrycznego rygla); zdjęcie zostanie następnie wy-
słane do właściwego adresata w formie załącznika do wiadomości poczty

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
214  9.4. Pisanie kodu serwera dla systemu Android

elektronicznej. Dzięki temu będziemy wiedzieć nie tylko, kiedy miało miejsce
żądanie otwarcia drzwi wejściowych, ale też kto wszedł do domu po automa-
tycznym odblokowaniu zamka.

Robienie zdjęcia
Na potrzeby tego aspektu projektu należy przeanalizować zawartość pliku
CameraSurface.java w rozpakowanym katalogu DoorLockServer. Najważ-
niejsze funkcje potrzebne do utworzenia obiektu powierzchni aparatu i uzy-
skania obrazu zostały dość dobrze udokumentowane w zestawie narzędzi
Android SDK. Co więcej, w internecie istnieją dosłownie setki przykła-
dów kodu i poradników dotyczących uzyskiwania plików graficznych ze
zdjęciami w systemie Android18. Mechanizm pobierania obrazów w ramach
aplikacji serwera WWW opracowałem na bazie przykładowego kodu pro-
gramisty aplikacji systemu Android Krishnaraja Varmy.
Konfiguracja aparatu używanego w kodzie aplikacji systemu Android wymaga
zaimportowania wielu przestrzeni nazw tego systemu. W tym celu musimy
wykonać kilka dodatkowych kroków przygotowujących powierzchnię wy-
świetlania. Oto najważniejsze biblioteki używane w części programu od-
powiedzialnej za uzyskanie obrazu (w ramach pliku DoorLockServer.zip):
Plik AndroidDoorLock/DoorLockServer/src/com/mysampleapp/androiddoorlockserver/
CameraSurface.java

import android.content.Context;
import android.hardware.Camera;
import android.hardware.Camera.AutoFocusCallback;
import android.hardware.Camera.PictureCallback;
import android.hardware.Camera.ShutterCallback;
import android.util.AttributeSet;
import android.view.GestureDetector;
import android.view.MotionEvent;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.GestureDetector.OnGestureListener;

Oprócz dostępu do urządzenia aparatu fotograficznego musimy jeszcze


zaimplementować mechanizm wyświetlania podglądu zrobionego zdjęcia
na ekranie telefonu. W tym celu musimy najpierw zainicjalizować zmienne
klatki i powierzchni aparatu:
private FrameLayout cameraholder = null;
private CameraSurface camerasurface = null;

18
http://developer.android.com/reference/android/hardware/Camera.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  215

Zmienne będą nam potrzebne do prawidłowej alokacji obiektów powierzchni


i klatki aparatu:
camerasurface = new CameraSurface(t is);
cameraholder.addView(camerasurface, new
LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));

Krishnaraj użył wywołań zwrotnych, aby wstrzymać wykonywanie pewnych


operacji do czasu zakończenia przetwarzania. Wspomniany mechanizm
umożliwił na przykład oczekiwanie na ustawienie autofocusu, na zamknięcie
migawki oraz na sprawdzenie, czy dane obrazu zostały prawidłowo zapi-
sane na karcie SD. Zastosowanie wywołań zwrotnych gwarantuje nam, że
wymienione zdarzenia będą występowały jedno po drugim i że żadna z tych
operacji nie rozpocznie się przed zakończeniem poprzedniej.
Plik AndroidDoorLock/DoorLockServer/src/com/mysampleapp/androiddoorlockserver/
CameraSurface.java

public void startTakePicture(){


camera.autoFocus(new AutoFocusCallback() {
@Override
public void onAutoFocus(boolean success, Camera camera) {
takePicture();
}
});
}

public void takePicture() {


camera.takePicture(
new ShutterCallback() {
@Override
public void onShutter(){
if(null != callback) callback.onShutter();
}
},
new PictureCallback() {
@Override
public void onPictureTaken(byte[] data, Camera camera){
if(null != callback) callback.onRawPictureTaken(data, camera);
}
},
new PictureCallback() {
@Override
public void onPictureTaken(byte[] data, Camera camera){
if(null != callback) callback.onJpegPictureTaken(data, camera);
}
});
}

Dane są zapisywane na karcie SD w ciele metody onJpegPictureTaken.


Ponieważ plik graficzny ma być wysłany w formie załącznika do wiadomości
poczty elektronicznej i ponieważ kolejne zdjęcia nie wymagają archiwizacji

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
216  9.4. Pisanie kodu serwera dla systemu Android

na karcie SD, dane są za każdym razem zapisywane w jednym, tak samo


nazwanym pliku.
FileOutputStream outStream = new
FileOutputStream(String.format("/sdcard/capture.jpg"));

outStream.write(data);
outStream.close();

Czytelnicy, którzy wolą, aby każde kolejne zdjęcie było trwale zapisywane
na karcie SD (zamiast nadpisywać tak samo nazwany plik z poprzednim
zdjęciem), mogą dopisywać do nazwy pliku graficznego przyrostek znacznika
czasowego — oto rozwiązanie zastosowane w oryginalnym kodzie Krish-
naraja:
FileOutputStream outStream = ne FileOutputStream(String.format(
"/sdcard/%d.jpg", System.currentTimeMillis()));

Takie rozwiązanie nie jest jednak zalecane, jeśli na karcie SD nie ma dosta-
tecznie dużo przestrzeni i jeśli nie planujemy przechowywać tych samych
obrazów w telefonie i w skrzynce odbiorczej poczty elektronicznej. Czytel-
nicy, którzy zdecydują się na stosowanie tego schematu nazewnictwa, mu-
szą pamiętać o konieczności rejestrowania nazw plików z odpowiednimi
znacznikami czasowymi, aby na tej podstawie wybierać właściwe załączniki
do wysyłanych wiadomości. Przeanalizujmy teraz sposób dołączania obra-
zów do wiadomości poczty elektronicznej i wysyłania tych wiadomości.

Wysyłanie wiadomości
Skoro już pobraliśmy i zapisaliśmy na karcie SD tymczasowy plik obrazu
ze zdjęciem (zrobionym za pomocą wbudowanego aparatu), musimy jesz-
cze użyć autonomicznego mechanizmu dołączania tego zdjęcia do tworzo-
nej wiadomości (bez konieczności angażowania użytkownika). Na szczęście
możemy użyć do tego celu kodu JavaMail for Android autorstwa Jona Simo-
na. Projekt obejmuje między innymi funkcję wysyłania wiadomości poczty
elektronicznej w systemie Android. W tym celu musimy pobrać i dodać
do projektu zależności (pliki jar) potrzebne do działania JavaMail for
Android i kodu Jona obsługującego wiadomości poczty elektronicznej19.
Odpowiedni kod możemy zmodyfikować z myślą o wysyłaniu załączników
z plikami graficznymi. Musimy najpierw zaimportować wiele bibliotek
Javy używanych przez klasę JavaMail:

19
http://code.google.com/p/javamail-android/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  217

import java.util.Date;
import java.util.Properties;
import javax.activation.CommandMap;
import javax.activation.DataHandler;
import javax.activation.DataSource;
import javax.activation.FileDataSource;
import javax.activation.MailcapCommandMap;
import javax.mail.BodyPart;
import javax.mail.Multipart;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeBodyPart;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;

Metody public Mail(String user, String pass) i public void addAttachment


(String filename) throws Exception umożliwiają nam łatwe wysyłanie plików
ze zdjęciami do wyznaczonego adresata. Wysyłanie wiadomości poczty
elektronicznej jest bardzo proste — wystarczy ustawić w ciele metody onJpeg
PictureTaken() (w pliku AndroidDoorLockServerActivity.java) nazwę użyt-
kownika, hasło, adres odbiorcy i parametry załącznika:
try
GMailSender mail = new GMailSender("NAZWA_KONTA_GMAIL@gmail.com",
"HASŁO_DO_KONTA_GMAIL");
mail.addAttachment(Environment.getExternalStorageDirectory() +
"/capture.jpg");
String[] toArr = {"ADRES_ODBIORCY_WIADOMOŚCI@gmail.com"};
mail.setTo(toArr);
mail.setFrom("NAZWA_KONTA_GMAIL@gmail.com");
mail.setSubject("Nowe zdjęcie");
mail.setBody("System zrobił zdjęcie - patrz załącznik");
if(mail.send()) {
Toast.makeText(AndroidDoorLockServerActivity.this,
"Wiadomość e-mail została prawidłowo wysłana.",
Toast.LENGTH_LONG).show();
} else {
Toast.makeText(AndroidDoorLockServerActivity.this,
"Wiadomość e-mail nie została wysłana.",
Toast.LENGTH_LONG).show();
}
} catch (Exception e) {
Log.e("SendMail", e.getMessage(), e);
}

Łańcuchy NAZWA_KONTA_GMAIL@gmail.com, HASŁO_DO_KONTA_GMAIL i ADRES_ODBIORCY_


WIADOMOŚCI@gmail.com należy oczywiście zastąpić danymi pasującymi do
naszego konta Gmail. Warto pamiętać o możliwości wysyłania wiadomo-
ści do użytkowników, którzy nie posługują się adresem usługi Gmail — rów-
nie dobrze można powiadamiać użytkowników innych kont pocztowych.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
218  9.4. Pisanie kodu serwera dla systemu Android

Na proces wysyłania wiadomości składa się jeszcze kilka innych wyrażeń


przygotowawczych. Warto dobrze przeanalizować pobrany kod, aby lepiej
zrozumieć wszystkie zależności i procesy potrzebne do wysłania wiadomo-
ści poczty elektronicznej z urządzenia z systemem Android bez udziału
użytkownika.

Ustawianie uprawnień dostępu do urządzeń


Nasz system jest prawie gotowy. Połączenie czterech odrębnych progra-
mów dla systemu Android w jedną aplikację umożliwi nasłuchiwanie żądań
przychodzących protokołu HTTP, odblokowywanie elektrycznego rygla
za pośrednictwem płytki IOIO, robienie zdjęć za pomocą wbudowanego
aparatu urządzenia z systemem Android oraz wysyłanie tych zdjęć w formie
załączników do wiadomości poczty elektronicznej.
Dysponujemy już kodem odpowiedzialnym za robienie zdjęć i wysyłanie ich
za pośrednictwem wiadomości poczty elektronicznej, pozostaje nam już tylko
zaimplementowanie mechanizmów dostępu do aparatu, modułu komunikacji
bezprzewodowej Wi-Fi i obsługi sieci. Oznacza to, że plik AndroidMani-
fest.xml musi zawierać nie tylko uprawnienia dostępu do stosu sieci i ko-
munikacji bezprzewodowej w technologii Wi-Fi, ale także uprawnienia
dostępu do wbudowanego aparatu i karty SD:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.mysampleapp.androiddoorlockserver"
android:versionCode="1"
android:versionName="1.0">
<uses-sdk android:minSdkVersion="3" />
<uses-permission android:name="android.permission."></uses-permission>
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE">
</uses-permission>
<uses-permission android:name="android.permission.INTERNET">
</uses-permission>
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-feature android:name="android.hardware.camera" />
<uses-feature android:name="android.hardware.camera.autofocus"/>
<uses-permission android:name="android.permission.CAMERA"/>
<uses-permission android:name="android.permission.VIBRATE"/>
<uses-permission
android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
<application android:icon="@drawable/icon"
android:label="@string/app_name">
<activity android:name=".AndroidDoorLockServerActivity"
android:label="@string/app_name"
android:screenOrientation="landscape">
<intent-filter>

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  219

<action android:name="android.intent.action.MAIN" />


<category
android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

Po ustawieniu adresu IP sieci lokalnej oraz nazwy usżytkownika, hasła


i docelowego adresu poczty elektronicznej możemy skompilować, zainsta-
lować i uruchomić aplikację serwera systemu zamka sterowanego przez
Androida na smartfonie z tym systemem.

Testowanie serwera
Serwer tego projektu można przetestować, uzyskując dostęp do jego adresu
URL z poziomu przeglądarki internetowej. Warto sprawdzić, czy elek-
tryczny zamek rzeczywiście został otwarty, czy aparat zrobił zdjęcie i czy
to zdjęcie zostało wysłane do wybranego adresata w formie załącznika
wiadomości poczty elektronicznej. Jeśli wszystko działa zgodnie z oczekiwa-
niami, możemy sobie pogratulować dobrze wykonanej pracy. Zważywszy
na liczę zależności występujących w tym projekcie, prawidłowe połączenie
wszystkich tych elementów już za pierwszym razem można potraktować
jako dobry powód do świętowania. Jeśli coś nie działa prawidłowo, warto
uważnie przeanalizować każdą funkcję z osobna. Czy serwer WWW od-
powiada na żądania? Czy przełącznik PowerSwitch Tail włącza zasilanie
elektrycznego rygla? Czy migawka aparatu fotograficznego zamyka się?
Warto pamiętać, że w zależności od szybkości połączenia sieciowego i mo-
dułu komunikacji bezprzewodowej Wi-Fi wbudowanego w telefon z syste-
mem Android wysłanie zdjęcia za pośrednictwem poczty elektronicznej
może zająć nawet minutę.
Podczas realizacji tego projektu udało nam się osiągnąć całkiem sporo —
już teraz moglibyśmy używać systemu zdalnie otwieranego zamka poprzez
wpisywanie odpowiedniego adresu URL w przeglądarce internetowej.
Warto jednak poświęcić jeszcze dosłownie chwilę na opracowanie własnej
aplikacji klienckiej, która będzie uzyskiwała dostęp do wspomnianego adresu
URL (podobnie jak w przypadku projektu internetowego włącznika światła).
Dzięki temu będziemy mogli otworzyć drzwi za pomocą zaledwie jednego
kliknięcia. Docelowo moglibyśmy zgromadzić więcej funkcji automatyzacji
domu w jednym programie mobilnym, który umożliwi dostęp do różnych
projektów za pośrednictwem jednego zbiorczego interfejsu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
220  9.5. Pisanie aplikacji klienckiej dla systemu Android

9.5. Pisanie aplikacji klienckiej


dla systemu Android
Napisanie kodu aplikacji klienckiej dla systemu Android, która będzie wysy-
łała polecenia odblokowania drzwi do programu serwera, nie jest niczym
trudnym. W tym podrozdziale ponownie użyjemy kodu aplikacji klienckiej
systemu Android z projektu internetowego włącznika światła, aby zapewnić
użytkownikowi łatwy dostęp do funkcji zwalniającej elektryczny rygiel. Tym
razem użyjemy zwykłego przycisku (zamiast przełącznika), ponieważ za-
implementowaliśmy już mechanizm odblokowywania zamka na pięć sekund.
Skoro dysponujemy mechanizmem czasowym, stosowanie przełącznika nie
jest konieczne. Innym elementem, który dodamy do tej aplikacji, jest kod
włączający moduł sieci bezprzewodowej (o ile nie jest aktywny).
Po uruchomieniu programu sprawdzamy, czy dostęp do modułu sieci bez-
przewodowej Wi-Fi jest możliwy. Jeśli ten moduł jest wyłączony, włączamy
go i czekamy, aż program kliencki nawiąże połączenie z siecią. Umożliwiamy
użytkownikowi naciśnięcie wyświetlonego przycisku Otwórz drzwi — po
wykryciu naciśnięcia tego przycisku aplikacja uzyskuje dostęp do adresu
URL serwera i zwalnia elektryczny rygiel. W największym uproszczeniu
aplikacja kliencka wykonuje następujące kroki:
1. Musimy utworzyć w środowisku Eclipse projekt aplikacji dla sys-
temu Android nazwany DoorLockClient.
2. Należy sprawdzić (w głównej ścieżce programu), czy moduł ko-
munikacji bezprzewodowej Wi-Fi jest włączony. Jeśli moduł Wi-
Fi jest wyłączony, musimy aktywować ten moduł.
3. Należy dodać przycisk do opisu układu main.xml i oznaczyć nowy
przycisk etykietą Otwórz drzwi.
4. Musimy powiązać obiekt przycisku w ramach klasy DoorLock z me-
todą nasłuchującą zdarzenia naciśnięcia tego przycisku. Jeśli pro-
gram musi włączyć moduł Wi-Fi, przycisk Otwórz drzwi powinien
być niedostępny przez kilka sekund — ten czas jest potrzebny na
uwierzytelnienie interfejsu Wi-Fi w bezprzewodowym punkcie dostę-
powym i uzyskanie adresu IP urządzenia klienckiego.
5. Należy dodać wywołanie żądania adresowanego na adres URL
serwera systemu otwierania drzwi (na przykład na adres 192.168.
1.230).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  221

Kwestie bezpieczeństwa
Jedną z zalet własnej, niestandardowej aplikacji klienckiej dla systemu
Android jest możliwość zabezpieczenia (choć trzeba przyznać, że
niezbyt skutecznego) dostępu do zdalnie sterowanego zamka. Po-
nieważ adres URL serwera WWW, na który wysyłamy żądanie otwarcia
drzwi, nie jest wyświetlany na ekranie smartfonu, adres ten pozostanie
ukryty przynajmniej dla użytkowników, którzy nie potrafią odnaleźć
odpowiednich zapisów w kodzie źródłowym. Opisane zabezpieczenie
nie gwarantuje jednak skuteczności, ponieważ sam adres URL jest wy-
syłany na serwer w formie zwykłego tekstu. Jedno z rozszerzeń tego
projektu, które zaproponuję w dalszej części tego rozdziału (w pod-
rozdziale „Następne kroki”), będzie dotyczyło właśnie dodania lepszych
mechanizmów zabezpieczeń. Dodanie hasła lub (co byłoby jeszcze
lepsze) jakiegoś wyszukanego schematu uwierzytelniania według
wielu czynników znacznie podniosłoby wartość tego systemu.

Zaczniemy od tej samej procedury, którą zastosowaliśmy już w podroz-


dziale 7.6 zatytułowanym „Pisanie kodu klienta dla systemu Android”.
Najpierw musimy utworzyć w środowisku Eclipse projekt aplikacji systemu
Android (patrz rysunek 9.7 zatytułowany „Konfiguracja nowej aplikacji
klienckiej systemu zamka sterowanego przez Androida”).
Możemy teraz dodać przycisk o nazwie unlockbutton, przypisać mu etykietę
Otwórz drzwi i tak ustawić jego szerokość, aby wypełniał układ LinearLayout
macierzystego kontenera. Plik main.xml powinien mieć następującą postać:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent" android:layout_height="fill_parent">
<Button android:id="@+id/unlockbutton" android:layout_height="wrap_content"
android:text="Otwórz drzwi" android:layout_width="fill_parent"></Button>
</LinearLayout>

Wprowadzone zmiany należy zapisać. Należy teraz otworzyć plik DoorLock-


Client.java i umieścić w nim referencje do obiektu unlockbutton klasy Button
i odpowiedniej metody nasłuchującej zdarzeń. Musimy też dodać kod spraw-
dzający aktywność modułu Wi-Fi oraz — w razie potrzeby — aktywujący
ten moduł. Kompletny kod zawarty w pliku DoorLockClient.java pokazano
na poniższym listingu:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
222  9.5. Pisanie aplikacji klienckiej dla systemu Android

Rysunek 9.7. Konfiguracja nowej aplikacji klienckiej systemu zamka


sterowanego przez Androida

Plik AndroidDoorLock/DoorLockClient/src/com/mysampleapp/doorlockclient/
DoorLockClient.java

package com.mysampleapp.doorlockclient;

import java.io.InputStream;
import java.net.URL;
import android.net.wifi.WifiManager;
import android.widget.Button;
import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

public class DoorLockClient extends Activity {


/** Metoda wywoływana podczas pierwszego tworzenia danej aktywności. */
@Override

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  223

public void onCreate(Bundle savedInstanceState) {


super.onCreate(savedInstanceState);
setContentView(R.layout.main);
Button unlockbutton = (Button) findViewById(R.id.unlockbutton);

findViewById(R.id.unlockbutton).setOnClickListener(mClickListenerUnlockButton);
try {
WifiManager wm =
(WifiManager) getSystemService(WIFI_SERVICE);
if (!wm.isWifiEnabled()) {
unlockbutton.setEnabled(false);
wm.setWifiEnabled(true);
// Czeka 17 sekund na aktywację modułu Wi-Fi
// i nawiązanie połączenia
Thread.sleep(17000);
unlockbutton.setEnabled(true);
}
} catch (Exception e) {
Log.e("LightSwitchClient", "Error: " + e.getMessage(), e);
}
}
View.OnClickListener mClickListenerUnlockButton =
new View.OnClickListener() {
public void onClick(View v) {
try {
final InputStream is =
new URL("http://192.168.1.230:8000").openStream();
}
catch (Exception e) {
}
}
};
}

Importujemy referencje do uniwersalnych bibliotek java.io.InputStream


i java.net.URL oraz do bibliotek stworzonych specjalnie z myślą o systemie
Android: android.widget.Button i android.net.wifi.WifiManager.
Dodajemy referencję do obiektu unlockbutton klasy Button, po czym
przypisujemy temu obiektowi metodę widoku mClickListenerUnlockButton.
Musimy sprawdzić stan modułu Wi-Fi — jeśli ten moduł jest nieak-
tywny, należy go włączyć. Przycisk unlockbutton pozostanie nieaktywny
przez siedemnaście sekund, aby umożliwić inicjalizację i nawiązanie
połączenia przez moduł Wi-Fi.
Należy utworzyć metodę widoku OnClickListener dla przycisku unlock-
button.

W odpowiedzi na kliknięcie przycisku unlockbutton aplikacja powinna


wysłać żądanie na adres serwera uruchomionego na drugim urządzeniu
z systemem Android.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
224  9.5. Pisanie aplikacji klienckiej dla systemu Android

Zanim będziemy mogli przetestować tę aplikację, musimy zrealizować


jeszcze jedno zadanie. Część czytelników zapewne pamięta sposób ustawiania
w systemie Android uprawnień dostępu do sieci na potrzeby aplikacji klienc-
kiej projektu internetowego włącznika światła. To samo musimy zrobić na
potrzeby programu klienckiego projektu drzwi otwieranych przez Androida.
Musimy też nadać tej aplikacji uprawnienia dostępu do stanu modułu Wi-Fi.
Odpowiednie uprawnienia należy zdefiniować w pliku AndroidManifest.xml,
który po wprowadzeniu niezbędnych zmian powinien mieć następującą
postać:
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.mysampleapp.doorlockclient"
android:versionCode="1"
android:versionName="1.0">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
<uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />

<application android:icon="@drawable/icon" android:label="@string/app_name">


<activity android:name=".DoorLockClient"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>

Po zapisaniu projektu możemy przystąpić do testów na urządzeniu z syste-


mem Android. Warto najpierw przetestować działanie programu w sytuacji,
gdy moduł Wi-Fi jest włączony. W takim przypadku przycisk powinien być
dostępny natychmiast po uruchomieniu aplikacji. Należy teraz zamknąć
program (najlepiej za pomocą Menedżera zadań, aby mieć pewność, że
instancja programu zostanie zniszczona i nie będzie działać w tle). Warto
teraz wyłączyć moduł Wi-Fi i ponownie uruchomić aplikację kliencką tego
projektu. Tym razem przycisk Otwórz drzwi powinien być przez jakiś czas
zablokowany w oczekiwaniu na uruchomienie modułu Wi-Fi i nawiązanie
połączenia sieciowego. Jeśli moduł komunikacji radiowej jest włączony,
możemy rozpocząć testy z użyciem serwera systemu otwierania drzwi.
Wystarczy kliknąć przycisk Otwórz drzwi. W ciągu jednej, dwóch sekund
elektryczny rygiel powinien otworzyć się na blisko pięć sekund (po tym czasie
zostanie ponownie zamknięty). Jeśli system działa prawidłowo, możemy
sobie pogratulować dobrze wykonanej pracy! W przeciwnym razie musimy

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  225

sprawdzić, czy zastosowane urządzenie z systemem Android rzeczywiście


uzyskało połączenie sieciowe. Wystarczy sprawdzić dostęp do odpowiedniego
adresu URL z poziomu przeglądarki internetowej systemu Android. Jeśli
dostęp do tego adresu URL jest niemożliwy, należy sprawdzić, czy serwer
systemu otwierania drzwi nadal działa i czy urządzenie serwera ma przypisa-
ny właściwy (zdefiniowany przez nas wcześniej) adres IP. Warto spróbować
uzyskać dostęp do tego adresu URL za pośrednictwem innego systemu,
aby sprawdzić, czy pozostałe urządzenia podłączone do sieci domowej
mają dostęp do serwera tego projektu.

9.6. Testy i instalacja


Aplikacja kliencka dla systemu Android wysyła żądanie na adres URL ser-
wera po naciśnięciu przycisku interfejsu użytkownika, zatem jesteśmy już
bardzo blisko szczęśliwego końca tego projektu. Aby przetestować mechani-
zmy sterowania ryglem i robienia zdjęć, należy podłączyć do prądu serwer
projektu (telefon z systemem Android) i upewnić się, że wszystkie połączenia
pomiędzy tym telefonem, płytką IOIO i przełącznikiem PowerSwitch
Tail są prawidłowe. Żądanie do tego serwera należy wysłać za pomocą
innego urządzenia z systemem Android (i uruchomioną aplikacją kliencką
projektu). Warunkiem prawidłowego przetestowania obsługi żądań jest połą-
czenie obu urządzeń z systemem Android (serwera i klienta) do sieci bez-
przewodowej obsługiwanej przez ten sam punkt dostępowy Wi-Fi. Po połą-
czeniu projekt może wyglądać podobnie do mojego systemu (patrz rysunek 9.8
zatytułowany „Testowanie systemu sterowania zamkiem”).

Rysunek 9.8. Testowanie systemu sterowania zamkiem

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
226  9.7. Następne kroki

Musimy jeszcze zainstalować mechanizm elektrycznego rygla w ościeżnicy


drzwi wejściowych. Instalacja rygla może być dość kłopotliwa, szczególnie
dla czytelników, którzy nie przepadają za pracą w drewnie ani prowadzeniem
w ścianach. Czytelników planujących instalację tego systemu na stałe go-
rąco zachęcam do poproszenia o pomoc sprawdzonego stolarza i elektryka.
Bezpieczeństwo domowej instalacji elektrycznej (i nasze zdrowie psychiczne)
z pewnością jest warte tych dodatkowych wydatków.
Podczas instalacji rygla warto zadbać o umieszczenie telefonu z systemem
Android, płytki IOIO i przełącznika PowerSwitch Tail w łatwo dostępnym
miejscu. Nie muszę chyba mówić, że wymienionych elementów nie należy
umieszczać pod tynkiem — taka instalacja nie tylko utrudniłaby wymianę
ewentualnych uszkodzonych komponentów w przyszłości, ale też rodziłaby
poważne ryzyko pożarowe w razie niewłaściwego zaizolowania przewo-
dów. Polecam zakup odpowiedniej skrzynki w sklepie z elektroniką. Skrzyn-
ka powinna być na tyle duża, aby pomieścić wszystkie elementy i ewentu-
alne dodatkowe urządzenia, które mogą być potrzebne w przyszłości (jeśli
na przykład zdecydujemy się rozbudować ten system o dodatkowe elementy).
Musimy konsekwentnie przestrzegać zasad bezpiecznego łączenia przewodów.
Po połączeniu obwodu i umieszczeniu komponentów w docelowych miejscach
zwykle lutuję wszystkie elementy i zabezpieczam odsłonięte powierzchnie
przewodzące (w tym końcówki i przewody) za pomocą węża termokurczliwe-
go, aby uniknąć ryzyka zwarcia. Czytelnicy, którzy mogą liczyć na pomoc elek-
tryka, koniecznie powinni zasięgnąć jego opinii na temat zalecanych praktyk
i poprosić o rady podczas łączenia tego systemu.

9.7. Następne kroki


Gratulacje! Właśnie zakończyłeś jeden z najbardziej złożonych projektów
opisanych w tej książce. Zrobiłeś spory postęp, zyskując przy tym dużo
nowej wiedzy i doświadczenia. Potrafisz teraz automatyzować pracę wielu
różnych urządzeń elektrycznych w swoim domu. W ostatnim projekcie opisa-
nym w tej książce połączymy wiele spośród zaprezentowanych wcześniej
technik, aby utworzyć aplikację nasłuchującą wielu zdarzeń i komunikującą
się z użytkownikiem za pośrednictwem syntezatora mowy. Zanim przystą-
pimy do tego projektu, warto rozważyć rozszerzenie systemu drzwi stero-
wanych przez Androida o następujące elementy:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 9. • Zamek do drzwi sterowany przez Androida  227

 Możemy zaimplementować system Perfect Paper Passwords Steve’a


Gibsona, który uzupełni ten projekt o bezpieczniejszy schemat
uwierzytelniania z uwzględnieniem wielu czynników (w tym haseł
jednorazowych)20. System Perfect Paper Passwords umożliwia na
przykład udostępnianie jednorazowych kodów osobom, które z róż-
nych względów muszą wejść do naszego domu, na przykład lekarzom
odbywającym wizyty domowe, osobom zatrudnionym do sprzątania
domu czy fachowcom wykonującym niezbędne naprawy.
 Do płytki IOIO można dodatkowo podłączyć czujnik PIR, aby wy-
krywać ruch i wysyłać informacje o tego rodzaju zdarzeniach. Projekt
w oryginalnej formie co prawda działa dość podobnie, jednak robio-
ne zdjęcia nie zawsze będą przedstawiały osobę wchodzącą do domu
(jeśli na przykład drzwi zostaną celowo lub przypadkiem otwarte
z pewnym opóźnieniem). Warto wykorzystać dostępność dużej liczby
analogowych i cyfrowych wtyków na płytce IOIO, aby podłączyć
czujnik ruchu PIR podobny do tego z rozdziału 4. zatytułowanego
„Elektryczny pies stróżujący”.
 Istnieje możliwość podłączenia wielu elektrycznych rygli do serwera
WWW tego systemu i odblokowywania poszczególnych zamków za
pomocą różnych adresów URL. Do otwierania drzwi wejściowych
może służyć na przykład adres http://192.168.1.230/drzwi wejsciowe,
natomiast do otwierania drzwi do piwnicy można używać adresu
http://192.168.1.230/drzwi_do_piwnicy.
Telefonu z systemem Android można z powodzeniem używać do sterowania
wieloma innymi urządzeniami. Serwer połączony z płytką IOIO może służyć
do włączania i wyłączania świateł, urządzeń AGD, komputerów i dowolnych
innych urządzeń elektrycznych. Program serwera WWW można rozsze-
rzyć o mechanizmy rejestrowania zdarzeń, wysyłania wiadomości poczty
elektronicznej z powiadomieniami o zmianach stanu i wykrywania zmiany
orientacji (za pomocą wbudowanego kompasu i akcelerometru), jeśli urzą-
dzenie, na którym działa ten serwer, zostanie przez kogoś poruszone.

20
https://www.grc.com/ppp.htm

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
228  9.7. Następne kroki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10.
Dajmy przemówić
naszemu domowi

C
zyż nie byłoby wspaniale, gdybyśmy podczas zbliżania się do drzwi
wejściowych byli pozdrawiani przez nasz dom i informowani o waż-
nych zdarzeniach, które miały miejsce podczas naszej nieobecności?
A może nasz dom powinien odpowiadać na pytania o stan skrzynki odbior-
czej poczty elektronicznej, polecenia sprawdzenia prognozy pogody lub żąda-
nia odtworzenia ulubionej kolejki plików muzycznych? Dom mógłby też gło-
śno powiadamiać domowników o zdarzeniach wykrywanych przez czujniki,
na przykład o przekroczeniu poziomu wody w zbiorniku lub o konieczności
dosypania nasion dla ptaków w karmniku (odpowiednio z pierwszego i dru-
giego projektu). (Patrz rysunek 10.1 zatytułowany „Powiadamianie o zda-
rzeniach”).
Ten projekt tchnie nowe życie w te z pozoru dziwaczne projekty. Utworzymy
centralny węzeł odpowiedzialny za obsługę komunikacji pomiędzy wszyst-
kimi systemami zbudowanymi w tej książce i za głosowe porozumiewanie
się z użytkownikiem.
Otrzymywanie wiadomości poczty elektronicznej i wpisów na Twitterze
oczywiście ma swoje zalety, jednak możliwość prowadzenia konwersacji
z własnym domem byłaby jeszcze ciekawsza. Byłoby wspaniale, gdybyśmy
mogli głośno zadać pytanie „która godzina?” bądź wypowiedzieć jakieś

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
230  10.1. Czego potrzebujemy

Rysunek 10.1. Powiadamianie o zdarzeniach… niech nasz dom sam


informuje nas o zdarzeniach związanych z funkcjonowaniem
zaprojektowanych przez nas systemów automatyzacji

polecenie, na przykład „włącz światła” lub „puść muzykę”, i gdyby nasz dom
reagował, generując odpowiednią odpowiedź lub wykonując nasze polecenie.
Właśnie opisane mechanizmy zrealizujemy w ramach projektu opisanego
w tym rozdziale. Projekt połączy opracowane wcześniej projekty internetowe-
go włącznika światła i drzwi sterowanych przez Androida oraz umożliwi
sterowanie tymi rozwiązaniami za pomocą poleceń głosowych.
Przy okazji realizacji tego projektu przeanalizujemy możliwości implementacji
dodatkowych poleceń głosowych, jak wybór wykonawcy i albumu do od-
tworzenia przez zestaw stereo, zwiększanie i zmniejszanie głośności itp.

10.1. Czego potrzebujemy


Mimo że ten sam projekt równie dobrze moglibyśmy zaimplementować
w systemie Windows (przy użyciu interfejsu Speech API firmy Microsoft)
lub w systemie Linux (za pomocą projektu open source Festival), zdecydowa-
łem się wybrać platformę Mac, ponieważ uważam, że mechanizm prze-
kształcania tekstu na głos (ang. Text-to-Speech — TTS) dostępny w systemie

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  231

OS X 10.7 (Lion) jest najlepszy spośród rozwiązań dostępnych w tych


trzech systemach operacyjnych. Większość użytkowników komputerów Mac
w ogóle nie wie o istnieniu tego mechanizmu ani tym bardziej o możliwości
pobrania dodatkowych głosów dla systemu OS X.
Poniżej wymieniłem urządzenia i części, których będziemy potrzebowali
do realizacji tego projektu:
 komputer Apple Mac z systemem operacyjnym OS X 10.7 (Lion)
lub nowszym;
 domowy sprzęt stereo ze standardowym wejściem 3,5 mm lub RCA;
 jeden z następujących przewodów:
 przewód stereo męski-męski do połączenia komputera Mac z do-
mowym sprzętem stereo lub
 przewód stereo z przejściówką RCA – wtyk słuchawkowy 3,5 mm
(jeśli system stereo obsługuje tylko wejście RCA) lub
 bezprzewodowy głośnik Bluetooth, na przykład Supertooth DISCO1;
 bezprzewodowy mikrofon i stacja odbiorcza, na przykład Radio Shack
Wireless Lapel Microphone System2;
 przejściówka USB – wejście słuchawkowe 3,5 mm do wysyłania sy-
gnału od bezprzewodowej stacji mikrofonu do komputera Mac, na
przykład iMic firmy Griffin Technology3.
Zanim będziemy mogli posłuchać głosów swojego komputera, musimy zna-
leźć sposób odtwarzania dźwięków z komputera Mac przy użyciu zestawu
głośnikowego (niezależnie od tego, czy ten zestaw połączono bezpośrednio
z komputerem, za pośrednictwem systemu stereo, czy przy użyciu systemu
głośników bezprzewodowych Bluetooth).

10.2. Konfiguracja głośników


Głośnik używany do wzmocnienia sygnału audio generowanego przez
komputer jest jednym z najważniejszych czynników decydujących o sukcesie
tego projektu. Głośnik musi być na tyle głośny, aby dźwięk był słyszalny

1
http://www.supertooth.net/AU/produitmusique.htm
2
http://www.radioshack.com/product/index.jsp?productId=2131022
3
http://store.griffintechnology.com/imic

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
232  10.2. Konfiguracja głośników

co najmniej w kilku pomieszczeniach (w idealnych warunkach dźwięk


powinien być słyszalny w całym domu). W tym podrozdziale przeanalizuje-
my zarówno przewodowe, jak i bezprzewodowe systemy nagłośnienia.
Najprostszym sposobem połączenia komputera Mac z domowym systemem
stereo jest użycie przewodu męski-męski z przejściówką RCA – wtyk słu-
chawkowy 3,5 mm. Przewód będzie łączył wyjście słuchawkowe kompute-
ra Mac ze wzmacniaczem stereo i (lub) wtykiem wejściowym odbiornika.
Jeśli domowy system stereo nie udostępnia wtyku jack 3,5 mm, musimy
zastosować przewód audio z końcówką żeńską 3,5 mm i końcówką męską
RCA. Przewód powinien być na tyle długi, aby wygodnie połączyć kompu-
ter z systemem stereo — warto więc mieć na uwadze docelowy rozkład urzą-
dzeń podczas kupowania tego przewodu w sklepie ze sprzętem audio-wideo.
Jeśli komputer i system stereo dzieli wiele pomieszczeń, niezbędny prze-
wód musi być dość długi, a instalacja całego systemu wymaga wywiercenia
wielu otworów w ścianach. Jeśli nie chcemy instalować komputera w tym
samym pomieszczeniu, w którym znajduje się system stereo, i jeśli nie mamy
zamiaru prowadzić przewodów przez ściany, powinniśmy rozważyć zasto-
sowanie bezprzewodowej alternatywy. Polecam wykorzystanie zewnętrznych
głośników Bluetooth, które oferują największą elastyczność spośród do-
stępnych rozwiązań.
Konfiguracja połączenia głośnika Bluetooth i komputera Mac jest dość pro-
sta. Wystarczy włączyć moduł komunikacji Bluetooth na komputerze Mac
za pośrednictwem panelu ustawień systemu Bluetooth. Należy następnie
włączyć zasilanie zewnętrznego głośnika Bluetooth i skonfigurować go w taki
sposób, aby komunikował się z komputerem. Konfiguracja zwykle spro-
wadza się do przytrzymania wciśniętego przycisku zasilania do momentu,
w którym odpowiednia dioda na głośniku Bluetooth zacznie migać. Następny
krok polega na kliknięciu przycisku Skonfiguruj nowe urządzenie w panelu
ustawień Bluetooth systemu Mac. System powinien automatycznie wykryć
głośniki Bluetooth. W przypadku głośnika Supertooth DISCO w systemie
Mac zostanie wyświetlone urządzenie ST DISCO R58 (patrz rysunek 10.2
zatytułowany „Nawiązywanie połączenia z bezprzewodowym głośnikiem
Bluetooth”).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  233

Rysunek 10.2. Nawiązywanie połączenia z bezprzewodowym głośnikiem


Bluetooth

Należy teraz wybrać nazwę głośnika. W zależności od stosowanego gło-


śnika Bluetooth połączenie albo może być nawiązywane automatycznie,
albo może wymagać podania czterocyfrowego kodu potwierdzenia (na przy-
kład 0000 lub 1234). W przypadku głośnika Supertooth DISCO mój sys-
tem Mac automatycznie skonfigurował odpowiednie urządzenie bez ko-
nieczności stosowania jakichkolwiek kodów.
Po prawidłowym wykryciu i skonfigurowaniu urządzenia na ekranie po-
winien się pojawić komunikat potwierdzenia udanego nawiązania połą-
czenia z głośnikiem. Należy kliknąć opcję Dźwięk w Preferencjach syste-
mowych i wybrać głośnik w zakładce Wyjście. Warto teraz otworzyć aplikację
muzyczną iTunes w systemie Mac, aby odtworzyć jakiś plik muzyczny
i sprawdzić, czy dźwięk rzeczywiście zostanie odtworzony przez bezprzewo-
dowy głośnik. Testy komunikacji z urządzeniem można zakończyć, klikając
opcję Mowa w preferencjach systemowych i wybierając zakładkę Synteza
mowy. Należy teraz kliknąć przycisk Odtwórz. Jeśli usłyszymy z głośników
wygenerowany komunikat tekstowy, możemy przyjąć, że system Mac jest
prawidłowo skonfigurowany. Musimy jeszcze ustawić poziom głośności gene-
rowanego dźwięku, tak aby komunikaty były słyszalne na wyznaczonym
obszarze.
Bezprzewodowa konfiguracja systemu audio ma swoje wady i zalety. Jeśli zale-
ży nam na wygodzie oferowanej przez transmisję dźwięku bez konieczno-
ści instalacji okablowania, zewnętrzny głośnik Bluetooth jest najlepszym

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
234  10.3. Wsłuchajmy się w głos systemu

rozwiązaniem. Jeśli jednak jakość dźwięku ma dla nas większe znaczenie niż
wygoda transmisji bezprzewodowej, tylko przewodowe połączenie komputera
ze wzmacniaczem stereo zapewni oczekiwany efekt. Jeśli mamy szczęście
i instalujemy system w pomieszczeniach, w których zainstalowano już
okablowanie dla systemu nagłośnienia, połączenie komputera z tym sys-
temem jest oczywistym rozwiązaniem.

Zalety komunikacji bezprzewodowej Bluetooth


Możliwość bezprzewodowego wysyłania sygnału audio za pomocą
technologii Bluetooth jest oferowana przez większość komputerów
Mac. Ten wyjątkowo elastyczny sposób łączenia urządzeń umożli-
wia swobodną instalację komputera i zewnętrznego głośnika Blu-
etooth w wybranych miejscach. Zamiast prowadzić przewód audio
pomiędzy komputerem a systemem stereo możemy zastosować bez-
przewodową komunikację Bluetooth o zasięgu około 10 metrów.

Musimy jeszcze tak skonfigurować system Mac, aby nasłuchiwał poleceń


głosowych i reagował, odtwarzając odpowiednie odpowiedzi głosowe. Po-
zostaje nam jeszcze napisanie skryptu języka AppleScript, który wykorzy-
sta wbudowany serwer rozpoznawania mowy systemu OS X do nasłu-
chiwania i wykonywania wydawanych poleceń.

10.3. Wsłuchajmy się w głos systemu


Zanim będziemy mogli na głos wydawać polecenia systemowi Mac, musimy
najpierw włączyć serwer rozpoznawania mowy w ramach tego systemu.
Warto pamiętać, że serwer rozpoznawania mowy nie działał prawidłowo
w wersjach 10.5 i 10.6 systemu; został ostatecznie poprawiony dopiero
w wersji 10.7 Lion. Począwszy od tej wersji, system Mac ponownie stał się
skuteczną platformą rozpoznawania mowy.
Aby skonfigurować mechanizm rozpoznawania mowy w systemie Mac, nale-
ży kliknąć ikonę Mowa (Speech) w panelu preferencji systemowych (System
Preferences); patrz rysunek 10.3 zatytułowany „Dostęp do ustawień roz-
poznawania i syntezy mowy w systemie OS X”.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  235

Rysunek 10.3. Dostęp do ustawień rozpoznawania i syntezy mowy


w systemie OS X

Należy teraz wybrać zakładkę Rozpoznawanie mowy (Speech Recognition)


i włączyć Mówione komunikaty (Speakable Items); patrz rysunek 10.4 zaty-
tułowany „Włączanie mówionych komunikatów”.

Rysunek 10.4. Włączanie mówionych komunikatów

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
236  10.3. Wsłuchajmy się w głos systemu

Warto przeczytać wskazówki wyświetlone po pierwszym włączeniu tej


opcji, aby podczas definiowania szczegółowych ustawień mieć na uwadze
zalecenia projektantów tych rozwiązań. Algorytmy rozpoznawania mowy
nie są wystarczająco skuteczne, aby łatwo rozumieć i rozpoznawać różne
dialekty, akcenty i poziomy głośności, jednak odpowiednie technologie są
stale rozwijane.
Z moich doświadczeń wynika, że podczas wydawania poleceń systemowi
Mac należy mówić głośno i wyraźnie, a poszczególne słowa poleceń należy
wypowiadać nienaturalnie wolno. Co więcej, polecenia należy wypowiadać
w warunkach niemal pełnego braku innych dźwięków w tle. Warto poekspe-
rymentować z mikrofonami zainstalowanymi w różnych miejscach (w szcze-
gólności w różnych odległościach od ust wydającego polecenia) i różnymi
pauzami dzielącymi kolejne wyrazy, aby sprawdzić, jak mechanizm rozpo-
znawania mowy radzi sobie ze słownictwem zdefiniowanym w naszym
skrypcie. Warto pamiętać, że zgodnie z domyślnymi ustawieniami mikrofonu
w systemie Mac domyślnie jest używany wewnętrzny mikrofon. W dalszej
części tego rozdziału zmienimy odpowiednie opcje, aby wymusić stosowanie
interfejsu iMic (na razie można pozostawić ustawienia domyślne).
Po aktywacji opcji mówionych komunikatów na ekranie komputera zostanie
wyświetlony okrągły symbol mikrofonu. Wspomniany symbol jest w istocie
oknem rozpoznawania mowy. Aby aktywować system rozpoznawania mowy,
należy przytrzymać wciśnięty klawisz Escape. Wymaganie przytrzymywania
tego klawisza wyeliminujemy wraz z uruchomieniem skryptu implementu-
jącego system mówiącego domu i konfiguracją bezprzewodowego mikrofonu;
na razie pozostawimy ustawienia domyślne, aby ułatwić diagnozowanie
tego skryptu.
Przed zamknięciem panelu ustawień mowy musimy ustawić jeszcze jedną
opcję. W tym celu należy kliknąć zakładkę Synteza mowy (Text to Speech)
i wybrać jedną z opcji dostępnych na liście rozwijanej Głos systemowy (System
Voice); patrz rysunek 10.5 zatytułowany „Ustawienia syntezatora mowy”.
Dostępne głosy można sprawdzić, klikając przycisk Odtwórz (Play). Do-
myślny głos oznaczono imieniem Alex. Głos Aleksa jest całkiem dobry, jed-
nak sam wolę żeński głos Samanthy z amerykańską wymową. Ponieważ pliki
głosów są dość duże, firma Apple nie dostarcza wszystkich dostępnych gło-
sów wraz z systemem Lion. Dodatkowe głosy można pobrać, wybierając opcję
Dostosuj (Customize) z listy rozwijanej Głos systemowy (System Voice).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  237

Rysunek 10.5. Ustawienia syntezatora mowy

Kliknięcie tej opcji spowoduje wyświetlenie nowego okna dialogowego z listą


głosów dostępnych do pobrania za darmo z serwera firmy Apple (patrz rysu-
nek 10.6 zatytułowany „Wybór głosu systemu Lion”)4.

Rysunek 10.6. Wybór głosu systemu Lion

4
Użytkownicy polskiej wersji systemu OS X Lion mogą wybrać syntezator mowy
Agata — przyp. tłum.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
238  10.4. Kalibracja mikrofonu bezprzewodowego

Użytkownik ma do wyboru wiele głosów, z których każdy można sprawdzić


jeszcze przed pobraniem, klikając przycisk Odtwarzaj (Play). Po wybra-
niu ulubionego głosu musimy uzbroić się w cierpliwość na czas pobierania
i konfiguracji potrzebnych plików na danym komputerze (czas potrzebny
na wykonanie tych kroków zależy od parametrów połączenia internetowego
i szybkości procesora). Na przykład plik z głosem Samanthy zajmuje po-
nad 450 megabajtów.
Po pobraniu i zainstalowaniu plików z wybranym głosem możemy dodatko-
wo dostosować opcje odtwarzania tego głosu za pomocą suwaka Szybkość
mówienia (Speaking Rate); zmiana położenia tego suwaka powoduje szybsze
lub wolniejsze generowanie dźwięku. Na tym etapie sugeruję zachowanie
domyślnej szybkości mówienia — w razie potrzeby zawsze można wrócić do
tych ustawień już po połączeniu i sprawdzeniu całego systemu obejmującego
mikrofon i głośniki. Skoro mowa o mikrofonie, nasze następne zadanie
polega na podłączeniu mikrofonu bezprzewodowego i jego kalibracji pod
kątem rozpoznawania mowy.

10.4. Kalibracja mikrofonu


bezprzewodowego
Użytkownicy komputerów MacBook Pro oraz iMac mogą skorzystać z wbu-
dowanych, wewnętrznych mikrofonów. Takie rozwiązanie sprawdzi się w przy-
padku wydawania poleceń bezpośrednio przed laptopami z wymienionych
serii, ale będzie coraz mniej skuteczne wraz z rosnącą odległością od ekranu
(i mikrofonu). W tym przypadku zależy nam raczej na możliwości prowa-
dzenia rozmowy z naszym domem w czasie chodzenia po pokojach, ogląda-
nia telewizji, przygotowywania śniadania w kuchni czy sprzątania salonu.
Ten cel można osiągnąć za pomocą mikrofonu bezprzewodowego.
Warunkiem niezawodnej współpracy bezprzewodowego mikrofonu z mecha-
nizmem rozpoznawania mowy w systemie Mac OS jest zastosowanie urzą-
dzenia odpowiedniej jakości, które zagwarantuje czystą transmisję sygnału.
Mikrofon, którego sygnał będzie zakłócany przez trzaski czy syki, nie spraw-
dzi się w tym systemie, ponieważ mechanizm rozpoznawania mowy musi
prawidłowo odróżniać właściwy sygnał od szumu. Jeśli budowany system ma
mieć praktyczną wartość i ma skutecznie realizować swoje zadania przez dłuż-
szy czas, warto zainwestować w mikrofon bezprzewodowy wysokiej jakości
(podobny do mikrofonów używanych przez profesjonalnych wokalistów).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  239

Taki mikrofon może co prawda kosztować kilkaset złotych (zależnie od moż-


liwości i zasięgu), jednak jakość sygnału i czystość dźwięku z pewnością są
warte dodatkowych nakładów. Czytelnikom, którzy przed podjęciem decyzji
o zainwestowaniu tak poważnych środków wolą dobrze przetestować ten
system, polecam nieco tańszy produkt o nazwie Radio Shack Wireless Lapel
Microphone System.
Należy podłączyć interfejs Griffin iMic do jednego z wolnych portów USB
komputera Mac, po czym podłączyć wyjście stacji bazowej mikrofonu bez-
przewodowego do wejścia interfejsu iMic. Warto jeszcze sprawdzić, czy
w interfejsie iMic wybrano wejście mikrofonowe. Możemy następnie włączyć
mikrofon bezprzewodowy i zasilanie stacji bazowej. W panelu Rozpoznawa-
nie mowy (Speech Recognition) w ramach preferencji systemowych należy
wybrać system iMic USB i kliknąć przycisk Kalibruj (Calibrate). Wybór tej
opcji spowoduje wyświetlenie okna kalibracji mikrofonu (patrz rysunek 10.7
zatytułowany „Kalibracja mikrofonu”). Podczas kalibracji należy mówić
w kierunku mikrofonu i tak ustawić pozycję suwaka, aby poziom głośności
mieścił się w zielonym polu.

Rysunek 10.7. Kalibracja mikrofonu

Warto też sprawdzić, czy podczas mówienia do mikrofonu w różnych miej-


scach pokoju wskaźnik sygnału nadal będzie się mieścił w zielonym polu.
Zanim będziemy mogli przystąpić do kodowania aplikacji, musimy wyko-
nać jeszcze jedno zadanie. Trzeba podłączyć głośniki potrzebne do odtwa-
rzania generowanych komunikatów.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
240  10.5. Programowanie mówiącego systemu

10.5. Programowanie mówiącego


systemu
Napisanie dobrego syntezatora mowy i oprogramowania rozpoznającego
mowę jest trudne. Właśnie dlatego wykorzystamy oprogramowanie, które
powstało w wyniku ciężkiej pracy inżynierów firmy Apple i które zostało
włączone do systemu operacyjnego OS X. Dostęp do tego silnika można
uzyskać na wiele sposobów, w tym za pośrednictwem odpowiednich metod
języków Objective-C, Perl, Python i Ruby oraz specjalnych konstrukcji
stworzonych z myślą o pozostałych językach skryptowych. Z moich doświad-
czeń wynika jednak, że zdecydowanie najprostszym sposobem budowy,
modyfikowania i testowania odpowiednich rozwiązań jest użycie języka
AppleScript.
Chciałbym przy tym podkreślić, że nie jestem wielkim zwolennikiem języka
AppleScript. Próby pisania skryptów w formie przypominającej zdania języka
angielskiego okazują się skuteczne tylko w przypadku najprostszych roz-
wiązań. Wady i ograniczenia tego języka już po kilku minutach są oczywiste
dla każdego programisty, który miał do czynienia z bardziej eleganckimi
językami programowania, jak Ruby czy Python. W języku AppleScript na-
wet implementacja prostych zadań, na przykład operacji na łańcuchach, oka-
zuje się dość trudna. Mimo tych wszystkich ograniczeń warto podkreślić, że
AppleScript bije na głowę pozostałe języki skryptowe w zakresie bezpro-
blemowej integracji z pozostałymi aplikacjami systemu OS X przystosowa-
nymi do współpracy z tym językiem. Skrypty języka AppleScript można
z powodzeniem integrować z oprogramowaniem dołączonym do systemu
Mac OS X, jak iTunes, Mail, Safari czy Finder, a także z wieloma innymi
programami dla tego systemu, w tym z komunikatorem Skype, pakietem biu-
rowym Microsoft Office itp. W przypadku tego projektu warto wykorzystać
duże możliwości współpracy ze skryptami oferowane przez serwer rozpozna-
wania mowy firmy Apple — właśnie tego produktu użyjemy podczas re-
alizacji opisywanego projektu.
Skrypty języka AppleScript można co prawda pisać w dowolnym edytorze
tekstu, jednak zdecydowanie wygodniejszym rozwiązaniem jest użycie spe-
cjalnej aplikacji AppleScript Editor. Aplikację można znaleźć w folderze
Applications/Utilities. Po pierwszym uruchomieniu edytora skryptów języka
AppleScript wyświetlone zostanie puste okno podzielone na dwa panele.
Górna połowa okna służy do wpisywania kodu, natomiast dolna część okna
obejmuje trzy zakładki odpowiedzialne odpowiednio za monitorowanie zda-
rzeń i odpowiedzi oraz wyświetlanie wyników wykonywanego skryptu. Edytor

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  241

co prawda ułatwia pisanie skryptów poprzez wyróżnianie poszczególnych


elementów składniowych odpowiednimi kolorami, ale nie oferuje mechani-
zmów znanych z bardziej rozbudowanych środowisk IDE, na przykład wy-
kańczania kodu czy kompilacji „w locie”. Typowe skrypty są jednak na tyle
krótkie, że brak wymienionych funkcji nie stanowi większego problemu.
Język AppleScript ma własne słownictwo, słowa kluczowe i idiomy. Opano-
wanie tego języka nie jest trudne, ale bywa dość irytujące, szczególnie z uwagi
na konieczność precyzyjnego doboru składni, tak aby tworzony skrypt prawi-
dłowo oddawał nasze intencje. Na przykład analiza składniowa łańcucha
w poszukiwaniu adresu poczty elektronicznej w większości języków skrypto-
wych jest dziecinnie prosta. W języku AppleScript jest inaczej. Realizacja
tego zadania w języku AppleScript jest trudna z powodu konieczności
zapewnienia zgodności z historycznymi rozwiązaniami i w związku z niety-
powym sposobem pisania skryptów. Czytelnicy, którzy nie mają doświadcze-
nia w pracy w tym języku, muszą mi zaufać i uwierzyć, że skrypty opracowa-
ne na potrzeby tego projektu działają zgodnie z tym, co o nich napisałem.
Czytelników, którym język AppleScript przypadnie do gustu lub którzy
będą zainteresowani rozbudową kodu tego projektu, zachęcam do lektury
dostępnej w internecie dokumentacji opublikowanej przez firmę Apple5.
Zanim przystąpimy do pisania tego skryptu, musimy zastanowić się, co do-
kładnie ten skrypt ma robić. Pierwszym zadaniem tego skryptu będzie reago-
wanie na wybraną grupę wypowiadanych słów i wyrażeń oraz podejmowanie
odpowiednich działań. Które polecenia powinniśmy wybrać? Na początek
warto stworzyć skrypt odwołujący się do adresów URL udostępnianych
przez projekty, które zrealizowaliśmy z myślą o dostępie za pośrednictwem
internetu, a więc przez internetowy włącznik światła i drzwi otwierane przez
Androida. Skoro już podejmujemy się zadania opracowania skryptu w języku
AppleScript, warto przy okazji wykorzystać część wbudowanych aplikacji
systemu OS X, na przykład Mail i iTunes, do odbierania i czytania nieode-
branej poczty oraz odtwarzania wybranych plików muzycznych. Zaimple-
mentujemy też mechanizm odpowiadania przez dom na pytanie o aktualną
godzinę.
Musimy zainicjalizować aplikację SpeechRecognitionServer oraz zdefiniować
zbiór słów i wyrażeń, których chcemy nasłuchiwać. Aby właściwie reago-
wać na wydawane polecenia, wystarczy użyć sekwencji wyrażeń if-then.

5
http://developer.apple.com/library/mac/#documentation/AppleScript/
Conceptual/AppleScriptLangGuide/introduction/ASLR_intro.html

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
242  10.5. Programowanie mówiącego systemu

Jeśli na przykład prosimy komputer o rozpoczęcie odtwarzania muzyki, skrypt


powinien wywołać aplikację iTunes, wymusić przeszukanie utworów mu-
zycznych zapisanych w jej bibliotece, posortowanie tych utworów według
artysty i albumu, umieszczenie tych nazw, nazwisk i tytułów w zbiorze
słów wymagających interpretacji oraz użycie mechanizmu syntezatora mowy
do zadania pytania o artystę i album interesujący użytkownika. Podobnie
możemy wymusić odczytanie nowych wiadomości poczty elektronicznej,
wydając polecenie „sprawdź pocztę”. To polecenie powinno uruchomić apli-
kację Mail, sprawdzić skonfigurowane wcześniej konto pocztowe pod ką-
tem ewentualnych nowych wiadomości, sprawdzić, czy skrzynka odbiorcza
nie zawiera nieprzeczytanych wiadomości, oraz użyć mechanizmu syntezy
mowy do przeczytania nazwisk nadawców i tytułów tych wiadomości.
Przejdźmy teraz do szczegółowej analizy przebiegu wykonywania tego skryptu.
Kompletny kod skryptu pokazano poniżej. Większość zastosowanych kon-
strukcji składniowych powinna być łatwa w interpretacji nawet dla programi-
stów, którzy nigdy wcześniej nie mieli do czynienia z językiem AppleScript.
Plik GivingYourHomeAVoice/osx-voice-automation.scpt

with timeout of 2629743 seconds


set exitApp to "no"
repeat while exitApp is "no"
tell application "SpeechRecognitionServer"
activate
try
set voiceResponse to listen for {"zapal światło", "zgaś światło", ¬
"otwórz drzwi", "włącz muzykę", "wstrzymaj muzykę", ¬
"wznów muzykę", "zatrzymaj muzykę", "następny utwór", ¬
"głośniej", "ciszej", ¬
"poprzedni utwór", "sprawdź pocztę", "godzina", "zadzwoń", ¬
"koniec rozmowy", "zamknij aplikację"} giving up after 2629743
on error -- limit czasowy
return
end try
end tell

if voiceResponse is "zapal światło" then


-- otwiera adres URL włączający internetowy włącznik światła
open location "http://192.168.1.100:3344/command/on"
say "Światło jest włączone."

else if voiceResponse is "zgaś światło" then


-- otwiera adres URL wyłączający internetowy włącznik światła
open location "http://192.168.1.100:3344/command/off"
say "Światło jest wyłączone."

else if voiceResponse is "otwórz drzwi" then


-- otwiera adres URL powodujący odblokowanie zamka sterowanego przez Androida

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  243

open location "http://192.168.1.230:8000"


say "Otwieranie drzwi."

else if voiceResponse is "włącz muzykę" then


tell application "iTunes"
set musicList to {"Anuluj"} as list
set myList to (get artist of every track ¬
of playlist 1) as list
repeat with myItem in myList
if musicList does not contain myItem then
set musicList to musicList & myItem
end if
end repeat
end tell

say "Którego wykonawcy chcesz posłuchać?"


tell application "SpeechRecognitionServer"
set theArtistListing to ¬
(listen for musicList with prompt musicList)
end tell

if theArtistListing is not "Anuluj" then


say "Którego albumu " & theArtistListing & ¬
" chcesz posłuchać?"
tell application "iTunes"
tell source "Library"
tell library playlist 1
set uniqueAlbumList to {}
set albumList to album of tracks ¬
where artist is equal to theArtistListing

repeat until albumList = {}


if uniqueAlbumList does not contain ¬
(first item of albumList) then
copy (first item of albumList) to end of ¬
uniqueAlbumList
end if
set albumList to rest of albumList
end repeat

set theUniqueAlbumList to {"Anuluj"} & uniqueAlbumList


tell application "SpeechRecognitionServer"
set theAlbum to (listen for the theUniqueAlbumList ¬
with prompt theUniqueAlbumList)
end tell
end tell
if theAlbum is not "Anuluj" then
if not ((name of playlists) contains "Current Album") then
set theAlbumPlaylist to ¬
make new playlist with properties {name:"Current Album"}
else
set theAlbumPlaylist to playlist "Current Album"
delete every track of theAlbumPlaylist
end if

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
244  10.5. Programowanie mówiącego systemu

tell library playlist 1 to duplicate ¬


(every track whose album is theAlbum) to theAlbumPlaylist
play theAlbumPlaylist
else
say "Anulowanie wyboru muzyki"
end if
end tell
end tell
else
say "Anulowanie wyboru muzyki"
end if

else if voiceResponse is "wstrzymaj muzykę" or ¬


voiceResponse is "wznów muzykę" then
tell application "iTunes"
playpause
end tell

else if voiceResponse is "zatrzymaj muzykę" then


tell application "iTunes"
stop
end tell

else if voiceResponse is "następny utwór" then


tell application "iTunes"
next track
end tell

else if voiceResponse is "poprzedni utwór" then


tell application "iTunes"
previous track
end tell

-- Zwiększa i zmniejsza głośność (kod zaczerpnięty z wpisu HexMonkeya:


-- http://forums.macrumors.com/showthread.php?t=144749).
else if voiceResponse is "głośniej" then
set currentVolume to output volume of (get volume settings)
set scaledVolume to round (currentVolume / (100 / 16))
set scaledVolume to scaledVolume + 1
if (scaledVolume > 16) then
set scaledVolume to 16
end if
set newVolume to round (scaledVolume / 16 * 100)
set volume output volume newVolume
else if voiceResponse is "ciszej" then
set currentVolume to output volume of (get volume settings)
set scaledVolume to round (currentVolume / (100 / 16))
set scaledVolume to scaledVolume - 1
if (scaledVolume < 0) then
set scaledVolume to 0
end if
set newVolume to round (scaledVolume / 16 * 100)
set volume output volume newVolume

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  245

else if voiceResponse is "sprawdź pocztę" then


tell application "Mail"
activate
check for new mail
set unreadEmailCount to unread count in inbox
if unreadEmailCount is equal to 0 then
say "W skrzynce odbiorczej nie ma nieprzeczytanych wiadomości."
else if unreadEmailCount is equal to 1 then
say "W skrzynce odbiorczej jest jedna nieprzeczytana wiadomość."
else
say "Masz " & unreadEmailCount & ¬
" nieprzeczytanych wiadomości w skrzynce odbiorczej."
end if
if unreadEmailCount is greater than 0 then
say "Mam przeczytać nieprzeczytane wiadomości?"
tell application "SpeechRecognitionServer"
activate
set voiceResponse to listen for {"tak", "nie"} ¬
giving up after 1 * minutes
end tell
if voiceResponse is "tak" then
set allMessages to every message in inbox
repeat with aMessage in allMessages
if read status of aMessage is false then
set theSender to sender of aMessage
set {savedDelimiters, AppleScript's text item delimiters} ¬
to {AppleScript's text item delimiters, "<"}
set senderName to first text item of theSender
set AppleScript's text item delimiters ¬
to savedDelimiters
say "Nadawca: " & senderName
say "Temat: " & subject of aMessage
delay 1
end if
end repeat
end if
end if
end tell

Ÿ else if voiceResponse is "godzina" then


set current_time to (time string of (current date))
set {savedDelimiters, AppleScript's text item delimiters} to ¬
{AppleScript's text item delimiters, ":"}
set hours to first text item of current_time
set minutes to the second text item of current_time
set AMPM to third text item of current_time
set AMPM to text 3 thru 5 of AMPM
set AppleScript's text item delimiters to savedDelimiters
say "Jest godzina " & hours & " " & minutes & AMPM
  --else if voiceResponse is "zadzwoń" then
-- tell application "Skype"
-- -- Podczas pierwszej próby dostępu do aplikacji Skype za pośrednictwem
-- -- tego skryptu
-- -- zostanie wyświetlone okno dialogowe zabezpieczeń interfejsu API Skype’a.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
246  10.5. Programowanie mówiącego systemu

-- -- Wybiera opcję "Pozwól tej aplikacji używać Skype’a", aby ¬


-- -- od tej pory skrypt miał dostęp do interfejsu API tej aplikacji.
-- activate
-- -- identyfikator testowej usługi echo123 należy zastąpić ¬
-- -- numerem telefonu lub identyfikatorem użytkownika komunikatora Skype
-- send command "CALL echo123" script name ¬
-- "Place Skype Call"
-- end tell
-- else if voiceResponse is "koniec rozmowy" then
-- tell application "Skype"
-- quit
-- end tell

¡ else if voiceResponse is "zamknij aplikację" then


set exitApp to "tak"
say "Zakończono nasłuchiwanie. Zamykanie aplikacji."
delay 1
do shell script "killall SpeechRecognitionServer"
end if
end repeat
end timeout

Aby zapewnić ciągłość działania programu, musimy najpierw otoczyć


ten skrypt dwiema pętlami. Pierwsza pętla (with timeout... end with)
ma zapobiegać przekraczaniu limitu czasowego przez ten skrypt. Od-
powiedni limit czasowy należy określić w sekundach. W tym przypadku
skrypt ma działać przez miesiąc (a średnia liczba sekund w jednym mie-
siącu wynosi około 2,6 miliona).
Druga pętla (while) jest powtarzana do momentu ustawienia wartości
"tak" w zmiennej exitApp (wspomniana wartość jest ustawiana poprzez
wydanie polecania głosowego „zamknij aplikację” — patrz końcowy
fragment kodu).
Musimy następnie zainicjalizować Speech Recognizer Server i przeka-
zać na jego wejściu tablicę słów i wyrażeń kluczowych za pośrednictwem
metody listen. Serwer rozpoznawania mowy będzie działał przez mie-
siąc, zatem obsługa otrzymywanych poleceń nie będzie wymagała wielo-
krotnego uruchamiania skryptu. Czas działania programu można zmie-
nić, odpowiednio modyfikując wartość giving up.
Jeśli wyrażenie przychodzące jest interpretowane jako polecenie włącze-
nia światła, skrypt otwiera domyślną przeglądarkę i kieruje ją na adres
URL serwera systemu internetowego włącznika światła. Wypowie-
dziane wyrażenie „zgaś światło” spowoduje otwarcie adresu URL tego
samego projektu z poleceniem off. Analogiczne rozwiązanie należałoby
zastosować do otwierania adresu URL serwera projektu drzwi otwiera-
nych przez Androida.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  247

Oprócz otwierania adresów URL w zależności od wydawanych po-


leceń głosowych nasz program może także współpracować z aplikacja-
mi systemu OS X przystosowanymi do integracji ze skryptami języka
AppleScript, jak iTunes czy Mail. W powyższym fragmencie kodu
zrealizowaliśmy następujące zadania:
1. Otwieramy aplikację iTunes.
2. Tworzymy pustą tablicę.
3. Wypełniamy tę tablicę wszystkimi utworami w lokalnej bibliotece
iTunes, przy okazji usuwając powtarzające się tytuły.
4. Wyodrębniamy z tablicy utworów nazwiska wykonawców.
5. Jeśli tablica zawiera przynajmniej jednego wykonawcę, nazwiska i
nazwy wykonawców są przekazywane na serwer rozpoznawania
mowy za pomocą metody listen for.
6. Prosimy użytkownika o wybór wykonawcy, którego utworów chce
słuchać. Jeśli użytkownik odpowiada nazwą lub nazwiskiem wyko-
nawcy występującego w bibliotece, przekazujemy na wejściu ser-
wera rozpoznawania mowy co najmniej jeden album tego wyko-
nawcy. Na tym etapie użytkownicy mogą też przerwać procedurę
wyboru muzyki, wypowiadając słowo „anuluj”.
7. Jeśli dla jakiegoś wykonawcy istnieje w bibliotece wiele albumów,
ta sama procedura jest powtarzana, aby użytkownik mógł wybrać
jeden z albumów wybranego wcześniej wykonawcy. W przeciw-
nym razie skrypt od razu rozpoczyna odtwarzanie albumu.
Polecenia wstrzymania, wznowienia i zatrzymania odtwarzania muzyki
oraz przejścia do następnego i poprzedniego utworu powodują wywo-
łania odpowiednich metod aplikacji iTunes.
Polecenia zwiększenia i zmniejszenia głośności powodują odczytanie bie-
żącej głośności ustawionej na komputerze Mac oraz zwiększenie lub zmniej-
szenie odpowiedniej wartości w takim samym stopniu jak w przypadku
klawiszy zwiększania i zmniejszania głośności na klawiaturze komputera
Mac. Te polecenia są szczególnie przydatne w sytuacji, gdy musimy
zwiększyć lub zmniejszyć głośność odtwarzanej muzyki bez użycia rąk.
Ta część skryptu wymaga uprzedniego skonfigurowania niezbędnych
kont poczty elektronicznej i wbudowanej aplikacji Mail systemu OS X.
Fragment odpowiedzialny za integrację z programem Mail realizuje
następujące zadania:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
248  10.5. Programowanie mówiącego systemu

1. Otwiera program Mail.


2. Sprawdza wszystkie skonfigurowane serwery poczty elektronicznej
pod kątem nowych, nieprzeczytanych wiadomości.
3. Zlicza nieprzeczytane wiadomości poczty elektronicznej we
wszystkich skrzynkach odbiorczych i na głos informuje użytkowni-
ka o tej liczbie.
4. Jeśli istnieją jakieś nieprzeczytane wiadomości, skrypt pyta użyt-
kownika, czy życzy sobie przeczytania tych wiadomości.
5. Jeśli użytkownik odpowie twierdząco, program tworzy tablicę nie-
przeczytanych wiadomości i dla każdej z nich odczytuje nazwisko
nadawcy i temat. W przeciwnym razie następuje koniec procedury
obsługi poczty elektronicznej.
Ÿ Ta część kodu wyodrębnia bieżącą godzinę z wartości zwróconej przez
funkcję current date języka AppleScript. Po uzyskaniu godziny skrypt
wykonuje następujące kroki:
1. Przypisuje bieżącą godzinę do łańcucha current_time.
2. Używa funkcji savedDelimiters języka AppleScript do podzielenia
łańcucha current_time według separatora :. Dzieli ten łańcuch na
wartości składowe reprezentujące godzinę i minutę. Dalsza część
łańcucha zawiera informację o tym, czy jest to godzina przed-, czy
popołudniowa.
3. Przypisuje uzyskane wartości odpowiednim zmiennym (reprezen-
tującym godziny, minuty oraz przedpołudnie lub popołudnie), po
czym głosowo przekazuje te informacje użytkownikowi.
  Czytelnicy, którzy dysponują zainstalowaną aplikacją kliencką Mac
Skype i chcą prowadzić rozmowy telefoniczne bez pomocy rąk, mogą
usunąć symbole komentarzy poprzedzające wiersze w tej części kodu
(w języku AppleScript komentarze oznacza się podwójnymi myślnikami).
Należy też skonfigurować nazwę konta w miejsce usługi testowej Skype’a
nazwanej echo123.
¡ To polecenie kończy wykonywanie skryptu i gwarantuje prawidłowe
zniszczenie procesu serwera rozpoznawania mowy za pomocą polecenia
powłoki killall SpeechRecognitionServer.
Po wpisaniu tego skryptu w edytorze języka AppleScript należy zapisać
program i kliknąć przycisk Kompiluj (Compile) na pasku narzędzi tego
edytora. Jeśli ten skrypt zawiera jakiekolwiek literówki czy inne błędy, nie

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  249

zostanie skompilowany. Ewentualne usterki należy usuwać tak długo, aż


skrypt zostanie prawidłowo skompilowany. Warto też raz jeszcze sprawdzić,
czy skalibrowany mikrofon bezprzewodowy jest włączony i czy poziom gło-
śności sygnału wejściowego został prawidłowo ustawiony. Głośność ze-
wnętrznych głośników należy ustawić na takim poziomie, aby odpowiedzi
systemu i odtwarzana muzyka były dobrze słyszalne. Wystarczy teraz kliknąć
przycisk Uruchom (Run) i przygotować się na dłuższą konwersację.

10.6. Rozmowa z własnym domem


Moment naszej największej chwały zbliża się wielkimi krokami. Wystarczy
teraz wypowiedzieć polecenie „godzina” i słuchać, jak nasz komputer wypo-
wiada bieżącą godzinę. Jeśli powiemy „włącz muzykę”, nasz komputer
powinien zapytać „którego wykonawcy chcesz posłuchać?”. Możemy teraz
powiedzieć nazwę lub nazwisko wykonawcy, którego utwory znajdują się
w lokalnej bibliotece aplikacji iTunes, po czym wybrać album tego artysty, aby
wreszcie rozpocząć odtwarzanie. Kiedy znudzi nam się słuchanie muzyki,
wystarczy, że powiemy „zatrzymaj muzykę”.
Aby uzyskać informacje o nieprzeczytanej poczcie w skrzynce odbiorczej,
wystarczy wydać komputerowi polecenie „sprawdź pocztę”. Warto sprawdzić
na ekranie komputera, czy system prawidłowo podaje liczbę nieprzeczyta-
nych wiadomości oraz czy odczytuje nadawców i tematy właściwych wia-
domości.
Jeśli dysponujemy działającym systemem drzwi sterowanych przez Androida
lub internetowego włącznika światła, możemy dodatkowo wydać polecenie
„otwórz drzwi” lub „zapal światło” i sprawdzić, czy nasz system odpowied-
nio odblokował elektryczny rygiel drzwi wejściowych lub zapalił światło.
Wreszcie osiągnęliśmy swój cel, czyli stworzyliśmy dom sterowany głosem.
Super!
Warto przeprowadzić testy polegające na wydawaniu poleceń z różnych
punktów pokoju. Po sprawdzeniu działania systemu w jednym pokoju należy
wykonać testy w pozostałych pomieszczeniach. W ten sposób przekonamy
się, jak daleko sięga zasięg naszego bezprzewodowego mikrofonu — w któ-
rych pomieszczeniach sygnał jest zbyt słaby, aby skutecznie wydawać pole-
cenia systemowi. Warto mieć na uwadze te ograniczenia w przyszłości,
podczas właściwego korzystania z tego systemu.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
250  10.7. Następne kroki

Aby zapewnić odpowiednią trwałość tego skryptu, warto go przekonwertować


na plik wykonywalny. Po umieszczeniu ikony skryptu na pulpicie systemu
OS X należy ją kliknąć, przytrzymując klawisz Ctrl, po czym wybrać opcję
Otwórz w czasie logowania (Open at Login) w sekcji opcji wyświetlonego
menu kontekstowego. Dzięki temu skrypt będzie automatycznie urucha-
miany przy okazji każdego logowania się w systemie Mac — zaraz po zalo-
gowaniu nasz system będzie gotowy do obsługi zdefiniowanych wcześniej
poleceń głosowych.
Skrypt można oczywiście udoskonalać i rozbudowywać, dodając obsługę
nowych słów i wyrażeń, które najlepiej będą pasowały do danego środowi-
ska. Możemy na przykład przystosować projekt sterowania zasłonami do
obsługi przez internet, aby jednym poleceniem „odsłoń okna” podnieść
wszystkie zasłony i rolety. Innym ciekawym rozwiązaniem byłoby pobieranie
prognozy pogody z internetu (na przykład z serwisu weather.gov należącego
do Amerykańskiej Narodowej Służby Oceanicznej i Meteorologicznej) i głośne
informowanie domowników o nadchodzących zmianach. Zachęcam też do
rozważenia rozwiązań opisanych w podrozdziale „Następne kroki”.

10.7. Następne kroki


Gratuluję udanej realizacji ostatniego projektu opisanego w tej książce. Jak
widać, stworzenie systemu automatyzacji domu na podstawie poleceń głoso-
wych nie jest niczym trudnym. Mimo że dostępne technologie nie są dosko-
nałe, możliwość sterowania urządzeniami domowymi w ten sposób jest spo-
rym osiągnięciem (jeszcze dwadzieścia lat temu kojarzono podobne roz-
wiązania raczej z wizjami autorów science fiction).
Zachęcam do dalszego doskonalenia opisanych tutaj rozwiązań na przykład
poprzez wprowadzenie następujących elementów:
 Warto rozszerzyć mechanizm głosowej prezentacji nieprzeczytanych
wiadomości o informowanie użytkownika o dacie wysłania i zawartości
poszczególnych wiadomości. Cennym rozwiązaniem byłoby także do-
danie możliwości usuwania wiadomości lub odpowiadania na wia-
domości przy użyciu z góry zdefiniowanych szablonów (na przykład
w formie polecenia „odpowiedz »tak«”).
 Mechanizm zarządzania tablicą wykonawców i albumów z biblioteki
aplikacji iTunes można skopiować, tak aby użytkownik mógł łatwo (za
pomocą poleceń głosowych) zarządzać kontaktami w komunikatorze

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 10. • Dajmy przemówić naszemu domowi  251

Skype i wybierać z listy tych kontaktów osobę, do której chce zadzwonić.


Po wydaniu polecenia „zadzwoń” skrypt powinien wypełnić tablicę
dalszych poleceń nazwami kontaktów aktywnego konta komunikatora
Skype. Tak jak w przypadku nazw i nazwisk wykonawców, użytkow-
nik musiałby tylko odpowiedzieć na pytanie, podając nazwę kon-
taktu, z którym chce się połączyć.
 Warto rozważyć rozszerzenie skryptów języka Python projektów
ćwierkającego karmnika dla ptaków i systemu powiadamiania o do-
starczonych paczkach tak, aby przylot ptaka lub dostarczenie paczki
powodowało odpowiedni komunikat głosowy. Odpowiednie działanie
można zaimplementować za pośrednictwem poleceń powłoki archi-
tektury OSA (od ang. Open Script Architecture)6.
 Mechanizmy rozpoznawania mowy można przenieść na platformy
programowe inne niż system OS X — wystarczy przekonwertować
ten skrypt na aplikację systemu Android (za pomocą intencji Recogni-
zerIntent systemu Android) lub aplikację systemu Windows (przy
użyciu interfejsu Speech API firmy Microsoft)7.

6
http://developer.apple.com/library/mac/#documentation/Darwin/Reference/
ManPages/man1/osascript.1.html
7
Patrz odpowiednio http://developer.android.com/resources/articles/speech-input.html
lub http://msdn.microsoft.com/en-us/library/ee125663%28VS.85%29.aspx.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
252  10.7. Następne kroki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Część III
Przewidywana
przyszłość

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
254  Programming Your Home

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 11.
Przyszłe projekty

Z
decydowana większość tej książki była poświęcona rzeczywistym
projektom automatyzacji domu, które już teraz można zrealizować
stosunkowo niewielkim kosztem. W tym rozdziale przeanalizujemy
wyjątkowo ciekawą, błyskawiczną ewolucję w dziedzinie mikrokontrolerów,
smartfonów i komputerów, aby na tej podstawie spróbować przepowiedzieć
przyszłość tych technologii.
Zaczniemy od omówienia potencjalnych scenariuszy rozwoju technologii
Arduino, systemu Android i innych systemów operacyjnych w niedalekiej
przyszłości. W dalszej części rozdziału podejmiemy próbę rozszerzenia
naszych prognoz jeszcze o dekadę, aby wyobrazić sobie technologie auto-
matyzacji domu, które będą nam towarzyszyć w 2025 roku. Zważywszy na
niesamowity postęp technologii mobilnych w ostatnich dziesięciu latach,
nasze pomysły dotyczące przyszłego rozwoju tych technologii szybko mogą
się okazać zupełnie pospolite. W rzeczywistości większość proponowanych
scenariuszy można by zrealizować już teraz (podczas implementacji tych
rozwiązań bardzo pomocne byłyby doświadczenia zebrane w trakcie pro-
jektów opisanych w tej książce). Zanim wybiegniemy dalej w przyszłość,
warto przyjrzeć się rozwiązaniom, które powinny zagościć na sklepowych
półkach już w ciągu roku.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
256  11.1. Przyszłość na wyciągnięcie ręki

11.1. Przyszłość na wyciągnięcie ręki


Dzięki otwartym rozwiązaniom sprzętowym przybiera na sile coraz więcej
firm rozszerza swoją ofertę o odpowiednie produkty i usługi. Okazuje się
jednak, że także uznane technologie, jak Arduino czy Android, nie stoją
w miejscu. Obie te platformy doczekały się ważnych aktualizacji w czasie, gdy
kończyłem pracę nad tą książką.
W tym podrozdziale omówimy zapowiedziane innowacje i usprawnienia,
które zostaną wprowadzone w najbliższym czasie. Przeanalizujemy także
wpływ tych zmian na pracę konstruktorów używających tych technologii (na
przykład podczas realizacji projektów opisanych w tej książce).

Arduino 1.0
Dokładnie w czasie, gdy pisałem ostatnie strony tej książki, zespół odpo-
wiedzialny za rozwój technologii Arduino zapowiedział nadchodzące wyda-
nie wersji 1.0. W nowej wersji wprowadzono wiele daleko idących zmian,
które z pewnością wymuszą odpowiednie dostosowanie istniejącego kodu.
Decyzja zespołu rozwijającego technologię Arduino była o tyle ryzykow-
na, że istnieje mnóstwo bibliotek, przykładów kodu, dokumentów, książek
i zapisów wideo przygotowanych przez samych użytkowników dla wcze-
śniejszych wersji tej technologii. Nie inaczej jest w przypadku tej książki.
Po spopularyzowaniu standardu Arduino 1.0 opisane projekty i ich za-
leżności (w formie bibliotek) z pewnością będą wymagały modyfikacji pod
kątem zmian wprowadzonych w tym standardzie. Najważniejsze spośród
wprowadzonych zmian opisano poniżej:
 Rozszerzenia plików szkiców zmieniono z .pde na .ino. Zdecydo-
wano się na tę zmianę, aby uniknąć mylenia tych szkiców ze szkica-
mi języka Processing, które także są zapisywane w plikach z roz-
szerzeniem .pde.
 Biblioteka Ethernet platformy Arduino będzie oferowała rdzenną
obsługę systemu DNS i protokołu DHCP. Takie rozwiązanie
znacznie ułatwi przypisywanie adresów IP.
 Klasa String została zoptymalizowana, dzięki czemu wymaga
mniejszej ilości zasobów i może realizować więcej zadań, gene-
rując mniejsze obciążenie.
 Klasa Serial oferuje teraz więcej funkcji do analizy składniowej,
dzięki którym możemy łatwiej przeszukiwać dane i ładować wiele
bajtów do bufora. Opisana zmiana może powodować pewne

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 11. • Przyszłe projekty  257

problemy podczas stosowania istniejącego kodu. Problemy mogą


mieć związek na przykład ze stosowaniem operacji asynchronicz-
nych (niedostępnych lub nieużywanych w szkicach sprzed wydania
Arduino 1.0).
 Także pozostałe biblioteki wbudowane, na przykład te obsługujące
czytnik kart SD, zostały zaktualizowane z myślą o ułatwieniu
budowy złożonych szkiców bez obaw o niezawodność i wydajność
wewnętrznych rozwiązań.
 Zmiany w samym środowisku IDE są raczej kosmetyczne. Ogra-
niczono się do wprowadzenia nowych ikon, schematów kolorów
i wskaźników (na przykład paska postępu kompilacji), aby uno-
wocześnić wygląd środowiska IDE i ułatwić użytkownikom ko-
rzystanie z elementów interfejsu.
 W nowej wersji zmieniono nazwy, zwracane typy i implementacje
wielu ważnych klas funkcji (w tym podstawowych elementów bi-
blioteki Wired). Autorzy bibliotek będą jeszcze przez wiele mie-
sięcy dostosowywać swój kod pod kątem współpracy ze zmodyfi-
kowanymi rozwiązaniami niskopoziomowymi.
Szczegółowy wykaz zmian można znaleźć w odpowiednim wpisie na ofi-
cjalnym blogu technologii Arduino1. Środowisko programowania Arduino
IDE na szczęście jest na tyle autonomiczne i przenośne, że instalacja
wielu różnych wersji na jednym komputerze nie stanowi żadnego proble-
mu. Oznacza to, że możemy nadal używać wcześniejszych wydań środo-
wiska IDE (przynajmniej dopóki niezbędne zależności nie zostaną zaktuali-
zowane w celu zapewnienia zgodności z najnowszymi zmianami). Z czasem,
wraz z popularyzacją nowej wersji (najpewniej w ciągu roku), coraz więcej
popularnych bibliotek użytkowników doczeka się odpowiednich konwersji.
W tej sytuacji celem przyszłych wydań tej książki będzie właśnie prezentacja
rozwiązań (w tym kodu źródłowego) zgodnych zarówno z nowym, jak i ze
starymi wydaniami tego środowiska IDE.

Android@Home
Na konferencji Google IO w 2011 roku oficjalnie ogłoszono powstanie
interfejsu Android Open Accessory API i zestawu narzędzi Android
Development Kit (ADK). Celem obu projektów było zapewnienie dostępu

1
http://arduino.cc/blog/2011/10/04/arduino-1-0/

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
258  11.1. Przyszłość na wyciągnięcie ręki

do tanich mikrokontrolerów, czujników i urządzeń wykonawczych na po-


ziomie interfejsu API systemu operacyjnego Android. Uczestnicy konfe-
rencji otrzymali niestandardowe wersje płytek Arduino Mega z zainstalo-
wanymi podstawowymi czujnikami — wskazania tych czujników mogli
odczytywać za pośrednictwem urządzeń z systemem Android, na przykład
telefonu Google Nexus2. Na wspomnianej konferencji zasugerowano wiele
scenariuszy konfiguracyjnych możliwych dzięki tej technologii. Jednym z nich
było rozwiązanie nazwane Android@Home. Zademonstrowano przykłady
sterowania bezprzewodowym oświetleniem, systemami domowej rozrywki
oraz urządzeniami do ćwiczeń. Należy przypuszczać, że na konferencji
Google IO 2012 poznamy wiele dodatkowych rozwiązań przygotowanych
przez niezależnych producentów.
Projekt Google@Home jest możliwy dzięki zestawowi narzędzi ADK,
a sercem tej technologii jest specyfikacja sprzętowa, która ma na celu wy-
znaczenie standardów komunikacji pomiędzy urządzeniami. System ope-
racyjny Android może prawidłowo reagować na te komunikaty. Należy
oczekiwać, że za jakiś czas, kiedy odpowiednie technologie sprzętowe doj-
rzeją i zyskają na popularności, system operacyjny Android będzie sterował
pracą dużo większej liczby różnych urządzeń, nie tylko telefonów. Firma
Google ma nadzieję, że proponowane rozwiązania z czasem zrewolucjoni-
zują rynek automatyzacji domu — warunkiem takiej rewolucji jest akcep-
tacja tej specyfikacji przez producentów urządzeń domowych i dopuszcze-
nie do wzajemnej komunikacji tych urządzeń.
Jako doświadczony obserwator wielu podobnych prób wprowadzenia stan-
dardów automatyzacji domu w przeszłości nie wróżę temu projektowi więk-
szych szans — jestem sceptyczny przede wszystkim z powodu małego (przy-
najmniej na razie) zainteresowania projektem Google@Home ze strony
innych firm niż Google. Wielu producentów prawdopodobnie przyjęło
postawę wyczekiwania i śledzenia sytuacji, aby przystąpić do projektu we
właściwym momencie. Nawet jeśli projekt Android@Home nie zawładnie
sercami milionów konsumentów, jego wpływ na sferę automatyzacji urządzeń
domowych bez wątpienia skłoni konkurentów firmy Google (w szczególno-
ści takich gigantów jak Apple i Microsoft) do bliższej analizy potencjału
tego rynku. Jednym z prawdopodobnych pierwszym obszarów, w których
można z powodzeniem stosować tego rodzaju technologie, jest telewizja.

2
http://www.adafruit.com/products/191

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 11. • Przyszłe projekty  259

Przycisk Home w urządzeniach firmy Apple


Wraz z wprowadzeniem technologii Siri w telefonie iPhone 4S firma Apple
skonstruowała pewien metainterfejs ponad standardowym mechanizmem
wyszukiwania informacji — interfejs, który nie potrzebuje przeglądarki
internetowej do przeglądania wyników zapytania. Dla właścicieli wyszukiwa-
rek internetowych, w tym firm Google i Microsoft, nowa technologia oznacza
zasadniczą zmianę, ponieważ modele biznesowe ich wyszukiwarek polegają
przede wszystkim na przeplataniu wyników wyszukiwania z powiązanymi
reklamami. W pewnych scenariuszach technologia Siri filtruje uzyskane
wyniki tekstowe przed ich głosowym przekazaniem użytkownikowi (robi to
na podstawie konwersacji z użytkownikiem, nie operacji na bazie danych),
eliminując przy tym niechciane reklamy. Chociaż nie można wykluczyć, że
pewnego dnia firma Apple zdecyduje się dodać reklamy do konwersacji
prowadzonej przez technologię Siri i użytkownika (takie rozwiązanie tech-
nicznie jest możliwe), w najbliższym czasie opisana technologia prawdo-
podobnie będzie wolna od reklam. Którą technologię wybierze użytkownik,
który ma do dyspozycji albo wpisanie na klawiaturze zapytania i uzyskanie
mnóstwa linków wymieszanych z reklamami, albo głosowe poproszenie
telewizora o informację i otrzymanie precyzyjnej, jasnej odpowiedzi?
Firma Apple, podobnie jak firmy Google i Microsoft, zaprojektowała do-
datkowo komputer, który nawiązuje połączenie z telewizorem w celu stru-
mieniowej transmisji muzyki lub zapisów wideo. Jeśli wierzyć plotkom, na-
stępna generacja urządzenia Apple TV umożliwi głosowe sterowanie telewi-
zorem z wykorzystaniem technologii Siri (bez użycia tradycyjnego pilota).
Łatwo sobie wyobrazić możliwość proszenia telewizora o wyświetlenie
lokalnej prognozy pogody, odtworzenie albumu ulubionego wykonawcy, wy-
słuchania i wysłania odpowiedzi na wiadomość poczty elektronicznej oraz —
to możliwe! — nawiązanie połączenia z pozostałymi urządzeniami w domu
(zapewne iPhone’ami i iPadami) w celu ich synchronizacji (za pośred-
nictwem usługi iCloud) i włączenie do opisanej konwersacji. Trudno
oczekiwać, by firmy Google i Microsoft bezczynnie czekały na ruchy Ap-
ple — przeciwnie, należy oczekiwać, że technologie rozpoznawania mowy
i ogromne zbiory danych zgromadzone na serwerach pozwolą tym poten-
tatom pokonać firmę Apple przynajmniej w dziedzinie poleceń głosowych.
Jak nietrudno odgadnąć, inżynierowie firmy Apple stale poszukują sposo-
bów bardziej ścisłego związania swojej platformy z urządzeniami domo-
wymi. Firma Apple wciąż nie ujawniła swoich planów dotyczących rynku
domowych urządzeń konsumenckich, które w przyszłości będą konkurowały

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
260  11.2. Prognoza długoterminowa

z technologią Android@Home firmy Google i pochodnymi urządzenia


Kinect firmy Microsoft. Ewentualna propozycja firmy Apple z pewnością
wzbudzi ogromne zainteresowanie i będzie się cieszyła sporym wsparciem
ze strony programistów.

11.2. Prognoza długoterminowa


Mimo że wszystkie te rozwiązania projektowane z myślą o ułatwieniu na-
szego codziennego życia są naprawdę wspaniałe, podstawowym warunkiem
funkcjonowania tych technologii jest energia elektryczna. Łatwo sobie wy-
obrazić wzrost zapotrzebowania na zasoby naszej planety, gdyby każdy miał
ochotę i możliwość automatyzacji swojego domu. Miejmy nadzieję, że na-
stępne pokolenie przedsiębiorców osiągnie w dziedzinie gromadzenia i dys-
trybucji energii równie wiele jak moje pokolenie osiągnęło na polu kom-
puterów i globalnej komunikacji. Inteligentne sieci elektroenergetyczne,
odnawialne źródła energii i coraz większe poszanowanie dla środowiska
będą równie ważne dla przyszłych systemów automatyzacji jak niedrogie
czujniki, standardowe protokoły i wszechobecna, bezpieczna komunikacja
bezprzewodowa.
Zważywszy na problemy z dostępem do energii elektrycznej, można przy-
jąć, że coraz większą popularnością będą się cieszyły czujniki i systemy
przekazywania komunikatów o niskim poborze energii. Ile współczesnych
komputerów, monitorów, zegarów, radioodbiorników, telefonów, tabletów
i konsol do gier stale podłączamy do gniazdek elektrycznych w naszym domu?
Jeszcze czterdzieści lat temu lista takich urządzeń była nieporównanie krót-
sza i obejmowała głównie lampy, lodówki, czasem telewizor i gramofon,
kilka radioodbiorników i zegar. Po zaledwie czterdziestu latach w wielu do-
mach każde pomieszczenie zawiera przynajmniej kilka urządzeń elektrycz-
nych, które w dodatku stale komunikują się z innymi urządzeniami. Scen-
tralizowane usługi monitorują przekazywane komunikaty w celu wykrywania
ważnych zdarzeń i właściwego reagowania na sytuację. Jak podobne syste-
my będą działały w przyszłości?

Dom jako komputer


Wyobraźmy sobie sytuację, w której wybieramy jeden z projektów opisa-
nych w tej książce i rozszerzamy odpowiedni system, tak aby obejmował
wszystkie pomieszczenia w naszym domu. Automatyzacja jest dosłownie

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 11. • Przyszłe projekty  261

wszędzie, a w powietrzu aż roi się od komunikatów przesyłanych do ser-


wera w celu dalszego przetworzenia. Sam serwer może mieć postać wirtual-
nego serwera prywatnego działającego w chmurze lub magistrali komunika-
tów zarządzanej przez zewnętrznego usługodawcę. Taki dom może bły-
skawicznie informować domowników o ważnych zdarzeniach i jednocześnie
wykrywać obecność mieszkańców domu, aby na tej podstawie dostosowywać
swoje reakcje na spływające komunikaty. Systemy rozpoznawania obrazów
i głosu będą potrafiły określać tożsamość osób przebywających w domu
i dostosowywać usługi automatyzacji do preferencji tych osób. Życie w śro-
dowisku wypełnionym rozmaitymi czujnikami będzie równie naturalne i bez-
problemowe jak dodawanie wpisów na Twitterze za pomocą telefonu. Gro-
madzone dane będą analizowane i dostosowywane do stylu życia domow-
ników. Dom będzie w stanie przewidywać nasze czynności i zachowania
na podstawie takich czynników zewnętrznych jak pora roku, pora dnia, pogo-
da, dostarczone przesyłki, charakter gości przebywających w domu, dłu-
gość wizyty, preferowane tryb i forma cyfrowej rozrywki oraz częstotliwość
i sposób filtrowania komunikatów ostrzegawczych.

System zainstalowany w materacu


Części elektroniczne są coraz tańsze. Jeśli porównamy cenę płytki Arduino
(dostępnej za około 100 złotych) do kosztu komputera sprzed dziesięciu
lat, który oferował identyczną moc obliczeniową, nietrudno sobie wyobra-
zić możliwości sprzętu dostępnego za jeszcze mniejsze pieniądze w nieda-
lekiej przyszłości. Wystarczy połączyć te mikrokontrolery z jeszcze tańszymi
czujnikami, aby stworzyć dom pełen punktów gromadzenia i przetwarzania
informacji. Po naszym wyjściu dom przejdzie w stan uśpienia, w którym
będzie zużywał tylko tyle energii elektrycznej, ile potrzebuje do utrzymania
gotowości.
W czasie snu czujniki nacisku zainstalowane w naszym łóżku określą, czy
mieliśmy spokojny sen, i na tej podstawie dostosują dźwięk budzika, który
obudzi nas rano. Jeśli we wszystkich drzwiach wewnętrznych będą zainsta-
lowane czujniki, dom zarejestruje wzorce poruszania się pomiędzy pokojami
i na tej podstawie będzie mógł z wyprzedzeniem włączać światła i używane
urządzenia.
Dom będzie pamiętał, że na przykład we wszystkie dni robocze wstajemy
do pracy o 6 rano, bierzemy prysznic, aby po 30 minutach udać się do kuch-
ni na filiżankę kawy. Zaraz po uruchomieniu budzika system może odkrę-
cić wodę pod prysznicem, aby miała odpowiednią temperaturę w momencie,

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
262  11.3. Dom przyszłości

w którym wejdziemy do kabiny. W czasie, w którym będziemy się ubierać,


ekspres będzie dla nas parzył świeżą kawę, tak aby była gotowa, kiedy wej-
dziemy do kuchni. Dom będzie też wiedział, że w soboty śpimy do 8, zatem
nie będzie powtarzał opisanej procedury — w weekend wszystkie urządzenia
domowe związane z budzeniem domowników będą działały w trybie stero-
wania ręcznego. Opisany scenariusz można zaprogramować i zaimplemen-
tować już dzisiaj przy użyciu narzędzi i technologii, którymi posługiwaliśmy
się podczas realizacji projektów opisanych w tej książce. Spadek cen elek-
troniki, rozwój technologii przetwarzania sygnałów generowanych przez
czujniki w chmurze i postępująca standaryzacja interfejsów spowodują, że
coraz więcej osób będzie oczekiwało realizacji podobnych scenariuszy.

11.3. Dom przyszłości


Jak każdy pasjonat nowych technologii lubię wyobrażać sobie prawdopodob-
ne scenariusze rozwoju istniejących rozwiązań w przyszłości. Jako pragma-
tyczny programista wiem jednak, że tego rodzaju wizje nie mogą się spełnić
w ciągu jednej nocy. Warunkiem postępu są przyrostowe zmiany i uspraw-
nienia w wielu powiązanych dziedzinach. Wszystkie te doskonalone usłu-
gi, wynajdywane technologie i odkrycia w pewnym momencie osiągają punkt
krytyczny i jako takie wpływają na bieg historii.
W swoim życiu miałem szczęście uczestniczyć w trzech wielkich rewolucjach
technologicznych. Pierwsza z nich polegała na wprowadzeniu i błyskawicznej
ewolucji komputera osobistego w latach osiemdziesiątych ubiegłego wieku.
Drugą rewolucją była prawdziwa eksplozja popularności internetu w latach
dziewięćdziesiątych ubiegłego wieku, zaś trzecia rewolucja polegała na
błyskawicznym rozwoju urządzeń mobilnych w pierwszej dekadzie XXI
wieku.
Rozmaite technologie z czasem spotykają się w jednym punkcie. Przetwarza-
nie w chmurze, superkomputery wielkości telefonu z dostępem do internetu,
niedrogie czujniki przystosowane do komunikacji sieciowej, autonomiczne
sterowniki, tanie nośniki danych i krótsze cykle przetwarzania z czasem
doprowadzą do nowej, równie niezwykłej ery w historii przetwarzania infor-
macji. Po uwzględnieniu wszystkich tych czynników decydujących o rozwoju
technologii przygotowałem opis typowego popołudnia miłośnika technologii
w 2025 roku (patrz rysunek 11.1 zatytułowany „Bardziej inteligentny dom
ok. roku 2025”).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 11. • Przyszłe projekty  263

Rysunek 11.1. Bardziej inteligentny dom ok. roku 2025

Po powrocie do domu po długim dniu w pracy Magda aktywuje zamek


w drzwiach obsługiwanych bez użycia kluczy. Zdarzenie otwarcia drzwi jest
zapisywane (wraz z odpowiednim zapisem wideo) w bezpiecznym banku
danych w chmurze. Na podstawie współrzędnych systemu GPS telefon
Magdy włączył w domu klimatyzację na dwadzieścia minut przed jej wej-
ściem do domu. W momencie przybycia do domu temperatura wewnątrz
jest identyczna jak wtedy, gdy rano wychodziła do pracy.
Na schodach czeka paczka zawierająca ręczniki papierowe, które zostały
automatycznie zamówione w momencie wykrycia kończącego się zapasu
w podajniku jednorazowych ręczników. Komunikat potwierdzający dostar-
czenie przesyłki automatycznie zeruje licznik tego podajnika, dzięki czemu
dalsze zamówienia nie są wysyłane.
Magda ma ze sobą torbę z zakupami, które zrobiła na podstawie listy wy-
generowanej przez lodówkę. Czujniki w lodówce wykryły, że jutro upływa
termin przydatności do spożycia pomidorów, zatem Magda postanowiła
kupić dodatkowe składniki potrzebne do przygotowania sosu spaghetti.
Podczas przygotowywania posiłku i nalewania do garnka wody na maka-
ron spaghetti czujniki zainstalowane w kranie monitorują czystość wody.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
264  11.3. Dom przyszłości

W razie wykrycia jakiejś anomalii system automatycznie wysyła odpowiedni


komunikat do wydziału gospodarki wodnej urzędu miasta.
Po obiedzie Magda postanawia trochę poćwiczyć na swoim stacjonarnym
symulatorze roweru. Magda zwykle spotyka o tej porze znajomego pod-
czas przejażdżki po drodze prowadzącej przez prerię. Zakłada więc słu-
chawki śledzące ruch w trzech wymiarach, włącza listę ulubionych utworów
i zaczyna pedałować. Zestaw słuchawkowy zawiera wbudowane czujniki
pulsu, ciśnienia krwi i pocenia się — monitorowane wartości są wyświe-
tlane ponad sielankową sceną powoli mijanych pagórków i kołyszącego się
zboża. Po kilku minutach awatar znajomego Magdy pojawia się obok niej
i wysyła sygnał sprawdzający, czy Magda jest zainteresowana rozmową
w czasie rowerowej przejażdżki. Magda potwierdza zainteresowanie roz-
mową, zatem oboje wspólnie spędzają następne pół godziny na przejażdżce
i pogawędce. Na końcu przejażdżki każdy rowerzysta otrzymuje 200 punk-
tów energii, które są doliczane do sieci elektroenergetycznej zasilanej między
innymi przez rowery treningowe.
Fotokomórki zainstalowane w oknach wykrywają zmierzch, co powoduje
odpowiednie przygotowanie oświetlenia domu, w tym zasunięcie zasłon
i aktywację czujników ruchu w poszczególnych pokojach. Dawno minęły
czasy, w których trzeba było ciągle włączać i wyłączać światło oraz można
było omyłkowo zostawić zapalone światło w pustym pokoju. System oferuje
jeszcze specjalny tryb na czas wizyty gości, jednak przez większość czasu
czujniki ruchu w zupełności wystarczają do włączania i wyłączania światła
zależnie od obecności domowników w poszczególnych pomieszczeniach.
Opisana strategia zarządzania oświetleniem ma niemały wpływ na wysokość
rachunków za energię elektryczną.
Magda siada przed telewizorem, aby odpocząć. Prosi telewizor o listę no-
wych zapisów wideo polecanych przez jej znajomych. Sterowanie głosem
jest teraz czymś zupełnie naturalnym w przypadku urządzeń przekazujących
treści. Udało się także udoskonalić algorytmy filtrowania treści i identyfikacji
samych użytkowników. Podczas odtwarzania sekwencji klipów wideo na
ekranie jest prezentowany także bieżący status Magdy i jej znajomych, lista
komunikatów, prognoza pogody i lista najbliższych programów (zapisów
wideo). Magda w każdej chwili może zażądać wyświetlenia wybranych in-
formacji. Na podstawie prognozy pogody Magda decyduje, co ubierze na
siebie jutro. Ponieważ zbliża się ciepły front atmosferyczny, wieszaki w garde-
robie Magdy są ustawiane w taki sposób, aby odpowiednie ubrania były do-

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 11. • Przyszłe projekty  265

stępne na wyciągnięcie ręki. System może zarządzać ubraniami, ponieważ


w każdym wieszaku zainstalowano czujnik RFID. Jutro ma być ciepło
i słonecznie.
Mam nadzieję, że spodobała Ci się moja wizja przyszłości. Czytelnicy,
którzy wolą sami wyznaczać kierunki rozwoju technologii zamiast czekać
na to, co przyniesie przyszłość, mogą już teraz zbudować podobny system
automatyzacji domu za pomocą dostępnych rozwiązań. Odpowiednie
połączenie efektywnych kosztowo technologii, prostej implementacji, oka-
zyjnych zakupów, akcji marketingowych i wyboru właściwego momentu
spowoduje, że ktoś kiedyś zrealizuje ten futurystyczny scenariusz, na zawsze
zmieniając sposób interakcji ludzi z ich domami. Tym kimś możesz być
właśnie Ty!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
266  11.3. Dom przyszłości

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 12.
Więcej pomysłów
na projekty

S
koro dysponujemy już niezbędnymi podstawami, możemy wykorzystać
zebrane doświadczenia w zakresie projektowania i konstruowania sys-
temów automatyzacji domu do tworzenia własnych projektów. W tym
niedługim ostatnim rozdziale krótko przeanalizujemy pomysły na alterna-
tywne wykorzystanie elementów i urządzeń, których używaliśmy w projektach
opisanych w tej książce.
Czytelnicy, którzy zbudowali wszystkie projekty opisane w tej książce, już
teraz dysponują większością sprzętu potrzebnego do realizacji pomysłów
prezentowanych w tym rozdziale. Możemy także wykorzystać kod źródło-
wy tych projektów — w wielu przypadkach wystarczy wprowadzenie kilku
drobnych zmian. Przeanalizujmy teraz kilka dodatkowych sposobów na
zaprogramowanie domu.

12.1. Wykrywacz bałaganu


Masz małżonka, dzieci lub partnera, którzy za żadne skarby nie potrafią utrzy-
mać porządku? Niezależnie od tego, jak często sprzątasz, w domu stale
jest brudno? Każda wolna, posprzątana przestrzeń natychmiast przyciąga
stare gazety, ulotki reklamowe, puste opakowania, brudne ubrania, tekturo-
we kartony i rozmaite inne śmieci? Właśnie z myślą o takich przypadkach

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
268  12.2. Monitor zużycia energii elektrycznej

powstała koncepcja nowatorskiego systemu wykrywacza śmieci przy użyciu


czujnika odległości (dalmierza) na podczerwień1.
Czujnik należy skierować w stronę pustej przestrzeni, aby zmierzyć jego
wskazania dla posprzątanego pomieszczenia. Pojawienie się śmieci spowo-
duje, że odległość wskazywana przez dalmierz będzie mniejsza. Wykrycie
śmieci powinno powodować wysłanie wiadomości poczty elektronicznej do
współlokatorów podejrzewanych o śmiecenie z żądaniem usunięcia śmieci
z obszaru monitorowanego przez czujnik. To do projektanta należy okre-
ślenie agresywności systemu rozumianej jako częstotliwość wysyłania tych
powiadomień. Po usunięciu śmieci system może wysłać (w imieniu domu)
wiadomość z podziękowaniami za przywrócenie porządku.

12.2. Monitor zużycia


energii elektrycznej
Jeśli wykorzystamy nieco zmodyfikowaną koncepcję znaną z urządzenia
Tweet-A-Watt firmy Adafruit2 do budowy wykrywacza przepływu prądu
elektrycznego (nazwanego na przykład Kill-A-Watt), będziemy mogli mie-
rzyć zużycie energii elektrycznej przez takie urządzenia jak lodówka czy
telewizja.
Niektórzy dostawcy energii elektrycznej już teraz oferują swoim klientom
możliwość śledzenia danych o zużyciu energii (zwykle w formie miesięcz-
nych statystyk). Odpowiednie dane są przeważnie dostępne na stronach
internetowych dostawców — na podstawie tych danych i wskazań naszego
urządzenia można obliczyć procentowy udział monitorowanych urządzeń
w łącznym zużyciu energii przez gospodarstwo domowe. Miesięczny rachu-
nek za energię elektryczną pozwoli nam dodatkowo obliczyć koszt funk-
cjonowania wybranych urządzeń w ciągu miesiąca, doby i godziny. Wielu
użytkowników będzie zaskoczonych, kiedy odkryją, ile pieniędzy wydają
na oglądanie telewizji przez kilka godzin dziennie lub ile naprawdę kosz-
tuje funkcjonowanie zamrażarki, którą kupili po okazyjnej cenie w jakiejś
wyjątkowej promocji.

1
http://www.adafruit.com/products/164
2
http://www.adafruit.com/products/143

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 12. • Więcej pomysłów na projekty  269

12.3. Elektryczny strach na wróble


Masz problem ze zwierzętami, które regularnie nawiedzają Twój ogródek
warzywny? Nieproszonych gości można się pozbyć, stosując odpowiednie
technologie. Zapomnijmy o malowniczych, ale bezużytecznych, statycznych
strachach na wróble — jeśli mają skutecznie spełniać swoją funkcję, muszą
sprawiać wrażenie żywych (dzięki czujnikowi ruchu i mocnym silnikom).
Kiedy ten nieznośny królik znowu wpadnie do naszego ogródka, aby urzą-
dzić sobie kolację z naszych warzyw, czujnik ruchu wykryje nieproszonego
gościa i ożywi stracha na wróble. Strach będzie teraz poruszał ramionami
i nogami na tyle sugestywnie, aby skutecznie przestraszyć królika. Po wykry-
ciu ruchu strach na wróble może też robić zdjęcia za pomocą telefonu z sys-
temem Android zainstalowanego w głowie stracha — uzyskane w ten sposób
zdjęcia zwierząt można bez trudu wysyłać za pośrednictwem poczty elek-
tronicznej.

12.4. Pilot systemu domowej rozrywki


Warto rozważyć rozbudowę serwera na bazie frameworku Rails, którego
użyliśmy w projekcie internetowego włącznika światła, o mechanizm prze-
syłania poleceń w formie sygnałów światła podczerwonego za pośrednic-
twem portu szeregowego połączonego z płytką Arduino, do której z kolei
podłączono podczerwoną diodę LED3. Podczas budowy systemu przesyła-
nia sygnałów za pośrednictwem światła podczerwonego warto skorzystać
z zaleceń Maika Schmidta opublikowanych w książce Arduino: A Quick
Start Guide [Sch11]. Podczerwone diody LED należy zainstalować
w przedniej części wszystkich sterowanych w ten sposób urządzeń systemu
rozrywki, czyli na przykład telewizorów i wzmacniaczy audio. Należy też
opracować przyjazny interfejs użytkownika aplikacji klienckiej systemu
iOS lub Android bądź połączyć interfejs użytkownika tego projektu z inter-
fejsem programu klienckiego któregoś z wcześniejszych projektów (na przy-
kład z interfejsem aplikacji otwierającej drzwi z poziomu systemu Android).

3
http://www.adafruit.com/products/387

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
270  12.6. Sterowanie nawadnianiem za pomocą czujnika wilgotności

12.5. Wyłącznik urządzeń domowych


na czas snu
Czy któremuś z członków rodziny zdarza się zasnąć podczas oglądania tele-
wizji? Zapominasz wyłączyć na noc prądożerny, czterordzeniowy komputer?
A może ktoś zapomniał zgasić światło w piwnicy? Jeśli tak, warto napisać
skrypt, który wyłączy światła, urządzenia i komputery w czasie, gdy wszy-
scy domownicy powinni spać. Jeśli komputer obsługuje standard Wake-On-
LAN (WOL), wystarczy utworzyć skrypt wysyłający pakiet z żądaniem
zakończenia pracy. Światła można zgasić za pomocą odpowiednich poleceń
narzędzia heyu i przełączników X10. Telewizory i systemy stereo można
wyłączyć przy użyciu pilota do systemu domowej rozrywki. Do wyłączania
wszystkich pozostałych urządzeń można użyć przełącznika przekaźnikowego
PowerSwitch Tail. System pozwoli zaoszczędzić trochę pieniędzy, ogra-
niczyć emisję dwutlenku węgla i ochronić planetę w czasie naszego snu.

12.6. Sterowanie nawadnianiem


za pomocą czujnika wilgotności
Warto podłączyć do płytki Arduino czujnik temperatury i wilgotności
DHT22 oraz silnik krokowy sterujący kranem doprowadzającym wodę do
węża ogrodowego, który z kolei zasila zraszacze trawnika4. Po wykryciu wy-
sokiej temperatury i niskiej wilgotności utrzymującej się przez określony czas
system powinien otworzyć zawór kranu zasilającego wąż ogrodowy i dalej
zraszacze. Po dziesięciu minutach system powinien ponownie odciąć do-
pływ wody do zraszaczy. Na podstawie czasu podlewania można obliczyć
objętość zużytej wody. W tym celu należy najpierw obliczyć liczbę sekund
potrzebnych do napełnienia litrowego zbiornika po otwarciu zaworu przez
silnik krokowy.
Jeśli na przykład wypełnienie zbiornika zajmuje trzydzieści sekund, mo-
żemy przyjąć, że w każdym cyklu zraszacze pracujące przez dziesięć minut
zużyją dwadzieścia litrów (dwa litry na minutę razy dziesięć minut). Warto
rejestrować dane o ilości zużytej wody za pomocą modułu komunikacji
bezprzewodowej XBee i komputera PC (na przykład w formie z rozdziału
5. zatytułowanego „Ćwierkający karmnik dla ptaków”), aby po miesiącu

4
https://www.adafruit.com/products/385

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 12. • Więcej pomysłów na projekty  271

ocenić, jaki procent wody zużywamy na podlewanie trawnika. Po skalibro-


waniu tych wartości możemy obliczać koszty zraszania trawnika w czasie
rzeczywistym, aby na bieżąco obserwować odpływ pieniędzy przez otwarty
kurek.

12.7. Czujniki dymu przystosowane


do komunikacji sieciowej
Czujniki dymu nie tylko ratują życie, ale też pomagają minimalizować straty
materialne. Takie czujniki są jednak nieskuteczne, jeśli nikt nie słyszy alar-
mu (jeśli na przykład nikogo nie ma w domu). Czytelnicy dysponujący od-
powiednią wiedzą mogą podłączyć przewody bezpośrednio do elektroniki
czujnika, aby mierzyć zmiany napięcia w momencie uruchomienia alarmu.
Warto jednak pamiętać, że taka ingerencja w urządzenie najprawdopodob-
niej naruszy warunki gwarancji czujnika. Co więcej, nieprawidłowo prze-
prowadzone zmiany mogą narażać na ryzyko życie i zdrowie osób, których
bezpieczeństwo zależy od prawidłowego działania tego czujnika. Zamiast
przylutowywać przewody bezpośrednio do płytki elektronicznej czujnika
dymu warto kupić układ mikrofonowy Electret, po czym wykorzystać do-
świadczenie w komunikacji systemu Arduino i modułów XBee do połą-
czenia elementów projektu, kalibracji wartości progowych i monitorowania
danych wejściowych mikrofonu pod kątem poziomu głośności powodowa-
nego przez alarm5. W momencie wykrycia alarmu komputer PC, który
otrzyma odpowiedni komunikat za pośrednictwem modułu XBee, powinien
wygenerować i wysłać wiadomość poczty elektronicznej alarmującą właści-
ciela domu. Można by nawet zmodyfikować aplikację serwera dla systemu
Android (patrz rozdział 9. zatytułowany „Zamek do drzwi sterowany
przez Androida”), aby system robił zdjęcie obszaru monitorowanego przez
czujnik dymu i dołączał fotografię do wysyłanego komunikatu.
Komunikat alarmowy może powodować dodatkowe działania, na przykład
automatyczne dzwonienie do sąsiadów i odtwarzanie przygotowanej wia-
domości z prośbą o sprawdzenie, czy w naszym domu nie wybuchł pożar
(na wypadek, gdybyśmy nie otrzymali lub nie mogli przeczytać wiadomości
poczty elektronicznej). Konstruktorzy absolutnie pewni niezawodności tego
systemu mogą zaimplementować system automatycznego wzywania straży
pożarnej, jeśli alarm nie zostanie zdezaktywowany w określonym czasie

5
http://www.sparkfun.com/products/9964

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
272  12.9. Inteligentny sterownik klimatyzacji i wentylacji

(musimy jednak mieć na uwadze, że nieuzasadnione wzywanie służb ratow-


niczych może się wiązać z poważnymi kosztami, ponieważ fałszywe alarmy
zwykle są surowo karane). Niezależnie od zastosowanych rozszerzeń naj-
ważniejszą zaletą tego projektu jest możliwość alarmowania praktycznie
całego świata o wykrytym niebezpieczeństwie dzięki połączeniu zwykłego
czujnika z urządzeniami obsługującymi komunikację z internetem.

12.8. Zbliżeniowy mechanizm


otwierania bramy garażowej
Kiedy zbliżamy się ze smartfonem wyposażonym w moduł GPS do naszego
garażu, telefon wysyła żądanie otwarcia bramy garażowej. Odpowiedni
sygnał trafia do płytki Arduino z modułem XBee podłączonej do radiowe-
go pilota napędu bramy garażowej, który z kolei wysyła sygnał do właści-
wego urządzenia podnoszącego bramę.
Otwieranie drzwi garażowych za pomocą smartfonów z systemami An-
droid i iOS jest możliwe także bez odwołań do pozycji GPS — rozwiązania
tego typu należą do najpopularniejszych projektów „zrób to sam” (wiele
filmów prezentujących realizację tej koncepcji opublikowano w serwisie
YouTube). Ponieważ garaż jest statyczną konstrukcją, wartości określające
wysokość i szerokość geograficzną oraz położenie względem poziomu morza
pozostają stałe. Implementacja mechanizmu otwierania i zamykania bramy
garażowej na podstawie położenia smartfonu nie powinna nam sprawić duże-
go problemu — wystarczy rozszerzenie serwera na bazie frameworku Rails
z rozdziału 7. zatytułowanego „Internetowy włącznik światła”.

12.9. Inteligentny sterownik


klimatyzacji i wentylacji
Klimatyzacją i ogrzewaniem domu można sterować za pomocą nieporów-
nanie bardziej inteligentnego systemu niż tradycyjne sterowniki. Możemy
na przykład zwiększać i zmniejszać ustawienia termostatu na podstawie
bieżącej godziny lub według poleceń wysyłanych za pośrednictwem zdalne-
go urządzenia. Ben Heckendorn, prowadzący program The Ben Heck
Show, nagrał kiedyś odcinek poświęcony takiemu projektowi6. Podoba mi

6
http://revision3.com/tbhs/homeauto

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Rozdział 12. • Więcej pomysłów na projekty  273

się sposób prezentacji projektu przez Bena, ponieważ nie zanudza widzów
szczegółami budowy samego termostatu. Co więcej, w projekcie zastosowa-
no części, których sami używaliśmy w rozdziale 8. zatytułowanym „Auto-
matyzacja działania zasłony”, zatem budowa i implementacja tego pro-
jektu nie powinny nam sprawić żadnego problemu.

12.10. Inteligentna skrzynka na listy


Także budowa inteligentnej skrzynki na listy należy do najbardziej popular-
nych projektów „zrób to sam”, na temat których napisano mnóstwo artykułów
i opublikowano w internecie mnóstwo zapisów wideo. Wystarczy ponownie
wykorzystać sprzęt, którego użyliśmy w rozdziale 5. zatytułowanym „Ćwier-
kający karmnik dla ptaków”, aby w momencie wykrycia przez fotokomórkę
światła docierającego do wnętrza skrzynki na listy opublikować wpis na
Twitterze lub wysłać wiadomość poczty elektronicznej. Warto też rozważyć
zastosowanie urządzenia z systemem Android i syntezatorem mowy (patrz
rozdział 10. zatytułowany „Dajmy przemówić naszemu domowi”), aby po
wykryciu listu system informował nas na głos: masz nową pocztę.

12.11. Inteligentne oświetlenie


Projekt opisany w rozdziale 7. zatytułowanym „Internetowy włącznik świa-
tła” warto rozbudować do postaci systemu zarządzającego oświetleniem
w całym domu. Do aktywowania i dezaktywowania światła w piwnicy, ła-
zience i sypialni można z powodzeniem używać czujników ruchu. Zdarze-
nia włączania i wyłączania świateł warto rejestrować, aby następnie zestawić
czas oświetlania poszczególnych pomieszczeń z miesięcznym rachunkiem
za energię elektryczną.

12.12. Monitorowanie źródeł energii


zasilanych promieniami
słonecznymi i wiatrem
12.12. Monitorowanie źródeł energii

Szczęśliwcy, którzy dysponują solarnymi lub wiatrowymi kolektorami ener-


gii pokrywającymi część zapotrzebowania na energię elektryczną, mogą wyko-
rzystać kombinację płytki Arduino, modułu XBee i komputera PC do

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
274  12.12. Monitorowanie źródeł energii

mierzenia zarówno energii generowanej przez te urządzenia, jak i stanu


naładowania akumulatorów gromadzących energię ze źródeł odnawialnych.
Tak skonstruowany system może na przykład wysyłać wiadomości poczty
elektronicznej z powiadomieniami o niskim stanie naładowania akumulato-
rów. Rejestrowanie dostępnych danych w dłuższym okresie pozwoli lepiej
zrozumieć różnice dzielące poszczególne miesiące i tym samym skuteczniej
przewidywać efektywność poszczególnych źródeł energii.
Czytelników, którym uda się zrealizować te i inne projekty automatyzacji
domu, zachęcam do dzielenia się swoimi doświadczeniami i osiągnięciami
z pozostałymi czytelnikami — jednym z miejsc, w których można opisywać
swoje pomysły, odkrycia i stworzone konstrukcje, jest forum tej książki. Do
zobaczenia na forum!

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Dodatki

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497
0e6f6f1d43742eedec5157bda515121f
0
Dodatek A
Instalacja bibliotek
platformy Arduino

J
edną z największych zalet rodziny produktów Arduino jest zastosowa-
nie otwartej platformy sprzętowej. Oznacza to, że każdy może uczestni-
czyć w procesie tworzenia i rozwijania bibliotek sprzętowych i pro-
gramowych dla tej platformy. Takie biblioteki można następnie łatwo dołą-
czać do szkiców platformy Arduino, aby albo rozszerzyć oferowane przez
nią funkcje i mechanizmy, albo (tak jest w większości przypadków) ułatwić
samemu sobie pisanie szkiców.
Rozwiązania opracowane przez społeczność użytkowników tej platformy
zostały wykorzystane w wielu projektach opisanych w tej książce. Okazuje
się jednak, że instalacja nowych bibliotek platformy Arduino nie jest auto-
matyczna i nie sprowadza się do uruchomienia skryptu instalacyjnego.
Pliki bibliotek, które często są udostępniane w formie skompresowanych
archiwów .zip, należy rozpakować i umieścić w folderze libraries środowiska
programowania Arduino IDE. Położenie tego folderu zależy od systemu
operacyjnego, w którym uruchamiamy środowisko Arduino IDE.

A.1.1. System Apple OS X


1. Należy znaleźć ikonę platformy Arduino (zwykle znajduje się
w głównym folderze /Applications).

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
278  Inteligentny dom

2. Ikonę tej platformy należy kliknąć, przytrzymując wciśnięty klawisz


Ctrl. Na ekranie zostanie wyświetlone menu kontekstowe.
3. Z wyświetlonego menu należy wybrać opcję Pokaż zawartość pa-
kietu (Show Package Contents). Opcja spowoduje otwarcie folderu
zawierającego zasoby danej aplikacji platformy Arduino.
4. Należy teraz przejść do folderu Contents/Resources/Java/libraries.
5. Właśnie do folderu libraries należy skopiować pliki nowej biblioteki.
Pliki biblioteki można też umieścić w folderze Documents/Arduino/libraries
w katalogu domowym użytkownika.

A.1.2. System Linux


1. Należy określić miejsce przechowywania rozpakowanych plików
aplikacji platformy Arduino.
2. Należy przejść do folderu libraries.
3. Do folderu libraries należy skopiować pliki nowej biblioteki.

A.1.3. System Windows


1. Należy określić miejsce przechowywania rozpakowanych plików
aplikacji platformy Arduino.
2. Należy przejść do folderu libraries.
3. Do folderu libraries należy skopiować pliki nowej biblioteki.
Po skopiowaniu plików biblioteki do odpowiedniego katalogu należy po-
nownie uruchomić środowisko Arduino IDE, tak aby można było odwoływać
się do nowej biblioteki w kodzie szkiców.
Aby zainstalować na przykład bibliotekę CapSense na potrzeby projektu ćwier-
kającego karmnika dla ptaków na komputerze z systemem Mac OS X firmy
Apple, należy najpierw rozpakować plik CapSense.zip. Wypakowany folder
CapSense należy następnie umieścić w folderze /Applications/Arduino/Contents/
Resources/Java/libraries. Należy teraz ponownie uruchomić środowisko Ar-
duino IDE, a następnie utworzyć nowy szkic platformy Arduino. W oknie
środowiska Arduino IDE należy wpisać następujący kod tego szkicu:

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Dodatek A • Instalacja bibliotek platformy Arduino  279

#include <CapSense.h>;
void setup() {}
void loop() {}

Należy kliknąć przycisk Verify dostępny na pasku narzędzi środowiska


Arduino IDE. Jeśli biblioteka CapSense została skopiowana we właściwe
miejsce, powyższy szkic powinien zostać skompilowany bez żadnych błędów.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
280  Inteligentny dom

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Dodatek B
Bibliografia

[Bur10] Ed Burnette, Hello, Android: Introducing Google’s Mobile


Development Platform, Third Edition, The Pragmatic
Bookshelf, Raleigh i Dallas, 2010.
[CADH09] David Chelimsky, Dave Astels, Zach Dennis, Aslak Hellesøy,
Bryan Helmkamp i Dan North, The RSpec Book,
The Pragmatic Bookshelf, Raleigh i Dallas, 2009.
[Fal10] Robert Faludi, Building Wireless Sensor Networks,
O’Reilly & Associates Inc., Sebastopol, 2010.
[LA03] Mark Lutz, Python. Wprowadzenie. Wydanie III,
Helion, Gliwice 2009.
[RC11] Ben Rady i Rod Coffin, Continuous Testing: with Ruby,
Rails, and JavaScript, The Pragmatic Bookshelf,
Raleigh i Dallas, 2011.
[Sch11] Maik Schmidt, Arduino: A Quick Start Guide,
The Pragmatic Bookshelf, Raleigh i Dallas, 2011.
[TFH09] David Thomas, Chad Fowler i Andrew Hunt,
Programowanie w języku Ruby. Wydanie II,
Helion, Gliwice, 2006.

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
282  Inteligentny dom

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Skorowidz

A aplikacja kliencka, 220


połączenia, 198
ADK, 41, 195, 257 serwer WWW, 207
IOIO, 41 sterowanie, 202
adres IP, Patrz IP Development Tools Eclipse, 164
aktywacja dwucewkowa, 180 Eclipse, 163
Android, 27, 40, 162 intencja, 208
ADK, 41, 257 interfejs API, 258
Google@Home, 258 IOIO, 41
Android@Home, 40, 257 kod serwera, 207
ADK, 195 konfiguracja urządzenia, 210
aparat, 214 okno dialogowe nowego projektu,
konfiguracja, 214 164
podgląd zdjęcia, 214
Open Accessory Development Kit,
aplikacja kliencka, 220
Patrz ADK
kod, 221
SDK, 41, 163
konfiguracja, 222
serwer WWW, 211
testowanie, 224
testowanie, 219
uprawnienia dostępu, 224
tworzenie, 211
zabezpieczenia, 221
statyczny adres IP, 209
AVD, 163
testowanie, 211
bezprzewodowe otwieranie drzwi,
tryb diagnostyczny, 206
195

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
284  Inteligentny dom

Android Nano, 95, 97


uprawnienia dostępu, 218 silnik krokowy, 173
wiadomości e-mail, 216 łączenie, 188
dołączanie grafiki, 216 szkic, 42
X10, 167 struktura, 42
AppleScript, 240 TDD, 33
Editor, 240 Uno Ethernet, 54
syntezator mowy, 242 wiadomości e-mail, 64
testowanie, 249 hosting, 64
Arduino, 31, 33, 37, 42 serwer poczty SMTP, 64
1.0, 256 wirtualny emulator, 43
ATMega 168/328, 42 wysyłanie komunikatu, 70
biblioteki, 277 XBee, 43, 106, 130
instalacja, 277 zabezpieczanie powiadomień, 66
czujnik nacisku, 130 zasilanie, 122
czujnik pojemnościowy, 99, 100 Audacity, 84
czujnik ugięcia, 53 automatyzacja domu, 25, 260
łączenie, 55 „zrób to sam”, 27
Ethernet, 54 analiza inwestycji, 28
fotokomórka, 103 Android, 27
Fritzing, 31 protokół komunikacji, 26
IDE, 57, 69, 257 standaryzacja, 26
Adapter USB, 155 TCP/IP, 27
LED Blink, 57 wysyłania impulsów, 26
Linux, 69 warsztat, 30
Serial Monitor, 62 automatyczna zasłona, 173
Upload, 62 budowa rozwiązania, 177
Verify, 62 części systemu, 175
Inkscape, 31 czujnik temperatury, 181
Integrated Development wartość progowa, 186
Environment, Patrz IDE czujniki, 176
konfiguracja, 57 dołączanie, 181
mechanizm przesyłania poleceń, 269 instalacji, 187
moduł fotokomórka, 177
dźwiękowy, 82 wartość progowa, 185
MP3, 81 instalacja sprzętu, 187
sieciowy, 67 lista komponentów, 174

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Skorowidz  285

schemat połączeń, 182 serwer WWW, 207


silnik krokowy testowanie, 219
instalacja, 188 testowanie systemu, 225
kalibracja, 188 biblioteka
programowanie, 179 AF_Wave, 85
sposób łączenia, 179 AFMotor, 177, 179
szkic, 180, 182 android.net.wifi.WifiManager, 223
testowanie, 186 android.widget.Button, 223
wygląd systemu, 189 Arduino Ethernet, 67
CairoPlot, 124
B Capacitive Sensing, 100
datetime, 120
baza danych, 114 Ethernet, 70
Debian, 114 interfejsu SPI, 67
packagedelivery, 135 IOIOLib, 202
deliverystatus, 136 java.io.InputStream, 165, 223
tracking, 136 java.net.URL, 165, 223
SQLite, 114, 134 MediaPlayer, 85, 86
sqlite3, 114, 135 os, 142
tweetingbirdfeeder, 115 packagetrack, 137, 142
birdfeeding, 115 Pyserial, 114, 118
seedstatus, 115 Python-Twitter, 114, 118
tworzenie, 114 serial, 120, 142
bezprzewodowe otwieranie drzwi, 194 Servo, 86
Android, 195 ServoTimer2, 86
aplikacja kliencka, 220 smtplib, 142
połączenia, 198 sqlite, 120
serwer WWW, 207 sqlite3, 142
budowa rozwiązania, 197 suds, 138
IOIO, 195 sys, 142
instalacja systemu, 226 time, 142
lista komponentów, 195 twitter, 120
PowerSwitch Tail II, 194 wavehc, 85
przełącznik przekaźnikowy, 194 Bluetooth, 232, 234
rozbudowa, 226 nawiązywanie połączenia, 233
Perfect Paper Passwords, 227
schemat połączeń, 201

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
286  Inteligentny dom

C elektryczny pies stróżujący, 77, 81


budowa rozwiązania, 80
czujnik lista elementów, 79
dymu, 271 montaż, 90
nacisku, 126 PIR, 82
Arduino, 130 próbki dźwięków, 83
łączenie, 130 rozbudowa, 91
odległości, 268 schemat połączeń, 82
pojemnościowy, 99 szkic, 85
Arduino, 99 testowanie, 89
budowa, 99
sposób podłączenia, 99 F
zastosowania, 123
ruchu, 269 fotokomórka, 102, 177
temperatury, 181 Adruino, 103
wartość progowa, 186 schemat połączeń, 103
ugięcia, 53 silnik krokowy, 181
Arduino, 53 wartość bazowa, 105
montowanie, 72 wartość progowa, 185
próg generowania zdarzenia, 58 zastosowania, 123
rozbudowa, 74 fotowoltaniczny system zasilania, 122
szkic, 58 Freemind, 31
tolerancja, 58 Fritzing, 31
wiadomość e-mail, 64
wykorzystanie, 74 G
wilgotności, 270
Gmail, 135
Google@Home, 258
D
DIY, 40 H
Django, 65
Heyu, 150
kod źródłowy, 156
E x10.conf, 156
Eclipse, 163 Hyperterminal, 107
Electric Sheep, 199
Elektor Electronic Toolbox, 32

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Skorowidz  287

I czujnik pojemnościowy, 98
budowa, 99
iCircuit, 32 programowanie, 99
IDE, 42, 57, 69, 257 fotokomórka, 102
Inkscape, 31 konfiguracja bazy danych, 114
internetowy włącznik światła, 149 lista komponentów, 95
Android, 162 nasłuchiwanie komunikatów, 119
testowanie, 167 publikowanie wpisów, 113
bieżący stan światła, 162 schemat połączeń, 108
budowa rozwiązania, 153 szkic, 109
kod klienta, 158, 162 Twitter, 94
testowanie, 161, 167 XBee, 95
lista komponentów, 151 zabezpieczenie urządzeń, 121
łączenie, 154 zasilanie, 122
rozbudowa, 170 fotowoltaniczne, 122
Ruby on Rails, 158 klucz
X10, 150 API, 118
CM11A, 155 konsumenta standardu OAuth,
IOIO, 195, 199 118
ADK, 41 tajnego tokenu dostępu, 118
IOIOLib, 202 tajny konsumenta, 118
schemat połączeń, 201 kompilator, 156
serwer WWW, 212 komunikacja bezprzewodowa, 106
IP, 68, 209 Bluetooth, 234
przypisanie stałego adresu, 68 Wi-Fi, 106
iPad, 32 XBee, 43, 106
Elektor Electronic Toolbox, 32 krok, 178
iCircuit, 32
iThoughts HD, 32 M
miniDraw, 32
MAC, 68
K metodyka wytwarzania sterowanego
testami, Patrz TTD
karmnik dla ptaków, 93 Minicom, 107
Arduino Nano, 95, 97 miniDraw, 32
budowa rozwiązania, 98
części systemu, 96

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
288  Inteligentny dom

moduł monitorowanie, 85
dźwiękowy, 78 zasada działania, 84
AF_Wave, 85 płytki mikrokontrolerów, 37
Arduino, 82 Arduino, 37
łączenie, 82 pojemność elektryczna, 99
próbki dźwięków, 83 PowerSwitch Tail II, 194
szkic demonstracyjny, 85 powiadamianie o zdarzeniach, 230
zarządzanie odtwarzaniem, 86 konfiguracja głośników, 231
parowanie, 44 Bluetooth, 232
sieciowy, 67, 70 nawiązywanie połączenia, 233
Arduino, 67 lista komponentów, 231
kodowanie, 67 mechanizm rozpoznawania mowy,
przypisanie adresu, 68 234
stały adres IP, 68 konfiguracja, 234
multimetr, 34 włączanie mówionych
komunikatów, 235
O wybór głosu, 237
rozbudowa, 250
open source, 31 syntezator mowy, 237, 240
Freemind, 31 kod, 242
Fritzing, 31 testowanie, 249
Heyu, 150 TTS, 230
Inkscape, 31 wewnętrzny mikrofon, 238
kalibracja, 239
P protokół komunikacji, 26
parowanie modułów, 44 SOAP, 138
pasywny czujnik ruchu na standaryzacja, 26
podczerwień, Patrz PIR TCP/IP, 27
Perfect Paper Passwords, 227 wysyłania impulsów, 26
PHP, 64, 65 przełącznik przekaźnikowy, 194
hosting, 64 Python, 33, 45
mail, 66 easy_install, 118
wiadomości e-mail, 65 identyfikacja XBee, 143
pin, Patrz wtyk implementacja dostarczania paczek,
PIR, 77 139
instalacja, 90 testowanie skryptu, 144
łączenie, 82

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Skorowidz  289

implementacja procesów karmnika, Android, 211


113, 119 IOIO, 212
nasłuchiwanie komunikatów, 119 testowanie, 219
os, 142 serwomotor, 78
packagetrack, 137, 142 moment obrotowy, 91
przetwarzanie komunikatów, 134 sterowanie, 86
publikowanie wpisów, 113 silnik krokowy, 173
Pyserial, 114, 118 aktywacja dwucewkowa, 180
python-fedex, 138 Arduino, 173
Python-Twitter, 114, 118 łączenie, 188
serial, 142 fotokomórka, 181
smtplib, 142 kalibracja, 188
SQLite, 114 koło pasowe, 176
sqlite3, 142 instalacja, 188
suds, 138 krok, 178
sys, 142 liczba obrotów, 189
testy jednostkowe, 33 moduł silnika, 190
time, 142 programowanie, 179
sposób łączenia, 179
R zasada działania, 178
zastosowania, 190
realizacja projektów, 37 Simple Object Access Protocol,
Android, 40 Patrz protokół SOAP
Arduino, 42 Siri, 259
bezpieczeństwo, 47 SQLite, 114
elementy elektroniczne, 39 Manager, 116
oprogramowanie, 38, 45 Browse and Search, 121
urządzenia wykonawcze, 38 sqlite3, 114, 135
XBee, 43 standard uwierzytelniania OAuth,
Ruby on Rails, 33, 65, 158 117
konfiguracja, 161 system powiadamiania o poziomie
RSpec, 33 wody, 51
Arduino, 55
S konfiguracja, 57
screen, 107, 134 budowa rozwiązania, 55
Serial Monitor, 62 czujnik ugięcia, 53, 55
serwer WWW, 207 diagram połączeń, 56

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
290  Inteligentny dom

system powiadamiania o poziomie wody testowanie, 63


lista komponentów, 53 tolerancja, 58
łączenie, 55, 71 uruchamianie, 62
moduł sieciowy, 67 wiadomości e-mail, 64
kodowanie, 67 hosting, 64
łączenie, 67 serwer poczty SMTP, 64
rozbudowa, 74
spławik, 56 T
szkic, 56
TDD, 33
testowanie, 63, 71
testy jednostkowe, 33
tworzenie, 58
py.test, 33
uruchamianie, 62
token dostępu, 118
wiadomości e-mail, 64
TTS, 230
szkic, 42, 56 Twitter, 93
#include, 42 dane uwierzytelniające, 117
automatyczna zasłona, 182 klucze, 118
testowanie, 186 nowe konto, 117
czujnik nacisku, 131, 132 publikacja wpisu, 117
testowanie, 133 Python, 113
wartość progowa, 134
czujnik pojemnościowy, 100 U
dołączanie bibliotek, 68
fotokomórka, 103 urządzenia wykonawcze, 38
IDE, 42
moduł sieciowy, 67 V
testowanie, 71
VPS, 65
wysyłanie komunikatu, 70
monitorowanie czujnika PIR, 85
główna pętla, 87
W
testowanie, 89 warsztat, 30
silnik krokowy, 180 pomieszczenie, 30
struktura, 42 wyposażenie, 30
ugięcie czujnika, 58 wiadomości e-mail, 64
konfiguracja portu szeregowego, Arduino, 64
59 czujnik ugięcia, 64
próg generowania zdarzenia, 58 PHP, 64, 65
serwer poczty SMTP, 64

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
Skorowidz  291

wirtualne serwery prywatne, monitorowanie komunikacji, 157


Patrz VPE podłączanie, 154
wtyk, 42 Firecracker, 152
wykrywacz dostarczania paczek, 125, Heyu, 150
131 moduł sterownika, 152
budowa rozwiązania, 128 problemy, 158
części systemu, 127 protokół, 158
czujnik nacisku, 126 zasada działania, 153
instalacja systemu, 145 x10.conf, 156
lista komponentów, 127 XBee, 43
łączenie sprzętu, 129 Arduino, 43, 106, 130
rozbudowa, 146 komunikacja radiowa, 43
schemat połączeń, 130 możliwości, 106
testowanie skryptu, 144 nadajnik radiowy, 95
testowanie szkicu, 133 parowanie modułów, 44
schemat łączenia, 106
X
X10, 150
AM486 Appliance, 157
Android, 167
CM11A, 152, 155
adapter USB, 154
Arduino, 154
interfejs, 154

ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497


0e6f6f1d43742eedec5157bda515121f
0
ebookpoint kopia dla: Krzysztof Podwysocki blakusername@gmail.com G0105202497
0e6f6f1d43742eedec5157bda515121f
0

You might also like