Android Things memiliki kemampuan unik untuk terhubung dengan mudah ke komponen elektronik eksternal dengan Peripheral API dan dukungan perangkat built-in. Pada artikel ini anda akan belajar tentang berbagai jenis periferal yang dapat anda hubungkan untuk menyesuaikan perangkat IoT anda dengan Android Things.

Bekerja dengan Antarmuka Berbeda

Android Things ini memungkinkan sebagian besar perangkat untuk dihubungkan ke papan prototipe anda melalui penggunaan API Peripheral, yang mendukung GPIO, PWM, II2C, SPI dan UART interface, yang masing-masing adalah standar industri antarmuka untuk berkomunikasi dengan periferal. Pada bagian ini anda akan mempelajari antarmuka, dan bagaimana berkomunikasi dengan perangkat yang anda kenal dengan papan prototipe Android Things anda menggunakan koneksi ini.

GPIO

Pin dari General Purpose Input / Output (GPIO) digunakan untuk komunikasi digital (biner) dengan komponen, seperti membaca apakah sebuah tombol ditekan atau tidak, atau menghidupkan atau mematikan LED. Dari metode-metode I / O yang akan anda lihat dalam tutorial ini, GPIO adalah yang paling sederhana untuk digunakan, hanya membutuhkan satu pin dan menggunakan nilai boolean untuk keadaan tinggi atau rendah.

Sebelum anda dapat terhubung ke pin GPIO, anda perlu mengetahui nama unik dari pin tersebut. Anda bisa mendapatkan nama dari semua pin yang tersedia dengan mengambil kembali PeripheralManagerService dan memanggil getGpioList(). Pada sebuah Raspberry Pi, ini akan mengembalikan daftar berikut ini:

[BCM12, BCM13, BCM16, BCM17, BCM18, BCM19, BCM20, BCM21, BCM22, BCM23, BCM24, BCM25, BCM26, BCM27, BCM4, BCM5, BCM6]

Untuk mengetahui pin mana yang masing-masing diwakili, anda bisa merujuk ke diagram Raspberry Pi I / O.

Begitu anda memiliki nama pin yang akan anda baca atau tulis, anda bisa mendapatkan sebuah referensi objek Gpio ke pin itu dengan memanggil openGpio (String pin_name) dari PeripheralManagerService anda.  

try {
    mGpio = service.openGpio(PIN_NAME);
} catch (IOException e){

}

Pin GPIO dapat digunakan untuk input atau output. Jika anda akan menggunakan pin untuk membaca informasi, anda perlu mengkonfigurasi pin arah DIRECTION_IN, dan mengatur jenis pemicu untuk pin yang sehingga ia tahu kapan harus membiarkan aplikasi anda tahu bahwa sesuatu telah terjadi.

mGpio.setDirection(Gpio.DIRECTION_IN);
mGpio.setEdgeTriggerType(Gpio.EDGE_BOTH);

Tipe pemicu terdiri dari EDGE_NONE, EDGE_RISING,   EDGE_FALLING, dan EDGE_BOTH. Jika tombol ditekan, maka terjadi kenaikan saat rangkaian tombol selesai dan sinyal tegangan tinggi muncul di pin fisik. Peristiwa jatuh terjadi saat tombol dilepaskan. Kode anda akan diberitahu tentang perubahan berdasarkan jenis pemicu yang anda tetapkan.

Saat GPIO anda mendengarkan pemicu tepi, anda perlu membuat sebuah GpioCallback untuk mendaftarkan nilai komponen GPIO dalam aplikasi anda.

private GpioCallback mCallback = new GpioCallback() {
    @Override
    public boolean onGpioEdge(Gpio gpio) {
        try {
            Log.d("Tuts+", "GPIO value:  " + gpio.getValue());
        } catch( IOException e ) {

        }
        return super.onGpioEdge(gpio);
    }

    @Override
    public void onGpioError(Gpio gpio, int error) {
        super.onGpioError(gpio, error);
    }
};

