Modulbild

Raspberry Pi

lock
Bevorstehend

Projektideen mit Raspberry Pi

Ziele dieses Moduls
Keine Ziele hinterlegt.

In diesem Projekt verwandelst du einen Raspberry Pi in eine WLAN-Wetterstation. Er wird Temperatur und Luftfeuchtigkeit messen und diese Daten dann über dein Schul-WLAN oder ein eigenes Hotspot-Netzwerk auf einer einfachen Webseite anzeigen, die du selbst programmierst. So kannst du die aktuellen Wetterdaten jederzeit von deinem Smartphone, Tablet oder einem anderen Computer im selben Netzwerk abrufen!

Dieses Projekt vermittelt dir wichtige Kenntnisse in:

  • Linux-Grundlagen: Umgang mit der Kommandozeile.

  • Python-Programmierung: Daten von Sensoren auslesen.

  • Webentwicklung-Grundlagen: Eine einfache Webseite erstellen (HTML, CSS).

  • Netzwerktechnik: Einen einfachen Webserver betreiben und über WLAN darauf zugreifen.

  • Datenverarbeitung: Daten sammeln und visualisieren.

1. Was du brauchst:

  • Hardware:

    • Ein Raspberry Pi (Modell 3B+, 4 oder Zero W sind ideal wegen WLAN).

    • Ein Netzteil für den Raspberry Pi.

    • Eine microSD-Karte (mind. 8GB, besser 16GB oder 32GB).

    • Ein DHT11 oder DHT22 Temperatur- und Feuchtigkeitssensor (DHT11 ist einfacher, DHT22 genauer).

    • Jumper-Kabel (männlich-weiblich) zum Verbinden des Sensors mit dem Raspberry Pi.

    • Ein Breadboard (optional, aber hilfreich für den Sensoranschluss).

    • Ein Monitor, Tastatur und Maus für die Ersteinrichtung des Raspberry Pi (danach kannst du per SSH zugreifen).

  • Software:

    • Raspberry Pi Imager (für deinen Computer).

    • Raspberry Pi OS Lite (64-bit) oder Raspberry Pi OS Full (64-bit) (wenn du eine grafische Oberfläche bevorzugst).

    • Ein Texteditor (z.B. Thonny auf dem Pi, oder VS Code auf deinem Computer).

    • Python 3 (ist standardmässig auf Raspberry Pi OS installiert).

2. Schritt für Schritt: Deine Wetterstation bauen

Schritt 1: Raspberry Pi vorbereiten (Betriebssystem installieren)

  1. Lade den Raspberry Pi Imager auf deinen Computer herunter und installiere ihn.

  2. Starte den Imager.

  3. Wähle unter "BETRIEBSSYSTEM WÄHLEN" das "Raspberry Pi OS Lite (64-bit)" (empfohlen, da es keine grafische Oberfläche hat und weniger Ressourcen verbraucht) oder "Raspberry Pi OS Full (64-bit)".

  4. Wähle unter "SPEICHER WÄHLEN" deine microSD-Karte aus.

  5. Klicke auf das Zahnrad-Symbol (Einstellungen), bevor du auf "SCHREIBEN" klickst:

    • Aktiviere SSH und setze ein sicheres Passwort.

    • Konfiguriere das WLAN (SSID und Passwort deines Schul-WLANs oder eines Hotspot-Netzwerks).

    • Setze die Sprache und Tastaturbelegung auf Deutsch.

  6. Klicke auf "SCHREIBEN" und warte, bis der Vorgang abgeschlossen ist.

  7. Entferne die microSD-Karte sicher aus deinem Computer und stecke sie in den Raspberry Pi.

Schritt 2: Sensor anschliessen

