Shelly 1PM + ESP32: Daten speichern & zeitgesteuert senden

# -----------------------------------------------------------------------------
# Autor: Stefan Draeger
# Webseite: https://draeger-it.blog
# Beitrag: https://draeger-it.blog/shelly-1pm-esp32-daten-speichern-zeitgesteuert-senden/
# Beschreibung:
# Dieses Skript liest eine JSON-Datei vom ESP32-C3 ein, fügt neue Messdaten
# hinzu und speichert die aktualisierten Daten zurück in die Datei.
# -----------------------------------------------------------------------------

import ujson

# Globales Dictionary zur Speicherung der Messdaten
data = {}

# Liest die JSON-Datei ein und wandelt den Inhalt in ein Dictionary um
def read_json_file(filename):
    global data
    try:
        with open(filename, 'r') as file:
            data = ujson.load(file)
    except OSError:
        print(f"Datei '{filename}' wurde nicht gefunden.")
    except ValueError:
        print(f"Fehler beim Einlesen der Datei '{filename}': Ungültiges JSON-Format.")

# Fügt dem Dictionary einen neuen Eintrag mit Zeitstempel und Messwerten hinzu
def add_entry(date_str, timestamp_str, values_dict):
    """
    Fügt einen neuen Datensatz zum globalen Dictionary 'data' hinzu.

    :param date_str: Datum als String, z. B. "10.03.2025"
    :param timestamp_str: Zeitstempel als String, z. B. "1741590664"
    :param values_dict: Dictionary mit Messwerten
    """
    global data

    # Wenn das Datum noch nicht existiert, wird es angelegt
    if date_str not in data:
        data[date_str] = {}

    # Zeitstempel samt Werten hinzufügen oder überschreiben
    data[date_str][timestamp_str] = values_dict

# Speichert das Dictionary als JSON-Datei auf dem ESP32
def save_data_to_file():
    """
    Speichert das globale Dictionary 'data' in die Datei 'data.json'.
    """
    global data
    try:
        with open("data.json", "w") as file:
            ujson.dump(data, file)
            print("Daten erfolgreich gespeichert.")
    except OSError:
        print("Fehler beim Schreiben der Datei.")

# Gibt das Dictionary zeilenweise in der Shell aus
def print_json_dict():
    global data
    for key, value in data.items():
        print(f"{key}: {value}")

# ----------------------------------------------------------------------
# Hauptprogramm
# ----------------------------------------------------------------------

filename = "data.json"

# Vorhandene Datei einlesen
read_json_file(filename)

# Inhalt der Datei anzeigen
print("Inhalt der Datei:")
print_json_dict()

# Neuen Messwert hinzufügen
add_entry("10.03.2025", "1741590722", {
    "voltage": 228,
    "ampere": 9,
    "apower": 21,
    "current": 3
})

# Datei mit neuem Eintrag speichern
save_data_to_file()

# Datei erneut laden und aktualisierte Daten anzeigen
read_json_file(filename)
print("Aktualisierter Inhalt der Datei:")
print_json_dict()

# -----------------------------------------------------------------------------
# Autor: Stefan Draeger
# Webseite: https://draeger-it.blog
# Beitrag: https://draeger-it.blog/shelly-1pm-esp32-daten-speichern-zeitgesteuert-senden/
#
# Beschreibung:
# Dieses Skript stellt mit dem ESP32-C3 Super Mini eine Verbindung zum lokalen
# WLAN her und nutzt eine Status-LED an GPIO 2 als einfache Rückmeldung.
#
# - Während der Verbindungssuche blinkt die LED.
# - Nach erfolgreicher Verbindung leuchtet die LED dauerhaft.
# - Bei fehlgeschlagener Verbindung bleibt die LED aus.
# -----------------------------------------------------------------------------

import network
import time
from machine import Pin

# WLAN-Zugangsdaten
SSID = "abc"
PASSWORD = "123"

# Status-LED an GPIO 2 (z. B. für den ESP32-C3 Super Mini)
led = Pin(2, Pin.OUT)