Setelah callback anda dibuat, daftarkan dengan obyek Gpio  anda.

mGpio.registerGpioCallback(mCallback);

Jika pin GPIO anda menulis informasi, anda perlu mengatur arahannya sebagai DIRECTION_OUT_INITIALLY_LOW atau DIRECTION_OUT_INITIALLY_HIGH, tergantung pada apakah anda ingin komponen untuk memulai sebagai on atau off. Tidak ada jenis pemicu yang diperlukan untuk pin output.

mGpio.setDirection(Gpio.DIRECTION_OUT_INITIALLY_LOW);

Untuk menuliskannya ke perangkat, anda dapat menghubungi   setValue(boolean)di objek Gpio untuk mengatur keadaan komponen.

mGpio.setValue(true);

Setelah aplikasi anda selesai berjalan, anda perlu membatalkan registrasi ulang input callback anda, jika sudah dibuat dan terdaftar, dan tutup akses ke perangkat menggunakan metode close() di onDestroy().

@Override
protected void onDestroy() {
    super.onDestroy();

    if( mGpio != null ) {
        try {
            mGpio.unregisterGpioCallback(mCallback);
            mGpio.close();
            mGpio = null;
        } catch( IOException e ) {
            
        }
    }
}

PWM

Perangkat Pulse Width Modulation (PWM) menggunakan alternasi keadaan digital, yang dikenal berfungsi sebagai sinyal kontrol proporsional. Ada tiga bagian utama dari sinyal kontrol proporsional yang harus diperhatikan:

• Frekuensi: Ini menggambarkan seberapa sering pulsa keluaran berulang. Unit pengukuran untuk frekuensi adalah hertz (Hz).
• Duty Cycle: Ini mewakili lebar pulsa dalam frekuensi yang ditentukan. Siklus tugas dinyatakan sebagai persentase sinyal tinggi dalam suatu frekuensi, jadi siklus yang setengahnya akan memiliki siklus kerja 50%.
• Periode: Ini merupakan waktu yang dibutuhkan setiap siklus naik / turun terjadi. Periode berbanding terbalik dengan frekuensi.

Dengan menyesuaikan siklus sinyal, anda dapat mengontrol rata-rata 'on' waktu gelombang. Di bawah ini anda dapat melihat contoh sinyal periode 50%.  

Beberapa perangkat yang bisa menggunakan sinyal PWM meliputi motor servo, yang menggunakan frekuensi untuk menentukan posisi mereka, atau matriks LED, yang bisa menggunakan sinyal PWM untuk mengatur kecerahan.  

Bahkan dengan hanya perangkat motor dan GPIO, anda dapat membuat sejumlah besar perangkat IoT, seperti pohon kucing "cerdas" dengan laser bermotor.

Sama halnya dengan GPIO, anda dapat mengambil daftar port PWM yang tersedia dengan membuat sebuah PeripheralManagerService dan memanggil   getPwmList(). Pada Raspberry Pi, daftar ini akan terlihat seperti berikut:

[PWM0, PWM1]

Setelah anda mengetahui nama pin PWM yang ingin anda gunakan, anda dapat membuka koneksi ke perangkat itu menggunakan metode openPwm(String). Ini perlu dibungkus dengan sebuah blok try/catch untuk menangani kemungkinan dilempar IOException.

try {
    mPwm = service.openPwm(PIN_NAME);
} catch( IOException e ) {

}

Setelah anda membuka koneksi ke pin PWM anda, anda dapat mengontrol pengaturan di dalamnya, seperti frekuensi dan siklus tugas.

mPwm.setPwmFrequencyHz(120);
mPwm.setPwmDutyCycle(25);
mPwm.setEnabled(true);

Sebelum anda selesai dengan aplikasi anda dan menghancurkan Aktivitas, anda akan perlu untuk menutup sambungan dan melepaskan referensi ke perangkat PWM anda.

@Override
protected void onDestroy() {
    super.onDestroy();
    if( mPwm != null ) {
        try {
            mPwm.close();
            mPwm = null;
        } catch( IOException e ) {

        }
    }
}

