Kilometrage des vehicules : releves km, km par kWh, capacite estimee (tables, vues, Grafana, formulaire HA)
This commit is contained in:
Tallagrand Thierry
@@ -1350,6 +1350,101 @@ ORDER BY date_trunc(pas.unite, debut)"""
|
||||
COULEURS_VEHICULES = {"VW": "blue", "JEEP": "green", "ZERO": "purple",
|
||||
"Invite": "yellow", "Non etiquete": "orange"}
|
||||
|
||||
# Kilometrage et capacite (04/10/2026) : vues km_intervalle et capacite_estimee
|
||||
# du service d'historisation (tools/kilometrage.mjs). Aucune constante ici : les
|
||||
# references (autonomie / capacite) viennent du releve, donc des helpers HA.
|
||||
KM_REF = """(SELECT autonomie_ref_km / capacite_kwh FROM releve_km
|
||||
WHERE vehicule = '{v}' AND capacite_kwh > 0 AND autonomie_ref_km > 0 ORDER BY ts DESC LIMIT 1)"""
|
||||
KM_NUAGE = """WITH i AS (SELECT * FROM km_intervalle WHERE statut = 'valide'),
|
||||
cap AS (SELECT DISTINCT ON (vehicule) capacite_kwh AS c FROM releve_km
|
||||
WHERE capacite_kwh > 0 ORDER BY vehicule, ts DESC),
|
||||
x AS (SELECT round(kwh_consommes::numeric, 2)::float8 AS x, vehicule, km_parcourus::float8 AS km FROM i
|
||||
UNION ALL SELECT 0, NULL, NULL
|
||||
UNION ALL SELECT c::float8, NULL, NULL FROM cap)
|
||||
SELECT x AS "kWh consommes",
|
||||
CASE WHEN vehicule = 'JEEP' THEN km END AS "JEEP",
|
||||
CASE WHEN vehicule = 'VW' THEN km END AS "VW",
|
||||
CASE WHEN vehicule = 'ZERO' THEN km END AS "ZERO",
|
||||
round((x * """ + KM_REF.format(v="JEEP") + """)::numeric, 1)::float8 AS "Reference JEEP",
|
||||
round((x * """ + KM_REF.format(v="VW") + """)::numeric, 1)::float8 AS "Reference VW",
|
||||
round((x * """ + KM_REF.format(v="ZERO") + """)::numeric, 1)::float8 AS "Reference ZERO"
|
||||
FROM x ORDER BY 1"""
|
||||
|
||||
KM_XY = {"type": "xychart", "pluginVersion": "11.3.0",
|
||||
"title": "Kilometres contre kWh : le nuage des trajets",
|
||||
"description": ("Un point = l'intervalle entre deux releves du compteur d'un vehicule. "
|
||||
"kWh consommes = kWh livres par la borne entre les deux releves + "
|
||||
"(niveau au 1er - niveau au 2nd) x capacite. Les droites sont les "
|
||||
"references donnees par le proprietaire (JEEP 50 km, VW 42 km, ZERO 200 km "
|
||||
"pour une charge pleine). Sous la droite : on a roule moins loin par kWh "
|
||||
"(conduite, froid, chauffage — ou batterie qui s'use). Les intervalles "
|
||||
"d'une hybride finis batterie vide sont ecartes (km essence possibles)."),
|
||||
"datasource": PG, "gridPos": {"x": 0, "y": 24, "w": 14, "h": 11},
|
||||
"targets": [sql("A", KM_NUAGE, fmt="table")],
|
||||
"fieldConfig": {"defaults": {"unit": "lengthkm", "color": {"mode": "palette-classic"},
|
||||
"custom": {"show": "points", "pointSize": {"fixed": 10}, "pointShape": "circle",
|
||||
"lineWidth": 1, "fillOpacity": 60}},
|
||||
"overrides": [sur(v, [{"id": "color", "value": {"mode": "fixed", "fixedColor": COULEURS_VEHICULES[v]}}])
|
||||
for v in ["JEEP", "VW", "ZERO"]] +
|
||||
[sur("Reference " + v, [{"id": "color", "value": {"mode": "fixed", "fixedColor": COULEURS_VEHICULES[v]}},
|
||||
{"id": "custom.show", "value": "lines"},
|
||||
{"id": "custom.lineStyle", "value": {"fill": "dash", "dash": [10, 10]}}])
|
||||
for v in ["JEEP", "VW", "ZERO"]]},
|
||||
"options": {"mapping": "manual",
|
||||
"series": [{"frame": {"matcher": {"id": "byIndex", "options": 0}},
|
||||
"x": {"matcher": {"id": "byName", "options": "kWh consommes"}},
|
||||
"y": {"matcher": {"id": "byName", "options": n}}}
|
||||
for n in ["JEEP", "VW", "ZERO", "Reference JEEP", "Reference VW", "Reference ZERO"]],
|
||||
"legend": {"showLegend": True, "displayMode": "list", "placement": "bottom"},
|
||||
"tooltip": {"mode": "single", "sort": "none"}}}
|
||||
|
||||
KM_INTERVALLES = table("Les intervalles entre releves", [sql("A",
|
||||
"SELECT vehicule AS \"Vehicule\",\n"
|
||||
" to_char(debut AT TIME ZONE 'Europe/Paris', 'Dy DD/MM HH24:MI') AS \"Du\",\n"
|
||||
" to_char(fin AT TIME ZONE 'Europe/Paris', 'Dy DD/MM HH24:MI') AS \"Au\",\n"
|
||||
" km_parcourus AS \"km\",\n"
|
||||
" round(kwh_charges::numeric, 2) AS \"kWh borne\",\n"
|
||||
" niveau_debut || ' -> ' || niveau_fin || ' %' AS \"Niveau\",\n"
|
||||
" round(kwh_consommes::numeric, 2) AS \"kWh consommes\",\n"
|
||||
" round(km_par_kwh::numeric, 1) AS \"km/kWh\",\n"
|
||||
" round(km_par_kwh_ref::numeric, 1) AS \"Reference\",\n"
|
||||
" statut AS \"Statut\"\n"
|
||||
"FROM km_intervalle ORDER BY fin DESC", fmt="table")],
|
||||
PG, 14, 24, 10, 11,
|
||||
"Tous les intervalles, y compris ceux ecartes du nuage, avec la raison. "
|
||||
"« niveau manquant » : redonner le releve avec le niveau (« JEEP 112694 km 54 % »).",
|
||||
overrides=[sur("kWh borne", [{"id": "unit", "value": "kwatth"}]),
|
||||
sur("kWh consommes", [{"id": "unit", "value": "kwatth"}])])
|
||||
|
||||
KM_CAPACITE = ts("Capacite estimee des batteries (usure)", [sql("A",
|
||||
"SELECT debranche AS time,\n"
|
||||
" CASE WHEN vehicule = 'JEEP' THEN capacite_kwh END AS \"JEEP\",\n"
|
||||
" CASE WHEN vehicule = 'VW' THEN capacite_kwh END AS \"VW\",\n"
|
||||
" CASE WHEN vehicule = 'ZERO' THEN capacite_kwh END AS \"ZERO\"\n"
|
||||
"FROM capacite_estimee WHERE capacite_kwh IS NOT NULL AND $__timeFilter(debranche)\n"
|
||||
"ORDER BY 1")],
|
||||
PG, 0, 35, 14, 9, "kwatth",
|
||||
"Un point = un branchement ou le niveau a ete donne et la charge menee au plein "
|
||||
"(ou suivie d'un releve « debranche a NN % ») : capacite = kWh livres par la borne "
|
||||
"depuis le branchement / part manquante. Ce sont des kWh AU COMPTEUR (pertes du "
|
||||
"chargeur comprises). Une pente descendante sur des mois = usure de la batterie. "
|
||||
"Le niveau saisi est un entier : sur une petite charge, 1 point d'erreur pese lourd.",
|
||||
extra={"overrides": [sur(v, [{"id": "color", "value": {"mode": "fixed", "fixedColor": COULEURS_VEHICULES[v]}}])
|
||||
for v in ["JEEP", "VW", "ZERO"]]})
|
||||
KM_CAPACITE["fieldConfig"]["defaults"]["custom"].update(
|
||||
{"drawStyle": "points", "pointSize": 10, "showPoints": "always", "spanNulls": False})
|
||||
|
||||
KM_RELEVES = table("Les releves du compteur", [sql("A",
|
||||
"SELECT to_char(ts AT TIME ZONE 'Europe/Paris', 'Dy DD/MM HH24:MI') AS \"Quand\",\n"
|
||||
" vehicule AS \"Vehicule\", km AS \"Compteur\",\n"
|
||||
" coalesce(niveau_pct || ' %', '?') AS \"Niveau\", source AS \"Source\"\n"
|
||||
"FROM releve_km ORDER BY ts DESC", fmt="table")],
|
||||
PG, 14, 35, 10, 9,
|
||||
"Releves recus par WhatsApp (concierge) ou par le tableau EVCS Master. Un "
|
||||
"releve fait au branchement est date du branchement : le compteur n'avance pas "
|
||||
"pendant la charge.",
|
||||
overrides=[sur("Compteur", [{"id": "unit", "value": "lengthkm"}])])
|
||||
|
||||
vehicules = dashboard("evcs-vehicules", "Les vehicules", (
|
||||
"Ce que chaque voiture encaisse, session par session et sur la periode "
|
||||
"choisie. L'etiquette vient d'un selecteur manuel : elle peut etre fausse, "
|
||||
@@ -1430,6 +1525,7 @@ vehicules = dashboard("evcs-vehicules", "Les vehicules", (
|
||||
{"id": "custom.width", "value": 110}]),
|
||||
sur("dont reseau", [{"id": "unit", "value": "kwatth"}]),
|
||||
sur("P max", [{"id": "unit", "value": "watt"}])]),
|
||||
KM_XY, KM_INTERVALLES, KM_CAPACITE, KM_RELEVES,
|
||||
])
|
||||
|
||||
# =====================================================================
|
||||
@@ -1791,7 +1887,7 @@ journee = dashboard(
|
||||
# found ». Ici on veut les quatre colonnes, tout le temps.
|
||||
barchart("Energie heure par heure",
|
||||
[sql("A", energie_sql(prevision=True), fmt="table")],
|
||||
PG, 0, 4, 24, 9, "kwatth",
|
||||
PG, 0, 5, 24, 9, "kwatth",
|
||||
"La forme de la journee : quand le solaire a couvert la maison, quand il "
|
||||
"a fallu acheter — et, a la suite des barres mesurees, ce que la derniere "
|
||||
"prevision annonce pour les heures qui restent. L'heure EN COURS n'a pas "
|
||||
|
||||
@@ -29,6 +29,7 @@ import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
import pg from 'pg';
|
||||
import { creerSchemaKm, ingererReleves, ingererNiveauSaisi } from './kilometrage.mjs';
|
||||
import { texteRapport, envoyer, donneesNuit, texteDepuis } from './rapport-nuit.mjs';
|
||||
import { diagnosticPv, etatCellules, productionJour, chargeSolaire, bilanNuit, etatReseau, importJour, minuitLocal, COMPTEURS_IMPORT, COMPTEUR_EDF, consoJour, COMPTEURS_CONSO, projectionSoir, previsionNuit, vrmVersCourbes, nuitMaisonPrevue } from './diagnostics-agent.mjs';
|
||||
|
||||
@@ -710,6 +711,9 @@ async function migrer(client) {
|
||||
// « montre-moi tous les signalements graves de la semaine ».
|
||||
await client.query(
|
||||
'CREATE INDEX IF NOT EXISTS observation_gravite_idx ON observation (gravite, ts DESC)');
|
||||
// Kilometrage et capacite des vehicules (04/10/2026) : tables releve_km et
|
||||
// niveau_saisi, vues km_intervalle et capacite_estimee (tools/kilometrage.mjs).
|
||||
await creerSchemaKm(client);
|
||||
|
||||
// -------------------------------------------------------------------
|
||||
// REPARATION UNIQUE (13/09/2026) — onze sessions etiquetees « VW » a tort
|
||||
@@ -2128,6 +2132,11 @@ async function cycle(client) {
|
||||
ordre: await appliquerOrdreAirtria(sql, client, st).catch((e) => {
|
||||
console.error(`ordre airtria en echec : ${e.message}`); return 0;
|
||||
}),
|
||||
kilometrage: DRY ? 0 : await ingererReleves(sql, (q, v) => client.query(q, v), st, journaliser).catch((e) => {
|
||||
console.error(`releves km en echec : ${e.message}`); return 0;
|
||||
}) + await ingererNiveauSaisi(sql, st).catch((e) => {
|
||||
console.error(`niveau saisi en echec : ${e.message}`); return 0;
|
||||
}),
|
||||
pvDiagnostic: DRY ? 0 : await publierDiagnosticPv(st).catch((e) => {
|
||||
console.error(`diagnostic PV en echec : ${e.message}`); return 0;
|
||||
}),
|
||||
|
||||
247
tools/kilometrage.mjs
Normal file
247
tools/kilometrage.mjs
Normal file
@@ -0,0 +1,247 @@
|
||||
// Kilometrage et capacite des vehicules (04/10/2026, demande du proprietaire).
|
||||
//
|
||||
// Deux mesures distinctes, decidees avec lui :
|
||||
// 1. km par kWh : entre deux RELEVES DU COMPTEUR kilometrique d'un vehicule,
|
||||
// kWh consommes = kWh livres par la borne a ce vehicule entre les deux
|
||||
// relevés + (niveau au 1er releve - niveau au 2nd) x capacite.
|
||||
// Cela mesure surtout la conduite et la saison (chauffage, froid).
|
||||
// 2. capacite estimee : a chaque branchement ou le niveau a ete SAISI et la
|
||||
// charge menee jusqu'au plein, capacite = kWh livres depuis la saisie /
|
||||
// (part manquante). C'est elle qui montrera l'usure de la batterie.
|
||||
//
|
||||
// ⚠️ La JEEP et la VW sont des HYBRIDES : batterie vide, elles roulent a
|
||||
// l'essence et ces kilometres gonfleraient le rendement. Un intervalle n'est
|
||||
// donc retenu que si le niveau au retour est > 0. La ZERO est tout electrique.
|
||||
//
|
||||
// Contrat d'entree (meme modele que l'etiquette du concierge) :
|
||||
// `input_text.evcs_releve_km` = tableau JSON des derniers releves, chacun
|
||||
// [vehicule, km, niveau_pct|null, epoch_s, source]
|
||||
// ecrit par le concierge WhatsApp ou par le script HA du tableau EVCS Master.
|
||||
// Le service les ingere chaque cycle, sans doublon (vehicule, horodatage).
|
||||
|
||||
export const VEHICULES_TOUT_ELECTRIQUES = ['ZERO'];
|
||||
export const RELEVE_HELPER = 'input_text.evcs_releve_km';
|
||||
export const NIVEAU_ENTITY = 'input_number.victron_evcs_vehicle_level_pct';
|
||||
export const NIVEAU_AT_ENTITY = 'input_datetime.victron_evcs_vehicle_level_at';
|
||||
export const NIVEAU_REF_ENTITY = 'input_number.victron_evcs_vehicle_level_ref_kwh';
|
||||
// Etats du controleur qui disent « le vehicule n'accepte plus rien ».
|
||||
export const ETATS_PLEIN = ['day_vehicle_full_idle', 'night_recovery_done_idle',
|
||||
'night_session_done_idle', 'departure_done_idle'];
|
||||
|
||||
// Lit le helper. Renvoie { releves: [...], rejets: [motif...] }. Pure.
|
||||
export function lireReleves(brut) {
|
||||
const s = (brut ?? '').toString().trim();
|
||||
if (!s || s === 'unknown' || s === 'unavailable') return { releves: [], rejets: [] };
|
||||
let tab;
|
||||
try { tab = JSON.parse(s); } catch { return { releves: [], rejets: ['JSON illisible'] }; }
|
||||
if (!Array.isArray(tab)) return { releves: [], rejets: ['pas un tableau'] };
|
||||
const releves = [], rejets = [];
|
||||
for (const e of tab) {
|
||||
if (!Array.isArray(e) || e.length < 4) { rejets.push('entree mal formee'); continue; }
|
||||
const [v, km, niveau, t, source] = e;
|
||||
const vehicule = (v ?? '').toString().trim().toUpperCase();
|
||||
const kmN = Number(km), tN = Number(t);
|
||||
const nivN = niveau === null || niveau === undefined || niveau === '' ? null : Number(niveau);
|
||||
if (!vehicule) { rejets.push('vehicule absent'); continue; }
|
||||
if (!Number.isInteger(kmN) || kmN <= 0 || kmN > 2000000) { rejets.push(`${vehicule} : km invalide (${km})`); continue; }
|
||||
if (nivN !== null && !(Number.isInteger(nivN) && nivN >= 0 && nivN <= 100)) {
|
||||
rejets.push(`${vehicule} : niveau invalide (${niveau})`); continue;
|
||||
}
|
||||
if (!Number.isFinite(tN) || tN < 1.7e9) { rejets.push(`${vehicule} : horodatage invalide`); continue; }
|
||||
releves.push({ vehicule, km: kmN, niveau: nivN, ts: new Date(tN * 1000),
|
||||
source: (source ?? '').toString() || 'inconnue' });
|
||||
}
|
||||
return { releves, rejets };
|
||||
}
|
||||
|
||||
// Ajoute un releve au tableau existant en gardant les 6 derniers (le helper est
|
||||
// plafonne a 255 caracteres par HA). Pure — utilisee par le concierge.
|
||||
export function ajouterReleve(brut, releve) {
|
||||
let tab = [];
|
||||
try { const t = JSON.parse(brut || '[]'); if (Array.isArray(t)) tab = t; } catch { /* repart a vide */ }
|
||||
tab.push([releve.vehicule, releve.km, releve.niveau ?? null, Math.round(releve.ts.getTime() / 1000), releve.source]);
|
||||
let out = tab.slice(-6);
|
||||
while (JSON.stringify(out).length > 255 && out.length > 1) out = out.slice(1);
|
||||
return JSON.stringify(out);
|
||||
}
|
||||
|
||||
export async function creerSchemaKm(client) {
|
||||
await client.query(`
|
||||
CREATE TABLE IF NOT EXISTS releve_km (
|
||||
vehicule text NOT NULL,
|
||||
ts timestamptz NOT NULL,
|
||||
km integer NOT NULL,
|
||||
niveau_pct integer,
|
||||
source text,
|
||||
capacite_kwh double precision,
|
||||
autonomie_ref_km double precision,
|
||||
tout_electrique boolean NOT NULL DEFAULT false,
|
||||
pose_a timestamptz NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (vehicule, ts)
|
||||
)`);
|
||||
// Chaque saisie du niveau au branchement (concierge ou tableau de bord),
|
||||
// avec le compteur de la borne a cet instant. Le vehicule se deduit de
|
||||
// l'etiquette du branchement, jamais du selecteur.
|
||||
await client.query(`
|
||||
CREATE TABLE IF NOT EXISTS niveau_saisi (
|
||||
saisi_a timestamptz PRIMARY KEY,
|
||||
niveau_pct integer NOT NULL,
|
||||
ref_kwh double precision NOT NULL,
|
||||
pose_a timestamptz NOT NULL DEFAULT now()
|
||||
)`);
|
||||
await client.query(SQL_VUE_INTERVALLES);
|
||||
await client.query(SQL_VUE_CAPACITE);
|
||||
}
|
||||
|
||||
// Un intervalle = deux releves consecutifs du meme vehicule.
|
||||
export const SQL_VUE_INTERVALLES = `
|
||||
DROP VIEW IF EXISTS km_intervalle;
|
||||
CREATE VIEW km_intervalle AS
|
||||
WITH r AS (
|
||||
SELECT vehicule, ts, km, niveau_pct, capacite_kwh, autonomie_ref_km, tout_electrique,
|
||||
lag(ts) OVER w AS ts0,
|
||||
lag(km) OVER w AS km0,
|
||||
lag(niveau_pct) OVER w AS n0
|
||||
FROM releve_km WINDOW w AS (PARTITION BY vehicule ORDER BY ts)
|
||||
), e AS (
|
||||
SELECT r.*, km - km0 AS km_parcourus,
|
||||
(SELECT coalesce(sum(coalesce(s.energie_station_kwh, s.energie_kwh)), 0)
|
||||
FROM session_charge s
|
||||
WHERE s.vehicule = r.vehicule AND s.debut >= r.ts0 AND s.debut < r.ts) AS kwh_charges
|
||||
FROM r WHERE ts0 IS NOT NULL
|
||||
), c AS (
|
||||
SELECT e.*,
|
||||
CASE WHEN n0 IS NOT NULL AND niveau_pct IS NOT NULL AND capacite_kwh > 0
|
||||
THEN kwh_charges + (n0 - niveau_pct) / 100.0 * capacite_kwh END AS kwh_consommes
|
||||
FROM e
|
||||
)
|
||||
SELECT vehicule, ts0 AS debut, ts AS fin, km_parcourus, kwh_charges, n0 AS niveau_debut,
|
||||
niveau_pct AS niveau_fin, capacite_kwh, kwh_consommes,
|
||||
CASE WHEN kwh_consommes > 0 THEN km_parcourus / kwh_consommes END AS km_par_kwh,
|
||||
CASE WHEN capacite_kwh > 0 AND autonomie_ref_km > 0
|
||||
THEN autonomie_ref_km / capacite_kwh END AS km_par_kwh_ref,
|
||||
CASE
|
||||
WHEN km_parcourus < 0 THEN 'compteur en baisse'
|
||||
WHEN km_parcourus = 0 THEN 'aucun km'
|
||||
WHEN n0 IS NULL OR niveau_pct IS NULL THEN 'niveau manquant'
|
||||
WHEN NOT tout_electrique AND niveau_pct <= 0 THEN 'batterie vide au retour : km essence possibles'
|
||||
WHEN kwh_consommes IS NULL OR kwh_consommes <= 0 THEN 'energie nulle'
|
||||
ELSE 'valide' END AS statut
|
||||
FROM c`;
|
||||
|
||||
// Capacite estimee : derniere saisie de chaque branchement termine.
|
||||
// - Branchement = derniere transition 'on' au plus 1 h apres la saisie (la
|
||||
// saisie vaut si elle date de branchement - 1 h ou apres).
|
||||
// - Le niveau saisi est celui du BRANCHEMENT (le proprietaire le lit sur la
|
||||
// voiture avant de brancher, et le dit parfois une heure apres : « c'etait
|
||||
// 53 % a 13h10 ») : l'energie se compte donc du compteur de la borne au
|
||||
// branchement jusqu'au debranchement.
|
||||
// - Niveau de fin = 100 si le controleur a vu le vehicule plein, sinon le
|
||||
// niveau d'un releve km du meme vehicule dans l'heure qui suit le
|
||||
// debranchement (« debranche a 78 % »).
|
||||
// - Vehicule = etiquette CONFIRMEE des sessions du branchement (celle que le
|
||||
// proprietaire corrige), a defaut celle du concierge.
|
||||
export const SQL_VUE_CAPACITE = `
|
||||
DROP VIEW IF EXISTS capacite_estimee;
|
||||
CREATE VIEW capacite_estimee AS
|
||||
WITH tr AS (
|
||||
SELECT ts, detail->>'apres' AS apres FROM evenement
|
||||
WHERE genre = 'vehicule'
|
||||
AND detail->>'entite' = 'binary_sensor.victron_evcs_vehicle_connected'
|
||||
), s AS (
|
||||
SELECT n.*,
|
||||
(SELECT max(ts) FROM tr WHERE apres = 'on' AND tr.ts <= n.saisi_a + interval '1 hour') AS branche
|
||||
FROM niveau_saisi n
|
||||
), s1 AS (
|
||||
SELECT DISTINCT ON (branche) * FROM s WHERE branche IS NOT NULL ORDER BY branche, saisi_a DESC
|
||||
), b AS (
|
||||
SELECT s1.*,
|
||||
(SELECT min(ts) FROM tr WHERE apres = 'off' AND tr.ts > s1.branche) AS debranche
|
||||
FROM s1 WHERE saisi_a >= branche - interval '1 hour'
|
||||
), v AS (
|
||||
SELECT b.*,
|
||||
coalesce(
|
||||
(SELECT sc.vehicule FROM session_charge sc
|
||||
WHERE sc.debut >= b.branche AND sc.debut < b.debranche AND sc.vehicule_sur
|
||||
GROUP BY sc.vehicule ORDER BY sum(coalesce(sc.energie_station_kwh, sc.energie_kwh)) DESC LIMIT 1),
|
||||
(SELECT label FROM etiquette_branchement eb
|
||||
WHERE eb.branchement BETWEEN b.branche - interval '2 seconds' AND b.branche + interval '2 seconds'
|
||||
LIMIT 1)) AS vehicule
|
||||
FROM b WHERE debranche IS NOT NULL
|
||||
), k AS (
|
||||
SELECT v.*,
|
||||
(SELECT valeur FROM mesure m WHERE m.cle = 'sensor.evcs_hq2239dnt7p_total_energy'
|
||||
AND m.ts <= v.debranche ORDER BY m.ts DESC LIMIT 1)
|
||||
- coalesce((SELECT valeur FROM mesure m WHERE m.cle = 'sensor.evcs_hq2239dnt7p_total_energy'
|
||||
AND m.ts <= v.branche ORDER BY m.ts DESC LIMIT 1), ref_kwh) AS kwh_livres,
|
||||
EXISTS (SELECT 1 FROM decision d WHERE d.ts > v.branche AND d.ts <= v.debranche
|
||||
AND d.etat = ANY (ARRAY['${ETATS_PLEIN.join("','")}'])) AS plein,
|
||||
(SELECT r.niveau_pct FROM releve_km r
|
||||
WHERE r.vehicule = v.vehicule AND r.niveau_pct IS NOT NULL
|
||||
AND r.ts >= v.debranche AND r.ts <= v.debranche + interval '1 hour'
|
||||
ORDER BY r.ts LIMIT 1) AS niveau_releve_apres
|
||||
FROM v
|
||||
), f AS (
|
||||
SELECT k.*, CASE WHEN plein THEN 100 ELSE niveau_releve_apres END AS niveau_fin FROM k
|
||||
)
|
||||
SELECT branche, debranche, coalesce(vehicule, '?') AS vehicule, niveau_pct, niveau_fin,
|
||||
kwh_livres, plein,
|
||||
CASE WHEN vehicule IS NOT NULL AND niveau_fin - niveau_pct >= 10 AND kwh_livres > 0
|
||||
THEN kwh_livres / ((niveau_fin - niveau_pct) / 100.0) END AS capacite_kwh
|
||||
FROM f`;
|
||||
|
||||
// Ingestion des releves du helper. Refuse un compteur qui baisse.
|
||||
export async function ingererReleves(sql, lire, st, journaliser) {
|
||||
const { releves, rejets } = lireReleves(st.get(RELEVE_HELPER)?.state);
|
||||
let n = 0;
|
||||
for (const r of releves) {
|
||||
const v = r.vehicule.toLowerCase();
|
||||
const cap = Number(st.get(`input_number.victron_evcs_capacity_${v}_kwh`)?.state);
|
||||
const auto = Number(st.get(`input_number.victron_evcs_autonomie_${v}_km`)?.state);
|
||||
const { rows: prec } = await lire(
|
||||
'SELECT km FROM releve_km WHERE vehicule = $1 AND ts < $2 ORDER BY ts DESC LIMIT 1',
|
||||
[r.vehicule, r.ts]);
|
||||
const { rows: deja } = await lire(
|
||||
'SELECT 1 FROM releve_km WHERE vehicule = $1 AND ts = $2', [r.vehicule, r.ts]);
|
||||
if (deja.length) continue;
|
||||
if (prec.length && r.km < Number(prec[0].km)) {
|
||||
const cle = `${r.vehicule}|${r.ts.toISOString()}`;
|
||||
if (!rejetsJournalises.has(cle)) {
|
||||
rejetsJournalises.add(cle);
|
||||
await journaliser(sql, 'vehicule', `Releve km ${r.vehicule} refuse : ${r.km} km < ${prec[0].km} km du releve precedent`,
|
||||
{ vehicule: r.vehicule, km: r.km, precedent: Number(prec[0].km), source: r.source });
|
||||
}
|
||||
continue;
|
||||
}
|
||||
await sql(
|
||||
`INSERT INTO releve_km (vehicule, ts, km, niveau_pct, source, capacite_kwh, autonomie_ref_km, tout_electrique)
|
||||
VALUES ($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT DO NOTHING`,
|
||||
[r.vehicule, r.ts, r.km, r.niveau, r.source, cap > 0 ? cap : null, auto > 0 ? auto : null,
|
||||
VEHICULES_TOUT_ELECTRIQUES.includes(r.vehicule)]);
|
||||
await journaliser(sql, 'vehicule',
|
||||
`Releve km ${r.vehicule} : ${r.km} km` + (r.niveau === null ? ', niveau non donne' : `, niveau ${r.niveau} %`) + ` (${r.source})`,
|
||||
{ vehicule: r.vehicule, km: r.km, niveau: r.niveau, ts: r.ts.toISOString(), source: r.source });
|
||||
n++;
|
||||
}
|
||||
for (const m of rejets) {
|
||||
if (rejetsJournalises.has(m)) continue;
|
||||
rejetsJournalises.add(m);
|
||||
await journaliser(sql, 'vehicule', `Releve km illisible : ${m}`, { brut: (st.get(RELEVE_HELPER)?.state || '').slice(0, 255) });
|
||||
}
|
||||
return n;
|
||||
}
|
||||
const rejetsJournalises = new Set();
|
||||
|
||||
// Saisie du niveau : une ligne par horodatage de saisie.
|
||||
export async function ingererNiveauSaisi(sql, st) {
|
||||
// L'attribut `timestamp` d'un input_datetime est en secondes epoch : pas de
|
||||
// fuseau a deviner (l'etat, lui, est une heure locale sans decalage).
|
||||
const at = Number(st.get(NIVEAU_AT_ENTITY)?.attributes?.timestamp) * 1000;
|
||||
const niveau = Number(st.get(NIVEAU_ENTITY)?.state);
|
||||
const ref = Number(st.get(NIVEAU_REF_ENTITY)?.state);
|
||||
if (!Number.isFinite(at) || !Number.isInteger(niveau) || !Number.isFinite(ref) || ref <= 0) return 0;
|
||||
const r = await sql(
|
||||
'INSERT INTO niveau_saisi (saisi_a, niveau_pct, ref_kwh) VALUES ($1,$2,$3) ON CONFLICT DO NOTHING',
|
||||
[new Date(at), niveau, ref]);
|
||||
return r?.rowCount || 0;
|
||||
}
|
||||
Reference in New Issue
Block a user