Poznaj możliwości platformy Arduino!

Arduino to niesamowita platforma, która otworzyła świat elektroniki przed wszystkimi. Dzięki niej możesz zbudować zaawansowany układ elektroniczny bez konieczności wykonywania czasochłonnych projektów i żmudnych obliczeń. Arduino błyskawicznie zyskało ogromną popularność, a w ślad za nią pojawiły się w sprzedaży liczne dodatkowe moduły. Pozwalają one zbudować dowolne urządzenie — ogranicza Cię tylko Twoja wyobraźnia!

Ta wyjątkowa książka została w całości poświęcona platformie Arduino. Znajdziesz tu szczegółowe omówienie możliwości platformy, liczne przykłady oraz opisy. W trakcie lektury dowiesz się, jak przygotować środowisko pracy, oraz rozpoczniesz tworzenie prostych projektów, korzystających z cyfrowych portów wejścia-wyjścia. W kolejnych rozdziałach poznasz coraz bardziej zaawansowane możliwości Arduino.

Wykorzystasz silniki prądu stałego i serwomechanizmy, zastosujesz czujniki ultradźwiękowe oraz wyświetlisz informacje na wyświetlaczu LCD. Ponadto przekonasz się, że można zintegrować Arduino z systemem iOS oraz innym oprogramowaniem. Książka ta jest doskonałą lekturą dla wszystkich pasjonatów elektroniki.

Dzięki tej książce:
• poznasz tajniki platformy Arduino
• wykorzystasz czujniki oraz silniki
• skomunikujesz się z układem za pomocą sieci
• odkryjesz dla siebie potencjał drzemiący w tej platformie!

Twoja przepustka do świata elektroniki.

Spis treści:

CZĘŚĆ I. ZACZYNAMY (19)

Rozdział 1. Witaj, Arduino (21)

• 1.1. Krótka historia Arduino (22)
• 1.2. Arduino (23)
  • 1.2.1. Arduino Uno (23)
  • 1.2.2. Arduino Duemilanove (24)
  • 1.2.3. Arduino Ethernet (24)
  • 1.2.4. Arduino Mega (25)
  • 1.2.5. Inne wersje Arduino (25)
  • 1.2.6. Atak klonów (27)
  • 1.2.7. Zaczynamy pracę z Arduino (28)
• 1.3. Przygotowywanie środowiska pracy (28)
  • 1.3.1. Oprogramowanie dla Arduino (28)
  • 1.3.2. Podstawowa konfiguracja sprzętu (29)
  • 1.3.3. Twój niezbędnik Arduino (29)
• 1.4. Niech coś się wydarzy! (30)
  • 1.4.1. Twoja pierwsza migająca dioda świecąca (30)
  • 1.4.2. Szkic błyskający diodą świecącą (30)
  • 1.4.3. Łączymy wszystko razem (31)
  • 1.4.4. Ładowanie i testowanie programu (32)
• 1.5. Poznajemy zintegrowane środowisko programistyczne (33)
  • 1.5.1. Edytor kodu (34)
  • 1.5.2. Monitor portu szeregowego (34)
  • 1.5.3. Wyłapywanie błędów (36)
  • 1.5.4. Przetwarzanie kodu (36)
• 1.6. Budowa szkicu (37)
  • 1.6.1. Procedura "setup" (37)
  • 1.6.2. Nieskończona pętla (37)
• 1.7. Komentowanie kodu (38)
• 1.8. Podsumowanie (39)

Rozdział 2. Cyfrowe wejścia i wyjścia (41)

• 2.1. Zaczynamy (41)
  • 2.1.1. Wykorzystanie płytki stykowej (42)
  • 2.1.2. Schemat obwodu (42)
  • 2.1.3. Diody świecące (44)
  • 2.1.4. Połączenia (44)
  • 2.1.5. Szkic błyskający pięcioma diodami (44)
  • 2.1.6. Załadowanie i test (47)
• 2.2. Przejęcie kontroli (47)
  • 2.2.1. Schemat obwodu (47)
  • 2.2.2. Połączenia (47)
  • 2.2.3. Wtrącające się przerwania (49)
  • 2.2.4. Szkic pozwalający kontrolować diody przy pomocy przycisku (49)
  • 2.2.5. Załadowanie i test (52)
  • 2.2.6. Czas na przerwę (52)
  • 2.2.7. Załadowanie i test (53)
• 2.3. Miernik refleksu (53)
  • 2.3.1. Schemat obwodu (53)
  • 2.3.2. Połączenia (53)
  • 2.3.3. Szkic do pomiaru refleksu (53)
  • 2.3.4. Załadowanie i test (56)
• 2.4. Miernik refleksu - kto naprawdę jest najszybszy? (56)
  • 2.4.1. Szkic do pomiaru refleksu (57)
  • 2.4.2. Załadowanie i test (58)
• 2.5. Podsumowanie (58)

Rozdział 3. Proste projekty: wejście i wyjście (61)

• 3.1. Pora na świat analogowy (62)
  • 3.1.1. Jaka jest różnica pomiędzy sygnałem analogowym i cyfrowym? (62)
  • 3.1.2. Odczyt sygnału z potencjometru (63)
  • 3.1.3. Podłączanie elementów (64)
  • 3.1.4. Szkic do odczytu ustawienia potencjometru (64)
  • 3.1.5. Załadowanie i test (66)
• 3.2. Przetwornik piezoelektryczny (67)
  • 3.2.1. Schemat obwodu (68)
  • 3.2.2. Połączenia (69)
  • 3.2.3. Szkic pozwalający mierzyć impulsy pochodzące z przetwornika piezoelektrycznego (70)
  • 3.2.4. Załadowanie i test (72)
  • 3.2.5. Obwód z dodanym głośniczkiem (72)
  • 3.2.6. Połączenia (72)
  • 3.2.7. Szkic generujący dźwięk (74)
  • 3.2.8. Załadowanie i test (74)
• 3.3. Budowa pentatonicznej klawiatury muzycznej (75)
  • 3.3.1. Schemat obwodu (75)
  • 3.3.2. Połączenia (75)
  • 3.3.3. Szkic obsługujący klawiaturę pentatoniczną (77)
  • 3.3.4. Załadowanie i test (78)
• 3.4. Podsumowanie (79)

CZĘŚĆ II. ZAPRZĘGAMY ARDUINO DO PRACY (81)

Rozdział 4. Rozszerzanie Arduino (83)

• 4.1. Zwiększanie możliwości Arduino poprzez dodatkowe biblioteki programistyczne (84)
• 4.2. Biblioteka podstawowa (84)
• 4.3. Biblioteki standardowe (85)
  • 4.3.1. Projektowanie sterowane testami przy użyciu biblioteki ArduinoTestSuite (85)
  • 4.3.2. Zapisywanie wartości w pamięci EEPROM (86)
  • 4.3.3. Zapisywanie większych ilości danych na kartach SD (87)
  • 4.3.4. Podłączanie do sieci w standardzie Ethernet (89)
  • 4.3.5. Komunikacja szeregowa z użyciem protokołu Firmata (90)
  • 4.3.6. Wyświetlanie informacji przy użyciu biblioteki LiquidCrystal (91)
  • 4.3.7. Sterowanie serwomechanizmami (92)
  • 4.3.8. Sterowanie silnikiem krokowym (92)
  • 4.3.9. Komunikacja z urządzeniami na magistrali SPI (93)
  • 4.3.10. Komunikacja przy użyciu magistrali dwuprzewodowej (95)
  • 4.3.11. Uzyskiwanie większej liczby portów szeregowych przy pomocy biblioteki SoftwareSerial (95)
• 4.4. Biblioteki udostępnione przez użytkowników (98)
  • 4.4.1. Instalowanie nowej biblioteki (98)