I²C

Bus Inter-Integrated Circuit (I²C) memungkinkan proyek anda berkomunikasi dengan beberapa perangkat melalui satu koneksi fisik, dan ini memungkinkan anda mengirim data kompleks hanya dengan beberapa pin Pi atau perangkat tertanam lainnya. I²C menggunakan komunikasi sinkron antara perangkat, dan bergantung pada sinyal clock untuk memastikan bahwa perangkat menanggapi pada waktu yang tepat.  

Perangkat yang mengeluarkan sinyal jam, yang sering kali menjadi perangkat Android Things anda, dikenal sebagai master, dan semua periferal terhubung yang menerima sinyal itu dikenal sebagai budak.

Tidak seperti PWM dan GPIO, yang hanya membutuhkan satu pin, perangkat I²C membutuhkan tiga sambungan:

• Sinyal jam bersama/ Shared clock signal (disingkat SCL), yang mengeluarkan sinyal jam dari perangkat induk ke perangkat slave.
• Shared Data Line (singkatan SDA), yang merupakan koneksi yang digunakan untuk transfer data aktual. Karena I²C adalah standar komunikasi sinkron (half-duplex), yang berarti data yang hanya bisa bergerak dalam satu arah pada satu waktu, hanya satu perangkat yang dapat menggunakan koneksi ini pada setiap titik waktu tertentu.
• Sambungan ground listrik

Ini perlu dicatat bahwa setiap perangkat slave I²C diprogram dengan alamat yang diatur, dan hanya akan merespon ketika perangkat master membuat permintaan data untuk alamat tertentu.

Beberapa periferal yang bisa menggunakan metode koneksi ini mencakup tampilan matriks LED tersegmen, dan berbagai sensor canggih.

Setiap perangkat Android Things akan memiliki satu set pin yang digunakan untuk I²C, yang dapat anda temukan dengan melihat dokumentasi untuk papan prototipe spesifik anda. Untuk Raspberry Pi, anda dapat merujuk gambar pinout di bagian atas artikel ini, yang menyatakan bahwa SDA dan SDL adalah pin 3 dan 5. Untuk menemukan nama I²C anda, anda dapat menjalankan kode berikut:

PeripheralManagerService manager = new PeripheralManagerService();
List<String> deviceList = manager.getI2cBusList();

if( !deviceList.isEmpty() ) {
   Log.d( "Tuts+", deviceList.toString() );
}

Potongan kode di atas akan menampilkan yang berikut pada Pi Raspberry:

[I2C1]

Setelah anda tahu nama bus I²C anda, anda bisa terhubung ke perangkat di bus itu menggunakan alamat perangkat lunak mereka. Anda dapat menemukan alamat perangkat lunak dan rincian koneksi tingkat rendah lainnya di komponen periferal "datasheet" - memerlukan pembacaan jika anda ingin menggunakan perangkat untuk proyek yang disematkan!

private I2cDevice mDevice;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    try {
        PeripheralManagerService manager = new PeripheralManagerService();
        mDevice = manager.openI2cDevice(I2C_DEVICE_NAME, I2C_ADDRESS);
    } catch (IOException e) {}
}

Setelah anda tahu nama bus I²C anda, anda bisa terhubung ke perangkat di bus (SMBus) itu menggunakan alamat perangkat lunak mereka. Anda dapat menemukan alamat perangkat lunak dan rincian koneksi tingkat rendah lainnya di komponen periferal "datasheet" - memerlukan pembacaan jika anda ingin menggunakan perangkat untuk proyek yang disematkan!

• readRegByte()dan writeRegByte(): Membaca atau menulis satu byte dari register tertentu.
• readRegWord() dan writeRegWord(): Membaca atau menulis byte dari dua register berurutan pada perifer dalam format little-endian.
• readRegBuffer() dan writeRegBuffer(): Membaca atau menulis byte dari hingga 32 register berturut-turut. Nilai ditulis atau diambil sebagai sebuah byte array.

