ESP32 Daten als CSV exportieren: Einfacher Zugriff über den Webbrowser

# Standardbibliothek für Zeitfunktionen
import time

# Eigene Module
import wifi                # WLAN-Verbindung herstellen
import led                 # LEDs zur Statusanzeige
import fetchShellyData as shelly  # Modul zum Abrufen von Shelly-Daten via HTTP
import util                # Hilfsfunktionen, z. B. zum Parsen der Daten oder RTC-Sync
import logger              # Debug-Logging
import datastore           # Daten lokal speichern/verwalten
import machine             # MicroPython-Hardwarefunktionen (z. B. Reset, Pin, etc.)
import server as restServer  # REST-API-Modul zum Bereitstellen von Daten

# Zeitintervall zwischen zwei Datenabrufen (in Millisekunden)
from configuration import FETCH_INTERVAL_MS

# Zeitpunkt des letzten Abrufs merken
letzter_aufruf = time.ticks_ms()

# Aufgabe: Daten vom Shelly holen, aufbereiten und speichern
def fetchData_task():
    data = shelly.fetch_shelly_data()               # Rohdaten vom Shelly abfragen (HTTP GET)
    shellyData = util.extract_shelly_values(data)   # Wichtige Werte extrahieren (current, voltage, apower)
    led.receivedDataLED()                           # LED blinkt kurz zur Bestätigung des Dateneingangs
    datastore.read_json_file()                      # Vorherige Daten aus Datei laden
    datastore.remove_old_entries()                  # Alte Einträge ggf. löschen (z. B. > 5 Tage alt)
    datastore.add_entry(shellyData)                 # Aktuelle Daten hinzufügen
    datastore.save_data_to_file()                   # Daten wieder in Datei speichern

# Hauptprogramm
try:
    led.setErrorLED(False)                          # Fehler-LED ausschalten
    led.setWiFiActive(False)                        # WiFi-LED ebenfalls deaktivieren (wird gleich gesetzt)

    isWiFiConnected = wifi.connect_wifi()           # Mit WLAN verbinden
    logger.debugLog('WiFi Verbindung: '+ ('AN' if isWiFiConnected else 'AUS'))

    if isWiFiConnected:
        if util.sync_rtc():                         # Systemzeit mit NTP synchronisieren
            server = restServer.init_rest_server()  # REST-API initialisieren
            while True:
                restServer.handle_rest_request(server)  # HTTP-Anfragen bearbeiten

                jetzt = time.ticks_ms()             # Aktueller Zeitstempel
                if time.ticks_diff(jetzt, letzter_aufruf) >= FETCH_INTERVAL_MS:
                    fetchData_task()                # Nur alle 5 Sekunden Daten abrufen
                    letzter_aufruf = jetzt
        else:
            led.setErrorLED(True)                   # RTC-Sync fehlgeschlagen → Fehler anzeigen
    else:
        led.setErrorLED(True)                       # WLAN-Verbindung fehlgeschlagen → Fehler anzeigen

    led.setWiFiActive(False)                        # WLAN-LED am Ende wieder deaktivieren

except Exception as e:
    led.setErrorLED(True)                           # Fehler-LED einschalten bei unerwartetem Fehler
    print(e)                                        # Fehlerausgabe zur Analyse

# Importiere Netzwerksteuerung für WLAN
import network
import time
import led
from configuration import WIFI_SSID as SSID, WIFI_PASSWORD as PASSWORD

# WLAN-Zugangsdaten (→ solltest du später z. B. in eine separate config.py auslagern)
SSID = "FRITZBox7590GI24"
PASSWORD = "22894580214767401850"

# Verbindet das Gerät mit dem WLAN-Netzwerk
def connect_wifi():
    global SSID, PASSWORD

    # WLAN-Schnittstelle im Station-Modus (STA_IF = Client-Modus)
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)  # Aktiviert WLAN

    # Wenn noch keine Verbindung besteht, versuche zu verbinden
    if not wlan.isconnected():
        print("Verbinde mit WLAN...")
        wlan.connect(SSID, PASSWORD)

        # Warte auf Verbindung (max. 10 Sekunden)
        timeout = 10  # Sekunden
        while not wlan.isconnected() and timeout > 0:
            led.blink(0.25)        # Status-LED blinkt während Verbindungsversuch
            timeout -= 0.5
            print(".", end="")     # Ausgabe eines Punkts pro Versuch (optional)

    # Ergebnis prüfen
    if wlan.isconnected():
        print("\nWLAN verbunden.")
        print("IP-Adresse:", wlan.ifconfig()[0])  # Ausgabe der zugewiesenen IP-Adresse
        led.setWiFiActive(True)                   # WLAN-LED einschalten
        return True
    else:
        print("\nVerbindung fehlgeschlagen.")
        led.setWiFiActive(False)                  # WLAN-LED ausschalten
        return False

# JSON-Verarbeitung und Logging
import ujson
import logger
import util

from configuration import DATASTORE_FILENAME as filename

# Globale Datenstruktur zum Zwischenspeichern der Daten im RAM
data = {}

# Liest die JSON-Datei ein und lädt sie als Dictionary in die globale Variable `data`
def read_json_file():
    global data, filename
    try:
        with open(filename, 'r') as file:
            data = ujson.load(file)  # Inhalt der Datei in `data` laden
        return data
    except OSError:
        logger.debugLog(f"Datei '{filename}' wurde nicht gefunden.", "ERROR")
    except ValueError:
        logger.debugLog(f"Fehler beim Einlesen der Datei '{filename}': Ungültiges JSON-Format.","ERROR")

# Fügt einen neuen Messwert in die Datenstruktur ein
def add_entry(values_dict):
    global data

    # Extrahiere Datum im Format DD.MM.YYYY und Zeitstempel (Unixzeit)
    timestamp_str = values_dict['unixtime']
    date_str = util.timestamp_to_date(values_dict['unixtime'])

    # Wenn der Tag noch nicht im Dictionary ist, anlegen
    if date_str not in data:
        data[date_str] = {}

    # Entferne den Zeitstempel aus dem Dictionary der Messwerte (ist schon im Key enthalten)
    values_dict.pop('unixtime')

    # Werte unter dem entsprechenden Datum und Zeitstempel speichern
    data[date_str][timestamp_str] = values_dict

# Speichert die globale `data`-Struktur als JSON-Datei
def save_data_to_file():
    global data, filename
    try:
        with open(filename, "w") as file:
            ujson.dump(data, file)  # Schreibe Daten in Datei
            logger.debugLog("Daten erfolgreich gespeichert.")
    except OSError as osError:
        logger.debugLog("Fehler beim Schreiben der Datei. {osError}", "ERROR")

# Löscht alle Datums-Einträge, die älter als X Tage sind (Standard: 5 Tage)
def remove_old_entries():
    global data

    # Prüfe, welche Datums-Schlüssel älter als erlaubt sind
    keys_to_delete = [key for key in data if util.is_older_than_days(key)]

    # Entferne alte Einträge
    for key in keys_to_delete:
        del data[key]

# Importiere Pin-Steuerung und Zeitfunktionen
from machine import Pin
import time

# Initialisierung der LED-Pins (Anpassen je nach Board / Verkabelung)
ledWiFi = Pin(2, Pin.OUT)    # LED für WLAN-Status
ledError = Pin(3, Pin.OUT)   # LED für Fehleranzeige
ledData = Pin(4, Pin.OUT)    # LED zeigt an, dass neue Daten empfangen wurden

# Schaltet die WLAN-LED ein oder aus
def setWiFiActive(value):
    ledWiFi.value(1 if value else 0)

# Blinkt die WLAN-LED einmal für das angegebene Zeitintervall (z. B. beim Verbindungsaufbau)
def blink(intervall):
    setWiFiActive(True)
    time.sleep(intervall)
    setWiFiActive(False)
    time.sleep(intervall)

# Schaltet die Fehler-LED ein oder aus
def setErrorLED(value):
    ledError.value(1 if value else 0)

# Blinkt kurz die Daten-LED, wenn neue Werte gespeichert wurden
def receivedDataLED():
    ledData.value(1)
    time.sleep(0.25)
    ledData.value(0)
    time.sleep(0.25)

import time

def debugLog(text, level="INFO"):
    try:
        print(text)
        now = time.localtime()
        datum = "{:02d}.{:02d}.{:04d}".format(now[2], now[1], now[0])
        uhrzeit = "{:02d}:{:02d}:{:02d}".format(now[3], now[4], now[5])
        log_line = f"[{datum} {uhrzeit}] [{level.upper()}] {text}\n"

        with open("debug.log", "a") as log_file:
            log_file.write(log_line)
    except Exception as e:
        print("Fehler beim Schreiben ins Log:", e)

# Standard- und Projektmodule
import json
import logger
import ntptime
import time
import machine

from configuration import DATA_RETENTION_DAYS

