Sterowanie Arduino z Androida przez USB. Sześć łatwych sposobów podłączenia Arduino do Androida. Tworzenie aplikacji na Androida

💖 Podoba Ci się? Udostępnij link swoim znajomym

Od jakiegoś czasu Google umożliwia podłączenie urządzeń z Androidem przez USB do różnych mikrokontrolerów, otwierając API. Teraz wszyscy, którzy zajmują się tworzeniem różnych projektów na Arduino, mogą się cieszyć, ponieważ teraz znacznie łatwiej będzie debugować system Android Arduino i w zasadzie regulować ich interakcję.

Zaczęliśmy już przybliżać czytelnikom możliwości połączenia mikrokontrolera ze smartfonem – patrz.

Ale już wcześniej różne moduły umożliwiały łatwą interakcję Androida i Arduino. Zastanówmy się, jak wdrożyć projekt, który będzie sterowany ze smartfona i co jest do tego potrzebne.

Gdzie mogę wykorzystać połączenie Androida z Arduino?

Przede wszystkim trzeba pomyśleć o tym, jak wykorzystać możliwość przesyłania sygnału z Androida do Arduino. Przecież przed przestudiowaniem jakichkolwiek materiałów każdy rozsądny człowiek powinien zrozumieć, dokąd go to ostatecznie doprowadzi. Nawet jeśli mówimy o hobby. Rzeczywiście, możliwość sterowania sprzętem ze smartfona już dawno przestała być postrzegana jako coś niezwykłego. Obecnie większość telewizorów, lodówek, a nawet odkurzaczy kupowanych przez klasę średnią ma możliwość przesyłania danych do smartfona.

To rozwiązanie pozwala znacznie uprościć życie przeciętnego człowieka, ponieważ do tego samego telewizora nie trzeba ciągle kupować baterii do pilota i szukać ich, jeśli się zgubią. Jesteśmy coraz bliżej cenionych inteligentnych domów, jednak część osób woli nie kupować takiego sprzętu, tylko zaprojektować go samodzielnie.

W tym przypadku pakiet Android Arduino należy rozpatrywać w dwóch wariantach:

  1. Zdalne sterowanie dowolnym urządzeniem za pomocą smartfona. Nazywa się to również połączeniem smartfon-MK. Cały ten sam sprzęt, np. rolety przesuwne czy oświetlenie w pomieszczeniu, które wyłączymy jednym kliknięciem. Jeśli chcesz zrobić to drugie, nie ma potrzeby zmiany okablowania ani kupowania specjalnych inteligentnych lamp, które mogą przepalić się po miesiącu. Wystarczy zakupić niewielki mikrokontroler Arduino, moduł komunikacji bezprzewodowej z Internetem lub Bluetooth oraz taśmę elektryczną. Po czym wystarczy przylutować najprostszy obwód, który zamyka się, jeśli sygnał zostanie wysłany do MK.
    Sygnał ten zostanie wysłany z Twojego telefonu, zamknij styki, a lampka zacznie się świecić. Aby uniknąć problemów i dla dodatkowego bezpieczeństwa domu, możesz napisać skrypt, który automatycznie otworzy obwód, jeśli urządzenie sterujące zostanie usunięte z pola widzenia. Zwykłe przełączniki będą nadal działać, ale tylko wtedy, gdy obwód zostanie zamknięty.
  2. Przesyłanie danych w celach informacyjnych lub komunikacji MK-Smartphone. Tutaj nie kontrolujesz już niektórych urządzeń, ale wręcz przeciwnie, różne urządzenia pozwalają odbierać określone dane na smartfonie. Pierwsze co przychodzi na myśl i najprostsze zastosowanie to czujnik ruchu. Moduł ten występuje w standardowych czujnikach dla mikrokontrolerów Arduino; jego zakup nie będzie stanowił problemu, podobnie jak montaż w przejściu. Następnie pozostaje tylko napisać kod, podobny do tego, który istnieje już na wielu anglojęzycznych forach, który wysyła SMS-a lub wiadomość w sieciach społecznościowych, a także specjalne narzędzie, jeśli ktoś przekroczy wiązkę podczerwieni.
    Możesz stworzyć bardziej złożone i zautomatyzowane systemy, które będą nie tylko przesyłać medialne informacje o Twoim mieszkaniu, ale także raportować, czy w Twojej domowej szklarni dojrzewają warzywa lub owoce. Wszystko zależy wyłącznie od wyobraźni samego inżyniera, jednak podstawa technologii pozostaje ta sama – przesyłanie danych z jednego urządzenia na drugie.

Wybrałeś więc odpowiedni projekt i przystąpiłeś do jego realizacji. Moduły i mikrokontrolery zostały już zamówione, a gdy są w drodze, można przystąpić do tworzenia oprogramowania. Przecież nagi Android nie wchodzi w interakcję z Arduino za pomocą magii.

Aplikacje na Androida umożliwiające interakcję z Arduino

Nie będziemy rozwijać narzędzia od zera, bo to nie jest podstawa do programowania w Javie. Najłatwiej jest skorzystać z gotowych silników i środowisk z interfejsem użytkownika, gdzie wystarczy dosłownie dodać tylko 1-2 linijki kodu przycisku, aby zaczął działać. Naturalnie takie podejście znacznie ogranicza funkcjonalność finalnego produktu i nieuchronnie osłabia kreatywność, ale przyda się tym, którzy chcą szybko i bez zbędnych problemów zrealizować prosty projekt.

