Tworzenie akcesoriów dla Androida w IOIO


Telefony z Androidem są doskonałą platformą dla tworzenia aplikacji, ale czasami miło jest jeśli aplikacje te wykraczają poza wbudowany sprzęt w telefonie i połączone są z domową elektronika. Płytka IOIO pozwala ci na zrobienie tego, a tu dowiesz się jak wykorzystać IOIO i interfejs dla różnych modułów elektronicznych i komponentów. Techniki te w IOIO są zilustrowane w przykładowych projektach. Projekty te to:
• Sygnalizacja napadu i włamania, która używa telefonu do wysyłania wiadomości SMS w razie wykrycia ruchu przez jego sensor PIR
• Rejestrator temperatury, który rejestruje temperaturę na karcie SD telefonu
• Wyświetlacz 8x8 macierzy LED, który wyświetla animacje i jest kontrolowany przez telefon
Czego będziemy potrzebować? Na pewno telefonu z Androidem oraz oczywiście płytki IOIO. Kady projekt wymaga również dodatkowych części. Projekty są o różnych poziomach trudności i wszystkie wymagają trochę lutowania, więc przyda się i lutownica
Pierwsze kroki z IOIO
IOIO jest płytką wejścia/wyjścia dla telefonów z systemem Android i tabletów. Pozwala ci dołączać urządzenia elektroniczne do telefonu przez łącze USB. Jeśli masz IOIO z najnowszym firmware, możesz również komunikować się przez Bluetooth jeśli dołączysz adapter Bluetooth do IOIO. W tej części omówimy jak skonfigurować komputer i telefon z Androidem do użycia z IOIO i użycie przykładowej aplikacji z oprogramowania IOIO dla włączania i wyłączania "stanu" LED w w telefonie
Co to jest IOIO?
IOIO jest produkowana i sprzedawana przez firmę SparkFun. Zawiera mikrokontroler PIC , interfejs USB i kilka innych komponentów dla regulacji napięcia zasilana itd. Cały projekt zarówno sprzętowy jak i programowy jest typu open source. Aby używać IOIO potrzebujesz:
- Telefonu z Androidem z łączem USB
- Komputera z Windows, Mac lub Linux
- Zasilacza 5-15V DC z co najmniej 500 mA
Ponieważ IOIO nie posiada żadnych przylutowanych gniazd do swoich łączy, będziemy dołączać je do niej aby doprowadzić zasilanie. Aby to zrobić będą potrzebne części wymienione poniżej:
płytka IOIO, listwa SIL Header,2.1 mm gniado zasilania, pojedyncze złącze pin, krótkie odcinki czerwonego i czarnego przewodu wielordzeniowego, 9 V zasilacz
Telefon z systemem Android
IOIO działa z szerokim zakresem telefonów z Androidem. Typ połączenia USB jakiego potrzebujesz to klient USB. Większość telefonów z systemem Android będzie go miała. Przybiera formę małego złącza USB-micro B. Jednak niektóre urządzenia z Androidem ma złącze USB wyglądające jak zwykłe gniazdo USB. Ten typ połączenia nie jest kompatybilny z IOIO. Kiedy używasz IOIO, piszesz program na komputerze ,a potem przenosisz go na telefon używając łącza USB. Możesz potem odłączyć USB od komputera i podłączyć z IOIO tak aby telefon był teraz połączony z płytką IOIO. Nie ma programowania samej płytki IOIO. Programy są uruchamiane na telefonie, telefonie , który komunikuje się z IOIO przez USB lub Bluetooth
Komputer
IOIO używa tego samego Zintegrowanego Środowiska Programistycznego (IDE) jakie Google zaleca dla urządzeń z Androidem - Eclipse. Eclipse nie jest wymagany dla Androida lub IOIO ,ale jest najpowszechniejszym oprogramowaniem używanym dla tworzenia dla nich aplikacji. Eclipse i pozostałe oprogramowanie jakiego potrzebujesz , jest dostępne na Windows, Ma i Linux.
Zasilacz
IOIO nie czerpie zasilania z USB. Więc jeśli połączysz do z telefonem przez USB, lampka zasilania na IOIO nie zaświeci się. Telefon otrzymuje moc ładowania z IOIO jeśli była podłączona do komputera, więc należy podłączyć zasilanie do płytki IOIO. Może to być wtyczka zasilania lub bateria 9V. Chociaż jeśli łączysz się przez USB a nie Bluetooth, mała bateria długo nie pociągnie, a prąd ładowania szybko ją opróżni. Nasze projekty używają mieszaniny zasilaczy i baterii. Żaden z naszych projektów nie jest energochłonny więc prąd 500 mA jest wystarczający. Jednak IOIO posiada wysokonapięciowy regulator, co oznacza ,że dla bardziej wymagających projektów może dostarczyć do 1,5A przy 5V. Więc jeśli planujesz używać IOIO do sterowania urządzenia o dużej mocy, możesz kupić zasilacz ,powiedzmy 20 W. Projekt pojazdu używa silnika o małej mocy i zasilanego baterią .Jeśli szukasz złącza zasilania na płycie, nie ma go ta. Będziemy potrzebowali lutownicy dla przyłączenia zasilania. Alternatywnie, istnieje obszar na płycie, poza złączem USB, gdzie może być przylutowane powierzchniowo złącze JST. SprakFun dostarcza takie złącze (PRT-0861) jak również adapter gniazda zasilania (TOL-08734), ale nie są one konieczne w naszych projektach
Przygotowanie płytki IOIO
Płytka IOIO jaką otrzymujesz , będzie zupełnie naga, bez złącza lub widocznych środków do podłączenia elektronik a nawet zasilacza. W naszych projektach będziemy robić zasilanie i elektroniczne wejścia/wyjścia. Aby to zrobić musimy znaleźć sposób na podłączenie przewodów do złącza. Wygodnym sposobem na zrobienie tego jest ptylutowanie taśm złącz do dwóch długich brzegów IOIO. Nasze projekty używają tylko pierwszych 20 złącz po każdej stronie i żadnych złącz na końcu. Wynik pokazano tu : IOIO ze złączami. aby przylutować złącza, umieść je we właściwym miejscu, obróć płytkę do góry nogami. Upewnij się ,że złącza są prosto, przylutuj je. Potem sprawdź ,czy nie ma jakichś zwarć między poszczególnymi złączami. Aby podłączyć zasilanie, potrzebujemy krótkiego przewodu mającego dwa piny na jednym końcu i standardowe gniazdko niskonapięciowe na drugim : Kabel zasilający. Płytka IOIO ma pin Vin i piny GND po przeciwnych stronach płytki, przez które jest dostarczane zasilanie. Oznacza to ,że nasz przewód musi być rozdzielone na końce płytki. Skręcenie przewodów razem pomaga uporządkować to prowadzenia. Dobrym pomysłem jest zastosowanie czerwonego przewodu dla podłączenia plusa do środkowego złącza gniazda 2.1 mm i czarnego przewodu prowadzone z zewnątrz złącza gniazda do pinu GDN. Zauważz ,że płytka IOIO ma do wyboru trzy gniazda GND. Każdy działa jeśli podepniemy zasilanie. Możemy teraz przynajmniej sprawdzić że nasza płytka jest zasilona, przez podłączenie zewnętrznego zasilacza. Powinna się zaświecić dioda LED "Power" i jeśli podłączyłeś telefon kablem USB, zauważysz jego ładowanie. Jeśli się nie ładuje możesz użyć małego śrubokręta aby dostosować potencjometrem za gniazdem USB. To decyduje o ilości dostarczanego prądu do telefonu. Jeśli jest ona zbyt niska, telefon może nie wykryć podłączenia płytki IOIO
Większość zasilaczy ma podłączony plus do środkowego pinu w 2.1 mm ,ale niektóre adaptery , szczególnie te muzyczne, są nieco inne. Więc sprawdź polaryzację , przed ich podłączeniem
Instalacja
Jeśli chcesz pisać własne aplikacje dla IOIO lub chcesz lepiej zrozumieć działanie aplikacji wykonaj poniższe instrukcje. Musisz zainstalować wszystko co potrzebne dla środowiska programistycznego Android, i dodatkowy kod dla tworzenia aplikacji używających IOIO. Kroki te obejmują ;
• Instalację Javy
• Instalację Eclipse
• Innstalację Android SDK
• Instalację Android ADT Plugin
• Import biblioteki IOIO i przykładowych aplikacji
Dla instalacji środowiska Javy i Eclipse zajrzyj tu : [http://wiki.eclipse.org/Eclipse/Installation]. Po zainstalowaniu Eclipse, zainstaluj Android SDK : [http://developer.android.com/sdk]. Instrukcje dotyczące instalacji Android ADT Plugin znajdziesz tu : [http://developer.android.com/sdk/eclipse-adt.html]. Po zainstalowaniu ADT Plugin, musisz powiedzieć Eclipse o położeniu Android SDK. Aby to zrobić otwórz panel Prefereces w Eclipse i wybierz Android z lewej strony. W polu SDK Location przejdź do katalogu głównego ADT jaki zainstalowałeś : Ustawienia położenia ADT w Eclipse. Jeśli zainstalowałeś ADT wcześniej, zainstaluj tylko podstawowe środowisko. Musimy zainstalować pakiety dla platformy Android jakiej używamy. Musimy zainstalować platformę, która będzie pasowała do wersji z naszego telefonu. Platformy są dodawane przy użyciu narzędzia nazwanego Android SDK i AVD manager. Jest uruchamiany z menu Window w Eclipse, lub wpisanie "android" z wiersza poleceń Linux lub Mac. Jak widać : Instalowanie platformy Android w Eclipse, tu jest zainstalowane kilka platform.Kiedy podstawowe środowisko Androida zostało już skompletowane, musisz zaimportować przykładowe projekty IOIO i bibliotekę z Eclipse. Pierwszy krok to pobranie pliku zip zawierającego IOIOLib i przykłady. Możesz znaleźć je tu : [https://github.com/ytai/ioio/wiki/Downloads]. Pobierz najnowszą wersję. Następnie w Eclipse kliknij prawym klawiszem myszki w obszarze ProjectExplorer zaznacz Import : Instalowanie biblioteki IOIO i przykładów. Kliknij Select Archive File. Przeglądnij pliki jakie pobrałeś. Dołącz wszystkie przykładowe projekty , chociaż potrzbujesz tylko HelloIOIO, IOIOLib i IOIOLibBT. Będziesz miał różne wpisy ,jak pokazano tu : Przykłady w Project Explorerze. Jeśli jest czerwony krzyżyk błędu obok któregoś z projektów, przejdź do menu Project i wybierz Clean aby wyczyścić wszystkie projekty. Zwykle usuwa to krzyżyki. Jeśli tak nie jest, spróbuj wkleić komunikat o błędzie, który pojawi się w wyszukiwarce
Hello IOIO
Otwórz pierwszy project na liście (HelloIOIO) i połącz telefon z komputerem przez USB. Dla aplikacji zainstalowanej na telefonie musisz upewnić się ,że debuggowanie USB jest włączone. Możesz znaleźć tą opcję jeśli otworzysz Ustawienia , Aplikacje a potem Rozwijanie. Wybierz HelloIOIO w Project Explorerze Eclipse i kliknik zielony przycisk Play na pasku narzędziowym. Kiedy zrobisz to pierwszy raz możesz zobaczyć okno dialogowe podobne do tego : Okno dialogowe Applicaton Type. Wybierz opcję Android Application. Jeśli telefon jest podłączony poprawnie, aplikacja zostanie zainstalowana i uruchomiona na nim , więc możesz rozłączyć się z komputerem i podpiąć pod płytkę IOIO, która powinna być podłączona do zasilania : Hello IOIO. Kliknięcie na przycisk będzie włączało i wyłączało LED na płytce IOIO. Biblioteka IOIO jest bardzo dobrze zaprojektowana i nawet jeśli nie masz dużego doświadczenia w programowaniu , będziesz mógł programować i modyfikować programy. W HelloIOIO są tylko dwa pliki które wykonują całą pracę : MainActivity.java i main.xml. MainActivit.java można znaleźć w src/ioio/eamples. Ten plik zawiera kod, który steruje jedną i tylko jedną Aktywnością w tym projekcie. W Adnroidzie, Aktywność jest pokrewna ekranowi w innych środowiskach. Jeśli spojrzysz na górę tego pliku zobaczysz :
public class MainActivity extends AbstractIOIOActivity
Mówi to nam ,że tworzymy subklasę AbstractIOIOActivity, która będzie implementowała środowisko IOIO poza nami, więc możemy się zająć tą częścią aplikacji , która jest dla niej określona . Plik Java nie ma informacji o tym jak jest ułożony interfejs użytkownika dla tej Aktywności. Jest to przechowywane w szablonie pliku main.xml, przechowywanym w re/layout:
< ?xml version="1.0" encoding="utf-8"? >:
android:orientation="vertical":
android:layout_width="fill_parent":
android:layout_height="fill_parent":
>:
android:layout_width="fill_parent":
android:layout_height="wrap_content":
android:text="@string/hello":
android:id="@+id/title"/>:
android:layout_width="wrap_content":
android:layout_height="wrap_content":
android:id="@+id/button">:
:

Plik XML zawiera znacznik LinearLayout, w którym zawarte są znacznikim TexxtView i ToggleButtons. Zauwaz ,że kontrolki interfejsu użytkownika mają atrybut android: id, który będzie używany w MaonActivity do uzyskania do nich uchwytu. Wróćmy do MainActivity.java. Pierwszą metodą jaką tam napotkamy jest onCreate
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
button_ = (ToggleButton) findViewById(R.id.button);
}
Będzie ona wywoływana kiedy Aktywność jest tworzona. Po wywołaniu onCreate w superklasie, powiąże nasz rozkład z Aktywnością a potem stworzy łącze do zmiennej składowej, która przechowuje referencję do przycisku przełączania. Android jest bardzo wybredny ,jeśli chodzi o to co dzieje się w jego wątku UI W rzeczywistości nie można zrobić niczego, żeby móc zablokować wątek UI, nawet na sekundę lub dwie. Jeśli to zrobisz Android podejmie decyzję ,że aplikacja jest nieodpowiednia i zrzuci śmiertelny wyjątek. Z tego powodu wstawiamy całe przetwarzanie aktywności IOIO do oddzielnej klasy z podklasą ABstractIOIOActivity.IOIOThread :
class IOIOThread extends AbstractIOIOActivity.IOIOThread {
private DigitalOutput led_;
@Override
protected void setup() throws ConnectionLostException {
led_ = ioio_.openDigitalOutput(0, true);
}
@Override
protected void loop() throws ConnectionLostException {
led_.write(!button_.isChecked());
try {
sleep(100);
} catch (InterruptedException e) {
}
}
}
Ta klasaw wymaga zaimplementowania dwóch metod :setup będzie wywoływana kiedy IOIO wykryje , że telefon został podłączony, podczas gdy loop jest wywoływana wielokrotnie i bez określonego czasu. Mamy zmienną składową nazwaną led_ która jest instancją DigitalOutput. Klasa DigitalOutput jest odpowiedzialna za funkcjonalność dotycząc korzystania z pin GPIO jako wyjścia cyfrowego. Sprowadza się to do ustalenia wyjścia na wysokie lub niskie , korzystając z metody write. Metoda setup po prostu ustawia instancję DigitalOutput przechowywaną w zmiennej led_. Pierwszy argument openDigitalOutput jest pinem do użycia - w tym przypadku, pin 0. Patrząc z bliska na płytkę IOIO, zobaczysz ,że nie ma pin 0. Pin 0 jest w rzeczywistości zarezerwowany dla pokładowego LED. Póżniej zmienimy ten przykład dla użycia zewnętrznego LED i zmienimy numer pinu na 46. Drugi argument openDigitalOutput jest stanem początkowym pin, którym w tym przypadku jest prawda, w znaczeniu high lub 3,3V. Patrząc na metodę loop, widzimy ,że wszystko co się wydarzy to to ,że używamy buton_isChecked() dla określenia stanu przycisku przełączania, a ustawienie wyjścia dla pinu LED będzie odwrotnością tego. Wtedy możemy spróbować konstrukcji wokół wywołania sleep. Pętla powinna zawierać sleep aby umożliwić temu wątkowi na ustąpienie i zezwolenie innym wątkom na posiadanie szansy na zrobienie czegoś. Wyjątek ze sleep będzie ignorowany. W samek klasie MainActivity mamy następujący kod, który będzie obecny w każdym projekcie i tworzący watek IOIO:
@Override
protected AbstractIOIOActivity.IOIOThread createIOIOThread() {
return new IOIOThread();
}
Przyłączanie rzeczy do IOIO
Więc teraz możemy podłączyć LED do IOIO z telefonu ,ale w przyszłych projektach będziemy podłączać zewnętrzne komponenty do płytki. To w końcu cel interfejsu płytki. Z pewnością mamy wiele gniazd do których możemy podłączyć rzeczy, ale zanim to zrobimy, musimy wiedzieć trochę więcej o tych połączeniach. Patrząc na zdjęcie płytki można zobaczyć etykiety obok każdego złącza. Na końcu płytki blisko złącza USB, mamy połączenia zasilania:
VIN : napięcie dostarczane między 5 a 15V DC Jest to najlepsze napięcie wejściowe dla płytki
3.3V : 3.3 V regulowane napięcie z regulatora napięcia IC z IOIO
5V : 5V regulowane napięcie z regulatora napięcia IC na IOIO
GND : Uziemienie lub 0V
Płytka IOIO jest zasadniczo płytką 3.3V. To znaczy, wszystkie wejścia i wyjścia są zaprojektowane do pracy przy 3.3 V. Jednak wiele modułów elektronicznych i urządzeń pracuje przy napięciu 5V To dlatego IOIO również dostarcza napięcia 5V a pewne piny mają możliwość podciągnięcia do 5V - ale nie wszystkie. Piny nie powiązane z zasilaniem są ponumerowane sekwencyjnie. Piny te mogą wszystkie być użyte jako pin GPIO lub General Purpose Input Output . To znaczy, kiedy są używane jako wyjścia mogą być ustawione na 3.3V lub 0V (GND) a kiedy są używanej jako cyfrowe wejścia , mogą określać czy napięcie jest powyżej czy poniżej progu napięcia o około 1,5V. Wiele z tych pinów może być wykorzystanych jako wejścia analogowe, wyjścia PWM (rodzaj wyjścia analogowego) i pewne wyjścia tolerujące 5V. Niektóre piny mogą być użyte dla komunikacji TWI (Two Wire Interface) z pewnymi peryferiami. Inne piny mogą być użyte dla komunikacji szeregowej z komputerami, modułami Bluetooth itp. używając jednego z czterech UART′ów (Universal Asynchronous Receiver Transmitters). Oto wykaz tych pinów:
Analogowe : 31-34, 37-46
TWI (data, zegar) : (4,5)(26,25),(47,48)
UART : 3-7, 9-14, 27-32, 34-40, 45-48
Przyjacielskie 5V : 3-7, 10-14, 18-26, 47-48
Aby udowodnić ,że możemy dołączyć zewnętrzną elektronikę do naszego IOIO, dołączmy diodęLED do jednego z pinów a potem zmodyfikujmy Hello IOIO aby jej użyć , zamiast LED wbudowanej w samą płytkę IOIO. Aby to zrobić, potrzebujemy diody i rezystora . Prawie każda dioda i rezystor między 100Ω a 270Ω . Dłuższe odnóże diody to plus. Jest wetknięte w gniazdo w pin 46 na IOIO. Odchyl drugą końcówkę i skręć z jednym wyprowadzeniem rezystora. Wetknij niepołączoną końcówkę rezystora do jednego z gniazdek GND : Dioda w IOIO. Wszystko co pozostało to ponowne połączenie telefonu z komputerem aby zmienić pin LED na 46. Otwórz MainActivity.java w Eclipse i zmień linię:
led_ = ioio_.openDigitalOutput(0,true) ;
na
led_ = ioio_.openDigitalOutput(46, true);
Ponownie zainstaluj aplikację w telefonie i potem podłącz telefon do zasilonego IOIO. Powinieneś teraz móc włączać i wyłączać zewnętrzną diodę LED