• 4.5. Rozbudowa Arduino przy użyciu nakładek (99)
  • 4.5.1. Popularne nakładki (99)
  • 4.5.2. Pułapka: czy to będzie działać z moim Arduino? (102)
• 4.6. Podsumowanie (103)

Rozdział 5. Arduino w ruchu (105)

• 5.1. Nabieranie prędkości z silnikami prądu stałego (106)
  • 5.1.1. Uruchamianie i zatrzymywanie silnika (107)
  • 5.1.2. Szkic uruchamiający i zatrzymujący mały silnik prądu stałego (108)
  • 5.1.3. Łączenie komponentów (108)
  • 5.1.4. Załadowanie i test szkicu (110)
• 5.2. Sterowanie prędkością i obracanie silnika w przeciwnym kierunku (111)
  • 5.2.1. Modulacja PWM przybywa na ratunek (112)
  • 5.2.2. Mostek H do sterowania silnikiem (112)
  • 5.2.3. Układ L293D (114)
  • 5.2.4. Łączenie elementów (115)
  • 5.2.5. Szkic sterujący układem L293D (116)
  • 5.2.6. Załadowanie i test szkicu (117)
  • 5.2.7. Zmiana prędkości obrotów silnika (117)
  • 5.2.8. Załadowanie i test szkicu (118)
• 5.3. Silniki krokowe: jeden krok naraz (119)
  • 5.3.1. Silniki bipolarne i unipolarne (119)
  • 5.3.2. Łączenie komponentów (122)
  • 5.3.3. Funkcje biblioteki silnika krokowego (123)
  • 5.3.4. Szkic sterujący silnikiem krokowym (125)
  • 5.3.5. Załadowanie i test szkicu (126)
• 5.4. Serwomechanizmy nie są takie straszne (126)
  • 5.4.1. Sterowanie serwomechanizmem (126)
  • 5.4.2. Funkcje i metody sterujące serwomechanizmem (127)
  • 5.4.3. Szkic sterujący serwomechanizmem (128)
  • 5.4.4. Łączenie komponentów (129)
  • 5.4.5. Załadowanie i test szkicu (129)
• 5.5. Wielka siła małego silnika bezszczotkowego (130)
  • 5.5.1. Dlaczego bez szczotek (130)
  • 5.5.2. Sterowanie (131)
  • 5.5.3. Szkic sterujący silnikiem bezszczotkowym (132)
  • 5.5.4. Łączenie komponentów (134)
  • 5.5.5. Załadowanie i test szkicu (134)
  • 5.5.6. Obroty w przeciwnym kierunku (135)
  • 5.5.7. Szkic zmieniający kierunek obrotów silnika bezszczotkowego (135)
  • 5.5.8. Łączenie komponentów (136)
  • 5.5.9. Załadowanie i test szkicu (136)
• 5.6. Nakładka sterująca kilkoma silnikami (136)
• 5.7. Podsumowanie (137)

Rozdział 6. Wykrywanie przedmiotów (139)

• 6.1. Ultradźwiękowe wykrywanie przedmiotów (139)
  • 6.1.1. Wybór czujnika ultradźwiękowego (140)
  • 6.1.2. Trzy lub cztery przewody (141)
  • 6.1.3. Szkice do ultradźwiękowego wykrywania przedmiotów (142)
  • 6.1.4. Łączenie elementów (144)
  • 6.1.5. Załadowanie i test szkicu (145)
• 6.2. Pomiar odległości za pomocą podczerwieni (145)
  • 6.2.1. Łączenie czujników podczerwieni i ultradźwiękowego (146)
  • 6.2.2. Czujnik Sharp GP2D12 (146)
  • 6.2.3. Nieliniowy algorytm obliczania odległości (146)
  • 6.2.4. Szkic do pomiaru odległości (147)
  • 6.2.5. Łączenie elementów (149)
  • 6.2.6. Załadowanie i test szkicu (149)
