In diesem Tutorial lernst du, wie du den DHT11 und den DHT22 am Arduino und ESP8266 anschließt und verwendest.

Den Sensor DHT11 anschließen

Der Anschluss des DHT11 am Arduino ist ganz leicht, du benötigst lediglich drei Kabel. Orientiere dich beim Anschluss an folgender Skizze. An welchen Digital-Pin du deinen Sensor anschließt, steht dir natürlich frei. Damit der Code dieses Tutorials passt, wähle bitte den Pin 4.

Den Sensor DHT22 anschließen

Um deinen DHT22 am Arduino oder ESP8266 anzuschließen, benötigst du neben Sensor, Microcontroller, Breadboard und Kabeln einen Widerstand mit 10 kΩ. Orientiere dich beim Anschluss am Arduino an folgender Skizze:

Hier ist der Signalpin des DHT22 am Digital-Pin 4 des Arduinos angeschlossen – so passt der Anschluss zum Sketch unten. Prinzipiell steht es dir natürlich frei, welchen Digital-Pin du verwendest.

Der Anschluss am ESP8266 sieht folgendermaßen aus:

Beim Arduino kannst du den DHT11 oder DHT22 entweder mit 5 Volt oder 3,3 Volt versorgen. Beim ESP8266 stehen dir natürlich nur 3,3 Volt zur Verfügung.

Die passenden Bibliotheken

Du benötigst zwei Bibliotheken, von denen du jedoch nur eine im Sketch einbinden musst. Öffne zunächst deinen Bibliotheksmanager und suche dort nach Adafruit Unified Sensor. Installiere anschließend die aktuelle Version.

Suche nun nach DHT11 oder DHT22 und installiere die Bibliothek DHT sensor library.

Wenn du beide Bibliotheken erfolgreich installiert hast, geht es weiter mit der Messung.

Temperatur und Luftfeuchtigkeit messen

Binde als erstes die Bibliothek für den Sensor zu Beginn deines Sketchs ein:

#include "DHT.h"

Anschließend definierst du den Pin, an dem der Sensor angeschlossen ist. In der Zeile danach legst du den Typ des DHT fest: In unserem Fall also DHT22 – wenn du einen DHT11 verwendest, kannst du die Zeile entsprechend abändern.

#define DHTPIN 4   
#define DHTTYPE DHT22

Nun fehlen noch zwei Variablen für die Temperatur und die Luftfeuchtigkeit sowie ein Objekt für den Sensor namens dht.

float temp;
float humidity;

DHT dht(DHTPIN, DHTTYPE);

In der Setup-Funktion startest du den Sensor mit

dht.begin();

Die eigentliche Messung findet dann im Loop statt. Diese könnte dank der eingebundenen Bibliothek kaum einfacher sein, da es passende Funktionen gibt. Die Messergebnisse speicherst du in den entsprechenden Variablen:

temp = dht.readTemperature();
humidity = dht.readHumidity();

Und das war es schon. Hier nun der vollständige Sketch, in dem du die Messergebnisse alle zwei Sekunden im Seriellen Monitor ausgibst:

#include "DHT.h"

#define DHTPIN 4   
#define DHTTYPE DHT22

float temp;
float humidity;

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(9600);
  dht.begin();
}

void loop() {

  temp = dht.readTemperature();
  humidity = dht.readHumidity();
  
  Serial.print("Temperatur: ");
  Serial.print(temp);
  Serial.println(" *C");
  Serial.print("Luftfeuchtigkeit: ");
  Serial.print(humidity);
  Serial.println(" %");

  Serial.println();
  delay(2000);

}

Wie geht es weiter?

Wie wäre es mit einem eigenen ESP8266 Web Server, über den du die aktuelle Temperatur vom Smartphone aus abrufen kannst?

Dieses Projekt ist der zweite Teil einer Serie: Inhaltlich baut es auf unserem Stillen Alarm mit Telegram auf. Schaue dort hinein, um mehr über die grundlegenden Funktionen des Sketchs zu erfahren. Auch in diesem Projekt wartet dein ESP8266 darauf, dass ein bestimmtes Ereignis eintritt. Allerdings wird er hier nicht durch einen Interrupt getriggert, sondern fragt selbst die Daten eines Temperatursensors ab.

Anfänger

1 – 2 Stunden

ca. 12 €

Für dieses Projekt benötigst du (Mengen s. Beschreibung):

AZDelivery NodeMCU Amica Modul V2 ESP8266 ESP-12F WiFi - Node MCU ESP 8266 WiFi Development Board mit CP2102 kompatibel mit Arduino - inklusive Installationsanleitung als E-Book

Maße (LxBxH): 48 x 26 x 13 mm

7,49 €

Angebot

AZDelivery GY-68 BMP180 Barometrischer Luftdruck und Temperatur Sensor kompatibel mit Arduino und Raspberry Pi inklusive E-Book!

3,79 €

AZDelivery Mini Breadboard 400 Pin mit 4 Stromschienen kompatibel mit Arduino und Jumper Wire Kabeln

Breadboard – kaufen Sie jetzt zum Vorteilspreis!; Steckbrett für schnellen...

3,99 €

AZDelivery Jumper Wire Kabel 3 x 40 STK. je 20 cm M2M/ F2M / F2F kompatibel mit Arduino und Raspberry Pi Breadboard inklusive E-Book!

6,99 €

Der passende Temperatursensor

In diesem Projekt verwenden wir den Sensor BMP180. Du kannst aber natürlich auch jeden anderen Temperatursensor verwenden – z.B. einen einfachen TMP36, einen DHT22 oder einen GY-906. Denke in diesem Fall daran, deinen Sketch entsprechend anzupassen.

In diesen Tutorials lernst du, wie du einen TMP36 und einen GY-906 anschließt und verwendest.

Der Aufbau des Projekts

Du benötigst nur deinen ESP8266, den Temperatursensor (in unserem Fall einen BMP180), ein Breadboard und Kabel. Orientiere dich beim Aufbau an diesem Schema:

Der Sensor BMP180 wird per I²C angeschlossen. Am ESP8266 musst du deshalb zwingend die beiden Pins D1 und D2 verwenden. Schließe den Sensor wie folgt an:

Der Sketch

___STEADY_PAYWALL___

Kopiere den folgenden Sketch in deine Arduino IDE, ergänze deine Daten und lade ihn auf deinen ESP8266.

Sketch als .txt anschauen

/*
   Die Temperatur überwachen mit Telegram - polluxlabs.net
*/

//Bibliotheken
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.h>

#include <Wire.h>
#include <Adafruit_BMP085.h>

// Deine WLAN-Zugangsdaten
const char* ssid = "NETZWERKNAME";
const char* password = "PASSWORT";

// Den Telegram-Bot initialisieren
#define botToken "DEIN TOKEN"  // den Bot-Token bekommst du vom Botfather)

//Deine UserID
#define userID "DEINE USERID"

WiFiClientSecure client;
UniversalTelegramBot bot(botToken, client);