Der DHT11/DHT22 Sensor hat typischerweise 3 Pins: VCC (Strom), GND (Masse) und Data (Daten).

  1. Schalte den Raspberry Pi aus und trenne ihn vom Strom.

  2. Verbinde die Pins des DHT11/DHT22 Sensors mit den GPIO-Pins des Raspberry Pi:

    • VCC des Sensors an 3.3V (Pin 1) des Raspberry Pi.

    • GND des Sensors an GND (Pin 6) des Raspberry Pi.

    • Data des Sensors an einen beliebigen GPIO-Pin (z.B. GPIO4 / Pin 7).

    • Optional: Ein 10k Ohm Pull-up-Widerstand zwischen Data und VCC wird oft empfohlen, ist aber bei vielen DHT-Breakout-Boards schon integriert.

    www.electronicwings.com

Schritt 3: Python-Skript zum Auslesen des Sensors

Wir verwenden eine Python-Bibliothek, um den Sensor auszulesen.

  1. Schalte den Raspberry Pi ein. Warte, bis er gestartet ist.

  2. Verbinde dich per SSH mit dem Raspberry Pi von deinem Computer aus (z.B. mit PuTTY unter Windows oder dem Terminal unter Linux/macOS): ssh pi@<IP-Adresse-deines-Pi> (Die IP-Adresse findest du in deinem Router oder mit Tools wie nmap).

  3. Installieren der benötigten Bibliotheken:

    sudo apt update
sudo apt install python3-pip libgpiod-dev
pip3 install adafruit-circuitpython-dht

  4. Erstelle eine neue Python-Datei:

    nano sensor_reader.py

  5. Füge den folgenden Python-Code ein:

    import adafruit_dht
import board
import time
import json
import sys
import os
import subprocess

# Pin-Definition für den DHT-Sensor (hier GPIO4)
# Wenn du einen anderen GPIO-Pin verwendest, ändere board.D4 entsprechend
dht_device = adafruit_dht.DHT11(board.D4) # Für DHT11
# dht_device = adafruit_dht.DHT22(board.D4) # Für DHT22

def read_sensor_data():
    try:
        temperature_c = dht_device.temperature
        humidity = dht_device.humidity
        if temperature_c is not None and humidity is not None:
            return {"temperature": temperature_c, "humidity": humidity}
        else:
            return {"error": "Failed to retrieve data from DHT sensor. Try again."}
    except RuntimeError as error:
        # Fehler beim Lesen des Sensors
        return {"error": f"DHT sensor error: {error.args[0]}"}
    except Exception as error:
        # Andere unerwartete Fehler
        return {"error": f"An unexpected error occurred: {error}"}

if __name__ == "__main__":
    # Beispiel: Daten einmal lesen und ausgeben
    data = read_sensor_data()
    print(json.dumps(data)) # Ausgabe als JSON

  6. Speichere die Datei (Strg+X, Y, Enter).

  7. Teste das Skript:

    python3 sensor_reader.py

    Du solltest die Temperatur und Luftfeuchtigkeit als JSON-Objekt sehen.

Schritt 4: Webserver und HTML-Dashboard erstellen

Wir erstellen eine einfache HTML-Datei für das Dashboard und einen Python-Webserver, der diese Datei ausliefert und die Sensordaten bereitstellt.

  1. Erstelle ein Verzeichnis für deine Webseite:

    mkdir ~/web_dashboard
cd ~/web_dashboard

  2. Erstelle die HTML-Datei index.html:

    nano index.html
