Advertisement
  1. Code
  2. Android SDK

Android Things: Periphere Ein- / Ausgabe

This post is part of a series called Android Things.
Android Things: Your First Project
Android Things: Understanding and Writing Drivers

German (Deutsch) translation by Federicco Ancie (you can also view the original English article)

Android Things bietet eine einzigartige Möglichkeit, mit der Peripheral-API und der integrierten Geräteunterstützung problemlos eine Verbindung zu externen Elektronikkomponenten herzustellen. In diesem Artikel erfahren Sie mehr über die verschiedenen Arten von Peripheriegeräten, mit denen Sie eine Verbindung herstellen können, um Ihre IoT-Geräte mit Android Things anzupassen.

Arbeiten mit verschiedenen Schnittstellen

Mit Android Things können die meisten Geräte mithilfe der Peripheral-API, die GPIO-, PWM-, I2C-, SPI- und UART-Schnittstellen unterstützt, die jeweils branchenübliche Schnittstellen für die Kommunikation mit Peripheriegeräten sind, mit Ihrem Prototyping-Board verbunden werden. In diesem Abschnitt erfahren Sie, was diese Schnittstellen sind und wie Sie mit Geräten kommunizieren, die Sie über diese Verbindungen mit Ihrem Android Things-Prototyping-Board verbunden haben.

GPIO

GPIO-Pins (General Purpose Input / Output) werden für die digitale(binäre) Kommunikation mit Komponenten verwendet, z. B. zum Lesen, ob eine Taste gedrückt wird oder nicht, oder zum Ein- oder Ausschalten einer LED. Von den E / A-Methoden, die Sie in diesem Lernprogramm sehen werden, ist GPIO am einfachsten zu verwenden, da nur ein Pin erforderlich ist und boolesche Werte für hohe oder niedrige Zustände verwendet werden.

Bevor Sie eine Verbindung zu einem GPIO-Pin herstellen können, müssen Sie den eindeutigen Namen dieses Pins kennen. Sie können die Namen aller verfügbaren Pins abrufen, indem Sie den PeripheralManagerService abrufen und getGpioList() aufrufen. Auf einem Raspberry Pi wird die folgende Liste zurückgegeben:

Um herauszufinden, welche Pins diese jeweils darstellen, können Sie sich auf das Raspberry Pi-E / A-Diagramm beziehen.

Raspberry Pi IO pin name chart for Android ThingsRaspberry Pi IO pin name chart for Android ThingsRaspberry Pi IO pin name chart for Android Things

Sobald Sie den Namen des Pins haben, von dem Sie lesen oder in den Sie schreiben, können Sie einen Gpio-Objektverweis auf diesen Pin erhalten, indem Sie openGpio (String pin_name) von Ihrem PeripheralManagerService aufrufen.

GPIO-Pins können für die Ein- oder Ausgabe verwendet werden. Wenn Sie den Pin zum Einlesen von Informationen verwenden, müssen Sie die Pin-Richtung als DIRECTION_IN konfigurieren und den Triggertyp für diesen Pin festlegen, damit er weiß, wann Ihre Apps wissen müssen, dass etwas aufgetreten ist.

Die Triggertypen bestehen aus EDGE_NONE, EDGE_RISING, EDGE_FALLING und EDGE_BOTH. Wenn eine Taste gedrückt wird, tritt ein ansteigendes Ereignis auf, wenn die Tastenschaltung abgeschlossen ist und ein Hochspannungssignal am physischen Pin erscheint. Ein fallendes Ereignis tritt auf, wenn die Taste losgelassen wird. Ihr Code wird über Änderungen informiert, die auf der Art des von Ihnen festgelegten Triggers basieren.

GPIO input component ButtonGPIO input component ButtonGPIO input component Button

Nachdem Ihr GPIO auf Edge-Trigger wartet, müssen Sie einen GpioCallback erstellen, um den Wert der GPIO-Komponente in Ihrer App zu registrieren.

Sobald Ihr Rückruf erstellt wurde, registrieren Sie ihn bei Ihrem Gpio-Objekt.

Wenn Ihr GPIO-Pin Informationen schreibt, müssen Sie die Richtung als DIRECTION_OUT_INITIALLY_LOW oder DIRECTION_OUT_INITIALLY_HIGH festlegen, je nachdem, ob die Komponente ein- oder ausgeschaltet werden soll. Für einen Ausgangspin sind keine Triggertypen erforderlich.