public void singleByte(I2cDevice device, int address) throws IOException {
    // Read one register from slave
    byte value = device.readRegByte(address);

    // Write the value back to slave
    device.writeRegByte(address, value);
}

public byte[] multipleBytes(I2cDevice device, int startAddress) throws IOException {
    // Read three consecutive register values
    byte[] data = new byte[3];
    device.readRegBuffer(startAddress, data, data.length);
    return data;
}

Ketika aplikasi anda siap untuk ditutup pada perangkat Android Things anda, pastikan untuk membatalkan registrasi I²C anda.

@Override
protected void onDestroy() {
    super.onDestroy();

    if (mDevice != null) {
        try {
            mDevice.close();
            mDevice = null;
        } catch (IOException e) {}
    }
}

SPI

Koneksi serial antarmuka Peripheral/ Serial Peripheral interface (SPI) bekerja sama dengan koneksi I²C, kecuali mereka mendukung komunikasi full-duplex. Ini berarti data dapat dibaca dan ditulis ke periferal secara bersamaan, daripada membutuhkan perangkat induk untuk meminta informasi dari periferal budak. Sinyal jam masih diperlukan untuk mengendalikan aliran data dari beberapa perangkat pada bus sinyal SPI. SPI membutuhkan minimal empat koneksi untuk berfungsi:

• Master Out Slave In (MOSI)  
• Master In Slave Out (MISO)
• Clock signal (CLK)
• Shared ground (GND)

Selain itu, koneksi kelima diperlukan jika beberapa perangkat SPI dilampirkan ke bus SPI. Ini adalah Chip Select (CS), yang digunakan untuk memberi sinyal alamat perangkat periferal, sehingga perangkat utama anda dapat berkomunikasi dengan seorang budak tertentu.

Beberapa contoh perangkat yang menggunakan SPI termasuk LED papan dot matrix dan pembaca kartu SD, dan itu perlu dicatat bahwa banyak peripheral yang mendukung I²C juga akan mendukung SPI.

Sama seperti contoh sebelumnya, anda perlu mengetahui nama koneksi SPI di papan Android Things anda. Anda bisa menemukannya dengan membuat sebuah PeripheralManagerService dan memanggil getSpiBusList() pada objek itu. Pada Raspberry Pi anda akan memiliki yang berikut ini:  

[SPI0.0, SPI0.1]

Begitu anda tahu nama bus SPI yang akan anda gunakan, anda bisa membuka koneksi untuk itu.

private SpiDevice mDevice;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    try {
        PeripheralManagerService manager = new PeripheralManagerService();
        mDevice = manager.openSpiDevice(SPI_DEVICE_NAME);
    } catch (IOException e) {
    }
}

Agar perangkat berkomunikasi melalui bus SPI, mereka semua harus "berbicara dalam bahasa yang sama", artinya perangkat harus dikonfigurasi dengan kecepatan dan format data jam yang sama. Sementara beberapa peripheral dapat menyesuaikan tingkat format data dan jam mereka, yang lain tidak bisa. Karena semua perangkat pada bus SPI harus beroperasi dengan konfigurasi yang sama, penting untuk mengetahui kemampuan perangkat anda

• Mode SPI: Mode SPI memiliki dua komponen utama: apakah sinyal clock tinggi atau rendah sementara tidak ada data yang ditransfer, dan tepi pulsa digunakan untuk mentransfer data.
• Frekuensi: Ini mewakili sinyal jam bersama di Hz, dan kemungkinan besar akan menjadi nilai yang ditentukan oleh kemampuan perangkat budak anda.
• Bit justification: Digunakan untuk mengatur keberakhiran untuk data anda. Secara default, Android Things akan menggunakan big-endian, menempatkan yang paling signifikan besar (MSB) terlebih dahulu.
• Bits per word (BPW): Mengontrol berapa banyak bit yang akan dikirim ke perangkat slave sebelum mengaktifkan chip select signal. Secara default, delapan bit per kata akan dikirim.