# Funktion zum Aufbau der WLAN-Verbindung
def connect_wifi(ssid, password):
    # WLAN-Modul im Station Mode aktivieren
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)

    # Verbindung starten, falls noch nicht verbunden
    if not wlan.isconnected():
        print("Verbinde mit WLAN...")
        wlan.connect(ssid, password)

        # LED blinkt während der Verbindungssuche
        timeout = 10  # Sekunden
        while not wlan.isconnected() and timeout > 0:
            led.value(1 - led.value())  # LED-Zustand wechseln (manuelles Blinken)
            time.sleep(0.5)
            timeout -= 0.5
            print(".", end="")

    # Verbindung erfolgreich
    if wlan.isconnected():
        print("\nWLAN verbunden.")
        print("IP-Adresse:", wlan.ifconfig()[0])
        led.value(1)  # LED dauerhaft an
        return True
    else:
        # Verbindung fehlgeschlagen
        print("\nVerbindung fehlgeschlagen.")
        led.value(0)  # LED bleibt aus
        return False

# WLAN-Verbindung aufbauen
connect_wifi(SSID, PASSWORD)

# -----------------------------------------------------------------------------
# Autor: Stefan Draeger
# Webseite: https://draeger-it.blog
# Beitrag: https://draeger-it.blog/shelly-1pm-esp32-daten-speichern-zeitgesteuert-senden/
#
# Beschreibung:
# Dieses Skript verbindet den ESP32-C3 mit einem WLAN, synchronisiert die
# interne Echtzeituhr (RTC) über einen NTP-Server und gibt das aktuelle Datum 
# formatiert aus. 
#
# - Während der Verbindungssuche blinkt die LED.
# - Nach erfolgreicher Verbindung leuchtet die LED dauerhaft.
# - Das Datum wird im Format TT.MM.JJJJ ausgegeben.
# -----------------------------------------------------------------------------

import time
import network
import ntptime
from machine import Pin

# WLAN-Zugangsdaten
SSID = "abc"
PASSWORD = "123"

# Status-LED an GPIO 2 (z. B. für den ESP32-C3 Super Mini)
led = Pin(2, Pin.OUT)

# Funktion zum Aufbau der WLAN-Verbindung
def connect_wifi(ssid, password):
    """
    Baut eine Verbindung zum WLAN auf und gibt den Status zurück.
    Während der Verbindungssuche blinkt die LED, nach erfolgreicher Verbindung
    leuchtet sie dauerhaft.
    
    :param ssid: Name des WLAN-Netzwerks
    :param password: WLAN-Passwort
    :return: True, wenn erfolgreich verbunden, sonst False
    """
    wlan = network.WLAN(network.STA_IF)  # WLAN-Modul im Station Mode
    wlan.active(True)  # WLAN aktivieren

    if not wlan.isconnected():
        print("Verbinde mit WLAN...")
        wlan.connect(ssid, password)

        # LED blinkt während der Verbindungssuche
        timeout = 10  # Maximale Wartezeit in Sekunden
        while not wlan.isconnected() and timeout > 0:
            led.value(1 - led.value())  # LED-Zustand wechseln (manuelles Blinken)
            time.sleep(0.5)
            timeout -= 0.5
            print(".", end="")

    if wlan.isconnected():
        print("\nWLAN verbunden.")
        print("IP-Adresse:", wlan.ifconfig()[0])
        led.value(1)  # LED dauerhaft an = erfolgreich verbunden
        return True
    else:
        print("\nVerbindung fehlgeschlagen.")
        led.value(0)  # LED bleibt aus
        return False

# Funktion zur Umwandlung des Unix-Timestamps in ein formatiertes Datum
def formatDate():
    """
    Wandelt den aktuellen Unix-Zeitstempel in ein lesbares Datum um.

    :return: String im Format "TT.MM.JJJJ"
    """
    timestamp = time.localtime()  # Aktuelle Zeit abrufen
    return "{tag:02d}.{monat:02d}.{jahr:4d}".format(tag=timestamp[2], monat=timestamp[1], jahr=timestamp[0])

# WLAN-Verbindung herstellen
isWiFiConnected = connect_wifi(SSID, PASSWORD)

# Falls WLAN verbunden, Zeit vom NTP-Server holen
if isWiFiConnected:
    try:
        ntptime.settime()  # Zeit vom NTP-Server synchronisieren
        print("Zeit erfolgreich synchronisiert.")
        print("Aktuelles Datum:", formatDate())
    except:
        print("Fehler bei der Zeitsynchronisation.")
else:
    print("Keine WLAN-Verbindung – NTP-Sync nicht möglich.")

