Revision [d7ad982]
Letzte Änderung am 2019-11-19 13:20:41 durch Oksana Neopagitova
ADDITIONS
**Adressaten des Lehrangebotes:</span>** Studenten des Studienganges "Mobile Computing"
DELETIONS
**Adressaten des Lehrangebotes:</span>** Studenten des Studienganges "Mobile Computing"**
Revision [cad961b]
Bearbeitet am 2019-11-19 13:20:23 von Oksana Neopagitova
ADDITIONS
**<span style="color:#00386a">Tutor:</span>** Timmy Schieck
<span style="color:#00386a">
**Adressaten des Lehrangebotes:</span>** Studenten des Studienganges "Mobile Computing"**
**<span style="color:#00386a">
DELETIONS
**<span style="color:#00386a">Tutor:</span>** Timmy Schieck <span style="color:#00386a">
**Adressaten des Lehrangebotes:</span>** Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">
Revision [c73ca44]
Bearbeitet am 2019-11-19 12:41:13 von Oksana Neopagitova
ADDITIONS
**<span style="color:#00386a">Tutor:</span>** Timmy Schieck <span style="color:#00386a">
**Adressaten des Lehrangebotes:</span>** Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">
Ziel des Tutoriums:</span>**
DELETIONS
**<span style="color:#00386a">1. Tutor:</span>** Timmy Schieck <span style="color:#00386a">
**2. Adressaten des Lehrangebotes:</span>** Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">
3. Ziel des Tutoriums:</span>**
Revision [f66931e]
Bearbeitet am 2019-11-19 12:40:36 von Oksana Neopagitova
ADDITIONS
#### **<span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span>**

**<span style="color:#00386a">1. Tutor:</span>** Timmy Schieck <span style="color:#00386a">
**2. Adressaten des Lehrangebotes:</span>** Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">
3. Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverlässigkeit zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
Die App führt die Erkennung mittels eine trainierten neuronalen Netzes durch, was zuvor auf einem Computer trainiert wurde.
Das Training dieses Netzes benötigt Trainings-und Testdaten, die vorher aufgezeichnet werden.

Es werden dazu drei Anwendungen geschrieben:
1. eine App zum aufzeichen und labeln der gewünschten Muster
2. ein Computerprogramm welches die aufgezeichneten Trainingsdaten so verarbeitet wie das Smartphone, und danach das neuronale Netz trainiert
3. eine App die das trainierte neuronale Netz ausführt und damit die Bewegungen erkennt

Wenn nicht anders angegeben, bin ich der Urheber der Bilder, in dieser Wiki.

**<span style="color:#00386a">1. Datengewinnung/-erhebung:</span>**

Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:

>>* den (linearen) Beschleunigungssensor,
>>* das Gyroskop sowie
>>* den Schwerkraftsensor.

Es gibt weitere Sensoren, das sind aber die Grundlegenden.
Diese Sensoren werden genutzt um die Bewegungen in Signale umzuwandeln.

Genutztes Koordinatensystem

Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.

Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.

![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/1.png?width=300)
Abb.: Achsen eines Smartphones:
(Quelle: developer.android.com)

**Funktionsweise der App**

![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/2.png?width=300)
Abb.: Grafische Oberfläche der Aufzeichnungsanwendung

Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird. Zum Aufzeichnen wird der Knopf in der Mitte gedrückt und gehalten, wenn die Aufzeichnung beendet ist, den Knopf bitte loslassen. Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.

![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/3.png?width=300)
Abb.: Verzeichnis mit aufgezeichneten Datein auf Smartphone

In dem Bild lässt sich auch schon erkennen wie das Namesschema der Dateien ist:
>>1) rot - Typ der Geste (quadrat, circle, hline...)
>>1) grün - Zufallszahl
>>1) blau - Sensortyp (lin_acc, magf, grav..., bitte beachten es sind mehr Sensoren, als oben aufgeführt)
>>1) .csv