Dalam kode java Android Things anda, anda dapat menetapkan keempat nilai ini pada bus SPI anda seperti:

// Low clock, leading edge transfer
device.setMode(SpiDevice.MODE0);

device.setFrequency(16000000);
device.setBitsPerWord(8);
device.setBitJustification(false);

Bagaimana anda berinteraksi dengan perangkat anda di bus SPI tergantung pada apakah anda beroperasi dalam mode setengah penuh atau dupleks. Jika perangkat anda dikonfigurasi untuk half-duplex, anda akan ingin menukar data antara budak dan perangkat master dengan metode read() dan write() di objek SpiDevice. Jika anda beroperasi dalam mode full-duplex, anda akan ingin menggunakan metode transfer() dengan dua buffer array byte: satu dengan data yang akan dikirim, dan buffer kosong lainnya untuk menyimpan data respon.

//Half-duplex mode
public void sendCommand(SpiDevice device, byte[] buffer) throws IOException {
    // Shift data out to slave
    device.write(buffer, buffer.length);

    // Read the response
    byte[] response = new byte[32];
    device.read(response, response.length);
}

// Full-duplex mode
public void sendCommand(SpiDevice device, byte[] buffer) throws IOException {
    byte[] response = new byte[buffer.length];
    device.transfer(buffer, response, buffer.length);
}

Saat aplikasi anda siap untuk ditutup di perangkat Android Things, pastikan untuk membatalkan registrasi perangkat SPI anda.

@Override
protected void onDestroy() {
    super.onDestroy();

    if (mDevice != null) {
        try {
            mDevice.close();
            mDevice = null;
        } catch (IOException e) {}
    }
}

UART

Periferal yang lebih kompleks, seperti display LCD, pembaca kartu SD, dan modul GPS, sering kali menggunakan komunikasi serial melalui port UART saat berkomunikasi dengan perangkat utama. UART memungkinkan perangkat mengirim data mentah secara asinkron ke penyangga pada perangkat lain. Penyangga ini kemudian dibaca dalam urutan keluar pertama. Ini juga memungkinkan kedua format data dan kecepatan transfer dikonfigurasi pada kedua perangkat yang terhubung. Kedua perangkat harus setuju pada kecepatan transfer, sebagai UART tidak mendukung sinyal clock, tetapi kecepatan transfer cenderung lebih cepat dari I²C dan data dapat ditransfer dalam modus full-duplex antara perangkat. Tidak seperti I²C dan SPI, hanya satu perangkat yang melekat diperbolehkan per sambungan UART.

Periferal UART memiliki tiga kabel inti:

• RX, yang digunakan untuk menerima data.
• TX, yang digunakan untuk mentransmisikan data.
• GND, ground listrik.

Pada komponen perifer, pin ini pada umumnya akan diberi label seperti:

Selain itu, beberapa perangkat UART mungkin mencakup dua koneksi lagi untuk mengendalikan arus data:

• Permintaan untuk Kirim (RTS)
• Hapus untuk Kirim (CLS)

Serupa dengan semua contoh sebelumnya, anda perlu mengetahui nama koneksi UART perangkat Android Things anda. Anda dapat menemukannya dengan kode berikut:

PeripheralManagerService manager = new PeripheralManagerService();
List<String> deviceList = manager.getUartDeviceList();

if (!deviceList.isEmpty()) {
    Log.d("Tuts+", deviceList.toString());
}

Pada Raspberry Pi, output log akan terlihat seperti ini:

[UART0]

Setelah mengetahui nama koneksi UART anda, anda dapat membuat perangkat Android Things UART dengan cara yang sama seperti anda telah membuka koneksi perangkat lain.

PeripheralManagerService manager = new PeripheralManagerService();
mDevice = manager.openUartDevice(UART_DEVICE_NAME);

Begitu anda memiliki perangkat, anda perlu mengkonfigurasi format frame data yang akan dikirim antar perangkat. Ada empat sifat yang harus diperhatikan:

• Jumlah bit data: UART dapat mengirim antara lima dan sembilan bit untuk mewakili karakter data. Mengirimkan sedikit bit memungkinkan kecepatan transfer data lebih cepat, namun membatasi rentang karakter yang dapat dikirim.
• Bit paritas: Digunakan untuk memeriksa apakah isi data transmisi berjumlah genap atau ganjil. Jika paritas tidak diatur, maka bit paritas akan dihapus dari transmisi. Ini digunakan untuk pengecekan error pada transmisi.
• Bit Stop: Ini bisa diset ke 1 atau 2 bit. Transmisi akan berhenti selama durasi yang sama dengan jumlah stop bit untuk menunjukkan bahwa bingkai data telah berakhir.
• Baud rate: Baud rate adalah kecepatan transmisi untuk data frame anda. Karena tidak ada sinyal clock di UART, kedua perangkat harus dikonfigurasi dengan baud rate sebelum transmisi dimulai.

Masing-masing pengaturan ini dapat dikonfigurasi pada perangkat UART seperti:

uart.setBaudrate(9600);
uart.setDataSize(6);
uart.setParity(UartDevice.PARITY_NONE);
uart.setStopBits(2);

Sebelumnya anda mengetahui bahwa ada dua pengaturan kabel untuk perangkat UART, yang memiliki sinyal kontrol tambahan, dan yang tidak. Anda dapat mengkonfigurasi perangkat UART anda dalam kode dengan menggunakan metode setHardwareFlowControl().

uartDevice.setHardwareFlowControl(UartDevice.HW_FLOW_CONTROL_AUTO_RTSCTS);
//or
uartDevice.setHardwareFlowControl(UartDevice.HW_FLOW_CONTROL_NONE);

Setelah anda selesai mengonfigurasi perangkat anda, sekarang saatnya membaca dan menulis data dari papan Android Things anda dan perangkat UART anda. Menulis ditangani dengan memanggil metode write() dengan buffer array byte dan panjang array itu.

uartDevice.write(buffer, buffer.length);

Meskipun anda dapat terus melakukan polling untuk data di buffer baca perangkat anda, taruhan yang lebih baik adalah membuat objek UartDeviceCallback, yang menyediakan metode bernama onUartDeviceDataAvailable() yang akan dipicu saat data tersedia. Bila sudah, anda bisa membaca data dari buffer data perangkat anda. Anda akan dapat mengaitkan callback ini dengan perangkat UART anda dengan registerUartDeviceCallback, meskipun anda akan perlu ingat untuk memanggil   unregisterUartDeviceCallback bila sudah selesai menggunakan callback. Bila data tersedia, anda dapat mengambilnya kembali dengan menggunakan UART metode read().

private UartDeviceCallback mUartCallback = new UartDeviceCallback() {
    @Override
    public boolean onUartDeviceDataAvailable(UartDevice uart) {
        byte[] buffer = new byte[MAX_BUFFER_SIZE];
        try {
            uartDevice.read(buffer, buffer.length)
            //do something with the data in the buffer byte array
        } catch (IOException e) {}

        //Returning true keeps the callback active. If you return false,
        //the callback will automatically unregister.
        return true;
    }

    @Override
    public void onUartDeviceError(UartDevice uart, int error) {}
};

@Override
protected void onStart() {
    super.onStart();
    mDevice.registerUartDeviceCallback(mUartCallback);
}

@Override
protected void onStop() {
    super.onStop();
    mDevice.unregisterUartDeviceCallback(mUartCallback);
}

Setelah selesai dengan Aktivitas, pastikan untuk menutup dan membatalkan referensi ke perangkat UART anda.

@Override
protected void onDestroy() {
    super.onDestroy();

    if (uartDevice != null) {
        try {
            uartDevice.close();
            uartDevice = null;
        } catch (IOException e) {}
    }
}

I/O Lanjutan dan Update di Masa Depan