Um auf das Gerät zu schreiben, können Sie setValue(boolean) für das Gpio-Objekt aufrufen, um den Status der Komponente festzulegen.

Sobald Ihre App ausgeführt wurde, müssen Sie die Registrierung Ihres Eingaberückrufs aufheben, falls er erstellt und registriert wurde, und den Zugriff auf das Peripheriegerät mithilfe der close()-Methode in onDestroy() schließen.

PWM

PWM-Geräte (Pulse Width Modulation) verwenden den Wechsel digitaler Zustände, die als proportionales Steuersignal bezeichnet werden, um zu funktionieren. Es sind drei Hauptteile eines proportionalen Steuersignals zu beachten:

  • Frequenz: Hier wird beschrieben, wie oft sich der Ausgangsimpuls wiederholt. Die Maßeinheit für die Frequenz ist Hertz (Hz).
  • Arbeitszyklus: Dies ist die Breite eines Impulses innerhalb einer eingestellten Frequenz. Der Arbeitszyklus wird als Prozentsatz hoher Signale innerhalb einer Frequenz ausgedrückt, sodass ein Zyklus, der die Hälfte der Zeit abgelaufen ist, einen Arbeitszyklus von 50% haben würde.
  • Zeitraum: Dies ist die Zeit, die für jeden Auf- / Ab-Zyklus benötigt wird. Die Periode ist umgekehrt proportional zur Frequenz.

Durch Anpassen des Arbeitszyklus eines Signals können Sie die durchschnittliche Einschaltzeit einer Welle steuern. Unten sehen Sie ein Beispiel für ein 50% -Periodensignal.

Example of a PWM signalExample of a PWM signalExample of a PWM signal

Einige Geräte, die ein PWM-Signal verwenden können, umfassen Servomotoren, die die Frequenz zur Bestimmung ihrer Position verwenden, oder eine LED-Matrix, die das PWM-Signal zum Einstellen der Helligkeit verwenden kann.

PWM servo motor componentPWM servo motor componentPWM servo motor component

Selbst mit nur Motoren und GPIO-Geräten können Sie eine große Anzahl von IoT-Geräten erstellen, z. B. einen "intelligenten" Kratzbaum mit motorisiertem Laser.

Ähnlich wie bei GPIO können Sie eine Liste der verfügbaren PWM-Ports abrufen, indem Sie einen PeripheralManagerService erstellen und getPwmList() aufrufen. Auf einem Raspberry Pi sieht diese Liste folgendermaßen aus:

Sobald Sie den Namen des PWM-Pins kennen, den Sie verwenden möchten, können Sie mithilfe der openPwm(String)-Methode eine Verbindung zu diesem Peripheriegerät herstellen. Dies muss in einen try/catch-Block eingeschlossen werden, um die Möglichkeit einer ausgelösten IOException zu behandeln.

Sobald Sie eine Verbindung zu Ihrem PWM-Pin hergestellt haben, können Sie Einstellungen wie Frequenz und Arbeitszyklus steuern.

Bevor Sie mit Ihrer App fertig sind und die Activity zerstören, müssen Sie die Verbindung schließen und den Verweis auf Ihr PWM-Gerät freigeben.

I2C

Mit dem I2C-Bus (Inter-Integrated Circuit) kann Ihr Projekt über eine physische Verbindung mit mehreren Geräten kommunizieren und komplexe Daten mit nur wenigen Pins Ihres Pi oder eines anderen eingebetteten Geräts senden. I2C verwendet die synchrone Kommunikation zwischen Geräten und stützt sich auf ein Taktsignal, um sicherzustellen, dass die Geräte zum richtigen Zeitpunkt reagieren.

Das Gerät, das das Taktsignal ausgibt, das häufig Ihr Android Things-Gerät ist, wird als Master bezeichnet. Alle angeschlossenen Peripheriegeräte, die dieses Signal empfangen, werden als Slaves bezeichnet.

Im Gegensatz zu PWM und GPIO, die nur einen einzigen Pin benötigen, benötigen I2C-Geräte drei Verbindungen:

  • Geteiltes Taktsignal (abgekürzt SCL), das das Taktsignal vom Master-Gerät an die Slave-Geräte ausgibt.
  • Shared Data Line (abgekürzt SDA) ist die Verbindung, die für die eigentliche Datenübertragung verwendet wird. Da I2C ein synchroner (Halbduplex-) Kommunikationsstandard ist, dh Daten können sich jeweils nur in eine Richtung bewegen, darf zu einem bestimmten Zeitpunkt nur ein Gerät diese Verbindung verwenden.
  • Eine elektrische Erdungsverbindung.