Sygnalizacja włamania i napadu
Stworzymy sensor ruchu sygnalizacji włamania i napadu, który wysyła wiadomości tekstowe, kiedy wykryją ruch. Projekt ma kilka komponentów oprócz IOIO. Używa detektora ruchu PIR i rezystora. Tutaj mamy pokazany Interfejs Alarmu Są dwa pola, jedno dla numeru telefonicznego do wysyłania tekstu i jeden dla wiadomości do wysłania kiedy wykryty jest ruch. Pod tymi polami pojawiają się dwa przyciski przełączania. Pierwszy przełącza tryb testowy włącz/wyłącz. Jeśli jest w trybie tekstowym, żadna wiadomość tekstowa nie zostanie wysłana. Wiadomość pojawia się na zamiast tego na chwilę. Drugi przycisk jest oznaczony Run; przyciśnięci rozpoczyna monitorowanie po 10 sekundach, co daje dość czasu aby opuścić pokój.
Sprzęt
Potrzebujemy następujące pozycje : Moduł PIR, 10Ω 0,5W rezystor. Diagram dla projektu mamy pokazany tu : Schemat. Moduł PIR (Passive Infra Red) wykrywa ruch. Kiedy coś jest przed tym czujnikiem, włącza się tranzystor. Wyjście jest nazywane "otartym kolektorem" i wymaga rezystora 10kΩ podłączonego między wyjście a +5V. Wyjście będzie zazwyczaj normalnie przy 5V ,ale spada do 0V kiedy zostanie wykryty ruch. Z tego powodu musimy użyć jednego z pinów tolerancji 5V IOIO (w tym przypadku pin 48). Możemy oczekiwać czarnego przewodu z modułu PIR do GND, ale w rzeczywistości jest to wyjście i brązowy przewód to GND. Ponieważ istnieje kilka połączeń, po prostu wprowadzimy przewody do gniazd. Nie jest to najbardziej niezawodny sposób połączenia przewodów w gnieździe, ale jeśli zalejmy przewody warstwą lutu i umieścimy trochę zagięć w nich, możemy otrzymać bardzo dobre połączenie. Pierwszym krokiem w konstrukcji jest odcięcie gniazda złącza modułu PIR, taśmy u cyny na końcach przewodów. Potem lutujemy czerwony i czarny przewód do końców rezystora : Przygotowanie modułu PIR. Czerwona strona rezystora pójdzie do gniazda +5V, czarna do gniazda do pinu 48 a brązowy przewód do jednego z gniazd GND : Przygotowanie modułu PIR ,gdzie możesz również zobaczyć przewód zasilający. To wszystko jeśli chodzi o przygotowanie sprzętu. Teraz zajmijmy się oprogramowaniem
Oprogramowanie
Większość środowiska dla tej aplikacji jest podoba do tego z przykładu HelloIOIO , z poprzedniej części, więc skupimy się na kodzie związanym z czujnikiem PIR
protected void setup() throws ConnectionLostException {
pir_ = ioio_.openDigitalInput(48, Mode.FLOATING);
led_ = ioio_.openDigitalOutput(0);
}
Metoda setup otwiera wejście cyfrowe na pinie 48 dla czujnika PIR cyfrowe wyjście dla wbudowanej na IOIO diody LED. Dioda będzie migać przy wystąpieniu ruchu. Kiedy otworzymy cyfrowe wejście używając openDigitalInput,. dostarczymy dwóch argumentów, Pierwszym jest pin do otwarcia, a drugim określony tryb. Tryby jakie mamy to Mode.FLOATING, Mode.PULL_UP lub Mode.PULL_DOWN. Uzyjemy FLOATING ponieważ wbudowane rezystory które mogą być przypisane PULL_UP i PULL_DOWN są zbyt słabe dla czujnika PIR i musimy użyć rezystora zewnętrznego
protected void loop() throws ConnectionLostException {
boolean wasMovement = false;
try {
wasMovement = ! pir_.read();;
} catch (InterruptedException e1) {
e1.printStackTrace();
}
led_.write(! wasMovement); // LED false = on
if (wasMovement) {
movementCount ++;
}
long now = System.currentTimeMillis();
if (now > lastTime + 1000) {
// every second
lastTime = now;
if (movementCount > 50) {
if (now > startTime_ + 10000 && runButton_.isChecked()) {
handleAlarm();
}
}
movementCount = 0;
}
try {
sleep(10);
} catch (InterruptedException e) {
}
}
Wbudowana dioda LED jest łudząco prowadzona w taki sposób ,że kiedy wyjście jest ustawione na fałsz, włącza się, a kiedy jest ustawiona naprawdę, wyłącza. Czujnik PIR jest bardzo wrażliwy . a nie chcemy zbyt wielu fałszywych alarmów. Tak więc, zamiast wyzwalać alarm za każdym razem kiedy czujnik PIR wykrywa ruch, rozważamy czy będzie to alarm tylko jeśli istnieje więcej niż 50 takich zdarzeń na 100 razy, jakie sprawdzamy na sekundę. Aby to zrobić użyjemy zmiennych składowych : lastTime i movementCount. Zmienna lastTime jest długości integer i jest przypisywana do oststniego razu kiedy licznik był sprawdzany. Możemy użyc long integer dla reprezentowania czasu, ponieważ System.currentTimeMillis() może zwrócić nam czas systemowy w milisekundach. Poniższa linia określają czy cała sekunda minęła od czasu ostatniego sprawdzenia
if (now > lastTime + 1000) {
. Jeśli jest to co najmniej sekunda, kiedy testowaliśmy aby zobaczy czy upłynęło 10 sekund od naciśnięcia przycisku Run (za pmocą inne zmiennej składowej startTime), i że przycisk Run został sprawdzony. Jeśli wszystko to jest prawdą, wywołujemy handleAlarm
private void handleAlarm() {
if (testButton_.isChecked()) {
toast("Test Mode, no SMS sent");
}
else {
sendSMS();
}
runOnUiThread(new Runnable() {
@Override
public void run() {
runButton_.setChecked(false);
}
});
}
Metoda handleAlarm decyduje czy wysłać rzeczywistą wiadomość tekstową lub uczynić tylko powiadomienie w zależności od stanu testButton. Kiedy alarm został wyzwolony, przycisk Run jest odznaczony dla zabezpieczenia przed dalszym wyzwalaniem i wiadomością tekstową. Kod dla odznaczenia przycisku używa polecenia runOnUiThread. Jednym z udoskonaleń aplikacji jest to ,że pamięta numer telefonu i wiadomość do wysłania nawet po wyjściu z aplikacji. Czyni to za pomocą mechanizmu właściwości Androida. W metodzie onCreate, jak również zwykłym przypisaniu kontrolek interfejsu użytkownika pamiętamy zmienne, również ustawiamy ich domyślne wartości:
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
sms_ = (TextView)findViewById(R.id.sms);
message_ = (TextView)findViewById(R.id.message);
testButton_ = (ToggleButton)findViewById(R.id.testButton);
testButton_.setChecked(true);
runButton_ = (ToggleButton)findViewById(R.id.runButton);
sms_.setText(settings.getString("sms", ""));
message_.setText(settings.getString("message", "Something Moved!"));
runButton_.setOnCheckedChangeListener(this);
}
Poniższa linia odzyskuje ustawienia obiektu dla aplikacji:
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
Wtedy wartości pojedynczych ustawień mogą być odzyskane przy użyciu następującej składni, gdzie pierwszym argument jest nazwą ustawienia a drugi jest wartością domyślną jeśli nie znaleziono wartości:
message_.setText(settings.getString("message", "Something Moved!"));
Ustawienia są w rzeczywistości zapisywane kiedy jeden z przycisków przełączania zmienia stan w programie obsługi onCheckedChanged:
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
if (isChecked) {
toast("Masz 10 sekund zanim czujnik zadziała");
startTime_ = System.currentTimeMillis();
}
SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);
SharedPreferences.Editor editor = settings.edit();
editor.putString("sms", sms_.getText().toString());
editor.putString("message", message_.getText().toString());
editor.commit();
}
Ta metoda jest również odpowiedzialna za ustawienia znacznika czasu w zmiennej składowej startTIme dla usunięcia aktywacji alarmu

