In diesem Teil der Serie erstellen wir aus unserer Kivy‑App eine ausführbare Datei (.exe unter Windows, Binary unter Linux). Ideal, um die Gebäudedaten‑Visualisierung ohne Python‑Installation zu verteilen.

1. Ziel dieses Artikels

Unsere Kivy‑App läuft bereits auf dem Raspberry Pi oder PC. Jetzt wollen wir sie so verpacken, dass sie:

• ohne Python‑Installation gestartet werden kann
• einfach verteilt werden kann
• stabil und portabel ist

Dafür nutzen wir PyInstaller, das aus Python‑Projekten eigenständige Programme erzeugt.

2. Vorbereitung

Stelle sicher, dass dein Projekt folgende Struktur hat:

projekt/
│
├── VisualizerApp.py
├── app.kv
├── db_reader.py
├── db_init.py
├── datalogger.py
├── sensor_data.db
└── assets/ (optional)

3. PyInstaller installieren

Windows:

pip install pyinstaller

Linux / Raspberry Pi:

sudo apt install python3-pip<br>pip3 install pyinstaller

4. Kivy‑App mit PyInstaller bauen

Wechsle in den Projektordner:

cd projekt

Dann:

pyinstaller --onefile --windowed visualize.py

Parameter:

• --onefile → eine einzige ausführbare Datei
• --windowed → kein Terminalfenster (für GUI‑Apps)

Nach dem Build findest du die fertige Datei in:

dist/visualize.exe   (Windows)
dist/visualize       (Linux)

5. Wichtige Hinweise für Kivy‑Projekte

5.1. Kivy benötigt zusätzliche Dateien

Manchmal müssen Kivy‑Ressourcen manuell eingebunden werden:

pyinstaller --onefile --windowed visualize.py \
    --add-data "C:/Python/Lib/site-packages/kivy/data;kivy/data"

Unter Linux:

pyinstaller --onefile --windowed visualize.py \
    --add-data "/usr/lib/python3/dist-packages/kivy/data:kivy/data"

6. Datenbank einbinden

Die SQLite‑Datenbank muss im selben Ordner wie die EXE liegen.

Beispiel:

visualize.exe
sensor_data.db

Wenn du die Datenbank in ein Unterverzeichnis legen willst, passe den Pfad in db_reader.py an.

7. App testen

Starte die App:

• Windows: Doppelklick auf visualize.exe
• Linux: chmod +x visualize ./visualize

Wenn alles funktioniert, sollte die GUI starten und die Diagramme anzeigen.

8. Typische Fehler & Lösungen

❌ „ModuleNotFoundError: kivy“

→ Kivy‑Daten nicht eingebunden → --add-data verwenden.

❌ Schwarzes Fenster

→ OpenGL‑Treiber fehlen → unter Linux Mesa installieren.

❌ App startet, aber Diagramm leer

→ Datenbank nicht im selben Ordner → Pfad prüfen.

❌ App startet nur mit Terminal

→ --windowed vergessen.

9. Nächster Schritt

Im letzten Artikel führen wir alles zusammen und zeigen, wie du das komplette System stabil betreibst und weiter ausbauen kannst.

In diesem Teil der Serie erstellen wir einen automatisierten Datenlogger, der Sensordaten regelmäßig erfasst und in der SQLite‑Datenbank speichert. Die Ausführung übernimmt ein Cronjob auf dem Raspberry Pi.

1. Ziel dieses Artikels

Damit unsere Gebäudedaten später sinnvoll visualisiert werden können, müssen sie regelmäßig erfasst werden.
In diesem Artikel:

• erstellen wir einen robusten Python‑Datenlogger
• speichern Messwerte automatisch in SQLite
• richten einen Cronjob ein, der das Skript z. B. alle 5 Minuten ausführt

Damit läuft die Datenerfassung komplett im Hintergrund.

2. Datenlogger‑Skript erstellen

Wir erweitern das Skript aus Artikel 3 und machen es robuster.

Erstelle die Datei:

nano data_logger.py

Inhalt:

# data_logger.py
import sqlite3
from datetime import datetime
import Adafruit_DHT

# Sensor auswählen: DHT11 oder DHT22
# sensor = Adafruit_DHT.DHT11
sensor = Adafruit_DHT.DHT22

PIN = 4  # GPIO 4


def log_measurement():
    # Sensor auslesen
    humidity, temperature = Adafruit_DHT.read_retry(sensor, PIN)

    if humidity is None or temperature is None:
        print("Fehler beim Auslesen des Sensors")
        return

    # Zeitstempel exakt wie in db_init.py
    timestamp = datetime.now()

    # In Datenbank schreiben
    connection = sqlite3.connect("sensor_data.db")
    cursor = connection.cursor()

    cursor.execute("""
        INSERT INTO measurements (timestamp, temperature, humidity)
        VALUES (?, ?, ?)
    """, (timestamp, temperature, humidity))

    connection.commit()
    connection.close()

    print(f"Gespeichert: {timestamp} | {temperature:.1f}°C | {humidity:.1f}%")


if __name__ == "__main__":
    log_measurement()

3. Testlauf

python3 data_logger.py

Wenn alles funktioniert, erscheint:

Gespeichert: 21.4°C / 45.2%

4. Cronjob einrichten

Cronjobs sind ideal für regelmäßige Aufgaben wie Datenerfassung.

Cron‑Editor öffnen:

crontab -e

Folgende Zeile einfügen (alle 5 Minuten):

*/5 * * * * /usr/bin/python3 /home/pi/data_logger.py >> /home/pi/logger.log 2>&1

Erklärung:

• */5 → alle 5 Minuten
• python3 → Python‑Interpreter
• data_logger.py → unser Skript
• logger.log → Logdatei zur Fehlersuche

5. Cronjob testen

Liste aller Cronjobs anzeigen:

crontab -l

Nach 5–10 Minuten prüfen, ob neue Daten in der Datenbank stehen:

sqlite3 sensor_data.db "SELECT * FROM measurements ORDER BY id DESC LIMIT 5;"

6. Typische Fehler & Lösungen

❌ Cronjob läuft nicht

• Falscher Pfad zu Python
• Falscher Pfad zum Skript
• Skript nicht ausführbar → chmod +x data_logger.py

❌ „database is locked“

→ Cronjob läuft zu häufig → Intervall erhöhen (z. B. alle 2–5 Minuten).

❌ Keine Werte

→ Sensor nicht stabil → DHT22 braucht manchmal 1–2 Sekunden nach Boot.

7. Nächster Schritt

Im nächsten Artikel erweitern wir das System um weitere Sensoren wie CO₂, Helligkeit oder Bewegung – modular und flexibel.

In diesem Teil der Serie visualisieren wir Temperatur- und Luftfeuchtigkeitsdaten mit Matplotlib. Die Live‑Labels und das Diagramm werden regelmäßig über das Kivy‑Clock‑Modul aktualisiert. Die App nutzt automatisch die Datenbank aus Artikel 3 — inklusive Beispieldaten oder echten Sensordaten.

1. Ziel dieses Artikels

Wir erweitern die App aus Artikel 4:

• Matplotlib‑Diagramm einbinden
• Diagramm in graph_container platzieren
• Live‑Labels (temp_label, hum_label) mit echten Werten füllen
• automatische Updates über Clock.schedule_interval()
• Button „Aktualisieren“ funktioniert weiterhin

2. Warum Matplotlib statt Garden Graph?

Kurz und klar:

• Garden Graph funktioniert unter Windows oft nicht
• Installation bricht ab oder Modul fehlt
• keine gepflegte Windows‑Unterstützung

Matplotlib dagegen:

• stabil
• plattformübergreifend
• extrem flexibel
• perfekt in Kivy integrierbar

Darum nutzen wir Matplotlib.

3. Matplotlib installieren

pip install matplotlib
pip install kivy-garden
garden install matplotlib

4. Daten aus SQLite laden

nano db_reader.py

Inhalt:

import sqlite3

def load_data(limit=100):
    connection = sqlite3.connect("sensor_data.db")
    cursor = connection.cursor()

    cursor.execute("""
        SELECT timestamp, temperature, humidity
        FROM measurements
        ORDER BY id DESC
        LIMIT ?
    """, (limit,))

    rows = cursor.fetchall()
    connection.close()
    return rows[::-1]

5. Visualizer‑App mit Matplotlib & Clock

Ersetze VisualizerApp.py durch:

from kivy.app import App
from kivy.lang import Builder
from kivy.clock import Clock

from kivy_garden.matplotlib.backend_kivyagg import FigureCanvasKivyAgg
from matplotlib.figure import Figure

from db_reader import load_data
from db_init import initialize_database


class VisualizerApp(App):
    def build(self):
        initialize_database()

        self.build_plot()

        # Automatische Updates alle 10 Sekunden
        Clock.schedule_interval(lambda dt: self.update_plot(), 10)

        return self.root

    def build_plot(self):
        self.fig = Figure(figsize=(5, 3))
        self.ax = self.fig.add_subplot(111)
        self.canvas = FigureCanvasKivyAgg(self.fig)

        container = self.root.ids.graph_container
        container.clear_widgets()
        container.add_widget(self.canvas)

        self.update_plot()

    def update_plot(self):
        data = load_data(100)
        if not data:
            return

        temps = [row[1] for row in data]
        hums = [row[2] for row in data]

        # Diagramm aktualisieren
        self.ax.clear()
        self.ax.plot(temps, label="Temp (°C)", color="red")
        self.ax.plot(hums, label="Hum (%)", color="blue")
        self.ax.legend()
        self.canvas.draw()

        # Live-Werte aktualisieren
        last = data[-1]
        self.root.ids.temp_label.text = f"Temperatur: {last[1]:.1f} °C"
        self.root.ids.hum_label.text = f"Luftfeuchtigkeit: {last[2]:.1f} %"


if __name__ == "__main__":
    VisualizerApp().run()

6. Was jetzt passiert

✔️ Live‑Labels

Die Labels über der Grafik zeigen:

• aktuelle Temperatur
• aktuelle Luftfeuchtigkeit

✔️ Diagramm

Matplotlib zeigt die letzten 100 Messpunkte.

✔️ Automatische Updates

Alle 10 Sekunden:

• Diagramm neu gezeichnet
• Live‑Labels aktualisiert

✔️ Button „Aktualisieren“

Funktioniert weiterhin manuell.

✔️ Echte Sensordaten

Wenn du log_sensor_data.py ausführst, erscheinen die Werte automatisch in der App.

In diesem Teil der Serie installieren wir Kivy, erstellen das Grundlayout unserer App und integrieren zwei Live‑Labels, die Temperatur und Luftfeuchtigkeit anzeigen. Das Layout wird vollständig in einer .kv‑Datei definiert. Beim Start initialisiert die App automatisch die Datenbank und legt Beispieldaten an.

1. Ziel dieses Artikels

Wir bauen das Grundgerüst der App:

• Kivy installieren
• Layout in .kv definieren
• zwei Live‑Labels über der Grafik anzeigen
• Platzhalter für das Diagramm einfügen
• Datenbank beim Start automatisch initialisieren

Die Live‑Labels werden in Artikel 5 mit echten Werten gefüllt.

2. Kivy installieren

2.1 venv aktivieren (Beispiel Windows, PyCharm‑Terminal)

venv\Scripts\activate

2.2 Kivy + Windows‑Dependencies installieren

pip install "kivy[base]" kivy-deps.sdl2 kivy-deps.glew kivy-deps.angle

Linux/Raspberry Pi:

pip install kivy

3. .kv‑Layout erstellen

Erstelle:

nano visualizer.kv

Inhalt:

BoxLayout:
    orientation: "vertical"
    padding: 10
    spacing: 10

    BoxLayout:
        orientation: "horizontal"
        size_hint_y: 0.15
        spacing: 20

        Label:
            id: temp_label
            text: "Temperatur: -- °C"
            font_size: "20sp"

        Label:
            id: hum_label
            text: "Luftfeuchtigkeit: -- %"
            font_size: "20sp"

    BoxLayout:
        id: graph_container
        size_hint_y: 0.75

    Button:
        text: "Aktualisieren"
        size_hint_y: 0.1
        on_release: app.update_plot()

Was hier passiert:

• Zwei Live‑Labels oben (Temperatur & Luftfeuchtigkeit)
• graph_container als Platzhalter für das Diagramm
• Button, der später das Diagramm neu lädt

4. Python‑App erstellen

Erstelle:

nano VisualizerApp.py

Inhalt:

from kivy.app import App
from kivy.lang import Builder
from db_init import initialize_database


class VisualizerApp(App):
    def build(self):
        # Datenbank initialisieren (Artikel 3)
        initialize_database()

    def update_plot(self):
        # Wird in Artikel 5 implementiert
        print("Diagramm wird in Artikel 5 implementiert.")


if __name__ == "__main__":
    VisualizerApp().run()

5. Ausblick auf Artikel 5

Im nächsten Artikel:

• binden wir Matplotlib ein
• setzen das Diagramm in graph_container
• aktualisieren die Live‑Labels
• nutzen Clock.schedule_interval() für automatische Updates

In diesem Teil der Serie initialisieren wir die SQLite‑Datenbank für unsere Gebäudedaten‑App. Beim Start der App wird die Datenbank automatisch angelegt und mit Beispieldaten gefüllt. Zusätzlich zeigen wir, wie echte Messwerte vom DHT‑Sensor (DHT11 oder DHT22) in die Datenbank geschrieben werden.

1. Ziel dieses Artikels

Wir richten die Datenbasis für die Visualisierung ein:

• Die App kann die Datenbank beim Start automatisch initialisieren.
• Wenn die Datenbank neu ist → Tabelle wird angelegt.
• Wenn sie bereits existiert → 20 Beispieldatensätze werden eingefügt.
• Zusätzlich gibt es ein Skript, das echte Sensordaten in die Datenbank schreibt (DHT11 oder DHT22).

2. Datenbank‑Initialisierung für die App

Erstelle die Datei:

nano db_init.py

Inhalt:

import sqlite3
import os
from datetime import datetime, timedelta
import random


def initialize_database():
    db_exists = os.path.exists("sensor_data.db")

    connection = sqlite3.connect("sensor_data.db")
    cursor = connection.cursor()

    cursor.execute("""
        CREATE TABLE IF NOT EXISTS measurements (
            id INTEGER PRIMARY KEY AUTOINCREMENT,
            timestamp DATETIME,
            temperature REAL,
            humidity REAL
        )
    """)

    connection.commit()

    # Wenn DB neu → fertig
    if not db_exists:
        print("Datenbank neu erstellt.")
        connection.close()
        return

    # Wenn DB existiert → Beispieldaten einfügen, falls zu wenige vorhanden
    cursor.execute("SELECT COUNT(*) FROM measurements")
    count = cursor.fetchone()[0]

    if count < 20:
        print("Füge 20 Beispieldatensätze hinzu…")
        now = datetime.now()

        for i in range(20):
            ts = now - timedelta(minutes=20 - i)
            temp = round(random.uniform(20.0, 25.0), 1)
            hum = round(random.uniform(40.0, 55.0), 1)

            cursor.execute("""
                INSERT INTO measurements (timestamp, temperature, humidity)
                VALUES (?, ?, ?)
            """, (ts, temp, hum))

        connection.commit()

    connection.close()

Dieser Code wird später in der Kivy‑App (Artikel 4/5) beim Start aufgerufen.

3. Sensordaten vom DHT11/DHT22 in die Datenbank schreiben

Jetzt ergänzen wir wieder den Teil, den du vorher schon drin hattest:
Ein Skript, das echte Messwerte vom Sensor in die Datenbank schreibt.

3.1. Voraussetzungen

• DHT11 oder DHT22 ist wie in Artikel 2 beschrieben angeschlossen.
• Bibliothek installiert:

pip3 install Adafruit_DHT

3.2. Skript zum Speichern eines Messwerts

Erstelle die Datei:

nano log_sensor_data.py

Inhalt:

import sqlite3
from datetime import datetime
import Adafruit_DHT

# Sensor wählen: DHT11 oder DHT22
# sensor = Adafruit_DHT.DHT11
sensor = Adafruit_DHT.DHT22

PIN = 4  # GPIO 4


