b274989166
Le surplus dit ce qu'on peut dépenser sans acheter ; l'autorisation de soutirage dit ce que le branchement supporte. Une charge doit tenir dans les deux. Jusqu'ici seules les bornes VE étaient bornées par la seconde — une charge de waterfall pouvait donc créer un dépassement que seule la protection L4 rattrapait, après coup. C'est ce qui change. `SurplusContext::drawMargin` est une valeur de CYCLE, résolue une fois par `houseDrawMargin()` et jamais relue : deux lectures à deux instants feraient décider sur deux mondes. Chaque charge servie l'entame. Le motif porte les quatre grandeurs gravées au §6.3 : la marge (SIGNÉE), l'ampleur du dépassement, la source, et la phase qui borne. La phase n'est publiée que s'il y en a une — un plafond total n'en a pas, et en annoncer une enverrait mesurer au hasard. Précédence LM-1011 appliquée telle quelle : DRAW_CAP seulement à autorisation NULLE, sinon BELOW_MIN_POWER. Les bornes VE ne sont pas écrêtées par la marge de la maison, et ce n'est pas un oubli : `evPhaseAllowanceW()` connaît LES PHASES QU'ELLES OCCUPENT. Leur appliquer en plus la pire phase les priverait d'une phase saine parce qu'une autre sature. Entre deux bornes justes on garde la mieux informée, pas la plus sévère. Elles décrémentent la marge comme les autres. LIMITE DE MODÈLE assumée (LM-1210-a) : `LoadDeclared::phases` est un nombre, pas un masque — le moteur ignore sur quelle phase une charge est câblée. La pire phase est donc retenue. Deviner, dans une couche de sécurité, se paie au disjoncteur. Le pessimisme est borné en pratique et coûte du rendement, jamais de la sécurité ; le lever demande un masque déclaré, donc config, interface et migration. Documenté dans la spec et le design, à trancher. Suite complète : simulation 52/52, charging 48/48 identique à la référence ligne à ligne — les bornes ne bougent pas, c'est l'invariant du lot — loadmodel 21/21, spotmarket 32/32, doxygen 0 avertissement. Contre-épreuve : bornage débranché, la charge est servie 1000 W alors que l'autorisation est déjà dépassée de 460 W. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015F7G5VeaPVSMeVNjiGj36p
685 lines
39 KiB
C++
685 lines
39 KiB
C++
// SPDX-License-Identifier: GPL-3.0-or-later
|
||
// Copyright (C) 2025 - 2026, Patrick Schurig / ETM PowerSync
|
||
|
||
#include <QSet>
|
||
#include "rulebasedscheduler.h"
|
||
#include "../energyarbitrator.h"
|
||
#include "../../evcharger.h"
|
||
#include "../../types/chargingaction.h"
|
||
#include "../../types/charginginfo.h"
|
||
|
||
#include "plugininfo.h"
|
||
#include <QUuid>
|
||
#include <algorithm>
|
||
|
||
RuleBasedScheduler::RuleBasedScheduler(EnergyArbitrator *arbitrator, QObject *parent)
|
||
: QObject(parent)
|
||
, m_arbitrator(arbitrator)
|
||
{
|
||
}
|
||
|
||
Plan RuleBasedScheduler::getPlan(const SurplusContext &ctx)
|
||
{
|
||
// Planification (même logique que l'amont — écrit dans m_chargingActions)
|
||
m_arbitrator->runSpotMarketPlanning(ctx.timestamp);
|
||
m_arbitrator->runSurplusPlanning(ctx.timestamp);
|
||
|
||
Slot slot;
|
||
slot.from = ctx.timestamp;
|
||
slot.to = ctx.timestamp.addSecs(60);
|
||
|
||
const auto &cas = m_arbitrator->scheduledActions();
|
||
const auto &evs = m_arbitrator->registeredEvChargers();
|
||
|
||
// 3g-1 — bornes déjà servies par un financement RÉSEAU (échéance, spot market). Elles ne
|
||
// doivent pas recevoir en plus une allocation de surplus : la précédence du proxy est
|
||
// conservée, et c'est ce jeu qui la porte jusqu'au waterfall.
|
||
QSet<QString> gridFundedEvs;
|
||
|
||
// Même priorité que adjustEvChargers() — iso-fonctionnel 3b
|
||
for (auto it = evs.constBegin(); it != evs.constEnd(); ++it) {
|
||
EvCharger *ev = it.value();
|
||
if (!ev->available() || !ev->pluggedIn())
|
||
continue;
|
||
|
||
const ChargingActions &actions = cas.value(ev);
|
||
LoadAction la;
|
||
|
||
if (actions.value(ChargingAction::ChargingActionIssuerTimeRequirement).chargingEnabled()) {
|
||
la = buildTimeRequirementAction(
|
||
ev, actions.value(ChargingAction::ChargingActionIssuerTimeRequirement));
|
||
|
||
} else if (actions.value(ChargingAction::ChargingActionIssuerSpotMarketCharging).chargingEnabled()) {
|
||
const auto &ca = actions.value(ChargingAction::ChargingActionIssuerSpotMarketCharging);
|
||
la.loadId = ev->thing()->id().toString();
|
||
la.kind = LoadAction::Setpoint;
|
||
la.funding = LoadAction::Grid;
|
||
la.chargingEnabled = true;
|
||
la.currentA = ca.maxChargingCurrent();
|
||
la.phaseCount = ca.desiredPhaseCount();
|
||
la.reason = { DecisionCode::EvSpotMarket };
|
||
la.estimatedPowerW = la.currentA * 230.0 * la.phaseCount;
|
||
la.counts[CountKey::DrawCommitted] = la.estimatedPowerW; // R3 — acheté
|
||
|
||
} else {
|
||
// 3g-1 — LE SURPLUS N'EST PLUS DÉCIDÉ ICI. La borne descend dans le waterfall, où
|
||
// elle partage le budget avec l'ECS et la PAC, décrémente la cascade et porte un
|
||
// vrai rang. Les trois branches supprimées produisaient toutes des actions
|
||
// financées au surplus :
|
||
//
|
||
// EV_SURPLUS → remplacé par SURPLUS_SETPOINT du waterfall
|
||
// buildMinCurrent → remplacé par le PLANCHER (§12), qui est la même idée
|
||
// exprimée une seule fois pour tous les mécanismes
|
||
// buildIdle → remplacé par BELOW_MIN_POWER / SURPLUS_INSUFFICIENT, qui
|
||
// DISENT pourquoi la borne ne charge pas
|
||
//
|
||
// Rien n'est émis dans ce cas : l'absence d'action ici est ce qui laisse la place
|
||
// à celle du waterfall. En émettre une produirait deux actions pour la même borne.
|
||
continue;
|
||
}
|
||
|
||
// Seules les actions financées au RÉSEAU sortent encore d'ici — échéance et spot
|
||
// market, qui restent au proxy (DESIGN_3g §3.1).
|
||
gridFundedEvs.insert(la.loadId);
|
||
slot.actions.append(la);
|
||
}
|
||
|
||
// ---- Waterfall ECS (charges non-EV à paliers) ---------------------------------
|
||
// Correction A — déduction EV unique : ctx.meter.exportW est la mesure BRUTE
|
||
// (invariant 8). Les consignes EV de CE cycle ne sont pas encore visibles au
|
||
// compteur ; on réserve donc leur puissance commandée non encore mesurée.
|
||
double evReservedW = 0;
|
||
double drawCommittedW = 0; // R3 — watts ACHETÉS ce cycle
|
||
for (const LoadAction &la : slot.actions) {
|
||
if (la.kind != LoadAction::Setpoint || !la.chargingEnabled)
|
||
continue;
|
||
// 3g-1 — RESTREINT au financement réseau. Une borne servie par la cascade décrémente
|
||
// déjà le budget par son allocation ; la réserver EN PLUS la compterait deux fois.
|
||
// La correction A ne disparaît pas, elle se limite à ce qui reste décidé en amont.
|
||
if (la.funding != LoadAction::Grid)
|
||
continue;
|
||
EvCharger *ev = evs.value(ThingId(la.loadId));
|
||
const double measuredW = ev ? ev->currentPower() : 0.0;
|
||
evReservedW += qMax(0.0, la.estimatedPowerW - measuredW);
|
||
// R3 — LE REGISTRE DES WATTS ACHETÉS. Distinct de la correction ci-dessus, et la
|
||
// distinction est la découverte du lot : evReservedW décroît à mesure que la mesure
|
||
// rattrape la commande, alors que ce qui a été ACHETÉ ne bouge pas. Confondre les deux
|
||
// donnerait une identité vraie au premier cycle et fausse après convergence — qui
|
||
// passerait tous les tests, puisqu'ils portent sur des cycles isolés.
|
||
//
|
||
// Toute l'allocation du proxy y entre : l'échéance décide de charger qu'il y ait du
|
||
// soleil ou non, et le moteur ne calcule aucun partage pour elle. Là où il SAIT
|
||
// partager, il partage — voir EV_GRID_START.
|
||
drawCommittedW += la.estimatedPowerW;
|
||
}
|
||
// Surplus net SIGNÉ : exportW − importW = −puissance compteur. Négatif en import →
|
||
// l'ECS déleste (budget < palier) au lieu de rester allumé sur le réseau. (Le maintien
|
||
// transitoire sous minOn est géré par le verrou de l'adaptateur, pas par le budget.)
|
||
double remainingSurplusW = (ctx.meter.exportW - ctx.meter.importW) - evReservedW;
|
||
|
||
// ---- Prise en compte du stockage (3g-1) ---------------------------------------
|
||
// Remontée du chemin VE, où elle vivait par accident d'histoire. Ce n'a jamais été une
|
||
// règle « véhicule » : c'est une règle de BUDGET. Tant qu'elle restait dans
|
||
// planSurplusCharging(), une batterie sous sa réserve empêchait de charger la voiture mais
|
||
// laissait le chauffe-eau se servir — deux poids, deux mesures pour la même énergie.
|
||
//
|
||
// ⚠️ CHANGEMENT DE COMPORTEMENT pour l'ECS et la PAC, qui n'ont jamais connu cette règle.
|
||
// Une installation qui servait ses charges sous le seuil de réserve ne le fera plus.
|
||
// Retenu pour le MOTIF : sans lui, une installation qui exporte en plein soleil
|
||
// n'enclencherait rien en publiant « surplus insuffisant », et l'installateur chercherait
|
||
// une panne qui n'existe pas.
|
||
m_reserveActive = false;
|
||
m_reserveSocPct = 0;
|
||
m_reserveSeuilPct = 0;
|
||
m_reserveWithheldW = 0;
|
||
|
||
if (ctx.battery.present) {
|
||
const double seuil = m_arbitrator->batteryLevelConsideration() * 100.0;
|
||
|
||
if (ctx.battery.socPercent < seuil) {
|
||
m_reserveActive = true;
|
||
m_reserveSocPct = ctx.battery.socPercent;
|
||
m_reserveSeuilPct = seuil;
|
||
m_reserveWithheldW = qMax(0.0, remainingSurplusW);
|
||
// Sous la réserve : le stockage passe AVANT toute charge pilotée. On ne réduit pas
|
||
// le budget, on l'annule — servir « un peu » reviendrait à retarder la recharge de
|
||
// la batterie tout en ne démarrant probablement personne (planchers du §12).
|
||
if (remainingSurplusW > 0)
|
||
qCDebug(dcNymeaEnergy()).nospace()
|
||
<< "[Waterfall] Stockage à " << ctx.battery.socPercent << "% sous la réserve de "
|
||
<< seuil << "% : budget de surplus annulé (" << remainingSurplusW << " W).";
|
||
remainingSurplusW = qMin(remainingSurplusW, 0.0);
|
||
|
||
// La batterie charge sous son seuil : lui laisser de quoi le faire. Le tampon est
|
||
// repris tel quel de l'amont — il évite que le waterfall ne mange exactement ce
|
||
// que la batterie s'apprêtait à prendre.
|
||
if (ctx.battery.powerW > 0)
|
||
remainingSurplusW -= 500;
|
||
} else if (ctx.battery.powerW > 0) {
|
||
// Au-dessus de la réserve et en charge : cette puissance est disponible pour les
|
||
// charges pilotées — les servir vaut mieux que de remplir une batterie déjà sûre.
|
||
remainingSurplusW += ctx.battery.powerW;
|
||
}
|
||
|
||
if (ctx.battery.powerW < 0) {
|
||
// Décharge : ne pas vider la batterie pour alimenter une charge pilotée, quel que
|
||
// soit le niveau. Ce qu'elle fournit n'est pas du surplus.
|
||
remainingSurplusW += ctx.battery.powerW; // powerW < 0 → retranche
|
||
}
|
||
}
|
||
|
||
// Comptabilité PUBLIÉE du budget (télémétrie RPC). Elle s'alimente DANS la cascade,
|
||
// pendant que celle-ci se déroule : c'est le seul endroit qui sache ce qui a réellement
|
||
// été alloué et ce qui a été recrédité. La recalculer ailleurs donnerait deux comptes à
|
||
// tenir d'accord, et le chiffre publié serait le premier à mentir.
|
||
PlanBudget compta;
|
||
PlanDraw draw; // registre des watts achetés — R3
|
||
draw.committedW = drawCommittedW; // ce que le proxy a déjà engagé au réseau
|
||
compta.surplusW = remainingSurplusW;
|
||
compta.evReservedW = evReservedW;
|
||
|
||
// Charges pilotables non-EV triées par priorité ASCENDANTE : rang 1 = premier servi
|
||
// (OPTIMIZER_PROTOCOL §5 + annexe C — la priorité est un rang). Le budget de surplus est
|
||
// UNIQUE et cascade à travers TOUTES ces charges par priorité :
|
||
// - etmvariableload (ECS/routeur, kind Setpoint W → buildSetpointAction, règle d'arrondi §5) ;
|
||
// - sg-ready (PAC, kind State → buildSgReadyStateAction, mapping sémantique).
|
||
// Charges en WATTS (Setpoint) : etmvariableload (continu) ET relay-router (rév. 3, combinaison
|
||
// de relais dérivée côté routeur). Charge à ÉTATS : sg-ready (PAC). Le scheduler distingue
|
||
// Setpoint vs State (nature de l'action), PAS la classe concrète d'adaptateur (frontière rév. 3).
|
||
// 3g-1 — le waterfall n'est plus « non-EV » : les bornes y sont, et c'est toute la
|
||
// transplantation. Elles partagent le budget, décrémentent la cascade et portent un rang
|
||
// qui a enfin un sens. Le nom de la variable est conservé pour limiter le diff ; sa
|
||
// sémantique est désormais « charges arbitrées par le waterfall ».
|
||
QList<LoadContext> nonEvLoads;
|
||
for (const LoadContext &lc : ctx.loads) {
|
||
const bool arbitree = lc.adapter == QStringLiteral("etmvariableload")
|
||
|| lc.adapter == QStringLiteral("relay-router")
|
||
|| lc.adapter == QStringLiteral("sg-ready")
|
||
|| lc.adapter == QStringLiteral("evcharger");
|
||
if (!arbitree)
|
||
continue;
|
||
// Déjà servie au réseau ce cycle : lui allouer du surplus en plus reviendrait à la
|
||
// commander deux fois, avec deux consignes différentes.
|
||
if (gridFundedEvs.contains(lc.id))
|
||
continue;
|
||
nonEvLoads.append(lc);
|
||
}
|
||
// 3g-2 — tri TOTAL et STABLE. Le rang seul ne suffit pas : deux charges de même rang
|
||
// laissaient l'ordre à std::sort, qui n'est pas stable, sur une liste dont l'origine est
|
||
// un QHash — donc sans ordre garanti d'un cycle à l'autre. Au banc, deux bornes à
|
||
// priority = 100 : la cascade était correcte, mais LAQUELLE démarrait n'était ni réglable
|
||
// ni reproductible (relevé du 2026-08-26, §3.2). L'identifiant départage : il est stable
|
||
// par construction, et l'égalité parfaite de deux charges n'existe pas.
|
||
std::sort(nonEvLoads.begin(), nonEvLoads.end(),
|
||
[](const LoadContext &a, const LoadContext &b) {
|
||
if (a.priority != b.priority)
|
||
return a.priority < b.priority;
|
||
return a.id < b.id;
|
||
});
|
||
|
||
QSet<QString> waterfallEvIds;
|
||
// Étape 3 — l'autorisation de SOUTIRAGE, consommée le long de la cascade au même titre que
|
||
// le surplus. C'est une marge de CYCLE : elle est prise une fois dans le contexte, jamais
|
||
// relue, et chaque charge servie l'entame de ce qu'elle a été autorisée à prendre.
|
||
DrawMargin margeRestante = ctx.drawMargin;
|
||
for (const LoadContext &lc : nonEvLoads) {
|
||
if (lc.adapter == QStringLiteral("sg-ready"))
|
||
slot.actions.append(buildSgReadyStateAction(lc, remainingSurplusW, compta));
|
||
else
|
||
slot.actions.append(buildSetpointAction(lc, remainingSurplusW, margeRestante, compta, draw)); // etmvariableload + relay-router + evcharger
|
||
|
||
// Le décrément vaut pour TOUTES les charges servies, bornes et PAC comprises : elles
|
||
// consomment la même autorisation, qu'elles aient été bornées par elle ou non. Ne
|
||
// décompter que les charges qu'on borne offrirait aux suivantes une marge déjà dépensée.
|
||
if (margeRestante.borne && !slot.actions.isEmpty())
|
||
margeRestante.watts -= slot.actions.last().estimatedPowerW;
|
||
// 3g-2 — c'est ICI que le jeu se constitue, au moment où la décision est prise. Le
|
||
// redéduire plus tard depuis les motifs ou le financement dériverait du vrai au
|
||
// premier motif ajouté (EV_GRID_START porte funding=Grid tout en venant du waterfall).
|
||
if (lc.adapter == QStringLiteral("evcharger"))
|
||
waterfallEvIds.insert(lc.id);
|
||
}
|
||
|
||
// Grid funding (ECS/PAC) : dormant jusqu'à 3f (waterfall réseau) — non implémenté ici.
|
||
|
||
Plan plan;
|
||
plan.planId = QUuid::createUuid().toString(QUuid::WithoutBraces);
|
||
plan.strategy = QStringLiteral("rule-based");
|
||
plan.timeSlots.append(slot);
|
||
|
||
compta.remainingW = remainingSurplusW;
|
||
plan.budget = compta;
|
||
// R3 — le soutirage est publié DANS LA MÊME TRAME que le budget : les deux décrivent le
|
||
// même cycle, et les lire à deux instants ferait comparer deux mondes.
|
||
plan.draw = draw;
|
||
plan.waterfallEvIds = waterfallEvIds;
|
||
return plan;
|
||
}
|
||
|
||
LoadAction RuleBasedScheduler::buildTimeRequirementAction(EvCharger *ev,
|
||
const ChargingAction &ca) const
|
||
{
|
||
// Le courant final est affiné par adjustEvChargers() (allowance root-meter).
|
||
// En 3b on log la valeur brute de la planification — iso-fonctionnel.
|
||
LoadAction la;
|
||
la.loadId = ev->thing()->id().toString();
|
||
la.kind = LoadAction::Setpoint;
|
||
la.funding = LoadAction::Grid;
|
||
la.chargingEnabled = true;
|
||
la.currentA = ca.maxChargingCurrent();
|
||
la.phaseCount = ca.desiredPhaseCount();
|
||
la.reason = { DecisionCode::EvDeadline };
|
||
la.estimatedPowerW = la.currentA * 230.0 * la.phaseCount;
|
||
la.counts[CountKey::DrawCommitted] = la.estimatedPowerW; // R3 — acheté (échéance)
|
||
return la;
|
||
}
|
||
|
||
LoadAction RuleBasedScheduler::buildSetpointAction(const LoadContext &lc,
|
||
double &remainingSurplusW,
|
||
DrawMargin &margeRestante,
|
||
PlanBudget &budget, PlanDraw &draw) const
|
||
{
|
||
// Recrédit anti-clignotement (Correction B / contrat rév. 2 §5) : la conso de DÉBUT de cycle
|
||
// est déjà soustraite de l'export mesuré → on la rend au budget local avant d'arrondir.
|
||
// PAS de relecture post-setpoint (invariant 8 : aucune boucle de feedback).
|
||
//
|
||
// 3g-2 — SAUF sous la réserve de stockage, et c'est la seule exception. Le recrédit
|
||
// suppose que le budget est une MESURE dont la conso de la charge a déjà été retranchée ;
|
||
// sous la réserve, le budget n'est pas une mesure mais une DÉCISION de retenir
|
||
// (LM-1203-b : « le budget est annulé, pas réduit »). Recréditer dans un budget décidé nul
|
||
// rend exactement ce qu'on venait de confisquer : toute charge déjà en marche le restait,
|
||
// la réserve ne mordait que sur les augmentations, et le motif publié — « aucune charge
|
||
// n'est servie » — était faux. Attrapé par batteryLevelConsiderationStopCharging au moment
|
||
// où les bornes ont commencé à exécuter réellement les décisions du waterfall.
|
||
const double recreditW = m_reserveActive ? 0.0 : lc.telemetry.currentPowerW;
|
||
const double budgetW = remainingSurplusW + recreditW;
|
||
budget.recreditedW += recreditW;
|
||
|
||
const QList<int> &levels = lc.declared.powerLevels;
|
||
const bool dynamic = levels.isEmpty();
|
||
//! 3g-2 — une borne se distingue ici par une seule chose : elle peut DÉMARRER en soutirant
|
||
//! (acquisitionTolerance). Tout le reste du waterfall la traite comme n'importe quelle
|
||
//! charge continue, et c'est le sens de la transplantation.
|
||
const bool estUneBorne = lc.adapter == QStringLiteral("evcharger");
|
||
|
||
double setpointW;
|
||
bool sousPlancher = false; //!< Budget > 0 mais sous le premier palier atteignable.
|
||
double plancherW = 0; //!< Ce palier, précisément — le motif doit le NOMMER.
|
||
if (dynamic) {
|
||
// Dynamic (routeur PV / triac) : modulation continue bornée au plafond déclaré.
|
||
const double maxW = lc.declared.maxPowerW > 0 ? lc.declared.maxPowerW : budgetW;
|
||
|
||
// 3g-2 — le PLAFOND est passé SOUS le plancher. Pour une charge de configuration
|
||
// c'est impossible (isValid() le refuse) ; pour une borne, le plafond du cycle est
|
||
// écrêté par la protection de surcharge, et il peut donc descendre sous ce que la
|
||
// borne exige. Aucune allocation ne la démarrera, et le dire « budget sous le
|
||
// plancher » enverrait chercher du soleil là où il faut regarder l'abonnement
|
||
// (règle 7-b). Le budget n'est pas consommé : il passe entier à la suivante.
|
||
if (lc.declared.minPowerW > 0 && maxW < lc.declared.minPowerW) {
|
||
LoadAction la;
|
||
la.loadId = lc.id;
|
||
la.kind = LoadAction::Setpoint;
|
||
la.funding = LoadAction::Surplus;
|
||
la.chargingEnabled = false;
|
||
la.powerW = 0;
|
||
la.estimatedPowerW = 0;
|
||
// R3 — zéro AVEC sa destination : la grandeur existe et vaut 0. Un counts vide
|
||
// dirait qu'elle n'existe pas, ce qui est une autre affirmation.
|
||
la.counts[CountKey::BudgetAllocated] = 0.0;
|
||
la.reason = { DecisionCode::PhaseLimit,
|
||
{{"limitW", qRound(maxW)}, {"requiredW", qRound(lc.declared.minPowerW)}} };
|
||
remainingSurplusW = budgetW; // rien d'engagé : le recrédit repart intact
|
||
return la;
|
||
}
|
||
|
||
setpointW = qBound(0.0, budgetW, maxW);
|
||
|
||
// §12 / LM-1203 — le domaine n'est pas [0, max] mais {0} ∪ [min, max]. Sous le
|
||
// plancher, la charge ne prend RIEN, et le budget PASSE à la suivante.
|
||
//
|
||
// Ne rien transmettre serait le vrai défaut : une charge de rang 1 au plancher élevé
|
||
// retiendrait en otage un budget qu'elle ne peut pas utiliser, et tout le waterfall en
|
||
// aval resterait à sec pendant qu'elle-même ne démarre pas. C'est le cas des deux
|
||
// bornes — 2 kW chacune sous un plancher de 1,38 kW n'en fait démarrer aucune, quand
|
||
// servir la première à fond en fait charger une.
|
||
if (lc.declared.minPowerW > 0 && setpointW > 0 && setpointW < lc.declared.minPowerW) {
|
||
setpointW = 0;
|
||
plancherW = lc.declared.minPowerW;
|
||
sousPlancher = true;
|
||
|
||
// 3g-2 — DÉMARRAGE SOUS TOLÉRANCE, et c'est une décision d'ACHETER.
|
||
//
|
||
// `acquisitionTolerance` est la part du plancher qu'on accepte de ne pas couvrir
|
||
// par le surplus pour démarrer quand même : à 0,5, une borne qui exige 4 140 W
|
||
// démarre dès 2 070 W de surplus et SOUTIRE les 2 070 restants. Le comportement
|
||
// existait déjà chez le proxy amont — il y était invisible, confondu avec le
|
||
// plancher dans evFloorW(). On ne l'introduit pas, on le rend lisible et chiffré.
|
||
//
|
||
// Brèche assumée dans DESIGN_3g §3.1, qui défère le financement réseau à 3f :
|
||
// c'est un cas particulier BORNÉ, et il l'est par construction —
|
||
// · il exige du surplus réel (budgetW > 0), donc jamais un démarrage à sec ;
|
||
// · il consomme TOUT le budget restant, donc au plus UNE borne par cycle : la
|
||
// suivante trouve un budget nul et repart sur son motif ordinaire ;
|
||
// · il reste sous le plafond de la protection de surcharge, contrôlé plus haut.
|
||
const double tolerance = m_arbitrator->acquisitionTolerance();
|
||
if (estUneBorne && tolerance > 0 && budgetW > 0 && budgetW >= plancherW * tolerance) {
|
||
const double soutireW = plancherW - budgetW;
|
||
|
||
LoadAction la;
|
||
la.loadId = lc.id;
|
||
la.kind = LoadAction::Setpoint;
|
||
// Le financement dit la VÉRITÉ sur l'origine : une partie de cette puissance
|
||
// vient du réseau. La comptabilité qui suit la partage en conséquence.
|
||
la.funding = LoadAction::Grid;
|
||
la.chargingEnabled = true;
|
||
la.phaseCount = static_cast<uint>(qMax(1, lc.declared.phases));
|
||
la.powerW = plancherW;
|
||
la.estimatedPowerW = plancherW;
|
||
// R3 — LE PARTAGE, publié plutôt que déduit du motif : la part de surplus dans
|
||
// le registre d'allocation, la part achetée dans celui du soutirage.
|
||
la.counts[CountKey::BudgetAllocated] = budgetW;
|
||
la.counts[CountKey::DrawCommitted] = soutireW;
|
||
la.reason = { DecisionCode::EvGridStart,
|
||
{{"budgetW", qRound(budgetW)}, {"floorW", qRound(plancherW)},
|
||
{"gridW", qRound(soutireW)}} };
|
||
|
||
// Le surplus est ENTIÈREMENT dépensé — pas au-delà : le complément vient du
|
||
// réseau et se compte là où vivent déjà les puissances commandées non encore
|
||
// mesurées. Laisser le budget filer en négatif ferait porter le soutirage par
|
||
// la cascade, où il se lirait comme un manque de surplus chez les suivantes.
|
||
// R3 — le moteur SAIT partager ici, donc il partage : la part surplus entre
|
||
// dans le registre d'allocation, la part achetée dans le registre de soutirage.
|
||
// Elle allait dans evReservedW, qui est une CORRECTION : une tranche
|
||
// d'allocation y rendait toute définition du champ fausse pour l'un des deux
|
||
// termes, et interdisait de le nommer honnêtement à l'écran.
|
||
budget.allocatedW += budgetW;
|
||
draw.committedW += soutireW;
|
||
remainingSurplusW = 0;
|
||
return la;
|
||
}
|
||
}
|
||
} else {
|
||
// Fixed : plus haut palier déclaré ≤ budget (levels triés croissants, 0 inclus →
|
||
// garantit une consigne valide même budget ≤ 0). Granularité connue → zéro cycle de retard.
|
||
int chosen = 0;
|
||
for (int l : levels) {
|
||
if (l <= budgetW) chosen = l;
|
||
else break;
|
||
}
|
||
setpointW = chosen;
|
||
|
||
// §12 — même distinction qu'en dynamic, et le plancher y est DÉRIVÉ : levels[0] vaut
|
||
// toujours 0, donc le premier palier atteignable est levels[1].
|
||
//
|
||
// Ce qui se joue ici est la différence entre « il n'y a pas assez » et « il y en a,
|
||
// mais pas au bon format ». Un budget de 300 W devant un premier palier de 500 W
|
||
// n'est pas un manque de surplus : c'est une granularité. Les deux phrases envoient
|
||
// l'installateur vers des gestes opposés — attendre le soleil, ou relire son câblage.
|
||
const int premier = levels.size() > 1 ? levels.at(1) : 0;
|
||
if (premier > 0 && budgetW > 0 && chosen == 0) {
|
||
plancherW = premier;
|
||
sousPlancher = true;
|
||
}
|
||
}
|
||
|
||
// --- Étape 3 : la cascade ne CRÉE pas le dépassement ----------------------------------
|
||
//
|
||
// Le surplus dit ce qu'on peut dépenser sans acheter ; l'autorisation de soutirage dit ce
|
||
// que le branchement supporte. Ce sont DEUX ressources, et une charge doit tenir dans les
|
||
// deux. Jusqu'ici seules les bornes étaient bornées par la seconde — d'où des charges de
|
||
// waterfall qui pouvaient créer une surcharge que seule la protection L4 rattrapait, après
|
||
// coup.
|
||
//
|
||
// Les BORNES en sont exclues, et ce n'est pas un oubli : leur plafond de cycle est déjà
|
||
// écrêté par `evPhaseAllowanceW()`, qui connaît LES PHASES QU'ELLES OCCUPENT. Leur
|
||
// appliquer en plus la marge de la maison — la pire phase — les priverait d'une phase
|
||
// saine parce qu'une autre sature. Mieux vaut la borne mieux informée que la borne la
|
||
// plus sévère.
|
||
bool capEpuise = false;
|
||
if (!estUneBorne && margeRestante.borne && setpointW > 0) {
|
||
if (margeRestante.watts <= 0) {
|
||
// \rule{LM-1011} — autorisation résiduelle NULLE : c'est DRAW_CAP, et rien d'autre.
|
||
setpointW = 0;
|
||
capEpuise = true;
|
||
sousPlancher = false; // ce n'est pas une affaire de format, il ne reste RIEN
|
||
} else if (setpointW > margeRestante.watts) {
|
||
setpointW = margeRestante.watts;
|
||
|
||
// Fixed : retomber sur un palier ATTEIGNABLE. Écrêter à la marge donnerait une
|
||
// consigne que le mécanisme ne sait pas tenir, et il prendrait le palier au-dessus
|
||
// — c'est-à-dire exactement le dépassement qu'on vient de refuser.
|
||
if (!dynamic) {
|
||
int retenu = 0;
|
||
for (int l : levels) {
|
||
if (l <= setpointW) retenu = l;
|
||
else break;
|
||
}
|
||
setpointW = retenu;
|
||
} else if (lc.declared.minPowerW > 0 && setpointW < lc.declared.minPowerW) {
|
||
setpointW = 0;
|
||
}
|
||
|
||
// \rule{LM-1011} — il RESTE de l'autorisation, simplement pas au bon format. Le
|
||
// motif est donc BELOW_MIN_POWER, jamais DRAW_CAP : dire « épuisée » enverrait
|
||
// revoir l'abonnement là où il faut lire une fiche technique.
|
||
if (setpointW <= 0) {
|
||
sousPlancher = true;
|
||
plancherW = dynamic ? lc.declared.minPowerW
|
||
: (levels.size() > 1 ? levels.at(1) : 0);
|
||
}
|
||
}
|
||
}
|
||
|
||
// ECS-410 — charge INDISPONIBLE : elle sort de l'ARBITRAGE, pas de la COMPTABILITÉ.
|
||
// Aucune allocation neuve, mais sa consommation reste retranchée du budget : une
|
||
// puissance qu'on ne sait plus couper est de la conso fixe, au même titre que la base de
|
||
// la maison. La retirer du bilan offrirait aux charges suivantes un budget qui n'existe
|
||
// pas — c'est le trou d'ECS-306 rouvert par une autre porte.
|
||
//
|
||
// Le figeage est porté par l'adaptateur : lockMin == lockMax == puissance crue engagée.
|
||
// Le clamp ci-dessous suffit donc à produire la bonne comptabilité, sans branche spéciale.
|
||
if (!lc.telemetry.available) {
|
||
const double gele = lc.telemetry.lockMinPowerW;
|
||
LoadAction la;
|
||
la.loadId = lc.id;
|
||
la.kind = LoadAction::Setpoint;
|
||
la.funding = LoadAction::Surplus;
|
||
la.powerW = gele;
|
||
la.estimatedPowerW = gele;
|
||
la.counts[CountKey::BudgetAllocated] = gele; // R3 — gelée, mais toujours allouée
|
||
// Le LIBELLÉ n'entre pas dans les paramètres : c'est de la langue naturelle saisie
|
||
// par l'installateur, et la charge utile RPC doit en rester exempte. Il est substitué
|
||
// au rendu, par renderFr(reason, label).
|
||
la.reason = { DecisionCode::LoadUnavailable, {{"frozenW", qRound(gele)}} };
|
||
remainingSurplusW = budgetW - gele;
|
||
budget.allocatedW += gele; // une puissance qu'on ne sait plus couper reste allouée
|
||
return la;
|
||
}
|
||
|
||
// ECS-306 — clamp lock-aware AVANT de décrémenter le budget (AGENTS règle 4 : les
|
||
// bornes de l'adaptateur écrêtent TOUTE sortie de stratégie, et leur résultat doit
|
||
// revenir à l'arbitre). Sans ceci, l'adaptateur remonte le palier de son côté et le
|
||
// scheduler décrémente une valeur plus basse : pendant toute la fenêtre minOn, les
|
||
// charges suivantes reçoivent un résidu surestimé → soutirage réseau.
|
||
// ECS-309 — ce que la stratégie voulait, AVANT que les bornes de verrou n'écrêtent.
|
||
// Sans cette mémoire, le motif ne peut pas distinguer « le budget ne payait pas » de
|
||
// « le verrou a refusé » : les deux finissent à la même consigne.
|
||
const double vouluW = setpointW;
|
||
|
||
if (lc.telemetry.lockMaxPowerW >= 0)
|
||
setpointW = qMin(setpointW, lc.telemetry.lockMaxPowerW);
|
||
if (setpointW < lc.telemetry.lockMinPowerW)
|
||
setpointW = lc.telemetry.lockMinPowerW; // puissance engagée, non-coupable
|
||
|
||
LoadAction la;
|
||
la.loadId = lc.id;
|
||
la.kind = LoadAction::Setpoint;
|
||
la.funding = LoadAction::Surplus;
|
||
la.powerW = setpointW;
|
||
la.estimatedPowerW = setpointW;
|
||
la.counts[CountKey::BudgetAllocated] = setpointW; // R3
|
||
// 3g-2 — une borne lit `chargingEnabled` avant tout le reste (EvAdapter::applyAction) ;
|
||
// laissé à sa valeur par défaut, il faisait refuser TOUTE consigne issue du waterfall,
|
||
// consigne non nulle comprise. Sans objet pour les autres mécanismes, qui l'ignorent.
|
||
la.chargingEnabled = setpointW > 0;
|
||
la.phaseCount = static_cast<uint>(qMax(0, lc.declared.phases));
|
||
|
||
// ECS-309 — le motif nomme le MÉCANISME qui a produit l'issue, jamais un mécanisme
|
||
// plausible. La règle 7 d'AGENTS.md exige un motif non vide ; celle-ci exige qu'il soit
|
||
// vrai. Un motif faux envoie diagnostiquer le mauvais problème, avec l'autorité d'une
|
||
// explication — constaté au banc le 2026-08-09 : palier 0 avec 7706 W disponibles, et
|
||
// « Surplus insuffisant (7706 W) » publié.
|
||
// ECS-309-b — le critère est ce que le verrou a FAIT à la consigne voulue, pas une
|
||
// comparaison au budget. « setpointW > budgetW » nommait minOn dès que le budget était
|
||
// négatif à palier nul : 0 > −389 est vrai, et le motif annonçait « maintenue à 0 W
|
||
// (puissance engagée) » alors que rien n'était engagé et que le soutirage était la seule
|
||
// cause. Constaté au banc le 2026-08-13, sept fois en quatre heures, toujours au cycle
|
||
// suivant un palier 0. Les deux branches se lisent maintenant sur le même axe :
|
||
// le verrou a relevé la consigne (minOn), ou il l'a rabaissée (minOff).
|
||
if (setpointW > vouluW)
|
||
la.reason = { DecisionCode::LockMinOn,
|
||
{{"appliedW", qRound(setpointW)}, {"budgetW", qRound(budgetW)}} };
|
||
else if (setpointW < vouluW)
|
||
// Le budget payait vouluW ; c'est la fenêtre minOff qui interdit de monter. Le motif
|
||
// cite le budget DISPONIBLE, précisément pour couper court à l'explication budgétaire.
|
||
la.reason = setpointW <= 0
|
||
? DecisionReason(DecisionCode::LockMinOff,
|
||
{{"budgetW", qRound(budgetW)}, {"requestedW", qRound(vouluW)}})
|
||
: DecisionReason(DecisionCode::LockMinOffCapped,
|
||
{{"appliedW", qRound(setpointW)}, {"budgetW", qRound(budgetW)},
|
||
{"requestedW", qRound(vouluW)}});
|
||
else if (setpointW > 0)
|
||
// « stepped » remplace le suffixe « (palier) » composé en dur : le client décide
|
||
// comment il le dit, la box dit seulement que la consigne est arrondie sur un palier.
|
||
la.reason = { DecisionCode::SurplusSetpoint,
|
||
{{"budgetW", qRound(budgetW)}, {"setpointW", qRound(setpointW)},
|
||
{"stepped", !dynamic}} };
|
||
else if (m_reserveActive && (m_reserveWithheldW + lc.telemetry.currentPowerW) > 0)
|
||
// 3g-1 — il Y A du surplus, et une règle l'interdit. À ne pas confondre avec
|
||
// « il n'y en a pas » : le geste attendu n'est pas le même, et le second envoie
|
||
// chercher une panne inexistante.
|
||
//
|
||
// 3g-2 — ce que la réserve retient à CETTE charge a deux termes, et il faut les deux :
|
||
// le surplus annulé (le même pour toutes), ET sa propre consommation, que le recrédit
|
||
// lui aurait rendue. Sans le second, une charge en marche coupée par la réserve sur un
|
||
// surplus nul publiait « surplus insuffisant » — vrai sur le surplus, faux sur la
|
||
// cause : sans la réserve, elle aurait continué de tourner.
|
||
la.reason = { DecisionCode::BatteryReserve,
|
||
{{"socPercent", qRound(m_reserveSocPct)},
|
||
{"reservePercent", qRound(m_reserveSeuilPct)},
|
||
{"withheldW", qRound(m_reserveWithheldW + lc.telemetry.currentPowerW)}} };
|
||
else if (capEpuise) {
|
||
// L'autorisation de soutirage est épuisée. Le motif porte la marge, la source,
|
||
// l'ampleur du dépassement et la phase qui borne — chacune commande un geste
|
||
// différent, et aucune ne se déduit des autres.
|
||
QVariantMap params{{"marginW", qRound(margeRestante.watts)},
|
||
{"overshootW", qRound(qMax(0.0, -margeRestante.watts))},
|
||
{"source", drawCapSourceCode(margeRestante.source)}};
|
||
// La phase n'est publiée QUE lorsqu'il y en a une. Un plafond total n'en a pas, et en
|
||
// annoncer une enverrait mesurer au hasard — l'absence dit « il n'y a pas de phase
|
||
// coupable », ce qu'un « A » par défaut aurait rendu indiscernable d'une vraie phase A.
|
||
if (margeRestante.phase >= 0 && margeRestante.phase <= 2)
|
||
params.insert(QStringLiteral("phase"),
|
||
QString(QChar('A' + margeRestante.phase)));
|
||
la.reason = { DecisionCode::DrawCap, params };
|
||
}
|
||
else if (sousPlancher)
|
||
// §12 — dire QUE le budget est sous le plancher, pas qu'il est insuffisant : la
|
||
// seconde phrase enverrait chercher du soleil là où il faut lire une fiche technique.
|
||
la.reason = { DecisionCode::BelowMinPower,
|
||
{{"budgetW", qRound(budgetW)}, {"minPowerW", qRound(plancherW)}} };
|
||
else
|
||
la.reason = { DecisionCode::SurplusInsufficient, {{"budgetW", qRound(budgetW)}} };
|
||
|
||
// Résidu : budget − consigne engagée → charge suivante de la priorité (même cycle).
|
||
remainingSurplusW = budgetW - setpointW;
|
||
budget.allocatedW += setpointW;
|
||
return la;
|
||
}
|
||
|
||
LoadAction RuleBasedScheduler::buildSgReadyStateAction(const LoadContext &lc,
|
||
double &remainingSurplusW,
|
||
PlanBudget &budget) const
|
||
{
|
||
const int currentState = lc.telemetry.state;
|
||
const double p3 = lc.declared.estimatedPowerW.value(3, 0.0);
|
||
const double p4 = lc.declared.estimatedPowerW.value(4, 0.0);
|
||
|
||
// Recrédit (correction B) : la puissance ALLOUÉE de l'état courant (déclaré, 0 pour 1/2)
|
||
// revient au budget — comme l'ECS. Base : "quel surplus si la PAC n'était pas pilotée ?"
|
||
// 3g-2 — même exception que pour les charges en watts : sous la réserve, pas de recrédit.
|
||
// Une PAC en état 3 ou 4 y resterait sinon indéfiniment, la réserve n'agissant que sur les
|
||
// montées d'état. Voir la note détaillée dans buildSetpointAction().
|
||
const double allocatedNowW = m_reserveActive
|
||
? 0.0
|
||
: lc.declared.estimatedPowerW.value(currentState, 0.0);
|
||
const double budgetW = remainingSurplusW + allocatedNowW;
|
||
budget.recreditedW += allocatedNowW;
|
||
|
||
// Mapping SÉMANTIQUE (pas "le plus haut qui rentre") avec hystérésis d'état anti-oscillation :
|
||
// monter en 4 si budget ≥ P4×1,2 ; rester en 4 tant que budget ≥ P4×1,0 (zone morte) ;
|
||
// sinon recommandation (≥ P3) ; sinon normal (état 2, mains off).
|
||
// État 1 (effacement) jamais déclenché par le surplus seul — déféré (signal tarif/réseau).
|
||
constexpr double kForceMargin = 1.2; // hystérésis d'entrée en état 4
|
||
int targetState;
|
||
if (p4 > 0.0 && budgetW >= p4 * kForceMargin)
|
||
targetState = 4;
|
||
else if (currentState == 4 && p4 > 0.0 && budgetW >= p4) // zone morte : reste forcé
|
||
targetState = 4;
|
||
else if (p3 > 0.0 && budgetW >= p3)
|
||
targetState = 3;
|
||
else
|
||
targetState = 2;
|
||
|
||
// Clamp lock-aware (fenêtre minStateHold, calculée au MÊME ctx.timestamp).
|
||
const int loW = lc.telemetry.minState > 0 ? lc.telemetry.minState : 2;
|
||
const int hiW = lc.telemetry.maxState > 0 ? lc.telemetry.maxState : 2;
|
||
int bestState = qBound(qMin(loW, hiW), targetState, qMax(loW, hiW));
|
||
// Sécurité : ne jamais commander un état non déclaré (snap au plus haut déclaré ≤ cible).
|
||
if (!lc.declared.states.contains(bestState)) {
|
||
int snapped = lc.declared.states.isEmpty() ? 2 : lc.declared.states.first();
|
||
for (int s : lc.declared.states)
|
||
if (s <= bestState && s > snapped) snapped = s;
|
||
bestState = snapped;
|
||
}
|
||
|
||
LoadAction la;
|
||
la.loadId = lc.id;
|
||
la.kind = LoadAction::State;
|
||
la.funding = LoadAction::Surplus;
|
||
la.state = bestState;
|
||
la.estimatedPowerW = lc.declared.estimatedPowerW.value(bestState, 0.0);
|
||
la.counts[CountKey::BudgetAllocated] = la.estimatedPowerW; // R3
|
||
|
||
if (bestState != targetState)
|
||
la.reason = { DecisionCode::LockMinStateHold, {{"state", bestState}} };
|
||
else if (bestState == 4)
|
||
la.reason = { DecisionCode::SgForced,
|
||
{{"budgetW", qRound(budgetW)}, {"estimatedW", qRound(p4)}} };
|
||
else if (bestState == 3)
|
||
la.reason = { DecisionCode::SgRecommended,
|
||
{{"budgetW", qRound(budgetW)}, {"estimatedW", qRound(p3)}} };
|
||
else if (m_reserveActive && m_reserveWithheldW > 0)
|
||
la.reason = { DecisionCode::BatteryReserve,
|
||
{{"socPercent", qRound(m_reserveSocPct)},
|
||
{"reservePercent", qRound(m_reserveSeuilPct)},
|
||
{"withheldW", qRound(m_reserveWithheldW)}} };
|
||
else if (budgetW > 0 && p3 > 0)
|
||
// §12 — il y a du budget, mais aucun état ne sait le prendre : une PAC SG-Ready n'a
|
||
// pas d'« état 3 à moitié ». Le motif NOMME l'état hors d'atteinte et sa puissance
|
||
// estimée — dire « minPowerW » sans dire lequel remplacerait une phrase vague par
|
||
// une autre.
|
||
la.reason = { DecisionCode::BelowMinPower,
|
||
{{"budgetW", qRound(budgetW)}, {"minPowerW", qRound(p3)},
|
||
{"state", 3}} };
|
||
else
|
||
// Budget nul ou négatif : il n'y a réellement RIEN à allouer. « Surplus insuffisant »
|
||
// est alors la vérité, et c'est le seul cas où elle l'est.
|
||
la.reason = { DecisionCode::SgNormal, {{"budgetW", qRound(budgetW)}} };
|
||
|
||
// Budget restant : on ne soustrait que la puissance ALLOUÉE (états 1/2 = 0).
|
||
remainingSurplusW = budgetW - la.estimatedPowerW;
|
||
budget.allocatedW += la.estimatedPowerW;
|
||
return la;
|
||
}
|