Adafruit_BMP085 bmp;

//Variablen für die Temperatur
float temp;
float threshold = 27.00;

//Verbindung zum WLAN
void connectToWiFi() {
  Serial.print("Verbinde mich mit: ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(300);
  }
  Serial.println("");
  Serial.println("Verbunden!");
}

void setup() {
  Serial.begin(115200);
  client.setInsecure();

  if (!bmp.begin()) {
    Serial.println("Kein Sensor gefunden! Checke die Verbindung.");
    while (1) {}
  }
}

void loop() {
  temp = bmp.readTemperature();
  Serial.print("Temperatur = ");
  Serial.print(temp);
  Serial.println(" °C");

  if (temp > threshold) { //Die Temperatur, die überschritten werden muss
    connectToWiFi();
    bot.sendMessage(userID, "Temperatur zu hoch!  " + String(temp) + " °C", "");
    Serial.println("Temperatur zu hoch!");
    WiFi.disconnect();
    delay(300000);
  }
  delay(500);
}

Was ist neu in diesem Sketch?

Vieles im Code haben wir schon im Stillen Alarm verwendet. Ein paar Teile sind jedoch neu und diese schauen wir uns nun genauer an.

Zunächst benötigst du zwei weitere Bibliotheken. Wire.h ist für die Kommunikation per I²C zuständig. Diese Bibliothek ist standardmäßig bereits vorinstalliert. Damit du den Sensor BMP180 so einfach wie möglich verwenden kannst, existiert ebenfalls eine passende Bibliothek: Arduino_BMP085.h. Lass dich nicht vom Namen irritieren. Dort steht zwar BMP085 (das ist der Vorläufer des BMP180), sie funktioniert jedoch auch mit dem BMP180 problemlos.

Am Anfang deines Sketchs bindest du also zusätzlich diese beiden Bibliotheken ein:

#include <Wire.h>
#include <Adafruit_BMP085.h>

Ebenfalls zu Beginn des Sketchs erstellst du für den Sensor das Objekt bmp sowie zwei Variablen: eine für die gemessene Temperatur (temp) und eine für den Schwellenwert (threshold), bei dessen Überschreiten dein ESP8266 eine Nachricht an dich sendet. In unserem Beispiel setzen wir diesen Schwellenwert auf 27,00 °C. Da der BMP180 die Temperatur als Kommazahl ausgibt, benötigst du für diese Variablen den Dateityp float.

Adafruit_BMP085 bmp;
float temp;
float threshold = 27.00;

In der Setup-Funktion prüfst du, ob der Temperatursensor von deinem ESP8266 gefunden wurde und verwendet werden kann. Ist das nicht der Fall, wirst du im Seriellen Monitor darüber informiert und der Sketch begibt sich mit while(1) in eine Endlosschleife – friert also ein.

  if (!bmp.begin()) {
    Serial.println("Kein Sensor gefunden! Checke die Verbindung.");
    while (1) {}
  }

Solltest den obigen Text also in deinem Seriellen Monitor zu Gesicht bekommen, trenne deinen ESP8266 vom Strom und überprüfe deine Verkabelung. In den meisten Fällen sollte hier der Fehler liegen.

Der Loop

Im Loop fragst du die Temperatur im Halbsekundentakt ab und prüfst mit einem Schwellenwert, ob sie diesen überschritten hat.

temp = bmp.readTemperature();

Wenn das der Fall ist, verbindet sich dein ESP8266 mit dem Internet und sendet eine entsprechende Nachricht an dein Smartphone.

if (temp > threshold) { //Wenn die Temperatur über dem Schwellenwert liegt
    connectToWiFi();
    bot.sendMessage(userID, "Temperatur zu hoch!  " + String(temp) + " °C", "");

Die Funktion bot.sendMessage() besteht aus drei Teilen. Der mittlere ist die Nachricht selbst, die du hier jedoch aus zwei Strings und der Variablen temp “zusammenbaust”. Hierfür verbindest du die einzelnen Teilstrings einfach mit einem Pluszeichen – doch Vorsicht: In der Mitte befindet sich die Variable temp als float. Um den Wert in dieser Variablen senden zu können, musst du diese erst mit der Funktion String(temp) in einen String umwandeln.

Auf deinem Smartphone erscheint dann der Text: “Temperatur zu hoch! x °C” – wobei das x für die gemessene Temperatur steht.

Zuletzt trennt dein ESP8266 die Verbindung zu deinem WLAN wieder und setzt sich für 5 Minuten (300.000 Millisekunden) zur Ruhe. Erst dann beginnt er wieder damit, alle 500 Millisekunden die Temperatur vom BMP180 abzufragen.

    WiFi.disconnect();
    delay(300000);
  }
  delay(500);
}

Sollte danach die Temperatur immer noch über dem Schwellenwert liegen, erhältst du eine weitere Nachricht.

Falls noch nicht geschehen, lade den Sketch auf deinen ESP8266 und probiere ihn gleich aus.

Das passende Gehäuse

Möchtest du das Projekt in einem kleinen Gehäuse unterbringen? Hier findest du passende 3D-Druck-Dateien, die du herunterladen und ausdrucken kannst.

Wie geht es weiter?

Im nächsten Teil der Serie wartest du nicht darauf, bis dein ESP8266 sich bei dir meldet, sondern fragst die Temperatur selbst von deinem Smartphone aus ab.

Statt eines Temperatursensors kannst du auch andere Sensoren einsetzen: So kannst du dich warnen lassen, wenn die Luft zu schlecht oder das Licht zu hell ist. Es gibt auch Sensoren, die Flammen erkennen können – solltest du diesen einsetzen, hoffen wir, dass du niemals eine entsprechende Nachricht erhältst!

Der BMP180* misst jedoch neben der Umgebungstemperatur auch den Luftdruck, was es dir z.B. ermöglicht, eine rudimentäre Wettervorhersage zu bauen.

In diesem Tutorial erfährst du, wie du den Sensor anschließt, welche Bibliothek du brauchst und wie du die Temperatur und die Luftfeuchtigkeit misst.

Den BMP180 anschließen

Oft wir dieser kleine Sensor leider mit unverlöteten Pins geliefert, was für dich bedeutet, dass du diese selbst an das Breakout Board löten musst. Das sollte dich aber vor keine große Herausforderung stellen.

Die Kommunikation mit dem BMP180 erfolgt über I2C, versorgt wird er mit 3,3 Volt. Wenn du einen Arduino Uno verwendest, schließe deinen Sensor wie folgt an:

Die richtige Bibliothek für den BMP180

Neben der bereits vorinstallierten Bibliothek Wire, benötigst du noch eine weitere, um die Daten des Sensors problemlos auslesen zu können.

Öffne also den Bibliotheksmanager in der Arduino IDE und suche nach BMP180. Du findest nun eine Bibliothek namens Adafruit BMP085 Library – das ist die richtige, auch wenn sie ein anderes Modell im Namen trägt. Der BMP085 war das Vorgängermodell des BMP180, was die Kommunikation angeht, jedoch mehr oder weniger baugleich.