# -----------------------------------------------------------------------------
# Autor: Stefan Draeger
# Webseite: https://draeger-it.blog
# Beitrag: https://draeger-it.blog/shelly-1pm-esp32-daten-speichern-zeitgesteuert-senden/
#
# Beschreibung:
# Dieses Skript verbindet den ESP32-C3 mit einem WLAN-Netzwerk, ruft aktuelle
# Leistungsdaten eines Shelly-Geräts über die REST-API (rpc/Shelly.GetStatus)
# ab und extrahiert daraus die benötigten Messwerte.
#
# - WLAN-Verbindung mit Statusanzeige über LED (GPIO 2)
# - Abruf des Shelly-Status über HTTP (lokale IP)
# - Extraktion von Spannung, Leistung, Strom und Unix-Zeitstempel
# -----------------------------------------------------------------------------

import network
import time
from machine import Pin
import urequests

# WLAN-Zugangsdaten (bitte anpassen!)
SSID = "abc"
PASSWORD = "123"

# Shelly-REST-Endpunkt für Statusdaten
SHELLY_URL = "http://192.168.178.91/rpc/Shelly.GetStatus"

# Status-LED an GPIO 2 (zeigt WLAN-Status an)
led = Pin(2, Pin.OUT)

# Verbindet den ESP32 mit dem WLAN und zeigt den Status über die LED an
def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)

    if not wlan.isconnected():
        print("Verbinde mit WLAN...")
        wlan.connect(ssid, password)

        # LED blinkt während der Verbindungssuche
        timeout = 10  # Sekunden
        while not wlan.isconnected() and timeout > 0:
            led.value(1 - led.value())  # LED-Zustand wechseln
            time.sleep(0.5)
            timeout -= 0.5
            print(".", end="")

    if wlan.isconnected():
        print("\nWLAN verbunden.")
        print("IP-Adresse:", wlan.ifconfig()[0])
        led.value(1)  # LED dauerhaft an
        return True
    else:
        print("\nVerbindung fehlgeschlagen.")
        led.value(0)  # LED aus
        return False

# Ruft die JSON-Daten vom Shelly-Device ab
def fetch_shelly_data():
    try:
        response = urequests.get(SHELLY_URL)
        if response.status_code == 200:
            json_data = response.json()  # JSON zu Python-Dictionary umwandeln
            response.close()
            return json_data
        else:
            print("Fehler beim Abrufen der Daten:", response.status_code)
            response.close()
            return None
    except Exception as e:
        print("Verbindungsfehler:", e)
        return None

# Extrahiert relevante Werte aus der 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"]

        # Rückgabe als kompaktes Dictionary
        return {
            "voltage": voltage,
            "apower": apower,
            "current": current,
            "unixtime": unixtime
        }
    except KeyError as e:
        print("Fehlender Wert im JSON:", e)
        return None

# Gibt das aktuelle Datum im Format TT.MM.JJJJ zurück
def formatDate():
    timestamp = time.localtime()
    return "{:02d}.{:02d}.{:04d}".format(timestamp[2], timestamp[1], timestamp[0])

# Hauptablauf
isWiFiConnected = connect_wifi(SSID, PASSWORD)
if isWiFiConnected:
    shelly_data = fetch_shelly_data()
    if shelly_data:
        print("Empfangene Daten:")
        print(shelly_data)

        values = extract_shelly_values(shelly_data)
        if values:
            print("Extrahierte Werte:")
            print(values)

import network
import time
from machine import Pin
import urequests
import ntptime
import ujson

# Globales Dictionary für alle gesammelten Messdaten
data = {}

# WLAN-Zugangsdaten (bitte anpassen)
SSID = "abc"
PASSWORD = "123"

# Shelly-Endpunkt für den Abruf der aktuellen Leistungsdaten
SHELLY_URL = "http://192.168.178.91/rpc/Shelly.GetStatus"

# Abfrageintervall in Sekunden (5 Minuten)
INTERVAL = 300

# LED an GPIO 2 zur Anzeige der WLAN-Verbindung
led = Pin(2, Pin.OUT)

# Verbindet den ESP32 mit dem WLAN und zeigt den Status über die LED an
def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)

    if not wlan.isconnected():
        print("Verbinde mit WLAN...")
        wlan.connect(ssid, password)

        # LED blinkt während der Verbindungssuche
        timeout = 10
        while not wlan.isconnected() and timeout > 0:
            led.value(1 - led.value())
            time.sleep(0.5)
            timeout -= 0.5
            print(".", end="")

    if wlan.isconnected():
        print("\nWLAN verbunden.")
        print("IP-Adresse:", wlan.ifconfig()[0])
        led.value(1)  # LED dauerhaft an bei Verbindung
        return True
    else:
        print("\nVerbindung fehlgeschlagen.")
        led.value(0)
        return False

