### 4.3.7 Temperatur- und Feuchtigkeitsregelung
#### 4.3.7.1 Übersicht
In diesem Projekt zeigen wir, wie man ein Temperatur- und Feuchtigkeitsregelsystem mit einem micro:bit-Board, dem XHT11 Temperatur- und Feuchtigkeitssensor, einem 130-Motor, einem Atomisierungsmodul und einer OLED-Anzeige baut.
Das System misst die Umgebungstemperatur und -feuchte mit dem XHT11-Sensor und regelt diese durch Steuerung der Lüfterdrehung und des Wassernebel-Sprühens des Atomisierungsmoduls nach Bedarf. Überschreiten Temperatur oder Luftfeuchtigkeit die eingestellten Schwellenwerte, schaltet es den Lüfter ein und das Atomisierungsmodul sprüht Wassernebel. Gleichzeitig zeigt die OLED-Anzeige die aktuelle Temperatur und Luftfeuchtigkeit in Echtzeit an.
Da es Temperatur und Feuchtigkeit regeln kann, wird es häufig in Projekten eingesetzt, die eine Kontrolle von Temperatur und Luftfeuchte benötigen.
#### 4.3.7.2 Bauteilkenntnisse
**XHT11 Temperatur- und Feuchtigkeitssensor**
Der XHT11 Temperatur- und Feuchtigkeitssensor gibt digitale Signale aus. Er erfasst und wandelt analoge Signale um und misst Temperatur und Luftfeuchtigkeit, um eine ausgezeichnete Langzeitstabilität und hohe Zuverlässigkeit zu gewährleisten. Außerdem enthält er einen hochpräzisen resistiven Feuchtigkeitssensor und einen resistiven temperaturabhängigen Widerstandssensor und ist an einen 8-Bit-Hochleistungs-Mikrocontroller angeschlossen.
**XHT11 Kommunikationsmodus:**
Der XHT11 verwendet eine vereinfachte Single-Bus-Kommunikation. Ein Single-Bus bedeutet, dass es nur eine Datenleitung gibt, sodass Datenaustausch und Steuerung im System hierüber erfolgen.
- Definition der Single-Bus-Datenbitübertragung:
- Single-Bus-Datenformat: 40 Bits werden auf einmal übertragen, die höherwertigen Bits kommen zuerst.
- 8-Bit Feuchte-Ganzzahl + 8-Bit Feuchte-Dezimal + 8-Bit Temperatur-Ganzzahl + 8-Bit Temperatur-Dezimal + 8-Bit Paritätsbit. **Beachte: der Dezimalteil der Feuchte ist 0.**
- Definition des Paritätsbits:
- 8-Bit Feuchte-Ganzzahl + 8-Bit Feuchte-Dezimal + 8-Bit Temperatur-Ganzzahl + 8-Bit Temperatur-Dezimal. Die 8-Bit Parität sind die letzten 8 Bits des Ergebnisses.
Datenzeitreihendiagramm:
Nachdem der Host (MCU) ein Startsignal gesendet hat, wechselt der XHT11 vom Energiesparmodus in den Hochgeschwindigkeitsmodus. Sobald das Startsignal des Hosts endet, sendet der XHT11 ein Antwortsignal, gibt 40-Bit-Daten aus und führt eine Signalaufnahme durch. Die Signalübertragung ist unten dargestellt.
⚠️ **Hinweis:** Die vom Host aus dem XHT11 gelesenen Temperatur- und Feuchtigkeitsdaten sind stets der vorherige Messwert. Wenn der Abstand zwischen zwei Messungen groß ist, lesen Sie bitte zweimal hintereinander und verwenden Sie den zweiten erfassten Wert als Echtzeitwert.
**Schaltplan:**
**Parameter:**
- Betriebsspannung: DC 3.3V~5V
- Betriebsstrom: (Max)2.5mA@5V
- Maximale Leistung: 0.0125W
- Temperaturbereich: -25 ~ +60°C (±2℃)
- Feuchtebereich: 5 ~ 95%R (Genauigkeit ±5%RH bei ca. 25°C)
- Ausgangssignal: Digitaler bidirektionaler Single-Bus
**Atomisierungsmodul**
Das Atomisierungsmodul besteht aus einem Treiber und einer Atomisierungsscheibe, die Wasser zerstäubt. Es kann von einem Mikrocontroller oder über manuelle Tasten gesteuert werden.
**Funktionsprinzip:** Das Atomisierungsmodul verwendet in der Regel Ultraschalltechnik, um Wassernebel zu erzeugen. Es enthält eine piezoelektrische Keramikplatte, die zu schwingen beginnt, wenn eine Hochfrequenzspannung angelegt wird. Die Vibration sammelt kleine Wassertropfen an der Wasseroberfläche, die dann verteilt werden, um feinen Wassernebel zu bilden.
**Qualität des Wassernebels:** Dieses Modul kann Wasser effektiv in winzige Wasserpartikel umwandeln, normalerweise im Bereich von 1 bis 5 Mikrometern. Dieser feine Nebel verdunstet und diffundiert leichter in der Luft und wirkt somit als effektiver Luftbefeuchter.
⚠️ **Achtung:**
**1. Nach dem Einschalten muss die Atomisierungsscheibe im Wasser platziert werden. Wenn sie lange an der Luft bleibt, wird die Scheibe heiß und kann durchbrennen.**
**2. Legen Sie die Atomisierungsscheibe vorsichtig auf die Wasseroberfläche. Wenn sie untergetaucht ist, erzeugt sie keinen Wassernebel.**
**Parameter:**
- Betriebsspannung: DC 3.3 ~ 5V
- Montagebohrung: Durchmesser 4.8mm, Abstand 16mm
- Abmessungen: 31mm Länge, 23mm Breite, 8mm Höhe
- Gewicht: 4.5g
- Betriebstemperatur: -25°C bis +60°C
- Modulanschluss: 3-polige geschwungene Pins, Abstand 2.54
- Anschluss der Atomisierungsscheibe: PH2.0 Buchse
- Funktion: Wandelt Wasser in feinen Wassernebel um und gibt ihn an die Luft ab
**Abmessungen der Atomisierungsscheibe:**
⚠️ **Hinweis: Ziehen Sie möglichst nicht am Kabel der Scheibe, da sonst der Lötpunkt abreißen kann.**
**Gebrauchsanweisung für das Atomisierungsmodul:**
Es gibt zwei Steuerungsmodi: über Tasten und über MCU-Programmierung.
**Tastensteuerung:** Drücken Sie die Taste, um das Atomisierungsmodul einzuschalten. Drücken Sie die Taste erneut, um es auszuschalten.
**MCU-Programmiersteuerung:** Simuliert das Drücken einer Taste. Im Normalzustand gibt es High aus und beim Drücken Low. Nach dem Loslassen gibt es wieder High aus.
Daher müssen wir bei Verwendung der MCU nur ein kurzes Low-Pegel an das Modul anlegen, wie beim Drücken der Taste. Die Start- oder Pausenzeiten des Atomisierungsmoduls können durch Anpassung der High-Zeit gesteuert werden.
**Montieren Sie die Watte**:
1\. Soaken Sie die Watte vollständig im Wasser (finden Sie einen Behälter mit ausreichend Volumen, um die gesamte Watte zu bedecken, und lassen Sie sie mehr als 5 Minuten einweichen, damit sie das Wasser vollständig aufsaugt).
2\. Montieren Sie die Atomisierungsscheibe innerhalb der Kunststoffhalterung. Achten Sie auf die Richtung der Scheibe. Legen Sie ihr Kabel in die Nut der Halterung.
3\. Schließen Sie die andere Seite der Kunststoffhalterung.
4\. Setzen Sie die Watte in die Mitte der Halterung ein. Sie muss ganz bis zum Boden eingesetzt werden, bis sie die Atomisierungsscheibe berührt.
5\. Verbinden Sie die Atomisierungsscheibe mit dem PH2.0-Buchsenanschluss des Moduls, wie unten gezeigt.
6\. Verbinden Sie das Atomisierungsmodul mit dem micro:bit Shield und schließen Sie eine externe Stromversorgung an.
7\. Tauchen Sie die Watte erneut für mehr als 3 Minuten in Wasser. Das Wasser sollte die Watte möglichst vollständig bedecken, jedoch darf kein Wasser überlaufen.
8\. Drücken Sie die schwarze Taste am Modul, und Sie sehen, dass es zu sprühen beginnt. Der Wassernebel wird für 3 Sekunden gesprüht. Drücken Sie die Taste erneut, um es auszuschalten.
⚠️ **Achtung: Die Atomisierungsscheibe sollte nicht lange betrieben werden. Jeder Betrieb darf 5 Sekunden nicht überschreiten. Es ist am besten, 1 bis 2 Minuten zu pausieren, bis die Watte wieder vollständig mit Wasser gesättigt ist, bevor Sie fortfahren. Andernfalls kann es durchbrennen.**
#### 4.3.7.3 Benötigte Komponenten
| |  | |
| :--: | :--: | :--: |
| micro:bit V2 main board ×1 | micro:bit shield ×1 | atomization module ×1 |
||| |
| XHT11 temperature and
humidity sensor ×1 | OLED display ×1 | 130 motor ×1 |
| |||
| micro USB cable ×1 | 4 pin wire ×2 | 3 pin wire ×2 |
| || |
| fan ×1 | battery holder ×1 | AA battery(**self-prepared**) ×6 |
#### 4.3.7.4 Anschlussplan
⚠️ **Beim Verdrahten bitte auf die Kabelfarben achten.**
| 130 motor | wire color | micro:bit shield pin | micro:bit board pin |
| :-------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| IN+ | blue | 2 | P2 |
| IN- | green | 13 | P13 |
| OLED display | wire color | micro:bit shield pin | micro:bit board pin |
| :----------: | :--------: | :------------------: | :-----------------: |
| GND | black | G | G |
| VCC | red | V2 | V |
| SDA | blue | 20 | P20 |
| SCL | green | 19 | P19 |
| atomization module | wire color | micro:bit shield pin | micro:bit board pin |
| :----------------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V2 | V |
| S | yellow | 16 | P16 |
| XHT11 temperature and
humidity sensor | wire color | micro:bit shield pin | micro:bit board pin |
| :----------------------------------------: | :--------: | :------------------: | :-----------------: |
| G | black | G | G |
| V | red | V1 | V |
| S | yellow | 0 | P0 |
#### 4.3.7.5 Programmablauf
#### 4.3.7.6 Test-Code
⚠️ **Tipp 1: Bevor Sie den Code auf das Microbit-Board herunterladen, importieren Sie bitte die Bibliotheksdatei “oled_ssd1306\.py” und die Bibliotheksdatei “DHT11\.py” gemäß ** “[Bibliothek in MU importieren](https://docs.keyestudio.com/projects/KS4050/en/latest/docs/MicroPython/MU_development_environment.html#import-library-on-mu)” .
⚠️ **Tipp 2: Die Schwellenwerte 30 und 70 in der if()-Bedingung können je nach tatsächlicher Situation angepasst werden.**
**Vollständiger Code:**
```Python
'''
Theme: Air temperature and humidity regulation
Function: OLED displays temperature and humidity, XHT11 sensor controls the motor and the atomization module to regulate the environment temperature and humidity
Compiling IDE: MU 1.2.0
Author: https://docs.keyestudio.com
'''
# import related libraries
from microbit import *
from oled_ssd1306 import *
from DHT11 import *
# initialize and clear oled
initialize()
clear_oled()
sensor = DHT11(pin0) # set temperature and humidity pins
# Add an initialization waiting time
display.show(Image.ALL_CLOCKS, wait=False, loop=True)
sleep(3000) # Give the sensor a 3-second stabilization time
display.clear()
pin16.write_digital(1) # set P16 pin to high level
# Add a read counter
read_count = 0
last_valid_temp = 0
last_valid_humid = 0
while True:
# Try reading multiple times
for i in range(3):
sensor.read() # read the temperature and humidity values
if sensor.temp != 0 or sensor.humid != 0:
break
sleep(1000)
T = sensor.temp # store the temperature values in T
H = sensor.humid # store the humidity values in H
# Check the validity of the data
if T == 0 and H == 0 and read_count < 5:
# The first few reads might be 0. Keep trying
read_count += 1
add_text(0, 0, "Initializing...")
add_text(0, 2, "Attempt: " + str(read_count))
sleep(1000)
continue
# If the data is valid, update the last valid value
if T != 0 or H != 0:
last_valid_temp = T if T != 0 else last_valid_temp
last_valid_humid = H if H != 0 else last_valid_humid
read_count = 10 # The mark has been successfully read
# Use valid data (if the current value is 0, use the last valid value
display_temp = T if T != 0 else last_valid_temp
display_humid = H if H != 0 else last_valid_humid
clear_oled()
add_text(0, 0, "Temper: " + str(display_temp) + " C") # Display the temperature value
add_text(0, 2, "Humid: " + str(display_humid) + " %RH") # Display the humidity value
# control logic
if display_temp > 30 or display_humid > 70:
add_text(0, 4, "Cooling/Humidifying")
pin2.write_analog(500)
pin13.write_digital(0)
sleep(2000)
pin2.write_analog(0)
pin13.write_digital(0)
sleep(500)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
else:
add_text(0, 4, "Normal State")
pin2.write_analog(0)
pin13.write_digital(0)
pin16.write_digital(1)
sleep(500)
```
**Kurze Erklärung:**
① Importieren der Bibliotheken microbit, oled_ssd1306 und DHT11.
```Python
from microbit import *
from oled_ssd1306 import *
from DHT11 import *
```
② Initialisieren der OLED-Pixel, OLED löschen.
```Python
initialize()
clear_oled()
```
③ Initialisieren des Pins des XHT11 Temperatur- und Feuchtigkeitssensors.
```Python
sensor = DHT11(pin0) # set temperature and humidity pins
```
④ Variablen definieren und ihre Anfangswerte auf 0 setzen.
```Python
read_count = 0
last_valid_temp = 0
last_valid_humid = 0
```
⑤ Temperatur und Feuchtigkeit mehrfach einlesen und die gelesene Temperatur der Variable T und die Feuchtigkeit der Variable H zuweisen.
```Python
for i in range(3):
sensor.read() # read the temperature and humidity values
if sensor.temp != 0 or sensor.humid != 0:
break
sleep(1000)
T = sensor.temp # store the temperature values in T
H = sensor.humid # store the humidity values in H
```
⑥ Überprüfen der Gültigkeit der Temperatur- und Feuchtigkeitswerte.
```Python
if T == 0 and H == 0 and read_count < 5:
# The first few reads might be 0. Keep trying
read_count += 1
add_text(0, 0, "Initializing...")
add_text(0, 2, "Attempt: " + str(read_count))
sleep(1000)
continue
```
⑦ Wenn die Werte gültig sind, aktualisiere den zuletzt gültigen Wert.
```Python
if T != 0 or H != 0:
last_valid_temp = T if T != 0 else last_valid_temp
last_valid_humid = H if H != 0 else last_valid_humid
read_count = 10 # The mark has been successfully read
```
⑧ Verwende die gültigen Daten (wenn der aktuelle Wert 0 ist, verwende den zuletzt gültigen Wert).
```Python
display_temp = T if T != 0 else last_valid_temp
display_humid = H if H != 0 else last_valid_humid
```
⑨ Zeige die vom XHT11 erkannten Temperatur- und Feuchtigkeitswerte auf der OLED an.
```Python
add_text(0, 0, "Temper: " + str(display_temp) + " C") # Display the temperature value
add_text(0, 2, "Humid: " + str(display_humid) + " %RH") # Display the humidity value
```
⑩ Entscheidungsanweisung: if()...else...
Wenn die erkannte Temperatur über 30℃ oder die Feuchtigkeit über 70%RH liegt, stoppt der Lüfter nach 2 Sekunden Laufzeit. Dann arbeitet das Atomisierungsmodul und sprüht Wassernebel, um die Umgebungstemperatur und -feuchte zu regulieren. Gleichzeitig zeigt die OLED „Cooling/Humidifying“.
```Python
if display_temp > 30 or display_humid > 70:
add_text(0, 4, "Cooling/Humidifying")
pin2.write_analog(500)
pin13.write_digital(0)
sleep(2000)
pin2.write_analog(0)
pin13.write_digital(0)
sleep(500)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(3000)
pin16.write_digital(0)
sleep(200)
pin16.write_digital(1)
sleep(1000)
```
Andernfalls arbeiten der Lüfter und das Atomisierungsmodul nicht, und die OLED zeigt „Normal State“.
```Python
else:
add_text(0, 4, "Normal State")
pin2.write_analog(0)
pin13.write_digital(0)
pin16.write_digital(1)
```
⑪ Verzögerung 500 ms (0,5 s)
```Python
sleep(500)
```
#### 4.3.7.7 Testergebnis
Nach dem Verdrahten und 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.
Nach dem Hochladen des Testcodes drücken Sie die Reset-Taste auf der Rückseite des micro:bit.
Die 5×5 LED-Matrix auf dem micro:bit-Board zeigt das rotierende Zeigermuster, die OLED zeigt die Initialisierungsinformationen des XHT11 Temperatur- und Feuchtigkeitssensors an und danach zeigt die OLED die vom XHT11 erfassten Temperatur- und Feuchtigkeitswerte in Echtzeit an.
Wenn die erkannte Temperatur über 30℃ oder die Feuchtigkeit über 70%RH liegt, stoppt der Lüfter nach 2 Sekunden Laufzeit. Dann arbeitet das Atomisierungsmodul und sprüht Wassernebel, um die Umgebungstemperatur und -feuchte zu regulieren. Gleichzeitig zeigt die OLED „Cooling/Humidifying“. Andernfalls arbeiten der Lüfter und das Atomisierungsmodul nicht, und die OLED zeigt „Normal State“.
⚠️ **Hinweis: Die Bausteine im Experiment sind nicht in diesem Kit enthalten.**
(**Tipp:** Wenn kein Ergebnis angezeigt wird, drücken Sie bitte die Reset-Taste des micro:bit-Boards.)