Installiere also diese Bibliothek und schließe den Bibltiotheksmanager.

Temperatur und Luftdruck messen

Jetzt kann es mit der Messung auch schon losgehen. Kopiere dir den folgenden Sketch und lade ihn auf deinen Arduino hoch:

#include <Wire.h>
#include <Adafruit_BMP085.h>

Adafruit_BMP085 bmp;
  
void setup() {
  Serial.begin(9600);
  if (!bmp.begin()) {
	Serial.println("Sensor nicht gefunden!");
	while (1) {}
  }
}
  
void loop() {
    Serial.print("Temperatur = ");
    Serial.print(bmp.readTemperature());
    Serial.println(" *C");
    
    Serial.print("Luftdruck = ");
    Serial.print(bmp.readPressure());
    Serial.println(" Pa");
    
    Serial.println();
    delay(2000);
}

In deinem Seriellen Monitor sollten jetzt alle 2 Sekunden die Messwerte für die Temperatur in °C und den Luftdruck in Pa erscheinen. Wenn du den Luftdruck lieber in Bar haben möchtest, teile den Sensorwert einfach durch 100.000 – z.B. entsprechen 102395 Pa = 1,02395 Bar.

Wenn du keine Werte in deinem Seriellen Monitor siehst, überprüfe zunächst die Baudrate – im Sketch sind es 9600.

Wie geht es weiter?

Jetzt, wo du den Luftdruck messen kannst, wäre eine eine einfache Wettervorhersage eine gute Idee. Wie steigender und fallender Luftdruck mit dem kommenden Wetter zusammenhängen, kannst du hier nachlesen.

Du willst eigentlich nur die Temperatur messen? Dann erfahre hier auf pollux labs, wie du einen TMP36 oder einen GY-906 verwendest.

*Amazon Affiliate Links – wenn du dort bestellst, erhalten wir eine kleine Provsion.

Mit einem ESP8266 rufst du über eine API die aktuelle Wetterlage ab und zeigst auf einem OLED-Display an, ob es regnet, schneit oder die Sonne scheint. Falls du draußen einen Regenschirm benötigst, erinnert dich das Display und eine LED daran, deinen Regenschirm mitzunehmen.

Ach ja: Damit dein ESP8266 nicht den ganzen Tag im Internet verbringt und ständig die Wetterdaten abruft, integrierst du noch eine Radar-Modul. So kannst du dein Projekt zum Beispiel an der Wohnungstür platzieren und es nur dann anspringen lassen, wenn du dich ihm näherst. So wirst du genau zur richtigen Zeit erinnert.

Anfänger

1 – 2 Stunden

ca. 15 €

Für dieses Projekt benötigst du (Mengen s. Beschreibung):

AZDelivery NodeMCU Amica Modul V2 ESP8266 ESP-12F WiFi - Node MCU ESP 8266 WiFi Development Board mit CP2102 kompatibel mit Arduino - inklusive Installationsanleitung als E-Book

Maße (LxBxH): 48 x 26 x 13 mm

7,49 €

AZDelivery 1,3 Zoll OLED Display I2C SSH1106 Chip 128 x 64 Pixel I2C Bildschirm Anzeigemodul mit weißen Zeichen kompatibel mit Arduino und Raspberry Pi inklusive E-Book!

Es ist kompatibel mit Betriebsspannungen von 3,3V für Raspberry Pi und mit 5V.

8,49 €

WINGONEER 5PCS Mikrowellen-Radarsensor RCWL-0516 Schalter-Modul menschlicher Induktions-Brett-Detektor

4,99 €

AZDelivery Jumper Wire Kabel 3 x 40 STK. je 20 cm M2M/ F2M / F2F kompatibel mit Arduino und Raspberry Pi Breadboard inklusive E-Book!

6,99 €

Der Aufbau

So ungefähr sollte das fertig aufgebaute Projekt aussehen:

Setze zuerst deinen ESP8266 auf dein Breadboard. Wir empfehlen hierfür ein NodeMCU Lua Amica, denn das ist schmal genug, dass du an den Pinouts noch Kabel einstecken kannst. Die neuere Version namens Lolin ist da im Nachteil und deshalb für Projekte auf Breadboards eher ungeeignet. Anschließend verbindest du deinen Microcontroller mit diesem 3 Bauteilen:

OLED-Display

In diesem Projekt verwendest du ein kleines OLD-Display mit I²C-Anschluss. Setze dein Display auf das Breadbaord und verbinde es zunächst mit einem der GND-Pins und einem 3,3V-Ausgang am Microcontroller. Anschließend verbindest du den Display-Pin SCL mit D1 und den Pin SDA mit D2. Mit den beiden Pins D1 und D2 kannst du per I²C mit deinem Display kommunizieren.

Radar-Modul RCWL-0516

Dieser Sensor ist ein einwandfreier Bewegungssensor mit einer Reichweite von 5 bis 7 Metern. Das Tolle an diesem Modul ist, dass es sogar Bewegungen durch ein Hindernis (zum Beispiel eine Box) erkennen kann.

Der Anschluss ist kinderleicht: Neben dem üblichen Anschluss von GND und 3,3V verbindest du den Pin OUT mit dem Pin D7 an deinem ESP8266.

Die LED

Nun zur allerleichtesten Übung, der LED. Verbinde die Anode (langes Bein) mit dem Pin D6 und die Kathode (kurzes Bein) mit Erde. Vergiss nicht, einen Widerstand zwischenzuschalten!

Der Code für dein Projekt

Etwas komplexer wird es jetzt, denn zunächst musst du dich für eine -kostenlosen- API registrieren, von der du die aktuelle Wetterlage an deinem Wohnort (oder an jedem anderen Ort der Erde) abrufen kannst.

Registriere dich zunächst auf https://openweathermap.org. Für einen Account benötigst du nur einen Usernamen, eine E-Mail-Adresse und ein Passwort. In deinem persönlichen Bereich hast du unter dem Menüpunkt API keys nun die Möglichkeit einen solchen API key zu erstellen. Diesen benötigst du später in deinem Arduino Sketch für die API-Abfrage der Wetterdaten. Wenn du das gemacht hast, kann es mit dem Code weitergehen.

___STEADY_PAYWALL___

Die benötigten Bibliotheken

Für dieses Projekt benötigst du 6 Bibliotheken. Falls du sie bisher in deiner Arduino IDE noch nicht installiert hast, hole das am besten gleich nach. Klicke hierfür auf den Menüpunkt Werkzeuge und anschließend auf Bibliotheken verwalten. Anschließend öffnet sich der sogenannte Bibliotheksverwalter, in dem du nach den jeweiligen Bibliotheken suchen kannst. Installiere jeweils die neueste Version.

Wenn du damit fertig bist, bindest du sie noch vor der Funktion void setup() am Anfang deines Sketchs ein:

#include <Wire.h> //I2C-Verbindung
#include <Adafruit_GFX.h> //OLED-Display
#include <Adafruit_SSD1306.h> //OLED-Display

#include <ESP8266WiFi.h> //WiFI
#include <ArduinoJson.h> //JSON
#include <ESP8266HTTPClient.h> //API-Abfrage

Zugangsdaten zum Internet und OLED-Display

Damit sich dein ESP8266 mit dem Internet verbinden kann, musst du deine Zugangsdaten hinterlegen. Gleich dahinter folgt etwas Code für die Kommunikation mit deinem Display:

// WIFI-Zugangsdaten
const char* ssid = "Dein Netzwerkname";
const char* password =  "Dein Passwort";


//OLED-Display
#define SCREEN_WIDTH 128 // Breite des Displays in Pixeln
#define SCREEN_HEIGHT 64 // Höhe des Displays in Pixeln

//Angaben zum OLED-Display und der Kommunikation per I2C
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

Icons für alle (wichtigen) Wetterlagen

Auf deinem Display sollen später Icons erscheinen, die das aktuelle Wetter symbolisieren: Klarer Himmel, Wolken, Schnee, Nebel – und ein Regenschirm für Regen und Gewitter. Die Deklarationen dieser Icons im Code sind sehr lang. Deshalb findest du sie nicht an dieser Stelle, sondern im gesamten Arduino-Sketch, den du unten findest.

Die Setup-Funktion

In der Funktion void setup() definierst du die beiden Pins für die LED und den Radar-Sensor, bereitest du die Verbindung zum Seriellen Monitor vor, gibst die Adresse deines Displays an und legst die Schriftgröße und -farbe fest.

void setup() {

  pinMode (12, OUTPUT); //LED Pin (am ESP8266 D6)
  pinMode (13, INPUT); //Radar Pin (am ESP8266 D7)

  Serial.begin(115200); //Verbindung zum Seriellen Monitor

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Display-Addresse: 0x3C
    Serial.println(F("SSD1306 allocation failed"));
    for (;;);
  }

  display.setTextSize(1); //Schriftgröße
  display.setTextColor(WHITE); //Schriftfarbe
}

Der Loop

In der Funktion void loop() arbeitet dein Radar-Modul. Alle 100 Millisekunden prüft es, ob sich etwas in der Nähe bewegt. Ist das der Fall, verbindet sich dein ESP8266 mit dem Internet und startet die Abfrage der Wetterdaten von Openweather. Solange das nicht der Fall ist, läuft der Loop immer weiter und das OLED-Display bleibt dunkel.

void loop() {

  delay(100); //100 Millisekunden warten

  if (digitalRead(13) == 1) { //Sobald das Radar eine Bewegung registriert, startet die Internet-Verbindung
    WiFi.begin(ssid, password); //Internet-Verbindung starten

    while (WiFi.status() != WL_CONNECTED) { //Statusnachricht "Verbindung herstellen" solange nicht verbunden
      delay(1000);
      display.clearDisplay();
      display.setCursor(0, 10);
      display.println("Connecting to WiFi...");
      display.display();

    }

    delay(1000);
    display.clearDisplay();
    display.setCursor(0, 10);
    display.println("Hello, world!"); //Ausgabe, sobald die Verbindung zum Internet steht
    display.display();

    apiCall(); //Aufruf der Funktion für Abruf und Ausgabe der Wetterdaten
    
  } else {
    WiFi.disconnect(); //Wenn keine Bewegung registriert wird Internet-Verbindung beenden...
    digitalWrite(12, LOW); //...und die LED ausschalten
  }
}

Die Funktion apiCall()

Diese Funktion ist das Herzstück deines Codes! Hier startest du die Abfrage bei der API (ein sogenannter API Call), verarbeitest die in deinem ESP8266 ankommenden Daten und zeigst abhängig vom Wetter ein entsprechendes Icon auf deinem Display an. Zusätzlich gibst du noch die aktuelle Temperatur aus und lässt bei Regen die LED leuchten.

Dieser Code ist nicht ganz einfach. Deshalb schauen wir ihn uns Schritt für Schritt an:

Als allererstes definierst du natürlich die Funktion selbst und schreibst eine If-Abfrage, innerhalb der sich der gesamte folgende Code abspielt. Mit dieser Abfrage stellst du sicher, dass dieser nur ausgeführt wird, wenn die Verbindung zum Internet steht. Denn ohne Internet keine Wetterdaten.

