O autorach (11)

O korektorze merytorycznym (12)

Wprowadzenie (13)

Podziękowania (14)

Rozdział 1. Zmiany w rdzeniu Arduino 1.0.4 (15)

• Zmiany w środowisku programistycznym Arduino (15)
• Zmiany w szkicowniku (17)
• Aktualizacje interfejsu API (17)
  
  • Funkcja pinMode (17)
  • Zwracane typy danych (18)
  • Typ uint_8 (18)
• Rdzeń Arduino API Core 1.0.4 (18)
  
  • Biblioteka Arduino.h (18)
  • Ulepszony obiekt Serial (19)
  • Ulepszona klasa Stream (19)
  • Klasa Print (20)
  • Nowa klasa Printable (22)
  • Ulepszona biblioteka String (22)
  • Ulepszona biblioteka Wire (22)
  • Ulepszona biblioteka HardwareSerial (23)
• Ulepszenia płyt i kompatybilność USB (23)
  
  • Ulepszony program Avrdude (23)
  • Nowa płyta Arduino Leonardo (23)
  • Warianty płyt (25)
  • Opcje programów ładujących zmienione na programatory (27)
  • Nowe programy rozruchowe (27)
  • Oprogramowanie wbudowane USB dla układu 16u2 (27)
• Podsumowanie (28)

Rozdział 2. Programowanie Arduino i kodowanie społecznościowe (29)

• Elementy kodowania społecznościowego i zarządzania projektem (30)
  
  • Czym jest projekt i jak jest zorganizowany? (30)
  • Kontrola wersji (33)
  • Śledzenie spraw (33)
  • Dokumentacja (34)
• Zarządzanie projektem w kodowaniu społecznościowym (34)
  
  • Kontrola wersji w programach Git i GitHub (34)
  • Czym jest program Git? (34)
  • Instalacja programu Git (35)
  • Narzędzia GitHub (35)
• Podstawowa kontrola wersji (36)
  
  • Tworzenie własnego projektu (36)
  • Edycja kodu i sprawdzanie zmian (38)
  • Przebieg procesu (38)
  • Podsumowanie: utworzenie własnego projektu (40)
  • Podsumowanie: odgałęzienie innego projektu (41)
  • Tworzenie żądania zmian (43)
  • Jak uwzględniać żądania zmian (47)
  • Czym jest zarządzanie sprawami? (50)
  • Zarządzanie sprawami w systemie GitHub (50)
  • Połączenie kontroli wersji z zarządzaniem zmianami (51)
• Dokumentacja (52)
  
  • System GitHub wiki (52)
  • Tworzenie stron (52)
  • Składnia Markdown (54)
• Udostępnianie projektu społeczności Arduino (57)
  
  • Odgałęzienie projektu Arduino (57)
• Jak zbudować środowisko programistyczne Arduino (58)
• Zasoby społeczności (59)
• Podsumowanie (59)

Rozdział 3. Oprogramowanie openFrameworks a Arduino (61)

• Od czego zacząć (62)
• Kod Arduino (62)
  
  • Weryfikacja kodu (63)
  • Funkcje Arduino do transmisji szeregowej (63)
• Konfiguracja openFrameworks (64)
  
  • Połączenie z Arduino za pomocą openFrameworks (64)
  • Weryfikacja kodu (66)
  • Funkcje openFrameworks do transmisji szeregowej (67)
• Koduj raz dzięki Firmata i ofArduino (67)
  
  • Konfiguracja protokołu Firmata (68)
  • Sterowanie Arduino za pomocą openFrameworks (69)
  • Weryfikacja kodu (71)
  • Najważniejsze stałe wykorzystywane przez klasę ofArduino (71)
  • Lista funkcji klasy ofArduino (71)
• Rozwijanie pomysłu (72)
  
  • Zmiany w kodzie (73)
  • Weryfikacja kodu (74)
• Inne pomysły do zrealizowania (74)
• Podsumowanie (75)