Na początek przyjrzyjmy się trzem podstawowym plikom, które napotkasz podczas projektowania programu:

  1. MainActivity.java to cały kod aplikacji w języku o tej samej nazwie; wszystkie napisane przez Ciebie funkcje i metody są tutaj zapisywane.
  2. Activity_main.xml – układ, jak łatwo się domyślić po rozszerzeniu pliku. Tutaj przechowywana jest lokalizacja przycisków, tekstu i innych elementów interaktywnych, które następnie są ożywiane w kodzie.
  3. AndroidManifest.xml – ten plik również dotyczy układów, ale w nieco innym obszarze. Definiuje podstawowe parametry uruchomienia aplikacji oraz potrzebne jej uprawnienia. W naszym przypadku jest to konieczność włączenia Bluetootha, gdyż za jego pośrednictwem będziemy komunikować się z MK. Jeśli tworzysz czujnik, który musi przesyłać informacje na dużą odległość, należy odpowiednio włączyć i sprawdzić działanie bezprzewodowego lub mobilnego Internetu.

Podstawy odbioru i transmisji danych

Aby zrozumieć, jak ogólnie będzie działać Twój przyszły projekt, warto przestudiować podstawową fizykę pól elektromagnetycznych. Aby jednak nie przeciążać niepotrzebnymi informacjami, wystarczy zrozumieć, że dziś przesyłanie danych odbywa się na trzy główne sposoby:

  1. Za pomocą kabla USB, który nie wszędzie się nadaje, ale jest dobrą opcją do skonfigurowania projektu.
  2. Na przykład poprzez Bluetooth i powiązane protokoły ostatnio popularne stało się używanie systemu plików NTFS do sterowania urządzeniami inteligentnymi. Ponieważ jednak mówimy o projekcie na Arduino MK, skupimy się na bluetooth.
  3. Przez bezprzewodowy internet. Nie ma tu nic nowego; w zasadzie Twój telefon komórkowy lub mikrokontroler pełni rolę serwera, który odbiera i przetwarza otrzymane dane, a następnie wykonuje obliczenia lub działania i wysyła odpowiedź.

Oto główne metody przesyłania i odbierania informacji, wystarczy wybrać odpowiednią. W przypadku projektów, które nie będą używane na duże odległości, najlepszą opcją pod względem objętości kodu i łatwości konfiguracji jest Bluetooth.

Jakie komponenty mogą być wymagane do interakcji?

Wspominaliśmy już powyżej, że dla projektu na Arduino, który zakłada wykorzystanie jednej z metod transmisji danych na odległość, konieczny jest zakup dodatkowych modułów. Ponownie, Bluetooth jest najlepszym wyborem. Moduł ten umożliwia odbieranie i wysyłanie sygnałów o określonej częstotliwości, które są odbierane przez większość smartfonów, w związku z czym nie powinny pojawić się żadne problemy. Możesz wybrać jedno z urządzeń prezentowanych w głównej linii Arduino lub chińskie odpowiedniki, które będą znacznie tańsze.

Jednym z modułów, który możesz zabrać jest Bluetooth Bee, który można kupić w wielu sklepach, od firmy DFRobot.

Wszystko zależy od konkretnego systemu i wymaganej w nim „przepustowości”. W końcu, jeśli jest to kamera do monitoringu wideo, strumień danych musi być przesyłany w sposób ciągły i w dużych ilościach. A do prostego czujnika ruchu wystarczy najtańszy moduł Wi-Fi. Podobnie jest w przypadku zautomatyzowanych urządzeń inteligentnego domu.

Wybierając każdy komponent, weź pod uwagę swoje potrzeby i to, co zamierzasz wdrożyć w projekcie, i nie przepłacaj za funkcje, których nie potrzebujesz.

Konfiguracja połączenia

Tak więc, teraz stworzyłeś i już zainstalowałeś aplikację lub jej gotowy odpowiednik na swoim smartfonie do sterowania mikrokontrolerem za pomocą Arduino, musisz:

  1. Włącz sam moduł Bluetooth w systemie, zasilając go z sieci lub akumulatora.
  2. Uruchom aplikację na swoim telefonie i znajdź żądane urządzenie.
  3. Połącz się z modułem Bluetooth używając hasła domyślnego lub tego, które ustawiłeś podczas flashowania Arduino.
  4. Wydaj pierwsze polecenia i zobacz jak system na nie zareaguje.

Warto w tym miejscu wspomnieć, że w Google Play znajduje się wiele aplikacji dla Arduino, w kolejnym materiale pokażemy 7 z nich.

Najprostszy przykład

Abyś wiedział w przybliżeniu jak powinien funkcjonować gotowy projekt, podamy przykład zastosowania tego samego dodatku do Twojej lampy.

  1. Z systemem łączysz się za pomocą smartfona.
  2. Naciskasz jeden przycisk, a obwód otwiera się lub zamyka.
  3. Światło pojawia się lub znika.
  4. Naciśnij ponownie przycisk na smartfonie, a efekt będzie odwrotny.

Naturalnie, aby to zrobić, należy najpierw zamknąć obwód, włączając żarówkę za pomocą przełącznika ściennego. Ale to tylko warunkowy przykład tego, co można zrealizować za pomocą tej technologii.

W nadchodzących lekcjach bardziej szczegółowo omówimy interakcję smartfonów i mikrokontrolerów i razem z Tobą przeprowadzimy kilka przydatnych lekcji.

W tym samouczku dowiesz się, jak używać modułu Bluetooth i aplikacji MIT do utworzenia bezprzewodowego połączenia szeregowego pomiędzy telefonem z systemem Android a płytką Arduino. W tym artykule opisano, jak się połączyć, napisać szkic Arduino, który może przyjmować i wysyłać podstawowe polecenia oraz jak samodzielnie stworzyć aplikację. Zakłada się, że znasz już część podstaw, wykonałeś kilka projektów arduino i znasz arduino IDE. Jeśli próbowałeś komunikacji szeregowej z płytką Arduino, wszystko powinno być całkowicie jasne. Jeśli masz jakieś problemy lub pytania, możesz je zadać na stronie dyskusji.