Die Dateien lassen sich entweder manuell per USB auf den PC übertragen (Ordner: Android/data/com.example.schieck.ga/files/*) oder per Email an eine zuvor eingestellte Adresse versenden. Sie enthalten die Bewegungsmuster die später genutzt werden um das neuronale Netz zu trainieren.

![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/4.png?width=300)
Abb.: Inhalt einer csv Datei

In dem Bild sieht man was der Sensor eigentlich macht, es wird zu einem bestimmten Zeitpunkt ein bestimmter Zustand gemessen. Die App schreibt dann diese Zustände in die Dateien.
Es liegen also timestamp-value-paare vor.

**Implementierung**

Namensschema:
[Geste].[Zufallszahl].[Sensortyp].csv

Das Namensschema hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, was sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.

![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/5.png?width=300)

Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein SensorManager genutzt und ein SensorEventListener (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
class MainActivity() : Activity(), SensorEventListener {
var sensor_manager: SensorManager? = null

...und im onCreate() Callback initialisiert.
sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager


Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
>>* Abtastraten

val delay = SensorManager.SENSOR_DELAY_FASTEST

![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/6.png?width=400)
_Die Quellcodes können von mir direkt erhalten werden, bitte schreiben sie mich an. <span style="text-decoration:underline;">schieck@stud.fh-sm.de</span>_

**<span style="color:#00386a">2. Vorverarbeitung der Daten:</span>**

**Anpassen der Zeitstempel**
Um die timestamps besser überschauen zu können, wird von allen timestamps der niedrigste abgezogen, das geschieht mit:
fun adjustTimestamps(sample: Sample): Sample {
>>>>>>>var first = sample.timestamp.first()
>>>>>>>var retVal = sample

>>>>>>>sample.timestamp.forEachIndexed { index, fl ->
>>>>>>>>>retVal.timestamp[index] -= first
>>>>>>>}
>>>>>>>return retVal
>>>>>}


**Betragsquadrat berechnen**
Mittels des Betragsquadrat werden aus den Werten für x, y und z, ein Wert gemacht. Dadurch wird erreicht das die Werte Orientierungsunabhängig sind.


TODO: hier gehört ne formel hin, aber
##### formel ...
##### formel funktioniert nicht...
fun AbsoluteSquare(sample: Sample): Sample {
>>>>>>>val sampleSize = sample.x.size
>>>>>>>val retVal = Sample(sample.sensor, sample.gesture)

>>>>>>>for (i in 0 until sampleSize) {
>>>>>>>>>val absSquare = Math.abs((sample.x[i] + sample.y[i] + sample.z[i]))
>>>>>>>>>retVal.absoluteSquare.add(absSquare)
>>>>>>>}
>>>>>>>return retVal
>>>>>}


**Fehlende Werte ermitteln**
Die Werte die von Android Sensoren zurückgeliefert werden, sind nicht äquidistant (gleicher zeitlicher Abstand zwischen den Messwerten). Das ist aber nötig um sie später einem maschinellem Lernalgorhythmus zuzuführen. Die Sensoren von Android Geräten haben i.d.R. eine Abtastrate von 20-80Hz. Daher ist, verbunden mit der Unsicherheit WANN bestimmte Sensoren, bestimmte Werte zurückliefern, eine starke Fluktuation zu erkennen.

![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/7.png?width=400)
Abb.: Nicht-Äquidistante Abstände bei den Timestamps


Um dieses Problem zu beheben kann man das Signal (linear) interpolieren. Dabei werden die fehlenden Punkte durch die Mittel der umliegenden Punkte aufgefüllt.

TODO: Formel für lineares interpolieren, die YAML für die wiki nervt echt, sie kommt nicht mal mit simplen formeln klar...
fun interpolate(sample: Sample): Sample {
>>>>>>>//require(count < 2) { "interpolate: illegal count!" }

>>>>>>>val retVal = sample

>>>>>>>for (i in 0 until sample.size) {
>>>>>>>>>retVal.timestamp[i] = sample.timestamp.first() + i * (sample.timestamp.last() - sample.timestamp.first()) / sample.size
>>>>>>>>>retVal.x[i] = sample.x.first() + i * (sample.x.last() - sample.x.first()) / sample.size
>>>>>>>>>retVal.y[i] = sample.y.first() + i * (sample.y.last() - sample.y.first()) / sample.size
>>>>>>>>>retVal.z[i] = sample.z.first() + i * (sample.z.last() - sample.z.first()) / sample.size
>>>>>>>}
>>>>>>>return retVal
>>>>>}

**Trainieren von OLVQ1**
DELETIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">Tutor:</span> **Timmy Schieck**<span style="color:#00386a">Adressaten des Lehrangebotes:</span> **Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverlässigkeit zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
Die App führt die Erkennung mittels eine trainierten neuronalen Netzes durch, was zuvor auf einem Computer trainiert wurde.
Das Training dieses Netzes benötigt Trainings-und Testdaten, die vorher aufgezeichnet werden.
Es werden dazu drei Anwendungen geschrieben:
1. eine App zum aufzeichen und labeln der gewünschten Muster
2. ein Computerprogramm welches die aufgezeichneten Trainingsdaten so verarbeitet wie das Smartphone, und danach das neuronale Netz trainiert
3. eine App die das trainierte neuronale Netz ausführt und damit die Bewegungen erkennt
Wenn nicht anders angegeben, bin ich der Urheber der Bilder, in dieser Wiki.
**<span style="color:#00386a">1. Datengewinnung/-erhebung:</span>**
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
>>* den (linearen) Beschleunigungssensor,
>>* das Gyroskop sowie
>>* den Schwerkraftsensor.
Es gibt weitere Sensoren, das sind aber die Grundlegenden.
Diese Sensoren werden genutzt um die Bewegungen in Signale umzuwandeln.
Genutztes Koordinatensystem
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/1.png?width=300)
Abb.: Achsen eines Smartphones:
(Quelle: developer.android.com)
**Funktionsweise der App**
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/2.png?width=300)
Abb.: Grafische Oberfläche der Aufzeichnungsanwendung
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird. Zum Aufzeichnen wird der Knopf in der Mitte gedrückt und gehalten, wenn die Aufzeichnung beendet ist, den Knopf bitte loslassen. Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/3.png?width=300)
Abb.: Verzeichnis mit aufgezeichneten Datein auf Smartphone
In dem Bild lässt sich auch schon erkennen wie das Namesschema der Dateien ist:
>>1) rot - Typ der Geste (quadrat, circle, hline...)
>>1) grün - Zufallszahl
>>1) blau - Sensortyp (lin_acc, magf, grav..., bitte beachten es sind mehr Sensoren, als oben aufgeführt)
>>1) .csv
Die Dateien lassen sich entweder manuell per USB auf den PC übertragen (Ordner: Android/data/com.example.schieck.ga/files/*) oder per Email an eine zuvor eingestellte Adresse versenden. Sie enthalten die Bewegungsmuster die später genutzt werden um das neuronale Netz zu trainieren.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/4.png?width=300)
Abb.: Inhalt einer csv Datei
In dem Bild sieht man was der Sensor eigentlich macht, es wird zu einem bestimmten Zeitpunkt ein bestimmter Zustand gemessen. Die App schreibt dann diese Zustände in die Dateien.
Es liegen also timestamp-value-paare vor.
**Implementierung**
Namensschema:
[Geste].[Zufallszahl].[Sensortyp].csv
Das Namensschema hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, was sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/5.png?width=300)
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein SensorManager genutzt und ein SensorEventListener (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
class MainActivity() : Activity(), SensorEventListener {
var sensor_manager: SensorManager? = null
...und im onCreate() Callback initialisiert.
sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
>>* Abtastraten
val delay = SensorManager.SENSOR_DELAY_FASTEST
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/6.png?width=400)
_Die Quellcodes können von mir direkt erhalten werden, bitte schreiben sie mich an. <span style="text-decoration:underline;">schieck@stud.fh-sm.de</span>_
**<span style="color:#00386a">2. Vorverarbeitung der Daten:</span>**
**Anpassen der Zeitstempel**
Um die timestamps besser überschauen zu können, wird von allen timestamps der niedrigste abgezogen, das geschieht mit:
fun adjustTimestamps(sample: Sample): Sample {
>>>>>>>var first = sample.timestamp.first()
>>>>>>>var retVal = sample
>>>>>>>sample.timestamp.forEachIndexed { index, fl ->
>>>>>>>>>retVal.timestamp[index] -= first
>>>>>>>}
>>>>>>>return retVal
>>>>>}
**Betragsquadrat berechnen**
Mittels des Betragsquadrat werden aus den Werten für x, y und z, ein Wert gemacht. Dadurch wird erreicht das die Werte Orientierungsunabhängig sind.
TODO: hier gehört ne formel hin, aber
##### formel ...
##### formel funktioniert nicht...
fun AbsoluteSquare(sample: Sample): Sample {
>>>>>>>val sampleSize = sample.x.size
>>>>>>>val retVal = Sample(sample.sensor, sample.gesture)
>>>>>>>for (i in 0 until sampleSize) {
>>>>>>>>>val absSquare = Math.abs((sample.x[i] + sample.y[i] + sample.z[i]))
>>>>>>>>>retVal.absoluteSquare.add(absSquare)
>>>>>>>}
>>>>>>>return retVal
>>>>>}
**Fehlende Werte ermitteln**
Die Werte die von Android Sensoren zurückgeliefert werden, sind nicht äquidistant (gleicher zeitlicher Abstand zwischen den Messwerten). Das ist aber nötig um sie später einem maschinellem Lernalgorhythmus zuzuführen. Die Sensoren von Android Geräten haben i.d.R. eine Abtastrate von 20-80Hz. Daher ist, verbunden mit der Unsicherheit WANN bestimmte Sensoren, bestimmte Werte zurückliefern, eine starke Fluktuation zu erkennen.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/7.png?width=400)
Abb.: Nicht-Äquidistante Abstände bei den Timestamps
Um dieses Problem zu beheben kann man das Signal (linear) interpolieren. Dabei werden die fehlenden Punkte durch die Mittel der umliegenden Punkte aufgefüllt.
TODO: Formel für lineares interpolieren, die YAML für die wiki nervt echt, sie kommt nicht mal mit simplen formeln klar...
fun interpolate(sample: Sample): Sample {
>>>>>>>//require(count < 2) { "interpolate: illegal count!" }
>>>>>>>val retVal = sample
>>>>>>>for (i in 0 until sample.size) {
>>>>>>>>>retVal.timestamp[i] = sample.timestamp.first() + i * (sample.timestamp.last() - sample.timestamp.first()) / sample.size
>>>>>>>>>retVal.x[i] = sample.x.first() + i * (sample.x.last() - sample.x.first()) / sample.size
>>>>>>>>>retVal.y[i] = sample.y.first() + i * (sample.y.last() - sample.y.first()) / sample.size
>>>>>>>>>retVal.z[i] = sample.z.first() + i * (sample.z.last() - sample.z.first()) / sample.size
>>>>>>>}
>>>>>>>return retVal
>>>>>}
**Trainieren von OLVQ1**
***
CategoryTutorienFKITSS18;CategoryTutorienFKITSS19
Revision [45296aa]
Bearbeitet am 2019-04-10 15:34:50 von ClaudiaMichel
ADDITIONS
***
CategoryTutorienFKITSS18;CategoryTutorienFKITSS19
Revision [d4188a9]
Bearbeitet am 2018-11-08 10:58:41 von FabianEndres
ADDITIONS
Es werden dazu drei Anwendungen geschrieben:
1. eine App zum aufzeichen und labeln der gewünschten Muster
2. ein Computerprogramm welches die aufgezeichneten Trainingsdaten so verarbeitet wie das Smartphone, und danach das neuronale Netz trainiert
3. eine App die das trainierte neuronale Netz ausführt und damit die Bewegungen erkennt
Wenn nicht anders angegeben, bin ich der Urheber der Bilder, in dieser Wiki.
**<span style="color:#00386a">1. Datengewinnung/-erhebung:</span>**
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
>>* den (linearen) Beschleunigungssensor,
>>* das Gyroskop sowie
>>* den Schwerkraftsensor.
Es gibt weitere Sensoren, das sind aber die Grundlegenden.
Diese Sensoren werden genutzt um die Bewegungen in Signale umzuwandeln.
Genutztes Koordinatensystem
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/1.png?width=300)
Abb.: Achsen eines Smartphones:
(Quelle: developer.android.com)
**Funktionsweise der App**
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/2.png?width=300)
Abb.: Grafische Oberfläche der Aufzeichnungsanwendung
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird. Zum Aufzeichnen wird der Knopf in der Mitte gedrückt und gehalten, wenn die Aufzeichnung beendet ist, den Knopf bitte loslassen. Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/3.png?width=300)
Abb.: Verzeichnis mit aufgezeichneten Datein auf Smartphone
In dem Bild lässt sich auch schon erkennen wie das Namesschema der Dateien ist:
>>1) rot - Typ der Geste (quadrat, circle, hline...)
>>1) grün - Zufallszahl
>>1) blau - Sensortyp (lin_acc, magf, grav..., bitte beachten es sind mehr Sensoren, als oben aufgeführt)
>>1) .csv
Die Dateien lassen sich entweder manuell per USB auf den PC übertragen (Ordner: Android/data/com.example.schieck.ga/files/*) oder per Email an eine zuvor eingestellte Adresse versenden. Sie enthalten die Bewegungsmuster die später genutzt werden um das neuronale Netz zu trainieren.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/4.png?width=300)
Abb.: Inhalt einer csv Datei
In dem Bild sieht man was der Sensor eigentlich macht, es wird zu einem bestimmten Zeitpunkt ein bestimmter Zustand gemessen. Die App schreibt dann diese Zustände in die Dateien.
Es liegen also timestamp-value-paare vor.
**Implementierung**
Namensschema:
[Geste].[Zufallszahl].[Sensortyp].csv
Das Namensschema hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, was sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/5.png?width=300)
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein SensorManager genutzt und ein SensorEventListener (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
class MainActivity() : Activity(), SensorEventListener {
var sensor_manager: SensorManager? = null
...und im onCreate() Callback initialisiert.
sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.
>>* Abtastraten
val delay = SensorManager.SENSOR_DELAY_FASTEST
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/6.png?width=400)
_Die Quellcodes können von mir direkt erhalten werden, bitte schreiben sie mich an. <span style="text-decoration:underline;">schieck@stud.fh-sm.de</span>_
**<span style="color:#00386a">2. Vorverarbeitung der Daten:</span>**
**Anpassen der Zeitstempel**
Um die timestamps besser überschauen zu können, wird von allen timestamps der niedrigste abgezogen, das geschieht mit:
fun adjustTimestamps(sample: Sample): Sample {
>>>>>>>var first = sample.timestamp.first()
>>>>>>>var retVal = sample
>>>>>>>sample.timestamp.forEachIndexed { index, fl ->
>>>>>>>>>retVal.timestamp[index] -= first
>>>>>>>}
>>>>>>>return retVal
>>>>>}
**Betragsquadrat berechnen**
Mittels des Betragsquadrat werden aus den Werten für x, y und z, ein Wert gemacht. Dadurch wird erreicht das die Werte Orientierungsunabhängig sind.
TODO: hier gehört ne formel hin, aber
##### formel ...
##### formel funktioniert nicht...
fun AbsoluteSquare(sample: Sample): Sample {
>>>>>>>val sampleSize = sample.x.size
>>>>>>>val retVal = Sample(sample.sensor, sample.gesture)
>>>>>>>for (i in 0 until sampleSize) {
>>>>>>>>>val absSquare = Math.abs((sample.x[i] + sample.y[i] + sample.z[i]))
>>>>>>>>>retVal.absoluteSquare.add(absSquare)
>>>>>>>}
>>>>>>>return retVal
>>>>>}
**Fehlende Werte ermitteln**
Die Werte die von Android Sensoren zurückgeliefert werden, sind nicht äquidistant (gleicher zeitlicher Abstand zwischen den Messwerten). Das ist aber nötig um sie später einem maschinellem Lernalgorhythmus zuzuführen. Die Sensoren von Android Geräten haben i.d.R. eine Abtastrate von 20-80Hz. Daher ist, verbunden mit der Unsicherheit WANN bestimmte Sensoren, bestimmte Werte zurückliefern, eine starke Fluktuation zu erkennen.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/7.png?width=400)
Abb.: Nicht-Äquidistante Abstände bei den Timestamps
Um dieses Problem zu beheben kann man das Signal (linear) interpolieren. Dabei werden die fehlenden Punkte durch die Mittel der umliegenden Punkte aufgefüllt.
TODO: Formel für lineares interpolieren, die YAML für die wiki nervt echt, sie kommt nicht mal mit simplen formeln klar...
fun interpolate(sample: Sample): Sample {
>>>>>>>//require(count < 2) { "interpolate: illegal count!" }
>>>>>>>val retVal = sample
>>>>>>>for (i in 0 until sample.size) {
>>>>>>>>>retVal.timestamp[i] = sample.timestamp.first() + i * (sample.timestamp.last() - sample.timestamp.first()) / sample.size
>>>>>>>>>retVal.x[i] = sample.x.first() + i * (sample.x.last() - sample.x.first()) / sample.size
>>>>>>>>>retVal.y[i] = sample.y.first() + i * (sample.y.last() - sample.y.first()) / sample.size
>>>>>>>>>retVal.z[i] = sample.z.first() + i * (sample.z.last() - sample.z.first()) / sample.size
>>>>>>>}
>>>>>>>return retVal
>>>>>}
**Trainieren von OLVQ1**
Revision [8750fb0]
Bearbeitet am 2018-11-08 09:55:28 von ClaudiaMichel
ADDITIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">Tutor:</span> **Timmy Schieck**<span style="color:#00386a">Adressaten des Lehrangebotes:</span> **Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverlässigkeit zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
Die App führt die Erkennung mittels eine trainierten neuronalen Netzes durch, was zuvor auf einem Computer trainiert wurde.
Das Training dieses Netzes benötigt Trainings-und Testdaten, die vorher aufgezeichnet werden.
DELETIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span>**
_**In Bearbeitung**_
_**TODO: wo kommt dieser Kommentar her?**_
**<span style="color:#00386a">Tutor:</span>** Timmy Schieck
**<span style="color:#00386a">Adressaten des Lehrangebotes:</span>**
Studenten des Studienganges "Mobile Computing"
**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
Revision [4e53c38]
Bearbeitet am 2018-11-07 15:40:09 von schieck
ADDITIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span>**
_**In Bearbeitung**_
_**TODO: wo kommt dieser Kommentar her?**_
**<span style="color:#00386a">Tutor:</span>** Timmy Schieck
**<span style="color:#00386a">Adressaten des Lehrangebotes:</span>**
Studenten des Studienganges "Mobile Computing"
**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
DELETIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">Tutor:</span> **Timmy Schieck**<span style="color:#00386a">Adressaten des Lehrangebotes:</span> **Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverlässlichkeit
Revision [a136d61]
Bearbeitet am 2018-11-05 22:00:36 von SebastianPrang
ADDITIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">Tutor:</span> **Timmy Schieck**<span style="color:#00386a">Adressaten des Lehrangebotes:</span> **Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverlässlichkeit
DELETIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span>**
_**In Bearbeitung**_
**<span style="color:#00386a">Tutor:</span>** Timmy Schieck
**<span style="color:#00386a">Adressaten des Lehrangebotes:</span>**
Studenten des Studienganges "Mobile Computing"
**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
Revision [d1ab3ec]
Bearbeitet am 2018-11-05 19:06:03 von schieck
ADDITIONS
**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten mit einer hohen Zuverl
DELETIONS
**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
# <span style="color:#00386a">A. Datengewinnung/-erhebung:</span>
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
* den [(linearen) Beschleunigungssensor](https://de.wikipedia.org/wiki/Beschleunigungssensor),
* das [Gyroskop](https://de.wikipedia.org/wiki/Kreiselinstrument) sowie
* den [Schwerkraftsensor](https://de.wikipedia.org/wiki/Bewegungssensor).
Diese werden hier genutzt, um die Datenbasis anzulegen und später die zu erkennenden Gesten aufzuzeichnen bzw. die Gestenerkennung selbst durchzuführen.
**Genutztes Koordinatensystem**
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
Achsen eines Smartphones: [https://developer.android.com/images/axis_device.png](https://developer.android.com/images/axis_device.png)
**Funktionsweise der App**
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird.
Danach wird der Knopf in der Mitte unten gerückt gehalten und die Geste aufgezeichnet. Als letztes wird der Knopf wieder losgelassen.
Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
![text](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/Kh5jBZL.jpg)
Abb.: MainActivity.xml
##### Implementierung
Als erstes schreiben wir die App, die aus den Sensorwerten Listen mit timestamp-value-Paaren erstellt und diese in seperate Dateien schreibt.
Es werden csv ("comma seperated value" -> "Komma getrennte Werte") Dateien generiert. Jeweils pro Sensor und Geste, eine Datei.
Der Dateiname wird nach folgendem Schema gebildet:
[Geste].[Zufallszahl].[Sensortyp].csv
Das hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, welche Werte sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien
von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
>>* [https://i.imgur.com/slhwby9.png](https://i.imgur.com/slhwby9.png)
>>* [https://i.imgur.com/UGIACfM.png](https://i.imgur.com/UGIACfM.png)
In diesen Dateien ist in der ersten Spalte der timestamp (in Nanosekunden) der vom System vergeben wird zu sehen,
in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die
Dateien in der Größe variierern.
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein [https://developer.android.com/reference/android/hardware/SensorManager
SensorManager](https://developer.android.com/reference/android/hardware/SensorManager
SensorManager) genutzt und ein
[https://developer.android.com/reference/android/hardware/SensorEventListener
SensorEventListener](https://developer.android.com/reference/android/hardware/SensorEventListener
SensorEventListener) (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
%%class MainActivity() : Activity(), SensorEventListener {%% %% var sensor_manager: SensorManager? = null%%
...und im onCreate() Callback initialisiert.
%% sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager %%
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.

>>* [https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Abtastraten](https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Abtastraten)
%%val delay = SensorManager.SENSOR_DELAY_FASTEST%%
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/5RGMxJh.png?width=1024)
Abb.: Funktionsweise der Aufzeichnungsroutine
Quellcodes/Gesten aufzeichnen:
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/anweisungen.png?width=200)
Abb.: Beschreibung der Gesten die mit dem Programm aufgezeichnet werden sollen.
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/iclauncherbackground.png?width=300)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/activitymain.png?width=300)
**<span style="color:#00386a">Z. Literaturhinweise:</span>**
https://developer.android.com/reference/android/hardware/SensorEvent
***
CategoryTutorienFKITSS18
Revision [6f635eb]
Bearbeitet am 2018-11-01 18:39:55 von schieck
ADDITIONS
Abb.: MainActivity.xml
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/5RGMxJh.png?width=1024)
Abb.: Funktionsweise der Aufzeichnungsroutine
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/anweisungen.png?width=200)
Abb.: Beschreibung der Gesten die mit dem Programm aufgezeichnet werden sollen.
DELETIONS
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/5RGMxJh.png?width=800)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
[Quellcodes der App](/files/TutoriumMobileEingebetteteIntelligenzSS18/Quellcodes-Gesten-Aufzeichnen.zip)
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/anweisungen.png?width=100)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
Revision [71bc3df]
Bearbeitet am 2018-10-18 14:16:47 von ClaudiaMichel
ADDITIONS
***
CategoryTutorienFKITSS18
Revision [39b0a39]
Bearbeitet am 2018-09-19 16:00:52 von ClaudiaMichel
ADDITIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span>**
_**In Bearbeitung**_
**<span style="color:#00386a">Tutor:</span>** Timmy Schieck
**<span style="color:#00386a">Ziel des Tutoriums:</span>**
Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten zu erkennen. z.B. Kreise, Linien, Quadrate, etc.
**<span style="color:#00386a">Adressaten des Lehrangebotes:</span>**
Die meisten Android-Smartphones verfügen über mindestens drei Sensoren zur Bewegungserkennung:
* den [(linearen) Beschleunigungssensor](https://de.wikipedia.org/wiki/Beschleunigungssensor),
* das [Gyroskop](https://de.wikipedia.org/wiki/Kreiselinstrument) sowie
* den [Schwerkraftsensor](https://de.wikipedia.org/wiki/Bewegungssensor).
Diese werden hier genutzt, um die Datenbasis anzulegen und später die zu erkennenden Gesten aufzuzeichnen bzw. die Gestenerkennung selbst durchzuführen.
**Genutztes Koordinatensystem**
Das Koordinatensystem ist relativ zum Bildschirm des Telefons in seiner Standardausrichtung definiert.
Die Achsen werden nicht vertauscht, wenn sich die Bildschirmausrichtung des Geräts ändert.
Die X-Achse ist horizontal und zeigt nach rechts, die Y-Achse ist vertikal und zeigt nach oben und die
Z-Achse zeigt zur Außenseite der Vorderseite des Bildschirms. In diesem System haben Koordinaten hinter dem Bildschirm negative Z-Werte.
Achsen eines Smartphones: [https://developer.android.com/images/axis_device.png](https://developer.android.com/images/axis_device.png)
**Funktionsweise der App**
Auf der linken Seite wird die Geste eingestellt die aufgezeichnet wird.
Danach wird der Knopf in der Mitte unten gerückt gehalten und die Geste aufgezeichnet. Als letztes wird der Knopf wieder losgelassen.
Danach schreibt die App selbständig die Dateien mit den entsprechenden Sensorwerten in den Speicher des Telefons.
![text](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/Kh5jBZL.jpg)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
##### Implementierung
Als erstes schreiben wir die App, die aus den Sensorwerten Listen mit timestamp-value-Paaren erstellt und diese in seperate Dateien schreibt.
Es werden csv ("comma seperated value" -> "Komma getrennte Werte") Dateien generiert. Jeweils pro Sensor und Geste, eine Datei.
Der Dateiname wird nach folgendem Schema gebildet:
[Geste].[Zufallszahl].[Sensortyp].csv
Das hat die Funktion, das nicht erst die Datei geöffnet werden muss um zu wissen, welche Werte sie enthält.
Die Zufallszall verhindert (oder macht es zumindest sehr unwahrscheinlich) das man nacharbeiten muss, und Dateien
von Hand umbenennen, falls man Dateien aus mehreren Quellen hat.
>>* [https://i.imgur.com/slhwby9.png](https://i.imgur.com/slhwby9.png)
>>* [https://i.imgur.com/UGIACfM.png](https://i.imgur.com/UGIACfM.png)
In diesen Dateien ist in der ersten Spalte der timestamp (in Nanosekunden) der vom System vergeben wird zu sehen,
in den letzten drei Spalten stehen die Werte (in m/s^2). Je nachdem was für eine Geste aufgezeichnet wurde, können die
Dateien in der Größe variierern.
Damit die App Sensorwerte vom Betriebssystem empfangen kann, wird ein [https://developer.android.com/reference/android/hardware/SensorManager
SensorManager](https://developer.android.com/reference/android/hardware/SensorManager
SensorManager) genutzt und ein
[https://developer.android.com/reference/android/hardware/SensorEventListener
SensorEventListener](https://developer.android.com/reference/android/hardware/SensorEventListener
SensorEventListener) (stellt Callback zur Verfügung, das die Sensorwerte vom Betriebssystem entgegenimmt) implementiert.
%%class MainActivity() : Activity(), SensorEventListener {%% %% var sensor_manager: SensorManager? = null%%
...und im onCreate() Callback initialisiert.
%% sensor_manager = getSystemService(Context.SENSOR_SERVICE) as SensorManager %%
Zusatzlich wird ein Variable deklariert die die Abtastrate der Sensoren festlegt. Sie bieten nur grobe Richtwerte, da sich die in den Smartphones verbauten Sensoren, von Gerät zu Gerät unterscheiden, und sich damit auch die Abtastraten unterscheiden.

>>* [https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Abtastraten](https://developer.android.com/reference/android/hardware/SensorManager.html#SENSOR_DELAY_FASTEST
Abtastraten)
%%val delay = SensorManager.SENSOR_DELAY_FASTEST%%
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/5RGMxJh.png?width=800)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
[Quellcodes der App](/files/TutoriumMobileEingebetteteIntelligenzSS18/Quellcodes-Gesten-Aufzeichnen.zip)
Quellcodes/Gesten aufzeichnen:
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/anweisungen.png?width=100)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/iclauncherbackground.png?width=300)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
![image](/uploads/TutoriumMobileEingebetteteIntelligenzSS18/activitymain.png?width=300)
**<span style="color:red">Bitte ergänzen: Abb.: Titel der Abbildung, Quelle, Datum</span>**
**<span style="color:#00386a">Z. Literaturhinweise:</span>**
https://developer.android.com/reference/android/hardware/SensorEvent
DELETIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">Tutor:</span> **Timmy Schieck**<span style="color:#00386a">Ziel des Tutoriums:</span> **Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten zu erkennen. z.B. Kreise, Linien, Quadrate, etc.**<span style="color:#00386a">Adressaten des Lehrangebotes:</span>**
Die meisten Android-Smartphones verf
Revision [caa24e1]
Bearbeitet am 2018-09-18 20:37:28 von schieck
ADDITIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">Tutor:</span> **Timmy Schieck**<span style="color:#00386a">Ziel des Tutoriums:</span> **Es wird eine App fuer Android erstellt, die in der Lage ist, in die Luft "gemalte" Gesten zu erkennen. z.B. Kreise, Linien, Quadrate, etc.**<span style="color:#00386a">Adressaten des Lehrangebotes:</span>**
Studenten des Studienganges "Mobile Computing"
# <span style="color:#00386a">A. Datengewinnung/-erhebung:</span>
Die meisten Android-Smartphones verf
DELETIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">A. Tutor/in:</span> **Timmy Schieck**<span style="color:#00386a">B. Ziel des Tutoriums:</span> **Vermittlung grundlegender praktischer Kenntnisse auf dem Gebiet der Sensorprogrammierung auf Android, sowie der Mustererkennung mit Python.**<span style="color:#00386a">C. Adressaten des Lehrangebotes:</span> **Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">D. Veranstaltungsinhalte:</span>**
1. Erstellung einer Android Anwendung zum Aufzeichnen von Sensordaten.
2. Vorverarbeitung der gewonnenen Sensordaten, um die Mustererkennung darauf auszuführen.
3. Trainieren eines Models mit den vorhandenen Daten.
4. Implementation des Models auf Android.
**<span style="color:#00386a">E. Literaturhinweise:</span>**
https://developer.android.com/reference/android/hardware/SensorEvent
Revision [6a88f67]
Bearbeitet am 2018-08-20 16:50:17 von ClaudiaMichel
DELETIONS
***
CategoryInfoTutorien
Revision [f6ef3cf]
Die älteste bekannte Version dieser Seite wurde von ClaudiaMichel am 2018-05-07 16:29:57 erstellt
ADDITIONS
#### <span style="color:#00386a">Tutorium Mobile und Eingebettete Intelligenz</span> ****<span style="color:#00386a">A. Tutor/in:</span> **Timmy Schieck**<span style="color:#00386a">B. Ziel des Tutoriums:</span> **Vermittlung grundlegender praktischer Kenntnisse auf dem Gebiet der Sensorprogrammierung auf Android, sowie der Mustererkennung mit Python.**<span style="color:#00386a">C. Adressaten des Lehrangebotes:</span> **Studenten des Studienganges "Mobile Computing"**<span style="color:#00386a">D. Veranstaltungsinhalte:</span>**
1. Erstellung einer Android Anwendung zum Aufzeichnen von Sensordaten.
2. Vorverarbeitung der gewonnenen Sensordaten, um die Mustererkennung darauf auszuführen.
3. Trainieren eines Models mit den vorhandenen Daten.
4. Implementation des Models auf Android.
**<span style="color:#00386a">E. Literaturhinweise:</span>**
https://developer.android.com/reference/android/hardware/SensorEvent
***
CategoryInfoTutorien