Es ist erwähnenswert, dass jedes I2C-Slave-Gerät mit einer festgelegten Adresse programmiert ist und nur reagiert, wenn das Master-Gerät eine Datenanforderung für diese bestimmte Adresse stellt.

I2C bus diagramI2C bus diagramI2C bus diagram

Einige Peripheriegeräte, die diese Verbindungsmethode verwenden können, umfassen segmentierte LED-Matrixanzeigen und verschiedene fortschrittliche Sensoren.

I2C OLED componentI2C OLED componentI2C OLED component

Jedes Android Things-Gerät verfügt über eine Reihe von Pins, die für I2C verwendet werden. Diese finden Sie in der Dokumentation zu Ihrem spezifischen Prototyping-Board. Für den Raspberry Pi können Sie auf das Pinbelegungsbild oben in diesem Artikel verweisen, in dem angegeben ist, dass SDA und SDL die Pins 3 und 5 sind. Um den Namen Ihres I2C zu ermitteln, können Sie den folgenden Code ausführen:

Das obige Code-Snippet gibt Folgendes auf einem Raspberry Pi aus:

Sobald Sie den Namen Ihres I2C-Busses kennen, können Sie über deren Softwareadresse eine Verbindung zu Geräten auf diesem Bus herstellen. Sie finden die Softwareadresse und andere Verbindungsdetails auf niedriger Ebene im "Datenblatt" der Peripheriekomponente - erforderliche Lektüre, wenn Sie ein Peripheriegerät für ein eingebettetes Projekt verwenden möchten!

Bei der Kommunikation mit einem Gerät über I2C können Sie das SMBus-Protokoll (System Management Bus) verwenden, um Daten in Registern abzulegen oder Daten abzurufen, die in Registern auf jedem Peripheriegerät gespeichert wurden. Dies erfolgt unter Verwendung der Geräteadresse und der Registeradresse. Mit Android Things können Sie einzelne Bytes aus einem Register oder Gruppen von Bytes aus mehreren Registern mit den folgenden Methoden lesen oder schreiben:

  • readRegByte() und writeRegByte(): Liest oder schreibt ein einzelnes Byte aus einem bestimmten Register.
  • readRegWord() und writeRegWord(): Lesen oder Schreiben von Bytes aus zwei sequentiellen Registern auf einem Peripheriegerät im Little-Endian-Format.
  • readRegBuffer() und writeRegBuffer(): Lesen oder Schreiben von Bytes aus bis zu 32 aufeinanderfolgenden Registern. Werte werden als byte array geschrieben oder abgerufen.

Wenn Ihre App auf Ihrem Android Things-Gerät geschlossen werden kann, müssen Sie die Registrierung Ihres I2C-Busses aufheben.

SPI

SPI-Verbindungen (Serial Peripheral Interface) funktionieren ähnlich wie I2C-Verbindungen, unterstützen jedoch die Vollduplex-Kommunikation. Dies bedeutet, dass Daten gleichzeitig gelesen und in Peripheriegeräte geschrieben werden können, anstatt dass das Master-Gerät Informationen von den Slave-Peripheriegeräten anfordern muss. Ein Taktsignal ist weiterhin erforderlich, um den Datenfluss von mehreren Geräten auf dem SPI-Signalbus zu steuern. Für SPI sind mindestens vier Verbindungen erforderlich:

  • Master Out Slave In (MOSI)
  • Master In Slave Out (MISO)
  • Taktsignal (CLK)
  • Gemeinsamer Boden (GND)

Darüber hinaus ist eine fünfte Verbindung erforderlich, wenn mehrere SPI-Geräte an einen SPI-Bus angeschlossen sind. Dies ist der Chip Select (CS), mit dem die Hardwareadresse von Peripheriegeräten signalisiert wird, damit Ihr Master-Gerät mit einem bestimmten Slave kommunizieren kann.

Einige Beispiele für Peripheriegeräte, die SPI verwenden, sind LED-Punktmatrixkarten und SD-Kartenleser. Es ist erwähnenswert, dass viele Peripheriegeräte, die I2C unterstützen, auch SPI unterstützen.

