Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00220 006512 13598901 na godz. na dobę w sumie
Arduino dla zaawansowanych - książka
Arduino dla zaawansowanych - książka
Autor: , Liczba stron: 296
Wydawca: Helion Język publikacji: polski
ISBN: 978-83-246-8222-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> elektronika >> arduino
Porównaj ceny (książka, ebook, audiobook).

Platforma Arduino to cudowne dziecko inżynierów, dzięki któremu świat elektroniki zyskał tysiące nowych entuzjastów. Skąd oni się wzięli? Dzięki Arduino nawet kompletny laik może zbudować atrakcyjny układ elektroniczny, który ułatwi mu życie. Jeżeli do tego dołożymy świetną dokumentację oraz środowisko przeznaczone specjalnie do tworzenia oprogramowania, to staje się jasne, dlaczego Arduino jest tak popularne.

Na rynku wydawniczym obecnych jest już kilka pozycji poświęconych Arduino, jednak zazwyczaj zawierają one zbiory projektów, które czytelnik może wykonać we własnym zakresie. Tymczasem jeżeli masz ambicję tworzyć nowatorskie rozwiązania, których nie spotkasz w sieci ani w książkach, musisz zdobyć zdecydowanie szerszą wiedzę. Ta książka Ci jej dostarczy. W trakcie lektury dowiesz się, jak wykorzystać sieci radiowe XBee, komunikować się z systemem Android oraz integrować Arduino z niestandardowymi układami, takimi jak Atmel. Ponadto dowiesz się, jak wykorzystać wiele platform Arduino do pracy nad jednym problemem. A potem nauczysz się tworzyć biblioteki dla Arduino i udostępniać je społeczności. W tym tkwi największa siła platformy!

Dowiedz się:

Obowiązkowa lektura dla każdego pasjonata elektroniki!

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Tytuł oryginału: Pro Arduino ISBN: 978-83-246-8222-5 Original edition copyright © 2013 by Rick Anderson and Dan Cervo. All rights reserved. Polish edition copyright © 2014 by HELION SA. All rights reserved. All rights reserved. No part of this book may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from the Publisher. 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. Autor oraz 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/arduza.zip Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/arduza Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Printed in Poland. • Kup książkę • Poleć książkę • Oceń książkę • Księgarnia internetowa • Lubię to! » Nasza społeczność Spis tre(cid:258)ci Rozdzia(cid:239) 1. O autorach .............................................................................................................11 O korektorze merytorycznym .................................................................................12 Wprowadzenie ......................................................................................................13 Podzi(cid:218)kowania ......................................................................................................14 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 Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH Rozdzia(cid:239) 2. Programowanie Arduino i kodowanie spo(cid:239)eczno(cid:258)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(cid:239) 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 6 Kup książkęPoleć książkę SPIS TRE(cid:165)CI 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(cid:239) 4. Narz(cid:218)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(cid:239) 5. Modu(cid:239)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 Symulacja czujników ...........................................................................................125 Czujniki analogowe ............................................................................................................................126 Czytnik czujnika analogowego ..................................................................................................126 Filtr dolnoprzepustowy ..............................................................................................................126 Weryfikacja kodu ........................................................................................................................128 Drabinka rezystorowa .................................................................................................................128 Rozdzia(cid:239) 6. 7 Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH 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 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 Sieci sensorowe Android .....................................................................................155 Budowa sieci sensorowej ...................................................................................................................156 Biblioteki openFrameworks ..............................................................................................................157 Kod Arduino .......................................................................................................................................164 Aplikacja Android ..............................................................................................................................171 Podsumowanie ....................................................................................................................................178 Zastosowanie Arduino z uk(cid:239)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 Rozdzia(cid:239) 7. Rozdzia(cid:239) 8. Rozdzia(cid:239) 9. 8 Kup książkęPoleć książkę SPIS TRE(cid:165)CI 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(cid:239) 10. Wieloprocesorowo(cid:258)(cid:202): wi(cid:218)ksza moc po(cid:239)(cid:200)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(cid:239) 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 9 Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH Rozdzia(cid:239) 12. W(cid:239)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(cid:239) 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 10 Kup książkęPoleć książkę R O Z D Z I A (cid:146) 6 (cid:132) (cid:132) (cid:132) Symulacja czujników Układy Arduino mogą być użyte do symulowania czujników podłączonych do innych płyt Arduino lub urządzeń współpracujących z czujnikami. Symulowanie czujników umożliwia generowanie określonych i powtarzalnych danych, które mogą być użyte do testowania systemów i usuwania błędów, jak również do badania czujników, które nie są aktualnie dostępne. W tym rozdziale w większym stopniu skupiliśmy się na koncepcjach podłączenia różnego typu czujników niż na przesyłanych danych. Na potrzeby opisywanych zagadnień dane są odpowiednio uproszczone, niemniej jednak są wysyłane w taki sam sposób jak przez prawdziwe czujniki. Aby lepiej zademonstrować, jak Arduino może bezpośrednio symulować różne czujniki, każdy opisany przykład zawiera kod odczytujący dane z różnego typu interfejsów. Kody pochodzą z różnych źródeł i nie zostały zmodyfikowane. Celem koncepcji symulacji nie jest zastąpienie czujników. W przypadku małych projektów przygotowanie symulacji może zająć więcej czasu niż użycie rzeczywistych czujników. Techniki symulacji są przydatne w zastosowaniach wymagających kontrolowanego przetwarzania danych, takich jak budowa robotów, testowanie platform lub badanie działania czujników. Podstawowym celem tego rozdziału jest pomoc przy pokonywaniu przeszkód, jakie możesz napotkać podczas budowania systemów symulujących czujniki lub tworzenia wykorzystujących je skomplikowanych projektów. Czujniki służą do zamiany różnych parametrów fizycznych na impulsy elektryczne, które mogą zostać odczytane przez systemy komputerowe. Temperatura, położenie lub skład chemiczny przedmiotów to przykłady cech fizycznych, które mogą być badane za pomocą czujników. W symulacji nie jest najważniejsze pełne odtworzenie pracy lub funkcjonalności czujników. Niemniej jednak dane muszą być wysyłane w tym samym momencie, w takiej samej kolejności i tą samą metodą, jak w prawdziwym czujniku. Dokumentacja dostarcza niezbędnych informacji o ważnych funkcjach czujnika (np. zakres danych, ich typ, rodzaj komunikacji). W tym rozdziale będą potrzebne dwie płyty kompatybilne z Arduino oparte na układzie ATmega 328P i dość szeroki zestaw podstawowych elementów do budowy prototypów projektów. Jedna z płyt Arduino zostanie użyta do odczytywania czujnika, a druga do jego symulacji. Dwie płyty mogą być zastosowane do zasymulowania szerokiego spektrum czujników, przy czym szkic kodu czujnika pozostanie niezależny od szkicu kodu czytnika. Dzięki temu symulacje będą najbardziej dokładne w kontekście synchronizacji czasowej urządzeń, a jeżeli symulowany czujnik zostanie zamieniony na prawdziwy, nie będzie wymagana modyfikacja szkicu kodu czujnika. Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH Czujniki analogowe Jest bardzo wiele czujników mierzących np. temperaturę, ruch lub położenie. Tego rodzaju czujniki sterują w sposób ciągły napięciem wyjściowym, ściśle skorelowanym ze stanem czujnika. Dostarczana informacja może być odczytana przez analogowe piny Arduino. Dane analogowe można zasymulować za pomocą potencjometru, lecz ponieważ potencjometr jest sam w sobie czujnikiem, więc nie jest odpowiedni do zastosowań w automatycznym sterowania urządzeniami. Arduino posiada wejścia analogowe, ale brakuje mu prawdziwych wyjść. Istnieją metody złagodzenia braku wyjść analogowych poprzez zastosowanie przetwornika cyfrowo-analogowego lub potencjometru cyfrowego. Są to doskonałe rozwiązania w przypadku systemów produkcyjnych, lecz rzadko można je znaleźć w zwykłym zestawie elementów. Przykłady w tej części rozdziału opisują sposób zbudowania dwóch różnych przetworników cyfrowo-analogowych do wygenerowania sygnału analogowego, wykorzystujących tylko rezystory i kondensatory. Pierwszy przykład dotyczy kodu na Arduino dla czujnika temperatury TMP35 firmy Analog Devices. Czytnik czujnika analogowego Listing 6.1 przedstawia kod czytnika analogowego, wykorzystany w obu przykładach. Kod musi być załadowany do płyty Arduino użytej jako czytnik. Drugie Arduino będzie użyte jako czujnik dostarczający sygnał analogowy. Kod z listingu 6.1 pochodzi z oryginalnego przykładu ze strony firmy LadyADA (pod adresem www.ladyada.net/learn/sensors/tmp36.html). Jego działanie nie zostało zmienione, zmodyfikowane są jedynie komentarze. Przykład dotyczy czujnika temperatury, ale koncepcja odczytu sygnału z pinu analogowego i korelacji obliczeń z sygnałem na wyjściu dotyczy również innych czujników analogowych. Kod z listingu odczytuje sygnał analogowy na pinie 0 i na monitorze portu szeregowego wyświetla przetworzone dane opisujące temperaturę. Listing 6.1. Kod czytnika czujnika temperatury LadyADA ze zmodyfikowanymi komentarzami int sensorPin = 0; void setup() { Serial.begin(9600); } // koniec void setup() void loop() { int reading = analogRead(sensorPin); float voltage = reading * 5.0; // konwersja odczytu na wartość napięcia voltage /= 1024.0; // podzielenie odczytanego napięcia przez maksymalną rozdzielczość przetwornika ADC Serial.print(voltage); Serial.println( V ); float temperatureC = (voltage - 0.5) * 100 ; // zmniejszenie o 500 mV i przemnożenie // przez 100, by otrzymać stopnie Celsjusza Serial.print(temperatureC); Serial.println( stopni C ); float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0; // zamiana stopni C na F Serial.print(temperatureF); Serial.println( stopni F ); delay(1000); } // koniec void loop() Filtr dolnoprzepustowy Pierwszą metodą uzyskania sygnału analogowego jest zastosowanie filtru dolnoprzepustowego. Filtr zbudowany jest z rezystora i kondensatora połączonych szeregowo. Kondensator jest ładowany sygnałem modulacji PWN z Arduino i rozładowywany przez rezystor do wejścia analogowego płyty. Taka metoda konwersji sygnału 126 Kup książkęPoleć książkę ROZDZIA(cid:146) 6. (cid:132) SYMULACJA CZUJNIKÓW cyfrowego na analogowy sprawdza się, ponieważ pełne naładowanie kondensatora trwa pewien czas i poprzez kontrolę czasu utrzymania wysokiego stanu na wyjściu cyfrowym można uzyskać poziom napięcia stanowiący określony procent maksymalnego napięcia na wyjściu cyfrowym. Impuls PWM o poziomie wypełnienia 50 naładuje kondensator do 50 pojemności, co pozwoli uzyskać połowę maksymalnego napięcia. Jeżeli napięcie na pinie cyfrowym wynosi 5 V, wówczas uzyska się napięcie wyjściowe ok. 2,5 V. Jeżeli w takiej konfiguracji zastosowany zostanie kondensator o zbyt małej pojemności, jego czas rozładowania będzie krótszy od czasu naładowania i nie będzie możliwe uzyskanie odpowiedniego napięcia na pinie analogowym. Z kolei kondensator o dużej pojemności spowoduje wydłużenie czasu spadku napięcia z poziomu przy pełnym naładowaniu. O ile pojemność kondensatora nie będzie zbyt mała, może być on użyty do symulowania wrażliwych czujników, szybko zmieniających napięcie. Do symulacji mniej wrażliwych czujników można zastosować nie tylko większy kondensator, ale również większy rezystor, przez co zmiany napięcia będą wolniejsze. Rezystor spowalnia rozładowanie kondensatora przez pin PWM. Aby nie obniżać całkowitego napięcia, należy zastosować niewielki rezystor. Opisana metoda nadaje się do konwersji sygnału cyfrowego na analogowy w przypadku, gdy dokładność nie jest istotna. W modulacji PWM dostępnych jest 256 poziomów (od 0 do 255), co przy napięciu 5 V daje ok. 0,019 – 0,2 V na jeden poziom. Filtr charakteryzuje się ponadto pewnym niewielkim rozrzutem napięcia, co zmniejsza dokładność. Rozrzut nie jest niekorzystnym zjawiskiem, szczególnie w konfiguracji, gdzie czujnik jest kontrolowany w pętli i wysyła sygnał bezpośrednio na wejście. Prawdziwy czujnik wysyłający sygnał analogowy może mieć pewną niedokładność, a więc czujnik symulowany będzie w takim przypadku lepszym przybliżeniem rzeczywistego. Konfiguracja sprzętu jest przedstawiona na rysunku 6.1. Piny z napięciem 5 V i piny masy obu płyt Arduino są połączone ze sobą, dzięki czemu zasilana jest płyta symulująca czujnik. Taka konfiguracja zapewnia również komunikację pomiędzy oboma układami, ponieważ mają wspólną masę (taka sama konfiguracja występuje we wszystkich przykładach). Filtr dolnoprzepustowy składa się z kondensatora elektrolitycznego podłączonego biegunem ujemnym do masy, a dodatnim do wejścia analogowego czytnika. Pin 9 Arduino będącego czujnikiem jest dołączony do rezystora, którego druga strona jest dołączona do dodatniego bieguna kondensatora. Rysunek 6.1. Konfiguracja filtru dolnoprzepustowego 127 Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH Listing 6.2 przedstawia sposób sterowania napięciem wyjściowym. Wartość zmiennej typu byte jest modyfikowana i zapisywana na pinie nr 9. Wartość zmiennej sensorOut można zmieniać za pomocą poleceń odbieranych z portu szeregowego. Aby lepiej odwzorować działanie symulowanego czujnika, można obliczyć wartość z zakresu np. od 0 do 100°C. Listing 6.2. Kod dla płyty Arduino symulującej czujnik byte sensorOut = 0x00; void setup() { pinMode(9,OUTPUT); // tu można skonfigurować port szeregowy } // koniec void setup() void loop() { sensorOut++; // przetwarzanie zmiennej wyjściowej analogWrite (9,sensorOut); // symulacja rzeczywistego czujnika delay(1000); // opóźnienie oddające prędkość odświeżania czujnika } // koniec void loop() Weryfikacja kodu Po skonfigurowaniu układu i załadowaniu kodu podłącz port USB komputera do płyty Arduino będącej czytnikiem i otwórz monitor portu szeregowego. Czytnik będzie wyświetlał wartości napięcia na wejściu analogowym oraz temperaturę w skali Celsjusza i Fahrenheita. Arduino będące czujnikiem będzie podawać napięcie w zakresie od 0 V do ~5 V o skoku ~0,02 V, odpowiadające temperaturze od –50°C do 450°C z dokładnością ok. 2°C. Drabinka rezystorowa Drabinka rezystorowa jest inną metodą uzyskania sygnału analogowego za pomocą Arduino. Składa się z 20 rezystorów, z których 9 ma określoną rezystancję, a pozostałych 11 dwukrotnie większą. Drabinka jest w rzeczywistości układem dzielników napięcia. Działanie metody polega na sumowaniu wielu sygnałów cyfrowych w jeden, przy czym napięcie każdego z nich jest sukcesywnie zmieniane przez różne rezystory. Jest to metoda równoległego binarnego sterowania napięciem wyjściowym. Najmniej znaczący bit steruje sygnałem podawanym na rezystor najbliżej masy, natomiast najbardziej znaczący bit sygnałem na drugim końcu łańcucha rezystorów. Rysunek 6.2 przedstawia schemat drabinki rezystorowej, w której wejście Vin0 odpowiada najmniej znaczącemu bitowi i jego zmiana stanu na wysoki będzie wywoływać najmniejszą zmianę napięcia. Poprzez dodawanie kolejnych wejść Vinn+1 na końcu drabinki można ją rozbudować do dowolnej liczby bitów. Rysunek 6.2. Schemat drabinki rezystorowej 128 Kup książkęPoleć książkę ROZDZIA(cid:146) 6. (cid:132) SYMULACJA CZUJNIKÓW Wartości rezystorów mogą być dowolne, o ile tylko jedna wartość będzie dwukrotnie większa od drugiej, przy czym nie może być zbyt duża, aby nie tłumiła napięcia wyjściowego. Odpowiednie wartości rezystancji wynoszą odpowiednio 1 kΩ oraz 470 Ω. Dobierając rezystory o dokładności 5 , można za pomocą dobrego multimetru uzyskać stosunek rezystancji 2:1. Drabinkę można wyskalować do dowolnej liczby bitów, dodając lub odejmując po dwa rezystory. W tym przykładzie zastosowany jest 10-bitowy konwerter odpowiadający rozdzielczości przetwornika analogowo-cyfrowego płyty Arduino. Kod implementuje 10-bitowy licznik sterujący konwerterem. Wartości mniejszych rezystorów oznaczone są jako 1R, a większych jako 2R. Budując układ, korzystaj z rysunku 6.3. Rozpocznij od rezystora 2R, podłączając go jednym końcem do masy, a drugim do innej łączówki na tej samej stronie płyty montażowej. Połącz za pomocą tej łączówki po tej samej stronie płyty dziewięć rezystorów 1R, a ostatni dołącz do pinu nr 0 płyty Arduino będącej czytnikiem. Końcówki każdego z dziesięciu pozostałych rezystorów 2R są z jednej strony dołączone do złączonych końcówek rezystorów 1R, a z drugiej do kolejnych pinów od 2 do 11 płyty Arduino będącej czujnikiem, licząc od rezystora 2R podłączonego najbliżej masy. Pozostałe dwa połączenia doprowadzone są do pinów 5 V i masy obu płyt Arduino. Kod programu czytnika jest taki sam jak dla filtru dolnoprzepustowego. Rysunek 6.3. Połączenie drabinki rezystorowej Kod implementuje podstawowy licznik binarny i jest wprowadzeniem do programowania rejestrów AVR Arduino. Użycie rejestrów może w niektórych przypadkach skrócić kod, ale również go skomplikować. Kod musi zmieniać wartości czterech rejestrów: DDRB, DDRD, PORTB oraz PORTD. Pierwsze litery oznaczają typ rejestru, natomiast ostatnia litera oznacza pin płyty Arduino. Wszystkie opisane porty mają 8-bitów (lub dwie części po 4 bity). (cid:120) Nazwa rejestru kończąca się na literę D oznacza piny od 0 do 7. (cid:120) Litera B oznacza piny od 8 do 13, natomiast dwa ostatnie bity są nieużywane. Bity i piny są skorelowane ze sobą, począwszy od najmniej znaczącego bitu. Aby ustawić wysoki stan na pinie 0, należy do rejestru PORTD wpisać wartość 0b00000001. 129 Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH (cid:120) DDRx oznacza rejestr kierunku danych, określający, czy pin ma być wejściem (0) czy wyjściem (1). Zmianę osiąga się przez wpisanie do rejestru bajtu danych, na przykład wartość 0b11100011 ustawia piny nr 7, 6, 5, 1 i 0 jako wyjścia, natomiast piny nr 4, 3 oraz 2 jako wejścia. Za pomocą tej metody piny konfiguruje się podobnie jak przy użyciu funkcji pinMode(pin, kierunek) wywoływanej dla każdego pinu w funkcji setup(). Jeżeli wymagane jest użycie funkcji szeregowych, dwa najmłodsze bity rejestru xxxD muszą być pominięte, przez co nie można wykorzystać całego bajtu. (cid:120) Wpisując bajt danych do rejestru PORTx, można w jednym wierszu kodu zmieniać stan całej grupy pinów na wysoki lub niski, zależnie od wpisanej wartości. Natomiast wpisując do zmiennej wartość PORTx, można odczytać zawartość rejestru. W zależności od ustawionego trybu rejestru DDRx można określić, jak zostały ustawione bity danych: wewnętrznie za pomocą funkcji output(1) lub zewnętrznie funkcją input(0). Do Arduino będącego czujnikiem załaduj kod z listingu 6.3. Kod ustawia za pomocą rejestru stan pinów od 2 do 11, tak samo jak za pomocą funkcji pinMode(). Następnie kod zwiększa wartość zmiennej typu unsigned int do liczby 1024. Za pomocą operatora AND przycinanych jest 10 bitów zmiennej, dzięki czemu licznik nie osiąga maksymalnej 16-bitowej wartości równej 65535. Wartość jest następnie przesuwana tak, aby poszczególne bity odpowiadały pinom. Niepotrzebne bity są zerowane za pomocą bitowego operatora AND, po czym dane są umieszczane w odpowiednim rejestrze. Ponieważ środowisko Arduino IDE wykorzystuje kompilator AVR języka C/C++, nie są wymagane dołączenia ani deklaracje nazw rejestrów. Po prostu wpisuje się je i używa tak samo jak każdej innej zmiennej. (cid:132) Uwaga Bezpo(cid:258)rednie zmienianie warto(cid:258)ci rejestrów jest zaawansowan(cid:200) technik(cid:200) programistyczn(cid:200), która mo(cid:285)e nie dotyczy(cid:202) wszystkich p(cid:239)yt kompatybilnych z Arduino. Sprawd(cid:283) uk(cid:239)ad pinów danej p(cid:239)yty i opis rejestru w dokumentacji. Listing 6.3. Kod czujnika unsigned int manipVar=0; // jedyna zmienna potrzebna do wygenerowania danych void setup() { DDRD = DDRD | 0b11111100; // ustawienie pinów 2 – 7 jako wyjścia lub pozostawienie pinów 1, 2 wolnych // na potrzeby komunikacji szeregowej DDRB = DDRB | 0b00001111; // ustawienie pinów 8 – 11 jako wyjścia, pozostawienie pozostałych wolnych } // koniec void setup() void loop() { manipVar++; // zmienną manipVar można dowolnie zmodyfikować manipVar = 0b0000001111111111; // maska resetująca zmienną manipVar // gdy osiągnie wartość 1024 PORTD = (manipVar 2) 0b11111100; //przesunięcie w lewo o 2 bity, następnie zamaskowanie // aby wyodrębnić piny 2 – 7 ze zmiennej manipVar, // następnie wpisanie bitów do pinów 2 – 7 PORTB = (manipVar 6) 0b00001111; // przesunięcie w prawo o 6 bitów // w celu ustawienia wartości pinów 8 – 11 delay (1000); // uwzględnienie odświeżenia danych czujnika } // koniec void loop() 130 Kup książkęPoleć książkę ROZDZIA(cid:146) 6. (cid:132) SYMULACJA CZUJNIKÓW Weryfikacja kodu Po załadowaniu kodu do obu płyt Arduino i umieszczeniu elementów na płycie montażowej podłącz czytnik i otwórz terminal portu szeregowego. Wyświetlana będzie ta sama informacja, jak w poprzednim przykładzie, ale z dokładnością ok. 0,0048 V lub 0,5°C w tym samym zakresie temperatur. W tej metodzie rozrzut jest mniejszy niż w przypadku filtru dolnoprzepustowego, jak również wykorzystana jest maksymalna rozdzielczość przetwornika analogowo-cyfrowego. Jest to lepsza metoda symulowania czujników analogowych. Wadą jest natomiast większa liczba wykorzystywanych pinów, użytych elementów i zastosowanie zaawansowanej techniki programowania do odliczania wartości. W przedstawionej konfiguracji odliczanie wartości od 0 do następnego 0 wprowadza dodatkowe opóźnienie ok. 4 ms, które formuje trójkątną falę o częstotliwości ok. 250 Hz z interwałem ok. 4 μs pomiędzy kolejnymi wartościami. Krótki kod pozwala utworzyć z Arduino prosty generator funkcyjny wykorzystujący tabelę bajtów. Można również symulować piezoelektryczne czujniki pukania. (cid:132) Uwaga Aby lepiej pozna(cid:202) kod, zast(cid:200)p drabink(cid:218) rezystorow(cid:200) seri(cid:200) diod LED, do(cid:239)(cid:200)cz potencjometr do pinu analogowego nr 0. Nast(cid:218)pnie do zmiennej manipVar przypisz funkcj(cid:218) analogRead(0) i zmniejsz argument funkcji delay do 100. W(cid:239)(cid:200)cz zasilanie i obserwuj konwersj(cid:218) sygna(cid:239)u z potencjometru na warto(cid:258)(cid:202) binarn(cid:200). Czujniki cyfrowe Pracując z czujnikami cyfrowymi, można odnieść wrażenie, że jest tyle sposobów obsługi, ile typów czujników. W tej części rozdziału opisany jest przekrój sposobów komunikacji. W symulacjach tych czujników ważna jest zgodność ze specyfikacjami różnych protokołów. Dane mogą być wysyłane lub odbierane, wysyłane w dowolnej kolejności do wielu urządzeń lub żądane w dowolnym momencie, przez co implementacja niektórych urządzeń może być trudna. Cenną pomocą przy wyborze najlepszej metody symulacji jest dokumentacja do czujników i układów Atmel. Czujniki PWM Czujniki PWM nie są tak popularne, jak inne typy czujników, ale wciąż zasługują na uznanie. Są powszechnie używane do sterowania silnikami. W pewnym sensie czujnik PWM zastępuje odbiornik RC, który też jest swego rodzaju czujnikiem. Chociaż w mikrokontrolerze Atmel brakuje niektórych elementów ściśle odpowiadających specyfikacji większości czujników wykorzystujących modulację PWM, niemniej jednak możliwy jest ich odczyt. Funkcja pulseIn() może odczytywać wygnał wyjściowy PWM z innego pinu z wystarczającą dokładnością umożliwiającą korelację danych. Kod, który można wykorzystać do symulowania czujników tego typu, jest podobny do przedstawionego w listingu 6.2. Jeżeli weźmiemy pod uwagę fakt, że nie ma czujników implementujących modulację PWM odpowiadającą tolerancji czasowej Arduino, okaże się, że nie znajdziemy przykładów do tej części rozdziału. Taki sposób przekazywania informacji cyfrowej może być przydatny do budowy innych układów czujników. Kod Graya Kod Graya jest metodą generowania fali prostokątnej na dwóch lub więcej pinach, przy czym fale te są przesunięte w fazie. Metoda ustawiania faz wielu sygnałów pozwala na odczyt w dowolnym momencie zmiany położenia lub kierunku poruszania się przedmiotów. Przesunięcie fazowe fal prostokątnych pozwala określić, czy bity są przesunięte w lewo, czy w prawo. Kod Graya jest również nazywany cyklicznym kodem dwójkowym i jest powszechnie używany w czujnikach zamieniających liniowy lub kątowy ruch elementów na impulsy umożliwiające określenie ich położenia oraz kierunku i prędkości przemieszczania. W ten sposób działa kółko przewijania w myszy komputerowej. Kod Graya jest szeroko stosowany w robotyce w obrotomierzach. Jeżeli 131 Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH jedna wartość wyjściowa stanowi sygnał odniesienia z przyjętą zasadą narastającego lub opadającego zbocza, wówczas druga wartość wyjściowa odczytana w momencie zmiany sygnału pozwala określić kierunek obrotów. Jeżeli sygnał na drugim wyjściu jest niski przed odczytem sygnału na pierwszym wyjściu, oznacza to, że urządzenie porusza się w określonym kierunku, natomiast jeżeli sygnał jest wysoki — w przeciwnym. W czujniku tego typu potrzebne są przynajmniej dwa piny dla danych i jeden do zasilania/masy. Im więcej pinów ma czujnik, tym jest dokładniejszy, dzięki możliwości wykrywania błędów i brakujących impulsów. Rysunek 6.4 przedstawia impulsy z dwuwyjściowego dekodera. Odczytywana jest zmiana stanu na wysoki lub niski pierwszego sygnału. Stan drugiego zależy od kierunku przesunięcia pierwszego sygnału w chwili odczytu. Rysunek 6.4. Impulsy dwuwyjściowego dekodera Śledzenie impulsów i wykrycie pełnego obrotu jest zadaniem czytnika lub kontrolera. Kod czytnika musi również rozpoznawać kierunek przesunięcia kodu Graya. Dr Ayars jest autorem artykułu na temat odczytu obrotomierza (SparkFun, nr COM-09117). W tym przykładzie kod zmniejsza lub zwiększa wartość zmiennej w zależności od kierunku obrotu dekodera w momencie minięcia zapadki, ale nie w zależności od liczby wykonanych obrotów. Więcej informacji na temat odczytu tego typu czujników można znaleźć na blogu dr. Ayarsa pod adresem http://hacks.ayars.org/2009/12/using-quadrature-encoder-rotary-switch.html. Technika zastosowana w listingu 6.4 jest jedną z metod odczytu kodu Graya i doskonale nadaje się do dekoderów dwuwyjściowych. W przypadku dekoderów o trzech lub więcej wyjściach niezbędna jest bardziej zaawansowana metoda umożliwiająca korektę błędów odczytu i zliczania impulsów. W pierwszej części przykładu należy załadować poniższy kod do Arduino używanego jako czytnik. Listing 6.4. Kod dr Ayarsa ze zmienionymi komentarzami byte Blinker = 13; int Delay = 250; byte A = 2; // pin wyjściowy pierwszego czujnika byte B = 3; // pin wyjściowy drugiego czujnika volatile int Rotor = 0; // licznik kliknięć czujnika void setup() { pinMode(Blinker, OUTPUT); pinMode(A, INPUT); pinMode(B, INPUT); digitalWrite(A, HIGH); // włączenie rezystorów podwyższających digitalWrite(B, HIGH); attachInterrupt(0, UpdateRotation, FALLING); // użycie przerwania na pinie A 132 Kup książkęPoleć książkę ROZDZIA(cid:146) 6. (cid:132) SYMULACJA CZUJNIKÓW Serial.begin(9600); } // koniec setup() void loop() { digitalWrite(Blinker, HIGH); // miganie diody delay(Delay); // tu może być wykonany dowolny kod, czujnik będzie odświeżony digitalWrite(Blinker, LOW); // po zgłoszeniu przerwania na pinie 2 delay(Delay); } // koniec loop() void UpdateRotation() { // odświeżenie odczytu czujnika przy opadającym sygnale na pinie 2 if (digitalRead(B)) { Rotor++; // zwiększenie kierunku, gdy w momencie zgłoszenia przerwania } // na drugim pinie jest stan wysoki else { Rotor--; // zmniejszenie kierunku, gdy w momencie zgłoszenia przerwania } // na drugim pinie jest stan niski Serial.println(Rotor, DEC); } // koniec UpdateRotation() Generowanie kodu Graya Aby Arduino mogło udawać czujnik wysyłający kod Graya, musi generować fale prostokątne, równomiernie przesunięte w fazie między sobą. Najlepszym sposobem sterowania serią sygnałów cyfrowych wysyłanych w określonej kolejności jest zastosowanie funkcji szeregowej digitalWrite() do ustawiania stanów pinów wyjściowych oraz funkcji delay() do kontroli fazy sygnału. Do sterowania każdym wyjściem symulowanego obrotomierza jest użyta osobna funkcja digitalWrite(), natomiast po każdym zapisie stanu jest użyta funkcja delay() przesuwająca sygnał cyfrowy. W obrotomierzu z dwoma wyjściami stany pinów zmieniane są w pętli. W każdym przebiegu pętli wywoływana jest dwukrotnie funkcja digitalWrite(), a po każdym zapisie funkcja delay(). W ten sposób jest generowana fala prostokątna, której okres jest dwukrotnie dłuższy od całkowitego opóźnienia. W każdym przebiegu pętli generowana jest jedna połowa kodu Graya. Kolejność zmian stanów pinów określa kierunek obrotów. Zmiana stanu pinów w kolejności od 1 do 3 oznacza jeden kierunek, natomiast od 3 do 1 oznacza kierunek przeciwny. Procentowe przesunięcie fazy sygnałów jest kontrolowane za pomocą funkcji delay() wywoływanej po funkcji digitalWrite(). W celu obliczenia różnicy fazy indywidualne opóźnienie wprowadzane za pomocą funkcji delay() jest podzielone przez całkowite opóźnienie. Jeżeli całkowite opóźnienie sygnału na dwóch wyjściach jest równe 6 ms, a indywidualne 3 ms, wówczas drugi sygnał jest przesunięty w fazie o 50 . Niektóre obrotomierze generują sygnały przesunięte w fazie o 100 , czyli mające całkowicie przeciwne stany. Aby w obrotomierzu o czterech wyjściach trzeci sygnał był przeciwny do pierwszego, a przesunięcie fazowe było wciąż równomierne, pierwszy sygnał musi zmieniać stan w tej samej chwili co trzeci sygnał, natomiast czwarty sygnał nie może mieć opóźnienia. W ten sposób okres sygnału będzie równy 6 ms, a przesunięcie fazowe równe 1 ms. Wygenerowany okres obrotu będzie zależał od szybkości zmian sygnałów czujnika. Aby obliczyć maksymalną częstotliwość symulowanych zmian, należy podzielić liczbę 60 przez całkowity okres obrotu i pomnożyć przez liczbę kroków na określonym dystansie. Dystans w odniesieniu do obrotów oznacza jeden obrót, natomiast odległość liniowa może być wyrażona w metrach lub innych jednostkach. W tym przykładzie symulacji obrotomierza przyjętych jest 12 kroków na jeden obrót. Najkrótszy czas jednego cyklu zaimplementowanego w czytniku jest równy 8 ms, co daje wynik 60 s / (0,008 s / krok × 12 kroków / obrót) = 625 obrotów na minutę. Czas wykonywania funkcji digitalWrite() można zaniedbać w obliczeniach maksymalnej prędkości obrotowej. Wprowadzane dodatkowe opóźnienie jest równe ok. 6,75 μs, co daje tolerancję błędu równą 0,3 . Jeżeli opóźnienie zostanie usunięte, czujnik może generować sygnał odpowiadający prędkości 1,8 mln obrotów na minutę. 133 Kup książkęPoleć książkę ARDUINO DLA ZAAWANSOWANYCH Obliczenia maksymalnej prędkości obrotowej nie są wykonywane w celu określenia opóźnienia, ale do pozyskania informacji potrzebnych do zastosowania symulowanego sprzętu w pętli sterującej. Opóźnienia pomiędzy zapisami stanu na pinach powinny być równe co najmniej 1 ms, a ponadto powinno być uwzględnione dodatkowe opóźnienie związane ze sterowaniem i zmianami prędkości. Jeżeli kod czytnika ma problemy z dokładnym odczytem wyjścia czujnika, należy zwiększyć opóźnienie pomiędzy wywołaniami funkcji digitalWrite(). Rysunek 6.5 przedstawia konfigurację sprzętu. Piny nr 2 i 3 czytnika są dołączone odpowiednio do pinów 10 i 11 czujnika. Do sterowania kierunkiem sygnału wyjściowego służą dwa przyciski monostabilne dołączone do masy i osobno do pinów nr 2 (poziom wysoki) i 3 (poziom niski). Kod z listingu 6.5 należy załadować do Arduino użytego jako czujnik. Do czytnika natomiast należy załadować kod z listingu 6.4. W odróżnieniu od rzeczywistego obrotomierza, do symulacji potrzebny jest jeszcze jeden pin, a mianowicie muszą być połączone piny zasilające 5 V oraz piny masy obu układów Arduino. Rysunek 6.5. Układ symulujący kod Graya Listing 6.5. Kod Arduino użytego jako czujnik byte first , second; // kierunek zmiany pinów boolean click , stateChang; // umieszczenie kliknięcia i zmiany stanu w zmiennych void setup() { pinMode(2 , INPUT); // przycisk dekodera w dół pinMode(3 , INPUT); // przycisk dekodera w górę pinMode(11 , OUTPUT); pinMode(10 , OUTPUT); // wyjścia dekodera digitalWrite(2 , HIGH); digitalWrite(3 , HIGH); // wejścia rezystorów podwyższających digitalWrite(10 , HIGH); // stan początkowy digitalWrite(11 , LOW); stateChang = true; } // koniec void setup() 134 Kup książkęPoleć książkę ROZDZIA(cid:146) 6. (cid:132) SYMULACJA CZUJNIKÓW void loop() { if (digitalRead(2) == 0 ){ // w dół first = 10; second = 11; // zapis na pinie 10, następnie na 11 dla kierunku w dół click = true;
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Arduino dla zaawansowanych
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: