EVCC Integration

🔗 Was ist EVCC?

EVCC (Electric Vehicle Charge Controller) ist eine Open-Source EV-Charging Steuerung für Heimnutzer.

• Website: evcc.io
• GitHub: github.com/evcc-io/evcc
• Dokumentation: docs.evcc.io
• Demo-Video: YouTube
• Screenshot: GitHub

Features von EVCC

• ⚡ EV-Charging Optimierung - Lädt Auto mit Solarstrom
• 🔋 Batterie-Management - Intelligente Lade-/Entlade-Steuerung
• 📊 Dynamic Tariffs - Günstig laden bei Niedrigpreisen
• 🏠 Home Energy Management - Eigenverbrauch maximieren
• 🌐 60+ Wallboxen - go-eCharger, Wallbox, etc.
• 🔌 100+ Geräte - Wechselrichter, Zähler, Batterien

---

🎯 SolarLog + EVCC = Perfekte Kombination

Unterschiedliche Zielgruppen

EVCC	SolarLog
Heimnutzer mit 1 Standort	Installateure mit 100+ Standorten
EV-Charging Optimierung	Multi-Site Monitoring
Lokal installiert (Go Binary)	Cloud-Native SaaS
Kostenlos (Open Source)	20-50€/Monat/Standort

Hybrid-Ansatz: "EVCC Enterprise Wrapper"

┌────────────────────────────────────────────────────┐
│  Standort 1: Niederlauer                           │
│  ┌──────────────────────────────────────────────┐  │
│  │ EVCC (lokal installiert)                     │  │
│  │ ├─ Kostal PLENTICORE plus 4.2               │  │
│  │ ├─ BYD HVS 7.7 Batterie                     │  │
│  │ ├─ Wallbox go-eCharger                      │  │
│  │ └─ Optimiert EV-Laden mit Solarstrom        │  │
│  └──────────────────────────────────────────────┘  │
│           │                                        │
│           ▼ HTTP API (Port 7070)                   │
│  ┌──────────────────────────────────────────────┐  │
│  │ SolarLog Agent (ESP32 oder Raspberry Pi)    │  │
│  │ ├─ Pollt EVCC API alle 30s                  │  │
│  │ └─ Sendet Daten an Cloud                    │  │
│  └──────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────┘
           │
           ▼ HTTPS (Cloudflare Tunnel)
┌────────────────────────────────────────────────────┐
│  SolarLog Cloud (Multi-Tenant)                     │
│  https://solarlog.karma.organic                    │
│  ┌──────────────────────────────────────────────┐  │
│  │ Dashboard für Installateur                   │  │
│  │ ├─ Standort 1: 3.8 kW ✅                     │  │
│  │ ├─ Standort 2: 5.2 kW ✅                     │  │
│  │ ├─ Standort 3: 0.0 kW ❌ (Fehler)            │  │
│  │ └─ ... (97 weitere Standorte)               │  │
│  └──────────────────────────────────────────────┘  │
└────────────────────────────────────────────────────┘

---

📡 EVCC API Integration

EVCC API Endpunkte

EVCC bietet eine einfache REST API:

# Basis-URL (lokal)
http://localhost:7070

# Haupt-Endpunkte
GET  /api/state              # Aktueller Systemstatus
GET  /api/site               # Site-Konfiguration
GET  /api/loadpoints         # Wallbox-Status
GET  /api/vehicles           # Fahrzeug-Status
GET  /api/battery            # Batterie-Status

Beispiel: Daten von EVCC abrufen

import requests
import time

EVCC_BASE_URL = "http://localhost:7070"
SOLARLOG_API = "https://solarlog-api.karma.organic/api/v1"
SOLARLOG_TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."

def fetch_evcc_state():
    """Hole aktuellen Zustand von EVCC"""
    response = requests.get(f"{EVCC_BASE_URL}/api/state")
    return response.json()

def transform_to_solarlog_format(evcc_data):
    """Transformiere EVCC-Daten ins SolarLog-Format"""
    return {
        "current_power": evcc_data.get("pvPower", 0),           # W
        "total_energy": evcc_data.get("pvEnergy", 0) * 1000,    # Wh
        "grid_power": evcc_data.get("gridPower", 0),            # W (negativ = Einspeisung)
        "battery_soc": evcc_data.get("batterySoc", 0),          # %
        "battery_power": evcc_data.get("batteryPower", 0),      # W
        "home_consumption": evcc_data.get("homePower", 0),      # W
    }