SPI supported SD card reader and MP3 player componentSPI supported SD card reader and MP3 player componentSPI supported SD card reader and MP3 player component

Genau wie in den vorherigen Beispielen müssen Sie den Namen der SPI-Verbindung auf Ihrem Android Things-Board kennen. Sie finden dies, indem Sie einen PeripheralManagerService erstellen und getSpiBusList() für dieses Objekt aufrufen. Auf einem Raspberry Pi steht Folgendes zur Verfügung:

Sobald Sie den Namen des SPI-Busses kennen, den Sie verwenden werden, können Sie eine Verbindung zu ihm herstellen.

Damit Geräte über den SPI-Bus kommunizieren können, müssen sie alle "dieselbe Sprache sprechen", dh sie müssen für dieselbe Taktrate und dasselbe Datenformat konfiguriert sein. Während einige Peripheriegeräte ihr Datenformat und ihre Taktrate anpassen können, können andere dies nicht. Da alle Geräte an einem SPI-Bus mit derselben Konfiguration arbeiten müssen, ist es wichtig, die Funktionen Ihrer Peripheriegeräte zu kennen, bevor Sie versuchen, sie in Ihren SPI-Bus aufzunehmen. Es gibt vier Einstellungen / Parameter, die für Ihren SPI-Bus eingestellt werden müssen:

  • SPI-Modus: Der SPI-Modus besteht aus zwei Hauptkomponenten: ob das Taktsignal hoch oder niedrig ist, während keine Daten übertragen werden, und welche Flanke eines Impulses zum Übertragen von Daten verwendet wird.
  • Frequenz: Dies stellt das gemeinsam genutzte Taktsignal in Hz dar und ist höchstwahrscheinlich ein Wert, der von den Fähigkeiten Ihrer Slave-Geräte bestimmt wird.
  • Bit-Begründung: Wird verwendet, um die Endianität für Ihre Daten festzulegen. Standardmäßig verwendet Android Things Big-Endian, wobei das wichtigste Big (MSB) an erster Stelle steht.
  • Bits pro Wort (BPW): Steuert, wie viele Bits an ein Slave-Gerät gesendet werden, bevor das Chipauswahlsignal umgeschaltet wird. Standardmäßig werden acht Bits pro Wort gesendet.

In Ihrem Java-Code für Android Things können Sie diese vier Werte auf Ihrem SPI-Bus folgendermaßen einstellen:

Wie Sie mit Ihren Geräten am SPI-Bus interagieren, hängt davon ab, ob Sie im Voll- oder Halbduplexmodus arbeiten. Wenn Ihre Geräte für Halbduplex konfiguriert sind, möchten Sie Daten zwischen den Slaves und dem Master-Gerät mit den Methoden read() und write() für das SpiDevice-Objekt austauschen. Wenn Sie im Vollduplexmodus arbeiten, sollten Sie die transfer()-Methode mit zwei Byte-Array-Puffern verwenden: einem mit den zu sendenden Daten und einem weiteren leeren Puffer zum Speichern von Antwortdaten.

Wenn Ihre App auf Ihrem Android Things-Gerät geschlossen werden kann, müssen Sie die Registrierung Ihres SPI-Geräts aufheben.

UART

Komplexere Peripheriegeräte wie LCD-Displays, SD-Kartenleser und GPS-Module verwenden bei der Kommunikation mit einem Master-Gerät häufig die serielle Kommunikation über UART-Ports. Mit UART können Geräte Rohdaten asynchron an einen Puffer auf einem anderen Gerät senden. Dieser Puffer wird dann in einer First-In-First-Out-Reihenfolge gelesen. Außerdem können sowohl das Datenformat als auch die Übertragungsgeschwindigkeit auf beiden angeschlossenen Geräten konfiguriert werden. Beide Geräte müssen sich auf eine Übertragungsgeschwindigkeit einigen, da UART kein Taktsignal unterstützt, die Übertragungsgeschwindigkeiten jedoch tendenziell schneller als I2C sind und Daten im Vollduplexmodus zwischen Geräten übertragen werden können. Im Gegensatz zu I2C und SPI ist pro UART-Verbindung nur ein angeschlossenes Peripheriegerät zulässig.