Rejestrator temperatury Bluetooth
Rejestrator temperatury jest najprostszym z naszych projektów . Bardzo łatwo go wykonać i nie ma nic do lutowania. Czujnik temperatury jest małym 3-pinowy układem, który po prostu wkładamy do gniazd na IOIO. Oprogramowanie sterujące pobiera temperaturę odczytując co 10 sekund i zapisując na karcie SD telefonu. Wyświetla również bieżącą temperaturę w stopniach. Kiedy chcemy odzyskać zebrane dane, możesz po prostu użyć funkcji pamięci masowej USB z telefonu do przesyłania plików na komputer. Dane są przechowywane w formacie CSV tak aby można je było importować do arkusza kalkulacyjnego. Co więcej, możemy wykorzystać moduł Bluetooth USB dołączonego do portu USB na IOIO dla bezprzewodowej komunikacji z telefonem. Jeśli nie chcesz Bluetooth, możesz po prostu dołączyć telefon do IOIO w ten sam sposób jak w naszym pierwszym projekcie.
Sprzęt
Oprócz IOIO, będziesz potrzebował poniższych pozycji : TMP35, adaptera USB Bluetooth . Lista IOIO Over Bluetooth urządzeń , które można przetestować znajduje się tu : [https://github.com/ ytai/ioio/wiki/IOIO-Over-Bluetooth]. Diagram dla projektu mamy tu : Diagram . Czujnik TMP36 używa niewielkiej ilości prądu, więc podłączamy go bezpośrednio do IOIO, możemy użyć dwóch gniazd GPIO dostarczających +3.3V i połączenia GND , które jest konieczne. Jego wyjścia będą podłączone do pinu 45, który jest używany jako wejście analogowe. Napięcie na tym wejściu będzie proporcjonalne do temperatury, a więc odczyt analogowy może być skonwertowany od temperatury przy pomocy matematyki. Umieszczenie nieznacznych zagięć w przewodach zapewni dobre połączenie z gniazdem. Na rysunku widać czujnik temperatury dołączony do gniazd 44 do 46 : Podłączenie czujnika temperatury . Upewnij ,że masz urządzenie w odpowiednim kierunku, z zakrzywionymi bokami w kierunku środka płytki. Adapter Bluetooth USB jest po prostu wciśnięty w gniazda USB
Ustawienie
Możesz pobrać aplikację ze strony internetowej, gdzie znajdziesz również kod źródłowy : http://www.ioiobook.com. Zainstaluj aplikację i podłącz zasilanie do płytki IOIO. Dla pracy łącza Bluetooth, musisz sparować adapter Bluetooth z IOIO z telefonem.Aby to zrobić, otwórz Ustawienia na twoim telefonie, i wybierz "Sieci bezprzewodowe i Sieci", potem "Ustawienia Bluetooth". Powinoo to uruchomić telefon dla wyszukiwania urządzeń, po czym powinieneś zobaczyć listę : Poszukiwanie dla IOIO przez Bluetooth . Wybierz urządzenie IOIO z listy i zostanie wyświetlony monit do pary z urządzeniem : Monit . Wpisz PIN 4554. teraz , kiedy uruchomisz aplikację, zobaczysz wyświetloną aktualną temperaturę . Jeśli klikniej na przycisku Logging, wtedy co 10 sekund temperatura będzie zapisywana do pliku na karcie SD telefonu. Plik będzie nazwany temp. Plik jest zapisywany w formacie CSV tak ,że można go otworzyć bezpośrednio w akruku kalkulacyjnym.
Oprogramowanie
Większość tego kodu jest podobna to tego z systemu napadowego i włamaniowego, więc tylko kilka rzeczy zostanie podkreślonych. Po pierwsze , jest funkcjonalność USB. Biblioteki IOIO są napisane w taki sposób ,że nie ma dosłownie żadnego kodu do napisania aby aplikacja pracowała z Bluetooth. Oznacza to ,że możemy wykonać wszystkie nasze projekty z Bluetooth zamiast USB, bez zmiany linijki kodu. Cóż nie jest to do końca prawda, ponieważ kolejny przykład opiera się na możliwości szybkiego włączania i wyłączania pinów, a Bluetooth nie jest wystarczająco szybki. Kod wart podkreślenia w tym projekcie, jest to ,że używamy do zapisania kartę SD. Metoda która to wykonuje jest nazwana appendToFile :
private void appendToFile(String filename, String line) {
File root = Environment.getExternalStorageDirectory();
try {
FileOutputStream f = new FileOutputStream(new File(root, filename),
true);
f.write(line.getBytes());
f.close();
} catch (Exception e) {
toast(e.getMessage());
}
}
Otwiera ona plik w trybie dołączania (tworzenie go jeśli nie istnieje) a potem dodaje linię sformatowaną z czasem, odczyt temperatury, i jednostki (F lub C). Dla tego, poniższa zgoda będzie dodana do pliku manifestu projektu . AndroidManifest.xml:
android:name="android.permission.WRITE_EXTERNAL_STORAGE">


Macierz LED
Będziemy korzystać z wielokolorowek macierzy LED aby stworzyć zabawną ładowarkę dla telefonu z Androidem : Macierz LED .W tym przypadku "zabawna" przybiera formę animacji maszerujących Space Invaders. Projekt posiada wiele różnych trybów : można wyświetlić obraz statyczny lub animację, lub skorzystać z mikrofonu telefonu aby zapewnić wyświetlanie typu widma. Jeśli uruchomimy odtwarzacz muzyczny na telefonie przed startem naszego projektu , będzie reagować na dźwięki dobiegające z telefonu. To jedyny nasz projekt, który będzie używał Bluetooth zamiast USB.
Projekt
W tym projekcie płytka IOIO używa 24 swoich pinów do sterowania macierzą LED, Wymaga 24 pinów ponieważ macierz LED jest ułożona w siatkę LED. Każda komórka w macierzy w rzeczywistości ma diody LED w sobie, jedną zieloną i jedną czerwoną. Są używane do ustawienia kolorów pojedynczej komórki na czerwony, zielony lub jeśli oba kolory są włączone równocześnie - na pomarańczowy.
Schemat Schemat macierzy
Anody diod LED są sterowane przez pin GPIO na IOIO. Każda ma szeregowy rezystor dla ograniczania prądu. Ponieważ 8 diod LED współdzieli wspólne uziemienie katody, mógłby popłynąć zbyt duży prąd do pinu GPIO. używane są tranzystory MOSFET dla przełączania każdej kolumny. Bramka każdego tranzystora jest połączona bezpośrednio z pinem GPIO
Diagram przewodów
Projekt jest budowany na fragmencie płytki prototypowej (stripboard). Jest to rodzaj płytki z równoległymi ścieżkami miedzianymi po jednej stronie płytki . Komponenty są układane od góry i przylutowywane od dołu. Na jednej strone płytki jest zbiór pinów zaprojektowanych dla akceptacji płytki IOIO z dołączonymi gniazdami. Płytka IOI będzie odwrócona do góry nogami nad gniazdami. Druga strona zawiera gniazda w których umieszczana jest macierz LED. Zaciski VIN i GND są używane do uproszczenia procesu dostarczania zasilania do projektu.
Konstrukcja
Będziemy potrzebowali następujących komponentów : 8x8 Dwukolorową macierz LED, MOSFET 2N7000, rezystor 100Ω 0,5 W, taśma gniazd SIL, piny SIL, blok zacisków śrubowych , stripboard 28 taśm , każda a 53 otworami
Krok 1. Przygotowanie płytki prototypowej
Pierwszym krokiem jest przycięcie płytki do odpowiednich rozmiarów. Najlepszym sposobem wykonania tego jest użycie ostrego noża prowadzić linię przez otwory na linii poniżej ostatniej taśmy lub kolumny, a potem przełamać płytkę na brzegu biurka. Bądź ostrożny. Następne należy przełamać ścieżkę w pozycji wskazywanej przez X : Rozkład stripboard. Otwory wywiercone w płytce. Zauważysz ,że lepiej pracować z pierwszą z nich. Kiedy wykonasz wszystkie otwory, wróć do inspekcji każdego starannie, aby upewnić się ,że nie pozostały ślady miedzi, gdyż mogą one powodować zniszczenie IOIO. W razie wątpliwości można użyć multimetru w trybie ciągłości ,aby upewnić się , że nie ma przerw.
Krok 2.Podłączenie przewodów
Miedziane ścieżki na dole będą utrzymywać nasze komponenty i tworzyć połączenia. Jednak jest wiele połączeń jakie musimy utworzyć za pomocą przewodów. Dłuższe przewody powinny być wykonane z przewodu izolowanego a krótsze , mogą wykorzystać goły drut. Wykorzystaj obrazek Rozkładu stripboard , jako odniesienia, lutując przewody na swoich miejscach. Zauważ ,że nie jest to szybkie zadanie, co najmniej godzina. Nie daj się skusić lutowaniu najpierw pinów. Najpierw przewody potem piny. Kiedy wszystkie przewody będą na miejscu, płytka powinna wyglądać tak : Stripboard z przewodami
Krok 3. Podłączanie rezystorów
Kolejnym krokiem jest dołączanie rezystorów. Kiedy będą na swoich miejscach, płytka powinna wyglądać tak : Stripboard z rezystorami
Krok 4. Dołączenie syków
Można łatwiej dopaspac wtyki do IOIOi gniazd na macierzy LED przez dopasowanie komponentów na styków przed wprowadzeniem ich we właściwe pozycje na płytce. Dwukrotnie sprawdź czy wszystko jest w porządku, ponieważ trudniej je wylutować. Jeśli styki nie są odpowiedniej długości, będziesz musiał przyciąć je. Podczas przycinania gniazd, zazwyczaj oznacza to rezygnację z jednego gniazd połączeniowych, więc przycinaj gniazda według potrzebnych numerów zamiast próbować i ciąć między gniazdami. Płytka powinna wyglądać tak : Stripboard ze stykami
Wstawianie MOSFET′ów
Ostatnie komponenty jaki dodajemy do płytki to tranzystory MOSFET. Oto wygląd płytki z tranzystorami : Stripboard z tranzystorami
Krok 6. Zasilanie i IOIO
To prawie cały sprzęt. Pozostaje przylutować terminal śrubowy dla zasilania, a potem dołączyć macierz LED i IOIO : Full stripboard
. Przylutuj blok zacisku śrubowego na pierwszym miejscu oznacza górne połączenie przez + aby zredukować szanse na odwrotne połączenie zasilania.
Oprogramowanie
Kluczem tego projektu jest możliwość odświeżania bardzo szybko. Jest to wszystko opakowane w łańcuch metod w MainActivity.java , który zaczyna się z refreshMatrix :
private void refreshMatrix() throws ConnectionLostException {
for (int col = 0; col < 8; col++) {
clearPreviousColumn(col);
displayColumn(col);
delay(3);
}
}
Tu iterujemy po każdej kolumnie, zerując jej poprzednie ustawienia, wyświetlając nową kolumnę, a potem oczekując 3 milisekundy :
private void clearPreviousColumn(int col) throws ConnectionLostException {
int columnToClear = col - 1;
if (columnToClear == -1)
{
columnToClear = 7;
}
cc[columnToClear].write(false);
for (int row = 0; row < 8; row++) {
r[row].write(false);
g[row].write(false);
}
}
Usuwanie poprzedniej kolumy jest kwestią znalezienia kolumny przed bieżącą, w tym zawijanie. Wtedy wyłączamy kolumnę katody na macierzy LED dla wspomnianej kolumny a potem wyłączamy czerwone i zielone anody dla 8 wierszy:
private void displayColumn(int col) throws ConnectionLostException {
cc[col].write(true);
for (int row = 0; row < 8; row++) {
r[row].write((display_[col][row] & 1) > 0);
g[row].write((display_[col][row] & 2) > 0);
}
}
Wyświetlenie nowej kolumny obejmuje włączenie właściwej kolumny katod macierzy LED, a potem ustawienie czerwonych i zielonych anod zgodnie z bieżącą kolumna tablicy kolorów 2D przechowywanej w zmiennej składowej display_, która wygląda mniej więcej tak :
private int[][] testPattern1_ = {
{1,1,1,1,1,1,1,1},
{1,2,2,2,2,2,2,2},
{1,2,3,3,3,3,3,3},
{1,2,3,1,1,1,1,1},
{1,2,3,1,2,2,2,2},
{1,2,3,1,2,3,3,3},
{1,2,3,1,2,3,1,1},
{1,2,3,1,2,3,1,2}
};
Liczba 0 oznacza wyłączenie obu diod, 1 - włączenie czerwonej diody, 2 - włączenie zielonej diody, 3 - włączenie obu diod (pomarańczowe). Wszystko w tej aplikacji , w tym animacja, jest kwestią przypisania display_ do innej tablicy 2D w każde pół sekundy. Klatki tej animacji są definiowane w oddzielnym pliku klasy, która jest również odpowiedzialną dla dostarczanie wartości (frameDelay) w czasie między klatkami w milisekundach:
package com.ioiobook.matrix;
public class TestAnimation {
public final static int frameDelay = 500;
public final static int[][][] animation = {
{ //1
{0,0,1,1,1,1,0,0},
{0,1,1,1,1,1,1,0},
{1,1,2,1,1,2,1,1},
{1,1,1,1,1,1,1,1},
{0,0,3,0,0,3,0,0},
{0,0,3,0,0,3,0,0},
{0,0,3,0,0,3,0,0},
{0,0,0,0,0,0,0,0}
},
{ //2
{0,0,0,0,0,0,0,0},
{0,0,1,1,1,1,0,0},
{0,1,1,1,1,1,1,0},
{1,1,2,1,1,2,1,1},
{1,1,1,1,1,1,1,1},
{0,0,3,0,0,3,0,0},
{0,3,0,0,0,0,3,0},
{0,0,3,0,0,3,0,0}
},
Wyświetlenie widma wymaga użycia innej biblioteki open source , zamkniętej w klasie (SpectrumDrawer.java)
public class SpectrumDrawer {
private float gain_ = 1000000.0f;
private int[][] displayArray_;
private Window win_;
private FFTTransformer spectrumAnalyser_;
private int historyIndex_;
private float[] average_;
private float[][] histories_;
private final int[] frequencies_ = { 2, 4, 6, 10, 15, 25, 55, 80 };
private final int[] colors_ = { 2, 2, 3, 3, 3, 1, 1, 1 };
public SpectrumDrawer(int[][] display) {
displayArray_ = display;
win_ = new Window(MainActivity.AUDIO_BUFFER_SIZE,
Window.Function.BLACKMAN_HARRIS);
spectrumAnalyser_ = new
FFTTransformer(MainActivity.AUDIO_BUFFER_SIZE, win_);
average_ = new float[MainActivity.AUDIO_BUFFER_SIZE / 2];
histories_ = new float[MainActivity.AUDIO_BUFFER_SIZE / 2]
[MainActivity.AUDIO_BUFFER_SIZE / 2];
}
public void calculateSpectrum(short[] buffer) {
spectrumAnalyser_.setInput(buffer, 0,
MainActivity.AUDIO_BUFFER_SIZE);
spectrumAnalyser_.transform();
historyIndex_ = spectrumAnalyser_.getResults(average_, histories_,
historyIndex_);
for (int c = 0; c < 8; c++) {
int resultIndex = frequencies_[c];
int power = (int) (Math.log(average_[resultIndex] * gain_));
Log.d("SRM", "" + power);
if (power > 7)
power = 7;
for (int r = 0; r < 8; r++) {
if (power > r) {
displayArray_[7 - r][c] = colors_[r];
} else {
displayArray_[7 - r][c] = 0;
}
}
}
}
}
Kiedy zostaje wywołana metoda calculateSepctrum, ma zastosowanie Szybka Transformacja Fouriera (FFT)dla próbki audio z mikrofonu telefonu. FFT jest użyta dla pobrania próbki pliku audio i znalezienia względnego rozmiaru każdej z częstotliwości tworzących dźwięk. Stworzy się tablica mocy zakresu częstotliwości. Możemy wybrać częstotliwości i wykorzystać jem aby ustawić kolory wyświetlacza matrycowego. Wymagana jest tablica history_ z innej biblioteki aby dostarczyć uśrednione wyniki FFT. Dla każdej kolumny, wyświetlimy numer LED w wierszu równym mocy. Aktualny kolor każdego światła LED jest określany przez tablice color_. Aby wypełnić SpectrumDrawer nowymi danymi, oddzielny wątek jest uruchamiany w metodzieonCreate klasy MainActivity:
AudioReader.Listener listener = new AudioReader.Listener()
{
@Override
public void onReadComplete(short[] buffer) {
spectrumDrawer_.calculateSpectrum(buffer);
}
@Override
public void onReadError(int error) {
}
};
audioReader_ = new AudioReader();
audioReader_.startReader(F, AUDIO_BUFFER_SIZE, listener);
Ten wątek jest hermetyzowany w klasie AudioReader, z biblioteki org.hermit





Statystyka generowana przez Reggi-Stat - www.reggi.pl