battery-charging-optimizer/FIX_SOC_SPIKE_REMOTE_MODE.md

# Fix: SOC Spike beim Umschalten auf REMOTE-Modus

## Problem

Beim Umschalten des ESS auf REMOTE-Modus meldet `sensor.esssoc` kurzzeitig ungültige Werte (z.B. 65535%). Dies führte zu folgenden Problemen:

1. **Automation 8** ("Stopp bei Max-SOC") triggert bei SOC > 99%
2. Die Automation deaktiviert `goodwe_manual_control`
3. Keep-Alive Automation stoppt
4. Laden wird vorzeitig abgebrochen

## Ursache

Der OpenEMS ESS liefert während des Modus-Wechsels ungültige Register-Werte, die als extrem hohe SOC-Prozentwerte interpretiert werden (z.B. 65535% = 0xFFFF als unsigned integer).

## Lösung

### 1. Automation 8: SOC-Plausibilitäts-Check

**Datei**: `automations/battery_optimizer_automations.yaml`

**Änderung**: Zusätzliche Template-Condition hinzugefügt:

```yaml
condition:
  - condition: state
    entity_id: input_boolean.goodwe_manual_control
    state: "on"
  # NEU: SOC-Plausibilitäts-Check
  - condition: template
    value_template: >
      {% set soc = states('sensor.esssoc') | float(0) %}
      {{ soc >= 99 and soc <= 101 }}
```

**Effekt**: Die Automation triggert nur noch, wenn der SOC im plausiblen Bereich von 99-101% liegt. Werte wie 65535% werden ignoriert.

### 2. Keep-Alive Automation: Schutz vor ungültigen Werten

**Datei**: `automations/speicher_manuell_laden.yaml`

**Änderung**: Zusätzliche Template-Condition hinzugefügt:

```yaml
conditions:
  - condition: state
    entity_id: input_boolean.goodwe_manual_control
    state: "on"
  # NEU: SOC-Plausibilitäts-Check
  - condition: template
    value_template: >
      {% set soc = states('sensor.esssoc') | float(50) %}
      {{ soc <= 100 }}
```

**Effekt**: Die Keep-Alive Automation sendet nur Modbus-Befehle, wenn der SOC plausibel ist (<= 100%). Bei Spikes wird der Befehl übersprungen, aber die Automation läuft beim nächsten 30s-Zyklus weiter.

## Implementierung

### Schritt 1: Backups wurden erstellt

```bash
# Automatisch erstellt:
battery_optimizer_automations.yaml.backup
speicher_manuell_laden.yaml.backup
```

### Schritt 2: Automationen in Home Assistant aktualisieren

#### Option A: YAML-Modus (empfohlen)

Wenn du die Automations über YAML-Dateien verwaltest:

1. **Öffne Home Assistant**
2. **Einstellungen** → **Automationen & Szenen**
3. **Klicke auf die drei Punkte** (⋮) → **YAML bearbeiten**
4. **Suche die beiden Automationen**:
   - "Batterie Optimierung: Stopp bei Max-SOC"
   - "Automation: Speicher manuell laden"
5. **Ersetze den Code** mit dem Inhalt aus den aktualisierten Dateien
6. **Speichern**
7. **Developer Tools** → **YAML** → **Automations neu laden**

#### Option B: UI-Modus

Wenn du die Automations über die UI erstellt hast:

1. **Öffne "Batterie Optimierung: Stopp bei Max-SOC"**
2. **Klicke auf "Bedingungen hinzufügen"** → **Vorlage**
3. **Füge ein**:
   ```yaml
   {% set soc = states('sensor.esssoc') | float(0) %}
   {{ soc >= 99 and soc <= 101 }}
   ```
4. **Speichern**

5. **Öffne "Automation: Speicher manuell laden"**
6. **Klicke auf "Bedingungen hinzufügen"** → **Vorlage**
7. **Füge ein**:
   ```yaml
   {% set soc = states('sensor.esssoc') | float(50) %}
   {{ soc <= 100 }}
   ```
8. **Speichern**

### Schritt 3: Automationen neu laden

```yaml
Developer Tools → YAML → Automations neu laden
```

## Test-Anleitung

### Test 1: Manuelles Laden mit Spike-Simulation

1. **Setze manuelles Laden**:
   ```
   input_boolean.goodwe_manual_control = on
   ```

2. **Überwache in den Logs**:
   ```
   Einstellungen → System → Logs
   Filter: "automation"
   ```

3. **Prüfe**, dass Keep-Alive läuft:
   - Alle 30 Sekunden sollte "OpenEMS ESS Ziel: -5000.0 W" erscheinen