O CZYM JEST ARTYKUŁ?

działania

1. Użyj poniższego kodu dla arduino

Możesz to zmienić. Ważnym aspektem jest tutaj szybkość transmisji - upewnij się, że jest ona zgodna z szybkością transmisji twojego modułu - sprawdź arkusz danych lub użyj w tym celu poleceń AT.

  • stała int ledPin = 2; // pin, do którego podłączona jest dioda LED, do bajtu serialA; void setup() ( // zainicjuj komunikację szeregową: Serial.begin(19200); //szybkość transmisji — upewnij się, że jest zgodna z szybkością modułu, który posiadasz: // zainicjuj diodę ledPin jako wyjście: pinMode(ledPin, OUTPUT) ; ) void pętli() ( if (Serial.available() > 0) (serialA = Serial.read();Serial.println(serialA);) przełącznik (serialA) (przypadek 1: digitalWrite(ledPin, HIGH); przerwa ; przypadek 2: digitalWrite(ledPin, LOW); przypadek 3: digitalWrite(ledPin, WYSOKI);

2. Jeśli chcesz tylko pobrać aplikację i zobaczyć, jak działa

pobierz aplikację, a następnie pobierz ją na swój telefon. Można go pobrać pod adresem -> https://drive.google.com/folderview?id=0B_PfPoEotOF8N2JwT3RSX011SjQ&usp=sharing. Twój telefon musi umożliwiać instalację aplikacji z zewnętrznych źródeł.

3. Jeżeli chcesz zmienić aplikację przejdź do


  • http://appinventor.mit.edu/explore/learn.html, aby dowiedzieć się, jak przygotować komputer i zainstalować oprogramowanie dla twórców aplikacji. Kiedy już wszystko zaczniesz działać, wykonaj co najmniej jedną lub dwie główne lekcje. Poniżej znajduje się zastosowana tutaj aplikacja. Możesz przesłać go do App Inventor, a następnie pobrać na swój telefon lub zmodyfikować. https://drive.google.com/folderview?id=0B_PfPoEotOF8N2JwT3RSX011SjQ&usp=sharing

Rzeczy, których będziesz potrzebować

  • płyta Arduino
  • moduł szeregowy bluetooth (w artykule wykorzystano moduł btm222 z wbudowanym regulatorem)
  • Jedyną problematyczną częścią jest moduł Bluetooth. W całym Internecie dostępne są różne moduły, więc sprawdź dane wyjściowe w posiadanym arkuszu danych, ponieważ mogą się różnić. Należy również pamiętać, że istnieją dwie ogólne klasy modułów Bluetooth: Klasa 1 ma zasięg około 100 metrów. Klasa 2 ma zasięg około 10 metrów. Jeśli zastanawiasz się, czy są one w pełni kompatybilne i możesz uzyskać 100 m tylko wtedy, gdy oba urządzenia obsługują ten zasięg
  • Zastosowany tutaj moduł szeregowy Bluetooth ma następujące styki od lewej do prawej (masa, RX, TX, niepodłączony, VCC). Oczywiście masa i VCC idą odpowiednio do masy i pinu + 5V na arduino. Ponieważ będziemy odbierać dane przez moduł, a następnie wysyłać je do płytki Arduino, wystarczy użyć pinu TX w module. Poprowadź przewód od tego pinu do wyjścia RX na płycie Arduino. Sterowanie diodą LED odbywa się za pomocą kodu PIN 2 w Arduino.
  • Dioda LED
  • rezystor (100 omów)
  • przewody
  • deska do pieczenia chleba

  • Jeśli jesteś początkującym, ten samouczek może być dla Ciebie nieco trudny. Jeśli nigdy nie próbowałeś komunikacji szeregowej z płytką Arduino lub przynajmniej nie wykonałeś większości przykładowych szkiców Arduino, skorzystaj z kilku łatwiejszych samouczków i wróć do nich później.

W tym artykule szczegółowo opisano tworzenie małej aplikacji na mobilny system operacyjny Android oraz szkic dla Arduino. Arduino Uno będzie wyposażone w nakładkę Wireless Shield z modułem Bluetooth. Aplikacja połączy się z modułem Bluetooth i wyśle ​​określone polecenie. Z kolei szkic za pomocą tego polecenia zaświeci lub wyłączy jedną z diod LED podłączonych do Arduino.

Będziemy potrzebować

Tworzenie aplikacji na Androida

Pusty

Rozwój systemu operacyjnego Android odbywa się w środowisku programistycznym ADT, Android Development Tools. Które można pobrać z portalu dla programistów Google. Po pobraniu i zainstalowaniu narzędzia ADT możesz go uruchomić. Jednak jest jeszcze za wcześnie, aby rozpocząć prace nad aplikacją. Musisz także pobrać zestaw SDK systemu Android w wymaganej wersji. Aby to zrobić, musisz otworzyć Menedżera SDK Androida „Okno → Menedżer SDK Androida”. Na liście musimy wybrać potrzebny nam SDK, w naszym przypadku Android 2.3.3 (API 10). Jeśli nie masz telefonu, wybierz wersję 2.3.3 lub nowszą; a jeśli jest - wersja zgodna z wersją systemu operacyjnego telefonu. Następnie kliknij przycisk „Zainstaluj pakiety”, aby rozpocząć proces instalacji.