# Synchronisiert die interne Uhr über einen NTP-Zeitserver
def sync_rtc():
    try:
        ntptime.settime()
        print("RTC erfolgreich synchronisiert.")
        return True
    except:
        print("Fehler bei der RTC-Synchronisation.")
        return False

# Wandelt Unix-Zeitstempel in ein Datumsformat TT.MM.JJJJ
def timestamp_to_date(timestamp):
    try:
        t = time.localtime(timestamp)
        return "{:02d}.{:02d}.{:04d}".format(t[2], t[1], t[0])
    except:
        return "00.00.0000"

# Ruft die aktuellen Daten vom Shelly-Gerät ab
def fetch_shelly_data():
    try:
        response = urequests.get(SHELLY_URL)
        if response.status_code == 200:
            json_data = response.json()
            response.close()
            return json_data
        else:
            print("Fehler beim Abrufen der Daten:", response.status_code)
            response.close()
            return None
    except Exception as e:
        print("Verbindungsfehler:", e)
        return None

# Extrahiert relevante Messwerte aus dem Shelly-JSON
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"]

        return {
            "voltage": voltage,
            "apower": apower,
            "current": current,
            "unixtime": unixtime
        }
    except KeyError as e:
        print("Fehlender Wert im JSON:", e)
        return None

# Gibt das aktuelle Datum aus der RTC im Format TT.MM.JJJJ zurück
def formatDate():
    timestamp = time.localtime()
    return "{:02d}.{:02d}.{:04d}".format(timestamp[2], timestamp[1], timestamp[0])

# Liest die bestehende Datei 'data.json' in das globale Dictionary
def read_json_file(filename):
    global data
    try:
        with open(filename, 'r') as file:
            data = ujson.load(file)
    except OSError:
        print(f"Datei '{filename}' wurde nicht gefunden.")
    except ValueError:
        print(f"Fehler beim Einlesen der Datei '{filename}': Ungültiges JSON-Format.")

# Fügt einen neuen Eintrag zum globalen Dictionary hinzu
def add_entry(date_str, timestamp_str, values_dict):
    """
    Fügt die Messwerte unter dem jeweiligen Datum und Zeitstempel ins Dictionary ein.
    Der Timestamp wird dabei als Key verwendet, die Messwerte als Value.
    """
    global data

    if date_str not in data:
        data[date_str] = {}

    # Entferne 'unixtime' aus den Werten, da er bereits als Key verwendet wird
    values_dict.pop('unixtime')

    data[date_str][timestamp_str] = values_dict

# Speichert das globale Dictionary in die Datei 'data.json'
def save_data_to_file():
    global data
    try:
        with open("data.json", "w") as file:
            ujson.dump(data, file)
            print("Daten erfolgreich gespeichert.")
    except OSError:
        print("Fehler beim Schreiben der Datei.")

# Gibt das komplette Dictionary formatiert in der Konsole aus
def print_json_dict():
    global data
    for key, value in data.items():
        print(f"{key}: {value}")

# -----------------------------------------
# Hauptprogramm
# -----------------------------------------

# WLAN einmalig beim Start verbinden
isWiFiConnected = connect_wifi(SSID, PASSWORD)

# Hauptschleife: Alle 5 Minuten Daten abfragen und speichern
while True:
    if isWiFiConnected:
        if sync_rtc():
            shelly_data = fetch_shelly_data()
            if shelly_data:
                print("Empfangene Daten:")
                print(shelly_data)

                values = extract_shelly_values(shelly_data)
                if values:
                    print("Extrahierte Werte:")
                    print(values)

                    # Aktuelles Datum als Schlüssel
                    datum = formatDate()
                    print("Verwendbares Datum als Key:", datum)

                    filename = "data.json"
                    read_json_file(filename)
                    print("Inhalt der Datei:")
                    print_json_dict()

                    # Daten hinzufügen und speichern
                    add_entry(datum, str(values['unixtime']), values)
                    save_data_to_file()

                    # Inhalt erneut ausgeben
                    read_json_file(filename)
                    print("Aktualisierter Inhalt:")
                    print_json_dict()

    print("Warte 5 Minuten bis zum nächsten Abruf...")
    time.sleep(INTERVAL)