4. **Simuliere ungültigen SOC** (nur zum Testen):
   ```yaml
   # Developer Tools → States
   # Ändere temporär sensor.esssoc auf 65535
   ```

5. **Erwartetes Verhalten**:
   - Keep-Alive überspringt diesen Zyklus
   - Automation 8 triggert NICHT
   - `goodwe_manual_control` bleibt `on`
   - Beim nächsten Zyklus (wenn SOC wieder normal) läuft Keep-Alive weiter

### Test 2: Automatischer Ladeplan

1. **Aktiviere Optimizer**:
   ```
   input_boolean.battery_optimizer_enabled = on
   ```

2. **Trigger manuelle Berechnung**:
   ```yaml
   Developer Tools → Services
   Service: pyscript.calculate_charging_schedule
   ```

3. **Warte auf nächste Ladestunde** oder trigger manuell:
   ```yaml
   Developer Tools → Services
   Service: pyscript.execute_charging_schedule
   ```

4. **Überwache Umschaltung auf REMOTE**:
   - Logs sollten zeigen: "OpenEMS ESS Ziel: -5000.0 W"
   - Keine vorzeitigen Stops durch Automation 8

### Test 3: Echtes Laden bis 100%

1. **Starte Laden bei niedrigem SOC** (z.B. 20%)
2. **Lass System bis 100% laden**
3. **Erwartetes Verhalten**:
   - Bei ca. 99% echter SOC: Automation 8 triggert
   - `goodwe_manual_control` wird deaktiviert
   - ESS geht auf INTERNAL-Modus
   - Notification: "Manuelles Laden beendet - SOC 100% erreicht"

## Monitoring

### Wichtige Log-Einträge

**Erfolgreicher Schutz vor Spike**:
```
Keep-Alive Automation: Condition failed (SOC check)
```

**Normales Keep-Alive**:
```
OpenEMS ESS Ziel: -5000.0 W -> 706 -> [reg1, reg2]
```

**Automation 8 triggert bei echten 100%**:
```
Batterie-Optimierung: Manuelles Laden beendet - SOC 100% erreicht
```

### Developer Tools State Monitoring

```yaml
# Überwache diese Entities:
sensor.esssoc                           # Sollte 0-100% sein
input_boolean.goodwe_manual_control     # Sollte nicht flackern
pyscript.battery_charging_schedule      # Check Attribute "schedule"
```

## Rollback (falls nötig)

Falls Probleme auftreten:

```bash
# Im Terminal:
cd /Users/felix/Nextcloud/AI/projects/homeassistant/openems/automations/

# Restore Backups:
mv battery_optimizer_automations.yaml.backup battery_optimizer_automations.yaml
mv speicher_manuell_laden.yaml.backup speicher_manuell_laden.yaml

# Dann in Home Assistant:
# Developer Tools → YAML → Automations neu laden
```

## Weitere Verbesserungen (optional)

### PyScript-Logging erweitern

In `battery_charging_optimizer.py`, Zeile 68-75:

```python
# SOC-Plausibilitäts-Check (filtert ungültige Werte wie 65535%)
if current_soc > 100 or current_soc < 0:
    log.warning(f"⚠ Ungültiger SOC-Wert erkannt: {current_soc}%. Verwende Fallback-Wert 50%.")
    current_soc = 50
```

**Empfehlung**: Bereits vorhanden und funktioniert korrekt.

### ESS-Sensor Smoothing (langfristig)

Erwäge einen Template-Sensor mit Averaging:

```yaml
# configuration.yaml
template:
  - sensor:
      - name: "ESS SOC Smoothed"
        unit_of_measurement: "%"
        state: >
          {% set current = states('sensor.esssoc') | float(50) %}
          {% if current > 100 or current < 0 %}
            {{ states('sensor.esssoc_smoothed') | float(50) }}
          {% else %}
            {{ current }}
          {% endif %}
```

## Changelog

**Version**: 3.3.2 (Fix)
**Datum**: 2024-11-30
**Änderungen**:
- ✅ Automation 8: SOC-Plausibilitäts-Check (99-101%)
- ✅ Keep-Alive: SOC-Plausibilitäts-Check (<= 100%)
- ✅ Backups erstellt
- ✅ Dokumentation

**Behobenes Problem**:
- Vorzeitiger Stop beim Umschalten auf REMOTE-Modus durch ungültige SOC-Werte

**Getestet**: Wartet auf User-Test

## Support

Bei Problemen:
1. Prüfe Home Assistant Logs
2. Prüfe `sensor.esssoc` Wert in Developer Tools → States
3. Prüfe Automation-Trace: Einstellungen → Automationen → (Automation auswählen) → Trace
4. Vergleiche mit Backup-Dateien