Po zakończeniu pobierania i instalacji przystępujemy do tworzenia aplikacji. Wybierz „Plik → Nowy → Projekt aplikacji na Androida”. Wypełnijmy zawartość okna tak jak pokazano na rysunku.

    Nazwa aplikacji – nazwa aplikacji, która będzie wyświetlana w sklepie Google Play. Ale aplikacji nie będziemy publikować, więc nazwa nie jest dla nas szczególnie istotna.

    Nazwa projektu - nazwa projektu w ADT.

    Nazwa pakietu - identyfikator aplikacji. Powinien się on składać w następujący sposób: nazwa Twojej witryny od tyłu oraz nazwa aplikacji.

Z rozwijanych list „Minimalny wymagany pakiet SDK”, „Docelowy zestaw SDK”, „Kompiluj z” wybierz wersję, którą pobraliśmy wcześniej. Nowsze wersje pakietu SDK obsługują motywy graficzne dla aplikacji, ale starsze wersje nie. Dlatego w polu „Motyw” wybierz „Brak”. Kliknij Następny".

Odznacz opcję „Utwórz niestandardową ikonę programu uruchamiającego”: na potrzeby tego artykułu nie będziemy skupiać się na tworzeniu ikony aplikacji. Kliknij Następny".

W oknie, które się pojawi, możesz wybrać widok „Aktywność”: widok tego, co będzie na ekranie po uruchomieniu aplikacji. Wybieramy „Pusta aktywność”, co oznacza, że ​​chcemy zacząć wszystko od zera. Kliknij Następny".

W naszej aplikacji będzie tylko jedna Aktywność, zatem nie musisz nic zmieniać w oknie, które się pojawi. Dlatego po prostu kliknij „Zakończ”.

To wszystko, nasza aplikacja została utworzona.

Konfiguracja emulatora

Aplikacje na Androida debuguje się na prawdziwym urządzeniu lub, jeśli go nie ma, to na emulatorze. Skonfigurujmy nasze.

Aby to zrobić, uruchom „Okno → Menedżer urządzeń wirtualnych Android”. W wyświetlonym oknie kliknij „Nowy”. Wypełnij pola formularza, który się pojawi. Od nich zależy, ile i jakie zasoby emulator udostępni „telefonowi”. Wybierz rozsądne wartości i kliknij OK.

W oknie Menedżera urządzeń wirtualnych Android kliknij przycisk „Start”. Spowoduje to uruchomienie emulatora. Uruchomienie trwa kilka minut. Więc bądź cierpliwy.

W rezultacie zobaczysz okno emulatora podobne do tego:

Aktywność napełniania

Aktywność to coś, co wyświetla się na ekranie telefonu po uruchomieniu aplikacji. Znajdziemy na nim dwa przyciski „Zaświeć czerwoną diodę LED” i „Zaświeć niebieską diodę LED”. Dodajmy je. W panelu „Eksplorator pakietów” otwórz plik res/layout/activity_main.xml. Jego wygląd będzie w przybliżeniu taki sam jak na zrzucie ekranu.

Przeciągnij 2 „ToggleButtons” na formularz ekranowy. Przejdź do zakładki „activity_main.xml” i zobacz następujący kod:

aktywność_main_aiutogen.xml xmlns:narzędzia = android:layout_width="match_parent" android:layout_height="match_parent" Android:paddingBottom= Android:paddingLeft= Android:paddingRight = „@dimen/activity_horizontal_margin” Android:wypełnienieTop = „@dimen/activity_vertical_margin” narzędzia:context = "MainActivity" > android:id="@+id/toggleButton1" android:layout_alignParentLeft="prawda" android:layout_alignParentTop="true" android:text="ToggleButton" /> android:id="@+id/toggleButton2" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_above="@+id/textView1" Android:layout_alignParentRight="prawda" android:text="ToggleButton" /> >

To nic innego jak nasza Aktywność, która nie jest wyświetlana w formie graficznej, lecz opisana w formacie XML.

Uczyńmy nazwy komponentów bardziej przejrzystymi. Zmieńmy pola Android:id w następujący sposób.

android:id="@+id/toggleRedLed" ... android:id="@+id/toggleGreenLed" ...

Dodamy do nich także podpisy, zmienimy ich kolor i wielkość tekstu. Wynikowy kod znaczników będzie wyglądał następująco:

aktywność_main.xml „http://schemas.android.com/apk/res/android” xmlns:narzędzia = „http://schemas.android.com/tools” android:layout_width="fill_parent" Android:paddingBottom= „@dimen/activity_vertical_margin” Android:paddingLeft= „@dimen/activity_horizontal_margin” Android:paddingRight = „@dimen/activity_horizontal_margin” Android:wypełnienieTop = „@dimen/activity_vertical_margin” narzędzia:context = "MainActivity" android:wagaSum="2" android:orientation="horizontal" > android:id="@+id/toggleRedLed" android:layout_width="wrap_content" android:layout_height="fill_parent" android:layout_weight="1" android:tło="#FF0000" Android:textOff="OFF" Android:textOn="ON" android:textSize="30dp" /> android:id="@+id/toggleGreenLed" android:layout_width="wrap_content" android:layout_height="fill_parent" android:layout_weight="1" android:tło="#00FF00" Android:textOff="OFF" android:textSize="30dp" Android:textOn="ON" /> >

Tych samych zmian można dokonać w trybie graficznym korzystając z zakładki „Konspekt/Właściwości”.

Pierwsze uruchomienie

Nowo utworzoną aplikację możemy uruchomić na emulatorze. Przejdź do ustawień uruchamiania „Uruchom” → Uruchom konfiguracje”, po lewej stronie kliknij „Aplikacja na Androida”. Pojawi się nowa konfiguracja „Nowa_konfiguracja”. Po prawej stronie okna wybierz zakładkę „Cel” i wybierz opcję „Uruchom na wszystkich kompatybilnych urządzeniach/AVD”.