# Extrahiert nur die benötigten Messwerte aus der vollständigen Shelly-Antwort
def extract_shelly_values(data):
    try:
        voltage = data["switch:0"]["voltage"]
        apower = data["switch:0"]["apower"]
        current = data["switch:0"]["current"]
        unixtime = data["sys"]["unixtime"]

        # Gibt ein flaches Dictionary mit den wichtigsten Werten zurück
        return {
            "voltage": voltage,
            "apower": apower,
            "current": current,
            "unixtime": unixtime
        }
    except KeyError as e:
        logger.debugLog("Fehlender Wert im JSON: {e}")
        return None

# Wandelt die aktuelle RTC-Zeit in das Format DD.MM.YYYY um (z. B. für die Datenstruktur im Speicher)
def timestamp_to_date(timestamp):
    try:
        t = machine.RTC().datetime()
        return "{:02d}.{:02d}.{:04d}".format(t[2], t[1], t[0])
    except Exception as e:
        logger.debugLog(e)
        return "-error-"

# Gleiche Funktion wie oben, aber klar benannt (könnte ggf. ersetzt oder vereinheitlicht werden)
def formatDate():
    t = machine.RTC().datetime()
    return "{tag:02d}.{monat:02d}.{jahr:4d}".format(tag = t[2],monat= t[1],jahr= t[0])

# Synchronisiert die Echtzeituhr (RTC) mit einem NTP-Server über das Internet
def sync_rtc():
    try:
        ntptime.settime()
        logger.debugLog("RTC erfolgreich synchronisiert.")
        return True
    except Exception as e:
        print(e)
        logger.debugLog("Fehler bei der RTC-Synchronisation. {e}", "ERROR")
        return False

# Prüft, ob ein gegebenes Datum älter ist als eine bestimmte Anzahl an Tagen
def is_older_than_days(date_str, days=DATA_RETENTION_DAYS):
    try:
        # Aktuelles Datum vom RTC-Modul holen
        today = machine.RTC().datetime()
        current_timestamp = time.mktime((today[0], today[1], today[2], 0, 0, 0, 0, 0))

        # Umwandlung des gegebenen Datumsstrings in einen Zeitstempel
        tag, monat, jahr = map(int, date_str.split("."))
        entry_timestamp = time.mktime((jahr, monat, tag, 0, 0, 0, 0, 0))

        # Vergleich
        delta = current_timestamp - entry_timestamp
        return delta > days * 86400  # 86400 Sekunden = 1 Tag
    except Exception as e:
        logger.debugLog("Fehler bei Datumsprüfung: {e}", "ERROR")
        return False

# Prüft, ob Internet verfügbar ist (z. B. für NTP oder externe APIs)
def internet_available():
    try:
        response = urequests.get("http://www.google.com")
        if response.status_code == 200:
            response.close()
            logger.debugLog("Internetverbindung verfügbar.")
            return True
        else:
            logger.debugLog("Internetverbindung nicht erfolgreich. Status: "+ response.status_code, "ERROR")
            response.close()
            return False
    except Exception as e:
        logger.debugLog("Kein Internetzugriff: {e}", "ERROR")
        return False

# Konvertiert die verschachtelte Datenstruktur in ein CSV-Format mit Semikolon als Trennzeichen
def dict_to_csv(data):
    # Header-Zeile definieren
    csv_lines = ["date;timestamp;current;voltage;apower"]
    for date, timestamps in data.items():
        for ts, values in timestamps.items():
            # Komma statt Punkt für Dezimaltrennung (deutsches Format)
            current = str(values.get('current', '')).replace('.', ',')
            voltage = str(values.get('voltage', '')).replace('.', ',')
            apower = str(values.get('apower', '')).replace('.', ',')
            # Zeile zusammenbauen
            line = f"{date};{ts};{current};{voltage};{apower}"
            csv_lines.append(line)
    return '\n'.join(csv_lines)

WIFI_SSID = "abc"
WIFI_PASSWORD = "123"

# Shelly API-Endpunkt
SHELLY_URL = "http://192.168.178.38/rpc/Shelly.GetStatus"

# Dateiname für gespeicherte Daten
DATASTORE_FILENAME = "data.json"

# REST-Server
REST_SERVER_PORT = 80

# Datenabrufintervall in Millisekunden
FETCH_INTERVAL_MS = 5000  # z. B. alle 5 Sekunden

# Maximale Aufbewahrungszeit (z. B. 5 Tage)
DATA_RETENTION_DAYS = 5