Benötigte Bauteile

Diese Bauteile brauchst du für dieses Projekt:

• Mikrocontroller: Zum Beispiel ein Arduino Nano oder Arduino UNO
• Durchflussmesser: Ein Turbinen-Durchflussmesser (z.B. YF-S201C*)
• Display: Ein 0,91“ OLED-Display (SSD1306-Chip)
• Breadboard und Jumper-Kabel
• Messbecher: Für die Kalibrierung, idealerweise 500 ml oder 1 Liter

Aufbau des Wasserzählers

Der Aufbau ist kompakt und nutzt die I²C-Pins des OLED-Displays und deines Arduinos, um die Verkabelung zu vereinfachen. Der Durchflussmesser benötigt (neben 5V und Erde) nur eine Verbindung. Auf der folgenden Skizze verwende ich einen Arduino Nano, du kannst aber auch einen UNO oder jeden anderen Arduino oder ESP32/8266 verwenden.

Hier noch einmal die Verbindungen im Detail:

Verbindung des Durchflussmessers:

• VCC: An den 5V-Pin des Arduinos
• GND: An einen GND-Pin des Arduinos
• Signal: An den digitalen Pin D2 des Arduinos. Dieser Pin ist für Interrupts geeignet, was eine präzise Messung der Impulse ermöglicht.

Verbindung des OLED-Displays:

• VCC: An den 3.3V-Pin des Arduinos
• GND:An einen GND-Pin des Arduinos
• SDA (Daten): An den SDA-Pin des Arduino. Beim Nano und UNO ist das Pin A4.
• SCL (Takt): An den SCL-Pin des Arduinos. Beim Nano und UNO ist das Pin A5.

Die benötigten Bibliotheken

Für dieses Projekt benötigst du zwei Bibliotheken für das OLED-Display. Suche hierfür im Bibliotheksverwalter nach Adafruit SSD1306. Bei der Installation wirst du gefragt, ob du auch die Bibliothek Adafruit GFX Library installieren möchtest – bestätige das bitte mit Ja.

Für den Durchflussmesser benötigst du in der Regel keine Bibliothek – seine Impulse verarbeitest du selbst im Sketch.

Der Sketch für den Wasserzähler

Der folgende Code liest die Impulse des Durchflussmessers und zeigt die gemessene Wassermenge auf dem OLED-Display an. Im Folgenden gehe ich von einer Wassermenge von 2,25ml pro Impuls aus. Ich empfehle dir jedoch, deinen Sensor selbst zu kalibrieren.

//Wasserverbrauch messen mit einem Durchflussmesser
//polluxlabs.net

#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

// Deklariere die Display-Parameter für ein 0,91'' Display
#define SCREEN_WIDTH 128 // OLED-Breite in Pixel
#define SCREEN_HEIGHT 32 // OLED-Höhe in Pixel

// Deklariere ein OLED-Display Objekt
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

// Pin für den Durchflussmesser
const int sensorPin = 2;

// Variable für die Impulszählung. `volatile` ist wichtig für Interrupts.
volatile long impulse_count = 0;

// Die kalibrierte Konstante für deinen Sensor (2.25 ml/impuls)
const float ML_PER_IMPULSE = 2.25;

void setup() {
  // Startet die serielle Kommunikation zur Fehlersuche
  Serial.begin(9600);

  // Initialisiert das OLED-Display
  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
    Serial.println(F("SSD1306-Zuweisung fehlgeschlagen"));
    for (;;); // Endlosschleife, wenn das Display nicht gefunden wird
  }
  display.clearDisplay();
  display.setTextSize(1);
  display.setTextColor(SSD1306_WHITE);
  
  // Initialisiert den Sensor-Pin als Eingang
  pinMode(sensorPin, INPUT);
  
  // Richtet einen Interrupt ein, der die Funktion count_impulses bei jedem Impuls aufruft
  attachInterrupt(digitalPinToInterrupt(sensorPin), count_impulses, RISING);
}

void loop() {
  // Eine Kopie des Zählers erstellen, um race conditions zu vermeiden
  long current_impulses = impulse_count; 

  // Berechnung des Wasserverbrauchs
  float water_volume_ml = current_impulses * ML_PER_IMPULSE;

  // Löscht den Display-Inhalt
  display.clearDisplay();

  // Zeigt den Titel an
  display.setTextSize(1);
  display.setCursor(0, 0);
  display.println("Wasserverbrauch:");

  // Zeigt den Wert an
  display.setTextSize(2);
  display.setCursor(0, 16);
  display.print(water_volume_ml);
  display.print(" ml");

  // Aktualisiert das Display
  display.display();

  // Kleine Pause, um das Display nicht zu überfordern
  delay(100);
}

// Interrupt-Service-Routine (ISR)
// Diese Funktion wird automatisch bei jedem Impuls aufgerufen
void count_impulses() {
  impulse_count++;
}

Kalibrierung des Sensors

Der Wert in der Zeile const float ML_PER_IMPULSE = 2.25; ist entscheidend für die Genauigkeit deiner Messung. Je nachdem, welches Modell du verwendest oder auch, wenn dein Sensor nicht präzise misst, kann dieser Wert abweichen. Um die richtige Wassermenge pro Impuls zu ermitteln, gehe wie folgt vor:

1. Vorbereitung: Halte einen Messbecher mit bekanntem Volumen (z. B. 500 ml) bereit. Lade den obenstehenden Sketch auf deinen Arduino.
2. Nullstellung: Starte den Sketch neu, indem du den Reset-Knopf auf deinem Arduino drückst. Das Display sollte 0.00 ml anzeigen.
3. Messung: Lasse genau 500 ml Wasser konstant schnell durch den Sensor in den Messbecher laufen.
4. Wert ablesen: Warte, bis die Messung auf dem Display nicht mehr steigt. Notiere den angezeigten Wert (z.B. 650 ml).
5. Neuer Menge: Berechne die korrekte Menge Wasser pro Impuls: 2,25ml x (500ml / 650ml) = 1,73ml/Impuls
6. Code anpassen: Ändere die Zeile im Sketch zu const float ML_PER_IMPULSE = 1.73;.
7. Testen: Lade den Sketch erneut hoch und wiederhole den Test mit 500 ml Wasser. Der angezeigte Wert sollte nun sehr nah an 500 ml liegen.

Um das Ergebnis genauer zu machen, kannst du auch mehrere Messungen durchführen und einen Mittelwert finden. Es kann durchaus sein, dass z.B. die Fließgeschwindigkeit des Wassers Auswirkungen auf die Zahl der gemessenen Impulse hat.

So funktioniert der Sketch

Lass uns schnell einen Blick auf die wichtigsten Teile des Sketchs werfen:

1. Die Setup-Funktion

Der Befehl attachInterrupt() ist hier das Herzstück. Anstatt im Loop ständig zu prüfen, ob ein Impuls vom Sensor kommt, richtest du hier einen sogenannten Hardware-Interrupt ein. Das bedeutet, dass der Arduino-Chip sofort seine aktuelle Aufgabe unterbricht und direkt zu der kleinen Funktion count_impulses() springt, sobald er ein Signal am Pin D2 empfängt. Das macht die Messung extrem reaktionsschnell und präzise.

2. Der Loop: Die Hauptlogik

Dieser Teil wird immer wieder wiederholt.

• Impulse auslesen: long current_impulses = impulse_count; kopiert den Wert des Volatile-Zählers. Das ist eine Schutzmaßnahme. Da der Zähler impulse_count jederzeit von der Interrupt-Funktion geändert werden könnte, sichern wir den Wert, bevor wir damit rechnen, um Fehler zu vermeiden.
• Berechnung: float water_volume_ml = current_impulses * ML_PER_IMPULSE; ist der Kern des Projekts. Hier wird die Anzahl der Impulse mit dem Kalibrierungsfaktor multipliziert, um das tatsächliche Wasservolumen in Millilitern zu erhalten.
• Display-Update: Die folgenden Befehle, wie display.clearDisplay(), display.setCursor() und display.print(), kümmern sich darum, die berechneten Daten auf dem OLED-Display darzustellen. Der Befehl display.display() sendet am Ende die gesammelten Daten an das Display, um die Anzeige zu aktualisieren.
• Pause: delay(100); sorgt für eine kurze Pause. Das ist wichtig, um zu verhindern, dass das Display zu schnell aktualisiert wird und um die CPU-Ressourcen des Arduinos zu schonen.

3. Die Funktion count_impulses(): Der Interrupt

Dies ist die kleine, aber sehr wichtige Funktion, die durch den Interrupt-Befehl ausgelöst wird. Sie wird nicht vom Loop aufgerufen, sondern springt automatisch in Aktion, sobald der Sensor einen Impuls sendet. Ihre einzige Aufgabe ist es, den Zähler impulse_count um eins zu erhöhen.

Wie geht es weiter?

Du kannst du nun den Wasserverbrauch messen und auf einem Display anzeigen. Eine interessante Weiterentwicklung könnte z.B. ein LED-Ring sein, der anzeigt, wie sehr du dich beim Händewaschen einem festgelegten Maximalverbrauch näherst. Oder du misst in deinem Garten den Wasserverbrauch und speicherst die Daten z.B. bei Adafruit IO in der Cloud.

Außerdem verwende ich das Python-Modul Flask, um den Webserver zu programmieren. Damit kannst du sowohl einfache Webseiten erstellen als auch komplexere Applikationen, mit denen du, wie in unserem Fall, Hardware steuern und Messdaten anzeigen kannst.

Eine erste Webseite mit Flask

Bevor du dich einem Webserver widmest, lass uns mit den Grundlagen anfangen. Falls du Flask noch nicht auf deinem Raspberry Pi installiert hast, hole das im Terminal nach:

pip install Flask

Öffne nun einen Editor (z.B. Visudal Studio Code) und erstelle ein Python-Script mit folgendem Inhalt:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Hallo, Raspberry Pi!"

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Speichere es anschließend ab unter einem Namen deiner Wahl und starte es. Solltest du im Terminal daraufhin die Fehlermeldung „Port 5000 is in use by another program.“ erhalten, wähle hinter port= eine andere Zahl, zum Beispiel 5010. Sobald das Script ordnungsgemäß auf einem freien Port läuft, siehst du im Terminal die IP-Adresse deines Raspberry Pis. Zum Beispiel: „Running on http://127.0.0.1:5010“

Wenn du die IP-Adresse (127.0.0.1:5010) kopierst und sie im Browser öffnest, solltest du den kleinen Gruß sehen, der im Code hinterlegt ist. Neben dieser IP-Adresse erhältst du auch eine Alternative – hier 192.168.0.143:5000. Falls sich die erste Adresse nicht öffnen lässt, probiere es einmal mit dieser.

So funktioniert der code

Lass uns nun einen genaueren Blick auf das Python-Script werfen, um zu verstehen, was dort passiert. Zunächst importierst du die Klasse Flask (Mehr über Flask) aus dem gleichnamigen Modul:

from flask import Flask

Anschließend erstellst du eine Instanz dieser Klasse namens app. Mit (__name__) dahinter teilst du Python mit, dass alle etwaigen zusätzlichen Dateien im selben Ordner liegen, wie das Script selbst. Dazu später mehr.

Die folgenden drei Zeilen

@app.route('/')
def home():
    return "Hallo, Raspberry Pi!"

stellen nun die Webseite bereit – in unserem Fall ist das nur eine einzelne Startseite. Mit dem sogenannten Dekorator @app.route(‚/‘) bestimmst du, was passiert, wenn diese Startseite aufgerufen wird – also einfach nur die IP-Adresse. Hierfür dient der Schrägstrich /.

Wenn das nun also passiert (so wie du es vorhin im Browser getan hast), dann wird die darauf folgende Funktion def home(): aufgerufen. Darin befindet sich einfach nur die Anweisung, den String Hallo, Raspberry Pi! wiederzugeben – den du dann im Browser siehst. Später folgen nun noch weitere Dekoratoren und Funktionen, die deinem Raspberry Pi Webserver mehr Leben einhauchen werden.

Zuletzt die beiden Zeilen

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Dieser Code wird ausgeführt, wenn wir dieses Skript direkt ausführen (anstatt es als Modul in ein anderes Script zu importieren). In dem Fall startet der Webserver von Flask, der auf Anfragen von jedem Gerät im gleichen WLAN-Netzwerk am Port 5000 reagiert.

Sensordaten empfangen und anzeigen

So ein kleiner Gruß ist ja nett, aber eine wirklich praktische Anwendung ist besser. Wie wäre es, wenn dein Raspberry Pi Webserver regelmäßig Daten von einem ESP8266 empfängt und diese auf einer Webseite anzeigt?

Im Folgenden lernst du, wie du mit dem Sensor BMP180 an einem ESP8266 die Temperatur und Luftfeuchtigkeit misst und die Messdaten an den Raspberry Pi sendest. Du selbst kannst die aktuellen Daten dann auf einer Webseite einsehen.

Hierfür benötigst du zweimal Code – einmal für den Raspberry Pi Webserver und einen Sketch für den ESP8266.

Das Python-Script für den Server

Zunächst kümmern wir uns um den Server. Damit dein Raspberry Pi die Daten in Empfang nehmen und auf einer Webseite anzeigen kann, ist nicht viel Code nötig. Du benötigst im Prinzip eine Funktion, die die gesendeten Messdaten entgegennimmt und eine weitere, um diese auf einer Webseite anzuzeigen. Hier das vollständige Script:

//Raspberry Pi Webserver
//polluxlabs.net

from flask import Flask, request, render_template_string
from datetime import datetime

app = Flask(__name__)

temperature = 0
pressure = 0
last_update = "Noch keine Daten empfangen"

@app.route('/update-sensor', methods=['POST'])
def update_sensor():
    global temperature, pressure, last_update
    temperature = request.form.get('temp')
    pressure = request.form.get('pressure')
    last_update = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    return "Daten aktualisiert", 200

@app.route('/')
def index():
    html = """
    <!DOCTYPE html>
    <html lang="de">
    <head>
        <meta charset="UTF-8">
        <title>BMP180 Sensordaten</title>
    </head>
    <body>
        <h1>BMP180 Sensordaten</h1>
        <p>Temperatur: {{ temperature }}°C</p>
        <p>Luftdruck: {{ pressure }} hPa</p>
        <p>Letzte Aktualisierung: {{ last_update }}</p>
    </body>
    </html>
    """
    return render_template_string(html, temperature=temperature, pressure=pressure, last_update=last_update)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

Kopiere den obigen Code uns speichere ihn in einer Date, die du z.B. webserver.py nennst.

So funktioniert das Script

Ein kurzer Blick auf die Funktionsweise des Raspberry Pi Webservers:

Daten empfangen

Der Teil des Scripts, der neue Daten empfängt, sieht so aus:

   @app.route('/update-sensor', methods=['POST'])
   def update_sensor():
       global temperature, pressure, last_update
       temperature = request.form.get('temp')
       pressure = request.form.get('pressure')
       last_update = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
       return "Daten aktualisiert", 200

• Dieser Code wartet auf neue Messwerte vom Sensor.
• Wenn neue Daten ankommen, werden sie in den Variablen temperature und pressure gespeichert.
• last_update speichert den Zeitpunkt, an dem die Daten ankamen.

Daten anzeigen

Die Webseite, die die Daten anzeigt, wird hier erstellt:

   @app.route('/')
   def index():
       html = """
       <!DOCTYPE html>
       <html lang="de">
       <head>
           <meta charset="UTF-8">
           <title>BMP180 Sensordaten</title>
       </head>
       <body>
           <h1>BMP180 Sensordaten</h1>
           <p>Temperatur: {{ temperature }}°C</p>
           <p>Luftdruck: {{ pressure }} hPa</p>
           <p>Letzte Aktualisierung: {{ last_update }}</p>
       </body>
       </html>
       """
       return render_template_string(html, temperature=temperature, pressure=pressure, last_update=last_update)

• Dieser Code erstellt eine einfache Webseite mithilfe von HTML.
• Die Seite zeigt die aktuelle Temperatur, den Luftdruck und die Zeit der letzten Aktualisierung an.

Webseite einrichten

Der Server wird hier gestartet:

   if __name__ == '__main__':
       app.run(host='0.0.0.0', port=5000, debug=True)

• Diese Zeilen starten den Webserver.
• host='0.0.0.0' bedeutet, dass der Server von anderen Geräten im Netzwerk erreichbar ist.
• port=5000 legt fest, dass die Webseite über Port 5000 erreichbar ist.

So arbeiten alle Teile zusammen: Der Sensor sendet Daten, das Script empfängt und speichert sie, und die Webseite zeigt sie an.

Starte den Raspberry Pi WebServer

Öffne nun auf deinem Raspberry Pi das Terminal und öffne dein Script, wobei du natürlich den Script-Namen verwendest, den du vergeben hast:

python3 webserver.py 

Anschluss des BMP180 und der Sketch für den ESP8266

Nun zum Sender, dem ESP8266, der mit dem Sensor BMP180 die aktuelle Temperatur und Luftfeuchtigkeit misst und an den Raspberry Pi weiterleitet. Bevor wir zum Code kommen, hier eine Skizze, wie du den Sensor am ESP8266 anschließt:

Wenn du den Sensor angeschlossen hast, kann es direkt mit dem Sketch weitergehen. Nur ein Hinweis vorab: Solltest du noch nie ein Projekt mit dem BMP180 gebaut haben, fehlt dir vermutlich noch die zugehörige Bibliothek. Öffne in diesem Fall den Bibliotheksmanager in der Arduino IDE und installiere die Bibliothek Adafruit BMP085 Library. Falls du gefragt wirst, ob du weitere benötigte Bibliotheken installieren möchtest, antworte bitte mit Ja.

Doch nun zum Sketch:

//Sending data to the Raspberry Pi Webserver
//polluxlabs.net

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

const char* ssid = "DEIN NETZWERK";
const char* password = "DEIN PASSWORT";
const char* serverName = "http://SERVER-IP/update-sensor";

Adafruit_BMP085 bmp;