Rozdział 4. Narzędzia Android ADK (77)

• Urządzenia z systemem Android (78)
• Co należy sprawdzić (78)
• Kompatybilne urządzenia (78)
• Modyfikacje (79)
• Konfiguracja środowiska Arduino IDE (79)
  
  • Tworzenie aplikacji w systemie Android (80)
  • Szkic Arduino (84)
  • Aplikacja Android ADK (85)
  • Plik src/CH4.example.proArduino/CH4ExamplesActivity.java (89)
• Uzupełnienie szkieletu kodu (94)
  
  • Uzupełnienie aplikacji (96)
  • Arduino (100)
  • Weryfikacja kodu (101)
• Interfejs SPI i protokół ADK (101)
• Podsumowanie (103)

Rozdział 5. Moduły radiowe XBee (105)

• Zakup modułów XBee (106)
• Prosty układ (107)
• Tryb transparentny (polecenia AT) (108)
  
  • Konfiguracja modułu (108)
  • Konfiguracja Arduino (109)
  • Weryfikacja kodu (109)
• Tryb API (110)
  
  • Konfiguracja modułu (110)
  • Konstrukcja pakietów API (111)
  • Wysyłanie poleceń (112)
  • Wysyłanie danych (113)
• Pakiety żądań (114)
• Pakiety odpowiedzi (115)
• Odbiór i odsyłanie danych w Arduino (117)
• Oprogramowanie wbudowane urządzenia końcowego (121)
• Podsumowanie (123)

Rozdział 6. Symulacja czujników (125)

• Czujniki analogowe (126)
  
  • Czytnik czujnika analogowego (126)
  • Filtr dolnoprzepustowy (126)
  • Weryfikacja kodu (128)
  • Drabinka rezystorowa (128)
  • Weryfikacja kodu (131)
• Czujniki cyfrowe (131)
  
  • Czujniki PWM (131)
  • Kod Graya (131)
• Czujniki szeregowe (135)
  
  • Szeregowe wysyłanie danych (135)
  • Weryfikacja kodu (137)
• Transmisja I2C (137)
  
  • Rejestr TWRC (138)
  • Rejestr TWAR (139)
  • Rejestr TWDR (139)
  • Rejestr TWSR (139)
  • Wysyłanie danych magistralą I2C (139)
  • Weryfikacja kodu (141)
• Podsumowanie (141)

Rozdział 7. Kontrolery PID (143)

• Obliczenia matematyczne (143)
  
  • Część proporcjonalna (143)
  • Część całkująca (144)
  • Część różniczkująca (144)
  • Suma wszystkich części (145)
  • Czas (145)
• Konfiguracja kontrolera PID (146)
  
  • Połączenia sprzętu (146)
  • Weryfikacja kodu (147)
• Aplikacja PID Tuner (148)
• Porównanie kontrolerów PID, DEAD BAND oraz ON/OFF (149)
• Kontroler PID może sterować (150)
  
  • Regulacja kontrolera (151)
  • Biblioteka PID (152)
  • Funkcje biblioteki PID (153)
• Dodatkowe materiały (154)
• Podsumowanie (154)

Rozdział 8. Sieci sensorowe Android (155)

• Budowa sieci sensorowej (156)
• Biblioteki openFrameworks (157)
• Kod Arduino (164)
• Aplikacja Android (171)
• Podsumowanie (178)

Rozdział 9. Zastosowanie Arduino z układami PIC32 i ATtiny Atmel (179)

• Arduino i niestandardowe środowiska (179)
• Środowisko MPIDE i platforma chipKIT PIC32 (180)
  
  • Przykład: wykrywanie przedmiotów z zastosowaniem usługi Task Manager (182)
• Zastosowanie Arduino z rodziną układów ATtiny (188)
  
  • Rodzina ATtiny 85/45/25 (189)
  • Rodzina ATtiny 84/44/24 (190)
  • Rodzina ATtiny 4313 oraz 2313 (190)
