In dieser Lektion lernst du, wie man ein Klimamessgerät baut, das auf einem Temperatur- und Feuchtigkeitssensor vom Typ DHT11 und zwei NeoPixeln basiert. Das Klimamessgerät kann sowohl die Temperatur als auch die Luftfeuchtigkeit messen. Die zwei NeoPixel zeigen an, ob es warm oder kalt ist und ob die Luft eher trocken oder feucht ist. Das hilft zu entscheiden, ob man lüften sollte oder nicht.
Wenn du mit der Lektion fertig bist, wirst du dies können:
Einen micro:bit zusammen mit einem
DragonTail
DragonTail
micro:bit - Elektronik - Hardware
Einen DragonTail kannst du benutzen, um einen micro:bit mit einem...
Mehr lesen
verwenden
Die Funktionsweise der NeoPixel verstehen
Die Funktionsweise eines Temperatur- und Luftfeuchtigkeitssensors vom Typ DHT11 verstehen
Daten von einem Temperatur- und Luftfeuchtigkeitssensor vom Typ DHT11 auslesen
NeoPixel programmieren
Funktionen programmieren.
Hardware
DHT11 - Temperatur- und Luftffeuchtigkeitssensor
Ein Temperatur- und Luftfeuchtigkeitssensor vom Typ DHT11 kann die Temperatur und die Luftfeuchtigkeit in der Umgebung messen.
Das Bauteil enthält sowohl einen Luftfeuchtigkeitssensor als auch einen Thermistor zur Temperaturmessung. Das Bauteil kann an einen micro:bit angeschlossen werden, der vom Sensor auslesen kann, wie hoch die Temperatur und die Luftfeuchtigkeit sind.
Der DHT11 misst am genauesten, wenn die Luftfeuchtigkeitswerte zwischen 20 und 80 % und die Temperaturen zwischen 0 und 50 °C liegen.
Der DHT11 ist nachstehend abgebildet. Er besitzt vier Pins. Der erste Pin (VCC) ist der Pin für die Stromversorgung des Bauteils, der zweite Pin ist der Datenpin (Data), der Daten an den micro:bit sendet. Der dritte Pin (N/C) muss nicht angeschlossen werden, denn N/C steht für Englisch no connection, also "keine Verbindung". Der vierte Pin (GND) ist der Erdanschluss des Bauteils.
Einbinden des DHT11-Sensors
Setze den DHT11 in das Steckbrett ein. Schließe den ersten Pin an den Pluspol der Stromversorgung an. Verbinde den zweiten Pin (Data) mit dem Pin P0 am Dragontail. Schließe den vierten Pin an den Minuspol der Stromversorgung am
Steckbrett
Steckbrett
Elektronik - Hardware
Ein Steckbrett ist ein Kunststoffelement, das mit Leiterbahnen aus Metall...
Mehr lesen
an.
NeoPixel
Ein NeoPixel ist ein elektronisches Bauteil, das drei
Leuchtdioden
Leuchtdiode (LED)
Elektronik - Hardware
Eine Leuchtdiode ist eine kleine Glühbirne, die in einer oder...
Mehr lesen
(LEDs) und einen Mikrocontroller enthält. NeoPixel können RGB-Farben anzeigen. Es ist möglich, mehrere Neopixel in Reihe zu schalten und über einen Pin auf dem micro:bit gleichzeitig anzusteuern.
Ein NeoPixel hat drei Anschlüsse (Beine) auf der linken und drei Anschlüsse auf der rechten Seite. Die Signale laufen von links nach rechts. In dieser Lektion arbeiten wir nicht mit einer Reihenschaltung, sondern wir verwenden zwei NeoPixel, die wir separat anschließen. Der erste NeoPixel dient zur Anzeige der Temperatur, und der zweite NeoPixel dient zur Anzeige der Luftfeuchtigkeit. Aus diesem Grund benötigen wir an jedem NeoPixel nur drei Anschlüsse:
Wir benutzen den VCC-Anschluss auf der linken Seite als Stromversorgung für den NeoPixel. Den IN-Anschluss links nutzen wir für die Dateneingabe vom micro:bit. Den GND-Anschluss auf der rechten Seite verbinden wir mit dem Minuspol der Stromversorgung.
Einrichten der NeoPixel
Setze den ersten NeoPixel ins Steckbrett und verbinde den linken VCC-(+)-Anschluss mit dem Pluspol der Stromversorgung des Steckbretts. Den IN-Anschluss verbindest du mit dem Pin P14 am Dragontail. Den rechten GND-Anschluss verbindest du mit dem Minuspol des Steckbretts.
Kompletter Schaltkreis
Der DHT11 und der rechte NeoPixel werden genau so angeschlossen, wie oben dargestellt. Jetzt setzen wir einen weiteren NeoPixel in das Steckbrett ein. Verbinde den linken VCC-(+)-Anschluss mit dem Pluspol der Stromversorgung am Steckbrett. Den IN-Anschluss verbindest du mit dem Pin P13 am Dragontail. Den rechten GND-Anschluss verbindest du mit dem Minuspol des Steckbretts.
Hier das gesamte Hardware-Setup im Überblick:
Software
Einführung
Mit dieser Schritt-für-Schritt-Anleitung programmierst du ein Klimamessgerät.
Wenn du mit dem Programmieren fertig bis, sollte dein Programm so aussehen:
Anschließen des micro:bit
Bevor du mit dem Programmieren deines Klimamessgeräts beginnen kannst, musst du deinen micro:bit so eingerichtet haben, dass er dein Programm von deinem Computer übernehmen kann:
Schritt 1
Schließe den micro:bit mit dem USB-Kabel an deinem Computer an.
Schritt 2
Öffne den Google Chrome-Browser, um sicherzustellen, dass alles wie in dieser Anleitung funktioniert.
Klicke auf "Neues Projekt" und gib ihm den Namen "Raumklima".
Schritt 3
Füge in den Codeblock "beim Start" den Befehl "zeige Symbol" ein und wähle dein eigenes Symbol oder das im Bild gezeigte Symbol aus.
Schritt 4
Verbinde jetzt deinen micro:bit mit der Browser-Anwendung. Klicke dafür auf die Schaltfläche mit den drei Pünktchen:
Schritt 5
Klicke im Menü auf "Gerät verbinden".
Dein micro:bit wird nun angezeigt, siehe Bild unten. Zum Herstellen der Verbindung klickst du jetzt auf "BBC micro:bit" und dann auf "Verbinden".
Schritt 6
Nun kannst du dein Programm aus MakeCode auf den micro:bit übertragen, indem du auf "Herunterladen" klickst:
Jetzt kannst du mit dem Programmieren loslegen.
Programmieren des Klimamessgeräts
Wir beginnen mit dem Code, der den DHT11-Sensor zum Laufen bringt. Um dieses Programm schreiben zu können, benötigst du eine zusätzliche Programmbibliothek.
Schritt 1
Klicke im Programmmenü links auf "Erweiterungen":
Schritt 2
Gib im Suchfeld "DHT11" ein und wähle dann aus den Suchergebnissen "DHT11_DHT22" aus:
Schritt 3
Die Hinzufügung wird jetzt im Programmmenü angezeigt:
Schritt 4
Jetzt entfernst du zunächst den Programmcode aus dem vorherigen Schritt ("Anschließen des micro:bit"). Auf der Arbeitsfläche befinden sich nun nur die beiden Programmierblöcke "beim Start" und "dauerhaft".
Schritt 5
Klicke auf die neue Bibliothek "DHT11/DHT22" und wähle dort den großen Block:
Ziehe den Block auf die Arbeitsfläche und setze ihn in den Programmierblock "dauerhaft" ein:
Schritt 6
Klicke im Programmmenü unterhalb der neuen Bibliothek auf "... mehr" und wähle dort "Temperature type":
Ziehe "Temperature type" in den Programmierblock "dauerhaft". Stelle die Maßeinheit auf "Celsius" ein, denn auf dieser Skala messen wir in Europa die Temperatur:
Schritt 7
Jetzt soll die Temperatur auf der Konsole angezeigt werden. Klicke auf "Fortgeschritten" und dann auf "Seriell":
Wähle den Block "seriell Zeile ausgeben":
Ziehe den Block in den Programmierblock "dauerhaft":
Klicke jetzt im Menü auf die Bibliothek "DHT11/DHT22" und wähle den zweiten Block "Read":
Setze den Block in die leere Stelle des Blocks "seriell Zeile ausgeben" und wähle als Anzeigeoption "temperature":
Schritt 8
Wähle in der Bibliothek "Grundlagen" den Block "pausiere" und füge ihn unten in deinem Programmierblock ein:
Schritt 9
Ob der Sensor funktioniert, kannst du testen, indem du den Code in deinen micro:bit herunterlädst. Es ist eine gute Idee, die Bauteile und deinen Programmcode kontinuierlich zu testen, wenn du an einem größeren Projekt arbeitest. Wenn du hingegen erst am Schluss testest, nachdem du mit dem Programmieren fertig bist, kann es sehr schwierig sein, den Fehler zu finden.
Klicke auf "Herunterladen" und dann auf "Datengerät anzeigen". Jetzt wird die Temperatur in der Konsole angezeigt:
Die gemessene Temperatur beträgt 22,06 Grad Celsius (°C).
Schritt 10
Wenn du möchtest, dass die Temperatur auf dem LED-Display des micro:bit angezeigt wird, wähle in der Bibliothek "Grundlagen" den Block "zeige Text" und setze ihn wie folgt in dein Programm ein:
Schritt 11
Neben der Temperatur können wir auch die Luftfeuchtigkeit auf der Konsole darstellen. Gehe dazu auf die gleiche Weise vor:
Dupliziere die letzten drei Codeblöcke und füge sie nach der Pause in deinen Programmierblock ein. Unter "Read" wählst du statt der Temperatur jetzt "humidity", das englische Wort für Luftfeuchtigkeit.
Jetzt kannst du auch die Luftfeuchtigkeit auf der Konsole ablesen.
Schritt 12
Nun wollen wir mit der Programmierung der NeoPixel beginnen. Dazu benötigst du eine neue Programmbibliothek. Klicke im Menü auf "Erweiterungen" und suche nach "neopixel". Klicke auf "NeoPixel", um die Bibliothek auszuwählen:
Die Hinzufügung wird jetzt im Menü angezeigt:
Schritt 13
Klicke auf "NeoPixel" und wähle den ersten Codeblock "setze strip auf":
Ziehe den Block in den Programmierblock "beim Start", wähle die Pin-Nummer und trage für die Anzahl der Pixel eine 1 ein:
Schritt 14
Die Farbe und die Leuchtstärke der NeoPixel lässt sich per Programmierung steuern. Zum Programmieren der Leuchtstärke brauchst du den Codeblock "setze Helligkeit". Klicke unterhalb des Menüeintrags "NeoPixel" auf "mehr":
Ziehe den Block "setze Helligkeit" in dein Programm:
Du legst selbst fest, wie hell die Diode leuchten soll. Bei Helligkeit 0 leuchtet der NeoPixel gar nicht. Bei Helligkeit 255 leuchtet der NeoPixel mit voller Stärke.
Schritt 15
Nun legst du fest, in welcher Farbe dein NeoPixel anfangs leuchten soll. Klicke unterhalb des Menüeintrags "NeoPixel" auf "mehr" und wähle den Block "setze Farbe von NeoPixel":
Ziehe den Block "setze Farbe von NeoPixel" in dein Programm:
In den meisten Programmiersprachen beginnt man beim Zählen mit der 0, deshalb steht 0 hier für den ersten NeoPixel. Setze die Farbe von NeoPixel 0 auf weiß.
Schritt 16
Damit der NeoPixel die von dir gewählte Helligkeit und Farbe zeigt, musst du einen weiteren Schritt ausführen. Suche im Menü unter "NeoPixel" den Codeblock "anzeigen" und füge ihn in dein Programm ein:
Dein erster NeoPixel wird jetzt beim Programmstart weiß leuchten.
Schritt 17
Jetzt programmierst du den zweiten NeoPixel auf gleiche Weise wie den ersten. Dupliziere die vier Codeblöcke und stelle sie anschließend so ein, dass sie "strip2" an Pin P14 ansteuern:
Beide NeoPixel werden jetzt beim Programmstart weiß leuchten.
Schritt 18
Nun bist du mit deinem Programm soweit, dass du zwei Funktionen zur Klimamessung programmieren kannst. Funktionen sind freie Codeblöcke, deren Inhalt man selbst festlegen kann. Die Funktionen kannst du wie alle anderen Codeblöcke, mit denen wir bisher gearbeitet haben, in deine Programmierblöcke einbinden.
Die erste Funktion, mit der wir beginnen, soll den ersten NeoPixel mit dem Namen "strip" rot leuchten lassen, wenn die Raumtemperatur mehr als 24 Grad beträgt; andernfalls soll der NeoPixel blau leuchten.
Öffne das Untermenü "Fortgeschritten" und klicke dann auf "Funktionen":
Erstelle jetzt eine Funktion und gib ihr den Namen "Temperatur". Anschließend klickst du auf "Fertig":
Schritt 19
Klicke im Codemenü auf "Logik" und wähle den Codeblock "wenn ... dann ... ansonsten" aus:
Füge den Codeblock in deine neue Temperatur-Funktion ein:
Schritt 20
Klicke erneut auf "Logik" und wähle im Abschnitt "Vergleich" den ersten Codeblock aus:
Setze den Block dort in deiner Funktion ein, wo bislang "wahr" stand:
Damit die Funktion erkennt, wie hoch die Temperatur am DHT11-Sensor ist, musst du einen Lesevorgang einbauen. Dazu verwendest du im Menü "DHT11/DHT12" den Codeblock "Read":
Füge den Codeblock in deine Funktion nach dem "wenn" ein. Jetzt änderst du noch das "=" zu ">" und die die Zahl 0 im letzten Feld auf die Zahl 24:
Deine Funktion macht bislang Folgendes: Wenn die Temperatur am Sensor größer als 24 ist, führt sie eine Aktion aus. Diese Aktion wollen wir im nächsten Schritt definieren.
Schritt 21
Wenn die Temperatur höher als 24 Grad ist, soll dein NeoPixel rot leuchten. Um die Farbe des NeoPixels zu verändern, musst du zunächst die aktuelle Leuchtfarbe löschen. Dazu verwendest du den Codeblock "ausschalten", den du im Menü "NeoPixel" findest. Anschließend klickst du unterhalb des Menüpunkts "NeoPixel" auf "mehr" und wählst dann den Codeblock "setze Farbe von NeoPixel 0 auf rot":
Schritt 22
Wenn die Temperatur nicht über 24 Grad liegt, soll dein NeoPixel blau leuchten:
Schritt 23
Deine Temperatur-Funktion ist jetzt fertig und soll vom Programmblock "dauerhaft" aus aufgerufen werden. In der Programmierung nennt man das Aktivieren einer Funktion "aufrufen".
Wähle im Menü "Funktionen" den Block "Aufruf Temperatur" aus und setze ihn in dein Programm ein:
Schritt 24
Als Nächstes programmieren wir die Funktion für das Auslesen der Luftfeuchtigkeit. Dupliziere die Funktion "Temperatur" und nenne sie "Feuchtigkeit". Diese Funktion soll je nach Luftfeuchtigkeit am Sensor verschiedene Aktionen ausführen. Zunächst änderst du im ersten Block der Funktion "temperature" in "humidity", das englische Wort für Luftfeuchtigkeit.
Wenn die Luftfeuchtigkeit über 60 liegt, möchten wir, dass dein zweiter NeoPixel, der die Bezeichnung "strip2" trägt, orange leuchtet. Liegt der Wert bei 60 oder darunter, soll er grün leuchten:
Schritt 25
Jetzt ist auch die Funktion für die Luftfeuchtigkeit fertig und soll vom Programmblock "dauerhaft" aufgerufen werden. Wähle im Menü "Funktionen" den Block "Aufruf Feuchtigkeit" aus und setze ihn in dein Programm ein:
Schritt 26
Klicke auf "Herunterladen". Jetzt bist du fertig und kannst dein neues Klimamessgerät ausprobieren.
Anwenden des Klimamessgeräts
Einführung
Nachdem du dein Klimamessgerät aufgebaut und programmiert hast, ist es einsatzbereit. Ein Klimamessgerät in Innenräumen kann dich darauf aufmerksam machen, ob du die Heizung höher oder niedriger einstellen solltest oder ob es Zeit, die Räume auszulüften.
Schritt 1
Vergewissere dich, dass MakeCode in deinem Browser geöffnet ist und dass dein micro:bit korrekt angeschlossen ist, wie im Abschnitt Anschließen des micro:bit gezeigt.
Schritt 2
Jetzt bis du bereit, dein System zu testen.
Aufgaben
Opgave 1
Ändere deine Funktionen so ab, dass die beiden NeoPixel in anderen Farben leuchten.
Verändere die Leuchtstärke (Helligkeit), indem du den Programmcode für die NeoPixel veränderst.
Teste dein Klimamessgerät an verschiedenen Stellen im Raum, zum Beispiel direkt an einem Heizkörper oder am Kühlschrank.
Opgave 2
Erweitere deine Temperaturfunktion so, dass der NeoPixel blau leuchtet, wenn die Temperatur 15 Grad oder weniger beträgt, dass er gelb leuchtet, wenn die Temperatur zwischen 16 und 22 Grad liegt, und dass er orange leuchtet, wenn die 23 Grad oder mehr beträgt.
Erweitere deine Feuchtigkeits-Funktion so, dass bei einer Luftfeuchtigkeit unter 45 auf dem LED-Display des micro:bit ein Smiley angezeigt wird.
Erweitere deine Feuchtigkeits-Funktion so, dass bei einer Luftfeuchtigkeit unter 45 auf dem LED-Display des micro:bit ein Smiley angezeigt wird.
Erstelle eine neue Funktion, die bewirkt, dass der NeoPixel, der der Temperatur zugeordnet ist, jedes Mal blinkt, wenn die gemessene Temperatur von der Temperatur abweicht, die 2 Sekunden zuvor gemessen wurde.
120 min 
7.-9. Klasse 