void setup() {
  Serial.begin(115200);
  
  WiFi.begin(ssid, password);
  Serial.println("Verbinde mit WLAN");
  while(WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Verbunden mit IP-Adresse: ");
  Serial.println(WiFi.localIP());

  if (!bmp.begin()) {
    Serial.println("BMP180 nicht gefunden, überprüfen Sie die Verkabelung!");
    while (1) {}
  }
}

void loop() {
  if(WiFi.status() == WL_CONNECTED) {
    WiFiClient client;
    HTTPClient http;

    float temperature = bmp.readTemperature();
    float pressure = bmp.readPressure() / 100.0F;

    // Daten für den POST-Request vorbereiten
    String httpRequestData = "temp=" + String(temperature) + "&pressure=" + String(pressure);

    // HTTP POST Request senden
    http.begin(client, serverName);
    http.addHeader("Content-Type", "application/x-www-form-urlencoded");
    
    int httpResponseCode = http.POST(httpRequestData);

    if (httpResponseCode > 0) {
      Serial.print("HTTP Response code: ");
      Serial.println(httpResponseCode);
    }
    else {
      Serial.print("Fehler code: ");
      Serial.println(httpResponseCode);
    }
    http.end();
  }
  else {
    Serial.println("WiFi getrennt");
  }

  delay(30000);  // Alle 30 Sekunden senden
}

So funktioniert der Sketch

Werfen wir nun einen Blick auf die einzelnen Bestandteile des Sketchs.

Einbindung der Bibliotheken

Am Anfang werden verschiedene Bibliotheken eingebunden, die für die WiFi-Verbindung, HTTP-Anfragen und die Kommunikation mit dem BMP180 Sensor benötigt werden.

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

Konfiguration

Anschließend legst du die WLAN-Zugangsdaten (SSID und Passwort) fest und hinterlegst die Adresse des Raspberry Pi Webservers. Ersetze hierbei SERVER-IP zum Beispiel durch 192.168.0.143:5000.

const char* ssid = "NETZWERK";
const char* password = "PASSWORT";
const char* serverName = "http://SERVER-IP/update-sensor";

Adafruit_BMP085 bmp;

Setup-Funktion

Hier stellst du die Verbindung zum WLAN her und initialisierst den Sensor:

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

  WiFi.begin(ssid, password);
  Serial.println("Verbinde mit WLAN");
  while(WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.print("Verbunden mit IP-Adresse: ");
  Serial.println(WiFi.localIP());

  if (!bmp.begin()) {
    Serial.println("BMP180 nicht gefunden, überprüfen Sie die Verkabelung!");
    while (1) {}
  }
}

Loop-Funktion

Nun zum Kern, hier prüfst du zunächst, ob die Internetverbindung steht, liest Temperatur und Luftdruck ein und sendest die Messdaten an den Raspberry Pi Webserver per HTTP POST. Anschließend prüfst du die Antwort des Servers, kappst die Verbindung zum WLAN und wartest 30 Sekunden bis zur nächsten Messung.

void loop() {
  if(WiFi.status() == WL_CONNECTED) {
    WiFiClient client;
    HTTPClient http;

    float temperature = bmp.readTemperature();
    float pressure = bmp.readPressure() / 100.0F;

    // Daten für den POST-Request vorbereiten
    String httpRequestData = "temp=" + String(temperature) + "&pressure=" + String(pressure);

    // HTTP POST Request senden
    http.begin(client, serverName);
    http.addHeader("Content-Type", "application/x-www-form-urlencoded");

    int httpResponseCode = http.POST(httpRequestData);

    // Überprüfung der Antwort
    if (httpResponseCode > 0) {
      Serial.print("HTTP Response code: ");
      Serial.println(httpResponseCode);
    }
    else {
      Serial.print("Fehler code: ");
      Serial.println(httpResponseCode);
    }
    http.end();
  }
  else {
    Serial.println("WiFi getrennt");
  }

  delay(30000);  // Alle 30 Sekunden senden
}

Lade den Sketch nun auf deinen ESP8266. Wenn du nun die IP-Adresse des Raspberry Pi Webservers in einem Browser öffnest, solltest du bald darauf die aktuellen Messdaten des ESP8266 darauf sehen.

Hübsche die Webseite etwas auf

Klappt alles? Dann wäre vielleicht eine etwas ansprechendere Webseite eine gute Idee. Im Prinzip sind dir hier keine Grenzen gesetzt, du kannst hier mit HTML und CSS schalten und walten wie du möchtest. Eine weiteres Layout inklusive eines Graphen für den Verlauf der Messdaten könnte z.B. dieses hier sein:

Das zugehörige Python-Script sieht folgendermaßen aus:

//Raspberry Pi Webserver
//polluxlabs.net

from flask import Flask, request, jsonify, render_template_string
from datetime import datetime
import json

app = Flask(__name__)

temperature = 20.0
pressure = 1013.25
last_update = "Noch keine Daten empfangen"
history = []

@app.route('/update-sensor', methods=['POST'])
def update_sensor():
    global temperature, pressure, last_update, history
    temperature = float(request.form.get('temp'))
    pressure = float(request.form.get('pressure'))
    last_update = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    
    history.append({"time": last_update, "temperature": temperature, "pressure": pressure})
    if len(history) > 10:
        history.pop(0)
    
    return "Daten aktualisiert", 200

@app.route('/get-data')
def get_data():
    return jsonify({
        "temperature": temperature,
        "pressure": pressure,
        "last_update": last_update,
        "history": history
    })

@app.route('/')
def index():
    html = """
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>BMP180 Sensordaten Dashboard</title>
    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/5.15.3/css/all.min.css" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        :root {
            --primary-color: #3498db;
            --secondary-color: #2c3e50;
            --background-color: #ecf0f1;
            --card-background: #ffffff;
        }
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            line-height: 1.6;
            color: var(--secondary-color);
            background-color: var(--background-color);
            margin: 0;
            padding: 0;
        }
        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 20px;
        }
        header {
            background-color: var(--primary-color);
            color: white;
            text-align: center;
            padding: 1rem;
            margin-bottom: 2rem;
        }
        h1 {
            margin: 0;
        }
        .dashboard {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
            gap: 20px;
        }
        .card {
            background-color: var(--card-background);
            border-radius: 8px;
            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
            padding: 20px;
            text-align: center;
        }
        .card-title {
            font-size: 1.2rem;
            color: var(--secondary-color);
            margin-bottom: 10px;
        }
        .card-value {
            font-size: 2.5rem;
            font-weight: bold;
            color: var(--primary-color);
        }
        .card-icon {
            font-size: 3rem;
            margin-bottom: 10px;
            color: var(--primary-color);
        }
        #updateTime {
            text-align: center;
            margin-top: 20px;
            font-style: italic;
        }
        #chart {
            width: 100%;
            height: 300px;
        }
    </style>
</head>
<body>
    <header>
        <h1>BMP180 Sensordaten Dashboard</h1>
    </header>
    <div class="container">
        <div class="dashboard">
            <div class="card">
                <i class="fas fa-thermometer-half card-icon"></i>
                <div class="card-title">Temperatur</div>
                <div class="card-value" id="temperature">--</div>
                <div>°C</div>
            </div>
            <div class="card">
                <i class="fas fa-tachometer-alt card-icon"></i>
                <div class="card-title">Luftdruck</div>
                <div class="card-value" id="pressure">--</div>
                <div>hPa</div>
            </div>
        </div>
        <div class="card" style="margin-top: 20px;">
            <canvas id="chart"></canvas>
        </div>
        <div id="updateTime">Letzte Aktualisierung: <span id="lastUpdate">--</span></div>
    </div>

    <script>
        let chart;

        function updateData() {
            fetch('/get-data')
                .then(response => response.json())
                .then(data => {
                    document.getElementById('temperature').textContent = data.temperature.toFixed(1);
                    document.getElementById('pressure').textContent = data.pressure.toFixed(2);
                    document.getElementById('lastUpdate').textContent = data.last_update;
                    
                    updateChart(data.history);
                });
        }

        function updateChart(history) {
            const ctx = document.getElementById('chart').getContext('2d');
            
            if (chart) {
                chart.destroy();
            }
            
            chart = new Chart(ctx, {
                type: 'line',
                data: {
                    labels: history.map(entry => entry.time),
                    datasets: [{
                        label: 'Temperatur (°C)',
                        data: history.map(entry => entry.temperature),
                        borderColor: 'rgb(255, 99, 132)',
                        tension: 0.1
                    }, {
                        label: 'Luftdruck (hPa)',
                        data: history.map(entry => entry.pressure),
                        borderColor: 'rgb(54, 162, 235)',
                        tension: 0.1
                    }]
                },
                options: {
                    responsive: true,
                    scales: {
                        x: {
                            display: true,
                            title: {
                                display: true,
                                text: 'Zeit'
                            }
                        },
                        y: {
                            display: true,
                            title: {
                                display: true,
                                text: 'Wert'
                            }
                        }
                    }
                }
            });
        }

        // Initialer Datenabruf
        updateData();

        // Aktualisiere Daten alle 30 Sekunden
        setInterval(updateData, 30000);
    </script>
</body>
</html>
    """
    return render_template_string(html)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

Wie geht es weiter?

Du hast nun einen Raspberry Pi Webserver, der Daten empfangen und auf einer Webseite visualisieren kann. Der nächste Schritt wäre eine Möglichkeit, über diese Webseite auch Geräte zu steuern, die wiederum z.B. an einem ESP8266 hängen und darüber gesteuert werden.

Um deine Messdaten zu speichern, verwendest du die Datenbank InfluxDB, die sicher hervorragend dazu eignet, zeitgebundene Daten zu speichern und nebenbei auch noch die Visualisierung deiner Daten einfach und intuitiv ermöglicht. InfluxDB wird lokal auf einem Raspberry Pi laufen. Der ESP8266 sendet die Messdaten dorthin und InfluxDB speichert und visualisiert sie. Anzeigen lassen kannst du diese dir dann in einem Browser und auf einem Gerät deiner Wahl.

Die Software, die du für die ESP8266 Wetterstation benötigst, ist kostenlos verfügbar.

Inhalte dieses Projekts:

• Die Sensoren DHT22 und BMP180 am ESP8266 anschließen und verwenden
• Messdaten auf einem OLED-Display anzeigen
• Den Raspberry Pi einrichten
• Per SSH auf deinen Raspberry Pi zugreifen
• InfluxDB installieren und die Messdaten vom ESP8266 übertragen
• Auf die Daten zugreifen und sie anschaulich visualisieren

Diese Bauteile benötigst du für die ESP8266 Wetterstation:

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

8,49 €

AZDelivery DHT22 AM2302 Temperatursensor und Luftfeuchtigkeitssensor kompatibel mit Arduino und Raspberry Pi inklusive E-Book!

Neben der Betriebsspannung muss lediglich ein Port mit dem Sensor verbunden werden.

9,49 €

Angebot

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

4,49 €

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

8,49 €

Angebot

Raspberry Pi 4 Modelo B 4GB

66,99 €

Den DHT22 AM ESP8266 anschließen und verwenden

Der Temperatursensor DHT22 misst neben der Temperatur auch die Luftfeuchtigkeit. Um ihn an deinem ESP8266 anzuschließen, orientiere dich an der folgenden Skizze. Achte bitte auf den 10 kΩ Widerstand, den du zwischen dem Anschluss des DHT22 am Pin D4 des ESP8266 und Plus einsetzen musst.

Übrigens: Falls du deinen ESP8266 noch nicht in der Arduino IDE verfügbar gemacht hast, findest du hier bei uns ein passendes Tutorial.

DIE PASSENDEN BIBLIOTHEKEN

Um deinen Sensor verwenden zu können, musst du zwei Bibliotheken installieren, von denen du jedoch nur eine im Sketch einbinden musst. Öffne deinen Bibliotheksmanager. Suche dort zunächst nach Adafruit Unified Sensor und installiere die aktuelle Version. Die Versionsnummern in den folgenden Screenshots können abweichen.

Suche anschließend nach DHT sensor library und installiere die entsprechende Bibliothek.

DIE TEMPERATUR und Luftfeuchtigkeit MESSEN

Kopiere dir den folgenden Sketch und lade ihn auf deinen Arduino hoch:

#include "DHT.h"

#define DHTPIN D4
#define DHTTYPE DHT22

float tempDHT22;
float humidity;

DHT dht(DHTPIN, DHTTYPE);

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

void loop() {

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

  Serial.print("Temperatur: ");
  Serial.print(tempDHT22);
  Serial.println("*C");
  
  Serial.print("Luftfeuchtigkeit: ");
  Serial.print(humidity);
  Serial.println("%");
  
  Serial.println();
  delay(2000);
}

So funktioniert der Sketch: Nachdem du die Bibliothek eingebunden hast, legst du den Pin fest, an dem der Sensor angeschlossen ist. In unserem Sketch ist das der Pin D4.

In der nächsten Zeile legst du das Modell des Sensors fest – in unserem Fall also ein DHT22. Anschließend erstellst du ein Objekt der Bibliothek names dht, das später bei der Messung mit den Funktionen dht.readTemperature() und dht.readHumidity() zum Einsatz kommt.

Der Rest des Sketchs dürfte für dich kein Problem sein. Achte jedoch darauf, dass die Baudrate von Sketch und Seriellem Monitor übereinstimmt. Hinweis: Es kann auch sein, dass dein DHT22 auch ohne Widerstand funktioniert – oder auch nur ohne Widerstand.

Wenn du doch lieber den Sensor DHT11 verwenden möchtest, musst du nur eine Stelle im Sketch anpassen:

#define DHTTYPE DHT11

Wie du den „kleinen Bruder“ des DHT22 – also den DHT11 – anschließt, erfährst du in der folgenden Skizze. Im weiteren Verlauf des Projekts verwenden wir jedoch weiterhin den DHT22.

DEN BMP180 am ESP8266 anschließen und verwenden

Neben der Luftfeuchtigkeit und der Temperatur soll die ESP8266 Wetterstation auch den aktuellen Luftdruck messen. Hierfür eignet sich der Sensor BMP180. Da dieser auch die Temperatur messen kann, schauen wir uns gleich auch noch die Messunterschiede zwischen DHT11 und BMP180 an. Doch zunächst zum Anschluss – orientiere dich hierbei an der folgenden Skizze:

Die benötigte Bibliothek

Neben der bereits vorinstallierten Bibliothek Wire (für die Kommunikation per I²C), 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.

Die Temperatur und den Luftdruck messen

Nun erweiterst du den obigen Sketch um den Code für den BMP180:

#include "DHT.h"
#include "Wire.h"
#include "Adafruit_BMP085.h"

#define DHTPIN D4
#define DHTTYPE DHT22

Adafruit_BMP085 bmp;

float tempDHT22;
float tempBMP180;
float humidity;
float pressure;

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  dht.begin();

  if (!bmp.begin()) {
    Serial.println("Sensor BMP180 nicht gefunden!");
    while (1) {}
  }
}

void loop() {

  tempDHT22 = dht.readTemperature();
  tempBMP180 = bmp.readTemperature();
  humidity = dht.readHumidity();
  pressure = bmp.readPressure();

  Serial.print("Temperatur DHT22: ");
  Serial.print(tempDHT22);
  Serial.println("*C");

  Serial.print("Temperatur BMP180: ");
  Serial.print(tempBMP180);
  Serial.println("*C");

  Serial.print("Luftfeuchtigkeit DHT22: ");
  Serial.print(humidity);
  Serial.println("%");

  Serial.print("Luftdruck BMP180: ");
  Serial.print(pressure/100);
  Serial.println("hPa");

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

Sobald du den Sketch auf deinen ESP8266 geladen hast, sollten im seriellen Monitor die vier Messdaten erscheinen.

In den allermeisten Fällen dürfte die Temperaturmessung des DHT22 und des BMP180 etwas auseinander liegen. Ein Blick in die jeweiligen Datenblätter verrät, dass beide Sensoren eine Genauigkeit von ±0,5°C haben – das ist eigentlich schon recht genau und für eine Wetterstation sicherlich genau genug. Für welchen Messwert du dich entscheidest, liegt nun bei dir – vielleicht hast du noch ein weiteres Thermometer zur Hand, das du als Referenz einsetzen kannst.

Im weiteren Verlauf dieses Projekts verwenden wir die Temperaturdaten des BMP180.

Das OLED-Display anschließen

Aktuell siehst du deine Messdaten nur im seriellen Monitor. Deshalb kommt nun ein Display zum Einsatz, auf dem du sie bequemer ablesen kannst. In diesem Projekt verwenden wir das handelsübliche OLED-Display Adafruit SSD1306 mit einer Größe von 128×64 px.

Erweitere also den Aufbau auf deinem Breadboard wie folgt:

Wie du siehst, sind sowohl der BMP180 als auch das OLED-Display per I²C (also an den Pins D1 und D2) am ESP8266 angeschlossen. Damit der Microcontroller beide Bauteile ansprechen kann, besitzen sie unterschiedliche Adressen – das OLED-Display mit 128×64 px die Adresse 0x3C und der BMP180 die Adresse 0x77.

Die benötigten Bibliotheken

Nun ist deine ESP8266 Wetterstation vollständig. Allerdings fehlt noch der Sketch, mit dem du deine Messdaten auf dem OLED-Display anzeigst. Auch für das Display benötigst du die Unterstützung von Bibliotheken, die du im Handumdrehen installierst. Öffne also wieder den Bibliotheksmanager und suche zunächst nach Adafruit SSD1306 und installiere die neueste Version. Falls du gefragt wirst, ob du auch zugehörige Erweiterungen installieren möchtest, bestätige das mit einem Ja.

Die zweite Bibliothek findest du mit einer Suche nach Adafruit GFX Library. Falls diese schon im Zuge der ersten Installation mitinstalliert wurde, brauchst du nichts weiter zu tun und kannst den Bibliotheksmanager schließen.

Messdaten auf dem Display anzeigen

Ersetze den Code auf deinem ESP8266 durch den folgenden erweiterten Sketch:

#include "DHT.h"
#include "Wire.h"
#include "Adafruit_BMP085.h"
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define DHTPIN D4
#define DHTTYPE DHT22

Adafruit_BMP085 bmp;

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

float tempDHT22;
float tempBMP180;
float humidity;
float pressure;

DHT dht(DHTPIN, DHTTYPE);

void setup() {
  Serial.begin(115200);
  dht.begin();

  if (!bmp.begin()) {
    Serial.println("Sensor BMP180 nicht gefunden!");
    while (1) {}
  }

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {  // Display-Addresse: 0x3C für Groesse 128x64px
    Serial.println(F("SSD1306 allocation failed"));
    for (;;)
      ;
  }
  display.setTextSize(1);       //Schriftgröße
  display.setTextColor(WHITE);  //Schriftfarbe


  display.clearDisplay();
  display.display();
}

void loop() {

  tempDHT22 = dht.readTemperature();
  tempBMP180 = bmp.readTemperature();
  humidity = dht.readHumidity();
  pressure = bmp.readPressure();

  Serial.print("Temperatur DHT22: ");
  Serial.print(tempDHT22);
  Serial.println("*C");

  Serial.print("Temperatur BMP180: ");
  Serial.print(tempBMP180);
  Serial.println("*C");

  Serial.print("Luftfeuchtigkeit DHT22: ");
  Serial.print(humidity);
  Serial.println("%");

  Serial.print("Luftdruck BMP180: ");
  Serial.print(pressure / 100);
  Serial.println("hPa");
  Serial.println();

  display.clearDisplay();

  display.setCursor(10, 10);
  display.println("Temp.:  " + String(tempBMP180) + " *C");

  display.setCursor(10, 29);
  display.println("Luftf.: " + String(humidity) + " %");
  display.setCursor(10, 48);

  display.println("Luftd.: " + String(pressure/100) + " hPa");

  display.display();
  delay(2000);
}

Auf deinem OLED-Display sollten nun untereinander die Werte für Temperatur, Luftfeuchtigkeit und Luftdruck zu sehen sein, die alle zwei Sekunden aktualisiert werden.

Die Daten auf dem Raspberry Pi speichern und visualisieren

Messdaten auf einem Display sind eine tolle Sache – aber wenn du die Werte deiner Wetterstation über längere Zeit speichern und sie als Graphen anzeigen möchtest, musst du ein paar Schritte weiter gehen.

Im Folgenden richtest du deinen Raspberry Pi so ein, dass du ihn bequem von deinem Computer per SSH steuern kannst. Anschließend installierst du dort die Datenbank InfluxDB, in der deine Messwerte gespeichert werden. Praktischerweise bringt InfluxDB gleich eine Möglichkeit, die Daten ansprechend darzustellen. Doch eins nach dem anderen.

Das Betriebssystem auf dem Raspberry Pi installieren

Zunächst benötigst du ein entsprechend konfiguriertes Betriebssystem. Das lässt du auf eine Micro-SD-Karte schreiben, die du dann in deinen Raspberry Pi steckst.

Besonders einfach ist das mit dem kostenlosen Rasperry Pi Imager, den du hier herunterladen kannst. Wähle einfach die Version für dein Betriebssystem und starte den Download.

Öffne das Programm nach dem Download und wähle in der Oberfläche unter Betriebssystem -> Raspberry Pi OS (other) -> Raspberry Pi OS (64-bit).

Schließe als nächstes die Micro-SD-Karte, auf die du das Raspberry Pi OS installieren möchtest, an deinen Computer an. Wähle sie anschließend im Feld SD-Karte aus.

Bevor du jetzt auf den Button Schreiben klickst, wähle zunächst die erweiterten Einstellungen hinter dem Zahnrad-Symbol. Hier kannst du gleich den Hostnamen festlegen, SSH aktivieren und auch deine WLAN-Zugangsdaten hinterlegen. Das bedeutet, dass du deinen Raspberry Pi nicht mehr an einen Monitor anschließen musst, um diese Einstellungen vorzunehmen. Später reicht es, die Micro-SD-Karte und das Stromkabel einzustecken.

Wähle zunächst im oberen Bereich die folgenden Optionen:

Anschließend legst du deinen Benutzernamen fest und hinterlegst deine WLAN-Zugangsdaten. Die Wahl deines Benutzernamen steht dir natürlich frei – in den folgenden Befehlen verwenden wir hier jedoch das gängige pi.

Noch ein Stück weiter unten stellst du noch dein Land und deine Zeitzone ein:

Und das war es. Speichere diese Einstellungen und klicke im Hauptmenü auf Schreiben.

Per SSH auf den Raspberry Pi zugreifen

Nachdem das Raspberry Pi OS auf der Micro-SD-Karte und schließlich in deinem Raspberry Pi gelandet ist, starte diesen, indem du das Stromkabel anschließt. Warte nun ein paar Minuten, bis er fertig gebootet hat.

Nun wirst du dich per SSH (Secure Shell) mit dem Raspberry Pi verbinden. SHH ist eine beliebte – und verschlüsselte – Verbindung zwischen zwei Geräten. Hierdurch kannst du auf sichere Art und Weise von deinem Computer auf den Raspberry Pi zugreifen, Software installieren – und später deine Wetterdaten auswerten. So richtest du die Verbindung ein:

MacOS & Linux

Bei diesen beiden Betriebssystemen brauchst du lediglich das Terminal. In Unix-basierten Betriebssystemen ist SSH nämlich schon vorinstalliert. Öffne also das Terminal und tippe den folgenden Befehl ein:

sudo ssh pi@raspberrypi.local

Hinweis: Falls du einen anderen Benutzer- und Hostnamen vergeben hast, passe den Befehl entsprechend an.

Wenn du nach deinem Passwort gefragt wirst, trage jenes, das du im Raspberry Pi Imager vergeben hast, ein und drücke Enter. Möglicherweise musst du auch noch mal mit einem yes bestätigen, dass du die Verbindung aufbauen möchtest. Wenn die Verbindung steht, siehst du die folgende Zeile in deinem Terminal:

Um die Verbindung wieder zu beenden und deinen Raspberry Pi herunterzufahren, trage folgenden Befehl ins Terminal ein:

sudo poweroff

Windows

In Windows benötigst du eine Software, um dich per SSH zu verbinden – zum Beispiel PuTTY. Diese Programm kannst du hier herunterladen.

Installiere PuTTY auf deinem Computer, öffne es und trage die folgenden Daten in den Optionen/Einstellungen ein:

• Host Name: raspberrypi
• Port: 22
• Connection type: SSH

Klicke anschließend auf Open/Öffnen. Bei der ersten Verbindung erscheint ein Dialog-Fenster, das dich davor warnt, dass du eine Verbindung zu einem unbekannten Host aufbaust. Diese kannst du mit einem Klick auf No schließen.

Logge dich als nächstes mit deinen Zugangsdaten, die du im Raspberry Pi Imager festgelegt hast, ein. Sobald die Verbindung steht, siehst du auch wieder die oben genannte Zeile. Um den Raspberry Pi auszuschalten, verwendest du ebenfalls.

sudo poweroff

INfluxDB 2 auf dem Raspberry Pi installieren

Jetzt wo deine Verbindung steht, kannst du die Datenbank InfluxDB installieren, um die Daten deiner ESP8266 Wetterstation zu speichern. Trage hierfür im Terminal bzw. in PuTTY den folgenden Befehl ein. Kopiere die folgenden Zeilen vollständig, füge sie ins Terminal ein und führe sie mit Enter aus.

wget -q https://repos.influxdata.com/influxdata-archive_compat.key
echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null
echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list

sudo apt-get update && sudo apt-get install influxdb2

Nun läuft die Installation im Terminal. Ab und an wirst du um deine Zustimmung zur Installation von Erweiterungspaketen gefragt. Gib diese einfach durch Eingabe von Y und Enter.

Nachdem die Installation abgeschlossen ist, erscheint wieder die Zeile pi@raspberrypi:~$

Trage nun folgenden Befehl im Terminal ein, der dafür sorgt, dass InfluxDB beim Start des Raspberry Pi ebenfalls gestartet wird:

sudo service influxdb start

Anschließend prüfst du noch kurz, ob InfluxDB aktiv ist:

sudo service influxdb status

Im Terminal erscheint nun einiges an Text – darunter hoffentlich ein grünes active (running):

Drücke q auf deiner Tastatur, um wieder zur Kommandozeile zurückzukehren.

Auf die Datenbank zugreifen

Um auf InfluxDB im Browser zugreifen zu können, benötigst du zunächst die IP-Adresse des Raspberry Pi. Diese findest du mit folgendem Befehl im Terminal heraus:

hostname -I

In der Antwort des Raspberry Pi siehst du ganz vorne die IP-Adresse, in unserem Fall die 192.168.0.129

Um nun InfluxDB zu starten, öffne in deinem Browser ein neues Tab oder Fenster und tippe deine IP-Adresse gefolgt vom Port :8086. Die Adresse sieht dann zum Beispiel so aus:

192.168.0.129:8086

In deinem Browser öffnet sich nun die Startseite von InfluxDB:

Nun kann es losgehen – klicke also auf Get started. Es folgt eine Seite, auf der du deine Zugangsdaten festlegst:

Trage deinen Benutzernamen unter Username ein und hinterlege ein sicheres Passwort. Unter Initial Organization Name kannst du ebenso deinen Benutzernamen eintragen – solange du nicht wirklich eine Arbeitsgruppe für die Wetterstation hast.

Unter Initial Bucket Name kannst du zum Beispiel ESP8266 Wetterstation eintragen. Unter diesem Namen findest du später die Datenbank für deine Wetterstation.

Bestätige deine Eingabe und klicke auf der folgenden Seite auf Quick Start:

Testweise die WLAN-Signalstärke übertragen

Anschließend findest du auf der Webseite die Kachel Arduino. Dahinter verbirgt sich eine Art Tutorial, wie du deinen ESP8266 einrichtest, um Daten an die Datenbank zu übertragen – hier die Stärke deines WLAN-Signals. Dieses Tutorial spielen wir im Folgenden teilweise durch, um einen Sketch zu erhalten, den du danach so erweitern kannst, dass er die Messdaten der Wetterstation überträgt.

Im Menü links findest du mehrere Punkte – da du den zweiten Punkt Prepare Arduino IDE (also den ESP8266 in der IDE verfügbar machen) bereits beim Aufbau der Wetterstation abgeschlossen hast, kannst du ihn gleich überspringen und auf Install Dependencies klicken.

Hier erhältst du Informationen zu einer Bibliothek, die du in der Arduino IDE installieren musst, um Daten an InfluxDB übertragen zu können. Öffne also den Bibliotheksmanager und suche nach InfluxDB. Im Tutorial heißt die erforderliche Bibliothek InfluxDB Client for Arduino – es kann aber gut sein, dass du nur eine Bibliothek namens ESP8266 Influxdb findest. Sollte das der Fall sein, installiere einfach diese stattdessen. Wenn du fertig bist, klicke auf Next.

Auf der nächsten Seite Initialize Client kannst du den Bucket auswählen, in den die Daten übertragen werden sollen:

Gleich darunter findest du Code, den du in einen leeren Sketch einfügen sollst. Erstelle also einen neuen Sketch, kopiere den zur Verfügung gestellten Code und füge ihn ein. Achte unbedingt darauf, dass du die leeren Funktionen Setup und Loop mit diesem Code überschreibst.

In diesem Beispiel-Sketch musst du noch deine WLAN-Zugangsdaten hinterlegen, damit dein ESP8266 mit dem Raspberry Pi kommunizieren kann:

  // WiFi AP SSID
  #define WIFI_SSID "YOUR_WIFI_SSID"
  // WiFi password
  #define WIFI_PASSWORD "YOUR_WIFI_PASSWORD"

Trage also deine Daten ein und klicke im Tutorial wieder auf Next.

Es folgen wieder zwei Zeilen Code, die du in der Setup-Funktion unterhalb des dort schon vorhandenen Codes einfügen musst:

Der Sketch in diesem Tutorial überträgt die Stärke deines WLAN-Signals an die Datenbank. Die zwei Zeilen fügen den Datenpunkten zwei Tags hinzu – einmal das Gerät und einmal die SSID, also der Name deines WLAN-Netzwerks.

Gleich darunter findest du den Loop des Sketchs. Dieser ist aktuell noch leer – kopiere ihn dir also aus dem Tutorial und überschreibe damit die leere Loop-Funktion in deiner Arduino IDE. Im Loop wird jede Sekunde der Received Signal Strength Indicator (RSSI, also die Signalstärke des WLAN-Netzes) gemessen und in der InfluxDB hinterlegt.

Die zwei nächsten Punkte des Tutorials können wir überspringen. Hier geht es um Datenbank-Abfragen, die wir jedoch für unsere Zwecke nicht benötigen.

Der vollständige Beispiel-Sketch

Diese Copy & Paste Arbeit hat etwas Fingerspitzengefühl erfordert. Wenn alles an der richtigen Stelle gelandet ist, sollte dein Sketch wie folgt aussehen:

#if defined(ESP32)
#include <WiFiMulti.h>
WiFiMulti wifiMulti;
#define DEVICE "ESP32"
#elif defined(ESP8266)
#include <ESP8266WiFiMulti.h>
ESP8266WiFiMulti wifiMulti;
#define DEVICE "ESP8266"
#endif

#include <InfluxDbClient.h>
#include <InfluxDbCloud.h>

// WiFi AP SSID
#define WIFI_SSID "YOUR_WIFI_SSID"
// WiFi password
#define WIFI_PASSWORD "YOUR_WIFI_PASSWORD"

#define INFLUXDB_URL "DEINE URL (ist vorausgefüllt)"
#define INFLUXDB_TOKEN "DEIN TOKEN (ist vorausgefüllt)"
#define INFLUXDB_ORG "DEINE ORG (ist vorausgefüllt)"
#define INFLUXDB_BUCKET "ESP8266 Wetterstation"

// Time zone info
#define TZ_INFO "UTC2"

// Declare InfluxDB client instance with preconfigured InfluxCloud certificate
InfluxDBClient client(INFLUXDB_URL, INFLUXDB_ORG, INFLUXDB_BUCKET, INFLUXDB_TOKEN, InfluxDbCloud2CACert);

// Declare Data point
Point sensor("wifi_status");

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

  // Setup wifi
  WiFi.mode(WIFI_STA);
  wifiMulti.addAP(WIFI_SSID, WIFI_PASSWORD);

  Serial.print("Connecting to wifi");
  while (wifiMulti.run() != WL_CONNECTED) {
    Serial.print(".");
    delay(100);
  }
  Serial.println();

  // Accurate time is necessary for certificate validation and writing in batches
  // We use the NTP servers in your area as provided by: https://www.pool.ntp.org/zone/
  // Syncing progress and the time will be printed to Serial.
  timeSync(TZ_INFO, "pool.ntp.org", "time.nis.gov");


  // Check server connection
  if (client.validateConnection()) {
    Serial.print("Connected to InfluxDB: ");
    Serial.println(client.getServerUrl());
  } else {
    Serial.print("InfluxDB connection failed: ");
    Serial.println(client.getLastErrorMessage());
  }

  // Add tags to the data point
  sensor.addTag("device", DEVICE);
  sensor.addTag("SSID", WiFi.SSID());
}

void loop() {
    // Clear fields for reusing the point. Tags will remain the same as set above.
    sensor.clearFields();
  
    // Store measured value into point
    // Report RSSI of currently connected network
    sensor.addField("rssi", WiFi.RSSI());
  
    // Print what are we exactly writing
    Serial.print("Writing: ");
    Serial.println(sensor.toLineProtocol());
  
    // Check WiFi connection and reconnect if needed
    if (wifiMulti.run() != WL_CONNECTED) {
      Serial.println("Wifi connection lost");
    }
  
    // Write point
    if (!client.writePoint(sensor)) {
      Serial.print("InfluxDB write failed: ");
      Serial.println(client.getLastErrorMessage());
    }
  
    Serial.println("Waiting 1 second");
    delay(1000);
    
    }

Die Daten visualisieren

Jetzt wird es Zeit, sich die übertragenen Daten einmal anzusehen. Öffne hierfür im Menü links den Data Explorer über das Symbol mit dem Koordinatensystem und dem Graphen.

Hier kannst du dir im unteren Bereich eine Abfrage (Query) basteln, die die Signalstärke als Graphen darstellt:

Wähle hierfür links deinen Bucket und im ersten Filter rechts daneben im Dropdown-Menü SSID und darunter den Wert, der dem Namen deines WLAN-Netzwerks entspricht. Rechts daneben sollte ein weiterer Filter aufgehen, in dem im Dropdown-Menü bereits _field vorausgewählt ist. Als einzigen Wert findest du darin rssi, also die Signalstärke. Wähle diesen Wert aus. Falls noch ein weiterer Filter rechts daneben aufgehen, kannst du diesen über das X in der Ecke schließen.

Um diese als Graphen anzuzeigen, musst du nur noch rechts auf Submit klicken. Nun sollte im oberen Bereich eine Graph entstehen – hier ein Beispiel, das schon einige Minuten lief:

Deine Abfrage kannst du natürlich zeitlich anpassen. Voreingestellt ist ein Zeitraum von einer Stunde (Past 1h). Über das entsprechende Dropdown kannst du auch andere Zeiträume einstellen.

Ganz oben findest du auch die Auswahl Custom Time Range – hierüber kannst du den Zeitraum noch genauer über einen Kalender einstellen. Sobald du deine Auswahl getroffen hast, klicke links neben dem Dropdown-Menü auf den Refresh-Button oder auf Submit. Über diese beiden Buttons kannst du den Graphen auch aktualisieren, um die aktuellen Daten miteinzubeziehen.

Du überträgst nun bereits Daten von deinem ESP8266 an deine Datenbank auf dem Raspberry Pi – wenn auch „nur“ die Stärke des WLAN-Signals. Nun wird es Zeit, die Messdaten zu übertragen.

Die Daten der ESP8266 WEtterstation übertragen und anzeigen

Um statt des WLAN-Signals die Messdaten zu übertragen, fügst du den Sketch aus dem Tutorial und deinen bisherigen Sketch der Wetterstation zusammen – und änderst außerdem noch zwei kleinere Stellen im Code.

Kopiere hierfür Stück für Stück aus deinem Wetterstation-Sketch die verschiedenen Teile (Bibliotheken und Definitionen, Setup sowie Loop) und füge sie nacheinander in den Sketch des Tutorials ein. Wenn du das getan hast, sieht dein vollständiger Sketch wie folgt aus:

#if defined(ESP32)
#include <WiFiMulti.h>
WiFiMulti wifiMulti;
#define DEVICE "ESP32"
#elif defined(ESP8266)
#include <ESP8266WiFiMulti.h>
ESP8266WiFiMulti wifiMulti;
#define DEVICE "ESP8266"
#endif

#include <InfluxDbClient.h>
#include <InfluxDbCloud.h>

// WiFi AP SSID
#define WIFI_SSID "YOUR_WIFI_SSID"
// WiFi password
#define WIFI_PASSWORD "YOUR_WIFI_PASSWORD"

#define INFLUXDB_URL "DEINE URL (ist vorausgefüllt)"
#define INFLUXDB_TOKEN "DEIN TOKEN (ist vorausgefüllt)"
#define INFLUXDB_ORG "DEINE ORG (ist vorausgefüllt)"
#define INFLUXDB_BUCKET "ESP8266 Wetterstation"

// Time zone info
#define TZ_INFO "UTC2"

// Declare InfluxDB client instance with preconfigured InfluxCloud certificate
InfluxDBClient client(INFLUXDB_URL, INFLUXDB_ORG, INFLUXDB_BUCKET, INFLUXDB_TOKEN, InfluxDbCloud2CACert);

// Declare Data point
Point sensor("wifi_status");

#include "DHT.h"
#include "Wire.h"
#include "Adafruit_BMP085.h"
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define DHTPIN D4
#define DHTTYPE DHT22

Adafruit_BMP085 bmp;

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

float tempDHT22;
float tempBMP180;
float humidity;
float pressure;

DHT dht(DHTPIN, DHTTYPE);

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

  // Setup wifi
  WiFi.mode(WIFI_STA);
  wifiMulti.addAP(WIFI_SSID, WIFI_PASSWORD);

  Serial.print("Connecting to wifi");
  while (wifiMulti.run() != WL_CONNECTED) {
    Serial.print(".");
    delay(100);
  }
  Serial.println();

  // Accurate time is necessary for certificate validation and writing in batches
  // We use the NTP servers in your area as provided by: https://www.pool.ntp.org/zone/
  // Syncing progress and the time will be printed to Serial.
  timeSync(TZ_INFO, "pool.ntp.org", "time.nis.gov");


  // Check server connection
  if (client.validateConnection()) {
    Serial.print("Connected to InfluxDB: ");
    Serial.println(client.getServerUrl());
  } else {
    Serial.print("InfluxDB connection failed: ");
    Serial.println(client.getLastErrorMessage());
  }

  // Add tags to the data point
  sensor.addTag("device", DEVICE);
  
  Serial.begin(115200);
  dht.begin();

  if (!bmp.begin()) {
    Serial.println("Sensor BMP180 nicht gefunden!");
    while (1) {}
  }

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {  // Display-Addresse: 0x3C für Groesse 128x64px
    Serial.println(F("SSD1306 allocation failed"));
    for (;;)
      ;
  }
  display.setTextSize(1);       //Schriftgröße
  display.setTextColor(WHITE);  //Schriftfarbe


  display.clearDisplay();
  display.display();
}

void loop() {
  tempDHT22 = dht.readTemperature();
  tempBMP180 = bmp.readTemperature();
  humidity = dht.readHumidity();
  pressure = bmp.readPressure();

  Serial.print("Temperatur DHT22: ");
  Serial.print(tempDHT22);
  Serial.println("*C");

  Serial.print("Temperatur BMP180: ");
  Serial.print(tempBMP180);
  Serial.println("*C");

  Serial.print("Luftfeuchtigkeit DHT22: ");
  Serial.print(humidity);
  Serial.println("%");

  Serial.print("Luftdruck BMP180: ");
  Serial.print(pressure / 100);
  Serial.println("hPa");
  Serial.println();

  display.clearDisplay();
  display.setCursor(10, 10);
  display.println("Temp.:  " + String(tempBMP180) + " *C");
  display.setCursor(10, 29);
  display.println("Luftf.: " + String(humidity) + " %");
  display.setCursor(10, 48);
  display.println("Luftd.: " + String(pressure / 100) + " hPa");

  display.display();

  // Clear fields for reusing the point. Tags will remain the same as set above.
  sensor.clearFields();

  // Store measured value into point
  sensor.addField("temp", tempBMP180);
  sensor.addField("humidity", humidity);
  sensor.addField("pressure", pressure/100);

  // Print what are we exactly writing
  Serial.print("Writing: ");
  Serial.println(sensor.toLineProtocol());

  // Check WiFi connection and reconnect if needed
  if (wifiMulti.run() != WL_CONNECTED) {
    Serial.println("Wifi connection lost");
  }

  // Write point
  if (!client.writePoint(sensor)) {
    Serial.print("InfluxDB write failed: ");
    Serial.println(client.getLastErrorMessage());
  }



  Serial.println("Waiting 1 second");
  delay(1000);
}

Im Code oben findest du zwei Änderungen, die wir uns jetzt näher anschauen. Zunächst streichst du den Tag SSID in der Setup-Funktion, da wir das nicht mehr brauchen. Übrig bleibt das device (also ESP8266) – hierüber können wir später im Data Explorer die Messdaten leichter finden.

// Add tags to the data point
sensor.addTag("device", DEVICE);

Außerdem müssen statt der Signalstärke unsere Messdaten für Temperatur, Luftfeuchtigkeit und -druck übertragen werden. Das geschieht im Loop mit folgendem Code:

  // Store measured value into point
  sensor.addField("temp", tempBMP180);
  sensor.addField("humidity", humidity);
  sensor.addField("pressure", pressure/100);

Hiermit werden die drei Felder (fields) mit den Namen temp, humidity und pressure in der Datenbank angelegt und mit den aktuellen Daten der Sensoren versorgt. Diese stammen aus unseren Variablen tempBMP180, humidity und pressure. Wie du siehst teilst du den Wert in der Variablen pressure noch durch 100, um statt Pascal (Pa) Hektopascal (hPa) zu erhalten.

Und das war auch schon alles. Achte darauf, dass deine korrekten WLAN-Zugangsdaten im Sketch eingetragen sind und lade ihn auf deinen ESP8266.

Die Daten im Data Explorer anzeigen

Als nächstes schaust du im Data Explorer nach, ob die Daten auch wie gewünscht deine Datenbank erreichen. Klicke hierfür links auf den entsprechenden Menüpunkt und erstelle deine Abfrage wie folgt:

Hier pickst du dir testweise die Temperatur über die Variable temp heraus. Wenn du deine Abfrage erstellt hast, klicke auf den Button Submit. Im oberen Bereich der Seite sollte nun ein Graph zu sehen sein – hier wieder ein Beispiel, das schon einige Zeit lief:

Wie du hier siehst begann die Aufzeichnung kurz nach 12 Uhr am 7. August 2023 mit Werten um die 24 °C. Gegen 12:20 Uhr brach die Verbindung zur Datenbank ab (die Wetterstation war aus) und begann wieder gegen 12:30 Uhr. Diese Zwischenzeit wird im Graphen als Verbindungslinie zwischen dem letzten erhaltenen und ersten wieder verfügbaren Datenpunkt dargestellt. Anschließend sank die Temperatur kontinuierlich von 25 °C auf circa 24,7 °C.

Hinweis: Auf der rechten Seite findest du den Punk Aggregate Function – hier kannst du einstellen, ob du von den Temperaturwerten den Durchschnitt (mean), den Median oder immer den letzten aktuellen Wert (last) sehen möchtest. Die letzte Option zeigt dir immer den aktuellen, tatsächlichen Wert an. Die beiden anderen glätten hingegen den Graphen, sodass Temperaturausschläge weniger ins Gewicht fallen.

Solange deine ESP8266 Wetterstation also läuft, werden Daten gesammelt. Auf diese kannst du entweder über das Dropdown (z.B. Past 1h) oder spezifisch über den Punkt Custom Time Range zugreifen. Es gibt allerdings noch eine weitere spannende Funktion: ein Dashboard.

Die Messdaten auf einem Dashboard anzeigen

Um die aktuelle Abfrage auf einem Dashboard zu speichern, das dir einen schnellen Überblick verschafft, klicke zunächst im Menü links auf den entsprechenden Button:

Klicke anschließend rechts auf den Button Create Dashboard und anschließend auf New Dashboard. Auf der folgenden Seite kannst du oben einen Namen für das Dashboard vergeben, zum Beispiel ESP8266 Wetterstation:

Anschließend kannst du über den Button Add Cell eine Kachel hinzufügen – zum Beispiel den gerade gesehenen Temperaturverlauf. Du landest nach deinem Klick wieder in der Ansicht des Data Explorers, nur das du diesmal hier die Abfrage für die neue Temperatur-Kachel erstellst.

Vergib zunächst wieder ganz oben einen Namen, zum Beispiel Temperaturverlauf. Anschließend wählst du im unteren Bereich wieder die Variable temp aus.

Alles, was jetzt noch fehlt ist ein Klick auf das Häkchen oben rechts – und schon landest du wieder auf deinem Dashboard, das nun den Temperaturverlauf enthält.

Im oberen Bereich findest du den Button Set Auto Refresh – hierüber kannst du einstellen, in welchem Intervall das Dashboard und damit auch der Graph aktualisiert werden soll.

Apropos Graph, du kannst auf dem Dashboard auch die aktuelle Temperatur anzeigen lassen. Klicke hierfür wieder auf Add Cell und erstelle die bekannte Abfrage erneut. Sobald du auf Submit geklickt hast, erscheint wieder dein Temperaturverlauf. Oben links findest du ein Dropdown-Menü, in dem du die Anzeige anpassen kannst. Wähle hier den Eintrag Gauge.

Nun siehst du nicht mehr den Verlauf, sondern die aktuelle Temperatur:

Vergib dieser Kachel wieder einen Namen und klicke abschließend auf das Häkchen rechts oben. Nun landest du wieder in deinem Dashboard mit den zwei Kacheln zur Temperatur.

Mit deinen beiden anderen Messwerten zu Luftdruck und -feuchtigkeit kannst du genauso verfahren. Noch ein letzter Hinweis zu den Kacheln: Über den Button Customize kannst du die Anzeige noch anpassen, was besonders beim Luftdruck sinnvoll ist. Stelle hier unter Thresholds einen Bereich von 900 bis 1100 ein, damit der Zeiger auch etwas zum Anzeigen hat. Ebenso kannst du dem Wert noch ein Suffix vergeben – hier also hPa.

Warnungen per Nachricht senden

Möchtest du Nachrichten an dich oder jemand anderes senden, wenn ein bestimmter Messwert über- oder unterschritten wird? Im folgenden Tutorial erfährst du, wie du mit dem ESP8266 oder ESP32 Nachrichten per Telegram, WhatsApp und E-Mail verschickst.

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?

Hier lernst du, wie du einen Farbsensor* anschließt, damit Farben erkennst und diese in das bekannte RGB-Modell umrechnest. In diesem Tutorial verwenden wir den gängigen Sensor TC3200.

AZDelivery Farbsensor TCS230 TCS3200 Farben Sensor Modul kompatibel mit Arduino inklusive E-Book!

Chip: TAOS TCS3200 RGB Sensor; Eingangsspannung: DC 3 ~ 5V; Hellweiße LEDs...

8,99 €

Den Farbsensor am Arduino anschließen

Am Sensor findest du insgesamt 8 Pins, von denen du 7 mit deinem Arduino wie folgt verbinden kannst. Die Wahl der Digitalpins ist natürlich dir selbst überlassen.

Eine kurze Erklärung zu den einzelnen Pins am Farbsensor: Mit den Pins S0 und S1 kannst du die Ausgangsfrequenz des Sensors steuern. So kannst du deine Ergebnisse optimieren, was wir in diesem Tutorials allerdings erst einmal beiseite lassen.

Die Pins S2 und S3 steuern die einzelnen Photodioden des Sensors. Hiervon gibt es je 16 Stück für die Farben Rot, Grün, Blau und Clear (also ohne Farbfilter). Die beiden Pins kannst du von deinem Arduino entweder auf HIGH oder LOW setzen – die Kombination bestimmt dann, welche Dioden angesprochen und welche Farbe also „gelesen“ werden soll:

Gleich im Sketch schauen wir uns diese Kombinationen genauer an. Es fehlt allerdings noch der Pin OUT – hierüber liest dein Arduino die Messergebnisse ein.

Der Sketch zum Farben erkennen

Kommen wir also zum Code. Du benötigst für den Farbsensor keine eigene Bibliothek, sondern kannst die Messungen mit ein paar einfachen Funktionen selbst erledigen. Definiere zunächst die verwendeten Anschlüsse zu Beginn des Sketchs:

#define S0 6
#define S1 7
#define S2 8
#define S3 9
#define sensorOut 10

Anschließend benötigst du noch je drei Variablen für die Roh- und RGB-Werte der einzelnen Farben Rot, Grün und Blau:

int frequencyR = 0;
int frequencyG = 0;
int frequencyB = 0;

int red = 0;
int green = 0;
int blue = 0;

Die Setup-Funktion

Hier startest du deinen Seriellen Monitor und definierst die einzelnen pinModes:

Serial.begin(115200);

pinMode(S0, OUTPUT);
pinMode(S1, OUTPUT);
pinMode(S2, OUTPUT);
pinMode(S3, OUTPUT);
pinMode(sensorOut, INPUT);

Wie du siehst, sprichst du die Pins S1 bis S3 von deinem Arduino aus an (OUTPUT) und möchtest vom Pin sensorOut Messdaten erhalten (INPUT). Fehlt noch eine Sache: Wie oben kurz erwähnt, steuerst du mit den Pins S1 und S2 die Ausgangsfrequenz. Diese setzt du mit den folgenden zwei Zeilen auf 20%:

digitalWrite(S0, HIGH);
digitalWrite(S1, LOW);

Für die Ausgangsfrequenz gibt es festgelegte Werte und Kombinationen. Wenn du etwas tiefer einsteigen und die Ergebnisse deines Sensors optimieren möchtest, orientiere dich an dieser Tabelle:

Der Loop

Kommen wir also zu den Messungen. Im Loop deines Sketchs führst du für jede der drei Farben Rot, Grün und Blau eine separate Messung durch und rechnest deine Ergebnisse in den RGB-Farbraum um. Zunächst der Code für Rot:

digitalWrite(S2, LOW);
digitalWrite(S3, LOW);

frequencyR = pulseIn(sensorOut, LOW);
Serial.print("Red = ");
Serial.print(frequencyR);

Als erstes setzt du die beiden Pins S2 und S3 auf LOW, um nur die Photodioden mit rotem Farbfilter anzusprechen. Anschließend liest du den Wert mit der Funktion pulseIn() ein und speicherst den Wert in der Variablen frequencyR. Zuletzt gibst du ihn im Seriellen Monitor aus. In der Arduino-Referenz lernst du mehr über die Funktion pulseIn().

Mit diesen Messergebnissen kannst du noch nicht viel anfangen – besser ist es, wenn du einen bekannten Wert wie den Rotanteil im RGB-Modus erhältst. So kannst du nämlich zusammen mit den Ergebnissen der Farben Grün und Blau die Farbe vor deinem Sensor mehr oder weniger genau bestimmen und sie z.B. zur Kontrolle auf einem TFT-Display* anzeigen.

Um das zu erreichen, bietet sich die Funktion map() an:

map(frequencyR, 20, 120, 255, 0)

In dieser Funktion benötigst du fünf Argumente: Zunächst den Messwert frequencyR und den Messbereich des Sensors. Hierfür machst du am besten ein paar Testmessungen mit verschiedenfarbigen Objekten vor deinem Farbsensor und schaust dir die Minimal- und Maximalwerte im Seriellen Monitor an. Bei uns lagen die Werte ungefähr im Bereich von 20 bis 120 – das kann bei dir jedoch anders sein.

Wenn du deinen passenden Wertebereich ermittelt hast, kommen die letzten beiden Argumente ins Spiel. Diese geben den maximalen (255) und minimalen Rotwert (0) im RGB-Modus an. Je „mehr“ Rot dein Farbsensor erkennt, desto geringer sein Messwert (bei uns also in Richtung 20). Das entspricht jedoch einem hohen Wert im RGB-Farbraum – deshalb „mappst“ du die 20 auf die 255 und andersherum die 120 auf die 0.

Alle Farben zusammen

Und das war es im Prinzip. Für die Farben Blau und Grün wiederholst du einfach das Prozedere der Farbe Rot. In deinem Seriellen Monitor siehst du nun die RGB-Werte jeder einzelnen Farbe, die zusammen in etwa die Farbe des Objekts vor dem Sensor ergeben sollten.

Hier nun der gesamte Sketch zum Rauskopieren:

//pins for color sensor
#define S0 6
#define S1 7
#define S2 8
#define S3 9
#define sensorOut 10

//raw and RGB values for each color
int frequencyR = 0;
int frequencyG = 0;
int frequencyB = 0;

int red = 0;
int green = 0;
int blue = 0;

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

  pinMode(S0, OUTPUT);
  pinMode(S1, OUTPUT);
  pinMode(S2, OUTPUT);
  pinMode(S3, OUTPUT);
  pinMode(sensorOut, INPUT);
  digitalWrite(S0, HIGH);
  digitalWrite(S1, LOW);
}

void loop() {
  digitalWrite(S2, LOW);
  digitalWrite(S3, LOW);

  frequencyR = pulseIn(sensorOut, LOW);
  Serial.print("Red = ");
  //Serial.print(frequencyR);
  red = map(frequencyR, 20, 150, 255, 0);
  Serial.print(red);


  digitalWrite(S2, LOW);
  digitalWrite(S3, HIGH);

  frequencyB = pulseIn(sensorOut, LOW);
  Serial.print(" Blue = ");
  //Serial.print(frequencyB);
  blue = map(frequencyB, 20, 150, 255, 0);
  Serial.print(blue);


  digitalWrite(S2, HIGH);
  digitalWrite(S3, HIGH);

  frequencyG = pulseIn(sensorOut, LOW);
  Serial.print(" Green = ");
  //Serial.println(frequencyG);
  green = map(frequencyG, 20, 150, 255, 0);
  Serial.println(green);

  delay(100);
}

Wie geht es weiter?

Du kannst nun Farben mit einem Farbsensor erkennen und sie in den RGB-Farbraum übertragen. Wie wäre es, wenn du dir einen eigenen Color Picker baust, mit dem du die RGB-Werte einzelner Objekte ermittelst? Hierfür bietet sich ein TFT-Display an, auf dem du die ermittelte Farbe auch gleich darstellen kannst.

Zugegeben, mit den Meteorologen in den Nachrichten kann dieses Projekt nicht mithalten, aber möglicherweise kann es dich vor den ganz großen Wetterumschwüngen warnen.

Anfänger

1 – 2 Stunden

ca. 10 € + Arduino

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

Arduino UNO Rev3 [A000066] - Vielseitiges Entwicklungsboard mit ATmega328P-Mikrocontroller, kompatibel IDE, ideal f�r Einsteiger und Elektronik-, Robotik- und DIY-Projekte.

28,51 €

Angebot

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

4,49 €

AZDelivery Micro Servo Motor kompatibel mit SG90 9G für RC Roboter Hubschrauber Flugzeug kompatibel mit Arduino ink. E-Book!

5,99 €

AZDelivery Breadboard Kit - 3X Jumper Wire m2m/f2m/f2f + 3er Set MB102 Breadboard kompatibel mit Raspberry Pi inklusive E-Book!

Steckbrett für schnellen Aufbau elektronischer Schaltungen mit 830 Kontakten.; ...

10,99 €

So funktioniert die Wettervorhersage

Wie eingangs erwähnt, ist eine Wettervorhersage eine komplexe Angelegenheit, an der Spezialisten mit Großcomputern arbeiten. Es gibt jedoch einen Zusammenhang, den wir uns in diesem Projekt zunutze machen: Steigt der Luftdruck, bessert sich das Wetter – fällt er, wird das Wetter schlecht.

Auch das ist eine starke Vereinfachung der Realität sein, aber dieser Zusammenhang soll uns hier einmal genügen. Immerhin wird dieses Prinzip schon seit Jahrhunderten angewandt. Sicherlich kennst du alte Barometer wie dieses hier:

Mehr über Barometer und die möglichen Anwendungen erfährst du auf Wikipedia. In unserer Arduino Wettervorhersage messen wir in regelmäßigen Abständen den Luftdruck und vergleichen ihn mit dem zuletzt gemessenen Wert. Fällt der Luftdruck immer weiter, dreht ein Servo-Motor einen Zeiger nach links in Richtung schlechtes Wetter. Wenn der Luftdruck kontinuierlich steigt, bewegt sich der Zeig nach rechts – es wird also gutes Wetter geben. Übrigens: Mit unserer ESP8266 Wetterstation speicherst du Daten zum Luftdruck lokal in einer Datenbank.

Luftdruck messen mit dem BMP180

Für die Messung des Luftdrucks verwenden wir den Sensor BMP180. Du kannst auch den genaueren BMP280* oder einen BME280* verwenden. Letzterer misst auch die Luftfeuchte, die wir in diesem Projekt jedoch nicht brauchen.

Diese Sensoren lassen sich leicht per I²C anschließen und mit einer passenden Bibliothek komfortabel verwenden. In diesem Tutorial erfährst du mehr darüber, wie du den BMP180 anschließt und verwendest.

Das Wetter mit einem Servo anzeigen

Es gibt viele denkbare Möglichkeiten, um die Veränderungen des Luftdrucks anzuzeigen: Verschiedene Displays oder auch ein NeoPixel LED-Ring. Hier verwenden wir jedoch einen Servo-Motor und eine passende Schablone. Diese können z.B. Kinder farbig gestalten und sie hat ebenso den gewissen Retro-Charme.

Was ein Servo-Motor ist, wie funktioniert und was es alles zu beachten gibt, erfährst in diesem Tutorial zu Servos.

Der Aufbau der Arduino Wettervorhersage

Es dauert nur wenige Minuten, die Wettervorhersage auf deinem Breadboard aufzubauen. Orientiere dich hierbei an diesem Schema:

Achte darauf, dass du den Servo mit 5V und den BMP180 mit 3,3V versorgst. Die Beschriftung der Pins des BMP180 befindet sich auf seiner Unterseite – vergewissere dich, dass du sie richtig am Arduino angeschlossen hast, bevor du ihn mit Strom versorgst.

Der Sketch

Es sind nicht viele Zeilen Code nötig, um die Wettervorhersage zum Laufen zu bringen. Starte wie so oft, indem du die nötigen Bibliotheken einbindest. Wie du sie installierst, erfährst du in den oben genannten Tutorials.

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

Anschließend erstellst du zwei Objekte – eines für den Luftdruck-Sensor und eines für den Servo:

Adafruit_BMP085 bmp;
Servo myServo;

Dazu benötigst du noch ein paar Variablen, um die Werte des Sensors und die gewünschte Position des Servos zu speichern:

int servoPosition;
long currentPressure;
long oldPressure;
int delta;

Die Setup-Funktion

Hier startest du den Seriellen Monitor und vergewisserst dich, dass der BMP180 richtig angeschlossen und funktionstüchtig ist. Anschließend weist du dem Servo den Anschlusspin 8 zu und drehst den Zeiger nach oben – auf 90°.

void setup() {
  Serial.begin(115200);
  if (!bmp.begin()) {
    Serial.println("Sensor not found!");
    while (1) {}
  }

  myServo.attach(8);
  myServo.write(90);
}

Übrigens: Wenn du nicht weißt, in welcher Position sich dein Servo gerade befindet und in welche Position der Zeiger bei der Montage schauen soll, dann bringe ihn erst nach dem Start an. Zu Beginn des Sketchs steht der Servo auf 90° – sodass der Zeiger nach oben gerichtet ist.

Der Loop der Arduino Wettervorhersage

Hier misst du als erstes den aktuellen Luftdruck und gibst ihn im Seriellen Monitor aus:

  currentPressure = bmp.readPressure();
  Serial.print("Current Pressure = ");
  Serial.print(currentPressure);
  Serial.println(" Pa");

Wie du siehst, geht das ganz einfach mit der Funktion bmp.readPressure(). Gleichzeitig speicherst du diesen Wert – der in Pascal ausgegeben wird – in der Variablen currentPressure.

Danach fragst du ab, ob sich der aktuelle Luftdruck gegenüber der Messung davor (gespeichert in der Variablen oldPressure) verändert hat. Falls ja, speicherst du diese Veränderung in der Variablen delta.

 if (oldPressure && currentPressure != oldPressure) {
   delta = currentPressure - oldPressure;

Im If-Statement siehst du die Bedingung oldPressure && – diese befindet sich hier, da es im ersten Messdurchgang noch keine alte Messung gibt. Erst wenn in dieser Variablen eine Zahl hinterlegt ist – sie also nicht mehr auf 0 bzw. false steht – wird diese Bedingung wahr. Alternativ kannst du auch folgendes schreiben:

 if (oldPressure == true && currentPressure != oldPressure) {

Den Servo steuern

Kommen wir zum Servo und der Anzeige der Wetterlage. Um die Veränderung des Luftdrucks in der Variablen delta anzuzeigen, musst du dem Servo mitteilen, wo er sich hindrehen soll. Ein Servo kann eine Position zwischen 0° und 180° einnehmen – zu Beginn des Sketchs steht er in der Mitte, also auf 90°.

Wir nehmen mal an, dass die maximale Veränderung in unserem Messzeitraum (mehr dazu gleich) bei +- 100 Pa liegt. Bei -100 Pa soll der Servo auf 0° fahren, bei +100 Pa entsprechend auf 180°. Hinweis: Möglicherweise liegen wir mit dieser Einschätzung falsch – hier sind also deine eigenen Experimente gefragt. Verfolge im Seriellen Monitor die Messwerte und kalibriere deine Wetterstation entsprechend.

Jedenfalls musst du die beiden Wertebereiche +-100 Pa und 0-180° unter einen Hut bringen. Hierfür bietet sich die Funktion map() an:

servoPosition = map(delta, -100, 100, 0, 180);

Hier nimmst du die aktuelle Veränderung delta, ihren möglichen Wertebereich +-100 und „mappst“ diesen Wert auf die möglichen Winkel des Servos: 0° bis 180°. Heraus kommt der Winkel, der der Veränderung des Luftdrucks entspricht. Diesen speicherst du in der Variablen servoPosition.

Anschließend steuerst du deinen Servo auf diese Position:

myServo.write(servoPosition);

Danach machst du die aktuelle Messung zur alten Messung oldPressure, mit der du die nächste vergleichst. Und als letztes wartest du eine gewisse Zeit bis zur Messung, in diesem Fall 5 Minuten bzw. 300.000 Millisekunden.

oldPressure = currentPressure;
delay(300000);

Hier nun der gesamte Sketch der Arduino Wettervorhersage zum Rauskopieren und Hochladen. Viel Spaß!

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

#include <Servo.h>

Adafruit_BMP085 bmp;
Servo myServo;

int servoPosition;
long currentPressure;
long oldPressure;
int delta;

void setup() {
  Serial.begin(115200);
  if (!bmp.begin()) {
    Serial.println("Sensor not found!");
    while (1) {}
  }

  myServo.attach(8);
  myServo.write(90);
}

void loop() {
  currentPressure = bmp.readPressure();
  Serial.print("Current Pressure = ");
  Serial.print(currentPressure);
  Serial.println(" Pa");

  if (oldPressure && currentPressure != oldPressure) {
    delta = currentPressure - oldPressure;
    Serial.print("Change: ");
    Serial.print(delta);
    Serial.println();
  }

  servoPosition = map(delta, -100, 100, 0, 180);
  myServo.write(servoPosition);
  
  oldPressure = currentPressure;

  delay(300000);
}

Fehlen dir noch Bauteile? Dann wirf einen Blick in unsere Übersicht der besten Arduino Starter Kits.

Dieses Projekt ist der dritte Teil einer Serie und baut auf die Vorgängerprojekte auf. In diesem Artikel findest du alles zum Aufbau und den passenden Sketch; wir besprechen jedoch nicht alle Teile des Codes. Wenn du mehr Details erfahren möchtest, wirf bitte einen Blick in die folgenden Projekte:

1. Ein stiller Alarm mit Telegram und einem ESP8266
2. Überwache die Temperatur mit Telegram und einem ESP8266

Falls du noch kein Projekt mit Telegram gebaut hast, lerne zunächst, wie du einen Telegram-Bot erstellst.

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

8,49 €

Angebot

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

4,49 €

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

Breadboard; Steckbrett für schnellen Aufbau elektronischer Schaltungen mit 400...

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 des Projekts

Wenn du das Vorgängerprojekt aufgebaut hast, dann musst du auf Seiten der Hardware nichts weiter tun – du kannst deinen Aufbau hier einfach weiterverwenden.

Im Sketch hat sich dafür einiges verändert:

Der Sketch

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

Sketch als .txt anschauen

/*
   Die Temperatur abfragen 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 "TOKEN"  // den Bot-Token bekommst du vom Botfather)

//Deine UserID
#define userID "USERID"

WiFiClientSecure client;
UniversalTelegramBot bot(botToken, client);

Adafruit_BMP085 bmp;

//Variable für die Temperatur
float temp;

//Variable für die Anzahl der Anfragen
int numNewRequests;

//Variable für den Text der Anfrage, die du sendest
String text = "";

//UserID des Absenders
String chat_id = "";

//Name des Absenders
String from_name = "";

//Variable für die Willkommensnachricht
String welcome = "";

//Funktion fürs Verarbeiten neuer Anfragen
void handleNewRequests(int numNewRequests) {

  for (int i = 0; i < numNewRequests; i++) { //loopt durch die neuen Anfragen

    //Checkt, ob du die Anfrage gesendet hast oder jemand anderes
    chat_id = String(bot.messages[i].chat_id);
    if (chat_id != userID) {
      bot.sendMessage(chat_id, "Du bist nicht autorisiert!", "");
      continue;
    }

    // Anfragetext speichern
    text = bot.messages[i].text;
    Serial.println(text);

    from_name = bot.messages[i].from_name;

    if (text == "/start") {
      welcome = "Willkommen, " + from_name + ".\n";
      welcome += "Mit folgendem Befehl fragst du die aktuelle Temperatur ab: \n\n";
      welcome += "/messen \n";
      bot.sendMessage(chat_id, welcome, "");
      bot.sendMessage(chat_id, "http://gph.is/2aLXZ8H", "");
    }

    if (text == "/messen") {
      temp = bmp.readTemperature();
      bot.sendMessage(chat_id, "Temperatur: " + String(temp) + " ºC", "");
    }
  }
}

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

  //Verbindung zum WLAN
  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!");

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

void loop() {

  //checkt, ob eine neue Anfrage reinkam
  int numNewRequests = bot.getUpdates(bot.last_message_received + 1);

  while (numNewRequests) { //wird ausgeführt, wenn numNewRequests == 1
    Serial.println("Anfrage erhalten");
    handleNewRequests(numNewRequests);
    numNewRequests = bot.getUpdates(bot.last_message_received + 1);
  }
  delay(1000);
}

Was ist neu in diesem Sketch?

In diesem Sketch läuft einiges anders: In den zwei vorangegangenen Projekten hat dein ESP8266 nur Nachrichten gesendet, in diesem Projekt wartet er jedoch auf eine Nachricht von dir – die er dann selbst mit der aktuellen Temperatur beantwortet.

Dafür muss dein ESP8266 – im Gegensatz zu den vorherigen Projekten – die ganze Zeit mit deinem WLAN verbunden sein. Deshalb wandert der Code, mit dem du die Verbindung herstellst, direkt in die Setup-Funktion:

  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!");

Schauen wir jetzt direkt in den Loop. Dort prüft dein ESP8266 alle 1000 Millisekunden, ob eine neue Anfrage vorliegt:

int numNewRequests = bot.getUpdates(bot.last_message_received + 1);

Wenn das der Fall ist, wird in der Variablen numNewRequests mithilfe der Funktion bot.getUpdates() die Anzahl der vorliegenden Anfragen gespeichert (im Normalfall eine 1, aber es können theoretisch ja auch mehrere vorliegen).

Das wiederum setzt den folgenden While-Loop in Gang, der die Funktion handleNewRequests() so oft aufruft wie Anfragen „abzuarbeiten“ sind. In diesem Loop wird auch die Variable numNewRequests aktualisiert – sobald hier wieder eine 0 enthalten ist, endet der Loop.

while (numNewRequests) {
  handleNewRequests(numNewRequests);
  numNewRequests = bot.getUpdates(bot.last_message_received + 1);
  }

Die Funktion handleNewRequests()

Kommen wir zum Kernstück des Sketchs. Diese Funktion handleNewRequests() erwartet bei Ihrem Aufruf ein Argument – nämlich die Anzahl der vorliegenden Anfragen, die in der Variablen numNewRequests steckt. Diese hast du beim Aufruf der Funktion im While-Lopp bereits mitgegeben:

handleNewRequests(numNewRequests);

Bei der Deklaration der Funktion taucht diese Variable wieder auf, um dann gleich weiterverarbeitet zu werden. Diesmal iterierst du mit einem For-Loop über die Anzahl der Anfragen, um sie eine nach der anderen abzuarbeiten:

void handleNewRequests(int numNewRequests) {
  for (int i = 0; i < numNewRequests; i++) { 

Innerhalb des Loops findet zuerst eine sehr wichtige Prüfung statt – nämlich ob die Anfrage überhaupt von einem autorisierten User (also von dir) stammt. Hierfür speicherst du die chat_id, die mit jeder Anfrage übergeben wird, in der gleichnamigen Variablen.

Anschließend prüfst du, ob diese mit deiner eigenen UserID übereinstimmt. Ist das nicht der Fall, erhält der Absender eine entsprechende Nachricht und der For-Loop wird mit continue abgebrochen:

chat_id = String(bot.messages[i].chat_id);
if (chat_id != userID) {
  bot.sendMessage(chat_id, "Du bist nicht autorisiert!", "");
  continue;
}

Wenn die Anfrage jedoch von dir stammt, speicherst du ihren Textinhalt und den Namen des Absenders (also wiederum deinen) ab:

text = bot.messages[i].text;
from_name = bot.messages[i].from_name;

Fehlen nur noch zwei If-Statements. Wenn du deinen Telegram-Bot zum ersten Mal startest, machst du das mit dem Text /start (den du natürlich auch senden kannst, wenn der Bot schon läuft). In diesem Fall erscheint eine kleine Begrüßungsnachricht mit einer Erklärung: Um die aktuelle Temperatur abzufragen, musst du deinem Bot (und damit deinem ESP8266) die Nachricht /messen schicken.

Hier werden wieder Strings miteinander verbunden, diesmal mit dem Operator +=, der einfach die Variable welcome um weiteren Text erweitert. Auch beachtenswert: Mit \n kannst du einen Zeilenumbruch einfügen.

Am Ende des Statements findest du wieder die Funktion bot.sendMessage(), die du bereits kennengelernt hast. Diese taucht hier gleich zweimal auf: Einmal, um den String welcome zu senden und dann noch einmal, um ein GIF hinterherzuschicken. Wenn du spaßeshalber auch GIFs senden möchtest, reicht dafür einfach die entsprechende URL der Datei.

if (text == "/start") {
  welcome = "Willkommen, " + from_name + ".\n";
  welcome += "Mit folgendem Befehl fragst du die aktuelle Temperatur ab: \n\n";
  welcome += "/messen \n";
  bot.sendMessage(chat_id, welcome, "");
  bot.sendMessage(chat_id, "http://gph.is/2aLXZ8H", "");
}

Die zweite Abfrage kümmert sich um die Anfrage /messen, die mit der aktuellen Temperatur beantwortet werden soll. Auch das kennst du bereits aus den vorangegangenen Projekten:

if (text == "/messen") {
  temp = bmp.readTemperature();
  bot.sendMessage(chat_id, "Temperatur: " + String(temp) + " ºC", "");
}

Und das war es auch schon. Du hast in dieser Lektion gelernt, wie du nicht nur Nachrichten von deinem ESP8266 an deinen Telegram-Bot senden kannst, sondern auch von dort aus Sensordaten abrufen kannst.

Wie geht es weiter?

Du kannst natürlich nicht nur die Temperatur abfragen. Der Sensor BMP180 kann auch den Luftdruck ermitteln. Der Nachfolger BMP280 misst sogar die Luftfeuchtigkeit. Baue z.B. eine Wetterstation, bei der du die aktuellen Daten aus der Ferne abfragst.

Eine weitere Möglichkeit ist ein Feuchtigkeitssensor, den du neben eine Pflanze in die Erde steckst. Wenn du denkst, die Erde sei zu trocken, kannst du eine automatische „Gießkanne“ von deinem Smartphone aus steuern.

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

8,49 €

Angebot

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

4,49 €

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

Breadboard; Steckbrett für schnellen Aufbau elektronischer Schaltungen mit 400...

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 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!

Zum Einsatz kommt hierbei der Sensor HC-SR501. Diese Art von Sensoren kennst du von den handelsüblichen Bewegungsmeldern, die das Licht anschalten, sobald jemand an ihm vorbeikommt.

Das ist ein sogenannter PIR-Sensor – PIR steht für Passive Infrared. Dieser Sensor erkennt also Infrarotstrahlung bzw. Wärme, die von Körpern abgestrahlt wird. Darüber hinaus springt er nur an, wenn sich dieser Körper bewegt – denn sonst würde er schließlich auch bei einer warmen Heizung Alarm schlagen.

Heißt also konkret: Sobald eine Person (oder auch eine Katze oder ein Hund) in die Reichweite des Bewegungsmelders gerät, registriert dieser die abgestrahlte Wärme sowie die Bewegung und gibt dir Bescheid.

Anfänger

1 – 2 Stunden

ca. 10 €

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

8,49 €

Angebot

AZDelivery HC-SR501 PIR Bewegungssensor Bewegungsmelde Modul kompatibel mit Arduino und Raspberry Pi inklusive E-Book!

PIR Modul zur Bewegungserkennung; Betriebsspannung 5V. Ideal für...

6,99 €

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

Breadboard; Steckbrett für schnellen Aufbau elektronischer Schaltungen mit 400...

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 €

Telegram vorbereiten

Zunächst benötigst du einen Account bei Telegram – und die dazugehörige App für dein Smartphone oder den Computer. Im Folgenden verwenden wir ein Smartphone. Telegram ist kostenlos, werbefrei und funktioniert so ähnlich wie WhatsApp. Allerdings hast du hier die Möglichkeit, Bots zu erstellen, mit denen du interagieren kannst.

Das machst du dir in diesem Projekt zunutze, indem du deinen ESP8266 mit deinem Telegram-Bot „sprechen“ lässt. Der Bot wiederum sendet dir daraufhin umgehend eine Benachrichtigung.

In diesem Tutorial auf Pollux Labs lernst du, wie du deinen eigenen Telegram-Bot erstellst.

Das Projekt aufbauen

Der Aufbau auf dem Breadboard geht ganz fix: Du musst nur den Bewegungssensor mit deinem ESP8266 verbinden:

Die Beschriftung der Pins am Sensor siehst du, wenn du die weiße Kappe abhebst. Verbinde den Sensor und deinen ESP8266 wie folgt:

Das war es auch schon mit der Hardware. Werfen wir einen Blick auf den Code.

Der Sketch für den Bewegungsmelder

Nun wird es Zeit für etwas Code. Falls du noch nie einen ESP8266 mit der Arduino IDE verwendet hast: In diesem Tutorial lernst du, wie du deinen ESP8266 in der Arduino IDE verfügbar machen und programmieren kannst.

Die benötigten Bibliotheken

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

Du benötigst insgesamt drei Bibliotheken. Zwei davon sollten bei dir schon vorinstalliert sein: ESP8266WiFi.h und WiFiClientSecure.h – du benötigst sie für die Verbindung zu deinem WLAN-Netzwerk und zum Senden der Daten.

Die Bibliothek UniversalTelegramBot.h übernimmt die Kommunikation mit deinem Telegram-Bot. Du findest sie im Bibliotheksverwalter der Arduino IDE –diese kann jedoch veraltet sein. Deshalb empfehlen wir dir, die Bibliothek hier bei uns herunterzuladen.

Anschließend musst du diese Bibliothek in deinen Sketch einbinden, indem du im Menü der Arduino IDE Sketch -> Bibliothek einbinden -> .ZIP-Bibliothek hinzufügen wählst und die gerade heruntergeladene ZIP-Datei auswählst.

Kopiere dir nun den folgenden Sketch und lade ihn auf deinen ESP8266.

Hinweis: Bevor dein Telegram-Bot Nachrichten empfangen kann, musst du ihn erst aufrufen und auf Start tappen. Das musst du allerdings nur einmal zu Beginn tun.

Sketch als .txt anschauen

/*
   Stiller Alarm mit Telegram - polluxlabs.net
*/

//Bibliotheken
#include <ESP8266WiFi.h>
#include <WiFiClientSecure.h>
#include <UniversalTelegramBot.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 User ID
#define userID "DEINE USERID"

WiFiClientSecure client;
UniversalTelegramBot bot(botToken, client);

const int sensor = 14; // Pin des Bewegungssensors, auf dem ESP Pin D5
bool motion = false;

// Indicates when motion is detected
void IRAM_ATTR detectingMovement() {
  motion = true;
}

//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();

  // Verwendeter Pin
  pinMode(sensor, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(sensor), detectingMovement, RISING);
}

void loop() {

  if (motion == true) {
    connectToWiFi();
    bot.sendMessage(userID, "Hier bewegt sich etwas!", "");
    Serial.println("Bewegung erkannt");
    motion = false;
    WiFi.disconnect();
  }
}

Der Sketch Schritt für Schritt

Schauen wir uns nun ein paar wichtige Teile des Sketchs für deinen Bewegungsmelder genauer an.

Zunächst gibt es einige Daten, die du durch deine eigenen ersetzen musst: Deine WLAN-Zugangsdaten sowie dein Token und deine User ID von Telgram. Trage diese Daten hier ein:

const char* ssid = "DEIN WLAN-NETZWERK";
const char* password = "DEIN PASSWORT";
#define botToken "DEIN TOKEN"
#define userID "DEINE USER ID"

Anschließend erstellst du eine Instanz von WiFiClientSecure names client und ebenso einen bot mit deinem oben definierten botToken und dem client.

WiFiClientSecure client;
UniversalTelegramBot bot(botToken, client);

Jetzt fehlen noch eine Konstante und eine Variable. In ersteren legst du du den Pin fest, an dem der Sensor angeschlossen ist. Hinweis: Die Zahlen auf dem ESP8266 und im Sketch unterscheiden sich. Wenn du den Sensor am Pin D5 angeschlossen hast, entspricht das im Sketch der 14.

Die Variable motion setzt du hier zu Beginn des Sketchs auf false. Diese Variable kann zwei Zustände haben: false, wenn keine Bewegung erkannt wird und true, wenn genau das der Fall ist. Du benötigst also den Datentyp bool, der nur diese zwei Werte annehmen kann.

const int sensor = 14; // Pin des Sensors, am ESP8266 Pin D5
bool motion = false; // Variable für eine erkannte Bewegung

Die Funktionen im Sketch

Jetzt kommt die erste Funktion ins Spiel. Diese Callback-Funktion wird aufgerufen, sobald der Sensor eine Bewegung erkennt und eine 1 (HIGH) an deinen ESP8266 sendet.

Die Funktion macht nichts anderes als die gerade definierte Variable motion auf true zu setzen. Das wiederum setzt die Nachricht an deinen Telegram-Bot in Gang – was wir uns gleich genauer anschauen werden.

void IRAM_ATTR detectingMovement() {
  motion = true;
}

Zunächst steht im Sketch jedoch noch eine weitere Funktion, die deinen ESP8266 mit dem Internet verbindet, sobald eine Bewegung erkannt wurde.

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

  WiFi.begin(ssid, password); //hast du zu Beginn hinterlegt
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(300);
  }
  Serial.println("");
  Serial.println("Verbunden!");
}