# -----------------------------------------------------------------------------
# Autor: Stefan Draeger
# Webseite: https://draeger-it.blog
# Beitrag: https://draeger-it.blog/shelly-1pm-esp32-daten-speichern-zeitgesteuert-senden/
#
# Beschreibung:
# Dieses MicroPython-Skript für den ESP32-C3 liest alle 5 Minuten Leistungsdaten 
# eines Shelly-Geräts per REST-Schnittstelle aus und speichert diese lokal in 
# einer JSON-Datei. Falls eine Internetverbindung besteht, werden die Daten an 
# ThingSpeak gesendet und anschließend vom Mikrocontroller gelöscht. 
# Zusätzlich wird ein Logfile "debug.log" mit Zeitstempeln geführt.
# -----------------------------------------------------------------------------

import network
import time
from machine import Pin
import urequests
import ntptime
import ujson

# Globales Dictionary zur Datenspeicherung
data = {}

# WLAN-Zugangsdaten (bitte anpassen)
SSID = "abc"
PASSWORD = "123"

# REST-Endpunkt des Shelly-Geräts
SHELLY_URL = "http://192.168.178.91/rpc/Shelly.GetStatus"

# Messintervall in Sekunden (5 Minuten)
INTERVAL = 300

# LED an GPIO 2 dient als Statusanzeige (verbunden/nicht verbunden)
led = Pin(2, Pin.OUT)

# -----------------------------------------------------------------------------
# Funktion: debugLog
# Schreibt Zeitstempel + Meldung + Schweregrad in die Datei "debug.log"
# -----------------------------------------------------------------------------
def debugLog(text, level="INFO"):
    try:
        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)

# -----------------------------------------------------------------------------
# Funktion: connect_wifi
# Baut eine WLAN-Verbindung auf und blinkt dabei die LED als Statusanzeige.
# -----------------------------------------------------------------------------
def connect_wifi(ssid, password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)

    if not wlan.isconnected():
        print("Verbinde mit WLAN...")
        wlan.connect(ssid, password)

        timeout = 10  # Sekunden
        while not wlan.isconnected() and timeout > 0:
            led.value(1 - led.value())  # LED blinkt
            time.sleep(0.5)
            timeout -= 0.5
            print(".", end="")

    if wlan.isconnected():
        led.value(1)
        debugLog("WLAN verbunden")
        debugLog("IP-Adresse: " + wlan.ifconfig()[0])
        return True
    else:
        debugLog("Verbindung fehlgeschlagen.", "ERROR")
        led.value(0)
        return False

# -----------------------------------------------------------------------------
# Funktion: sync_rtc
# Synchronisiert die interne Uhr des ESP32 mit einem NTP-Server.
# -----------------------------------------------------------------------------
def sync_rtc():
    try:
        ntptime.settime()
        debugLog("RTC erfolgreich synchronisiert.")
        return True
    except:
        debugLog("Fehler bei der RTC-Synchronisation.", "ERROR")
        return False

# -----------------------------------------------------------------------------
# Hilfsfunktion: Wandelt Unix-Timestamp in Datum (z. B. für JSON-Key)
# -----------------------------------------------------------------------------
def timestamp_to_date(timestamp):
    try:
        t = time.localtime(timestamp)
        return "{:02d}.{:02d}.{:04d}".format(t[2], t[1], t[0])
    except:
        return "00.00.0000"

# -----------------------------------------------------------------------------
# Funktion: fetch_shelly_data
# Holt aktuellen JSON-Status vom Shelly über die REST-Schnittstelle.
# -----------------------------------------------------------------------------
def fetch_shelly_data():
    try:
        response = urequests.get(SHELLY_URL)
        if response.status_code == 200:
            json_data = response.json()
            response.close()
            return json_data
        else:
            debugLog("Fehler beim Abrufen der Daten: " + str(response.status_code), "ERROR")
            response.close()
            return None
    except Exception as e:
        debugLog(f"Verbindungsfehler: {e}", "ERROR")
        return None

# -----------------------------------------------------------------------------
# Funktion: extract_shelly_values
# Extrahiert relevante Felder aus dem JSON-Response.
# -----------------------------------------------------------------------------
def extract_shelly_values(data):
    try:
        return {
            "voltage": data["switch:0"]["voltage"],
            "apower": data["switch:0"]["apower"],
            "current": data["switch:0"]["current"],
            "unixtime": data["sys"]["unixtime"]
        }
    except KeyError as e:
        debugLog(f"Fehlender Wert im JSON: {e}", "ERROR")
        return None

# Gibt das aktuelle Datum im Format TT.MM.JJJJ zurück (für JSON-Struktur)
def formatDate():
    timestamp = time.localtime()
    return "{:02d}.{:02d}.{:04d}".format(timestamp[2], timestamp[1], timestamp[0])