def send_to_solarlog(site_id, data):
    """Sende Daten an SolarLog Cloud"""
    headers = {"Authorization": f"Bearer {SOLARLOG_TOKEN}"}
    response = requests.post(
        f"{SOLARLOG_API}/sites/{site_id}/production",
        json=data,
        headers=headers
    )
    return response.status_code == 201

def main():
    """Hauptschleife: Alle 30 Sekunden Daten übertragen"""
    while True:
        try:
            # 1. Daten von EVCC holen
            evcc_data = fetch_evcc_state()

            # 2. Format konvertieren
            solarlog_data = transform_to_solarlog_format(evcc_data)

            # 3. An Cloud senden
            success = send_to_solarlog("niederlauer", solarlog_data)

            if success:
                print(f"✅ Daten gesendet: {solarlog_data['current_power']} W")
            else:
                print("❌ Fehler beim Senden")

        except Exception as e:
            print(f"⚠️ Error: {e}")

        time.sleep(30)

if __name__ == "__main__":
    main()

Beispiel-Response von EVCC

{
  "pvPower": 3800,          // Aktuelle PV-Leistung (W)
  "pvEnergy": 24.5,         // Tagesertrag (kWh)
  "gridPower": -1200,       // Netz (-) = Einspeisung, (+) = Bezug
  "homePower": 800,         // Hausverbrauch (W)
  "batteryPower": 1800,     // Batterie (+) = Laden, (-) = Entladen
  "batterySoc": 85,         // Batterie-SOC (%)
  "loadpoints": [
    {
      "title": "Garage",
      "chargePower": 0,     // Wallbox-Leistung (W)
      "chargeEnergy": 12.5, // Heute geladen (kWh)
      "mode": "pv"          // Lademodus
    }
  ]
}

---

🌐 EVCC Device Support

EVCC unterstützt 100+ Geräte aus verschiedenen Kategorien. SolarLog kann diese Geräte-Datenbank nutzen.

Vollständige Liste

Siehe: docs.evcc.io/docs/devices/meters

Wichtigste Kategorien

⚡ PV-Wechselrichter (60+ Hersteller)

Modbus TCP: - SMA: Sunny Boy, Sunny Tripower, Sunny Island - Kostal: PLENTICORE, PIKO - Fronius: Symo, Primo, Eco - SolarEdge: SE3K-SE27K (SunSpec) - Huawei: SUN2000 Serie - GoodWe: GW-Serie (ET, DT, DNS, MS) - Growatt: MIN, MOD, MAX Serie - Delta: RPI Serie (M/H)

HTTP REST API: - Kostal: PLENTICORE (REST API + Modbus) - Fronius: Solar API v1 - SMA: Webconnect, Speedwire

Cloud API: - Solax: Cloud API - Solarman: Cloud API - GoodWe: SEMS Portal

🔋 Batteriespeicher

• Tesla: Powerwall 2/3 (JSON API)
• BYD: HVS/HVM Serie (Modbus)
• Sonnen: sonnenbatterie (HTTP API)
• SENEC: Home V2/V3 (HTTP API)
• E3/DC: S10 Serie (RSCP)
• LG: RESU Serie
• Varta: pulse/element

🏠 Smart Meter / Energiezähler

• SMA: Energy Meter (Speedwire)
• Discovergy: Cloud API
• Shelly: 3EM, Pro 3EM (HTTP)
• Fronius: Smart Meter (Modbus)
• Eastron: SDM120/230/630 (Modbus)
• Carlo Gavazzi: EM Serie (Modbus)

🚗 EV-Charger / Wallboxen

• go-eCharger: Home+/Gemini (HTTP API)
• Wallbox: Pulsar/Commander (Cloud)
• ABL: eMH1 (Modbus)
• KEBA: KeContact P30 (UDP)
• Heidelberg: Energy Control (Modbus)
• OpenWB: (MQTT)

---

🛠️ SolarLog Agent (ESP32/Raspberry Pi)

Für die Integration mit EVCC kann ein kleiner Agent auf einem ESP32 oder Raspberry Pi laufen.

Option 1: ESP32 (16€)

// ESP32 Code (Arduino)
#include <WiFi.h>
#include <HTTPClient.h>
#include <ArduinoJson.h>

const char* EVCC_URL = "http://192.168.1.100:7070/api/state";
const char* SOLARLOG_API = "https://solarlog-api.karma.organic/api/v1/sites/niederlauer/production";
const char* JWT_TOKEN = "eyJhbGciOiJIUzI1...";