UART-Peripheriegeräte haben drei Adern:

  • RX, der zum Empfangen von Daten verwendet wird.
  • TX, mit dem Daten übertragen werden.
  • GND, elektrische Masse.
UART wiring diagramUART wiring diagramUART wiring diagram

Bei peripheren Komponenten werden diese Stifte im Allgemeinen wie folgt gekennzeichnet:

Simple UART componentSimple UART componentSimple UART component

Darüber hinaus können einige UART-Geräte zwei weitere Verbindungen zur Steuerung des Datenflusses enthalten:

  • Anfrage zum Senden (RTS)
  • Zum Senden freigeben (CLS)
UART component with RTS control signal pinUART component with RTS control signal pinUART component with RTS control signal pin

Ähnlich wie in allen vorherigen Beispielen müssen Sie den Namen der UART-Verbindung Ihres Android Things-Geräts kennen. Sie finden das mit folgendem Code:

Auf einem Raspberry Pi sieht die Protokollausgabe folgendermaßen aus:

Sobald Sie den Namen Ihrer UART-Verbindung kennen, können Sie ein Android Things UART-Gerät auf dieselbe Weise erstellen, wie Sie andere Geräteverbindungen geöffnet haben.

Sobald Sie Ihr Gerät haben, müssen Sie das Format für die Datenrahmen konfigurieren, die zwischen Geräten gesendet werden. Es sind vier Eigenschaften zu beachten:

  • Anzahl der Datenbits: UART kann zwischen fünf und neun Bits senden, um ein Datenzeichen darzustellen. Das Senden von weniger Bits ermöglicht eine schnellere Datenübertragungsrate, begrenzt jedoch den Bereich der Zeichen, die gesendet werden können.
  • Paritätsbit: Wird verwendet, um zu überprüfen, ob der Inhalt der Daten einer Übertragung eine gerade oder ungerade Zahl ergibt. Wenn die Parität auf keine gesetzt ist, wird das Paritätsbit aus der Übertragung entfernt. Dies wird zur Fehlerprüfung bei Übertragungen verwendet.
  • Stoppbits: Dies kann entweder auf 1 oder 2 Bits gesetzt werden. Die Übertragung wird für eine Dauer im Leerlauf sein, die der Anzahl der Stoppbits entspricht, um anzuzeigen, dass ein Datenrahmen beendet wurde.
  • Baudrate: Die Baudrate ist die Übertragungsgeschwindigkeit für Ihren Datenrahmen. Da UART keine Taktsignale enthält, müssen beide Geräte vor Beginn der Übertragung mit einer Baudrate konfiguriert werden.

Jede dieser Einstellungen kann auf einem UART-Gerät wie folgt konfiguriert werden:

Sie haben bereits erfahren, dass es für UART-Geräte zwei Verkabelungseinstellungen gibt, die mit zusätzlichen Steuersignalen und die ohne. Sie können Ihr UART-Gerät mithilfe der setHardwareFlowControl()-Methode im Code konfigurieren.

Sobald Sie Ihre Geräte konfiguriert haben, können Sie Daten von Ihrem Android Things-Board und Ihrem UART-Peripheriegerät lesen und schreiben. Das Schreiben erfolgt durch Aufrufen der Methode write() mit einem Byte-Array-Puffer und der Länge dieses Arrays.

Während Sie kontinuierlich Daten im Lesepuffer Ihres Geräts abfragen können, ist es besser, ein UartDeviceCallback-Objekt zu erstellen, das eine Methode namens onUartDeviceDataAvailable() bereitstellt, die ausgelöst wird, wenn Daten verfügbar sind. Wenn dies der Fall ist, können Sie Daten aus dem Datenpuffer Ihres Geräts lesen. Sie können diesen Rückruf mit Ihrem UART-Gerät mit dem registerUartDeviceCallback verknüpfen. Sie müssen jedoch daran denken, unregisterUartDeviceCallback aufzurufen, wenn Sie mit dem Rückruf fertig sind. Wenn Daten verfügbar sind, können Sie sie mithilfe der UART-Methode read() abrufen.

Wenn Sie mit Ihrer Activity fertig sind, müssen Sie den Verweis auf Ihr UART-Gerät schließen und ungültig machen.

Erweiterte E/A und zukünftige Updates