# -----------------------------------------------------------------------------
# Funktion: read_json_file
# Liest bestehende JSON-Datei auf dem Flash-Speicher in das globale Dictionary.
# -----------------------------------------------------------------------------
def read_json_file(filename):
    global data
    try:
        with open(filename, 'r') as file:
            data = ujson.load(file)
    except OSError:
        debugLog(f"Datei '{filename}' wurde nicht gefunden.", "ERROR")
    except ValueError:
        debugLog(f"Fehler beim Einlesen der Datei '{filename}': Ungültiges JSON-Format.", "ERROR")

# -----------------------------------------------------------------------------
# Funktion: add_entry
# Fügt einen Datensatz mit Timestamp in das Dictionary ein (Key = Datum)
# -----------------------------------------------------------------------------
def add_entry(date_str, timestamp_str, values_dict):
    global data
    if date_str not in data:
        data[date_str] = {}
    values_dict.pop('unixtime')
    data[date_str][timestamp_str] = values_dict

# -----------------------------------------------------------------------------
# Funktion: save_data_to_file
# Speichert das aktualisierte Dictionary in die Datei 'data.json'
# -----------------------------------------------------------------------------
def save_data_to_file():
    global data
    try:
        with open("data.json", "w") as file:
            ujson.dump(data, file)
            debugLog("Daten erfolgreich gespeichert.")
    except OSError:
        debugLog("Fehler beim Schreiben der Datei.", "ERROR")

# -----------------------------------------------------------------------------
# Funktion: internet_available
# Prüft, ob der ESP32 eine Verbindung zum Internet (nicht nur WLAN) hat.
# -----------------------------------------------------------------------------
def internet_available():
    try:
        response = urequests.get("http://www.google.com")
        if response.status_code == 200:
            response.close()
            debugLog("Internetverbindung verfügbar.")
            return True
        else:
            debugLog("Internetverbindung fehlgeschlagen. Status: " + str(response.status_code), "ERROR")
            response.close()
            return False
    except Exception as e:
        debugLog(f"Kein Internetzugriff: {e}", "ERROR")
        return False

# -----------------------------------------------------------------------------
# Funktion: send_data_to_thingspeak
# Überträgt die Daten an ThingSpeak und entfernt erfolgreich gesendete Einträge.
# -----------------------------------------------------------------------------
def send_data_to_thingspeak():
    global data

    THINGSPEAK_API_KEY = "9ZMMDML77HTWPMRR"
    THINGSPEAK_URL = "https://api.thingspeak.com/update.json"

    daten_zu_entfernen = []

    for datum in list(data.keys()):
        eintraege = data[datum]
        gesendete_timestamps = []

        for timestamp, werte in eintraege.items():
            try:
                payload = {
                    "api_key": THINGSPEAK_API_KEY,
                    "field1": werte.get("voltage"),
                    "field2": werte.get("apower"),
                    "field3": werte.get("current"),
                    "created_at": int(timestamp)
                }
                response = urequests.post(THINGSPEAK_URL, json=payload)
                if response.status_code == 200:
                    debugLog(f"Datensatz {timestamp} gesendet.")
                    gesendete_timestamps.append(timestamp)
                else:
                    debugLog(f"Fehler beim Senden von {timestamp}: Status {response.status_code}", "ERROR")
                response.close()
            except Exception as e:
                debugLog(f"Fehler beim Senden von {timestamp}: {e}", "ERROR")

        for ts in gesendete_timestamps:
            del data[datum][ts]

        if not data[datum]:
            daten_zu_entfernen.append(datum)

    for d in daten_zu_entfernen:
        del data[d]

    save_data_to_file()
    print("Alle gesendeten Daten wurden aus der Datei entfernt.")

# -----------------------------------------------------------------------------
# Hauptprogramm: 5-Minuten-Loop zum Messen, Speichern & ggf. Senden
# -----------------------------------------------------------------------------
isWiFiConnected = connect_wifi(SSID, PASSWORD)

while True:
    if isWiFiConnected:
        if sync_rtc():
            shelly_data = fetch_shelly_data()
            if shelly_data:
                values = extract_shelly_values(shelly_data)
                if values:
                    datum = formatDate()
                    read_json_file("data.json")
                    add_entry(datum, str(values['unixtime']), values)
                    save_data_to_file()

                # Wenn Internet vorhanden → versuche Upload
                if internet_available():
                    send_data_to_thingspeak()

    print("Warte 5 Minuten bis zum nächsten Abruf...")
    time.sleep(INTERVAL)