• Zastosowanie Arduino jako programatora systemowego (191)
• Projekt: pudełko otwierane szyfrem (192)
  
  • Co robi to urządzenie (192)
  • Lista materiałów (193)
• Podsumowanie (196)

Rozdział 10. Wieloprocesorowość: większa moc połączonych Arduino (197)

• Standard I2C (198)
• Standard SPI (199)
• Połączenie dwóch urządzeń (199)
  
  • Konfiguracja urządzenia master SPI (202)
  • Weryfikacja kodu (203)
  • Wektory przerwań (203)
  • Konfiguracja SPI za pomocą rejestrów (204)
  • Weryfikacja kodu (207)
  • Wiele urządzeń slave (208)
  • Tryb master w rejestrze (208)
  • Weryfikacja kodu (209)
• Dwubiegunowa symetryczna szyna danych (209)
  
  • Kod SABB (210)
  • Weryfikacja kodu (213)
  • Połączenie urządzeń SABB i SPI (213)
• Migracja do płyty Mega (214)
• Zalecane praktyki montażowe (215)
• Podsumowanie (216)

Rozdział 11. Tworzenie gier dla Arduino (217)

• Gry odpowiednie dla Arduino (217)
• Prosta gra (218)
  
  • Prototyp gry (219)
  • Programowanie gry (220)
  • Weryfikacja kodu (225)
  • Nieuczciwe sztuczki (225)
• Lepszy wyświetlacz i grafika (225)
  
  • Biblioteka Gameduino (226)
  • Nowa gra Ułóż stos (227)
  • Sztuka (229)
  • Kodowanie gry Ułóż stos (231)
  • Weryfikacja kodu (235)
  • Dźwięki (236)
  • Trochę efektów (237)
  • Programowanie automatycznej gry (238)
  • Ostatnie szlify (241)
  • Materiały o arcade i innych grach (242)
• Podsumowanie (242)

Rozdział 12. Własne biblioteki dla Arduino (243)

• Co musisz wiedzieć, aby napisać własną bibliotekę (243)
  
  • Utworzenie prostej biblioteki (245)
• Utworzenie biblioteki Motor (249)
• Anatomia folderu bibliotek Arduino (254)
  
  • Folder przykładów (255)
  • Licencja (255)
  • Plik keywords.txt (255)
  • Instalacja bibliotek Arduino (256)
  • Użycie bibliotek Arduino (256)
• Obiekty Arduino i konwencje bibliotek (256)
• Podsumowanie (263)

Rozdział 13. Zestaw testowy Arduino (265)

• Instalacja zestawu testowego (266)
• Rozpoczęcie testów (268)
• Format wyniku testu Arduino (270)
  
  • Szczegóły sekcji wyniku testu (270)
• Podstawowe funkcje zestawu testowego (271)
  
  • Funkcja ATS_begin (271)
  • Funkcja ATS_PrintTestStatus (272)
  • Funkcja ATS_end (272)
  • Użycie podstawowych funkcji (272)
• Wbudowane testy (273)
• Strategie testów płyt pochodnych od Arduino (273)
• Testowanie pamięci (274)
  
  • Przykład: testowanie wycieku pamięci (277)
• Testowanie bibliotek (278)
  
  • Test funkcji SPI.transfer() (284)
  • Test funkcji setBitOrder() (284)
  • Test funkcji setClockDivider() (285)
  • Test funkcji setDataMode() (285)
  • Wyniki testów biblioteki SPI (286)
• Podsumowanie (286)

Skorowidz (287)

• Tytuł: Arduino dla zaawansowanych
• Autor: Rick Anderson, Dan Cervo
• Tytuł oryginału: Pro Arduino
• ISBN: 978-83-246-8223-2, 9788324682232
• Data wydania: 2014-02-24
• Format: Ebook
• Identyfikator pozycji: arduza
• Wydawca: Helion