Kliknij „Zastosuj”, a następnie „Uruchom”. Aplikacja uruchomi się w emulatorze.

Można naciskać przyciski. Ale nic się nie stanie, ponieważ nie napisaliśmy jeszcze procedur obsługi kliknięć.

Aby uruchomić aplikację na prawdziwym urządzeniu, należy w jej ustawieniach włączyć opcję „Debugowanie USB” i podłączyć ją do komputera.

Na prawdziwym urządzeniu aplikacja wygląda dokładnie tak samo.

Pisanie kodu dla Androida

Redagowanie manifestu

Każda aplikacja na Androida musi poinformować system, jakie uprawnienia ma przyznać. Prawa te są wymienione w tzw. pliku manifestu AndroidManifest.xml. Musimy w nim wskazać fakt, że chcemy korzystać z Bluetooth w naszej aplikacji. Aby to zrobić, po prostu dodaj kilka linii:

AndroidManifest.xml „http://schemas.android.com/apk/res/android” pakiet="ru.amperka.arduinobtled" android:kod wersji="1" Android: nazwa wersji = „1.0” > android:minSdkVersion="10" android:targetSdkVersion="10" /> „Android.pozwolenie.BLUETOOTH”/> „Android.permission.BLUETOOTH_ADMIN”/>
android:allowBackup="true" android:icon="@drawable/ic_launcher" android:label="@string/nazwa_aplikacji" android:theme="@style/AppTheme" > android:nazwa = "ru.amperka.arduinobtled.MainActivity" android:label="@string/nazwa_aplikacji" > > „Android.intent.category.LAUNCHER” /> > > > >

Dodanie głównego kodu

Czas tchnąć życie w naszą aplikację. Otwórz plik MainActivity.java (src → ru.amperka.arduinobtled). Początkowo zawiera następujący kod:

Pakiet MainActivityAutogen.java ru.amperka.arduinobtled ; importuj pakiet android.os.Bundle ; importuj android.app.Activity ; importuj android.view.Menu ; klasa publiczna MainActivity rozszerza działanie ( @Override chronione void onCreate(Bundle zapisaneInstanceState) ( super .onCreate (savedInstanceState) ; setContentView(R.layout .activity_main ) ; ) @Override public boolean onCreateOptionsMenu( Menu menu) ( getMenuInflater() .inflate (R.menu .main , menu) ; return true ; ) )

Dodajmy kod zgodnie z tym, czego potrzebujemy:

    Włączymy Bluetooth, jeśli jest wyłączony.

    Będziemy przetwarzać kliknięcia przycisków

    Prześlemy informację, który przycisk został wciśnięty.

Do Arduino przeniesiemy jeden bajt z dwucyfrową liczbą. Pierwsza cyfra numeru to numer pinu, do którego podłączona jest ta lub inna dioda LED, druga to stan diody: 1 - włączona, 0 - wyłączona.

Numer polecenia oblicza się bardzo prosto: po naciśnięciu czerwonego przycisku pobierana jest liczba 60 (dla czerwonej diody LED wybraliśmy 6-ty pin Arduino) i dodawana jest do niej 1 lub 0, w zależności od tego, czy dioda ma teraz bądź włączony, czy nie. W przypadku zielonego przycisku wszystko jest podobne, tylko zamiast 60, pobierane jest 70 (ponieważ zielona dioda LED jest podłączona do styku 7). W rezultacie w naszym przypadku możliwe są 4 drużyny: 60, 61, 70, 71.

Napiszmy kod, który implementuje wszystko, co zostało powiedziane.

