-
Notifications
You must be signed in to change notification settings - Fork 0
/
E03_Bewegungsmessung.qmd
204 lines (157 loc) · 11.2 KB
/
E03_Bewegungsmessung.qmd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
---
title: "Bewegungsmessung"
author: "Pia Bereuter"
date: today
other-links:
- text: Kapitel PDF
icon: file-pdf
href: chapters/E03_Bewegungsmessung.pdf
code-links:
- text: Ausgangsdaten
icon: file-zip
href: data/E03_Bewegungsmessung.zip
resources:
- data/E03_Bewegungsmessung.zip
abstract: "Bewegungssensoren werden heute fast allgegenwärtig in vielen Bereichen eingesetzt, wie in Smartphones oder auch vielen Messgeräten der Geomatik. Diese Übung führt in die Funktionsweise von MEMS Bewegungssensoren ein und zeigt wie Bewegungsmessungen mit einem ICM20948 9DoF Motion Sensor durchgeführt werden können."
---
## Einführung
Ziel dieser Übung ist es Bewegungsmessung mit inertialen Messeinheiten (IMU)\index{IMU} über den ICM20948 Bewegungssensor kennen zu lernen und die Sensordaten auszulesen und testen. Der *ICM20948* ist ein 9DoF Bewegungssensor, der über eine I2C Schnittstelle mit dem Raspberry Pi verbunden wird und einer Python Library angesteuert werden kann.
**Unterlagen:** *<i class="bi-file-zip"></i> E03_Bewegungsmessung.zip*
**Vorbereitung**
- Schaut das Video zur Funktionsweise von MEMS Bewegungssensoren
- Video: [How MEMS Accelerometer Gyroscope Magnetometer Work](https://www.youtube.com/embed/eqZgxR6eRjo?si=u28t9yfD4BLPeYGd) (bis Minute 2:50), sowie folgendes
- Video: [Bosch Funktionsprinzip eines Beschleunigungssensors](https://www.youtube.com/embed/swCTbz5sIQM?si=Uga2sPKfiQW7EO6z)
- Studiere das Datenblatt zum ICM-20948 [@tdk2021]
- In welchen Temperaturbereichen kann der Sensor eingesetzt werden?
- Installiere auf deinem Smartphone die Applikation *[phyphox](https://phyphox.org)* und teste die Beschleunigungssensoren deines Smartphones.
::: {.content-visible when-format="html"}
{{< video https://www.youtube.com/embed/swCTbz5sIQM?si=Uga2sPKfiQW7EO6z >}}
:::
::: {.content-visible unless-format="html"}
](images/youtube_bosch_beschleunigungssensor.png)
:::
| **Unterlagen** | |
| ---------- | ------------------------------------------------------------ |
| Produkt | [ICM20948 Breakout](https://shop.pimoroni.com/products/icm20948) |
| Datenblatt | [ICM 20948](https://www.invensense.com/wp-content/uploads/2016/06/DS-000189-ICM-20948-v1.3.pdf) |
| GitHub | [icm20948-python](https://github.com/pimoroni/icm20948-python) |
## Beschleunigungssensoren IMU
Beschleunigungssensoren, oder inertiale Messeinheit (inertial measurement unit IMU) messen die Beschleunigung von Objekten mit dem Messprinzip der Trägheit und erfassen die Kraft die auf die Masse des Objekt wirkt, wenn dieses beschleunigt wird.
Für die Erfassung der sechs kinematischen Freiheitsgrade werden drei Achsen der Beschleunigung (Accelerometer) und drei Achsen der Rotation (Gyroskop) gemessen, die die Beschleunigungsmessung und Winkelgeschwindigkeit der Drehraten ausgeben. Für die Erfassung der Orientierung im Raum wird ein Magnetometer eingesetzt, welches die Ausrichtung des Objekts im Magnetfeld der Erde misst, um die Ausrichtung im Raum zu bestimmen. Wenn alle drei Sensoren kombiniert werden, spricht man von 9DoF Motion Sensoren, der neun Freiheitsgrade (9 Degrees of Freedom) misst.
Beschleunigungssensoren werden in vielen Anwendungen eingesetzt, wie z.B. in der Automobilindustrie (Auslösen von Airbags), der Luft- und Raumfahrt, der Medizintechnik (Beschleunigungssensoren in Herzschrittmachern) und der Unterhaltungselektronik (Smartphones für die Ausrichtung des Bildschirms).
## ICM20948 9DoF Motion Sensor\index{ICM20948}
Der ICM-20948 von [TDK InvenSense](https://invensense.tdk.com/products/motion-tracking/9-axis/icm-20948) (@fig-icm20948) ist ein 9-Achsen MEMS Bewegungssensor, mit einem 3-Achsen Gyroskop, einem 3-Achsen Beschleunigungssensor und einem 3-Achsen Magnetometer und sehr geringem Stromverbrauch. Er enthält zwei Chip, einen für die Bewegungsmessung mit Gyroskop und Beschleunigungssensor und einen zweiten für das Magnetometer.
MEMS\index{MEMS} sind mikroelektromechanische Systeme, die aus mikroskopisch kleinen mechanischen und elektrischen Komponenten bestehen. Diese werden meist aus Silicium hergestellt und sind im Falle von Beschleunigungssensoren sehr kleine Massen, die sich bei Beschleunigung bewegen und die Änderung der elektrischen Kapazität messen.
9DoF Motion Accelero-, Gyro-, Magnetometer
- ±2/±4/±8/±16 g 3-axis accelerometer
- ±250/±500/±1000/±2000 DPS (degrees per second) 3-axis gyroscope
- 3-axis compass with wide range up to ±4900 μT
- Python, C Library
- I2C interface (address: 0x68 or0x69)
- Qw/ST (Qwiic/STEMMA QT) connector
- I2C interface (address 0x68/0x69 (cut trace))
::: {.content-visible when-format="html"}
{#fig-icm20948}
:::
::: {.content-visible unless-format="html"}
{#fig-icm20948}
:::
## Übungsaufbau
- Schliesse den Raspberry Pi an Monitor, Keyboard und Maus an oder verbinde Dich mit diesem über SSH (und SFTP).
- Erstelle auf dem Raspberry Pi im `Documents` Ordner einen neuen Ordner `ICM20948`, in welchem Du Änderungen und neue Dateien für diese Übung speichern kannst.
- Schliesse den Sensor **ICM20948** an den Raspberry Pi über die Breakout Garden **I2C** Schnittstelle korrekt an (siehe [E01 Luftqualität](E01_Luftqualitaet.qmd)), so dass die Beschriftung der Anschlüsse am Sensor und bei der Schnittstelle übereinstimmen.
- Kontrolliere mit dem Befehl `i2cdetect -y 1` ob der Raspberry Pi mit dem Sensor verbunden ist. Der Sensor sollte auf der Adresse `0x68` erkannt werden.
- Aktiviere die virtuelle Environment von Python mit `source ~/.env/bin/activate` und kontrolliere, ob die Library `icm20948` installiert ist mit `python -c "import icm20948"`. Bei einer Fehlermeldung muss die Library in der aktivierten virtuellen Environment mit `pip install icm20948` installiert werden.
Wechsle in den Ordner *Documents* und kopiere mit folgenden Befehlen die Library auf Deinen Raspberry Pi.
``` bash
cd Documents
git clone https://github.com/pimoroni/icm20948-python
cd icm20948-python/examples
```
## Aufgabe 1: Bewegungsmessungen durchführen
Teste das Beispiel `read-all.py` im Ordner *examples*. Dieses Beispiel gibt die Messungen der einzelnen Bewegungsmessungen aus, der Beschleunigung, Winkelgeschwindigkeit und Orientierung mit dem Accelerometer, Gyrometer und Magnetometer.
Startet das Script mit `python read-all.py`^[Nicht vergessen zuerst die korrekte virtuelle Environment mit den installierten Libraries über `source ~/.env/bin/activate` zu starten]. Mit `Ctrl+c` kann das Script wieder gestopppt werden. Die Ausgabe sollte in etwa so aussehen (gekürzt):
``` bash
python read-all.py
read-all.py
Reads all ranges of movement: accelerometer, gyroscope and compass heading.
Press Ctrl+C to exit!
Accel: 01.01 -0.02 00.01
Gyro: -0.42 01.73 00.01
Mag: -86.85 57.45 34.05
Accel: 01.01 -0.02 00.02
Gyro: -0.40 01.50 -0.16
Mag: -85.35 55.50 34.80
```
Folgendes Code Snippet zeigt eine gekürzte Version des `read-all.py` Python Beispiels für die Ausgabe der Beschleunigungsmessung.
```{.python}
#!/usr/bin/env python
import time
from icm20948 import ICM20948
imu = ICM20948()
while True:
x, y, z = imu.read_magnetometer_data() # <1>
ax, ay, az, gx, gy, gz = imu.read_accelerometer_gyro_data() # <2>
print(""" # <3>
Accel: {:05.2f} {:05.2f} {:05.2f}
Gyro: {:05.2f} {:05.2f} {:05.2f}
Mag: {:05.2f} {:05.2f} {:05.2f}""".format(
ax, ay, az, gx, gy, gz, x, y, z
))
time.sleep(0.25) # <4>
```
1. Auslesen des Magnetometers (x,y,z)
2. Auslesen des Accelerometers (ax,ay,az) und Gyrometers (gx,gy,gz)
3. Messwerte auf der Konsole ausgeben
4. Warten 0.25 Sekunden (damit die Ausgabe nicht zu schnell ist)
::: {#exr-bewegungsmessung}
**Bewegungsmessung**\
- Führe das Beispiel `read-all.py` aus und beobachte die Messwerte.
- Versuche den Sensor jeweils leicht in eine Richtung zu bewegen, zu drehen, zu kippen und beobachte die Messwerte.
- Versuche den Sensor zu leicht zu schütteln und beobachte die Messwerte.
- Vergleiche die Messwerte mit den Messwerten deines Smartphones mit der App *phyphox*.
- Versucht zu eruieren wie die Achsen orientiert sind und vergleicht mit anderen Gruppen.
- Schreibe die Messwerte in eine Datei und visualisiere diese mit einem Plot, modifiziere dazu das Beispiel `read-all.py` und speichere die Datei als `read-csv.py`, so dass die Messungen zeilenweise mit einem Separator gespeichert werden. Ausgaben aus einem Plot können mit dem Befehl `python read-csv.py > imu_horizontal.csv` in eine Datei geschrieben werden. Nun könnt ihr verschiedene Versuche mit der IMU durchführen und in einer Datei speichern. Die Datei könnt ihr beispielsweise mit *LibreOffice Calc* oder *Excel* öffnen und die Daten visualisieren.
:::
::: {.content-hidden unless-meta="solution"}
::: {#sol-bewegungsmessung}
Die Datei `read-csv.py` mit den Messwerten mit Semikolon als Separator:
``` python
#!/usr/bin/env python
import time
from icm20948 import ICM20948
print("ax; ay; az; gx; gy; gz; x; y; z")
imu = ICM20948()
while True:
x, y, z = imu.read_magnetometer_data()
ax, ay, az, gx, gy, gz = imu.read_accelerometer_gyro_data()
print("""{:05.2f}; {:05.2f}; {:05.2f}; {:05.2f}; {:05.2f}; {:05.2f}; {:05.2f}; {:05.2f}; {:05.2f}""".format(
ax, ay, az, gx, gy, gz, x, y, z ))
time.sleep(0.25)
```
:::
:::
## Aufgabe 2: Magnetometer
Das Beispiel `bargraph.py` zeigt die Messwerte des Magnetometers in einem Balkendiagramm an und zeigt die Orientierung des Sensors an je nach dem über welche Achse gemessen wird. Der Befehl `python bargraph.py --help` zeigt die Optionen des Skripts an.
Die Ausgabe sollte für die Option `--graph` in etwa so aussehen:
``` bash
python bargraph.py --graph
bargraph.py - Convert raw values to heading
Rotate the sensor through 360 degrees to calibrate.
Press Ctrl+C to exit!
043.5 █████████████
```
::: {#exr-bewegungsmessung-heading}
**Bar graph**
- Kalibriere den Sensor und vergleiche die Orientierung des Sensors mit den Himmelsrichtungen
- Vergleiche die Ausgaben auch mit der Orientierung des Smartphones und den Messwerten der App *[phyphox](https://phyphox.org)*.
- Studiert den Code und versucht die Funktionsweise zu verstehen.
:::
::: {.content-hidden unless-meta="solution"}
::: {#sol-bewegungsmessung-heading}
Nach einer Kalibrierung des Sensors sind die Daten konsistenter und geben die Heading des Sensors in Grad an. Falls kein rudimentärer Graph in der Konsolenausgabe angezeigt wird, wurde das Skript ohne die Option `--graph` aufgerufen.
:::
:::
::: {.content-visible when-profile="chapter"}
## Referenzen
:::