### 4.3.9 Micro:bit Multi-sensor OLED Monitoring Platform
#### 4.3.9.1 Übersicht
In diesem Projekt verwenden wir das micro:bit-Board als zentrale Verarbeitungseinheit, um die Werte seiner eingebauten Sensoren (einschließlich Lichtsensor, Temperatursensor, Mikrofon) sowie externer Sensoren (wie PM2.5-Staubsensor, Niederschlagsensor und Solare Ultraviolett-Sensor) auszulesen. Diese Werte werden dann in Echtzeit über die I2C-Schnittstelle auf dem OLED angezeigt.
Gleichzeitig kann die Drehung des Lüfters auf dem 130-Motor-Modul durch Drücken der Taste A auf dem micro:bit-Board gesteuert werden, und das Versprühen von Wassernebel aus dem Zerstäubungsmodul kann durch Drücken der Taste B auf dem micro:bit-Board gesteuert werden.
#### 4.3.9.2 Benötigte Komponenten
| |  ||
| :--: | :--: | :--: |
| micro:bit V2 Board ×1 | micro:bit Shield ×1 |OLED-Display ×1 |
| |||
| PM2.5-Staubsensor ×1 | Motor ×1 | Niederschlagsensor ×1 |
||| |
| Ultraviolett-Sensor ×1| Batteriehalter ×1|AA-Batterien (**selbst bereitgestellt**) ×6|
| |||
| micro USB-Kabel ×1|4-poliges Kabel ×3 |3-poliges Kabel ×3 |
| |  | |
| Zerstäubungsmodul ×1| Lüfter ×1| |
#### 4.3.9.3 Anschlussdiagramm
⚠️ **Bitte achten Sie beim Verdrahten auf die Drahtfarbe.**
| Ultraviolettsensor | Drahtfarbe | micro:bit Shield-Pin | micro:bit Board-Pin |
| :----------------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| S | yellow | 0 | P0 |
| Niederschlagsensor | Drahtfarbe | micro:bit Shield-Pin | micro:bit Board-Pin |
| :----------------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V1 | V |
| S | yellow | 1 | P1 |
| PM2.5-Staubsensor | Drahtfarbe | micro:bit Shield-Pin | micro:bit Board-Pin |
| :---------------: | :--------: | :------------------: | :-----------------: |
| GND | black | G | G |
| VCC | red | V2 | V |
| LED | blue | 9 | P9 |
| OUT | green | 2 | P2 |
| Zerstäubungsmodul | Drahtfarbe | micro:bit Shield-Pin | micro:bit Board-Pin |
| :----------------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| S | yellow | 16 | P16 |
| Motor | Drahtfarbe | micro:bit Shield-Pin | micro:bit Board-Pin |
| :---: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| IN+ | blue | 13 | P13 |
| IN- | green | 15 | P15 |
| OLED-Display | Drahtfarbe | micro:bit Shield-Pin | micro:bit Board-Pin |
| :----------: | :--------: | :------------------: | :-----------------: |
| GND | black | G | G |
| VCC | red | V2 | V |
| SDA | blue | 20 | P20 |
| SCL | green | 19 | P19 |
#### 4.3.9.4 Ablaufdiagramm
#### 4.3.9.5 Testcode
⚠️ **Tipp 1: Bevor Sie den Code auf das Microbit-Board herunterladen, importieren Sie bitte die Bibliotheksdatei “oled_ssd1306\.py”, siehe ** “[Import Library on MU](https://docs.keyestudio.com/projects/KS4050/en/latest/docs/MicroPython/MU_development_environment.html#import-library-on-mu)” .
⚠️ **Tipp 2: Falls die Bibliotheksdatei "XHT11\.py" bereits auf das micro:bit-Board importiert wurde, muss sie vom micro:bit-Board entfernt werden. Andernfalls führt dies zu unzureichendem Speicher auf dem Microbit-Motherboard, wodurch das Herunterladen des Beispielcodes auf das Microbit-Board nicht erfolgreich ist. **
Klicken Sie auf die Schaltfläche "Files", dann rechtsklicken Sie in der linken Box auf die Bibliotheksdatei "XHT11\.py", es erscheint die Option "Delete (cannot be undone)", klicken Sie auf "Delete (cannot be undone)". Damit wurde die Bibliotheksdatei "XHT11\.py" gelöscht.
**Vollständiger Code:**
```Python
'''
Theme: A multi-sensor OLED monitoring platform based on Micro:bit
Function: OLED displays the values of multiple sensors
Compiling IDE: MU 1.2.0
Author: https://docs.keyestudio.com
'''
# import related libraries
from microbit import *
from oled_ssd1306 import *
import math
import time
display.show(Image.HAPPY) # LED matrix displays a happy pattern
# initialize and clear oled
initialize()
clear_oled()
# Hardware connection: PM2.5 dust sensor
out_Pin = pin2
led_Pin = pin9
# Hardware connection: steam sensor
Steam_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0
# Initialize the ADC pin (the ultraviolet sensor is connected to pin0)
uv_sensor = pin0
# Time parameter
delayTime = 280
delayTime2 = 40
offTime = 9680
def map_value(value, in_min, in_max, out_min, out_max):
"""Linearly map the input values to the output range"""
if in_max - in_min == 0:
return out_min
return (value - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
def get_rain_percentage():
"""Read the sensor and return the percentage of rainfall"""
raw_value = Steam_PIN.read_analog()
percentage = map_value(raw_value, DRY_VALUE, WET_VALUE, 0, 100)
return max(0, min(100, percentage))
def read_uv_index():
raw_value = uv_sensor.read_analog()
if raw_value > 1023:
raw_value = 1023
elif raw_value < 0:
raw_value = 0
uvi = raw_value * (15.0 / 1023)
return round(uvi, 1)
def microsecond_delay(us):
"""Precise microsecond delay"""
start = time.ticks_us()
while time.ticks_diff(time.ticks_us(), start) < us:
pass
while True:
# Measurement sequence
led_Pin.write_digital(0) # LED OFF
microsecond_delay(delayTime) # 280μs
dustVal = out_Pin.read_analog() # Read the PM2.5 dust sensor
microsecond_delay(delayTime2) # 40μs
led_Pin.write_digital(1) # LED ON
microsecond_delay(offTime) # 9680μs
Lightintensity = display.read_light_level()
Temperature = temperature()
soundLevel = microphone.sound_level()
rain_percent = get_rain_percentage()
uv = read_uv_index()
clear_oled()
if button_a.is_pressed(): # if button_a.is pressed
sleep(200)
pin13.write_digital(1) # the fan is rotating.
pin15.write_digital(0)
sleep(200)
else: # or
pin13.write_digital(0) # the fan does not rotate.
pin15.write_digital(0)
if button_b.is_pressed(): # if button_b.is pressed
pin16.write_digital(0) # the atomization module sprays water mist.
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else: # or
pin16.write_digital(1) # the atomization module does not spray water mist.
add_text(0, 0, "Temper:")
add_text(7, 0, str(int(Temperature)) + "C") # Display the Temperature value on the OLED
add_text(0, 2, "UV:")
add_text(3, 2, str(int(uv))) # Display the UV value on the OLED
add_text(5, 2, " | Rain:")
add_text(13, 2, str(int(rain_percent)) + "%") # Display the percentage of rainfall on the OLED
add_text(0, 4, "Light:")
add_text(6, 4, str(Lightintensity)) # Display the light intensity on the OLED
add_text(9, 4, " | Sound:")
add_text(18, 4, str(soundLevel)) # Display the noise intensity on the OLED
# Calculation and display
if dustVal > 36.455:
# The exact same calculation formula
voltage = dustVal / 1024.0
pm25 = (voltage - 0.0356) * 120000 * 0.035
# OLED displays detailed PM2.5dust value information.
add_text(0, 6, "PM2.5dust:")
add_text(10, 6, str(round(pm25)) + "ug/m3")
else:
print("Low value:", dustVal)
sleep(500)
```
**Kurze Erläuterung:**
① Importieren der Bibliotheken microbit, oled_ssd1306, math und time.
```Python
from microbit import *
from oled_ssd1306 import *
import math
import time
```
② Die 5×5-LED-Matrix zeigt .
```Python
display.show(Image.HAPPY)
```
③ OLED initialisieren und OLED löschen.
```Python
initialize()
clear_oled()
```
④ Initialisieren der Pins des PM2.5-Staubsensors.
```Python
out_Pin = pin2
led_Pin = pin9
```
⑤ Initialisieren des Pins und der Variablen des Niederschlagssensors.
```Python
Steam_PIN = pin1
WET_VALUE = 1023
DRY_VALUE = 0
```
⑥ Initialisieren des Pins des Solar-Ultraviolettsensors.
```Python
uv_sensor = pin0
```
⑦ Festlegen der Anfangswerte der Zeitvariablen.
```Python
delayTime = 280
delayTime2 = 40
offTime = 9680
```
⑧ Definition einer Map-Unterfunktion (um einen Zahlenbereich linear auf einen anderen abzubilden).
```Python
def map_value(value, in_min, in_max, out_min, out_max):
"""Linearly map the input values to the output range"""
if in_max - in_min == 0:
return out_min
return (value - in_min) * (out_max - out_min) // (in_max - in_min) + out_min
```
⑨ Definition einer Unterfunktion zur Ermittlung des Niederschlagsprozentsatzes.
```Python
def get_rain_percentage():
"""Read the sensor and return the percentage of rainfall"""
raw_value = Steam_PIN.read_analog()
percentage = map_value(raw_value, DRY_VALUE, WET_VALUE, 0, 100)
return max(0, min(100, percentage))
```
⑩ Definition einer Unterfunktion zur Ermittlung des vom Solaren Ultraviolettsensor erfassten UV-Index-Wertes.
```Python
def read_uv_index():
raw_value = uv_sensor.read_analog()
if raw_value > 1023:
raw_value = 1023
elif raw_value < 0:
raw_value = 0
uvi = raw_value * (15.0 / 1023)
return round(uvi, 1)
```
⑪ Definition einer Unterfunktion für Mikrosekunden-Verzögerung.
```Python
def microsecond_delay(us):
"""Precise microsecond delay"""
start = time.ticks_us()
while time.ticks_diff(time.ticks_us(), start) < us:
pass
```
⑫ Steuerung der Messzeit des PM2.5-Staubsensors, hauptsächlich zur Erkennung der Staubkonzentration in der Luft.
```Python
led_Pin.write_digital(0) # LED AUS
microsecond_delay(delayTime) # 280μs
dustVal = out_Pin.read_analog() # PM2.5-Staubsensor auslesen
microsecond_delay(delayTime2) # 40μs
led_Pin.write_digital(1) # LED AN
microsecond_delay(offTime) # 9680μs
```
⑬ Auslesen der Werte für Lichtintensität, Temperatur, Lautstärke, Niederschlagsmenge und Ultraviolett.
```Python
Lightintensity = display.read_light_level()
Temperature = temperature()
soundLevel = microphone.sound_level()
rain_percent = get_rain_percentage()
uv = read_uv_index()
```
⑭ Verzweigungsanweisung: if()...else...
Drücken Sie die Taste A auf dem micro:bit-Board, und der Motor treibt den Lüfter an. Andernfalls dreht sich der Lüfter nicht.
```Python
if button_a.is_pressed(): # wenn button_a gedrückt ist
sleep(200)
pin13.write_digital(1) # der Lüfter dreht sich.
pin15.write_digital(0)
sleep(200)
else: # oder
pin13.write_digital(0) # der Lüfter dreht sich nicht.
pin15.write_digital(0)
```
⑮ Verzweigungsanweisung: if()...else...
Drücken Sie die Taste B auf dem micro:bit-Board, und das Zerstäubungsmodul sprüht Wassernebel. Andernfalls arbeitet es nicht.
```Python
if button_b.is_pressed(): # wenn button_b gedrückt ist
pin16.write_digital(0) # das Zerstäubungsmodul sprüht Wassernebel.
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else: # oder
pin16.write_digital(1) # das Zerstäubungsmodul sprüht keinen Wassernebel.
```
⑯ Anzeige der Werte von Ultraviolett, Temperatur, Niederschlagsmenge, Lichtintensität und Geräuschpegel auf dem OLED.
```Python
add_text(0, 0, "Temper:")
add_text(7, 0, str(int(Temperature)) + "C") # Temperaturwert auf dem OLED anzeigen
add_text(0, 2, "UV:")
add_text(3, 2, str(int(uv))) # UV-Wert auf dem OLED anzeigen
add_text(5, 2, " | Rain:")
add_text(13, 2, str(int(rain_percent)) + "%") # Prozentuale Niederschlagsmenge auf dem OLED anzeigen
add_text(0, 4, "Light:")
add_text(6, 4, str(Lightintensity)) # Lichtintensität auf dem OLED anzeigen
add_text(9, 4, " | Sound:")
add_text(18, 4, str(soundLevel)) # Geräuschpegel auf dem OLED anzeigen
```
⑰ Wenn der Analogwert der PM2.5-Staubpartikel 36.455 überschreitet, kann daraus die Konzentration berechnet und auf dem OLED angezeigt werden. Andernfalls gibt der serielle Monitor die entsprechenden Staub-Analogwerte aus.
```Python
if dustVal > 36.455:
# The exact same calculation formula
voltage = dustVal / 1024.0
pm25 = (voltage - 0.0356) * 120000 * 0.035
# OLED displays detailed PM2.5dust value information.
add_text(0, 6, "PM2.5dust:")
add_text(10, 6, str(round(pm25)) + "ug/m3")
else:
print("Low value:", dustVal)
```
#### 4.3.9.6 Testergebnis
Nach dem Verdrahten und dem Einschalten über das Micro-USB-Kabel schließen Sie die externe Stromversorgung (6 AA-Batterien) an, um eine ausreichende Stromversorgung sicherzustellen, und klicken Sie auf “Flash”, um den Code auf das micro:bit-Board herunterzuladen.
Nachdem der Testcode hochgeladen wurde, drücken Sie die Reset-Taste auf der Rückseite des micro:bit.
Lesen Sie die Werte seiner eingebauten Sensoren (einschließlich Lichtsensor, Temperatursensor, Mikrofon) sowie externer Sensoren (wie PM2.5-Staubsensor, Niederschlagsensor und Solar-Ultraviolett-Sensor) aus. Anschließend werden Lichtintensität, Temperatur, Geräuschpegel, Niederschlagsintensität, Sonnen-UV-Intensität und PM2.5-Staubkonzentration in Echtzeit und anschaulich über das OLED-Anzeigefeld mit I2C-Schnittstelle dargestellt.
Pusten Sie Luft (oder erzeugen Sie ein sehr lautes Geräusch) in das Mikrofon auf dem Microbit-Board (⚠️ **besondere Erinnerung: Pusten hat einen deutlich sichtbareren Effekt**), und das OLED zeigt die Intensität des Luftstoßes (oder des Geräuschs) an.
Wenn Taste A auf dem micro:bit-Board gedrückt wird, dreht sich der Lüfter auf dem Motor-Modul. Wenn Taste B auf dem Board gedrückt wird, sprüht das Zerstäubungsmodul Wassernebel.
⚠️ Besonderer Hinweis: Manchmal kann die Spannung der externen Stromversorgung unzureichend sein. In solchen Fällen kann es erforderlich sein, die Taste auf dem micro:bit-Board zweimal zu drücken, bevor sich der Lüfter zu drehen beginnt oder das Zerstäubungsmodul Wassernebel versprüht.
⚠️ **Hinweis: Die Bausteine (building blocks) im Experiment sind nicht in diesem Kit enthalten.**
(**Tipp:** Falls kein Ergebnis sichtbar ist, drücken Sie bitte die Reset-Taste des micro:bit-Boards.)