Pakiet MainActivity.java ru.amperka.arduinobtled ; import java.io.IOException; import java.io.OutputStream; import wyjątek java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method ; importuj android.app.Activity ; import android.bluetooth.Adapter Bluetooth; import android.bluetooth.Urządzenie Bluetooth; import android.bluetooth.BluetoothSocket; importuj android.content.Intent ; importuj pakiet android.os.Bundle ; import android.util.Log ; importuj android.view.Menu ; importuj android.view.View ; import android.view.View.OnClickListener; import android.widget.Toast ; import android.widget.ToggleButton ; klasa publiczna MainActivity rozszerza implementacje działania Pogląd.OnClickListener( //Instancje naszych klas przycisków ToggleButton czerwonyPrzycisk; ToggleButton zielonyPrzycisk; //Gniazdo, za pomocą którego będziemy przesyłać dane do Arduino Klient BluetoothSocket; //Ta funkcja działa automatycznie po uruchomieniu aplikacji@Override chronione void onCreate(Pakiet zapisanyInstanceState) ( super .onCreate(savedInstanceState) ; setContentView(R.layout .activity_main ) ; //"Połącz" widok przycisku w oknie aplikacji z implementacją redButton = (ToggleButton) findViewById(R.id .toggleRedLed ) ; greenButton = (ToggleButton) findViewById(R.id .toggleGreenLed ) ; //Dodaj „odbiornik kliknięcia” do przycisku redButton.setOnClickListener(this); greenButton.setOnClickListener(this); //Włącz Bluetooth. Jeśli jest już włączony, nic się nie stanie Strunowy włączBT = Adapter Bluetooth.ACTION_REQUEST_ENABLE ; startActivityForResult(nowy zamiar(włączBT) , 0 ) ; //Chcemy użyć domyślnego adaptera Bluetooth BluetoothAdapter bluetooth = BluetoothAdapter.getDefaultAdapter(); //Próbuję wykonać te działania próbować ( //Urządzenie o tym adresie to nasza pszczółka Bluetooth //Adres jest ustalany w następujący sposób: nawiąż połączenie //pomiędzy komputerem a modułem (pin: 1234), a następnie zajrzyj do ustawień //adres modułu połączeniowego. Najprawdopodobniej będzie podobnie. Urządzenie BluetoothDevice = bluetooth.getRemoteDevice("00:13:02:01:00:09" ); //Zainicjuj połączenie z urządzeniem metoda m = urządzenie.getClass().getMethod("createRfcommSocket", nowa klasa(int.class)); clientSocket = (BluetoothSocket) m.invoke(urządzenie, 1); klientSocket.connect(); //Jeśli wystąpią jakiekolwiek błędy, wypisz komunikat w dzienniku) złapać ( Wyjątek IO Wyjątek bezpieczeństwa e) ( Log.d („BLUETOOTH”, e.getMessage () ) ; ) catch ( Wyjątek NoSuchMethodException e) ( Log.d („BLUETOOTH”, e.getMessage () ) ; ) catch ( Wyjątek IllegalArgument e) ( Log.d („BLUETOOTH”, e.getMessage () ) ; ) catch ( Wyjątek IllegalAccess e) ( Log.d („BLUETOOTH”, e.getMessage () ) ; ) catch ( Wyjątek InvocationTargetException e) ( Log.d („BLUETOOTH”, e.getMessage () ) ; ) //Wyświetl komunikat o udanym połączeniu Toast.makeText(getApplicationContext(), "POŁĄCZONY", Toast.LENGTH_LONG).show(); ) @Override publiczna wartość logiczna onCreateOptionsMenu( Menu menu) ( // Rozwiń menu; powoduje to dodanie elementów do paska akcji, jeśli jest obecny. getMenuInflater() .inflate (R.menu .main , menu) ; zwróć prawdę; ) //To jest dokładnie ta funkcja, która zostanie wywołana@Override public void onClick( Pogląd v) ( //Próba wysłania danych próbować ( //Pobierz strumień wyjściowy do przesyłania danych Strumień wyjściowy outStream = klientSocket.getOutputStream(); int wartość = 0; //W zależności od tego, który przycisk został naciśnięty, //zmień dane do wysłania if (v == redButton) ( wartość = (redButton.isChecked () ? 1 : 0 ) + 60 ; ) else if (v == greenButton) ( wartość = (greenButton.isChecked () ? 1 : 0 ) + 70 ; ) //Zapisz dane do strumienia wyjściowego outStream.write(wartość); ) złapać ( Wyjątek IO e) ( //Jeśli występują błędy, zapisz je w dzienniku Log.d („BLUETOOTH”, e.getMessage (, WYJŚCIE) ; pinMode(7 , WYJŚCIE) ; ) void pętli() ( //Jeśli dane dotarły if (Serial.available() > 0) ( //Odczytaj przychodzący bajt bajt przychodzącyByte = Serial.read(); //Pobierz numer PIN poprzez liczbę całkowitą dzielącą wartość odebranego bajtu przez 10 //i akcja, której potrzebujemy, uzyskując resztę dzielenia przez 2: //(1 - świeci, 0 - wyłącza) digitalWrite(bajt przychodzący / 10, bajt przychodzący % 2) ; ) )

Funkcje wypełniania szkicu

Do komunikacji Bluetooth-Bee ze sterownikiem wykorzystywane są te same piny (0 i 1), co w przypadku oprogramowania sprzętowego. Dlatego podczas programowania sterownika przełącznik „SERIAL SELECT” na „Wireless Shield” musi być ustawiony w pozycji „USB”, a po flashowaniu musi powrócić do pozycji „MICRO”.

Wynik

Wniosek

W tym artykule dowiedzieliśmy się, jak tworzyć aplikacje na system operacyjny Android i przesyłać dane poprzez Bluetooth. Teraz po naciśnięciu przycisku na ekranie telefonu z systemem operacyjnym Android zmieni się stan diody LED na płytce.

Możesz rozwinąć swój pomysł i stworzyć bardziej przyjazny dla użytkownika interfejs na Androidzie, sterować za jego pomocą znacznie bardziej złożonymi urządzeniami, publikować fajne aplikacje w Android Market i wiele, dużo więcej ciekawych rzeczy!

Przyjrzeliśmy się instalacji i konfiguracji oprogramowania potrzebnego do programowania dla ADK i Androida. Teraz, gdy mamy już wszystko gotowe, możemy przystąpić do realizacji naszego pierwszego projektu. I zgodnie z tradycją będzie to projekt z diodą LED.

Projekt będzie bardzo prosty - na ekranie urządzenia z Androidem zostanie wyświetlony przycisk, po naciśnięciu zaświeci się dioda LED na płycie debugowania, a po zwolnieniu zgaśnie.

Program dla Arduino

Stwórzmy nowy projekt. Nasz kod źródłowy będzie bardzo prosty:

#include #include Połączenie * połączenie; void adbEventHandler(Połączenie * połączenie, zdarzenie adb_eventType, długość uint16_t, uint8_t * dane) ( if (event == ADB_CONNECTION_RECEIVE) // Jeśli odebrane zostaną dane ( digitalWrite(13, data); // Zmień stan diody LED w zależności od odebranej zmiennej ) ) void setup() ( pinMode(13,OUTPUT); // Użyj wbudowanej diody LED L płytki Seeeduino ADK ADB::init(); połączenie = ADB::addConnection("tcp:4568", true, adbEventHandler); ) pusta pętla ( ) ( ADB::poll(); )

Krótko mówiąc - inicjujemy i tworzymy połączenie ADB, a także definiujemy funkcję adbEventHandler(), który będzie wywoływany za każdym razem, gdy dane zostaną odebrane z urządzenia z systemem Android. Po otrzymaniu danych zapisujemy otrzymany bajt za pomocą funkcji cyfrowyWrite(), zapalając lub gasząc diodę LED.

Teraz kompilujemy szkic i przesyłamy go na naszą tablicę.

Program na Androida

Otwórz Eclipse IDE i utwórz nowy projekt: Nowy -> Projekt... Otworzy się okno, w którym odnajdujemy folder Android i wybieramy Projekt aplikacji Android. Kliknij przycisk Dalej i wpisz nazwę projektu oraz niektóre parametry.

Następnie kliknij Dalej i utwórz ikonę aplikacji itp. Po kliknięciu przycisku Zakończ aplikacja jest gotowa. Teraz w oknie Eksploratora pakietów kliknij projekt prawym przyciskiem myszy i wybierz właściwości projektu: Właściwości. Upewnij się, że nazwa docelowa jest ustawiona na Google API, a nie Android.

Następnie otwieramy plik manifestu AndroidManifest.xml i wpisujemy w nim linię, aby system operacyjny Android dał nam pozwolenie na dostęp do odpowiednich usług:

Następnie kopiujemy niezbędne biblioteki, aby mieć pewność, że tryb MicroBridge działa: /src/org/microbridge/server i w tym folderze znajdują się 4 pliki. Możesz je pobrać z archiwum na końcu artykułu lub z oryginalnego przykładu ze studia Seed.

Teraz musimy dodać do działania elementy graficzne (okno aplikacji), które umożliwią interakcję z użytkownikiem. Na razie będziemy mieli tylko 2 elementy: tekst i ToggleButton (przycisk z 2 stanami).
Istnieją dwa sposoby tworzenia interfejsu użytkownika: przy użyciu układu graficznego (proste przeciąganie i upuszczanie oraz układ) oraz przy użyciu pliku XML. Użyjmy układu graficznego. W tym celu w oknie zasobów aplikacji kliknij plik /res/layout/activity_main.xml. I przeciągnij przycisk ToggleButton do wyświetlonego okna:

Teraz otwórz nasz główny plik /src/com/example/arduino52/MainActivity.java, usuń wszystko, co się w nim znajduje i skopiuj następujące wiersze:

Pakiet com.example.arduino52; importuj wyjątek java.io.IO; import org.microbridge.server.Server; importuj pakiet android.os.Bundle; importuj plik android.util.Log; importuj android.app.Activity; importuj android.widget.ToggleButton; importuj android.widget.CompoundButton; klasa publiczna MainActivity rozszerza działanie Implementuje CompoundButton.OnCheckedChangeListener ( Serwer serwera = null; @Override public void onCreate(Bundle zapisanyInstanceState) ( super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); ToggleButton mButton = (ToggleButton)findViewById(R .id.toggleButton1); mButton.setOnCheckedChangeListener(this); // Utwórz serwer TCP (w oparciu o serwer MicroBridge LightWeight) try (server = new Server(4568); // Ten sam port musi być używany na serwerze karty ADK .start (); ) catch (IOException e) ( Log.e("arduino52", "Nie można uruchomić serwera TCP", e); System.exit(-1); ) ) @Override chronione void onDestroy ()( super .onDestroy (); serwer.stop(); ) public void onCheckedChanged(CompoundButton przyciskView, wartość logiczna jest zaznaczona) ( dane bajtowe; if(isChecked) // Jeśli przycisk zostanie naciśnięty ( dane = 1; ) else ( dane = 0; ) try ( // Wyślij serwer danych.send(nowy bajt ((bajt) dane)); catch (IOException e) ( Log.e("arduino52", "Problem z wysyłaniem wiadomości TCP", e); ) ) )

Aplikacja na Androida jest nieco bardziej skomplikowana, nie będę opisywał całej jej struktury, są na to wyspecjalizowane strony i książki. Powiem tylko o głównych punktach, które są potrzebne w naszym projekcie.
Zatem najpierw inicjowany jest nasz serwer MicroBridge, który jest zainstalowany na porcie 4568. Dokładnie ten sam port powinien znajdować się w szkicu Arduino.
Następnie deklarowany jest program obsługi onCheckedChanged() która jest wywoływana za każdym razem, gdy zmienia się stan naszego ToggleButton. Następnie w zależności od stanu przycisku zapisujemy w zmiennej data 1 lub 0 i następuje próba przesłania tych danych do funkcji serwer.send()

Następnie podłączamy nasze urządzenie z Androidem do komputera, uruchamiamy nasz projekt Run, wybieramy tam nasze prawdziwe urządzenie (nie wirtualne) i czekamy, aż program zostanie skompilowany i zainstalowany na Twoim telefonie lub tablecie.

Oraz HTC Desire z oprogramowaniem Cyanogen 7.1.0 RC1 (Android 2.3.4). Na wszelki wypadek przypomnę, że wszystko, co zostanie opisane poniżej, działa dopiero od wersji Androida 2.3.4 dla telefonów i Androida 3.1 dla tabletów.

Warto w tym miejscu zaznaczyć, że ta osłona hosta USB nie jest do końca udana, zwłaszcza w połączeniu z Arduino Mega 2560. Pierwszym problemem było to, że ta płytka rozszerzeń została stworzona dla Arduino UNO i różni się od Mega pozycjami Styki SPI, więc musiałem dodać zworki (patrz zdjęcie). Drugim problemem, choć całkiem spodziewanym, była potrzeba zewnętrznego źródła zasilania do obsługi tej karty rozszerzeń. USB Host Shield 2.0 od Circuits@Home uchodzi za bardziej udany, ale jest też droższy.

Płytka z połączonymi stykami SPI

Konfiguracja oprogramowania Arduino

1. Jeśli nie jest jeszcze zainstalowany, pobierz i zainstaluj oprogramowanie dla Arduino.
2. Pobierz i rozpakuj pakiet ADK (zawiera aplikację DemoKit). Powinny pojawić się foldery aplikacji, oprogramowania sprzętowego i sprzętu.
3. Pobierz bibliotekę CapSense
4. Skopiuj firmware/arduino_libs/AndroidAccessory i firmware/arduino_libs/USB_Host_Shield do /biblioteki/ .
5. Utwórz katalog CapSense w /libraries/ i skopiuj do niego pliki CapSense.cpp i CapSense.h z archiwum CapSense.

Pobieranie oprogramowania sprzętowego

Google uprzejmie udostępnia szkic DemoKit dla Arduino. Wszystko, co musisz zrobić, to otworzyć go z oprogramowania/demokit/demokit.pde, skompilować i wgrać na płytkę.

Przetestuj aplikację na Androida

Pakiet DemoKit zawiera również źródła aplikacji na Androida, aby zademonstrować możliwości. Google zaprasza nas do samodzielnego stworzenia projektu na Androida i zmontowania tej aplikacji. Najpierw będziemy musieli zainstalować poziom API 10. Wtedy wszystko jest proste - tworzymy projekt Android i podajemy ścieżkę do folderu aplikacji, w Build Target określamy Google API (Platforma 2.3.3 , poziom API 10). Składamy aplikację i instalujemy ją na telefonie. Ci, którzy nie chcą zawracać sobie głowy montażem, mogą pobrać gotowy plik APK.

Początek

Po prostu podłączamy nasz telefon do USB Host Shield. Jeżeli wszystko zrobiliśmy poprawnie, na ekranie pojawi się prośba o uruchomienie aplikacji DemoKit.

Sama aplikacja zawiera dwie zakładki – In (przyciski, joystick i czujniki) oraz Out (diody LED, przekaźniki i serwa).

Uznałem, że do demonstracji wystarczy kilka diod LED i przycisk. Jak działa całe to cudo, możecie zobaczyć na filmie.

Jakiś kod

W tym przykładzie wiadomości przesyłane przez USB składają się z trzech bajtów:
Pierwszy bajt definiuje polecenie lub grupę urządzeń, np. diody LED - 0x2
Drugi bajt wskazuje konkretne urządzenie, np. zielona dioda LED - 0x1
Trzeci bajt zawiera wartość przekazaną do urządzenia, np. maksymalną jasność - 0xff

Arduino

... /* inicjalizacja */ AndroidAccessory acc("Google, Inc.", "DemoKit", "DemoKit Arduino Board", "1.0", "http://www.android.com", "0000000012345678"); void setup() ( .... acc.powerOn(); ) void pętli() ( byte msg; /* sprawdź połączenie */ if (acc.isConnected()) ( /* odbierz wiadomość z urządzenia z systemem Android */ int len = acc.read(msg, sizeof(msg), 1); if (len > 0) ( /* komunikat dla diod LED */ if (msg == 0x2) ( if (msg == 0x0) analogWrite(LED3_RED, msg) ; inaczej jeśli (msg == 0x1) analogWrite(LED3_GREEN, msg); else if (msg == 0x2) analogWrite(LED3_BLUE, msg); msg = 0x1; / * stan przycisku wysyłania */ acc.write(msg, 3);

Android

import com.android.future.usb.UsbAccessory; import com.android.future.usb.UsbManager; ... Rozszerzenia klasy publicznej Demokitactivity implementują wykonalne (prywatny USBManager Musbmanager; USBACCESSORY MACCCESSORY; FileinPutstream MinPuSTREAM; Utputstream; ... Private Void Openaccessory (USBACCESSORY) ) ( mAccessory = akcesoria; FileDescriptor fd = mFileDescriptor.getFileDescriptor(); mInputStream = nowy FileInputStream (fd); mOutputStream = nowy FileOutputStream(fd); Wątek = nowy wątek (null, this, "AccessoryThread"); wątek.start(); ) ) public void run() ( int ret = 0; bufor bajtów = nowy byte; int i; while (ret >= 0) ( // odbieranie wiadomości przychodzących ret = mInputStream.read(buffer); i = 0; while (i< ret) { int len = ret - i; switch (buffer[i]) { case 0x1: // сообщение от кнопки if (len >= 3) ( Wiadomość m = Message.obtain(mHandler, MESSAGE_SWITCH); m.obj = new SwitchMsg(bufor, bufor); mHandler.sendMessage(m); ) i += 3; przerwa; ) ) ) ) // przykład użycia - włączenie czerwonej diody LED na pełną jasność: // mActivity.sendCommand((byte)2, (byte)0, (byte)255) public void sendCommand(bajt polecenie, bajt docelowy, int wartość) ( bufor bajtowy = nowy bajt; if (wartość > 255) wartość = 255; bufor = polecenie; bufor = cel; bufor = (bajt) wartość; if (mOutputStream != null && bufor != -1) ( spróbuj ( mOutputStream. write(bufor) catch (IOException e) ( ... ) ) ) )

wnioski

Otwierając takie możliwości, Google oczywiście liczy przede wszystkim na pojawienie się dużej liczby aktywnych akcesoriów do Androida, ale nie najmniej istotny jest fakt, że w istocie otrzymujemy wygodne urządzenie do interakcji z różnymi czujnikami , czujniki i elementy wykonawcze. Takie urządzenie mogłoby z łatwością stać się mózgiem czegoś robota.

Nie możemy też zapominać, że urządzenie z Androidem dla Arduino może działać jako karta rozszerzeń, która ma GPS, Bluetooth, WiFi, akcelerometr i wiele więcej.

Powiedz przyjaciołom