void apiCall() {

  if ((WiFi.status() == WL_CONNECTED)) { //Netzwerkstatus checken

Wetterdaten abrufen und verarbeiten

Als nächstes erstellst du eine Instanz der Klasse HTTPClient namens http. Anschließend kommt die Abfrage bei Openweather. Hierfür verwendest du eine URL, in der die Art der Abfrage (aktuelles Wetter) und der gewünschte Ort definiert sind. Am Ende der URL steht dein API key, den du zu Beginn erstellt hast. Nähere Informationen erhältst du in der Dokumentation von Openweather.

    HTTPClient http; //Instanz von HTTPClient starten

    http.begin("http://api.openweathermap.org/data/2.5/weather?q=Berlin,de&units=metric&appid=DEIN API KEY"); //URL für die Abfrage

    int httpCode = http.GET(); //Antwort des Servers abrufen
    Serial.println(httpCode); //Antwort im Seriellen Monitor ausgeben

Jetzt folgt ein Check, ob die Abfrage funktioniert hat. In diesem Fall erhältst du vom Server die Antwort 200. Also schreibst du eine If-Abfrage, die allen folgenden Code nur ausführt, wenn die Server-Antwort positiv ausgefallen ist und du die gewünschten Daten erhalten hast.

Danach speicherst du diese Daten in der Variable payload und verarbeitest sie mit Hilfe der Bibliothek ArduinoJson. Die Erklärung, wie das genau funktioniert, würde den Rahmen hier sprengen. Nähere Erläuterungen findest du im Projekt Ein Newsticker per API Call & JSON und auf der Webseite des Entwicklers dieser Bibliothek.

    if (httpCode == 200) { //Die Antwort des Servers checken

      String payload = http.getString(); //Daten in eine Variable speichern

      const size_t capacity = JSON_ARRAY_SIZE(1) + 2 * JSON_OBJECT_SIZE(1) + 2 * JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(4) + JSON_OBJECT_SIZE(5) + JSON_OBJECT_SIZE(6) + JSON_OBJECT_SIZE(14) + 290;
      
      DynamicJsonDocument doc(capacity); //Größe des Speichers zur JSON-Verarbeitung festlegen

      DeserializationError error = deserializeJson(doc, payload); //JSON parsen

      http.end(); //Die Verbindung zum Server beenden

      if (error) { //Fehlermeldung bei fehlerhafter Verarbeitung
        Serial.print(F("deserializeJson() failed: "));
        Serial.println(error.c_str());
        return;
      }

In der Variable payload befinden sich nun die Wetterdaten im JSON-Format. Wie diese aussehen, kannst du sehen, wenn du die URL zur Abfrage aus deinem Sketch in deinem Browser aufrufst. Hier ein Beispiel für Berlin am Abend des 13. Januar 2020:

{"coord":{"lon":13.41,"lat":52.52},"weather":[{"id":802,"main":"Clouds","description":"scattered clouds","icon":"03n"}],"base":"stations","main":{"temp":3.2,"feels_like":-1.49,"temp_min":1.11,"temp_max":5,"pressure":1017,"humidity":86},"visibility":10000,"wind":{"speed":4.1,"deg":180},"clouds":{"all":40},"dt":1578947701,"sys":{"type":1,"id":1275,"country":"DE","sunrise":1578899517,"sunset":1578928632},"timezone":3600,"id":2950159,"name":"Berlin","cod":200}

Etwas schwer zu lesen, oder? Für deinen ESP8266 ist das jedoch kein Problem. Die Bibliothek ArduinoJson stellt dir hierfür alles zur Verfügung. Kurz gesagt, kannst du mit einer paar Zeilen Code genau die Daten herausfischen, die du brauchst. Über allem steht ein For-Loop, der dafür sorgt, das die kommenden Anzeigen und Animationen drei Mal angezeigt werden, bis das Display wieder erlischt:

      //Wetterlage und Temperatur ausgeben
      for (int j = 0; j < 3; j++) { // 3x Animation durchlaufen lassen bis zur nächsten Messung
        //Wetterdaten auslesen anhand von ID
        JsonObject weather_0 = doc["weather"][0];
        int weather_0_id = weather_0["id"]; // Wetter-ID
        Serial.println(weather_0_id);

Aus den Daten hast du jetzt die ID des aktuellen Wetters herausgelesen. Openweather vergibt nämlich jeder Wetterlage eine eigene dreistellige ID. So hat leichter Regen zum Beispiel die ID 500. Herabrieselnde Vulkanasche hingegen die ID 762! Alle IDs findest du hier.

Wetterdaten auf dem Display zeigen

Jetzt folgen eine Reihe von If-Abfragen, die das zum Wetter passende Icon auf deinem Display zeigen und animieren. Hier exemplarisch der ID-Bereich “Wolken” – das sind alle IDs zwischen 801 und 804. Nähere Erläuterungen findest du in den Kommentaren im Code. Interessant ist der For-Loop: Hier verschiebst du das Icon nach links, indem du es 128 Mal (die Breite des Icons) immer einen Pixel weiter links anzeigst. Das erzeugt den Eindruck einer Animation.

        if (weather_0_id > 800 && weather_0_id < 900) {
          //Cloud anzeigen und wegschieben
          display.clearDisplay(); //Display löschen
          display.drawBitmap(0, 0, clouds, 128, 64, WHITE); //Icon zeichnen...
          display.display(); //...und anzeigen
          digitalWrite(12, LOW); //LED ausschalten, da kein Regen
          delay(2000);
          for (int i = 0; i > -128; i--) { //Das Icon aus dem Display "schieben"
            display.clearDisplay();
            display.drawBitmap(i, 0, clouds, 128, 64, WHITE);
            display.display();
            delay(1);
          }

Es folgen weitere Abfragen per else if{} für die anderen Wetterlagen, die du unten im gesamten Sketch findest.

Jetzt fehlt noch die Anzeige der Temperatur. Auch diese liest du aus den JSON-Daten aus und bringst sie animiert auf dein Display:

//Temperatur anzeigen und animieren
        JsonObject main = doc["main"];
        int main_temp = (int)main["temp"]; // Daten in ein INT umwandeln und in Variable speichern
        String temp = String(main_temp) + " C"; //C für Celsius anhängen
        display.setTextSize(3); //Schriftgröße erhöhen
        display.setCursor(25, 20);
        display.println(temp);
        display.display();
        delay(2000);
        for (int i = 25; i > -144; i--) { //Animation
          display.clearDisplay();
          display.setCursor(i, 20);
          display.println(temp);
          display.display();
          delay(1);
        }

Zuletzt setzt du die Schriftgröße wieder auf 1 und schließt alle offenen Klammern. Das allerletzte else bezieht sich auf die Abfrage, ob die Antwort des Servers positiv (also 200) war und gibt eine Fehlermeldung zurück, falls das nicht so war.

Hier nun der vollständige Sketch. Wenn du ihn kopierst und verwendest, achte unbedingt darauf, deine eigenen WLAN-Daten und deinen API key von Openweather in die markierten Stellen einzutragen.

Wie geht es weiter?

Du hast jetzt ein Gerät gebaut, das dich an deinen Regenschirm erinnert. Integriere es in eine Box und versorge den ESP8266 zum Beispiel mit einer Powerbank über USB mit Strom. Diese Box kannst du in der Nähe deiner Wohnungstür platzieren, damit dich dein Projekt genau im richtigen Moment vor dem Regen draußen warnt.

Du denkst größer und an deinen eigenen Wetter-Server? Dann lerne hier, wie du deinen ESP8266 in einen Web Server verwandelst. Oder wie wäre es mit einer ESP8266 Wetterstation, die Daten auf einem Raspberry Pi sammelt und visualisiert?

Beachte jedoch: Zu 100% kannst du dich leider nicht auf die Wetterdaten aus dem Internet verlassen. Manchmal ist vielleicht ein prüfender Blick aus dem Fenster doch sicherer.

In diesem Tutorial lernst du, wie du den GY-906 anschließt und damit Temperaturen misst.

Bestseller Nr. 1

TECNOIOT 2pcs GY-906 MLX90614 Non-Contact Infrared Temperature Sensor Module MLX90614ESF

• GY906 GY-906 MLX90614 Berührungsloses Infrarot-Temperatursensor-Modul MLX90614ESF IIC I2C
• Das kompakte GY-906 MLX90614ESF ist ein berührungsloses Infrarot-Thermometer für Arduino oder jeden Mikrocontroller, der über seine I2C-Schnittstelle mit ihm kommunizieren kann. Dieser Sensor wird mit einer Breakout-Platine mit allen für den Betrieb benötigten Komponenten und zwei Arten von Stiften geliefert. Sie sind abgelötet.
• Einfache Bedienung, kleine Größe, niedrige Kosten; montiert auf einer Breakout-Platine mit zwei Arten von Stiften; 10k Pull-Up-Widerstände für die I2C-Schnittstelle mit optionalen Lötbrücken; einfach zu integrieren. Messauflösung von 0,02 Grad.
• Beschreibung Werkseitig kalibriert im breiten Temperaturbereich: -40 ... + 125 °C für Sensortemperatur und -70 ... + 380 °C für Objekttemperatur. Hohe Genauigkeit von 0,5 °C über breite Temperaturerange (0 ... + 50 °C für sowohl Ta als auch To) Hohe (medizinische) Genauigkeitskalibrierung.
• Hochleistungs-SMBus-kompatible digitale Schnittstelle; anpassbarer PWM-Ausgang für kontinuierliches Ablesen; einfache Anpassung für 8. 16V Anwendungen Schlaf-Modus für reduzierten Stromverbrauch; verschiedene Verpackungsoptionen für Anwendungen und Messungen; Automobilqualität

32,94 €

Bei Amazon kaufen

Bestseller Nr. 2

Hailege MLX90614 Non-Contact Infrared Temperature Sensor Module IIC I2C 3-5V for Arduino 51 MCU

• Both the IR sensitive thermopile detector chip and the signal conditioning ASIC are integrated in the same TO-39 can.
• MLX90614 Non-Contact Infrared Temperature Sensor Module
• Integrated into the MLX90614 are a low noise amplifier, 17-bit ADC and powerful DSP unit thus achieving high accuracy and resolution of the thermometer.
• The user can configure the digital output to be pulse width modulation (PWM). As a standard, the 10-bit PWM is configured to continuously transmit the measured temperature in range of -20 to 120°C, with an output resolution of 0.14°C.

16,49 €

Bei Amazon kaufen

Bestseller Nr. 3

Jadeshay Temperatursensor MLX90614-DCI Infrarot-Temperatursensormodul Langstrecken-DIY-PCB-Elektronikkomponenten

• 【Messbereich】 Das MLX90614-DCI-Infrarot-Temperatursensormodul kann die Temperaturüberwachung von einem Abstand von 50 Zentimetern bis 1 Meter durchführen.
• 【VOLLSTÄNDIG AUSGESTELLT】 Der Temperatursensor ist mit einer Kabelbrett mit allen für den Betrieb erforderlichen Komponenten und zwei Arten von Stiften ausgestattet. Sie sind unermüdlich.
• 【Arbeitsprinzip】 kontaktlos, basierend auf den vom Ziel emittierten Infrarotwellen misst das Temperatursensor -Modul die Oberflächentemperatur des Objekts, ohne es zu berühren.
• 【Praktische Anwendung】 geringe Größe: 1,7 * 1,2 * 1 cm/0,7 * 0,5 * 0,4 Zoll. Das Sensormodul eignet sich für nichtkontakte Infrarottemperatursensoren oder einen Mikrocomputer.
• 【Präzisionskomponenten】 Die Ausgangsdaten sind linear proportional zur Temperatur des Objekts, und das MLX90614-DCI-Infrarot-Temperatursensor-Modul hat eine hohe Genauigkeit und Auflösung.

37,49 €

Bei Amazon kaufen

So schließt du den Sensor an

Diesen Sensor schließt du im Handumdrehen per I²C an. Das heißt, du benötigst neben Plus und Minus nur zwei weitere Anschlüsse für SDA (Data) and SCL (Clock). Die entsprechenden Pins an deinem Arduino sind A4 für SDA und A5 für SCL. Wenn du mehr über I²C erfahren möchtest, hilft dir Wikipedia weiter.

Verbinde also die Pins VIN und GND am Sensor mit dem 5V und GND am Arduino. Anschließend verbindest du SDA mit A4 und SCL mit dem Pin A5. Das war es auch schon.

Der Code für den GY-906

Für deine ersten Experimente reicht es, wenn du die Temperatur im Seriellen Monitor ausgibst. Wenn dir das zu wenig ist, erfährst du hier, wie du ein TFT-Display am Arduino anschließt.

Bevor du jedoch loslegen kannst, benötigst du noch eine Bibliothek für den GY-906. Wähle hierfür im Menü Werkzeuge ->Bibliotheken verwalten.

Suche dort anschließend nach Adafruit_MLX90614 und installiere die Bibliothek in der aktuellsten Version:

Jetzt kann es losgehen: Binde zunächst zwei Bibliotheken in deinen Sketch ein. Die, die du gerade geladen hast, um die Daten des Sensors zu lesen und eine weitere (Wire.h) für die Kommunikation per I²C.

#include <Adafruit_MLX90614.h>
#include <Wire.h>

Anschließend erstellst du eine Instanz der Bibliothek mit dem Namen mlx:

Adafruit_MLX90614 mlx = Adafruit_MLX90614();

In der Funktion void setup() startest du nur den Seriellen Monitor und die gerade erstellt Instanz der Bibliothek. Mehr brauchst du nicht.

void setup() {
  Serial.begin(9600); 
  mlx.begin();  
}

Nun zum Kern deines Sketches, zur Funktion void loop(). Hier lässt du deinen GY-906 alle 500 Millisekunden eine Messung der Umgebungstemperatur und der Temperatur eines beliebigen Objekts vor dem Sensor ausführen. Die Ergebnisse gibst du dann im Seriellen Monitor aus:

void loop() {
  Serial.print("Umgebung = "); Serial.print(mlx.readAmbientTempC()); 
  Serial.print("*C\tObjekt = "); Serial.print(mlx.readObjectTempC()); Serial.println("*C");

  Serial.println();
  delay(500);
}

Praktischerweise besitzt die Bibliothek Adafruit_MLX90614 hierfür die zwei Funktionen readAmbientTempC() und readObjectTempC(), die du aufrufen und ohne Umwege direkt im Seriellen Monitor ausgeben kannst. Erstere gibt die Umgebungstemperatur aus, letztere die des Objekts direkt vor dem Sensor.

Im Gegensatz zum beliebten Temperatursensor TMP36 musst du hier also keine Umrechnungen von Spannung in Grad Celsius machen.

Hier der gesamte Skecht zum Rauskopieren:

#include <Adafruit_MLX90614.h>
#include <Wire.h>

Adafruit_MLX90614 mlx = Adafruit_MLX90614();

void setup() {
  Serial.begin(9600); 
  mlx.begin();  
}

void loop() {
  Serial.print("Umgebung = "); Serial.print(mlx.readAmbientTempC()); 
  Serial.print("*C\tObjekt = "); Serial.print(mlx.readObjectTempC()); Serial.println("*C");

  Serial.println();
  delay(500);
}

Wie geht es weiter?

Vom Seriellen Monitor bis zum Display ist es natürlich kein weiter Weg – du kannst dir damit und mit einer Batterie leicht ein mobiles Infrarot-Thermometer bauen.

Wenn du es lieber old school hast, ist vielleicht dieses Analog-Thermometer das richtige für dich. In diesem Projekt wird zwar ein TMP36 zum Messen verwendet, aber du kannst ihn nach diesem Tutorial ganz leicht durch den GY-906 ersetzen.

Die wichtigsten Daten

Was du wissen musst:

• Betriebsspannung: 2,7V – 5V
• Betriebstemperatur: -55°C – 150°C
• Messbereich: -40°C – 125°C
• Genauigkeit: ±2°C
• Anschluss: Analog

Hier findest du das vollständige Datenblatt des TMP36.

So schließt du den TMP36 an

Es ist ganz einfach, diesen Temperatursensor anzuschließen. Der TMP36 besitzt 3 Pins: Plus (V+), Analog-Ausgang und Erde (GND).

Aber Vorsicht: Achte unbedingt darauf, dass du Plus und Minus an die richtigen Pins anlegst. Wenn der Sensor mit der Wölbung nach unten vor dir liegt, kommt an den linken Pin Plus und an den rechten Minus. Der mittlere Pin ist der Analog-Ausgang. Wenn du den Strom falsch anlegst, geht dein Sensor möglicherweise kaputt!

Tutorial

Du willst in dein nächstes Projekt einen Temperatursensor integrieren? Erfahre alles über den richtigen Anschluss des TMP36 und lerne eine Funktion zum Auslesen der Temperatur, die du in all deinen Projekten einsetzen kannst.

Projekt: Analog-Thermometer

Wie wäre es mit einem Thermometer, das dir die Raum- oder Außentemperatur analog auf einer Schablone anzeigt? Alles, was du hierfür brauchst, sind ein Temperatursensor, ein Servo-Motor, Arduino, Breadboard, Kabel und Material für die Schablone.

Der Temperatursensor TMP36

Der Messbereich des TMP36 liegt zwischen -40°C und +150°C – wir hoffen mal stark, dass das für die Orte, an denen du dich aufhältst, ausreichend ist. Seine Genauigkeit ist mit ±2°C leider nicht allzu berauschend, möglicherweise reicht dir das ja aber schon für dein Projekt.

Einfacher Anschluss am Arduino

Den Temperatursensor TMP36 in Betrieb zu nehmen ist ziemlich einfach. Hierfür verbindest du den mittleren der drei Pins mit einem Analogeingang an deinem Arduino Board. Etwas aufpassen musst du allerdings beim Strom: Achte darauf, 5V und GND an die richtigen Pins anzuschließen. Die Wölbung des Sensors dient dir hierbei als Orientierung:

Überprüfe noch einmal die Anschlüsse. Wenn du den Sensor falsch herum anschließt, wird er heiß und kann durchbrennen.

Der Sketch für deinen TMP36

Du benötigst nur einige Zeilen einfachen Code, um deine Messungen zu starten:

//Anschlusspin des TMP36 am Arduino
const int analogIn = A0;

//Variablen für die Messwerte
int rawValue= 0;
double voltage = 0;
double tempC = 0;

void setup(){
  //Start des Seriellen Monitors mit der Baudrate 9600
  Serial.begin(9600);
}

void loop(){
  
  rawValue = analogRead(analogIn); //Einlesen des Messwerts
  voltage = (rawValue / 1023.0) * 5000; // Umrechnen in Millivolt
  tempC = (voltage-500) * 0.1; // Umrechnen in Grad Celsius

  Serial.print("Rohwert = " );  // den rohen Sensorwert anzeigen                   
  Serial.print(rawValue);      
  Serial.print("\t Millivolt = "); // die Spannung anzeigen     
  Serial.print(voltage,0); //
  Serial.print("\t Temperatur in C = "); //die Temperatur anzeigen
  Serial.println(tempC, 1);
  
  //Delay bis zur nächsten Messung
  delay(500);  
}

Im obigen Sketch ist der TMP36 mit dem Analogeingang 0 verbunden, den du im Loop mit analogRead(0) ausliest. Dazu brauchst du noch drei Variablen:

• Für den Rohwert, den der Sensor ausgibt
• Für die Spannung, die du hieraus berechnest
• Für die Temperatur, die du wiederum aus der Spannung berechnest

Der Sensor misst die Temperatur nicht direkt, sondern gibt je nach Umgebungswärme einen Wert zwischen 0 und 1023 aus. Da er an 5 Volt angeschlossen ist, entspricht dieser Bereich einer Spannweite von 0 Volt bis 5 Volt. Hier kommt die folgende Formel ins Spiel, mit der du zunächst die Spannung berechnest:

Voltage = (RawValue / 1023.0) * 5000;

Aber du willst ja vermutlich nicht die Spannung, sondern die Temperatur haben. Deshalb rechnest du die Volt wiederum in Grad Celsius um:

tempC = (Voltage-500) * 0.1;

Geschafft! Wenn du den Seriellen Monitor öffnest, siehst du alle 500 Millisekunden einen aktuellen Messwert.

Du kannst dieses Projekt einfach erweitern, wenn du einen Servo-Motor zur Verfügung hast und ein Analog-Thermometer bauen.

Die Umgebungstemperatur ist dir zu langweilig? Lerne, wie du mit dem Sensor GY-906 die Temperatur eines Objekts per Infrarot misst. Oder verwende den Sensor BMP180, wenn du neben der Temperatur auch den Luftdruck messen möchtest.

Für dieses Projekt benötigst du:

• Arduino Board (wir verwenden hier einen Uno)
• 1 oder 2 Steckplatine(n) – für 2 getrennte Stromkreise
• 1 Temperatursensor (z.B. einen TMP36)
• 1 Servomotor
• Temperatur-Schablone (z.B. diese hier von instructables.com)
• 9V Batterie mit Anschluss-Clip
• Ein paar Kabel

So sieht das fertige Projekt aus:

Intro

Eine Besonderheit dieses Projekts ist, dass du zwei voneinander getrennte Stromkreise verwendest – und der Strom hierfür von einer 9V Batterie kommt. Der Grund dafür ist, dass ein Servomotor recht viel Strom verbraucht, wenn er mit seiner Bewegung anfängt. Das wiederum lässt die Spannung im Stromkreis abfallen, wodurch der Temperatursensor falsche Ergebnisse liefert. Du benötigst also für dieses Arduino-Projekt eine Steckplatine, auf der du zwei getrennte Stromkreise bauen kannst – oder zwei separate Platinen.

Den Strom selbst solltest du nicht über die USB-Buchse anlegen, sondern entweder über ein Netzteil oder mit einer 9V Batterie einspeisen. Die 5 Volt, die per USB kommen, reichen für dieses Projekt nicht aus.

Im Programm-Code wirst du den seriellen Monitor der Arduino IDE verwenden. Hierfür musst du das USB-Kabel ebenfalls anschließen – keine Angst, der Strom kommt ausschließlich von der Batterie und nicht von beiden Quellen gleichzeitig.

Der Aufbau

Einen möglichen Aufbau siehst du hier:

Du erkennst oben die Batterie, die an die Anschlüsse Vin und GND angeschlossen wird. Den Temperatur-Sensor versorgst du mit 3,3 Volt. Den Servomotor mit 5 Volt.

Wenn du einen TMP36 für die Temperaturmessung verwendest, verbinde den mittleren Pin mit dem Analog-Eingang A0 auf deinem Arduino-Board. Hierüber liest du dann die Temperatur ab.

Erfahre alles Wichtige über den Temperatursensor TMP36: Messbereich, Genauigkeit und wie du ihn richtig anschließt.

TMP36 kennenlernen

Die Steuerung des Servomotors (oben das gelbe Kabel) verbindest du mit dem Digital-Ausgang 9.

Das war es im Prinzip auch schon. Bevor du den Strom anlegst, vergewissere dich noch einmal, ob alles richtig verkabelt und eingesteckt ist.

Die Schablone für die Anzeige

In diesem Projekt zeigt der Servomotor Temperaturen im Bereich von +10°C bis 30°C an – und zwar in einem Halbkreis, also 180°. Eine entsprechende Anzeige kannst du dir selbst gestalten oder einfach diese hier von instuctables.com herunterladen.

Druck sie dir aus, klebe sie auf einen stabilen Karton und schneide den Kreis aus. In der Mitte findest du den Ausschnitt, in den der Motor eingepasst wird.

Das Programm

Hinweis: Den vollständigen Code findest du weiter unten. Zunächst ein paar Zeilen, die noch vor dem Setup stehen.

#include <Servo.h> 

Servo myServo;

const int temperaturePin = 0;

int angle;

Für die Steuerung des Servomotors verwendest Du die entsprechende Bibliothek, die Dir eine Menge Arbeit abnimmt. Diese Bibliothek sollte bereits bei Dir installiert sein.

Anschließend erstellt du ein Servo-Objekt, legst den Eingangs-Pin für den Termperatur-Sensor fest und erstellst eine Variable für den Winkel des Servomotors. Dieser Winkel entspricht später der Temperatur, auf die der Zeiger des Motors ausgerichtet wird.

Das Setup-Funktion

void setup() {
  myServo.attach(9);
  Serial.begin(9600);
  
  myServo.write(0); //
  delay(2000); //
}

Im Setup legst du den Pin 9 fest, um den Servo zu steuern. Anschließend richtest du die Verbindung zum seriellen Monitor in deiner IDE ein. Den Motor fährst du dann erst mal auf den Winkel 0° und gibst ihm hierfür 2000 Millisekunden Zeit.

Übrigens: Alles Wissenswerte zu Servos erfährst du in diesem Tutorial.

Der Loop und eine Extra-Funktion

Hier spielt die eigentliche Musik: Du liest den Temperatursensor aus, rechnest ein paar Werte um und bewegst den Servomotor zur richtigen Gradzahl.

Zunächst eine Funktion, die Du benötigst, um den Ausgabewert des Temperatursensors in Volt umzurechnen:

float getVoltage(int pin)
{
  return (analogRead(pin) * 0.004882814);
}

Diese Funktion arbeitet mit einem Argument, “int pin”. Hierfür wirst du im Folgenden den Pin des Sensors nehmen. Über “return” liest du mit der Funktion “analogRead” den entsprechenden Wert ein und rechnest ihn in Volt um.

Jetzt zum Loop:

void loop() {
 
  float voltage, degreesC;

  voltage = getVoltage(temperaturePin);
  
  degreesC = (voltage - 0.5) * 100.0;

Serial.print("  voltage: ");
  Serial.print(voltage);
  Serial.print("  deg C: ");
  Serial.println(degreesC);
 
  angle = map(degreesC, 10, 30, 0, 180);

  if(degreesC < 10){
    delay(50);
    }else if(degreesC > 30){
      delay(50);
      }else{
         myServo.write(angle);
        }
        
 delay(1000);
}

Zunächst erstellst du zwei Variablen für Volt und Grad Celsius. Die Spannung berechnest du, in dem du die oben genannte Funktion mit dem Argument “temperaturePin” aufrufst – die Konstante, die du ganz am Anfang als Ausgang A0 deklariert hast. Die °C berechnest du dann wiederum aus der gerade berechneten Spannung.

Über “Serial.print” gibst du die errechneten Werte nun an den seriellen Monitor weiter, um dort zu überprüfen, ob der Sensor auch seine Arbeit macht und die Daten plausibel sind.

Eine wichtige Funktion ist die folgende: Hier “mappst” du die Temperaturwerte auf die möglichen Winkel des Servomotors:

  angle = map(degreesC, 10, 30, 0, 180);

Die Funktion “map” benötigt zunächst einen Wert, den sie “mappen” soll – in unserem Fall “degreesC”, also die Temperatur. Der zulässige Bereich liegt zwischen 10 und 30 °C – das sind also die ersten beiden Zahlen. Der Servomotor soll sich auf unserer Skala in einem Bereich von 180° bewegen – bei 0° liegen die 10°C und bei 180° die 30°C. Trage also noch die beiden Zahlen 0 und 180 ein. Fertig.

Nun zu dem Teil, der den Servomotor dazu bringt, die Temperatur auf deiner Skala anzuzeigen:

if(degreesC < 10){
    delay(50);
    }else if(degreesC > 30){
      delay(50);
      }else{
         myServo.write(angle);
        }

Da deine Skala bei +10°C anfängt und bei +30°C aufhört, musst du dem Motor mitteilen, dass er nichts tun soll, wenn die Temperatur darunter oder darüber liegt. Sollte die Temperatur aber in diesem Bereich liegen, dann gibst du den Befehl, dass er sich an den Winkelgrad bewegen soll, den du über die “map”-Funktion oben errechnet hast.

Ganz zuletzt gibst dem Motor per “delay” 1000ms Zeit, seinen Befehl auszuführen. Das war’s! Lade den Sketch auf deinen Arduino, setze den Servomotor in die Anzeige und probiere es gleich aus. Ein letzter Hinweis: Zu Beginn des Programms fährt dein Motor auf 10°C, also ganz nach links unten und wartet dort 2 Sekunden. Überprüfe, ob auch der Zeiger auch tatsächlich auf die 10°C zeigt. Falls nicht, passe ihn einfach an.

Hier der gesamte Sketch:

#include <Servo.h>

Servo myServo;

const int temperaturePin = 0;

int angle;

void setup() {
  myServo.attach(9);
  Serial.begin(9600);
  
  myServo.write(0);
  delay(2000);

void loop() {
 
  float voltage, degreesC;

  voltage = getVoltage(temperaturePin);
  
  degreesC = (voltage - 0.5) * 100.0;

  Serial.print("  voltage: ");
  Serial.print(voltage);
  Serial.print("  deg C: ");
  Serial.println(degreesC);
 
  angle = map(degreesC, 10, 30, 0, 180);

  if(degreesC < 10){
    delay(50);
    }else if(degreesC > 30){
      delay(50);
      }else{
         myServo.write(angle);
        }
        
 delay(1000);

float getVoltage(int pin)
{
  return (analogRead(pin) * 0.004882814);
}

Wie geht es weiter?

Mit dem TMP36 kannst du “nur” die Temperatur der Umgebung messen. Möchtest du jedoch aus sicherer Entfernung die Temperatur eines Objekts messen, dann benötigst du einen Sensor, der per Infrarot misst – z.B. den GY-906. Lerne hier, wie du den Temperatursensor GY-906 anschließt und verwendest.

Wenn du überhaupt keinen Temperatursensor verwenden willst, ist vielleicht eine Abfrage bei einem Wetterdienst das Richtige: Hier erfährst du, wie du aktuelle Wetterdaten mit einem ESP8266 aus dem Internet abrufst.