• 6.3. Wykrywanie ruchu metodą pasywnej podczerwieni (149)
  • 6.3.1. Użycie czujnika Parallax (151)
  • 6.3.2. Szkic do wykrywania ruchu za pomocą podczerwieni (151)
  • 6.3.3. Łączenie elementów (152)
  • 6.3.4. Załadowanie i test szkicu (153)
• 6.4. Podsumowanie (154)

Rozdział 7. Wyświetlacze LCD (155)

• 7.1. Wprowadzenie do wyświetlaczy LCD (156)
  • 7.1.1. Ciągi znaków: zmienne typu String i char (156)
• 7.2. Równoległy wyświetlacz znakowy Hitachi HD44780 (158)
  • 7.2.1. Wyświetlacz 4-bitowy czy 8-bitowy? (159)
  • 7.2.2. Biblioteka i funkcje (159)
  • 7.2.3. Schemat układu (159)
  • 7.2.4. Łączenie komponentów w trybie 4-bitowym (160)
  • 7.2.5. Szkic sterujący wyświetlaczem Hitachi HD44780 (162)
  • 7.2.6. Załadowanie i test szkicu (163)
• 7.3. Stacja meteorologiczna z szeregowym wyświetlaczem LCD (164)
  • 7.3.1. Wyświetlacze szeregowe i równoległe (164)
  • 7.3.2. Biblioteka SerLCD i jej funkcje (165)
  • 7.3.3. Czujnik temperatury Maxim DS18B20 (166)
  • 7.3.4. Biblioteki OneWire i DallasTemperature (167)
  • 7.3.5. Schemat układu (167)
  • 7.3.6. Łączenie wszystkich komponentów (167)
  • 7.3.7. Szkic dla stacji meteorologicznej z wyświetlaczem LCD (169)
  • 7.3.8. Załadowanie i test szkicu (170)
• 7.4. Wyświetlacz graficzny Samsung KS0108 (171)
  • 7.4.1. Biblioteka i funkcje (171)
  • 7.4.2. Schemat połączeń (171)
  • 7.4.3. Łączenie wszystkich komponentów (172)
  • 7.4.4. Szkic do rysowania na wyświetlaczu graficznym (173)
  • 7.4.5. Załadowanie i test szkicu (175)
• 7.5. Podsumowanie (176)

Rozdział 8. Komunikacja (177)

• 8.1. Technologia Ethernet (178)
  • 8.1.1. Biblioteka Ethernet (179)
  • 8.1.2. Nakładka Ethernet z kartą SD (180)
• 8.2. Serwer WWW Arduino (181)
  • 8.2.1. Konfiguracja serwera (181)
  • 8.2.2. Szkic konfigurujący serwer WWW (182)
  • 8.2.3. Załadowanie i test szkicu (184)
  • 8.2.4. Usuwanie usterek (184)
• 8.3. Ćwir, ćwir - komunikacja z portalem Twitter (184)
  • 8.3.1. Twitter i tokeny (185)
  • 8.3.2. Biblioteki i funkcje (185)
  • 8.3.3. Schemat układu i połączenia komponentów (185)
  • 8.3.4. Szkic do wysyłania tweeta po naciśnięciu przycisku (186)
  • 8.3.5. Załadowanie i test szkicu (187)
• 8.4. Łączność Wi-Fi (188)
  • 8.4.1. Nakładka Arduino WiFi (189)
  • 8.4.2. Biblioteka WiFi i jej funkcje (190)
  • 8.4.3. Ruchy ciała i bezprzewodowe przyspieszeniomierze (192)
  • 8.4.4. Łączenie komponentów (192)
  • 8.4.5. Szkic do komunikacji Bluetooth (193)
  • 8.4.6. Załadowanie i test szkicu (196)
