Skoda: Schluessel in den Einstellungen, Ladungen am Stueck, Wallbox in kW
- neuer Reiter "Fahrzeug": API-Schluessel eintragen und pruefen, ohne dass ein Wert je an den Browser zurueckgeht (restricted/skodaKeys.php) - ajax/skoda.php trennt Ladungen am Zustand statt an 30 Minuten Pause und rahmt sie mit der Zeile davor und danach ein - solarLog_skoda_ladepunkte.sql: Wallbox-Verlauf waehrend einer Ladung - Kachelformat "leistung_kw" fuer Quellen, die schon Kilowatt melden - Steckersymbol versteht evPlug als 1/0 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Claude Opus 5
@@ -10,6 +10,9 @@
|
||||
* GET ?action=geraete Geraete mit Raum, Verwendung und Alter
|
||||
* POST ?action=geraete-raeume {"rooms": {"12": "OG/Bad", ...}}
|
||||
* POST ?action=geraet-loeschen {"id": 12}
|
||||
* GET ?action=skoda-keys Stand der Fahrzeug-Schluessel (ohne Werte!)
|
||||
* POST ?action=skoda-keys-save {"felder": {"API_KEY2": "..."},
|
||||
* "loeschen": ["API_KEY3"]}
|
||||
*
|
||||
* Ein reiner Verteiler: geprueft und geschrieben wird in
|
||||
* restricted/costs.php bzw. restricted/kacheln.php, damit Maske und Endpunkt
|
||||
@@ -20,6 +23,7 @@ require_once("../helper.php");
|
||||
require_once("../restricted/costs.php");
|
||||
require_once("../restricted/kacheln.php");
|
||||
require_once("../restricted/automations.php");
|
||||
require_once("../restricted/skodaKeys.php");
|
||||
|
||||
if (!checkLogin()) {
|
||||
http_response_code(403);
|
||||
@@ -86,11 +90,23 @@ if ($_SERVER["REQUEST_METHOD"] === "POST") {
|
||||
$name = geraetLoeschen($body["id"] ?? 0);
|
||||
jsonAntwort(["geloescht" => $name, "geraete" => geraeteListe()]);
|
||||
|
||||
case "skoda-keys-save":
|
||||
/*
|
||||
* Neue Schluessel eintragen. Zurueck kommt der neue Stand -
|
||||
* aber nie ein Wert, siehe restricted/skodaKeys.php.
|
||||
*/
|
||||
jsonAntwort(skodaSchluesselSpeichern(
|
||||
$body["felder"] ?? [], $body["loeschen"] ?? []));
|
||||
|
||||
default:
|
||||
jsonAntwort(["error" => "Unbekannte Aktion."], 400);
|
||||
}
|
||||
} catch (InvalidArgumentException $e) {
|
||||
jsonAntwort(["error" => $e->getMessage()], 400);
|
||||
} catch (RuntimeException $e) {
|
||||
// Nicht die Eingabe, sondern die Umgebung - Datei fehlt, Rechte
|
||||
// fehlen. Die Meldung sagt schon, was zu tun ist; kein Vorspann.
|
||||
jsonAntwort(["error" => $e->getMessage()], 500);
|
||||
} catch (Throwable $e) {
|
||||
jsonAntwort(["error" => "Speichern fehlgeschlagen: " . $e->getMessage()], 500);
|
||||
}
|
||||
@@ -114,6 +130,14 @@ if ($action === "kacheln") {
|
||||
}
|
||||
}
|
||||
|
||||
if ($action === "skoda-keys") {
|
||||
try {
|
||||
jsonAntwort(skodaStand());
|
||||
} catch (Throwable $e) {
|
||||
jsonAntwort(["error" => "Schlüssel nicht abrufbar: " . $e->getMessage()], 500);
|
||||
}
|
||||
}
|
||||
|
||||
if ($action === "geraete") {
|
||||
try {
|
||||
jsonAntwort(["geraete" => geraeteListe(), "raeume" => raumListe()]);
|
||||
|
||||
+232
-35
@@ -42,54 +42,100 @@ if ($mysql->connect_errno) {
|
||||
$mysql->set_charset("utf8mb4");
|
||||
|
||||
/*
|
||||
* Ladevorgänge aus den Einzelzeilen schneiden. Aufeinanderfolgende Zeilen mit
|
||||
* chg_state = 'CHARGING' gehören zusammen, eine Pause über 30 Minuten trennt
|
||||
* zwei Vorgänge. Wird von mehreren Abschnitten gebraucht, deshalb einmal hier.
|
||||
* Ladevorgänge aus den Einzelzeilen schneiden. Wird von mehreren Abschnitten
|
||||
* gebraucht, deshalb einmal hier.
|
||||
*
|
||||
* Eine Ladung ist eine ununterbrochene Folge von Zeilen mit chg_state =
|
||||
* 'CHARGING'. Getrennt wird durch eine Zeile mit einem anderen Zustand, nicht
|
||||
* durch die Zeit dazwischen: gatherSkodaData.py schreibt nur, wenn das
|
||||
* Fahrzeug etwas Neues meldet, und beim Laden an der Wallbox tut es das
|
||||
* mitunter nur einmal in der Stunde. Früher trennte eine Pause über 30
|
||||
* Minuten - eine Ladung von 51 auf 80 % am 13.09.2026 zerfiel dadurch in drei
|
||||
* Stücke mit 0, 4 und 0 Prozentpunkten. Hört das Fahrzeug auf zu laden,
|
||||
* steht das in der nächsten Zeile; die Zeit allein trennt nur noch, wenn sie
|
||||
* so lang ist, dass der Abruf offenbar nicht lief (LADUNG_LUECKE_S).
|
||||
*
|
||||
* Dazu gehören die beiden Zeilen, die die Ladung einrahmen. Die davor sagt,
|
||||
* mit welchem Ladestand und Zählerstand sie begann - die erste CHARGING-Zeile
|
||||
* kommt oft erst Minuten später und hat dann schon geladen. Die danach
|
||||
* (CONNECT_CABLE, READY_FOR_CHARGING, ...) trägt den erreichten Ladestand:
|
||||
* bei einer Ladung bis zum Ziel ist das die einzige Zeile mit 80 %.
|
||||
*
|
||||
* Die Energie kommt aus der Differenz der Wallbox-Zählerstände statt aus einer
|
||||
* Summe über Leistungswerte - das trifft den Ladevorgang auf die Wattstunde.
|
||||
* Steht der Zähler still, wurde auswärts geladen (Schnellladesäule); dann
|
||||
* bleibt wh null und die Kapazitätsrechnung lässt die Ladung aus.
|
||||
* Ein Zählerstand 0 ist kein Stand, sondern ein ausgefallener Abruf der
|
||||
* Wallbox, und bleibt außen vor. Steht der Zähler still, wurde auswärts
|
||||
* geladen (Schnellladesäule); dann bleibt wh null und die Kapazitätsrechnung
|
||||
* lässt die Ladung aus.
|
||||
*/
|
||||
const LADUNG_LUECKE_S = 3 * 3600;
|
||||
|
||||
function sitzungenSQL($seit)
|
||||
{
|
||||
$luecke = LADUNG_LUECKE_S;
|
||||
return "
|
||||
SELECT MIN(datetime) AS beginn, MAX(datetime) AS ende,
|
||||
MIN(soc) AS soc_von, MAX(soc) AS soc_bis,
|
||||
CAST(MAX(soc) AS SIGNED) - CAST(MIN(soc) AS SIGNED) AS zuwachs,
|
||||
MIN(soc_start) AS soc_von, MAX(soc) AS soc_bis,
|
||||
CAST(MAX(soc) AS SIGNED) - CAST(MIN(soc_start) AS SIGNED) AS zuwachs,
|
||||
MAX(chg_type) AS art, MAX(target_soc) AS ziel,
|
||||
ROUND(AVG(chg_kw), 2) AS kw_mittel, ROUND(MAX(chg_kw), 2) AS kw_spitze,
|
||||
MAX(wb_wh_total) - MIN(wb_wh_total) AS wh,
|
||||
ROUND(SUM(kwh_teil), 3) AS kwh_fahrzeug,
|
||||
ROUND(AVG(pv_kw), 2) AS pv_kw, COUNT(*) AS punkte
|
||||
ROUND(AVG(CASE WHEN laedt THEN chg_kw END), 2) AS kw_mittel,
|
||||
ROUND(MAX(CASE WHEN laedt THEN chg_kw END), 2) AS kw_spitze,
|
||||
COALESCE(MAX(NULLIF(wb_wh_total, 0)) - MIN(wh_start), 0) AS wh,
|
||||
/*
|
||||
* Fahrzeugseitige Energie nur, wenn sie lückenlos integriert werden
|
||||
* konnte - siehe kwh_teil. Sonst NULL: eine halbe Summe sähe aus
|
||||
* wie eine kleine Ladung und verfälschte die Kapazitätsrechnung.
|
||||
*/
|
||||
CASE WHEN SUM(zu_lang) = 0 THEN ROUND(SUM(kwh_teil), 3) END AS kwh_fahrzeug,
|
||||
ROUND(AVG(CASE WHEN laedt THEN pv_kw END), 2) AS pv_kw,
|
||||
COUNT(*) AS punkte
|
||||
FROM (
|
||||
SELECT b.*, SUM(b.neu) OVER (ORDER BY b.datetime) AS sitzung FROM (
|
||||
SELECT a.*,
|
||||
a.chg_state = 'CHARGING' AS laedt,
|
||||
(a.st_vor <=> 'CHARGING' AND a.dt_vor <= $luecke) AS weiter,
|
||||
CASE WHEN a.chg_state = 'CHARGING'
|
||||
AND NOT (a.st_vor <=> 'CHARGING' AND a.dt_vor <= $luecke)
|
||||
THEN 1 ELSE 0 END AS neu,
|
||||
-- Beginn aus der Zeile davor, wenn sie nah genug liegt.
|
||||
CASE WHEN a.chg_state = 'CHARGING' AND NOT (a.st_vor <=> 'CHARGING')
|
||||
AND a.dt_vor <= $luecke
|
||||
THEN LEAST(a.soc, COALESCE(a.soc_vor, a.soc))
|
||||
ELSE a.soc END AS soc_start,
|
||||
CASE WHEN a.chg_state = 'CHARGING' AND NOT (a.st_vor <=> 'CHARGING')
|
||||
AND a.dt_vor <= $luecke
|
||||
THEN COALESCE(NULLIF(a.wh_vor, 0), NULLIF(a.wb_wh_total, 0))
|
||||
ELSE NULLIF(a.wb_wh_total, 0) END AS wh_start,
|
||||
/*
|
||||
* chg_kw ist die Ladeleistung, die das Fahrzeug selbst meldet -
|
||||
* gemessen HINTER dem Ladegerät. Die API kennt keine
|
||||
* Kilowattstunden, deshalb wird über die Zeit integriert, je
|
||||
* Schritt mit dem Mittel aus vorigem und aktuellem Wert.
|
||||
*
|
||||
* Über mehr als 30 Minuten ohne Meldung wäre die Fläche unter
|
||||
* der Kurve erfunden: die Leistung kann in der Zeit von 4 auf
|
||||
* 10 kW gestiegen sein, ohne dass eine Zeile davon weiß.
|
||||
* zu_lang merkt sich das, und die Ladung bekommt dann keinen
|
||||
* fahrzeugseitigen Wert.
|
||||
*/
|
||||
CASE WHEN a.st_vor <=> 'CHARGING' AND a.dt_vor BETWEEN 1 AND $luecke
|
||||
THEN (COALESCE(a.chg_kw, 0) + COALESCE(a.kw_vor, 0)) / 2
|
||||
* a.dt_vor / 3600
|
||||
ELSE 0 END AS kwh_teil,
|
||||
CASE WHEN a.st_vor <=> 'CHARGING' AND a.dt_vor > 1800
|
||||
THEN 1 ELSE 0 END AS zu_lang
|
||||
FROM (
|
||||
SELECT s.*, SUM(s.neu) OVER (ORDER BY s.datetime) AS sitzung FROM (
|
||||
SELECT datetime, soc, chg_state, chg_type, chg_kw, target_soc,
|
||||
wb_wh_total, pv_kw,
|
||||
CASE WHEN LAG(chg_state) OVER w <=> 'CHARGING'
|
||||
AND TIMESTAMPDIFF(MINUTE, LAG(datetime) OVER w, datetime) <= 30
|
||||
THEN 0 ELSE 1 END AS neu,
|
||||
/*
|
||||
* Fahrzeugseitige Energie: chg_kw ist die Ladeleistung, die
|
||||
* das Fahrzeug selbst meldet - gemessen HINTER dem Ladegerät.
|
||||
* Die API kennt keine Kilowattstunden, deshalb wird hier über
|
||||
* die Zeit integriert, je Schritt mit dem Mittel aus vorigem
|
||||
* und aktuellem Wert (Trapez). Beim Laden mit Wechselstrom
|
||||
* liegt die Leistung fast konstant an, da ist das genau genug.
|
||||
*
|
||||
* Die Bedingung hält die Summe innerhalb einer Ladung: über
|
||||
* eine Lücke von mehr als 30 Minuten hinweg wäre die Fläche
|
||||
* unter der Kurve frei erfunden.
|
||||
*/
|
||||
CASE WHEN LAG(chg_state) OVER w <=> 'CHARGING'
|
||||
AND TIMESTAMPDIFF(SECOND, LAG(datetime) OVER w, datetime)
|
||||
BETWEEN 1 AND 1800
|
||||
THEN (COALESCE(chg_kw, 0) + COALESCE(LAG(chg_kw) OVER w, 0)) / 2
|
||||
* TIMESTAMPDIFF(SECOND, LAG(datetime) OVER w, datetime) / 3600
|
||||
ELSE 0 END AS kwh_teil
|
||||
LAG(chg_state) OVER w AS st_vor,
|
||||
TIMESTAMPDIFF(SECOND, LAG(datetime) OVER w, datetime) AS dt_vor,
|
||||
LAG(soc) OVER w AS soc_vor,
|
||||
LAG(wb_wh_total) OVER w AS wh_vor,
|
||||
LAG(chg_kw) OVER w AS kw_vor
|
||||
FROM skoda WHERE datetime >= $seit
|
||||
WINDOW w AS (ORDER BY datetime)) s) t
|
||||
WHERE chg_state = 'CHARGING'
|
||||
WINDOW w AS (ORDER BY datetime)) a) b) t
|
||||
-- Die Ladezeilen und die eine Zeile, mit der die Ladung endet.
|
||||
WHERE laedt OR weiter
|
||||
GROUP BY sitzung";
|
||||
}
|
||||
|
||||
@@ -167,6 +213,154 @@ function kapazitaetSchaetzen($mysql)
|
||||
];
|
||||
}
|
||||
|
||||
/**
|
||||
* Verlauf einer Ladung: Wallbox-Leistung dicht, Ladestand dazwischen gefüllt.
|
||||
*
|
||||
* Das Fahrzeug meldet beim Laden an der Wallbox mitunter nur einmal in der
|
||||
* Stunde, die Wallbox steht in skoda_ladepunkte im Minutentakt (siehe
|
||||
* solarLog_skoda_ladepunkte.sql). Der Ladestand zwischen zwei Meldungen wird
|
||||
* nach der geflossenen Energie aufgefüllt, nicht nach der Zeit:
|
||||
*
|
||||
* soc(t) = soc_a + (soc_b - soc_a) * (wh(t) - wh_a) / (wh_b - wh_a)
|
||||
*
|
||||
* Das braucht weder Akkukapazität noch Wirkungsgrad. Gegengeprüft am
|
||||
* 13.09.2026: zwischen 56 % (09:59) und 70 % (11:22) ergibt es für 10:29
|
||||
* 59,6 % - gemeldet waren 60 %. Nach der Zeit wären es 61,1 % gewesen.
|
||||
*
|
||||
* Eine Meldung gilt für den Zeitpunkt, zu dem das Fahrzeug sie erfasst hat
|
||||
* (cap_chg), nicht für den Abruf - dazwischen können Minuten mit 11 kW
|
||||
* liegen. Der Zählerstand zu diesem Zeitpunkt kommt deshalb aus dem
|
||||
* Wallbox-Verlauf selbst und nicht aus der Zeile.
|
||||
*
|
||||
* Vor der ersten und nach der letzten Meldung bleibt der Ladestand leer:
|
||||
* hochgerechnet wird nichts.
|
||||
*
|
||||
* Liefert [verlauf, meldungen, wallbox]; ohne Punkte in skoda_ladepunkte
|
||||
* zwei leere Listen - dann zeichnet die Seite wie früher aus den Zeilen.
|
||||
*/
|
||||
function ladeverlauf($mysql, $von, $bis)
|
||||
{
|
||||
// Welche Wallbox: die, die im Zeitraum Energie abgegeben hat.
|
||||
$stmt = $mysql->prepare(
|
||||
"SELECT wallbox, MAX(wh_total) - MIN(wh_total) AS wh, COUNT(*) AS n
|
||||
FROM skoda_ladepunkte
|
||||
WHERE datetime BETWEEN (? - INTERVAL 30 MINUTE) AND (? + INTERVAL 30 MINUTE)
|
||||
GROUP BY wallbox ORDER BY wh DESC, n DESC LIMIT 1");
|
||||
if (!$stmt) {
|
||||
return [[], [], null]; // Tabelle fehlt noch
|
||||
}
|
||||
$stmt->bind_param("ss", $von, $bis);
|
||||
$stmt->execute();
|
||||
$wahl = $stmt->get_result()->fetch_assoc();
|
||||
if (!$wahl) {
|
||||
return [[], [], null];
|
||||
}
|
||||
$wallbox = $wahl["wallbox"];
|
||||
$spalte = $wallbox === "og" ? "wbog_wh_total" : "wb_wh_total";
|
||||
|
||||
$stmt = $mysql->prepare(
|
||||
"SELECT datetime, kw, wh_total, quelle FROM skoda_ladepunkte
|
||||
WHERE wallbox = ? AND datetime BETWEEN (? - INTERVAL 30 MINUTE) AND (? + INTERVAL 30 MINUTE)
|
||||
ORDER BY datetime");
|
||||
$stmt->bind_param("sss", $wallbox, $von, $bis);
|
||||
$stmt->execute();
|
||||
$res = $stmt->get_result();
|
||||
$verlauf = [];
|
||||
while ($z = $res->fetch_assoc()) {
|
||||
$verlauf[] = [
|
||||
"datetime" => $z["datetime"],
|
||||
"t" => strtotime($z["datetime"]),
|
||||
"kw" => floatval($z["kw"]),
|
||||
"wh" => $z["wh_total"] === null ? null : intval($z["wh_total"]),
|
||||
"quelle" => $z["quelle"],
|
||||
];
|
||||
}
|
||||
if (!$verlauf) {
|
||||
return [[], [], null];
|
||||
}
|
||||
|
||||
// Zählerstand zu einem beliebigen Zeitpunkt, aus dem Verlauf. Vor dem
|
||||
// ersten Punkt ruhte die Wallbox - dann gilt der Stand, den die Zeile
|
||||
// selbst trägt.
|
||||
$zaehlerBei = function ($t, $ersatz) use ($verlauf) {
|
||||
$vor = null;
|
||||
foreach ($verlauf as $p) {
|
||||
if ($p["wh"] === null) {
|
||||
continue;
|
||||
}
|
||||
if ($p["t"] >= $t) {
|
||||
if ($vor === null) {
|
||||
return $ersatz ?: $p["wh"];
|
||||
}
|
||||
$spanne = $p["t"] - $vor["t"];
|
||||
return $spanne > 0
|
||||
? $vor["wh"] + ($p["wh"] - $vor["wh"]) * ($t - $vor["t"]) / $spanne
|
||||
: $p["wh"];
|
||||
}
|
||||
$vor = $p;
|
||||
}
|
||||
return $vor ? $vor["wh"] : $ersatz;
|
||||
};
|
||||
|
||||
// Die Meldungen des Fahrzeugs, die den Verlauf einrahmen: die letzte vor
|
||||
// dem ersten Punkt, alle dazwischen, die erste nach dem letzten.
|
||||
$erster = $verlauf[0]["datetime"];
|
||||
$letzter = end($verlauf)["datetime"];
|
||||
$stmt = $mysql->prepare(
|
||||
"(SELECT COALESCE(cap_chg, datetime) AS erfasst, soc, chg_kw, chg_state, $spalte AS wh
|
||||
FROM skoda WHERE COALESCE(cap_chg, datetime) <= ? AND soc IS NOT NULL
|
||||
ORDER BY erfasst DESC LIMIT 1)
|
||||
UNION
|
||||
(SELECT COALESCE(cap_chg, datetime), soc, chg_kw, chg_state, $spalte
|
||||
FROM skoda WHERE COALESCE(cap_chg, datetime) > ? AND COALESCE(cap_chg, datetime) < ?
|
||||
AND soc IS NOT NULL)
|
||||
UNION
|
||||
(SELECT COALESCE(cap_chg, datetime), soc, chg_kw, chg_state, $spalte
|
||||
FROM skoda WHERE COALESCE(cap_chg, datetime) >= ? AND soc IS NOT NULL
|
||||
ORDER BY 1 LIMIT 1)
|
||||
ORDER BY erfasst");
|
||||
$stmt->bind_param("ssss", $erster, $erster, $letzter, $letzter);
|
||||
$stmt->execute();
|
||||
$res = $stmt->get_result();
|
||||
$meldungen = [];
|
||||
while ($z = $res->fetch_assoc()) {
|
||||
$t = strtotime($z["erfasst"]);
|
||||
$meldungen[] = [
|
||||
"datetime" => $z["erfasst"],
|
||||
"t" => $t,
|
||||
"soc" => intval($z["soc"]),
|
||||
"chg_kw" => $z["chg_kw"] === null ? null : floatval($z["chg_kw"]),
|
||||
"chg_state"=> $z["chg_state"],
|
||||
"wh" => $zaehlerBei($t, intval($z["wh"])),
|
||||
];
|
||||
}
|
||||
|
||||
// Ladestand je Punkt, zwischen den beiden Meldungen, die ihn einrahmen.
|
||||
foreach ($verlauf as &$p) {
|
||||
$p["soc"] = null;
|
||||
for ($i = 1; $p["wh"] !== null && $i < count($meldungen); $i++) {
|
||||
$a = $meldungen[$i - 1];
|
||||
$b = $meldungen[$i];
|
||||
if ($p["t"] < $a["t"] || $p["t"] > $b["t"]) {
|
||||
continue;
|
||||
}
|
||||
$spanne = $b["wh"] - $a["wh"];
|
||||
$p["soc"] = $spanne > 0
|
||||
? round($a["soc"] + ($b["soc"] - $a["soc"]) * ($p["wh"] - $a["wh"]) / $spanne, 1)
|
||||
: floatval($a["soc"]);
|
||||
break;
|
||||
}
|
||||
unset($p["t"]);
|
||||
}
|
||||
unset($p);
|
||||
foreach ($meldungen as &$m) {
|
||||
unset($m["t"], $m["wh"]);
|
||||
}
|
||||
unset($m);
|
||||
|
||||
return [$verlauf, $meldungen, $wallbox];
|
||||
}
|
||||
|
||||
/** Median eines nicht leeren Zahlenfeldes. */
|
||||
function median($werte)
|
||||
{
|
||||
@@ -237,6 +431,9 @@ case "kurve":
|
||||
while ($z = $res->fetch_assoc()) { $antwort["punkte"][] = $z; }
|
||||
$antwort["von"] = $von;
|
||||
$antwort["bis"] = $bis;
|
||||
|
||||
list($antwort["verlauf"], $antwort["meldungen"], $antwort["wallbox"])
|
||||
= ladeverlauf($mysql, $von, $bis);
|
||||
break;
|
||||
|
||||
/* ------------------------------------------------------------ gesundheit -- */
|
||||
|
||||
+39
-73
@@ -14,28 +14,25 @@
|
||||
* ein vorausgeladenes Bild oder einen Klick auf eine fremde Seite fernsteuerbar.
|
||||
*
|
||||
* ---------------------------------------------------------------------------
|
||||
* Zwei Schlüssel, zwei Kontingente
|
||||
* Ein Kontingent für alles
|
||||
*
|
||||
* Die API begrenzt auf 20 Anfragen je Stunde **und Schlüssel**, und Befehle
|
||||
* zählen genauso mit wie Abrufe. Steht in skoda.conf ein eigener
|
||||
* CMD_API_KEY, hat die Steuerung damit ihr eigenes Kontingent und nimmt dem
|
||||
* Abruf des Fahrzeugzustands nichts weg. Beide Schlüssel werden in der
|
||||
* MyŠkoda-App angelegt.
|
||||
* Die API begrenzt auf 20 Anfragen je Stunde, und Befehle zählen genauso mit
|
||||
* wie Abrufe. Die Doku schreibt "je Schlüssel" - gemessen stimmt das nicht,
|
||||
* der Zähler gilt für alle Schlüssel des Kontos zusammen (die Rechnung steht
|
||||
* bei _LIMIT in gatherSkodaData.py). Mehrere Schlüssel bringen also kein
|
||||
* zusätzliches Kontingent.
|
||||
*
|
||||
* Ohne eigenen Schlüssel greift dieses Skript auf API_KEY zurück - dann
|
||||
* teilen sich beide ein Kontingent, und weil sie in getrennten Prozessen
|
||||
* laufen und keinen gemeinsamen Zähler haben, ist es fest aufgeteilt:
|
||||
* Abruf und Steuerung laufen in getrennten Prozessen ohne gemeinsamen Zähler,
|
||||
* deshalb ist fest aufgeteilt:
|
||||
*
|
||||
* eigener CMD_API_KEY nur API_KEY
|
||||
* Abruf 18 / Stunde 14 / Stunde
|
||||
* Befehle 15 / Stunde 4 / Stunde
|
||||
* Reserve 2 / Stunde 2 / Stunde
|
||||
* Abruf 14 / Stunde (gatherSkodaData.py)
|
||||
* Befehle 4 / Stunde
|
||||
* Reserve 2 / Stunde
|
||||
*
|
||||
* gatherSkodaData.py stellt sich selbst um, sobald der zweite Schlüssel in
|
||||
* skoda.conf auftaucht - dort ist nichts von Hand nachzuziehen.
|
||||
*
|
||||
* Der zweite Schlüssel ist kein Freibrief, den Abruf zu beschleunigen: die
|
||||
* Kachelrichtlinie zielt auf die Last, nicht auf die Buchführung.
|
||||
* Ein eigener CMD_API_KEY trennt damit nicht die Kontingente, sondern nur,
|
||||
* wer womit fragt - er lässt sich einzeln widerrufen, ohne den Abruf
|
||||
* mitzunehmen. Welchen dieses Skript nimmt, entscheidet
|
||||
* skodaBefehlsSchluessel(): den eigenen, wenn es ihn gibt, sonst API_KEY.
|
||||
* ---------------------------------------------------------------------------
|
||||
*
|
||||
* Nicht angebunden ist die Standheizung. Ihr Start verlangt laut Spec die
|
||||
@@ -46,24 +43,13 @@
|
||||
*/
|
||||
|
||||
require_once("../helper.php");
|
||||
// Wo skoda.conf liegt, wie sie aussieht, welcher Schlüssel die Befehle
|
||||
// schickt und wie viele je Stunde erlaubt sind: alles dort, damit der Reiter
|
||||
// in den Einstellungen und dieser Endpunkt dieselbe Wahrheit benutzen.
|
||||
require_once("../restricted/skodaKeys.php");
|
||||
|
||||
header('Content-Type: application/json; charset=utf-8');
|
||||
|
||||
const API_BASIS = "https://public.api.connect.skoda-auto.cz/api/v1/vehicles/";
|
||||
const KONFIG = "/volume1/homes/wagner/SolarManager/skoda.conf";
|
||||
const KENNUNG = "SmartController-SkodaSteuerung/1.0 (+https://nas.el-wa.org/smart)";
|
||||
|
||||
/** Befehle je Stunde - siehe Kopfkommentar. Hängt davon ab, ob die
|
||||
* Steuerung einen eigenen Schlüssel hat oder ihn mit dem Abruf teilt. */
|
||||
const BEFEHLE_EIGENER_SCHLUESSEL = 15;
|
||||
const BEFEHLE_GETEILT = 4;
|
||||
|
||||
/** Wo der Stundenzähler liegt. Muss für den Webserver beschreibbar sein. */
|
||||
const ZAEHLER_ORTE = [
|
||||
"/volume1/web/smart/tiles", // falls per synoacltool freigegeben
|
||||
"/var/services/tmp/smart-tiles", // sonst
|
||||
];
|
||||
|
||||
/*
|
||||
* Die erlaubten Befehle. Der Schlüssel kommt aus dem Formular, der Pfad
|
||||
* niemals - so kann über den Parameter kein beliebiger Endpunkt der API
|
||||
@@ -93,18 +79,16 @@ if (!isset(BEFEHLE[$name])) {
|
||||
}
|
||||
$befehl = BEFEHLE[$name];
|
||||
|
||||
$konfig = konfigLesen();
|
||||
$konfig = skodaBefehlsSchluessel();
|
||||
if (!$konfig) {
|
||||
antwort(503, false, "Kein API-Schlüssel hinterlegt - skoda.conf fehlt.");
|
||||
antwort(503, false, "Kein API-Schlüssel hinterlegt - unter Einstellungen "
|
||||
. "▸ Fahrzeug lässt sich einer eintragen.");
|
||||
}
|
||||
|
||||
$grenze = $konfig["EIGENER"] ? BEFEHLE_EIGENER_SCHLUESSEL : BEFEHLE_GETEILT;
|
||||
if (!budgetFrei($grenze)) {
|
||||
if (!budgetFrei(SKODA_BEFEHLE)) {
|
||||
antwort(429, false, "Stündliches Kontingent für Befehle erschöpft ("
|
||||
. $grenze . " je Stunde)."
|
||||
. ($konfig["EIGENER"] ? "" : " Ein eigener CMD_API_KEY in skoda.conf"
|
||||
. " würde der Steuerung ein eigenes Kontingent geben.")
|
||||
. " Später erneut versuchen.");
|
||||
. SKODA_BEFEHLE . " je Stunde). Es teilt sich die 20 Anfragen der API"
|
||||
. " mit dem Abruf des Fahrzeugzustands. Später erneut versuchen.");
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- Ausführen */
|
||||
@@ -121,8 +105,9 @@ if ($name === "klima_start") {
|
||||
list($status, $inhalt) = senden($konfig, $befehl["pfad"], $rumpf);
|
||||
|
||||
if ($status === 202) {
|
||||
skodaAbrufAnstossen();
|
||||
antwort(200, true, $befehl["text"] . ". Das Fahrzeug führt den Befehl aus; "
|
||||
. "in der Anzeige erscheint es beim nächsten Abruf.");
|
||||
. "in der Anzeige erscheint es in einer halben Minute.");
|
||||
}
|
||||
antwort(200, false, fehlertext($status, $inhalt));
|
||||
|
||||
@@ -136,39 +121,19 @@ function antwort($code, $ok, $text)
|
||||
exit;
|
||||
}
|
||||
|
||||
/** API-Schlüssel und VIN aus skoda.conf lesen. Format: NAME=wert je Zeile. */
|
||||
function konfigLesen()
|
||||
{
|
||||
if (!is_readable(KONFIG)) {
|
||||
return null;
|
||||
}
|
||||
$werte = [];
|
||||
foreach (file(KONFIG, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES) as $zeile) {
|
||||
$zeile = trim($zeile);
|
||||
if ($zeile === "" || $zeile[0] === "#" || strpos($zeile, "=") === false) {
|
||||
continue;
|
||||
}
|
||||
list($k, $v) = explode("=", $zeile, 2);
|
||||
$werte[strtoupper(trim($k))] = trim(trim($v), "\"'");
|
||||
}
|
||||
if (empty($werte["API_KEY"]) || empty($werte["VIN"])) {
|
||||
return null;
|
||||
}
|
||||
// Eigener Schluessel fuer die Steuerung, wenn hinterlegt - sonst der
|
||||
// gemeinsame. Welcher es wurde, entscheidet unten ueber das Budget.
|
||||
$werte["EIGENER"] = !empty($werte["CMD_API_KEY"]);
|
||||
$werte["SCHLUESSEL"] = $werte["EIGENER"] ? $werte["CMD_API_KEY"] : $werte["API_KEY"];
|
||||
return $werte;
|
||||
}
|
||||
|
||||
/**
|
||||
* Stundenzähler für Befehle. Gleiches Verfahren wie die Bremse in tile.php:
|
||||
* eine kleine Datei, gegen gleichzeitige Zugriffe mit flock abgesichert.
|
||||
*
|
||||
* Das Fenster ist fest: es beginnt mit dem ersten Befehl und läuft eine Stunde.
|
||||
* Die API zählt gleitend, hier stehen also im Grenzfall zwei Fenster
|
||||
* nebeneinander - garantiert sind die $grenze Befehle, mehr geht auf das Risiko
|
||||
* eines 429 von der API selbst.
|
||||
*/
|
||||
function budgetFrei($grenze)
|
||||
{
|
||||
$ort = null;
|
||||
foreach (ZAEHLER_ORTE as $kandidat) {
|
||||
foreach (SKODA_ARBEITSORTE as $kandidat) {
|
||||
if (is_dir($kandidat) && is_writable($kandidat)) {
|
||||
$ort = $kandidat;
|
||||
break;
|
||||
@@ -180,7 +145,7 @@ function budgetFrei($grenze)
|
||||
return true;
|
||||
}
|
||||
|
||||
$griff = fopen($ort . "/.befehle.json", "c+");
|
||||
$griff = fopen($ort . "/" . SKODA_ZAEHLER_DATEI, "c+");
|
||||
if (!$griff || !flock($griff, LOCK_EX)) {
|
||||
return true;
|
||||
}
|
||||
@@ -207,16 +172,16 @@ function budgetFrei($grenze)
|
||||
/** Den Befehl an die API schicken. Liefert [HTTP-Status, Rumpf]. */
|
||||
function senden($konfig, $pfad, $rumpf)
|
||||
{
|
||||
$url = API_BASIS . rawurlencode($konfig["VIN"]) . "/" . $pfad;
|
||||
$url = SKODA_API . rawurlencode($konfig["vin"]) . "/" . $pfad;
|
||||
$kopf = [
|
||||
"X-API-Key: " . $konfig["SCHLUESSEL"],
|
||||
"X-API-Key: " . $konfig["schluessel"],
|
||||
"Accept: application/json",
|
||||
];
|
||||
$ch = curl_init($url);
|
||||
$optionen = [
|
||||
CURLOPT_POST => true,
|
||||
CURLOPT_RETURNTRANSFER => true,
|
||||
CURLOPT_USERAGENT => KENNUNG,
|
||||
CURLOPT_USERAGENT => SKODA_KENNUNG,
|
||||
CURLOPT_TIMEOUT => 20,
|
||||
CURLOPT_CONNECTTIMEOUT => 5,
|
||||
];
|
||||
@@ -257,7 +222,8 @@ function fehlertext($status, $inhalt)
|
||||
switch ($status) {
|
||||
case 0: return "Die Škoda-API ist nicht erreichbar.";
|
||||
case 400: return "Die API hat den Befehl abgelehnt." . $detail;
|
||||
case 401: return "Der API-Schlüssel ist abgelaufen - in der MyŠkoda-App erneuern.";
|
||||
case 401: return "Der API-Schlüssel ist abgelaufen - in der MyŠkoda-App "
|
||||
. "erneuern und unter Einstellungen ▸ Fahrzeug eintragen.";
|
||||
case 403: return "Der Schlüssel darf diesen Befehl nicht ausführen." . $detail;
|
||||
case 404: return "Fahrzeug nicht gefunden - stimmt die VIN in skoda.conf?";
|
||||
case 422: return "Das Fahrzeug kann das gerade nicht." . $detail;
|
||||
|
||||
@@ -2394,6 +2394,12 @@ input[type='range']::-webkit-slider-runnable-track {
|
||||
gap: .5rem;
|
||||
white-space: nowrap;
|
||||
}
|
||||
.kachel-wert .kw-schalter .kw-format {
|
||||
width: auto;
|
||||
font-size: .78rem;
|
||||
padding-top: .1rem;
|
||||
padding-bottom: .1rem;
|
||||
}
|
||||
.kachel-wert .kw-schalter label {
|
||||
display: inline-flex;
|
||||
align-items: center;
|
||||
|
||||
@@ -156,8 +156,12 @@ const homeSVG = {
|
||||
// Solarseite fuer dieselben Zahlen benutzt - eine eigene Regel hier
|
||||
// haette bedeutet, dass dieselbe Wallbox an zwei Stellen verschieden
|
||||
// gerundet dasteht.
|
||||
if (wert.format === "leistung") {
|
||||
const zahl = Number(text);
|
||||
//
|
||||
// "leistung_kw" ist dasselbe fuer Quellen, die schon Kilowatt melden -
|
||||
// die Wallboxen im SolarManager. Umgerechnet wird hier in Watt, damit
|
||||
// es eine Regel fuer beide bleibt.
|
||||
if (wert.format === "leistung" || wert.format === "leistung_kw") {
|
||||
const zahl = Number(text) * (wert.format === "leistung_kw" ? 1000 : 1);
|
||||
if (text === "" || isNaN(zahl)) return null;
|
||||
// Ersetzt wird nur das Trennzeichen: auf der Kachel steht ein
|
||||
// schmales Leerzeichen, im Rest der Anwendung ein gewoehnliches.
|
||||
|
||||
+269
-8
@@ -316,7 +316,7 @@ function kachelQuelle(wert) {
|
||||
* und aus drei Kuerzeln wuerden drei Zeilen.
|
||||
*/
|
||||
function kachelWertKurz(wert, kachel) {
|
||||
const einheit = wert.format === "leistung" ? "W/kW" : (wert.einheit || "");
|
||||
const einheit = istLeistung(wert) ? "W/kW" : (wert.einheit || "");
|
||||
const treffer = wert.wechselrichter ? null : katalogTreffer(wert);
|
||||
let text;
|
||||
|
||||
@@ -568,20 +568,29 @@ function kachelWertZeile(wert, i, kachel) {
|
||||
|
||||
+ '<div class="kw-einheit"><input type="text" class="form-control form-control-sm"'
|
||||
+ ' data-feld="einheit" placeholder="Einheit" maxlength="8"'
|
||||
+ (wert.format === "leistung" ? " disabled" : "")
|
||||
+ (istLeistung(wert) ? " disabled" : "")
|
||||
+ ' value="' + textSchuetzen(wert.einheit || "") + '"></div>'
|
||||
|
||||
+ '<div class="kw-stellen"><input type="number" class="form-control form-control-sm"'
|
||||
+ ' data-feld="stellen" min="0" max="3" placeholder="0"'
|
||||
+ (wert.format === "leistung" ? " disabled" : "")
|
||||
+ (istLeistung(wert) ? " disabled" : "")
|
||||
+ ' value="' + (wert.stellen === undefined ? "" : wert.stellen) + '"></div>'
|
||||
|
||||
+ '<div class="kw-symbol">' + kachelSymbolFeld(wert.icon || "") + "</div>"
|
||||
|
||||
+ '<div class="kw-schalter">'
|
||||
+ '<label title="Leistung: skaliert selbst zwischen W und kW">'
|
||||
+ '<input type="checkbox" class="form-check-input" data-feld="format"'
|
||||
+ (wert.format === "leistung" ? " checked" : "") + "> kW</label>"
|
||||
// Leistung: die Anzeige skaliert selbst zwischen W und kW. Gewählt wird
|
||||
// nur, in welcher Einheit die Quelle meldet - die Wallboxen schicken kW,
|
||||
// die Zähler W. Früher ein Häkchen, das stillschweigend Watt annahm.
|
||||
+ '<select class="form-select form-select-sm kw-format" data-feld="format"'
|
||||
+ ' title="Leistung: in welcher Einheit die Quelle meldet. Angezeigt wird'
|
||||
+ ' dann selbst in W oder kW.">'
|
||||
+ '<option value=""' + (istLeistung(wert) ? "" : " selected") + '>Einheit</option>'
|
||||
+ '<option value="leistung"' + (wert.format === "leistung" ? " selected" : "")
|
||||
+ '>Leistung aus W</option>'
|
||||
+ '<option value="leistung_kw"' + (wert.format === "leistung_kw" ? " selected" : "")
|
||||
+ '>Leistung aus kW</option>'
|
||||
+ "</select>"
|
||||
+ '<label title="Vorzeichen umdrehen - für Zähler, die verkehrt herum'
|
||||
+ ' eingebaut sind">'
|
||||
+ '<input type="checkbox" class="form-check-input" data-feld="negativ"'
|
||||
@@ -594,6 +603,11 @@ function kachelWertZeile(wert, i, kachel) {
|
||||
+ "</div></div>";
|
||||
}
|
||||
|
||||
/** Skaliert der Wert selbst zwischen W und kW? Egal, aus welcher Einheit. */
|
||||
function istLeistung(wert) {
|
||||
return wert.format === "leistung" || wert.format === "leistung_kw";
|
||||
}
|
||||
|
||||
/** Fremden Text sicher ins Markup bringen - Topics kommen aus der Datenbank. */
|
||||
function textSchuetzen(s) {
|
||||
const d = document.createElement("div");
|
||||
@@ -639,8 +653,9 @@ function kachelWertLesen(feldZeile) {
|
||||
const pfad = (hol("pfad") || "").trim();
|
||||
if (pfad) wert.pfad = pfad;
|
||||
}
|
||||
if (hol("format")) {
|
||||
wert.format = "leistung";
|
||||
const format = hol("format");
|
||||
if (format === "leistung" || format === "leistung_kw") {
|
||||
wert.format = format;
|
||||
} else {
|
||||
const einheit = (hol("einheit") || "").trim();
|
||||
if (einheit) wert.einheit = einheit;
|
||||
@@ -1130,3 +1145,249 @@ document.addEventListener("DOMContentLoaded", function () {
|
||||
geraeteBinden();
|
||||
geraeteHolen();
|
||||
});
|
||||
|
||||
|
||||
/* ==========================================================================
|
||||
Fahrzeug: die Zugangsschlüssel der MyŠkoda-Anbindung
|
||||
--------------------------------------------------------------------------
|
||||
Sie laufen ab. Bis hierher hieß der Tausch: per SSH auf die NAS, skoda.conf
|
||||
im Editor öffnen, nicht vertippen. Das gehört in die Einstellungen wie die
|
||||
Preise und die Geräte.
|
||||
|
||||
Was hier nie ankommt, sind die Schlüssel selbst. Die Seite steht im
|
||||
Heimnetz ohne Anmeldung offen, und ein solcher Schlüssel steuert das
|
||||
Fahrzeug von überall auf der Welt - Laden, Klima, Standort. Zu sehen sind
|
||||
nur die letzten vier Zeichen, gerade genug, um zwei auseinanderzuhalten.
|
||||
Geschrieben wird deshalb auch nur in eine Richtung: ein neuer Wert geht
|
||||
hinein, ein alter kommt nie heraus.
|
||||
|
||||
Der zweite und dritte Schlüssel beschleunigen nichts: das Kontingent der
|
||||
API gilt gemessen fürs ganze Konto. Sie sind für den Fall da, dass einer
|
||||
abläuft oder widerrufen wird - dann fragt der Abruf mit dem nächsten
|
||||
weiter, statt stillzustehen. Deshalb steht unter den Feldern, was gerade
|
||||
gilt, und nicht, was ein weiterer Schlüssel brächte.
|
||||
========================================================================== */
|
||||
|
||||
let skodaModell = null; // was ?action=skoda-keys liefert, ohne Werte
|
||||
|
||||
/* --- Zeichnen ------------------------------------------------------------ */
|
||||
|
||||
function zeichneSkoda() {
|
||||
const ziel = document.getElementById("skodaListe");
|
||||
if (!ziel || !skodaModell) return;
|
||||
|
||||
if (!skodaModell.da) {
|
||||
ziel.innerHTML = '<div class="alert alert-warning mb-0">'
|
||||
+ "Die Datei <code>" + textSchuetzen(skodaModell.datei) + "</code> gibt es nicht. "
|
||||
+ "Sie gehört zum SolarManager und wird dort angelegt – ohne sie läuft auch "
|
||||
+ "der Abruf nicht.</div>";
|
||||
return;
|
||||
}
|
||||
|
||||
const zeilen = skodaModell.felder.map(skodaZeile).join("");
|
||||
ziel.innerHTML =
|
||||
'<div class="skoda-felder">' + zeilen + "</div>"
|
||||
+ (skodaModell.schreibbar ? "" :
|
||||
'<div class="alert alert-warning mt-3 mb-0 py-2 small">'
|
||||
+ "Der Webserver darf <code>" + textSchuetzen(skodaModell.datei)
|
||||
+ "</code> nicht schreiben. Eintragen lässt sich hier nichts.</div>")
|
||||
+ '<div class="d-flex flex-wrap align-items-center gap-3 mt-3">'
|
||||
+ '<button type="button" class="btn btn-primary" id="skodaSpeichern"'
|
||||
+ (skodaModell.schreibbar ? "" : " disabled") + ">Eintragen</button>"
|
||||
+ '<span class="skoda-stand small text-body-secondary"></span>'
|
||||
+ "</div>"
|
||||
+ skodaBilanz();
|
||||
}
|
||||
|
||||
/** Eine Zeile: was der Schlüssel tut, ob er da ist, und ein Feld dafür. */
|
||||
function skodaZeile(f) {
|
||||
const kennung = "skodaFeld-" + f.feld;
|
||||
const stand = f.gesetzt
|
||||
? '<span class="badge text-bg-success">hinterlegt</span>'
|
||||
+ ' <span class="text-body-secondary">endet auf ' + textSchuetzen(f.maske) + "</span>"
|
||||
: '<span class="badge text-bg-secondary">'
|
||||
+ (f.pflicht ? "fehlt" : "nicht hinterlegt") + "</span>";
|
||||
|
||||
// Entfernen nur, wo es etwas zu entfernen gibt und wo es ohne geht. Der
|
||||
// erste Schlüssel lässt sich ersetzen, aber nicht abschaffen - ohne ihn
|
||||
// steht der Abruf.
|
||||
const weg = (f.gesetzt && !f.pflicht)
|
||||
? '<button type="button" class="btn btn-outline-danger btn-sm skoda-weg"'
|
||||
+ ' data-feld="' + textSchuetzen(f.feld) + '" title="Diesen Schlüssel entfernen">'
|
||||
+ '<i class="bi bi-trash"></i></button>'
|
||||
: "";
|
||||
|
||||
return '<div class="border-top py-3 skoda-feld" data-feld="' + textSchuetzen(f.feld) + '">'
|
||||
+ '<div class="d-flex flex-wrap align-items-baseline gap-2">'
|
||||
+ '<label class="fw-semibold mb-0" for="' + kennung + '">'
|
||||
+ textSchuetzen(f.titel) + "</label>"
|
||||
+ stand
|
||||
+ "</div>"
|
||||
+ '<p class="text-body-secondary small mb-2">' + textSchuetzen(f.zweck) + "</p>"
|
||||
+ '<div class="input-group input-group-sm">'
|
||||
+ '<input type="password" class="form-control" id="' + kennung + '"'
|
||||
+ ' autocomplete="off" spellcheck="false"'
|
||||
+ ' placeholder="' + (f.gesetzt ? "neuer Schlüssel – leer lassen, um ihn zu behalten"
|
||||
: "Schlüssel einfügen") + '">'
|
||||
+ '<button type="button" class="btn btn-outline-secondary skoda-zeigen"'
|
||||
+ ' title="Anzeigen"><i class="bi bi-eye"></i></button>'
|
||||
+ weg
|
||||
+ "</div>"
|
||||
+ "</div>";
|
||||
}
|
||||
|
||||
/** Was die hinterlegten Schlüssel einbringen - die Zahlen dahinter. */
|
||||
function skodaBilanz() {
|
||||
const m = skodaModell;
|
||||
const teile = [];
|
||||
teile.push(m.abruf + (m.abruf === 1 ? " Schlüssel" : " Schlüssel im Wechsel")
|
||||
+ " für den Abruf – beim Laden und während der Fahrt alle "
|
||||
+ m.takt + " Sekunden");
|
||||
teile.push(m.befehle + " Befehle je Stunde");
|
||||
if (m.ablauf) {
|
||||
teile.push("nächster Ablauf am " + datumLesbar(String(m.ablauf).slice(0, 10)));
|
||||
}
|
||||
return '<p class="text-body-secondary small mt-3 mb-0">'
|
||||
+ textSchuetzen(teile.join(" · ")) + "<br>"
|
||||
+ "Ein neuer Schlüssel gilt sofort; der Abruf liest die Datei von selbst neu."
|
||||
+ "</p>";
|
||||
}
|
||||
|
||||
function skodaStand(text, klasse) {
|
||||
const ziel = document.querySelector("#skodaListe .skoda-stand");
|
||||
if (!ziel) return;
|
||||
ziel.className = "skoda-stand small " + (klasse || "text-body-secondary");
|
||||
ziel.textContent = text;
|
||||
clearTimeout(skodaStand._uhr);
|
||||
if (klasse !== "text-danger") {
|
||||
skodaStand._uhr = setTimeout(function () {
|
||||
if (ziel.textContent === text) ziel.textContent = "";
|
||||
}, 8000);
|
||||
}
|
||||
}
|
||||
|
||||
/* --- Sprechen mit dem Endpunkt ------------------------------------------- */
|
||||
|
||||
async function skodaFrage(action, koerper) {
|
||||
const antwort = await fetch("ajax/settings.php?action=" + action, koerper ? {
|
||||
method: "POST",
|
||||
headers: { "Content-Type": "application/json" },
|
||||
body: JSON.stringify(koerper),
|
||||
} : { cache: "no-store" });
|
||||
const d = await antwort.json();
|
||||
if (!antwort.ok || d.error) throw new Error(d.error || "HTTP " + antwort.status);
|
||||
return d;
|
||||
}
|
||||
|
||||
async function skodaHolen() {
|
||||
const ziel = document.getElementById("skodaListe");
|
||||
if (!ziel) return;
|
||||
try {
|
||||
skodaModell = await skodaFrage("skoda-keys");
|
||||
zeichneSkoda();
|
||||
} catch (e) {
|
||||
ziel.innerHTML = '<div class="alert alert-danger mb-0">Schlüssel nicht abrufbar: '
|
||||
+ textSchuetzen(e.message) + "</div>";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Alles Eingetragene auf einmal senden.
|
||||
*
|
||||
* Leere Felder bedeuten "so lassen" - sonst löschte ein Speichern ohne
|
||||
* Eingabe alles, was man nicht noch einmal eintippt.
|
||||
*
|
||||
* Das kann dauern: der Server probiert jeden neuen Schlüssel einmal an der
|
||||
* API aus, bevor er ihn hinschreibt. Deshalb der Knopf mit Wartezustand.
|
||||
*/
|
||||
async function skodaSenden() {
|
||||
const knopf = document.getElementById("skodaSpeichern");
|
||||
const felder = {};
|
||||
document.querySelectorAll("#skodaListe .skoda-feld").forEach(function (zeile) {
|
||||
const feld = zeile.dataset.feld;
|
||||
const wert = zeile.querySelector("input").value.trim();
|
||||
if (wert) felder[feld] = wert;
|
||||
});
|
||||
if (!Object.keys(felder).length) {
|
||||
skodaStand("Kein Schlüssel eingetragen.", "text-warning");
|
||||
return;
|
||||
}
|
||||
|
||||
if (knopf) knopf.disabled = true;
|
||||
skodaStand("Wird an der Škoda-API ausprobiert …");
|
||||
try {
|
||||
const d = await skodaFrage("skoda-keys-save", { felder: felder });
|
||||
skodaModell = d.stand;
|
||||
zeichneSkoda();
|
||||
skodaStand((d.meldungen || []).join(" ") || "Eingetragen.", "text-success");
|
||||
} catch (e) {
|
||||
skodaStand(e.message, "text-danger");
|
||||
if (knopf) knopf.disabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Einen Schlüssel entfernen.
|
||||
*
|
||||
* Mit Rückfrage: er steht danach nirgends mehr, und ein neuer kommt nur aus
|
||||
* der MyŠkoda-App.
|
||||
*/
|
||||
async function skodaLoeschen(feld) {
|
||||
if (!window.confirm(feld + " entfernen?\n\nDer Schlüssel verschwindet aus der "
|
||||
+ "Konfiguration. Zurückholen lässt er sich nur über die MyŠkoda-App.")) {
|
||||
return;
|
||||
}
|
||||
skodaStand("Wird entfernt …");
|
||||
try {
|
||||
const d = await skodaFrage("skoda-keys-save", { loeschen: [feld] });
|
||||
skodaModell = d.stand;
|
||||
zeichneSkoda();
|
||||
skodaStand(feld + " entfernt.", "text-success");
|
||||
} catch (e) {
|
||||
skodaStand(e.message, "text-danger");
|
||||
}
|
||||
}
|
||||
|
||||
/* --- Bedienung ----------------------------------------------------------- */
|
||||
|
||||
function skodaBinden() {
|
||||
const liste = document.getElementById("skodaListe");
|
||||
if (!liste) return;
|
||||
|
||||
liste.addEventListener("click", function (ereignis) {
|
||||
const zeigen = ereignis.target.closest(".skoda-zeigen");
|
||||
if (zeigen) {
|
||||
// Ein eingefügter Schlüssel ist nicht zu merken, nur zu vergleichen -
|
||||
// wer ihn nicht sehen kann, sucht einen Tippfehler im Dunkeln.
|
||||
const feld = zeigen.closest(".input-group").querySelector("input");
|
||||
feld.type = feld.type === "password" ? "text" : "password";
|
||||
zeigen.querySelector("i").className =
|
||||
feld.type === "password" ? "bi bi-eye" : "bi bi-eye-slash";
|
||||
return;
|
||||
}
|
||||
const weg = ereignis.target.closest(".skoda-weg");
|
||||
if (weg) {
|
||||
skodaLoeschen(weg.dataset.feld);
|
||||
return;
|
||||
}
|
||||
if (ereignis.target.closest("#skodaSpeichern")) {
|
||||
skodaSenden();
|
||||
}
|
||||
});
|
||||
|
||||
// Enter im Feld soll dasselbe tun wie der Knopf daneben.
|
||||
liste.addEventListener("keydown", function (ereignis) {
|
||||
if (ereignis.key === "Enter" && ereignis.target.matches(".skoda-feld input")) {
|
||||
ereignis.preventDefault();
|
||||
skodaSenden();
|
||||
}
|
||||
});
|
||||
|
||||
const neuLaden = document.getElementById("skodaNeuLaden");
|
||||
if (neuLaden) neuLaden.addEventListener("click", skodaHolen);
|
||||
}
|
||||
|
||||
document.addEventListener("DOMContentLoaded", function () {
|
||||
skodaBinden();
|
||||
skodaHolen();
|
||||
});
|
||||
|
||||
+36
-1
@@ -649,7 +649,10 @@ function baueKurve() {
|
||||
options: {
|
||||
maintainAspectRatio: false,
|
||||
animation: false,
|
||||
interaction: { mode: "index", intersect: false },
|
||||
// "nearest" statt "index": Wallbox-Verlauf und Fahrzeugmeldungen haben
|
||||
// verschiedene Zeitpunkte, der n-te Wert der einen Reihe gehört nicht zum
|
||||
// n-ten der anderen.
|
||||
interaction: { mode: "nearest", axis: "x", intersect: false },
|
||||
scales: {
|
||||
// 'timestack' ist die Zeitachse, die diese Seite mitbringt
|
||||
// (js/chartjs-scale-timestack.min.js). Chart.js' eingebautes 'time'
|
||||
@@ -1151,6 +1154,38 @@ async function ladeKurve() {
|
||||
// Date-Objekten - die nimmt sie stillschweigend nicht an und zeigt
|
||||
// stattdessen den heutigen Tag.
|
||||
const zeit = (p) => new Date(String(p.datetime).replace(" ", "T")).getTime();
|
||||
|
||||
// Mit Wallbox-Verlauf (skoda_ladepunkte): die Leistung im Minutentakt,
|
||||
// der Ladestand dazwischen nach der geflossenen Energie aufgefüllt, und
|
||||
// die echten Meldungen des Fahrzeugs als Punkte darauf - damit sichtbar
|
||||
// bleibt, was gemessen und was abgeleitet ist. Das Fahrzeug meldet beim
|
||||
// Laden mitunter nur einmal in der Stunde; eine Linie durch diese Punkte
|
||||
// allein erfände den Verlauf dazwischen.
|
||||
if (d.verlauf && d.verlauf.length) {
|
||||
const imBild = (m) => zeit(m) >= zeit(d.verlauf[0]) - 600000
|
||||
&& zeit(m) <= zeit(d.verlauf[d.verlauf.length - 1]) + 600000;
|
||||
const meldungen = (d.meldungen || []).filter(imBild);
|
||||
kurveChart.data.datasets = [
|
||||
{ label: "Wallbox", yAxisID: "y", borderColor: "#4caf7d", backgroundColor: "rgba(76,175,125,.18)",
|
||||
borderWidth: 2, pointRadius: 0, fill: "origin", tension: 0,
|
||||
data: d.verlauf.map(p => ({ x: zeit(p), y: +p.kw })) },
|
||||
{ label: "Ladestand, aufgefüllt", yAxisID: "y1", borderColor: "#f0b429", borderWidth: 2,
|
||||
borderDash: [5, 4], pointRadius: 0, tension: 0, spanGaps: false,
|
||||
data: d.verlauf.map(p => ({ x: zeit(p), y: p.soc === null ? null : +p.soc })) },
|
||||
{ label: "Ladestand laut Fahrzeug", yAxisID: "y1", showLine: false,
|
||||
borderColor: "#f0b429", backgroundColor: "#f0b429", pointRadius: 4, pointHoverRadius: 6,
|
||||
data: meldungen.map(m => ({ x: zeit(m), y: +m.soc })) },
|
||||
{ label: "Leistung laut Fahrzeug", yAxisID: "y", showLine: false,
|
||||
borderColor: "#7aa7c7", backgroundColor: "#7aa7c7", pointRadius: 3, pointStyle: "rectRot",
|
||||
data: meldungen.filter(m => m.chg_kw !== null && m.chg_state === "CHARGING")
|
||||
.map(m => ({ x: zeit(m), y: +m.chg_kw })) }
|
||||
];
|
||||
kurveChart.update();
|
||||
return;
|
||||
}
|
||||
|
||||
// Ohne Wallbox-Verlauf - Ladungen von vor der Aufzeichnung - wie bisher
|
||||
// aus den Zeilen der Fahrzeugtabelle.
|
||||
kurveChart.data.datasets = [
|
||||
{ label: "Wallbox", yAxisID: "y", borderColor: "#4caf7d", backgroundColor: "rgba(76,175,125,.18)",
|
||||
borderWidth: 2, pointRadius: 0, fill: "origin", tension: .25,
|
||||
|
||||
@@ -339,7 +339,14 @@ const solarSVG = {
|
||||
} else {
|
||||
setDisplay("heatEG", "none");
|
||||
}
|
||||
if (plugev != "no car") {
|
||||
// solarManager/evPlug kommt als 1 oder 0, wie evPlugOG. Frueher kam
|
||||
// hier der Text der Wallbox an ("no car", "charging", ...); Number()
|
||||
// machte daraus NaN, und NaN != "no car" ist immer wahr - das
|
||||
// Steckersymbol stand dauerhaft da. Den Text weiter zu verstehen
|
||||
// kostet eine Zeile und haelt die Anzeige richtig, egal ob der
|
||||
// Manager schon neu gestartet ist oder nicht.
|
||||
const plugText = mqttData["solarManager/evPlug"];
|
||||
if (isNaN(plugev) ? (plugText !== undefined && plugText !== "no car") : plugev > 0) {
|
||||
setDisplay("evPlug", "");
|
||||
} else {
|
||||
setDisplay("evPlug", "none");
|
||||
|
||||
+13
-3
@@ -14,7 +14,9 @@
|
||||
* pfad optional: Schlüssel in einer JSON-Nachricht
|
||||
* wechselrichter Liste von Namen unter solarManager/invertersN (statt topic)
|
||||
* feld bei Wechselrichtern das Feld, meist p_AC
|
||||
* format "leistung" skaliert selbst zwischen W und kW
|
||||
* format "leistung" skaliert selbst zwischen W und kW, die Quelle
|
||||
* liefert Watt; "leistung_kw" dasselbe fuer Quellen, die
|
||||
* schon in Kilowatt melden (die Wallboxen im SolarManager)
|
||||
* einheit sonst die Einheit, die hinter der Zahl steht
|
||||
* stellen Nachkommastellen (0-3)
|
||||
* negativ das Vorzeichen umdrehen - fuer Zaehler, die verkehrt
|
||||
@@ -43,6 +45,14 @@ require_once(__DIR__ . "/costs.php"); // solarDb()
|
||||
/** Höchstens drei Werte je Kachel - mehr passt nicht auf 24 x 19 Einheiten. */
|
||||
const KACHEL_MAX = 3;
|
||||
|
||||
/**
|
||||
* Die Formate, die selbst zwischen W und kW skalieren - je nachdem, in welcher
|
||||
* Einheit die Quelle meldet. Die meisten Zähler schicken Watt; die Wallboxen
|
||||
* im SolarManager (evPower, evPowerOG) schicken Kilowatt, und als Watt gelesen
|
||||
* stand bei 1 kW Ladeleistung "1 W" auf der Kachel.
|
||||
*/
|
||||
const KACHEL_LEISTUNG = ["leistung", "leistung_kw"];
|
||||
|
||||
/**
|
||||
* Vorschläge für das Symbol vor einer Zahl.
|
||||
*
|
||||
@@ -326,8 +336,8 @@ function kachelWertPruefen($wert, $nummer)
|
||||
}
|
||||
|
||||
// Entweder das Format rechnet die Einheit selbst aus, oder sie steht da.
|
||||
if (($wert["format"] ?? "") === "leistung") {
|
||||
$sauber["format"] = "leistung";
|
||||
if (in_array($wert["format"] ?? "", KACHEL_LEISTUNG, true)) {
|
||||
$sauber["format"] = $wert["format"];
|
||||
} else {
|
||||
$einheit = trim((string)($wert["einheit"] ?? ""));
|
||||
if (mb_strlen($einheit) > 8) {
|
||||
|
||||
@@ -22,7 +22,8 @@
|
||||
* restricted/kacheln.php): bis zu drei Messwerte, jeder mit
|
||||
* topic (oder wechselrichter, siehe Carport), optional pfad
|
||||
* (Schlüssel in einer JSON-Nachricht) und entweder format
|
||||
* ("leistung" skaliert selbst zwischen W und kW) oder dem Paar
|
||||
* ("leistung" skaliert selbst zwischen W und kW, "leistung_kw"
|
||||
* ebenso fuer Quellen, die schon Kilowatt melden) oder dem Paar
|
||||
* einheit und stellen (Nachkommastellen). Fehlt der Eintrag, sind
|
||||
* es die drei Thermostatwerte - Soll, Ist, Feuchte - wie bisher.
|
||||
* Eine leere Liste heisst: kein Messwert, die Kachel trägt nur
|
||||
@@ -131,7 +132,7 @@ $rooms = [
|
||||
// die man sich vor dem Carport stellt: laedt gerade jemand?
|
||||
["floor" => "AG", "mqtt" => "Carport OG", "id" => "carport_og", "x" => 72, "y" => 154,
|
||||
"werte" => [
|
||||
["topic" => "solarManager/evPowerOG", "format" => "leistung",
|
||||
["topic" => "solarManager/evPowerOG", "format" => "leistung_kw",
|
||||
"icon" => "ev-station"],
|
||||
]],
|
||||
// Veranda und Terrasse gibt es zweimal, je Wohnpartei eine. In der
|
||||
@@ -159,7 +160,7 @@ $rooms = [
|
||||
// restricted/config.php. Ohne Kuerzel im Topic ist das die EG-Wallbox.
|
||||
["floor" => "AG", "mqtt" => "Garage", "id" => "garage", "x" => 131, "y" => 135,
|
||||
"werte" => [
|
||||
["topic" => "solarManager/evPower", "format" => "leistung",
|
||||
["topic" => "solarManager/evPower", "format" => "leistung_kw",
|
||||
"icon" => "ev-station"],
|
||||
]],
|
||||
// Der Garten ist kein Bauteil wie die anderen, aber ein Ort: hier haengen
|
||||
|
||||
@@ -22,6 +22,9 @@
|
||||
require_once(__DIR__ . "/costs.php");
|
||||
require_once(__DIR__ . "/kacheln.php");
|
||||
require_once(__DIR__ . "/reiter.php");
|
||||
// Nur wegen SKODA_APP_LINK - der Weg zu den Schlüsseln gehört neben das Feld,
|
||||
// in das sie eingetragen werden, und der Link soll nur an einer Stelle stehen.
|
||||
require_once(__DIR__ . "/skodaKeys.php");
|
||||
|
||||
/*
|
||||
* Die Reiter. Reihenfolge ist Anzeigereihenfolge; der erste ist der offene,
|
||||
@@ -31,6 +34,7 @@ $reiter = [
|
||||
["id" => "preise", "titel" => "Preise", "symbol" => "bi-currency-euro"],
|
||||
["id" => "kacheln", "titel" => "Home-Kacheln", "symbol" => "bi-grid-1x2"],
|
||||
["id" => "geraete", "titel" => "Geräte", "symbol" => "bi-house-gear"],
|
||||
["id" => "fahrzeug", "titel" => "Fahrzeug", "symbol" => "bi-ev-front"],
|
||||
];
|
||||
// "merken": der offene Reiter steht in der Adresse und uebersteht ein
|
||||
// Neuladen - siehe reiterMerken() in js/solar/common.js.
|
||||
@@ -192,6 +196,51 @@ try {
|
||||
</div>
|
||||
</div>
|
||||
<?= reiterFlaecheZu() ?><!-- /Geräte -->
|
||||
|
||||
<!-- =================================================== Fahrzeug ==== -->
|
||||
<!-- Die Zugangsschlüssel der MyŠkoda-Anbindung. Sie laufen ab und
|
||||
müssen dann getauscht werden - vorher hieß das: per SSH auf die NAS
|
||||
und skoda.conf im Editor öffnen.
|
||||
|
||||
Die Zeilen zeichnet js/solar/settings.js aus dem, was
|
||||
ajax/settings.php?action=skoda-keys liefert. Was dort NICHT
|
||||
mitkommt, sind die Schlüssel selbst: die Seite steht im Heimnetz
|
||||
ohne Anmeldung offen, und ein solcher Schlüssel steuert das
|
||||
Fahrzeug von überall auf der Welt. Zu sehen ist nur, ob einer
|
||||
hinterlegt ist und auf welche vier Zeichen er endet. -->
|
||||
<?= reiterFlaecheAuf("fahrzeug", $reiterOpt) ?>
|
||||
<div class="row">
|
||||
<div class="col-12 col-xxl-8">
|
||||
<div class="card mb-4" id="skodaKarte">
|
||||
<div class="card-header pb-2 pt-2">
|
||||
<h3 class="card-title"><i class="bi bi-key me-2"></i>Zugang zum Fahrzeug</h3>
|
||||
<div class="card-tools">
|
||||
<button type="button" class="btn btn-tool" id="skodaNeuLaden" title="Neu laden">
|
||||
<i class="bi bi-arrow-counterclockwise"></i>
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
<div class="card-body">
|
||||
<p class="text-secondary small mb-3">
|
||||
Die Schlüssel werden in der MyŠkoda-App erzeugt, gelten nur für die
|
||||
dort ausgewählten Fahrzeuge und laufen nach einiger Zeit ab. Ein neuer
|
||||
wird hier eingetragen und sofort einmal ausprobiert – was die API
|
||||
ablehnt, landet gar nicht erst in der Konfiguration.
|
||||
</p>
|
||||
<p class="mb-3">
|
||||
<a class="btn btn-sm btn-outline-primary"
|
||||
href="<?= SKODA_APP_LINK ?>" target="_blank" rel="noopener">
|
||||
<i class="bi bi-box-arrow-up-right me-1"></i>Schlüssel in der MyŠkoda-App verwalten
|
||||
</a>
|
||||
</p>
|
||||
<div id="skodaListe">
|
||||
<p class="text-secondary small mb-0">Wird geladen …</p>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
<?= reiterFlaecheZu() ?><!-- /Fahrzeug -->
|
||||
</div><!-- /tab-content -->
|
||||
|
||||
</div>
|
||||
|
||||
@@ -0,0 +1,546 @@
|
||||
<?php
|
||||
/**
|
||||
* Die Zugangsschlüssel der MyŠkoda-Anbindung.
|
||||
*
|
||||
* Eine Stelle für alles, was skoda.conf betrifft: wo die Datei liegt, wie sie
|
||||
* gelesen wird, was davon die Oberfläche sehen darf und wie ein neuer
|
||||
* Schlüssel hineinkommt. Vorher wusste ajax/skodaCmd.php das für sich allein;
|
||||
* mit dem Reiter in den Einstellungen wären es zwei Fassungen geworden, die
|
||||
* sich beim ersten Formatwechsel unterscheiden.
|
||||
*
|
||||
* Dieselbe Datei liest gatherSkodaData.py im SolarManager. Dass das Format
|
||||
* dort ein zweites Mal steht, lässt sich nicht vermeiden - zwei Sprachen,
|
||||
* zwei Repositorien. skoda.conf.example daneben ist die gemeinsame
|
||||
* Beschreibung, und sie ist die Stelle, an der ein neues Feld zuerst
|
||||
* auftauchen sollte.
|
||||
*
|
||||
* ---------------------------------------------------------------------------
|
||||
* Ein Schlüssel geht nie an den Browser zurück
|
||||
*
|
||||
* Die Seite steht im Heimnetz ohne Anmeldung offen (isLocal() in helper.php),
|
||||
* und so ein Schlüssel steuert das Fahrzeug von überall auf der Welt - Laden,
|
||||
* Klimatisierung, Standort. Wer ihn abliest, braucht das Heimnetz danach nicht
|
||||
* mehr. Die Maske bekommt deshalb nur zu sehen, ob ein Schlüssel hinterlegt
|
||||
* ist und auf welche vier Zeichen er endet; das genügt, um zwei
|
||||
* auseinanderzuhalten, und taugt zu nichts sonst.
|
||||
*
|
||||
* Geschrieben wird nur in eine Richtung: ein neuer Wert kommt herein, der alte
|
||||
* kommt nie heraus.
|
||||
* ---------------------------------------------------------------------------
|
||||
*/
|
||||
|
||||
/** Die Datei mit den Zugangsdaten. Liegt außerhalb des Webverzeichnisses; sie
|
||||
* gehört zum SolarManager, der sie ebenfalls liest.
|
||||
*
|
||||
* Mit define() davor umzuhängen - ein Prüflauf arbeitet dann auf einer Kopie
|
||||
* und nicht auf den echten Zugangsdaten. */
|
||||
defined("SKODA_KONFIG") || define("SKODA_KONFIG", "/volume1/homes/wagner/SolarManager/skoda.conf");
|
||||
|
||||
/** Basis der öffentlichen API. Ein GET darauf prüft einen Schlüssel. */
|
||||
const SKODA_API = "https://public.api.connect.skoda-auto.cz/api/v1/vehicles/";
|
||||
|
||||
const SKODA_KENNUNG = "SmartController-Skoda/1.0 (+https://nas.el-wa.org/smart)";
|
||||
|
||||
/** Wo die Schlüssel herkommen - der Link gehört in die Maske. */
|
||||
const SKODA_APP_LINK = "https://go.skoda.eu/api-keys";
|
||||
|
||||
/** Befehle je Stunde.
|
||||
*
|
||||
* Das Kontingent der API - 20 je Stunde - gilt gemessen fürs ganze Konto und
|
||||
* nicht je Schlüssel (die Rechnung steht bei _LIMIT in gatherSkodaData.py).
|
||||
* Abruf und Steuerung laufen in getrennten Prozessen ohne gemeinsamen
|
||||
* Zähler, also ist fest aufgeteilt: 14 für den Abruf, 4 für Befehle, 2
|
||||
* Reserve. Ein eigener CMD_API_KEY ändert daran nichts mehr. */
|
||||
const SKODA_BEFEHLE = 4;
|
||||
|
||||
/** Verzeichnisse für kleine Merkzettel zwischen Weboberfläche und Manager.
|
||||
* Das erste, das der Webserver beschreiben darf, gewinnt. Dieselbe Liste in
|
||||
* derselben Reihenfolge steht als _ANSTOSS_ORTE in gatherSkodaData.py. */
|
||||
const SKODA_ARBEITSORTE = [
|
||||
"/volume1/web/smart/tiles", // falls per synoacltool freigegeben
|
||||
"/var/services/tmp/smart-tiles", // sonst
|
||||
];
|
||||
|
||||
/** Name der Anstoßdatei - siehe skodaAbrufAnstossen(). */
|
||||
const SKODA_ANSTOSS_DATEI = ".skoda_abruf";
|
||||
|
||||
/** Name des Stundenzählers für Befehle - siehe budgetFrei() in skodaCmd.php. */
|
||||
const SKODA_ZAEHLER_DATEI = ".befehle.json";
|
||||
|
||||
/** Abstand zweier Abrufe beim Laden und während der Fahrt. Dieselbe Zahl
|
||||
* steht als _I_LADEN in gatherSkodaData.py; hier nur, um sie anzuzeigen.
|
||||
* Weitere Schlüssel machen sie nicht kleiner - siehe SKODA_BEFEHLE. */
|
||||
const SKODA_TAKT = 260;
|
||||
|
||||
/**
|
||||
* Die Schlüssel, die skoda.conf kennen darf, in Anzeigereihenfolge.
|
||||
*
|
||||
* Als Funktion und nicht als Konstante, weil jeder Eintrag seinen Satz
|
||||
* Erklärung mitbringt - die steht in der Maske und soll nicht dort noch
|
||||
* einmal getippt werden.
|
||||
*/
|
||||
function skodaFelder()
|
||||
{
|
||||
return [
|
||||
[
|
||||
"feld" => "API_KEY",
|
||||
"titel" => "Abruf",
|
||||
"pflicht" => true,
|
||||
"zweck" => "Holt den Fahrzeugzustand. Ohne ihn bleibt die "
|
||||
. "Fahrzeugseite leer.",
|
||||
],
|
||||
[
|
||||
"feld" => "API_KEY2",
|
||||
"titel" => "Abruf, zweiter Schlüssel",
|
||||
"pflicht" => false,
|
||||
"zweck" => "Freiwillig, und kein dichterer Abruf: das Kontingent "
|
||||
. "gilt gemessen fürs ganze Konto. Was er bringt, ist "
|
||||
. "Ausfallsicherheit – läuft einer ab oder wird er "
|
||||
. "widerrufen, fragt der Abruf mit dem nächsten weiter.",
|
||||
],
|
||||
[
|
||||
"feld" => "API_KEY3",
|
||||
"titel" => "Abruf, dritter Schlüssel",
|
||||
"pflicht" => false,
|
||||
"zweck" => "Wie der zweite. Mehr als drei liest die "
|
||||
. "Konfiguration nicht.",
|
||||
],
|
||||
[
|
||||
"feld" => "CMD_API_KEY",
|
||||
"titel" => "Befehle",
|
||||
"pflicht" => false,
|
||||
"zweck" => "Für Laden, Klimatisierung und Lüftung. Ohne ihn "
|
||||
. "schickt die Weboberfläche ihre Befehle mit dem "
|
||||
. "ersten Schlüssel. Ein eigener lässt sich einzeln "
|
||||
. "widerrufen, ohne den Abruf mitzunehmen.",
|
||||
],
|
||||
];
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------- Lesen -- */
|
||||
|
||||
/**
|
||||
* skoda.conf als Zuweisungen lesen. Format: NAME=wert, eine je Zeile.
|
||||
*
|
||||
* Liefert null, wenn die Datei fehlt oder nicht lesbar ist - das ist der
|
||||
* normale Zustand einer Installation ohne Fahrzeug und kein Fehler.
|
||||
*/
|
||||
function skodaKonfigLesen()
|
||||
{
|
||||
if (!is_readable(SKODA_KONFIG)) {
|
||||
return null;
|
||||
}
|
||||
$zeilen = file(SKODA_KONFIG, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
|
||||
if ($zeilen === false) {
|
||||
return null;
|
||||
}
|
||||
$werte = [];
|
||||
foreach ($zeilen as $zeile) {
|
||||
$zeile = trim($zeile);
|
||||
if ($zeile === "" || $zeile[0] === "#" || strpos($zeile, "=") === false) {
|
||||
continue;
|
||||
}
|
||||
list($k, $v) = explode("=", $zeile, 2);
|
||||
$werte[strtoupper(trim($k))] = trim(trim($v), "\"'");
|
||||
}
|
||||
return $werte;
|
||||
}
|
||||
|
||||
/**
|
||||
* Welcher Schlüssel die Befehle schickt und mit welcher VIN.
|
||||
*
|
||||
* Der eigene, wenn es ihn gibt - sonst der des Abrufs. Liefert null, solange
|
||||
* nichts hinterlegt ist.
|
||||
*/
|
||||
function skodaBefehlsSchluessel()
|
||||
{
|
||||
$werte = skodaKonfigLesen();
|
||||
if (!$werte || empty($werte["API_KEY"]) || empty($werte["VIN"])) {
|
||||
return null;
|
||||
}
|
||||
$eigener = !empty($werte["CMD_API_KEY"]);
|
||||
return [
|
||||
"vin" => $werte["VIN"],
|
||||
"schluessel" => $eigener ? $werte["CMD_API_KEY"] : $werte["API_KEY"],
|
||||
"eigener" => $eigener,
|
||||
];
|
||||
}
|
||||
|
||||
/** Die letzten vier Zeichen, mehr darf die Maske nicht wissen. */
|
||||
function skodaMaske($wert)
|
||||
{
|
||||
$wert = (string)$wert;
|
||||
return strlen($wert) > 4 ? "…" . substr($wert, -4) : "…";
|
||||
}
|
||||
|
||||
/**
|
||||
* Wann der erste Schlüssel abläuft, laut der letzten Antwort des Fahrzeugs.
|
||||
*
|
||||
* gatherSkodaData.py schreibt bei jedem Abruf mit, was der Header
|
||||
* X-API-Key-Expires-At sagt - bei mehreren Schlüsseln das früheste Datum.
|
||||
* Genauer geht es von hier aus nicht, ohne die API zu fragen, und dafür ist
|
||||
* die Auskunft zu unwichtig.
|
||||
*/
|
||||
function skodaAblaufAusHistorie()
|
||||
{
|
||||
$datum = null;
|
||||
try {
|
||||
$mysql = new mysqli($GLOBALS["mysql_server"], $GLOBALS["mysql_solarUser"],
|
||||
$GLOBALS["mysql_solarPass"], $GLOBALS["mysql_solarDB"]);
|
||||
if ($mysql->connect_errno) {
|
||||
return null;
|
||||
}
|
||||
$res = $mysql->query("SELECT key_expires FROM skoda "
|
||||
. "WHERE key_expires IS NOT NULL ORDER BY id DESC LIMIT 1;");
|
||||
if ($res && ($zeile = $res->fetch_assoc())) {
|
||||
$datum = $zeile["key_expires"];
|
||||
}
|
||||
$mysql->close();
|
||||
} catch (Throwable $e) {
|
||||
return null; // ohne Historie eben ohne Datum
|
||||
}
|
||||
return $datum;
|
||||
}
|
||||
|
||||
/**
|
||||
* Der Stand für die Maske: was hinterlegt ist, was daraus folgt.
|
||||
*
|
||||
* Ohne Schlüsselwerte - siehe den Kopfkommentar.
|
||||
*/
|
||||
function skodaStand()
|
||||
{
|
||||
$werte = skodaKonfigLesen();
|
||||
$da = is_array($werte);
|
||||
|
||||
$felder = [];
|
||||
$abruf = 0;
|
||||
foreach (skodaFelder() as $f) {
|
||||
$wert = $da && !empty($werte[$f["feld"]]) ? $werte[$f["feld"]] : "";
|
||||
$f["gesetzt"] = $wert !== "";
|
||||
$f["maske"] = $wert !== "" ? skodaMaske($wert) : "";
|
||||
$felder[] = $f;
|
||||
if ($wert !== "" && $f["feld"] !== "CMD_API_KEY") {
|
||||
$abruf++;
|
||||
}
|
||||
}
|
||||
|
||||
return [
|
||||
"datei" => SKODA_KONFIG,
|
||||
"da" => $da,
|
||||
"schreibbar" => $da && is_writable(SKODA_KONFIG),
|
||||
"vin" => $da && !empty($werte["VIN"]) ? skodaMaske($werte["VIN"]) : "",
|
||||
"felder" => $felder,
|
||||
"abruf" => $abruf,
|
||||
// Was gilt - die Zahlen, nach denen man sonst im Quelltext sucht.
|
||||
"takt" => SKODA_TAKT,
|
||||
"befehle" => SKODA_BEFEHLE,
|
||||
"ablauf" => $da ? skodaAblaufAusHistorie() : null,
|
||||
"link" => SKODA_APP_LINK,
|
||||
];
|
||||
}
|
||||
|
||||
/* ------------------------------------------------------------- Schreiben -- */
|
||||
|
||||
/**
|
||||
* Prüft einen Schlüssel, indem einmal das Fahrzeug abgefragt wird.
|
||||
*
|
||||
* Lieber eine Anfrage jetzt als ein Tippfehler, der erst Minuten später als
|
||||
* Zeile im Log auffällt. Sie kostet eine der 20 Anfragen, die der neue
|
||||
* Schlüssel in seiner ersten Stunde hat - die er ohnehin frisch mitbringt.
|
||||
*
|
||||
* Zurück kommt, was die API sagt, und ihr Ablaufdatum: [ok, status, ablauf,
|
||||
* text].
|
||||
*/
|
||||
function skodaSchluesselPruefen($schluessel, $vin)
|
||||
{
|
||||
$ch = curl_init(SKODA_API . rawurlencode($vin));
|
||||
curl_setopt_array($ch, [
|
||||
CURLOPT_RETURNTRANSFER => true,
|
||||
CURLOPT_HEADER => true,
|
||||
CURLOPT_USERAGENT => SKODA_KENNUNG,
|
||||
CURLOPT_TIMEOUT => 10,
|
||||
CURLOPT_CONNECTTIMEOUT => 5,
|
||||
CURLOPT_HTTPHEADER => [
|
||||
"X-API-Key: " . $schluessel,
|
||||
"Accept: application/json",
|
||||
],
|
||||
]);
|
||||
$inhalt = curl_exec($ch);
|
||||
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
|
||||
$kopfEnde = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
|
||||
curl_close($ch);
|
||||
|
||||
if ($inhalt === false) {
|
||||
return ["ok" => false, "status" => 0, "ablauf" => null,
|
||||
"text" => "Die Škoda-API ist nicht erreichbar."];
|
||||
}
|
||||
|
||||
$ablauf = null;
|
||||
foreach (explode("\n", substr($inhalt, 0, $kopfEnde)) as $zeile) {
|
||||
if (stripos($zeile, "X-API-Key-Expires-At:") === 0) {
|
||||
$ablauf = trim(substr($zeile, strlen("X-API-Key-Expires-At:")));
|
||||
}
|
||||
}
|
||||
|
||||
switch ($status) {
|
||||
case 200:
|
||||
return ["ok" => true, "status" => 200, "ablauf" => $ablauf, "text" => ""];
|
||||
case 401:
|
||||
return ["ok" => false, "status" => 401, "ablauf" => null,
|
||||
"text" => "Die API kennt diesen Schlüssel nicht - abgelaufen "
|
||||
. "oder vertippt."];
|
||||
case 403:
|
||||
return ["ok" => false, "status" => 403, "ablauf" => null,
|
||||
"text" => "Der Schlüssel gilt nicht für dieses Fahrzeug. In "
|
||||
. "der MyŠkoda-App muss es beim Anlegen ausgewählt sein."];
|
||||
case 404:
|
||||
return ["ok" => false, "status" => 404, "ablauf" => null,
|
||||
"text" => "Fahrzeug nicht gefunden - stimmt die VIN in "
|
||||
. SKODA_KONFIG . "?"];
|
||||
case 429:
|
||||
// Kein Urteil über den Schlüssel: er ist in Ordnung, nur gerade
|
||||
// ausgeschöpft. Das darf den Tausch nicht verhindern.
|
||||
return ["ok" => true, "status" => 429, "ablauf" => null,
|
||||
"text" => "Kontingent gerade erschöpft - nicht geprüft, "
|
||||
. "aber übernommen."];
|
||||
default:
|
||||
return ["ok" => true, "status" => $status, "ablauf" => $ablauf,
|
||||
"text" => "Unerwartete Antwort (HTTP " . $status . ") - nicht "
|
||||
. "geprüft, aber übernommen."];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Ein Schlüssel, wie er in einer Zeile NAME=wert stehen darf.
|
||||
*
|
||||
* Entscheidend ist, dass kein Zeilenumbruch hineinkommt: mit einem ließen sich
|
||||
* weitere Zuweisungen unterschieben, etwa eine fremde VIN. Sonst wird bewusst
|
||||
* wenig verlangt - welche Form Škoda seinen Schlüsseln morgen gibt, steht
|
||||
* nicht in unserer Hand.
|
||||
*/
|
||||
function skodaWertPruefen($feld, $wert)
|
||||
{
|
||||
$wert = trim((string)$wert);
|
||||
if ($wert === "") {
|
||||
throw new InvalidArgumentException($feld . ": kein Wert angegeben.");
|
||||
}
|
||||
if (preg_match('/\s/', $wert)) {
|
||||
throw new InvalidArgumentException($feld . ": ein Schlüssel enthält keine "
|
||||
. "Leerzeichen oder Zeilenumbrüche - versehentlich zu viel kopiert?");
|
||||
}
|
||||
if (!preg_match('/^[\x21-\x7e]{8,256}$/', $wert)) {
|
||||
throw new InvalidArgumentException($feld . ": das sieht nicht nach einem "
|
||||
. "Schlüssel aus (8 bis 256 Zeichen, keine Sonderzeichen).");
|
||||
}
|
||||
return $wert;
|
||||
}
|
||||
|
||||
/**
|
||||
* skoda.conf neu schreiben.
|
||||
*
|
||||
* $aenderungen: Feld => neuer Wert, oder Feld => null zum Entfernen.
|
||||
*
|
||||
* Die Datei bleibt, wie sie ist: jede Zeile, die nicht gemeint ist, geht
|
||||
* unverändert durch - Kommentare, VIN, DB_PASSWORD, Leerzeilen. Ein Feld, das
|
||||
* noch nicht vorkommt, wird angehängt.
|
||||
*
|
||||
* Geschrieben wird daneben und dann umbenannt. Das Umbenennen ist der einzige
|
||||
* Augenblick, in dem sich die Datei ändert; wer sie gerade liest - der Manager
|
||||
* alle paar Minuten, skodaCmd.php bei jedem Befehl - sieht entweder den alten
|
||||
* oder den neuen Stand, nie einen halben.
|
||||
*/
|
||||
function skodaKonfigSchreiben(array $aenderungen)
|
||||
{
|
||||
$roh = @file(SKODA_KONFIG);
|
||||
if ($roh === false) {
|
||||
throw new RuntimeException("Die Datei " . SKODA_KONFIG . " ist nicht lesbar.");
|
||||
}
|
||||
|
||||
$offen = $aenderungen; // was noch nicht untergebracht ist
|
||||
$neu = [];
|
||||
foreach ($roh as $zeile) {
|
||||
$blank = trim($zeile);
|
||||
$name = "";
|
||||
if ($blank !== "" && $blank[0] !== "#" && strpos($blank, "=") !== false) {
|
||||
$name = strtoupper(trim(explode("=", $blank, 2)[0]));
|
||||
}
|
||||
if ($name === "" || !array_key_exists($name, $offen)) {
|
||||
$neu[] = rtrim($zeile, "\r\n");
|
||||
continue;
|
||||
}
|
||||
if ($offen[$name] !== null) {
|
||||
$neu[] = $name . "=" . $offen[$name];
|
||||
} // null: Zeile fällt weg
|
||||
unset($offen[$name]);
|
||||
}
|
||||
foreach ($offen as $name => $wert) {
|
||||
if ($wert !== null) {
|
||||
$neu[] = $name . "=" . $wert;
|
||||
}
|
||||
}
|
||||
|
||||
// Rechte der alten Datei übernehmen: der Manager läuft unter einem anderen
|
||||
// Benutzer und muss sie weiter lesen können.
|
||||
$rechte = @fileperms(SKODA_KONFIG);
|
||||
$rechte = $rechte ? ($rechte & 0777) : 0666;
|
||||
|
||||
$vorlaeufig = SKODA_KONFIG . ".neu." . getmypid();
|
||||
if (@file_put_contents($vorlaeufig, implode("\n", $neu) . "\n") === false) {
|
||||
throw new RuntimeException("Konnte neben " . SKODA_KONFIG . " nicht "
|
||||
. "schreiben - fehlen dem Webserver die Rechte auf das Verzeichnis?");
|
||||
}
|
||||
@chmod($vorlaeufig, $rechte);
|
||||
if (!@rename($vorlaeufig, SKODA_KONFIG)) {
|
||||
@unlink($vorlaeufig);
|
||||
throw new RuntimeException("Konnte " . SKODA_KONFIG . " nicht ersetzen.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Neue Schlüssel prüfen und speichern.
|
||||
*
|
||||
* $neu: Feld => Wert. Leere Werte bedeuten "unverändert" und fallen hier
|
||||
* schon weg - ein leeres Feld in der Maske soll nichts löschen.
|
||||
* $loeschen: Felder, die verschwinden sollen.
|
||||
*
|
||||
* Erst prüfen, dann schreiben: ein Schlüssel, den die API ablehnt, kommt gar
|
||||
* nicht erst in die Datei. Sonst stünde der Abruf still, bis es jemand im Log
|
||||
* bemerkt.
|
||||
*/
|
||||
function skodaSchluesselSpeichern(array $neu, array $loeschen = [])
|
||||
{
|
||||
$stand = skodaStand();
|
||||
if (!$stand["da"]) {
|
||||
throw new RuntimeException("Die Datei " . SKODA_KONFIG . " gibt es nicht. "
|
||||
. "Ohne sie läuft auch der Abruf nicht - sie gehört zum SolarManager.");
|
||||
}
|
||||
$erlaubt = array_column(skodaFelder(), "feld");
|
||||
$werte = skodaKonfigLesen();
|
||||
$vin = $werte["VIN"] ?? "";
|
||||
if ($vin === "") {
|
||||
throw new RuntimeException("In " . SKODA_KONFIG . " steht keine VIN - "
|
||||
. "ohne sie lässt sich kein Schlüssel prüfen.");
|
||||
}
|
||||
|
||||
$aenderungen = [];
|
||||
foreach ($neu as $feld => $wert) {
|
||||
$feld = strtoupper((string)$feld);
|
||||
if (!in_array($feld, $erlaubt, true)) {
|
||||
throw new InvalidArgumentException("Unbekanntes Feld: " . $feld);
|
||||
}
|
||||
if (trim((string)$wert) === "") {
|
||||
continue; // leer heißt: so lassen
|
||||
}
|
||||
$aenderungen[$feld] = skodaWertPruefen($feld, $wert);
|
||||
}
|
||||
|
||||
/*
|
||||
* Derselbe Schlüssel zweimal bringt kein zweites Kontingent - die API
|
||||
* zählt den Schlüssel, nicht die Zeile. gatherSkodaData.py wirft ein
|
||||
* Duplikat beim Lesen weg; hier fiele es nur als "zwei Schlüssel" auf,
|
||||
* die den Abruf dann doch nicht beschleunigen.
|
||||
*/
|
||||
foreach ($aenderungen as $feld => $wert) {
|
||||
if ($wert === null) {
|
||||
continue;
|
||||
}
|
||||
foreach ($erlaubt as $anderes) {
|
||||
if ($anderes === $feld) {
|
||||
continue;
|
||||
}
|
||||
$schon = array_key_exists($anderes, $aenderungen)
|
||||
? $aenderungen[$anderes] : ($werte[$anderes] ?? "");
|
||||
if ($schon !== null && $schon !== "" && hash_equals((string)$schon, $wert)) {
|
||||
throw new InvalidArgumentException($feld . ": dieser Schlüssel steht "
|
||||
. "schon als " . $anderes . " da. Ein zweites Mal derselbe bringt "
|
||||
. "kein zweites Kontingent - in der MyŠkoda-App einen neuen anlegen.");
|
||||
}
|
||||
}
|
||||
}
|
||||
foreach ($loeschen as $feld) {
|
||||
$feld = strtoupper((string)$feld);
|
||||
if (!in_array($feld, $erlaubt, true)) {
|
||||
throw new InvalidArgumentException("Unbekanntes Feld: " . $feld);
|
||||
}
|
||||
if ($feld === "API_KEY") {
|
||||
throw new InvalidArgumentException("Ohne den ersten Schlüssel gibt es "
|
||||
. "keinen Abruf mehr. Er lässt sich ersetzen, aber nicht entfernen.");
|
||||
}
|
||||
$aenderungen[$feld] = null;
|
||||
}
|
||||
if (!$aenderungen) {
|
||||
throw new InvalidArgumentException("Nichts einzutragen.");
|
||||
}
|
||||
|
||||
/*
|
||||
* Ab hier wird das Netz befragt, und das kann dauern. helper.php hat die
|
||||
* Sitzung geöffnet und hält sie gesperrt, solange diese Anfrage läuft -
|
||||
* ohne das hier stünde der ganze Browser so lange still, auch die Kacheln
|
||||
* in einem anderen Reiter.
|
||||
*/
|
||||
if (session_status() === PHP_SESSION_ACTIVE) {
|
||||
session_write_close();
|
||||
}
|
||||
|
||||
$meldungen = [];
|
||||
foreach ($aenderungen as $feld => $wert) {
|
||||
if ($wert === null) {
|
||||
continue;
|
||||
}
|
||||
$urteil = skodaSchluesselPruefen($wert, $vin);
|
||||
if (!$urteil["ok"]) {
|
||||
throw new InvalidArgumentException($feld . ": " . $urteil["text"]);
|
||||
}
|
||||
if ($urteil["text"] !== "") {
|
||||
$meldungen[] = $feld . ": " . $urteil["text"];
|
||||
} elseif ($urteil["ablauf"]) {
|
||||
$meldungen[] = $feld . " angenommen, gültig bis "
|
||||
. skodaDatumKurz($urteil["ablauf"]) . ".";
|
||||
} else {
|
||||
$meldungen[] = $feld . " angenommen.";
|
||||
}
|
||||
}
|
||||
|
||||
skodaKonfigSchreiben($aenderungen);
|
||||
|
||||
/*
|
||||
* Der Manager liest skoda.conf von selbst neu, sobald sie sich geändert
|
||||
* hat - aber erst, wenn der nächste Abruf ohnehin ansteht, und beim Parken
|
||||
* sind das 20 Minuten. Derselbe Anstoß wie nach einem Befehl holt ihn auf
|
||||
* eine halbe Minute heran; dann greift ein neuer Schlüssel sofort.
|
||||
*/
|
||||
skodaAbrufAnstossen();
|
||||
|
||||
return ["meldungen" => $meldungen, "stand" => skodaStand()];
|
||||
}
|
||||
|
||||
/* ---------------------------------------------------------------- Beiwerk - */
|
||||
|
||||
/** Ein API-Datum kurz und deutsch. Unlesbares bleibt, wie es ist. */
|
||||
function skodaDatumKurz($iso)
|
||||
{
|
||||
$zeit = strtotime((string)$iso);
|
||||
return $zeit ? date("d.m.Y", $zeit) : (string)$iso;
|
||||
}
|
||||
|
||||
/**
|
||||
* Dem Abruf im solarManager Bescheid geben, dass sich gleich etwas ändert.
|
||||
*
|
||||
* Berührt wird eine leere Datei; gatherSkodaData.py sieht bei jedem seiner
|
||||
* Durchläufe auf ihre Änderungszeit und holt den nächsten Abruf auf
|
||||
* _NACH_BEFEHL Sekunden danach vor. Ein stat alle drei Sekunden ist billiger
|
||||
* als eine Verbindung, die dafür offen bleiben müsste, und es geht auch dann
|
||||
* nichts verloren, wenn einer der beiden Prozesse gerade neu startet.
|
||||
*
|
||||
* Kein Fehler, wenn es nicht klappt: der Befehl ist beim Fahrzeug, nur die
|
||||
* Anzeige zieht dann später nach.
|
||||
*/
|
||||
function skodaAbrufAnstossen()
|
||||
{
|
||||
foreach (SKODA_ARBEITSORTE as $ort) {
|
||||
if (is_dir($ort) && is_writable($ort)) {
|
||||
@touch($ort . "/" . SKODA_ANSTOSS_DATEI);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
-- Verlauf der Wallboxen waehrend einer Ladung.
|
||||
--
|
||||
-- Das Fahrzeug meldet seinen Stand beim Laden an der Wallbox mitunter nur
|
||||
-- einmal in der Stunde (Tabelle skoda). Fuer die Summe einer Ladung genuegt
|
||||
-- das - Energie vom Wallbox-Zaehler, Ladestand von der Zeile davor und danach
|
||||
-- -, fuer den Verlauf nicht: am 13.09.2026 meldete es um 10:29 noch 5,7 kW und
|
||||
-- um 11:22 dann 7,7 kW, waehrend die Wallbox seit 10:54 mit 11 kW lief.
|
||||
--
|
||||
-- Die Wallboxen dagegen stehen alle drei Sekunden zur Verfuegung. In EnergyFlow
|
||||
-- landen sie als Fuenf-Minuten-Werte, aber EnergyFlow wird nach zwoelf Monaten
|
||||
-- ausgeduennt (solarlog-rollup.sh thin) - eine Ladekurve vom letzten Sommer
|
||||
-- liesse sich dann nicht mehr zeichnen. Deshalb haelt gatherSkodaData.py die
|
||||
-- Werte hier fest, solange eine Wallbox Strom liefert, und diese Tabelle wird
|
||||
-- nicht ausgeduennt. Bei 60 Sekunden Abstand sind das rund 180 Zeilen je
|
||||
-- Ladung, im Jahr grob 25.000.
|
||||
--
|
||||
-- Der Gesamtzaehler steht in jeder Zeile mit. Zwischen zwei Meldungen des
|
||||
-- Fahrzeugs laesst sich der Ladestand damit nach der geflossenen Energie
|
||||
-- auffuellen, ohne Akkukapazitaet oder Wirkungsgrad zu kennen:
|
||||
--
|
||||
-- soc(t) = soc_a + (soc_b - soc_a) * (wh(t) - wh_a) / (wh_b - wh_a)
|
||||
--
|
||||
-- Beide Wallboxen werden festgehalten, auch wenn die Auswertung heute nur die
|
||||
-- im Carport kennt: laedt das Fahrzeug einmal im Obergeschoss, soll der
|
||||
-- Verlauf nicht fehlen.
|
||||
|
||||
CREATE TABLE IF NOT EXISTS `skoda_ladepunkte` (
|
||||
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
|
||||
`datetime` datetime NOT NULL COMMENT 'Ortszeit',
|
||||
`wallbox` enum('carport','og') NOT NULL COMMENT 'carport = Wattpilot, og = go-e',
|
||||
`kw` decimal(6,3) NOT NULL COMMENT 'Ladeleistung laut Wallbox; 0 = Ende der Ladung',
|
||||
`wh_total` bigint(20) unsigned DEFAULT NULL COMMENT 'Gesamtzaehler der Wallbox; NULL = nicht gelesen',
|
||||
`pv_kw` decimal(7,3) DEFAULT NULL COMMENT 'PV-Leistung im selben Augenblick',
|
||||
`grid_kw` decimal(7,3) DEFAULT NULL COMMENT 'Netz, positiv = Bezug',
|
||||
`quelle` enum('manager','energyflow') NOT NULL DEFAULT 'manager'
|
||||
COMMENT 'energyflow = nachgetragen aus Fuenf-Minuten-Werten, wh_total dann gerechnet',
|
||||
PRIMARY KEY (`id`),
|
||||
KEY `datetime` (`datetime`),
|
||||
KEY `wallbox` (`wallbox`, `datetime`)
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;
|
||||
Reference in New Issue
Block a user