Sementara Peripheral API memungkinkan anda berkomunikasi dengan hampir semua perangkat yang dapat dihubungkan ke papan Android Things anda, Google telah memberikan beberapa dukungan tambahan untuk membuat perangkat IoT anda menjadi lebih mudah. Bagian ini akan melihat beberapa dukungan periferal tambahan yang tersedia melalui Android Things.

I/O Asli

Sementara Android Things memberikan cara mudah bagi pengembang Android untuk masuk ke pengembangan IOT dengan SDK Android dan Java, banyak IOT aplikasi sudah ada di C dan C++, dan pengembang lainnya akan lebih memilih untuk bekerja di bahasa-bahasa karena berbagai alasan. Untuk mendukung hal ini, Google telah melengkapi API Peripheral dengan dukungan untuk aplikasi asli dan NDK. Saya tidak akan membahas topik ini secara mendalam, namun koneksi dibuat dan digunakan dengan cara yang sangat mirip dengan yang dibahas di atas.

WiFi dan Bluetooth

Tanpa cara untuk terhubung ke Internet, perangkat IoT akan menjadi hal yang begitu saja. Dengan dukungan nirkabel built-in, perangkat Android Things anda dapat terhubung ke Internet dan menggunakan berbagai sumber online, seperti Firebase dan layanan Google lainnya, atau layanan back-end lainnya. Selain itu, menggunakan alat seperti Google Play Services dan   Nearby Connections API dapat memungkinkan pengguna berkomunikasi langsung dengan perangkat anda melalui jaringan WLAN mereka.

Meski saat ini tidak diaktifkan dalam versi pratinjau pengembang Android Things, konektivitas Bluetooth juga merupakan kemampuan IoT yang penting. Dengan menggunakan Bluetooth, anda dapat membuat beberapa perangkat atau aksesori IoT dan memilikinya berkomunikasi melalui jarak pendek. Ini memungkinkan setiap perangkat memiliki informasi kontekstual tambahan tentang lingkungannya, seperti rumah pengguna atau ruang kerja, agar dapat melayani pengguna dengan sebaik-baiknya.

USB

Beberapa perangkat bekerja dengan port USB prototipe papan, meskipun tidak sepenuhnya diaktifkan pada iterasi saat ini dari pratinjau pengembang Android Things. Di pratinjau pengembang kedua, Google telah menambahkan audio USB keluar dengan dukungan teks ke ucapan, dan pengembang telah memastikan bahwa perangkat lain berfungsi, seperti mikrofon USB. Karena USB API diuji dan disetujui di versi Android Things berikutnya, akan ada beragam perangkat yang dapat dihubungkan ke perangkat IoT anda sebagai aksesori.

Kamera dan Tampilan

Beberapa perangkat, seperti Pi Raspberry, hadir dengan koneksi I / O tambahan yang ada di dalamnya, seperti HDMI, Display, dan Camera. Untungnya, semua ini diaktifkan dengan Android Things, memungkinkan anda melampirkan kamera dengan kabel pita 15cm ...

... atau layar melalui kabel pita atau koneksi HDMI:

Kesimpulan

Selamat! anda telah membahas banyak hal, dan telah mempelajari informasi yang sangat berharga tentang menghubungkan dan mengendalikan perangkat periferal dengan papan Android Things. Dengan menggunakan pengetahuan ini, anda harus bisa terhubung dan berkomunikasi dengan berbagai komponen perangkat keras.  

Di posting berikutnya dari seri ini, kami akan menggunakan pengetahuan kami tentang Peripherals API untuk membuat driver perangkat lunak untuk komponen sensor gerak GPIO, yang kemudian dapat digunakan dalam proyek Android Things yang lebih besar.

Sementara itu, lihat beberapa tutorial dan artikel kami yang lain tentang pengembangan Android!

• 
  Android SDK
  Android Things: Proyek Pertama anda
  Paul Trebilcox-Ruiz
• 
  Android SDK
  Layanan Google Play: Google Melemparkan v3 dan Media
  Paul Trebilcox-Ruiz
• 
  Android
  Cara Memulai Dengan Android's Native Development Kit
  Ashraff Hathibelagal