```html
<!DOCTYPE html>
<html lang="de">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Raspberry Pi Wetterstation</title>
    <script src="[https://cdn.tailwindcss.com](https://cdn.tailwindcss.com)"></script>
    <link href="[https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap](https://fonts.googleapis.com/css2?family=Inter:wght@400;600;700&display=swap)" rel="stylesheet">
    <style>
        body { font-family: 'Inter', sans-serif; background-color: #f0f4f8; color: #334155; display: flex; justify-content: center; align-items: center; min-height: 100vh; margin: 0; }
        .container { background-color: #ffffff; padding: 2.5rem; border-radius: 1rem; box-shadow: 0 10px 15px rgba(0, 0, 0, 0.1); text-align: center; max-width: 90%; width: 400px; }
        h1 { color: #1e293b; font-size: 2.25rem; font-weight: 700; margin-bottom: 1.5rem; }
        .data-display { display: flex; justify-content: space-around; margin-bottom: 2rem; }
        .data-item { background-color: #e0f2f7; padding: 1rem 1.5rem; border-radius: 0.75rem; width: 48%; }
        .data-item h2 { font-size: 1.25rem; font-weight: 600; color: #083344; margin-bottom: 0.5rem; }
        .data-item p { font-size: 2.5rem; font-weight: 700; color: #0c4a6e; }
        .last-updated { font-size: 0.875rem; color: #64748b; }
        .error-message { color: #ef4444; font-weight: 600; margin-top: 1rem; }
    </style>
</head>
<body>
    <div class="container">
        <h1>Wetterstation</h1>
        <div class="data-display">
            <div class="data-item">
                <h2>Temperatur</h2>
                <p id="temperature">-- °C</p>
            </div>
            <div class="data-item">
                <h2>Luftfeuchtigkeit</h2>
                <p id="humidity">-- %</p>
            </div>
        </div>
        <p class="last-updated" id="last-updated">Zuletzt aktualisiert: --:--:--</p>
        <p class="error-message" id="error-message"></p>
    </div>

    <script>
        async function fetchData() {
            const tempElement = document.getElementById('temperature');
            const humidityElement = document.getElementById('humidity');
            const lastUpdatedElement = document.getElementById('last-updated');
            const errorMessageElement = document.getElementById('error-message');

            try {
                // Ruft die Daten von unserem Python-Server ab
                const response = await fetch('/data');
                const data = await response.json();

                if (data.error) {
                    errorMessageElement.textContent = `Fehler: ${data.error}`;
                    tempElement.textContent = '-- °C';
                    humidityElement.textContent = '-- %';
                } else {
                    tempElement.textContent = `${data.temperature.toFixed(1)} °C`;
                    humidityElement.textContent = `${data.humidity.toFixed(1)} %`;
                    errorMessageElement.textContent = ''; // Fehler löschen
                }
                lastUpdatedElement.textContent = `Zuletzt aktualisiert: ${new Date().toLocaleTimeString()}`;

            } catch (error) {
                console.error('Fehler beim Abrufen der Daten:', error);
                errorMessageElement.textContent = 'Verbindungsfehler zur Wetterstation.';
                tempElement.textContent = '-- °C';
                humidityElement.textContent = '-- %';
            }
        }

        // Daten beim Laden der Seite abrufen und dann alle 5 Sekunden aktualisieren
        fetchData();
        setInterval(fetchData, 5000); // Alle 5 Sekunden aktualisieren
    </script>
</body>
</html>

  3. Erstelle die Python-Datei für den Webserver webserver.py:

    nano webserver.py
```python
import http.server
import socketserver
import json
import subprocess
import os
import sys

# Pfad zum sensor_reader.py Skript
SENSOR_SCRIPT_PATH = os.path.expanduser("~/sensor_reader.py")

class MyHandler(http.server.SimpleHTTPRequestHandler):
    def do_GET(self):
        if self.path == '/data':
            # Führe das sensor_reader.py Skript aus und lese die Ausgabe
            try:
                # Verwende sys.executable, um sicherzustellen, dass der richtige Python-Interpreter verwendet wird
                result = subprocess.run([sys.executable, SENSOR_SCRIPT_PATH], capture_output=True, text=True, check=True)
                sensor_data = json.loads(result.stdout)
            except subprocess.CalledProcessError as e:
                sensor_data = {"error": f"Sensor script error: {e.stderr.strip()}"}
            except json.JSONDecodeError:
                sensor_data = {"error": "Failed to decode sensor data JSON."}
            except FileNotFoundError:
                sensor_data = {"error": f"Sensor script not found at {SENSOR_SCRIPT_PATH}"}
            except Exception as e:
                sensor_data = {"error": f"An unexpected error occurred: {e}"}

            self.send_response(200)
            self.send_header('Content-type', 'application/json')
            self.end_headers()
            self.wfile.write(json.dumps(sensor_data).encode('utf-8'))
        else:
            # Für alle anderen Pfade (z.B. index.html) den Standard-Handler verwenden
            return http.server.SimpleHTTPRequestHandler.do_GET(self)