Während Sie mit der Peripherie-API mit fast jedem Gerät kommunizieren können, das mit Ihrem Android Things-Board verbunden werden kann, hat Google zusätzliche Unterstützung bereitgestellt, um das Erstellen Ihrer IoT-Geräte noch einfacher zu gestalten. In diesem Abschnitt werden einige der zusätzlichen Peripheriegeräte-Unterstützung vorgestellt, die über Android Things verfügbar sind.

Native I/O

Während Android Things eine einfache Möglichkeit für Android-Entwickler bietet, mit dem Android SDK und Java in die IoT-Entwicklung einzusteigen, gibt es in C und C++ bereits viele IoT-Apps, und andere Entwickler würden es aus verschiedenen Gründen vorziehen, in diesen Sprachen zu arbeiten. Um dies zu unterstützen, hat Google die Peripherie-API durch Unterstützung für native Anwendungen und das NDK ergänzt. Ich werde auf dieses Thema nicht näher eingehen, aber die Verbindungen werden auf sehr ähnliche Weise wie oben beschrieben hergestellt und verwendet.

WiFi und Bluetooth

Ohne eine Möglichkeit, eine Verbindung zum Internet herzustellen, wären IoT-Geräte einfach Dinge. Dank der integrierten drahtlosen Unterstützung können Ihre Android Things-Geräte eine Verbindung zum Internet herstellen und verschiedene Online-Ressourcen wie Firebase und andere Google-Dienste oder andere Back-End-Dienste verwenden. Mithilfe von Tools wie Google Play Services und der API für Verbindungen in der Nähe können Benutzer außerdem über ihr WLAN-Netzwerk direkt mit Ihrem Gerät kommunizieren.

Obwohl derzeit in den Entwicklervorschauversionen von Android Things nicht aktiviert, ist die Bluetooth-Konnektivität auch eine wichtige IoT-Funktion. Mit Bluetooth können Sie mehrere IoT-Geräte oder -Zubehörteile erstellen und diese über kurze Entfernungen kommunizieren lassen. Auf diese Weise verfügt jedes Gerät über zusätzliche Kontextinformationen zu seiner Umgebung, z. B. zu Hause oder am Arbeitsplatz eines Benutzers, um den Benutzer optimal bedienen zu können.

USB

Einige Geräte arbeiten mit USB-Anschlüssen für Prototypenkarten, obwohl diese in der aktuellen Iteration der Android Things-Entwicklervorschau nicht vollständig aktiviert sind. In der zweiten Entwicklervorschau hat Google der Sprachunterstützung USB-Audioausgang mit Text hinzugefügt, und Entwickler haben bestätigt, dass andere Geräte wie USB-Mikrofone funktionieren. Da USB-APIs in späteren Versionen von Android Things getestet und genehmigt werden, gibt es eine Vielzahl von Geräten, die einfach als Zubehör an Ihr IoT-Gerät angeschlossen werden können.

Kameras und Displays

Einige Geräte, wie z. B. der Raspberry Pi, verfügen über zusätzliche integrierte E/A-Anschlüsse, z. B. HDMI, Display und Kamera. Glücklicherweise sind alle diese Funktionen mit Android Things aktiviert, sodass Sie eine Kamera mit einem 15 cm langen Flachbandkabel anschließen können...

Raspberry Pi with connected camera moduleRaspberry Pi with connected camera moduleRaspberry Pi with connected camera module

... oder eine Anzeige über ein Flachbandkabel oder eine HDMI-Verbindung:

Raspberry Pi 5 display connected through HDMIRaspberry Pi 5 display connected through HDMIRaspberry Pi 5 display connected through HDMI

Abschluss

Herzliche Glückwünsche! Sie haben viel unternommen, aber unglaublich wertvolle Informationen zum Anschließen und Steuern von Peripheriegeräten mit einem Android Things-Board erhalten. Mit diesem Wissen sollten Sie in der Lage sein, verschiedene Hardwarekomponenten zu verbinden und mit ihnen zu kommunizieren.

Im nächsten Beitrag dieser Reihe werden wir unser Wissen über die Peripherie-API nutzen, um einen Softwaretreiber für eine GPIO-Bewegungssensorkomponente zu erstellen, der dann in einem größeren Android Things-Projekt verwendet werden kann.

In der Zwischenzeit lesen Sie einige unserer anderen Tutorials und Artikel zur Android-Entwicklung!

Advertisement
Advertisement
Looking for something to help kick start your next project?
Envato Market has a range of items for sale to help get you started.