-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathE01_Luftqualitaet.qmd
291 lines (226 loc) · 13.3 KB
/
E01_Luftqualitaet.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
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
---
title: "Luftqualitätmessung"
author: "Pia Bereuter"
date: today
other-links:
- text: Kapitel PDF
icon: file-pdf
href: chapters/E01_Luftqualitaet.pdf
code-links:
- text: Ausgangsdaten
icon: file-zip
href: data/E01_Luftqualitaet.zip
resources:
- data/E01_Luftqualitaet.zip
abstract: "Diese Übung zeigt wie Sensoren mit dem Raspberry Pi genutzt werden können am Beispiel des BME688 Sensors. Dieser Sensor erfasst Temperatur, Luftdruck, Luftfeuchtigkeit und Gas Scanner VOC. Die Übung zeigt wie der Sensor angeschlossen wird, wie die Sensordaten ausgelesen werden und wie die Sensordaten in einer Datei gespeichert werden können."
---
## Einführung
Ziel dieser ersten Übung ist es den BME688 Sensor kennen zu lernen und die Sensordaten auszulesen. Der BME688 ist ein 4-in-1 Sensor für Temperatur, Luftdruck, Luftfeuchtigkeit und Gas Scanner VOC. Der Sensor verfügt über eine I2C Schnittstelle, die mit der Python Library [bme680-python](https://github.com/pimoroni/bme680-python) angesteuert und die Sensordaten ausgelesen werden können.
**Unterlagen:** *<i class="bi-file-zip"></i> E01_Luftqualitaet.zip*
**Vorbereitung**
- Lest das Kapitel im Anhang zu [Raspberry Pi](A1_Rasperry_Pi.qmd)
- Konzentriere Dich auf die wichtigsten Details zur Inbetriebnahme des Raspberry Pi
- Lest die Dokumentation zum BME688 Sensor @bosch2022
- Konzentriere Dich auf die Beschreibung der Schnittstelle und technische Spezifikation auf dem Datenblatt
::: {.content-visible when-format="html"}
{{< video https://www.youtube.com/embed/4vdliMRtxBY >}}
:::
::: {.content-visible unless-format="html"}
](images/youtube_bosch_bme688.png)
:::
**Unterlagen** | |
|---------------|---------------------------------------------------------|
| Produkt | [BME688 4-in-1 Air Quality Breakout](https://shop.pimoroni.com/products/bme688-breakout) |
| Datenblatt | [Bosch Datasheet BME 688](https://www.bosch-sensortec.com/media/boschsensortec/downloads/datasheets/bst-bme688-ds000.pdf) |
| GitHub | [bme680-python Library mit Beispielen](https://github.com/pimoroni/bme680-python) |
| Tutorial | [Getting started with BME680 Breakout](https://learn.pimoroni.com/article/getting-started-with-bme680-breakout) |
## BME688\index{BME688}
BME688 - Bosch Sensor für Temperatur, Luftdruck, Luftfeuchtigkeit, Gas Scanner VOC (@fig-bme688)
- Temperatur +/-0.5°C (-40° .. -85°)
- Luftdruck +/-0.12hPa (300...1100hPa)
- Luftfeuchtigkeit +/-3% (0 ...100%)
- Gas Scanner VOC, VSCs (AI)
- Python, C Library
- Raspberry Pi Pins 1,3,5,7,9
{#fig-bme688}
## Ü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 `BME688`, in welchem Du Änderungen und neue Dateien für diese Übung speichern kannst.
- Schliesse den Sensor **BME688** an den Raspberry Pi über die Breakout Garden **I2C** Schnittstelle an.
::: hint
**Sensor Ausrichtung beachten**
Beim Anschliessen der Sensoren in die Schnittstellen des Breakout Garden **unbedingt** die korrekte Ausrichtung beachten! Die Beschriftung der Anschlüsse auf dem Sensor und dem Breakout Garden müssen übereinstimmen!
:::
### Kontrolle der Hardware
Kontrolliere mit dem Befehl `i2cdetect -y 1` ob der Raspberry Pi mit dem Sensor verbunden ist und der Raspberry Pi Zugriff auf den Sensor hat. Erscheint eine Zahl, dann hat der Raspberry Pi den Sensor auf dem I2C Bus erkannt. Falls Du mehr über das Program und den Befehl wissen möchtest, kannst Du mit dem Befehl `man i2cdetect` das Manual `man` aufrufen.
``` bash
i2cdetect -y 1
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: -- -- -- -- -- -- -- --
10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
70: -- -- -- -- -- -- 76 --
```
`i2cdetect` installieren, falls das Programm nicht existiert:
``` bash
sudo apt-get update
sudo apt install python3-smbus
sudo apt install i2c-tools
```
**Hinweis:** Damit der Befehl `i2cdetect` funktioniert, muss der I2C Bus aktiviert sein. Dies kann mit dem Befehl `sudo raspi-config` im Menü `Interfacing Options` und `I2C` aktiviert werden.
### Kontrolle der Installation
Aktiviere die virtuelle Python Environment (hier unter `~/.env`) und teste ob die für die Übung erforderlichen Python Libraries installiert sind.
Aktiviere über folgenden Befehl die virtuelle Umgebung, welche für diese Übungen im Homeordner `~/.env` erstellt wurde^[In dieser Übung wird die Python Virtual Environment `.env` im Homeordner `~/` erstellt und aktiviert. Diese kann auch an einem Ort erstellt werden, beispielweise projektbasiert. Erstellen einer Virtual Environment: `python -m venv ~/Development/Projekt1/env`]. Die aktivierte Umgebung wird durch die Anzeige des Umgebungsname in der Kommandozeile angezeigt, hier mit `(.env)`.
``` bash
source ~/.env/bin/activate
```
Teste ob die für die Übung erforderlichen Python Libraries installiert sind. Ein einfacher Test zur Kontrolle, ob ein Modul installiert ist, ist über das Import Statement des Moduls über die Python Konsole im Terminal. Falls kein Fehler auftritt, ist das Modul in der virtuellen Environment installiert.
``` bash
python -c "import math"
0 # <1>
python -c "import numpy"
Traceback (most recent call last): # <2>
File "<string>", line 1, in <module> # <2>
ImportError: No module named numpy # <2>
```
1. `math` Modul existiert
2. `numpy` Modul existiert nicht
Installiere das Modul mit folgendem Befehl, falls es nicht installiert ist.
``` bash
pip install bme680
```
### Kopiere (Clone) die Library mit den Beispielen auf den Raspberry Pi
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/bme680-python
cd bme680-python/examples
```
## Aufgabe 1: Sensormessungen ausführen
Teste das Beispiel `read-all.py` im Ordner *examples*. Dieses Beispiel gibt die Temperatur, Luftdruck und Luftfeuchtigkeit des Sensors BME 688 aus.
``` bash
python read-all.py
```
Mit `Ctrl+c` kann das Script wieder gestopppt werden. Die Ausgabe sollte in etwa so aussehen (gekürzt):
``` bash
# Output Beispiel
read-all.py - Displays temperature, pressure, humidity, and gas.
Press Ctrl+C to exit!
Calibration data:
par_gh1: -10
…
Initial reading:
gas_index: 0
gas_resistance: 1338124.79581836
heat_stable: False
humidity: 44.397
meas_index: 0
pressure: 990.82
status: 32
temperature: 28.89
Polling:
28.89 C,990.82 hPa,44.39 %RH
28.91 C,990.82 hPa,44.37 %RH,5684.846331497602 Ohms
28.94 C,990.80 hPa,44.31 %RH,5684.846331497602 Ohms
28.97 C,990.81 hPa,44.24 %RH,5684.846331497602 Ohms
29.00 C,990.81 hPa,44.19 %RH,5684.846331497602 Ohms
29.03 C,990.82 hPa,44.12 %RH,5684.846331497602 Ohms
```
Folgendes Code Snippet zeigt eine gekürtzte Version des read-all.py Python Beispiels, der die *Temperatur*, *Luftdruck* und *Luftfeuchtigkeit* mit der BME680 Library ausgibt.
``` python
#!/usr/bin/env python
import bme680
try:
sensor = bme680.BME680(bme680.I2C_ADDR_PRIMARY) # <1>
except (RuntimeError, IOError):
sensor = bme680.BME680(bme680.I2C_ADDR_SECONDARY) # <1>
# Oversampling Einstellungen
sensor.set_humidity_oversample(bme680.OS_2X) # <2>
sensor.set_pressure_oversample(bme680.OS_4X) # <2>
sensor.set_temperature_oversample(bme680.OS_8X) # <2>
sensor.set_filter(bme680.FILTER_SIZE_3) # <2>
print('Sensordaten:')
try:
while True:
if sensor.get_sensor_data(): # <3>
output = '{0:.2f} C,{1:.2f} hPa,{2:.3f} %RH'.format( # <3>
sensor.data.temperature, # <3>
sensor.data.pressure, # <3>
sensor.data.humidity) # <3>
print(output)
except KeyboardInterrupt:
pass
```
1. Testen der beiden möglichen I2C Adressen
2. Oversampling Einstellungen können Messungen durch Mitteln verbessern und das Rauschen und Drifts reduzieren
3. Sensordaten auslesen
::: {#exr-luftqualitaet}
**BME 688**\
Studiert die Python Skripte und online Tutorial zum Sensor
- Wie wird auf den Sensor zugegriffen?
- Wie reagiert der Feuchtigkeitssensor auf Änderungen?
- Wie hoch sind die Werte für den Luftdruck, was sind Vergleichswerte?
- Wie könnt Ihr einfach Sensorwerte in eine Datei schreiben?
:::
::: {.content-hidden unless-meta="solution"}
::: {#sol-luftqualitaet}
Verbindng über I2C. Messwerte in eine Textdatei schreiben `python3 read-all.py > bme680-data.txt`. Die erstellte Datei kann mit dem Befehl `cat bme680-data.txt` angezeigt werden. Der Sensor kann mit oder ohne Gasmessung betrieben werden `set_gas_status`. Die Messung von Gas erfordern eine aktivie Miniaturheizung innerhalb des Sensors. Deaktiviert können die anderen Messwerte schneller erhoben werden. Die Filteroption glättet die Messwerte und reduziert beispielsweise momentane Events, wie eine Tür die zugeschlagen wird und den Luftdruck ändert. Die Einheiten sind Grad Celsius, Hektopascal und Prozent relativer Luftfeuchtigkeit.
:::
:::
## Aufgabe 2: Berechnung der Atmosphärenkorrektur für Distanzmessungen (optional)
Geödätische Distanzmessverfahren wie bei der Tachymetrie (Totalstationen) und Laserscanning benötigen eine Korrektur der Messwerte, um die Distanz zwischen zwei Punkten auf der Erde zu berechnen. Über eine *Massstabskorrektur* (ppm [mm/km]) können distanzproportionale Reduzierungen berücksichtigt werden, die *Projektionsverzerrung*, *Reduktion auf Meereshöhe* und die *Atmophärenkorrektur* berücksichtigen.
Die Luftfeichtigkeit beeinflusst Distanzmessungen in feuchtem und heissen Klima. Diese muss den zur Messzeit geltenden atmosphärischen Bedingungen angepasst werden.
Die Korrektur wird als *Atmosphärenkorrektur* bezeichnet und ist abhängig von der *Temperatur*, dem *Luftdruck* und der *Luftfeuchtigkeit*. Die Korrektur wird in ppm (parts per million [mm/km]) angegeben und kann mit folgender @eq-atmosphaerenkorrektur berechnet werden [@grimm2023; @leicageosystems2022 S.87] und gilt für die Distanzmessung mit sichtbaren roten Laser
$$
\Delta D_1 = 286.338 - \begin{bmatrix}\frac{0.29535 \cdot p}{(1+\alpha \cdot t)}-\frac{4.126 \cdot 10^{-4} \cdot h}{(1+\alpha \cdot t)} \cdot 10^x\end{bmatrix}
$$ {#eq-atmosphaerenkorrektur}
$$\begin{aligned}
& \Delta D_1 && \text{Atmosphärische Korrektur} && [ppm]\\
& p && \text{Luftdruck} && [mbar]\\
& t && \text{Lufttemperatur} && [°C]\\
& h && \text{relative Luftfeuchte} && [\%]\\
& \alpha && = \frac{1}{273.15} \\
& x && = (7.5 \cdot \frac{t}{237.3 +t}) + 0.7857 \\
\end{aligned}
$$
Folgende Funktion in Python berechnet die Atmosphärenkorrektur für Geodätische Distanzmessverfahren basierend auf der @eq-atmosphaerenkorrektur
``` python
import math
def calculate_atmospheric_correction(temperature, air_pressure, humidity):
# Constants
ALPHA = 1 / 273.15
X = (7.5 * temperature / (237.3 + temperature)) + 0.7857
# Interim results
denominator = 1 + ALPHA * temperature
formula0 = 286.338
formula1 = 0.29535 * air_pressure / denominator
formula2 = 4.126 * 10 ** (-4) * humidity / denominator
formula3 = 10 ** X
# ppm-calculation
correction_ppm = round(formula0 - (formula1 - formula2 * formula3), 2)
# Return important values as a dictionary
result = {
"temperature": temperature,
"air_pressure": air_pressure,
"humidity": humidity,
"correction_ppm": correction_ppm
}
return result
```
Für Distanzmessungen höchster Genauigkeit sollte die atmosphärische Korrektur auf $1 ppm$ genau bestimmt werden, folglich sollten die Messwerte mindestens folgenden Genauigkeit aufweisen: die Temperatur auf $1°C$, der Luftdruck auf $3 mbar$ ($1 Millibar= 1 hPa$) und die Luftfeuchtigkeit auf $20 %$ genau bestimmt werden [@leicageosystems2022 S.87].
::: {#exr-atmosphaerenkorrektur}
**Atmosphärenkorrektur**\
Nutzt die Funktion `calculate_atmospheric_correction` um eine atmosphärische Korrektur mit den momentan gemessenen amtmosphärischen Bedingungen zu berechnen.
- Wie hoch ist die Korrektur mit den Werten des BME688 Sensors?
- Wie hoch ist dieselbe Korrektur bei doppelter Luftfeuchtigkeit?
- Wie hoch ist die Korrektur bei 20°C, 1000hPa und 50% sowie 100% Luftfeuchtigkeit?
- Erfüllt der BME688 Sensor die Anforderungen für Distanzmessungen höchster Genauigkeit?
:::
::: {.content-visible when-profile="chapter"}
## Referenzen
:::