# Port, auf dem der Webserver laufen soll
PORT = 8000

# Starte den Server
with socketserver.TCPServer(("", PORT), MyHandler) as httpd:
    print(f"Webserver läuft auf Port {PORT}")
    print(f"Zugriff über http://<IP-Adresse-deines-Pi>:{PORT}")
    httpd.serve_forever()

  4. Speichere die Datei (Strg+X, Y, Enter).

Schritt 5: Webserver starten und zugreifen

  1. Starte den Webserver auf deinem Raspberry Pi (immer noch per SSH verbunden):

    python3 webserver.py

    Der Server wird nun laufen und auf Verbindungen warten.

  2. Finde die IP-Adresse deines Raspberry Pi:

    • Öffne ein neues Terminalfenster auf deinem Raspberry Pi (oder eine neue SSH-Sitzung).

    • Gib den Befehl ein: hostname -I

    • Du siehst eine Reihe von Zahlen, z.B. 192.168.1.100. Das ist deine IP-Adresse.

  3. Greife über WLAN zu:

    • Nimm ein Gerät (Smartphone, Tablet, Laptop), das sich im gleichen WLAN-Netzwerk wie dein Raspberry Pi befindet.

    • Öffne den Webbrowser.

    • Gib die IP-Adresse deines Raspberry Pi gefolgt vom Port ein: http://<IP-Adresse-deines-Pi>:8000 (z.B. http://192.168.1.100:8000)

    Du solltest nun dein Wetter-Dashboard sehen, das die aktuellen Temperatur- und Feuchtigkeitswerte anzeigt!

3. Erweiterungsideen für Fortgeschrittene:

  • Autostart des Servers: Konfiguriere den Raspberry Pi so, dass der Webserver automatisch beim Start ausgeführt wird (z.B. mit systemd).

  • Weitere Sensoren: Schliesse andere Sensoren an (z.B. Luftdruck, Helligkeit, UV-Index) und integriere deren Daten in dein Dashboard.

  • Datenbank-Speicherung: Speichere die Sensordaten in einer kleinen Datenbank (z.B. SQLite) auf dem Raspberry Pi und zeige historische Daten oder Graphen an.

  • Besseres Web-Dashboard: Nutze fortgeschrittenere HTML/CSS/JavaScript-Kenntnisse oder Bibliotheken (z.B. Chart.js für Graphen), um das Dashboard optisch ansprechender zu gestalten.

  • Cloud-Anbindung: Sende die Daten an einen Cloud-Dienst (z.B. Thingspeak, Google Cloud IoT), um sie von überall aus abrufen zu können.

  • Sicherheit (für Sensibilisierung):

    • Benutzerauthentifizierung: Füge eine einfache Benutzerauthentifizierung für den Zugriff auf das Dashboard hinzu.

    • Firewall: Richte eine einfache Firewall (z.B. ufw) auf dem Raspberry Pi ein, um nur den Port 8000 zu öffnen.

    • HTTPS: Für fortgeschrittene SuS: Erkläre die Grundlagen von HTTPS und wie man ein selbstsigniertes Zertifikat erstellt (nicht für den Produktiveinsatz, aber gut zum Verständnis).

Dieses Projekt bietet eine hervorragende Grundlage, um die Vernetzung von Hardware und Software zu verstehen und legt den Grundstein für komplexere IoT-Anwendungen und das Verständnis von Netzwerkkommunikation – alles in einem sicheren und kontrollierten Umfeld.