Die Setup-Funktion

Auch hier musst du noch ein paar grundlegende Dinge erledigen: Den seriellen Monitor starten, den client konfigurieren und den pinMode für den angeschlossenen Sensor festlegen. 

Mit der Funktion attachInterrupt definierst du die Bewegungsmeldung. Im ersten Parameter steht der Pin, an dem der Sensor angeschlossen ist. Im zweiten, was passieren soll, wenn etwas erkannt wurde: die Funktion detectingMovement() ausführen. Der dritte Parameter definiert, wann das passieren soll – nämlich wenn das Signal am Pin von LOW auf HIGH wechselt.

Genauere Erläuterungen dieser Funktion findest du in der Arduino-Referenz.

void setup() {
  Serial.begin(115200);
  client.setInsecure();
  pinMode(sensor, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(sensor), detectingMovement, RISING);
}

Der Loop

Hier kommt also der entscheidende Teil des Sketches. Der Loop läuft die meiste Zeit, ohne dass er irgendetwas ausführt. Erst wenn der Sensor ein Signal sendet und der Interrupt die Variable motion auf true setzt, wird die Bedinung im If-Statement erfüllt und einiges in Gang setzt.
Zunächst wird die Funktion connectToWiFi() aufgerufen und dein ESP8266 verbindet sich mit dem Internet.

Die Nachricht senden

Anschließend sendet er mit bot.sendMessage() eine Nachricht an deinen Telegram-Bot. 

Das ist sozusagen das Herzstück deines Sketchs. Die Funktion sendMessage() benötigt drei Argumente: 

1. deine userID, die du oben im Sketch eingetragen hast
2. eine Nachricht deiner Wahl als String
3. den Parse Mode – Optional, lassen wir in diesem Projekte leer

Wenn also dein ESP8266 mit dem Internet verbunden ist, sollte nach wenigen Sekunden die Nachricht auf deinem Smartphone erscheinen.

Zuletzt wird die Variable motion wieder auf false gesetzt und die Verbindung zum Internet gekappt.

void loop() {

  if (motion == true) {
    connectToWiFi();
    bot.sendMessage(userID, "Hier bewegt sich etwas!", "");
    Serial.println("Bewegung erkannt");
    motion = false;
    WiFi.disconnect();
  }
}

Danach befindet sich dein Projekt wieder im Ausgangszustand und wartet auf die nächste Bewegung.
Falls noch nicht geschehen, lade den Sketch auf deinen ESP8266 und probiere ihn gleich aus. Und vergiss nicht: Vor dem ersten Test musst du deinen Bot zunächst einmalig starten, indem du auf start tappst.

Feinjustierung des Sensors

Auf der Unterseite des Sensors findest du zwei Potentiometer. Wenn du Sensor umdrehst, sodass die Platine nach oben zeigt, kannst du am linken Potentiometer die Empfindlichkeit einstellen. Experimentiere hiermit etwas, um die optimale Reichweite des Bewegungsmelders einzustellen.

Am rechten Potentiometer lässt sich einstellen, wie lange der Sensor ein HIGH-Signal sendet, bevor er wieder zurückgesetzt wird und neue Bewegungen erkennen kann. Diese Funktion nutzt du in diesem Projekt allerdings nicht, da der Sensor hier einen Interrupt triggert. Wie lange der Sensor das HIGH-Signal sendet, spielt hier keine Rolle.

Wie geht es weiter?

Du hast nun einen Bewegungsmelder, den du als stillen Alarm einsetzen kannst und der dir Nachrichten an deinen Telegram-Bot sendet. Im zweiten Teil dieser Projektserie überwachst du die Temperatur: Sobald ein von dir bestimmter Wert überschritten wurde, erhältst du eine Nachricht aufs Smartphone.

Auf pollux labs haben wir viele Tutorials und Projekte, die sich mit Temperatur- und anderen Sensoren beschäftigen.

Viel Spaß beim Ausprobieren!

Mit diesem Setting kannst du später aufwändigere Projekte bauen, um z.B. das Licht durch Gesten an- und ausschalten zu können.

Anfänger

1 – 2 Stunden

Für dieses Projekt benötigst du:

Einen kostenlosen Account bei Edge Impulse und einen Arduino Nano 33 BLE Sense.

Arduino® Board Nano 33 BLE Sense with headers

Arduino Board Nano 33 BLE Sense with headers; Inhalt: 1 Stück

Vorbereitungen

In unserem Tutorial Gesten erkennen mit dem Sensor APDS9960 haben wir beschrieben, wie du mit dem Arduino Nano 33 BLE Sense Bewegungen nach oben, unten, rechts und links erkennen kannst. Dieser Microcontroller kann aber deutlich mehr!

Du kannst ihn mit ein paar Vorbereitungen mit dem Service von Edge Impulse verbinden und seinen Beschleunigungssensor verwenden, um viel anspruchsvollere Gesten und Muster erkennen zu können.

Lies zunächst nach, wie du deinen Arduino mit Edge Impulse verbindest.

Bewegungsdaten sammeln

Am Anfang jeder künstlichen Intelligenz stehen Daten. Das bedeutet, dass du zunächst Daten zu den Bewegungen sammeln musst, die du später voneinander unterscheiden möchtest.

In diesem Tutorial lernst du, wie du Bewegungsdaten mit dem Arduino Nano 33 BLE Sense sammeln und speichern kannst. Auf dieses Tutorial bauen wir hier auf.

In diesem Projekt nutzt du dieses Wissen und bringst deinem Arduino bei zu erkennen, ob du eine Kreisbewegung ausführst, in der Luft winkst oder – nichts tust. Öffne in Edge Impulse als den Menüpunkt Data acquisition und sammle Samples für die zwei Bewegungen und den Ruhezustand – jeweils circa 3 Minuten.

Achte darauf, dass sich deine Bewegungen innerhalb einer Geste nicht zu sehr unterscheiden. Eine leichte Varianz ist aber normal und auch gut. Wenn du fertig bist, sollte dein Screen ungefähr so aussehen:

Anschließend geht es mit dem Training des KI-Modells weiter.

Einen Impulse entwickeln

Jetzt geht es weiter mit dem nächsten Menüpunkt: Impulse design. Hier entwickelst du aus deinen Rohdaten sogenannte Features, mit denen später deine Bewegungen analysiert und zugeordnet werden können.

Links siehst du die Karte Time series data – hier musst du zunächst nichts einstellen. Klicke stattdessen rechts daneben auf Add a processing block und wähle anschließend den Eintrag Spectral Analysis. Dieser Block eignet sich besonders für Bewegungsdaten.

Wähle eine Karte weiter den Eintrag Neural Network (Keras). Klicke zuletzt auf Save Impulse.

Neben dem Menüpunkt Create impulse sollte nun ein grüner Punkt erscheinen. Klicke nun gleich darunter auf Spectral features und anschließend oben auf Generate features.

Hier gibt es nichts weiter zu tun als auf den Button Generate features zu klicken. Diese Prozedur läuft nun durch und sollte nur wenige Sekunden dauern. Sobald sie abgeschlossen ist, siehst du rechts eine Visualisierung der Features und der Cluster, die sie bilden.

Wie du oben siehst, bilden die verschieden farbigen Punkte eigene Cluster, die voneinander entfernt liegen. Das sollte auch bei deinen Bewegungsdaten der Fall sein. Je besser du die Cluster voneinander unterscheiden kannst, desto besser kann das auch später dein KI-Modell.

Solltest du nur einen Haufen bunter Punkte sehen, gehe noch einmal zurück und sammle weitere oder neue Bewegungsdaten.

Das neuronale Netz trainieren

Edge Impulse hat nun klar definierte Daten und Klassen, die gut voneinander zu unterscheiden sind. Fehlt nur noch ein neuronales Netz, das neue Daten einem dieser Klassen zuordnen kann.

Kurz gesagt, ist ein neuronales Netz nichts anderes als Algorithmen, die versuchen Muster zu erkennen. Auf Wikipedia lernst du mehr über dieses Thema.

Klicke nun im Menü auf den nächsten Punkt NN Classifier.

Belasse die Einstellungen zunächst so wie sie sind und klicke auf den Button Start training. Das nun folgende Training des Netzes sollte wenige Minuten in Anspruch nehmen.

Anschließend erscheint eine neue Karte mit den Ergebnissen. Oben links siehst du unter Accuracy, wie akkurat dein neuronales Netz arbeitet. In unserem Fall kam eine Genauigkeit von 100% heraus, was darauf hoffen lässt, dass die Bewegungen und Gesten richtig erkannt werden.

Wenn du eine niedrigere Genauigkeit erhalten hast, findest du hinter dem Link Model performing poorly? unten rechts Tipps, wie du ein besseres KI-Modell entwickeln kannst.

Ein erster Test der künstlichen Intelligenz

Jetzt wird es spannend: Erkennt deine KI die Bewegungen, die du mit deinem Arduino Nano 33 BLE Sense ausführst, richtig?

Klicke im Menü auf den Punkt Live classification. Hier kannst einen ersten Test starten, indem du auf den Button Start sampling klickst und eine der trainierten Bewegungen ausführst.

Nachdem du das Sample aufgenommen hast, erscheint das Ergebnis. Wir haben eine Kreisbewegung ausgeführt, was die künstliche Intelligenz richtig der Klasse circle zugeordnet hat.

Sollte das bei dir nicht funktioniert haben, gehe am besten wieder ein paar Schritte zurück und versuche bessere Bewegungsdaten zu sammeln oder dein neuronales Netz besser zu trainieren.

Wenn du aber zufrieden bist, wird es Zeit die KI auf deinen Arduino zu bringen.

Die KI auf dem Arduino ausführen

Klicke hierfür auf den Menüpunkt Deployment und wähle unter der Überschrift Build firmware den Arduino Nano 33 BLE Sense.

Du kannst dir auch eine Arduino-Bibliothek erstellen lassen, die du in einen Sketch einbinden kannst. Wir bleiben hier jedoch bei der einfacheren Variante.

Weiter unten hast du auch die Möglichkeit, Optimierungen an deinem KI-Modell vorzunehmen, aber auch diese lassen wir hier erst einmal beiseite.

Klicke als nächstes auf den Button Build. Jetzt wird die Firmware mit deinem KI-Modell erstellt, was wieder einige Minuten dauern kann.

Als nächstes erhältst du eine Zip-Datei mit der Firmware. Führe, je nachdem welches Betriebssystem du verwendest, eine der folgenden Dateien aus:

• flash_windows.bat
• flash-mac.command
• flash_linux.sh

Achte darauf, dass du das Terminal, in dem das Sampling der Daten läuft, vorher schließt und diesen Prozess beendest.

Öffne nach dem Installieren der Firmware ein neues Terminal-Fenster und führe diesen Befehl aus:

edge-impulse-run-impulse

Jetzt läuft deine KI in diesem Terminal und prüft alle zwei Sekunden, ob sie eine Bewegung deines Arduinos erkennt und wenn ja, welche. Hier hat sie mit einer Wahrscheinlichkeit von 96% ein Winken erkannt – was stimmte:

Wie geht es weiter?

Du hast jetzt eine funktionierende künstliche Intelligenz auf deinem Arduino, die komplexe Bewegungen und Gesten erkennen kann.

Gehe einen Schritt weiter und integriere sie in ein neues Projekt, das du mit Gesten steuern kannst. Dein Arduino Nano 33 BLE Sense verfügt auch über ein Mikrofon, das du in Edge Impulse verwenden kannst. Sammle Geräusche und entwickle eine KI, die diese unterscheiden kann. Deiner Fantasie sind keine Grenzen gesetzt!

Edge Impulse ist übrigens nicht der einzige Service, mit dem relativ leicht KI-Modelle erstellen kannst: In diesem Tutorial stellen wir dir Googles Teachable Machine vor.

In diesem Tutorial lernst du, wie du mit dem Beschleunigungssensor des Arduino Nano 33 BLE Sense Bewegungsdaten sammelst und in Edge Impulse speicherst.

Du hast noch keinen Arduino Nano 33 BLE Sense?

Arduino® Board Nano 33 BLE Sense with headers

Arduino Board Nano 33 BLE Sense with headers; Inhalt: 1 Stück

Vorbereitungen

Bevor du anfangen kannst, Daten zu sammeln, musst du zunächst deinen Arduino mit einem Projekt bei Edge Impulse verknüpfen. Wie das funktioniert, erfährst du in diesem Tutorial auf pollux labs.

Wenn die Verbindung steht, siehst du deinen Microcontroller in Edge Impulse unter dem Menüpunkt Devices.

So sammelst du Bewegungsdaten

Jetzt kannst du beginnen, mit dem Beschleunigungssensor Daten zu sammeln, die dann dazu dienen, per maschinellem Lernen ein KI-Modell zu entwickeln.

Wechsle zunächst in den Menüpunkt Data acquisition. Das ist die zentrale Stelle, in der du Daten mit deinem Arduino misst (samplest) und bereitstellst. Rechts siehst du das Feld Collect data. Hier sollte unter Device dein Arduino Nano mit dem Namen auftauchen, den du ihm beim Verbinden gegeben hast.

Wie gesagt, verwendest du in diesem Tutorial den Beschleunigungssensor (engl. accelerometer). Wähle deshalb im Dropdown-Menü Sensor den Eintrag built-in accelerometer.

Daneben befindet sich das Feld Frequency – stelle hier 62.5 Hz ein. Im Feld Sample Rate trägst du 10000 (Millisekunden, also 10 Sekunden) ein.

Fehlt nur noch ein Name für die Samples. Du startest in diesem Tutorial zunächst mit einer Nicht-Bewegung, d.h. du lässt den Arduino Nano 33 BLE Sense während der Datenerfassung einfach ruhig liegen. Damit weiß dein KI-Modell später, was Keine Bewegung ist.