void setup() {
  Serial.begin(115200);
  WiFi.begin("SSID", "password");

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");
}

void loop() {
  // 1. Daten von EVCC holen
  HTTPClient http;
  http.begin(EVCC_URL);
  int httpCode = http.GET();

  if (httpCode == 200) {
    String payload = http.getString();

    // 2. JSON parsen
    DynamicJsonDocument doc(2048);
    deserializeJson(doc, payload);

    float pvPower = doc["pvPower"];
    float pvEnergy = doc["pvEnergy"];
    float gridPower = doc["gridPower"];

    // 3. An SolarLog senden
    sendToSolarLog(pvPower, pvEnergy * 1000, gridPower);
  }

  http.end();
  delay(30000); // 30 Sekunden
}

void sendToSolarLog(float power, float energy, float grid) {
  HTTPClient http;
  http.begin(SOLARLOG_API);
  http.addHeader("Content-Type", "application/json");
  http.addHeader("Authorization", String("Bearer ") + JWT_TOKEN);

  String json = "{\"current_power\":" + String(power) + 
                ",\"total_energy\":" + String(energy) + 
                ",\"grid_power\":" + String(grid) + "}";

  int httpCode = http.POST(json);
  Serial.println(httpCode == 201 ? "✅ Sent" : "❌ Error");
  http.end();
}

Option 2: Raspberry Pi (Python)

# Installation
sudo apt install python3-pip
pip3 install requests

# Systemd Service
sudo nano /etc/systemd/system/solarlog-agent.service

[Unit]
Description=SolarLog EVCC Agent
After=network.target

[Service]
Type=simple
User=pi
WorkingDirectory=/home/pi/solarlog-agent
ExecStart=/usr/bin/python3 /home/pi/solarlog-agent/agent.py
Restart=always

[Install]
WantedBy=multi-user.target

# Aktivieren
sudo systemctl enable solarlog-agent
sudo systemctl start solarlog-agent
sudo systemctl status solarlog-agent

---

🎯 Vorteile der EVCC-Integration

Für Heimnutzer

• ✅ EVCC bleibt lokal → alle EV-Features verfügbar
• ✅ Keine Änderung an EVCC-Konfiguration
• ✅ SolarLog Agent optional → kann deaktiviert werden
• ✅ Daten bleiben lokal (nur Statistiken an Cloud)

Für Installateure

• ✅ EVCC als "Treiber" für alle Geräte
• ✅ 100+ Geräte sofort unterstützt
• ✅ Kein eigener Modbus/HTTP-Code notwendig
• ✅ Community-Support von EVCC nutzen
• ✅ Updates automatisch von EVCC

Für SolarLog

• ✅ Fokus auf Multi-Site Management
• ✅ Keine Geräte-Treiber pflegen
• ✅ EVCC übernimmt Hardware-Kompatibilität
• ✅ Synergie statt Konkurrenz

---

📊 Business Model

Pricing für Installateure

EVCC	SolarLog Agent	SolarLog Cloud
Kostenlos	Kostenlos	20€/Monat/Standort

Beispiel-Rechnung:

Installateur mit 100 Kunden:
├─ 100x EVCC installiert (kostenlos)
├─ 100x SolarLog Agent (ESP32 @ 16€ = 1.600€ einmalig)
└─ 100x SolarLog Cloud (20€/Monat = 2.000€ MRR)

Investition: 1.600€
Monatlicher Umsatz: 2.000€
ROI: < 1 Monat!

---

🚀 Roadmap

Phase 1: EVCC API Adapter (Q4 2025)

• ✅ Python-Adapter für EVCC API
• ✅ ESP32 Agent-Code
• ✅ Raspberry Pi systemd Service

Phase 2: Geräte-Mapping (Q1 2026)

• EVCC Device-DB importieren
• Auto-Discovery von EVCC-Installationen
• Geräte-Profiles (Kostal, SMA, etc.)

Phase 3: Hybrid-Dashboard (Q2 2026)

• EVCC-Daten in SolarLog Dashboard
• Link zu lokaler EVCC-Instanz
• Unified Monitoring (Multi-Site)

Phase 4: Production (Q3 2026)

• Beta-Test mit 10 Installateuren
• Hardware-Kits verfügbar
• White-Label Option

---

🔗 Ressourcen

• EVCC Website: evcc.io
• EVCC Docs: docs.evcc.io
• EVCC GitHub: github.com/evcc-io/evcc
• EVCC Devices: docs.evcc.io/docs/devices/meters
• Demo Video: YouTube
• Screenshot: GitHub