• 8.5. Bezprzewodowa łączność Bluetooth (196)
  • 8.5.1. Płyta ArduinoBT (196)
  • 8.5.2. Dodawanie modułu Bluetooth (198)
  • 8.5.3. Nawiązywanie połączenia Bluetooth (198)
  • 8.5.4. Szkic do komunikacji Bluetooth (199)
• 8.6. Interfejs SPI (200)
  • 8.6.1. Biblioteka SPI (200)
  • 8.6.2. Urządzenia SPI i potencjometry cyfrowe (201)
  • 8.6.3. Schemat układu i połączenia elementów (202)
  • 8.6.4. Szkic cyfrowego sterownika diod LED (203)
• 8.7. Rejestrowanie danych (204)
  • 8.7.1. Rodzaje pamięci (205)
  • 8.7.2. Karty SD i biblioteka SD (205)
  • 8.7.3. Szkic rejestrujący na karcie SD dane z czujnika (206)
• 8.8. Serwis Xively (207)
  • 8.8.1. Tworzenie konta i pobieranie klucza API (208)
  • 8.8.2. Tworzenie nowego kanału danych (208)
  • 8.8.3. Szkic do rejestrowania danych z czujnika w serwisie Xively (209)
  • 8.8.4. Załadowanie i test szkicu (211)
• 8.9. Podsumowanie (212)

Rozdział 9. Czas na gry (213)

• 9.1. Nintendo Wii pozdrawia Cię (213)
  • 9.1.1. Kontroler Wii Nunchuk (214)
  • 9.1.2. Połączenie z kontrolerem Nunchuk (216)
  • 9.1.3. Wii zaczyna mówić (218)
  • 9.1.4. Wii testuje (226)
• 9.2. Wejście konsoli Xbox na rynek (227)
  • 9.2.1. Połączenie (228)
  • 9.2.2. Biblioteka hosta USB (229)
  • 9.2.3. Pozyskiwanie informacji o kontrolerze Xbox za pomocą nakładki hosta USB (229)
  • 9.2.4. Obowiązek raportowania przez kontroler Xbox (231)
  • 9.2.5. Czas na uruchomienie (233)
  • 9.2.6. Łączenie za pomocą kodu (233)
  • 9.2.7. Szkic Xboxhid.ino (235)
  • 9.2.8. Łączenie i testowanie układów (239)
• 9.3. Podsumowanie (239)

Rozdział 10. Integracja Arduino z urządzeniami iOS (241)

• 10.1. Podłączanie urządzenia iOS do Arduino (243)
  • 10.1.1. Przewód szeregowy Redpark (243)
  • 10.1.2. Ostateczne połączenie (244)
• 10.2. Kod iOS (245)
  • 10.2.1. Tworzenie jednookienkowej aplikacji w środowisku Xcode (245)
  • 10.2.2. Tworzenie kodu (250)
• 10.3. Angażujemy Arduino (253)
  • 10.3.1. Szkic do sterowania diodą LED z urządzenia iOS (253)
  • 10.3.2. Testowanie szkicu (254)
• 10.4. Zróbmy coś więcej w Xcode (255)
  • 10.4.1. Dodawanie kontrolki Slider (255)
• 10.5. Obsługa suwaka w Arduino (259)
  • 10.5.1. Układ Arduino do obsługi suwaka (260)
  • 10.5.2. Testowanie układu (261)
• 10.6. Wysyłanie danych do urządzenia iOS (262)
  • 10.6.1. Kodowanie w środowisku Xcode (262)
  • 10.6.2. Podczerwony czujnik odległości GP2D12 (265)
  • 10.6.3. Test (267)
• 10.7. Podsumowanie (267)

Rozdział 11. Elektroniczne gadżety (269)

• 11.1. Wprowadzenie do płyty LilyPad (270)
  • 11.1.1. Akcesoria LilyPad (271)
  • 11.1.2. Przewodzące nici i tkaniny (272)