def log_measurement():
    humidity, temperature = Adafruit_DHT.read_retry(sensor, PIN)

    if humidity is None or temperature is None:
        print("Fehler beim Auslesen des Sensors")
        return

    connection = sqlite3.connect("sensor_data.db")
    cursor = connection.cursor()

    timestamp = datetime.now()

    cursor.execute("""
        INSERT INTO measurements (timestamp, temperature, humidity)
        VALUES (?, ?, ?)
    """, (timestamp, temperature, humidity))

    connection.commit()
    connection.close()

    print(f"Gespeichert: {timestamp} | {temperature:.1f}°C | {humidity:.1f}%")


if __name__ == "__main__":
    log_measurement()

Ausführen:

python3 log_sensor_data.py

Bei jedem Aufruf wird ein neuer Messwert in der Tabelle measurements gespeichert.

4. Daten prüfen

Zum schnellen Check über das Terminal:

sqlite3 sensor_data.db "SELECT * FROM measurements LIMIT 10;"

Oder später in Python (z. B. in Artikel 5 mit db_reader.py).

5. Verbindung zu den nächsten Artikeln

• Artikel 4 ruft initialize_database() beim Start der Kivy‑App auf.
• Artikel 5 liest die Daten aus sensor_data.db und zeigt sie mit Matplotlib an.
• Artikel 6 lässt das Skript log_sensor_data.py per Cronjob parallel laufen, um echte Messdaten in die gleiche Datenbank zu schreiben.

Wenn du möchtest, passe ich in Artikel 4 und 5 noch Sätze an, die explizit darauf hinweisen, dass neben den Beispieldaten auch Echt‑Daten über log_sensor_data.py in die Visualisierung einfließen können.rsten GUI‑Elemente.

In diesem Teil der Serie schließen wir wahlweise den DHT11 oder DHT22 an den Raspberry Pi an und lesen Temperatur- und Luftfeuchtigkeitsdaten mit Python aus.

1. DHT11 oder DHT22 – welcher Sensor passt zu deinem Projekt?

Beide Sensoren funktionieren identisch in der Ansteuerung, unterscheiden sich aber in Genauigkeit und Messbereich.

Gut zu wissen:
Beide Sensoren werden mit derselben Python‑Bibliothek ausgelesen und nutzen dieselbe Verkabelung.

2. Benötigte Hardware

• Raspberry Pi (ab Modell 3)
• DHT11 oder DHT22
• 10k‑Ohm Pull‑Up‑Widerstand
• Jumper‑Kabel
• Optional: Steckbrett

3. Schaltplan & Verkabelung

Beide Sensoren haben dieselbe Pinbelegung:

Zwischen VCC und DATA kommt ein 5-10k‑Ohm Widerstand.

4. Python‑Bibliothek installieren

sudo apt update
sudo apt install python3-pip
pip3 install Adafruit_DHT

5. Python‑Skript zum Auslesen – wähle deinen Sensor

Erstelle die Datei:

nano dht_read.py

Variante A: DHT11

import Adafruit_DHT

sensor = Adafruit_DHT.DHT11
pin = 4  # GPIO 4

humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)

if humidity is not None and temperature is not None:
    print(f"Temperatur: {temperature:.1f}°C")
    print(f"Luftfeuchtigkeit: {humidity:.1f}%")
else:
    print("Fehler beim Auslesen des Sensors")

Variante B: DHT22

import Adafruit_DHT

sensor = Adafruit_DHT.DHT22
pin = 4  # GPIO 4

humidity, temperature = Adafruit_DHT.read_retry(sensor, pin)

if humidity is not None and temperature is not None:
    print(f"Temperatur: {temperature:.1f}°C")
    print(f"Luftfeuchtigkeit: {humidity:.1f}%")
else:
    print("Fehler beim Auslesen des Sensors")

6. Skript ausführen

python3 dht_read.py

7. Typische Fehler & Lösungen

❌ „Fehler beim Auslesen des Sensors“

• DATA‑Pin falsch
• Widerstand fehlt
• Sensor noch nicht stabil (1–2 Sekunden warten)

❌ Werte springen stark

• DHT11 ist weniger präzise → normal
• Schlechte Steckverbindungen
• Zu lange Kabel

8. Nächster Schritt