Ein passender Name für diese Art Samples ist auf Englisch idle. Du kannst aber jeden beliebigen Namen nehmen. Er muss für diese Art von Daten aber immer gleich sein.

So ungefähr sollten deine Einstellungen dann aussehen:

Erfasse dein erstes Sample

Jetzt geht es los. Lege deine Arduino ruhig auf den Tisch und klicke auf den Button Start sampling. Edge Impulse misst jetzt 10 Sekunden lang, in welche Richtungen sich dein Arduino entlang der X-, Y- und Z-Achse bewegt. Anschließend wird das Sample gespeichert.

Da du ja keine Bewegung ausgeführt hast, sieht das Ergebnis entsprechend ruhig aus:

Beim maschinellen Lernen gilt das Motto: Je mehr, desto besser. Das bedeutet für dich, dass eine Messung des Ruhezustands nicht ausreicht, um ein akkurates KI-Modell zu entwickeln.

Du solltest für jede Art Bewegung, die dein Modell später erkennen soll, mindestens 3 Minuten Daten bereitstellen. Für den Ruhezustand hast du bereits 10 Sekunden, fehlen also noch 2 Minuten und 50 Sekunden – oder anders gesagt 17 Durchgänge.

Eine echte Bewegung messen

Den Ruhezustand hast du jetzt. Zeit für etwas mehr Bewegung. Ändere den Namen im Feld Label zu wave – denn jetzt kommt Winken an die Reihe.

Nimm deinen Arduino in die Hand und klicke wie gehabt auf Start sampling. Jetzt winke mit dem Arduino, sobald die Messung startet. Anschließend solltest du ungefähr so eine Messbild erhalten:

Hier siehst jetzt ein ganz anderes Bild, dass deutlich eine charakteristische Bewegung anzeigt. Wenn du diese in dein Modell integrieren möchtest, musst du allerdings wieder viele weitere Samples aufnehmen.

Diese Bewegungen unterscheiden sich immer leicht voneinander und so lernt das KI-Modell viele Arten von Winken kennen und später zu unterscheiden.

Probiere noch viele weitere Arten von Bewegungen aus und schau dir die dazugehörigen Schaubilder an.

Wie geht es weiter?

Sobald du eine einigermaßen große Sammlung von Bewegungsdaten hast, kannst du dich an die Entwicklung des KI-Modells machen. In diesem Projekt erfährst du, wie du komplexe Bewegungen und Gesten mit Hilfe von künstlicher Intelligenz erkennst.

Keine Lust auf Edge Impulse? Lerne in diesem Tutorial Googles Teachable Machine kennen.

Daten sammeln mit dem Mikrofon

Mit Edge Impulse kannst du nicht nur Bewegungsdaten ermitteln, sondern auch Geräusche mit dem eingebauten Mikrofon des Arduino Nano 33 BLE Sense aufnehmen. So kannst du z.B. einen laufenden Wasserhahn von einer Kaffemühle unterscheiden.

Das Sampling funktioniert dabei ganz ähnlich wie oben beschrieben. Probiere es doch gleich einmal aus!

Lerne in diesem Tutorial, wie du deinen Arduino Nano 33 BLE Sense bei Edge Impulse verfügbar machst. Wir folgen hierbei weitestgehend dem englischen Leitfaden bei Edge Impulse.

Beachte bitte: Für dieses Tutorial benötigst du einen (kostenlosen) Account bei Edge Impulse und ein bereits angelegtes Projekt, mit dem du deinen Arduino verbinden kannst.

Arduino® Board Nano 33 BLE Sense with headers

Arduino Board Nano 33 BLE Sense with headers; Inhalt: 1 Stück

Benötigte Software

Um mit deinem Arduino Nano 33 BLE Sense bei Edge Impulse starten zu können, musst du zunächst folgende Software auf deinem PC / Mac installieren:

• Node.js v12 oder höher
• Arduino CLI
• Edge Impulse CLI

Aber keine Sorge, die Software ist gratis und normalerweise in wenigen Minuten installiert.

Node.js installieren

Bei Node.js handelt es sich um eine Laufzeitumgebung auf Basis von JavaScript, die Code auch außerhalb von Browsern ausführen kann. Die Software ist open source und funktioniert plattformübergreifend.

Um Node.js zu installieren, besuche die offizielle Webseite und lade dir die aktuelle Version herunter. Führe anschließend die Installation aus und folge den dortigen Anweisungen.

Arduino CLI installieren

Die Abkürzung CLI steht für Command Line Interface – das heißt in diesem Fall, dass du mit der Arduino CLI einen Sketch statt in der Arduino IDE auch über das Terminal kompilieren und hochladen kannst.

Um die Arduino CLI zu installieren, besuche die offizielle Webseite von Arduino. Hier hast du mehrere Möglichkeiten: Mac- und Linux-User können Homebrew verwenden. Wenn du Windows verwendest, oder die benötigten Dateien lieber selbst herunterladen möchtest, findest du diese unter Latest packages.

Nach der erfolgreichen Installation geht es mit dem CLI von Edge Impulse weiter.

Edge Impulse CLI installieren

Dieses Command Line Interface besteht aus mehreren Paketen, die du für die Kommunikation zwischen Arduino und Edge Impulse benötigst.

Öffne für die Installation das Terminal und führe folgenden Befehl aus:

npm install -g edge-impulse-cli

Die Installation sollte in wenigen Minuten abgeschlossen sein. Sollte es zu Problemen kommen, prüfe die Hinweise in der Dokumentation von Edge Impulse (englisch).

Als nächstes verbindest du deinen Arduino Nano 33 BLE Sense mit Edge Impulse, damit du mit dem Sammeln von Sensordaten beginnen kannst.

Den Arduino mit Edge Impulse verbinden

Hierfür sind noch einmal ein paar Schritte und eine Software nötig. Die Verbindung sollte jedoch in wenigen Minuten stehen.

Den Arduino vorbereiten

Verbinde deinen Arduino Nano 33 BLE Sense via USB mit deinem Computer. Drücke jetzt zwei Mal hintereinander den RESET-Button. Jetzt sollte eine gelbe LED dauerhaft leuchten, die dir signalisiert, dass du die benötigte Firmware von Edge Impulse aufspielen kannst.

Die Firmware von Edge Impulse installieren

Noch einmal ist etwas Software nötig für die Verbindung mit Edge Impulse. Diesmal nicht für deinen Computer, sondern für den Arduino selbst. Lade dir hier zunächst die aktuelle Firmware herunter und entpacke die Zip-Datei.

Starte jetzt – je nachdem, welches Betriebssystem (Windows, Mac, Linux) du verwendest – eine der folgenden Installationsdateien. Dein Arduino muss hierfür mit deinem Computer verbunden sein und die LED gelb leuchten.

• flash_windows.bat
• flash-mac.command
• flash_linux.sh

Wenn die Installation durchgelaufen ist, drücke noch einmal den RESET-Button auf deinem Arduino, um die neue Firmware zu booten.

Die Einrichtung abschließen

Alles, was jetzt noch fehlt, ist die Verknüpfung deines Arduinos mit einem deiner Projekte bei Edge Impulse. Starte hierfür im Terminal den Wizard mit folgendem Befehl:

edge-impulse-daemon

Der Wizard führt dich durch alle Schritte. Prüfe anschließend in deinem Projekt bei Edge Impulse, ob die Verbindung steht.

Und das sollte es gewesen sein! Jetzt kannst du mit verschiedenen Sensoren deines Arduinos Daten sammeln und in Edge Impulse zu einem KI-Modell verarbeiten.

Beachte bitte: Dein Arduino Nano ist jetzt grundsätzlich mit Edge Impulse und deinem Projekt dort verbunden. Wenn du ihn zwischenzeitlich jedoch für etwas Anderes verwendest und ihn danach wieder mit Edge Impulse verbinden möchtest, führe den Befehl edge-impulse-daemon wie oben beschrieben erneut aus. Danach steht dir dein Arduino in Edge Impulse wieder zur Verfügung.

Und noch etwas: Möchtest du den Arduino mit einem anderen Projekt in Edge Impulse verknüpfen, musst du die bestehende Verbindung zunächst trennen. Das machst du, indem du im Terminal diesen Befehl ausführst:

edge-impulse-daemon --clean

Der Wizard fragt dich dann nach Username und Passwort von Edge Impulse. Anschließend kannst du direkt im Terminal ein anderes Projekt auswählen.

Wie geht es weiter?

Jetzt, wo du deinen Arduino Nano mit Edge Impulse verknüpft hast, wird es Zeit, dass du ein paar Daten für deine KI sammelst. In diesem Tutorial lernst du, wie du mit dem eingebauten Bewegungssensor des Arduino Nano 33 BLE Sense Bewegungsdaten sammelst und speicherst.

Das alles klingt komplizierter als es ist! Fangen wir mit einem einfachen Test an.

Verbinde zunächst den Sensor MQ-3 wie folgt mit deinem Arduino:

Den Analogpin des MQ-3 auslesen

Um die Analogdaten des Sensors auszulesen und im Seriellen Monitor anzuzeigen, benötigst du nur sehr wenig Code. Kopiere dir den folgenden Sketch und lade ihn auf deinen Arduino. Achte darauf, dass die Baudrate des Sketchs und deines Seriellen Monitors übereinstimmen.

int analogValue = 0;

void setup() {
  Serial.begin(115200);
  pinMode(analogValue, INPUT);
}

void loop() {
  Serial.println(analogRead(analogValue));
  delay(200);
}

Wenn du jetzt deinen Seriellen Monitor öffnest, wirst du einen Haufen stetig fallender Zahlen sehen. Wie eingangs erwähnt, kannst du anhand dieser Zahlen noch keine Aussage über den Ethanolgehalt in der Luft treffen.

Stattdessen musst den Sensor einige Minuten in „frischer“ Luft stehen lassen und warten, bis sich die Zahlen auf einen Wert einpendeln. Dieser Wert zeigt dir dann an, dass der Sensor gerade kein Ethanol misst. Ist das jedoch der Fall, springt der Wert hoch – der Abstand zum Referenzwert ermöglicht dir dann eine vage Aussage über die Menge an Alkohol in der Luft.

Bei unserem Test hat sich der „Frischluft-Wert“ des MQ-3 nach einigen Minuten auf circa 100 eingependelt. Dieser Wert kann jedoch bei dir anders sein.

Wenn du jetzt z.B. eine offene Flasche Gin an den Sensor hältst, wirst du sehen, wie der Wert in deinem Seriellen Monitor steigt. Bei uns ging er hoch bis auf knapp 300.

Über den Analogpin des MQ-3 erhältst du also den relativen Wert des Alkoholgehalts in der Umgebungsluft. In deinem Sketch kannst du einen Schwellenwert festlegen, bei dessen Überschreiten etwas passieren soll – z.B. eine LED aufleuchtet.

Du kannst diesen Schwellenwert jedoch auch direkt am Sensor einstellen und seine Überschreitung vom Digitalpin des MQ-3 auslesen.

So verwendest du den Digitalpin des MQ-3

Für einen ersten Test reicht wieder ein ganz simpler Sketch aus. Lade den folgenden Code auf deinen Arduino:

int digitalValue = 2;

void setup() {
  Serial.begin(115200);
  pinMode(digitalValue, INPUT);
}

void loop() {
  Serial.println(digitalRead(digitalValue));
  delay(200);
}

In deinem Seriellen Monitor solltest du statt den Analogwerten vom ersten Test jetzt entweder eine 0 oder eine 1 sehen. Auch beim Verwenden des Digitalpins musst du den Sensor zunächst ein paar Minuten in Betrieb nehmen und ruhen lassen, bis er „weiß“, was Frischluft bedeutet.

Wenn du das getan hast, widmest du dich der Rückseite des MQ-3: Hier findest du ein Potentiometer, das du mit einem Schraubendreher einstellen kannst. Drehe die Schraube so weit, bis die Zahl in deinem Seriellen Monitor gerade auf die 1 springt und so bleibt.

Wiederhole jetzt den Test mit einer Flasche Alkohol und du wirst sehen, dass die Anzeige auf 0 springt.

Wie geht es weiter?

Wie zu Beginn gesagt, eignet sich der Sensor MQ-3 auf keinen Fall, um einzuschätzen, wie viel Alkohol jemand getrunken hat und welche Konsequenzen daraus zu ziehen sind.

Aber für ein paar Spielereien eignet er sich sehr wohl. Du könntest den Analogpin auslesen und dir eine Art Ampelsystem bauen, das je nach Abstand zum Frischluftwert verschieden viele LEDs auf einem NeoPixel-Ring aufleuchten lässt.

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.

In diesem Projekt lernst du, wie du ein einfaches Arduino Theremin mit einem Piezo-Summer und dem Ultraschall-Sensor HC-SR04 baust. Aber nicht nur das – damit auch ungeübte Musiker ihre Freunde begeistern können, spielt dieses Theremin nur Töne innerhalb einer von dir festgelegten Tonleiter.

Im Folgenden verwenden wir die beliebte A-Moll Pentatonik als Beispiel. Du kannst aber auch jede andere Tonleiter definieren und verwenden. Mehr dazu später.

Anfänger

1 – 2 Stunden

ca. 10 € plus ggfs. Kosten für den Arduino Uno

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

Arduino UNO Rev3 [A000066] - Vielseitiges Entwicklungsboard mit ATmega328P-Mikrocontroller, kompatibel IDE, ideal f�r Einsteiger und Elektronik-, Robotik- und DIY-Projekte.

28,51 €

AZDelivery Ultraschall Modul Kompatibel mit HC-SR04 Entfernungsmesser Sensor kompatibel mit Arduino und Raspberry Pi inklusive E-Book!

Ultraschall Entfernungsmessung von 2 cm bis zu 3 m auf ca. 3 mm genau; Maße...

5,29 €

AZDelivery KY-006 Passives Piezo Buzzer Alarm Modul kompatibel mit Arduino und Raspberry Pi inklusive eBook!

Piezoelektrischer Buzzer (passiv); Betriebsspannung 5 V

4,49 €

AZDelivery Breadboard Kit - 3X Jumper Wire m2m/f2m/f2f + 3er Set MB102 Breadboard kompatibel mit Raspberry Pi inklusive E-Book!

Steckbrett für schnellen Aufbau elektronischer Schaltungen mit 830 Kontakten.; ...

10,99 €

Der Aufbau des Arduino Theremins

Du musst nur zwei Bauteile auf deinem Breadboard montieren und mit deinem Arduino verbinden: Den Piezo-Summer und den Ultraschall-Sensor. Ersteren verbindest du mit dem Digitalpin 3 und mit Erde. Beim Ultraschall-Sensor verbindest du zunächst VCC mit Plus und GND mit Minus. Anschließend verbindest du den Ausgang TRIG mit dem Digitalpin 5 und ECHO mit dem Digitalpin 4 an deinem Arduino.

So funktioniert dein Theremin

Dieses Projekt funktioniert eigentlich ganz simpel: Der Ultraschall-Sensor HC-SR04 misst die Entfernung zu einem Objekt, z.B. zu deiner Hand. Diese Entfernung rechnest du in Tonhöhen um, die du über den Piezo-Summer ausgibst.

Da hier natürlich alle möglichen Entfernungen in einem bestimmten Bereich möglich sind, gibt es auch alle möglichen Töne – auch welche, die in klassischen Tonleitern nicht vorkommen. Deshalb sucht sich der folgende Sketch immer den nächsttieferen Ton in der A-Moll Pentatonik heraus. So spielst du kinderleicht ansprechende Melodien!

Der passende Sketch für Musiker

Zunächst legst du ein paar Variablen fest, die du später mit Leben füllst:

//Arduino Pins für den Ultraschall-Sensor
int trigger = 5;
int echo = 4;
int distance = 0;

//Pin des Piezo-Summers
const int piezo = 3;

//Variablen für die Bestimmung der Reichweite
int distance = 0;
int distanceHigh = 0;

//Variable für die Anzahl der Töne in der Tonleiter
int lengthOfScale = 0;

//Variable für die zu spielende Note
int note = 0;

Danach folgt ein Array, in dem die Töne der A-Moll Pentatonik stecken – genauer gesagt, welche Frequenzen (in Hertz) du mit deinem Piezo-Summer ausgibst. Das sind immer wieder die Töne A – C – D – E – G in verschiedenen Oktaven.

int scale[] = {
  147, 165, 196, 220, 262, 294, 330, 392, 440,
  523, 587, 659, 784, 880, 1047, 1175, 1319, 1568,
  1760, 2093, 2349
};

Auf Github findest du eine mehr oder weniger vollständige Liste aller Töne und ihrer Frequenzen.

Die Setup-Funktion

Hier startest du zunächst den Seriellen Monitor und legst die PinModes für die Pins des Ultraschall-Sensors fest. Dann kommt der erste interessante Teil des Sketchs: Dein Sensor hat eine theoretische Reichweite von 2cm bis 4m – die Reichweite, in der du spielst, wird aber vermutlich geringer sein.

Deshalb kalibrierst du den Sensor in den ersten fünf Sekunden nach dem Start. Das heißt, du bestimmst, wie weit weg deine Hand vom Sensor sein wird. Hierfür bewegst du deine Hand vor dem Sensor langsam circa 40-50cm weg. Die größte Entfernung speicherst du dann in die Variablen distanceHigh. Diese benötigst du später wieder.

void setup() {
  Serial.begin (9600);
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);

  while (millis() < 5000) {

    //Der Sensor misst die Entfernung
    digitalWrite(trigger, HIGH);
    digitalWrite(trigger, LOW);
    distance = pulseIn(echo, HIGH);
    Serial.println(distance);

    //Größte Entfernung speichern
    if (distance > distanceHigh) {
      distanceHigh = distance;
    }
  }
}

Hinweis: Um genau zu sein, misst der HC-SR04 nicht direkt die Entfernung, sondern nur wie lange ein ausgesendetes Ultraschall-Signal benötigt, um von einem Hindernis (deine Hand) wieder im Sensor einzutreffen. In diesem Tutorial erfährst du, wie du die Entfernung in cm messen kannst.

Jetzt musst du noch ermitteln, wie viele Töne sich in der Tonleiter, also im Array scale[] befinden. Das machst du folgendermaßen:

for (byte i = 0; i < (sizeof(scale) / sizeof(scale[0])); i++) {
  lengthOfScale += 1;
}

Der Loop

Hier spielt die Musik. Im Loop lässt du deinen Ultraschall-Sensor immer wieder die Entfernung zu deiner Hand messen. Je nachdem wie weit sie von ihm entfernt ist, erklingt ein anderer Ton. Zentral ist hierbei folgende Funktion:

note = map(distance, 250, distanceHigh, scale[0], scale[lengthOfScale - 1]);

Mithilfe der Funktion map() kannst du eine Zahl aus einem Bereich einem anderen Bereich zuordnen. In diesem Projekt „mapst“ du die aktuelle Entfernung deiner Hand (distance) auf eine bestimmte Tonfrequenz.

Hierfür sind zwei Bereiche notwendig: Die aktuelle Entfernung deiner Hand liegt im Bereich der minimalen (legst du auf 250 fest) und maximalen (distanceHigh) Entfernung deiner Hand, die du in der Kalibrierung zu Beginn festgelegt hast. Der zweite Bereich wird vom tiefsten Ton (also die Position 0 im Array scale[]) und dem höchsten Ton (ermittelst du mit scale[lengthOfScale – 1]) deiner Pentatonik im Array scale[] begrenzt.

Die Entfernung deiner Hand wird also in unserem konkreten Fall einer Zahl zwischen 147 und 2349 zugeordnet und in der Variablen note gespeichert.

In der Arduino-Referenz erfährst du mehr über die Funktion map().

Den richtigen Ton treffen

Bis jetzt hast du nur einen Frequenzbereich, in der die Note liegt. Dein Arduino Theremin soll aber keine ungenauen Zwischentöne spielen, sondern nur Noten der A-Moll Pentatonik. Hierfür benötigst du einen Loop und ein paar Abfragen:

    for (byte j = 0; j < (lengthOfScale); j++) {

    if (note == scale[j]) {
      tone(piezo, note);
      break;
    }
    else if (note > scale[j] && note < scale[j + 1]) {
      note = scale[j];
      tone(piezo, note);
      break;
    }
  }

Im For-Loop fragst du für jede Note des Arrays scale[] ab, ob du deine Hand schon in der richtigen Entfernung und die Note somit genau getroffen hast. In diesem Fall spielst du sie über die Funktion tone() mit deinem Piezo-Summer ab.

Falls nicht, fragst du im ersten else if, ob dein gespielter Ton zwischen zwei Noten steckt. Wenn das so ist, spielst du einfach die niedrigere von beiden.

Zu kompliziert? Ein Beispiel: Deine Hand hat eine Entfernung zum Sensor, die du mithilfe der Funktion map() auf eine Frequenz von 200 Hertz umgerechnet hast. Das ist aber keine Note der A-Moll Pentatonik, sondern liegt irgendwo zwischen einem G und einem Gis. Der nächsttiefere, richtige Ton ist laut deinem Array ein G mit 196 Hertz. Und den spielt dein Theremin dann.

Und das war’s! Schalte dein Arduino Theremin ein, kalibriere es und lass die Fetzen fliegen.

Hier nun der gesamte Sketch:

/*
   Arduino Theremin with A minor pentatonic scale
   pollux labs, 2020
   All rights reserved.
*/

const int trigger = 5;
const int echo = 4;

const int piezo = 3;

int distance = 0;
int distanceHigh = 0;

int lengthOfScale = 0;

int note = 0;

//A Minor pentatonic scale
int scale[] = {
  147, 165, 196, 220, 262, 294, 330, 392, 440,
  523, 587, 659, 784, 880, 1047, 1175, 1319, 1568,
  1760, 2093, 2349
};

//C Major scale
//int scale[] = {
//  131, 147, 165, 175, 196, 220, 247, 262, 294,
//  330, 349, 392, 440, 494, 523, 587, 659, 698,
//  784, 880, 988, 1047
//};


void setup() {
  pinMode(trigger, OUTPUT);
  pinMode(echo, INPUT);

  while (millis() < 5000) {
    digitalWrite(trigger, HIGH);
    digitalWrite(trigger, LOW);
    distance = pulseIn(echo, HIGH);

    if (distance > distanceHigh) {
      distanceHigh = distance;
    }
  }

  for (byte i = 0; i < (sizeof(scale) / sizeof(scale[0])); i++) {
    lengthOfScale += 1;
  }
}

void loop() {
  digitalWrite(trigger, HIGH);
  digitalWrite(trigger, LOW);

  distance = pulseIn(echo, HIGH);

  note = map(distance, 250, distanceHigh, scale[0], scale[lengthOfScale - 1]);

  for (byte j = 0; j < (lengthOfScale); j++) {

    if (note == scale[j]) {
      tone(piezo, note);
      break;
    }
    else if (note > scale[j] && note < scale[j + 1]) {
      note = scale[j];
      tone(piezo, note);
      break;
    }
  }
  delay(30);
}

In erster Linie reagiert dieser Sensor auf Wärme in Form von Infrarotstrahlen. Damit nicht die Heizung das Licht einschaltet, reagiert der Bewegungsmelder nur auf warme Objekte, die sich bewegen. Hierfür ist eine sogenannte Fresnel-Linse (die „Kuppel“) über dem eigentlichen Sensor verbaut.

Den Bewegungsmelder anschließen

Der Anschluss des HC-SR501 ist ganz simpel. Gerade einmal drei Pins benötigst du hierfür: Plus (VCC), Minus (GND) und OUT. Letzteren schließt du an einen Digitalpin deines Arduinos an. Sobald dein Sensor eine Bewegung erkennt, sendet er ein HIGH an den Arduino, das du in deinem Sketch auslesen kannst.

An der Unterseite des Bewegungsmelders findest du zwei Potentiometer. Drehe den Sensor um, sodass die Platine nach oben zeigt. Am linken Potentiometer kannst du die Empfindlichkeit des Sensors einstellen; am rechten die Länge, des Signals, das an deinen Arduino gesendet wird. Stellst du hier eine lange Zeitspanne ein, hält der Bewegungsmelder den „Alarm“ damit in dieser Zeit kann keine weitere Bewegung erkannt werden kann. Das ist praktisch, wenn du nicht möchtest, dass ein und dieselbe Bewegung mehrere Signale sendet.

Der passende Sketch

Für diesen Sketch haben wir eine LED an den Digitalpin 9 angeschlossen. Diese leuchtet auf, sobald eine Bewegung erkannt wurde. Der Bewegungsmelder hängt am Digitalpin 7.

Neben den Einstellungen und Angaben für die verwendeten Pins benötigst du nur eine Variable und eine IF-Abfrage:

status = digitalRead(sensor);

if (status == HIGH){
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}

Den Wert, den der Bewegungsmelder ausgibt, speicherst du in die Variable status – liegt keine Bewegung vor, ist dieser Wert 0. Wenn sich etwas vorm Sensor bewegt entsprechend 1.

Anschließend lässt du die LED bei einer Bewegung aufleuchten. Wenn dein Bewegungsmelder wieder auf Null umschaltet – weil er keine Bewegung erkennt – geht sie wieder aus. Das war’s.

Hier der vollständige Sketch:

int led = 9;
int sensor = 7;
int status = 0;

void setup(){
pinMode(led, OUTPUT);
pinMode(sensor, INPUT);
}

void loop(){

status = digitalRead(sensor);

if (status == HIGH){
digitalWrite(led, HIGH);
} else {
digitalWrite(led, LOW);
}
}

Wie geht es weiter?

Jetzt wo du weißt, wie du den Bewegungsmelder HC-SR501 richtig anschließt und verwendest, kannst du dich an ein richtiges Projekt machen. Wie wäre es z.B. mit dem Klassiker – ein Licht, das angeht, sobald du einen Raum betrittst?

In diesem Projekt baust du dir einen stillen Alarm, der dir per Telegram eine Nachricht an dein Smartphone sendet.

Diese Art von Bewegungsmelder ist übrigens nicht die einzige: In diesem Projekt verwendest du einen Mikrowellen-Radar, um herauszufinden, ob du einen Regenschirm benötigst.

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

29,71 €

Bei Amazon kaufen

Bestseller Nr. 2

Hailege MLX90614 berührungsloses Infrarot-Temperatursensormodul IIC I2C 3-5V für Arduino 51 MCU

• Sowohl der IR-empfindliche Thermopile-Detektorchip als auch der Signalkonditionierungs-ASIC sind in derselben TO-39-Dose integriert.
• MLX90614 berührungsloses Infrarot-Temperatursensormodul
• In das MLX90614 integriert sind ein rauscharmer Verstärker, ein 17-Bit-ADC und eine leistungsstarke DSP-Einheit, wodurch eine hohe Genauigkeit und Auflösung des Thermometers erreicht wird.
• Der Benutzer kann den digitalen Ausgang als Pulsweitenmodulation (PWM) konfigurieren. Standardmäßig ist die 10-Bit-PWM so konfiguriert, dass sie die gemessene Temperatur kontinuierlich im Bereich von -20 bis 120 °C mit einer Ausgangsauflösung von 0,14 °C überträgt.
• Wir bieten die Konformitätserklärung an. Dieses Produkt enthält auch ein elektronisches Benutzerhandbuch, das in Englisch, Deutsch, Französisch, Spanisch, Italienisch, Polnisch und Niederländisch verfügbar ist. Wenn Sie Unterstützung benötigen, kontaktieren Sie uns bitte.

16,49 €

Bei Amazon kaufen

Bestseller Nr. 3

TECNOULAB 2 Stück GY-906 MLX90614 MLX90614ESF berührungsloses Infrarot-Temperatursensormodul

• 【GY906】 GY-906 MLX90614 MLX90614ESF IIC I2C berührungsloses Infrarot-Temperatursensormodul
• 【Kompaktes Design】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 Anschlussplatine mit allen für den Betrieb notwendigen Komponenten und zwei Arten von Pins geliefert. Sie sind nicht geschweißt.
• 【Einfache Bedienung】Kleine Größe, niedrige Kosten; Auf einer Breakout-Platine mit zwei Arten von Stiften montiert; 10k-Pull-up-Widerstände für I2C-Schnittstelle mit optionalen Lötbrücken; Einfach zu integrieren. Messauflösung von 0,02 GRAD.
• 【Beschreibung】Werkseitig über einen weiten Temperaturbereich kalibriert: -40...+125 C für Sensortemperatur und -70...+380 C für Objekttemperatur. Hohe Genauigkeit von 0,5 °C über einen weiten Temperaturbereich (0 bis +50 °C für Ta und To). Hochpräzise Kalibrierung (medizinisch).
• 【Hohe Leistung】SMBus-kompatible digitale Schnittstelle; Anpassbarer PWM-Ausgang für kontinuierliches Lesen; Einfache Anpassung für 8...16 V-Anwendungen. Schlafmodus zur Reduzierung des Stromverbrauchs; Verschiedene Paketoptionen für Anwendungen und Messvielseitigkeit; Automobilqualität

31,55 €

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.

Aufbau & Funktion

Der Sensor HC-SR04 ist schnell aufgebaut und angeschlossen:

Versorge ihn am Pin VCC von deinem Arduino aus mit 5V und lege die Erde an Gnd.

Dann verbindest du einen Digitalausgang mit dem Trigger (Trig am Sensor) und einen weiteren mit dem Pin Echo.

Der Ultraschallsensor funktioniert ganz simpel: Er bekommt ein Signal (oder eben Trigger) und sendet eine Ultraschallwelle aus. Diese wird dann von dem Objekt oder Hindernis vor dem Sensor reflektiert und vom HC-SR04 wieder empfangen.

Dein Arduino misst nur die Zeit, die zwischen Senden und Empfangen vergangen ist. In deinem Code rechnest du diese Zeitspanne dann in die Entfernung um. Fertig!

Übrigens: Mit dem Sensor kannst du Entfernungen zwischen 2cm und circa 4 Metern messen – ein ganz schönes Stück also.

Hier findest du ein Datenblatt zum HC SR04.

Der Code für den HC-SR04

Du musst nicht viel programmieren, um den HC-SR04 in Gang zu setzen.

Definiere erst einmal ein paar Variablen:

int trigger=7; 
int echo=6; 
long zeit=0; 
long entfernung=0; 

Hier legst du zunächst fest, dass die Sensorpins Trig und Echo am Arduino mit den Digitalpins 6 und 7 verbunden sind.

Außerdem brauchst du eine Variable für die Zeit, die zwischen Senden und Empfangen verstrichen ist und eine weitere für die Entfernung, die du hieraus berechnest.

In der Setup-Funktion startest du den Seriellen Monitor und legst die pinModes fest: Der Trigger ist ein OUTPUT, das Echo ein INPUT:

void setup(){
Serial.begin (9600); 
pinMode(trigger, OUTPUT); 
pinMode(echo, INPUT);}

Die Entfernung messen

Jetzt geht es ans Eingemachte. Du startest die Messung mit einer Schallwelle, misst die Zeit bis zu ihrer Rückkehr zum Sensor und berechnest die Entfernung.

void loop(){

digitalWrite(trigger, HIGH); 
delay(10);
digitalWrite(trigger, LOW);

zeit = pulseIn(echo, HIGH); 

entfernung = (zeit/2) * 0.03432;

Serial.print(entfernung); 
Serial.println(" cm"); 

delay(1000);}

Zunächst setzt du den Trigger für 10 Millisekunden auf HIGH und anschließend wieder auf LOW. Damit sendest du die Schallwelle aus.

Mit der Funktion pulseIn() misst du die Zeit, bis die Schallwelle wieder im Sensor eintrifft und speicherst diese in der Variable zeit.

Mit der Variable entfernung machst du folgendes: Du teilst zunächst die vergangene Zeit durch 2 – denn du möchtest ja nur die Wegstrecke vom Sensor bis zum Hindernis messen. Anschließend multiplizierst du diese Zeit mit der Schallgeschwindigkeit in Zentimeter pro Mikrosekunde.

Nun gibst du nur noch die berechnete Entfernung in deinem Seriellen Monitor aus und limitierst die Messungen per delay() auf eine pro Sekunde.

Hier kommt der vollständige Code:

int trigger=7; 
int echo=6; 
long zeit=0; 
long entfernung=0; 

void setup(){
Serial.begin (9600); 
pinMode(trigger, OUTPUT); 
pinMode(echo, INPUT); 
}

void loop(){
digitalWrite(trigger, HIGH); 
delay(10);
digitalWrite(trigger, LOW);

zeit = pulseIn(echo, HIGH); 

entfernung = (zeit/2) * 0.03432; 

Serial.print(entfernung); 
Serial.println(" cm"); 

delay(1000);
}

In welchen Projekten kannst du den Ultraschallsensor HC SR04 verwenden? Zum Beispiel in einem Fahrzeug, das Hindernissen ausweichen kann. Oder doch nur ganz einfach, um den Abstand zu einem Objekt zu messen.

In diesem Projekt lernst du, wie du dein eigenes Arduino Theremin baust. Oder doch ein anderer Sensor? Hier lernst du auch, wie du mit dem VL52L0X am Arduino Entfernungen misst.

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.

Aufbau des Sound Sensors

Die wichtigsten Bauteile des Geräuschsensors, den du hier kennenlernst, sind: das Mikrofon, ein Komparator (hier der LM393, der zwei Spannungen miteinander vergleicht) und ein Potentiometer (um den Schwellenwert einzustellen). Du schließt den Sensor über mindestens 3 der 4 Pins an – Anode, Kathode, Analog- und/oder Digitalausgang.

Anschluss am digitalen Ausgang

Du kannst den Sound Sensor auf zwei Arten an deinem Arduino Board anschließen – analog oder digital. Der digitale Anschluss ist sinnvoll, wenn du etwas in Gang setzen möchtest, sobald ein lautes Geräusch erkannt wird. Das könnte zum Beispiel ein Klopfen an der Tür, oder ein Knall sein. So schließt du deinen Sensor an:

Versorge deinen Sensor wie vorgesehen mit Strom und schließe den digitalen Ausgang (DO) am Arduino am digitalen Eingang 2 an. Der Sensor selbst besitzt schon eine LED, die anzeigt, wenn ein Geräusch empfangen wurde. Spaßeshalber kannst du aber auch noch selbst eine LED installieren, wie ich auf dem Foto.

Lade jetzt den folgenden Sketch auf deinen Arduino und schon kann es losgehen.

int sensor = 2;
int LED = 12;
int noise  = 0;

void setup() {

pinMode(sensor, INPUT);
pinMode(LED, OUTPUT);

}

void loop() {

noise = digitalRead(sensor);

if (noise == 1){
  digitalWrite(12, HIGH);
}else{
  digitalWrite(12, LOW);
  }
}

Sollte deine LED jetzt dauerhaft brennen, bedeutet das, dass der Sensor durchgehend ein Geräusch erkennt. Nimm jetzt einen kleinen Schraubendreher zur Hand und drehe die Schraube am Potentiometer nach links – solange bis die LED ausgeht.

Jetzt mache direkt neben dem Mikrofon ein lautes Geräusch – schnippe zum Beispiel mit den Fingern. Die LED sollte kurz aufleuchten. Falls nicht – drehe die Schraube wieder leicht nach rechts. Mit etwas Fingerspitzengefühl findest du die richtige Feinjustierung.

Und jetzt der analoge Ausgang

Wenn du den Sound Sensor analog anschließt, erhältst du in Echtzeit ein Feedback zur Lautstärke. So kannst du zum Beispiel eine LED aufleuchten lassen, sobald eine bestimmte Lautstärke überschritten wird.

Verbinde den Sensor hierfür vom analogen Ausgang (AO) mit dem analogen Eingang A0 am Arduino. Lade nun folgenden Sketch hoch.

int sensor = A0;
int LED = 12;
int noise  = 0;

void setup() {

Serial.begin(9600);

pinMode(sensor, INPUT);
pinMode(LED, OUTPUT);

}

void loop() {

noise = analogRead(sensor);

Serial.println(noise);

if (noise > 200){
  digitalWrite(12, HIGH);
}else{
  digitalWrite(12, LOW);
  }
}

Um die Lautstärke besser verfolgen zu können, starten wir den Seriellen Monitor und lassen die die Werte des Sensors dort ausgeben. Auch hier ist wieder etwas Feinjustierung nötig. Stelle das Potentiometer so ein, dass du im seriellen Monitor Werte siehst, du etwas unter 200 liegen. Wenn du jetzt ein Geräusch machst, das laut genug ist, dass der Wert über 200 schnellt, sollte die LED aufleuchten.

Du siehst also, es reicht hier nicht, dass ein Geräusch erkannt wird. Dieses Geräusch muss auch noch laut genug sein, um die LED anzuschalten.

Für welche Projekte der digitale und analoge Anschluss der richtige sein könnte, überlasse ich dir. Sicherlich findest du eine spannende Anwendung!

Weiter Anleitungen zu Bauteilen und vollständige Arduino Projekte findest du in unserem Buch für angehende Maker:

Vom Anfänger zum Maker: Mit dem Arduino und ESP8266

• Kumbartzki, Frederik (Autor)

Bei Amazon kaufen

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.