• 11.2. Kurtka z wyłącznikami (274)
• 11.3. Osobiste pianino (276)
• 11.4. Płyta Arduino Pro Mini (279)
• 11.5. Inteligentne słuchawki (280)
• 11.6. Kurtka z kompasem (282)
• 11.7. Podsumowanie (286)

Rozdział 12. Stosowanie nakładek (287)

• 12.1. Podstawowe informacje o nakładkach (287)
• 12.2. Nakładka silnikowa Adafruit (288)
  • 12.2.1. Biblioteka AFMotor (289)
  • 12.2.2. Zastosowanie nakładki z silnikiem krokowym (290)
  • 12.2.3. Zastosowanie nakładki z silnikiem prądu stałego (292)
  • 12.2.4. Zakup nakładki silnikowej (294)
• 12.3. Jak zbudować własną nakładkę (295)
  • 12.3.1. Pamięć (295)
  • 12.3.2. Przesuwniki poziomów (296)
  • 12.3.3. Uchwyt karty SD (296)
  • 12.3.4. Podłączanie karty SD do płyty Arduino (297)
  • 12.3.5. Przygotowywanie płyty perforowanej (299)
  • 12.3.6. Test nakładki (302)
• 12.4. Podsumowanie (303)

Rozdział 13. Integracja z oprogramowaniem (305)

• 13.1. Kanał komunikacji szeregowej (306)
• 13.2. Serwomechanizm śledzący twarz (307)
  • 13.2.1. Montaż mechanizmu śledzącego twarz (308)
  • 13.2.2. Kod do śledzenia twarzy (309)
• 13.3. Zastosowanie oprogramowania Firmata do budowy equalizera (313)
  • 13.3.1. Zastosowanie Firmata w Twojej aplikacji (314)
  • 13.3.2. Analiza dźwięku w środowisku Processing (315)
  • 13.3.3. Montaż elementów equalizera (315)
  • 13.3.4. Kod equalizera (316)
• 13.4. Zastosowanie Pure Data do budowy syntezatora (319)
  • 13.4.1. Montaż komponentów syntezatora (320)
  • 13.4.2. Kod syntezatora (320)
• 13.5. Zastosowanie języka Python do mierzenia temperatury (324)
  • 13.5.1. Biblioteka szeregowa w języku Python (324)
  • 13.5.2. Montaż komponentów termometru (325)
  • 13.5.3. Kod monitorujący temperaturę (326)
• 13.6. Podsumowanie (328)

Dodatek A. Instalacja środowiska Arduino IDE (329)

• A.1. Windows (329)
  • A.1.1. Instalacja sterowników do płyty Arduino (329)
• A.2. Mac OS X (332)
• A.3. Linux (333)

Dodatek B. Podręcznik kodowania (337)

• B.1. Historia języka Arduino (337)
• B.2. Zmienne (338)
  • B.2.1. Typy zmiennych (339)
  • B.2.2. Tabele (340)
  • B.2.3. Ciągi znaków (341)
  • B.2.4. Stałe (341)
  • B.2.5. Zasięg zmiennych (342)
• B.3. Przejęcie kontroli (343)
  • B.3.1. Instrukcje if, else, else if (344)
  • B.3.2. Instrukcja switch-case (346)
  • B.3.3. Operatory logiczne (347)
• B.4. Zapętlenie (348)
  • B.4.1. Pętla for (348)
  • B.4.2. Pętla while (349)
  • B.4.3. Pętla do while (350)
• B.5. Funkcje (350)
• B.6. Podsumowanie (351)

Dodatek C. Biblioteki (353)

• C.1. Anatomia biblioteki (353)
  • C.1.1. Plik .h (nagłówkowy) (353)
  • C.1.2. Plik .cpp (354)
• C.2. Użycie biblioteki (355)
  • C.2.1. Zastosowanie biblioteki w szkicu (355)
  • C.2.2. Rozpowszechnianie biblioteki (356)

Dodatek D. Lista komponentów (357)

Dodatek E. Przydatne odnośniki (361)