hoffmation-base 3.8.0 → 4.1.0

package/lib/devices/jsObject/jsObjectEnergyManager.d.ts

@@ -1,5 +1,5 @@
 import { IoBrokerBaseDevice } from '../IoBrokerBaseDevice';
-import { iDisposable, iEnergyManager, iExcessEnergyConsumer } from '../../interfaces';
+import { iDisposable, iEnergyHistoryOutlook, iEnergyManager, iExcessEnergyConsumer, iMorningReserveVerdict } from '../../interfaces';
 import { IoBrokerDeviceInfo } from '../IoBrokerDeviceInfo';
 import { PhaseState } from '../models';
 export declare class JsObjectEnergyManager extends IoBrokerBaseDevice implements iEnergyManager, iDisposable {
@@ -24,6 +24,21 @@ export declare class JsObjectEnergyManager extends IoBrokerBaseDevice implements
     get excessEnergy(): number;
     /** @inheritDoc */
     get acBlocked(): boolean;
+    /**
+     * The same shared implementation the other energy manager delegates to - not a stub, and not a copy. This
+     * manager measures three phases and carries neither a battery nor the dials that say how a history is read,
+     * so the shared code answers nothing for it and reads nothing for it either. That is the honest answer and
+     * the one an installation on this manager already got; it is reached by running the real path rather than
+     * by declaring it here.
+     * @inheritDoc
+     */
+    get morningOutlook(): iEnergyHistoryOutlook | undefined;
+    /**
+     * Delegated for the same reason {@link morningOutlook} is - and it answers nothing here for the same reason
+     * too: this manager states neither the reserve nor the sun threshold a verdict would be measured against.
+     * @inheritDoc
+     */
+    get morningReserveVerdict(): iMorningReserveVerdict | undefined;
     private _excessEnergyConsumerConsumption;
     /**
      * Example:

package/lib/devices/jsObject/jsObjectEnergyManager.js

@@ -62,6 +62,25 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
     get acBlocked() {
         return this.excessEnergy < 200;
     }
+    /**
+     * The same shared implementation the other energy manager delegates to - not a stub, and not a copy. This
+     * manager measures three phases and carries neither a battery nor the dials that say how a history is read,
+     * so the shared code answers nothing for it and reads nothing for it either. That is the honest answer and
+     * the one an installation on this manager already got; it is reached by running the real path rather than
+     * by declaring it here.
+     * @inheritDoc
+     */
+    get morningOutlook() {
+        return utils_1.EnergyManagerUtils.morningOutlook(this);
+    }
+    /**
+     * Delegated for the same reason {@link morningOutlook} is - and it answers nothing here for the same reason
+     * too: this manager states neither the reserve nor the sun threshold a verdict would be measured against.
+     * @inheritDoc
+     */
+    get morningReserveVerdict() {
+        return utils_1.EnergyManagerUtils.morningReserveVerdict(this, this.morningOutlook);
+    }
     /**
      * Example:
      * ________________________________________
@@ -137,6 +156,10 @@ class JsObjectEnergyManager extends IoBrokerBaseDevice_1.IoBrokerBaseDevice {
         }
     }
     calculateExcessEnergy() {
+        // The same call the other manager's loop makes, so whether anything is read is decided in one place
+        // rather than by which manager happens to ask. This one states no dials, so nothing is read and no
+        // request quota is spent.
+        utils_1.EnergyManagerUtils.refreshEnergyHistory(this);
         const phaseProduction = this._currentProduction / 3.0;
         this._phaseAState = new models_2.PhaseState(this._powerValuePhaseA, phaseProduction);
         this._phaseBState = new models_2.PhaseState(this._powerValuePhaseB, phaseProduction);

package/lib/devices/sharedFunctions/index.d.ts

@@ -4,4 +4,5 @@ export * from './handleSensor';
 export * from './humiditySensor';
 export * from './lampUtils';
 export * from './shutterUtils';
+export * from './soilSensor';
 export * from './temperatureSensor';

package/lib/devices/sharedFunctions/index.js

@@ -20,4 +20,5 @@ __exportStar(require("./handleSensor"), exports);
 __exportStar(require("./humiditySensor"), exports);
 __exportStar(require("./lampUtils"), exports);
 __exportStar(require("./shutterUtils"), exports);
+__exportStar(require("./soilSensor"), exports);
 __exportStar(require("./temperatureSensor"), exports);

package/lib/devices/sharedFunctions/soilSensor.d.ts

@@ -0,0 +1,23 @@
+import { iSoilCollector, iSoilSensor } from '../../interfaces';
+import { SoilSensorChangeAction } from '../../action';
+export declare class SoilSensor implements iSoilSensor {
+    private readonly _device;
+    /** @inheritDoc */
+    readonly jsonOmitKeys: string[];
+    private _soilMoistureCallbacks;
+    private _soilMoisture;
+    private readonly _persistSoilSensorInterval;
+    constructor(_device: iSoilCollector);
+    /** @inheritDoc */
+    get soilMoisture(): number;
+    /** @inheritDoc */
+    set soilMoisture(val: number);
+    /** @inheritDoc */
+    persist(): void;
+    /** @inheritDoc */
+    addSoilMoistureCallback(pCallback: (action: SoilSensorChangeAction) => void): void;
+    /** @inheritDoc */
+    dispose(): void;
+    /** @inheritDoc */
+    toJSON(): Partial<SoilSensor>;
+}

package/lib/devices/sharedFunctions/soilSensor.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SoilSensor = void 0;
+const interfaces_1 = require("../../interfaces");
+const action_1 = require("../../action");
+const utils_1 = require("../../utils");
+const services_1 = require("../../services");
+class SoilSensor {
+    constructor(_device) {
+        this._device = _device;
+        /** @inheritDoc */
+        this.jsonOmitKeys = ['_device'];
+        this._soilMoistureCallbacks = [];
+        this._soilMoisture = interfaces_1.UNDEFINED_SOIL_MOISTURE_VALUE;
+        this._persistSoilSensorInterval = utils_1.Utils.guardedInterval(() => {
+            this.persist();
+        }, 5 * 60 * 1000, this, false);
+    }
+    /** @inheritDoc */
+    get soilMoisture() {
+        return this._soilMoisture;
+    }
+    /** @inheritDoc */
+    set soilMoisture(val) {
+        this._soilMoisture = val;
+        for (const cb of this._soilMoistureCallbacks) {
+            cb(new action_1.SoilSensorChangeAction(this._device, val));
+        }
+    }
+    /** @inheritDoc */
+    persist() {
+        var _a;
+        if (this._soilMoisture === interfaces_1.UNDEFINED_SOIL_MOISTURE_VALUE) {
+            // Nothing was ever reported --> persisting would only write a row of the sentinel, which reads like a
+            // measured -1 % in every later query.
+            return;
+        }
+        (_a = services_1.Persistence.dbo) === null || _a === void 0 ? void 0 : _a.persistSoilSensor(this._device);
+    }
+    /** @inheritDoc */
+    addSoilMoistureCallback(pCallback) {
+        this._soilMoistureCallbacks.push(pCallback);
+        if (this._soilMoisture !== interfaces_1.UNDEFINED_SOIL_MOISTURE_VALUE) {
+            pCallback(new action_1.SoilSensorChangeAction(this._device, this._soilMoisture));
+        }
+    }
+    /** @inheritDoc */
+    dispose() {
+        if (this._persistSoilSensorInterval) {
+            clearInterval(this._persistSoilSensorInterval);
+        }
+    }
+    /** @inheritDoc */
+    toJSON() {
+        return utils_1.Utils.jsonFilter(this, this.jsonOmitKeys);
+    }
+}
+exports.SoilSensor = SoilSensor;

package/lib/devices/victron/victron-device.d.ts

@@ -1,9 +1,14 @@
-import { iBatteryDevice, iEnergyManager, iExcessEnergyConsumer, iJsonOmitKeys } from '../../interfaces';
+import { iBatteryDevice, iEnergyHistoryOutlook, iEnergyManager, iExcessEnergyConsumer, iJsonOmitKeys, iMorningReserveVerdict } from '../../interfaces';
 import { VictronDeviceSettings } from '../../settingsObjects';
 import { Battery } from '../sharedFunctions';
 import { VictronDeviceData, VictronMqttConnectionOptions, VictronMqttConsumer } from 'victron-mqtt-consumer';
 import { BaseDevice } from '../BaseDevice';
 export declare class VictronDevice extends BaseDevice implements iEnergyManager, iBatteryDevice, iJsonOmitKeys {
+    /**
+     * The shortest horizon the battery reservation is spread over, in hours. Not a setting: it is a bound on
+     * the arithmetic rather than a dial of the plant - see {@link VictronDevice.reserveHorizonHours}.
+     */
+    private static readonly minimumReserveHorizonHours;
     /** @inheritDoc */
     readonly settings: VictronDeviceSettings;
     /** @inheritDoc */
@@ -17,11 +22,28 @@ export declare class VictronDevice extends BaseDevice implements iEnergyManager,
     private _lastPersistenceCalculation;
     private _nextPersistEntry;
     private _excessEnergy;
+    /** The last reported release state, so the five second loop writes a line on change, not on every pass. */
+    private _lastReleaseLine;
     constructor(opts: VictronMqttConnectionOptions);
     /** @inheritDoc */
     get acBlocked(): boolean;
     /** @inheritDoc */
     get batteryLevel(): number;
+    /**
+     * Delegated rather than written here, exactly the way this device delegates its consumer switching to
+     * {@link EnergyManagerUtils.turnOnAdditionalConsumer}: the answer is about the **plant**, and every energy
+     * manager owes the same one - so it is written once and no manager is left with a copy or a stub. What this
+     * device keeps for itself is the policy: the rungs, the reservation and the ac block.
+     * @inheritDoc
+     */
+    get morningOutlook(): iEnergyHistoryOutlook | undefined;
+    /**
+     * Delegated for the same reason {@link morningOutlook} is: the judgement is about the plant's battery and
+     * every manager owes the same one. What this device keeps for itself is what it *does* with the verdict -
+     * the reservation and the ac block below.
+     * @inheritDoc
+     */
+    get morningReserveVerdict(): iMorningReserveVerdict | undefined;
     get victronConsumer(): VictronMqttConsumer;
     get data(): VictronDeviceData;
     get excessEnergy(): number;
@@ -33,6 +55,7 @@ export declare class VictronDevice extends BaseDevice implements iEnergyManager,
     addExcessConsumer(device: iExcessEnergyConsumer): void;
     /** @inheritDoc */
     dispose(): void;
+    /** @inheritDoc */
     getReport(): string;
     recalculatePowerSharing(): void;
     toJSON(): Partial<VictronDevice>;
@@ -42,6 +65,65 @@ export declare class VictronDevice extends BaseDevice implements iEnergyManager,
      */
     setGridSetPoint(setPoint: number): void;
     private calculateExcessEnergy;
+    /**
+     * Rung 1, the only rung of the recorded history that decides: if the state of charge carries past the
+     * coming morning low even when no further yield arrives, nothing has to be held back and no consumer has to
+     * be kept off.
+     *
+     * This manager's own policy and rightly here rather than in the shared utils: what a plant does with the
+     * outlook is the manager's judgement, and the reservation and ac block it feeds are this device's.
+     *
+     * Arithmetic over the plant's own measured consumption - no fit, no weights, no window length. That is what
+     * separates it from the rung below, which measures against the lower edge of the fitted band and therefore
+     * only records (see {@link EnergyManagerUtils.observeModelShadow}).
+     * @param outlook - What the plant said, or undefined while it cannot say anything - which includes the
+     * absent charge level, so the guard against it stays in the shared utils alone.
+     * @returns The release, or undefined while the measured consumption cannot carry it.
+     */
+    private morningRelease;
+    /**
+     * How much of the production is held back for the battery.
+     *
+     * With the release nothing is held back: the coming morning clears the reserve on measured consumption
+     * alone. Without it the calculation is the one that was here before - it aims at a full battery by sunset,
+     * which over-reserves, and that is what an installation without a usable recorded history keeps.
+     * @param released - Whether rung 1 carried the coming morning.
+     * @param hoursTilSunset - The horizon the shortfall is spread over.
+     * @returns The wattage to hold back.
+     */
+    private neededBatteryWattage;
+    /**
+     * The horizon the shortfall is actually spread over: the remaining sun hours, but never less than
+     * {@link VictronDevice.minimumReserveHorizonHours}.
+     *
+     * The raw horizon is a difference against the next sunset and runs to zero, while the part of day this
+     * calculation is entered under is derived separately from today's sunset plus its own offsets - so the two
+     * do not turn at the same instant. In the gap the divisor is first tiny and then negative: a shortfall of a
+     * few percent becomes a rate in the megawatt range, at exactly zero an `Infinity` that leaves the process
+     * through `toJSON`, and past the turn a *negative* reservation that is added to the excess and offers
+     * energy the plant does not have. Every five seconds, and since the horizon is counted in hours rather than
+     * minutes, sixty times as large as when this was harmless.
+     *
+     * The bound is a rate bound, not a schedule: below half an hour of daylight there is nothing left to charge
+     * in, so the quotient stops describing a charging rate and only its magnitude still moves. Half an hour
+     * caps the reservation at twice the battery capacity per hour - still above anything the plant can take in,
+     * therefore never loosening a reservation that was meaningful, while keeping the value finite and signed
+     * the way the rest of the calculation assumes.
+     * @param hoursTilSunset - The raw remaining sun hours, which may be zero or negative.
+     * @returns The horizon to divide by, at least the minimum.
+     */
+    private reserveHorizonHours;
+    /**
+     * Reports the release whenever it changes, and never otherwise: this runs every five seconds, and a line
+     * per pass would bury the change nobody must miss. The very first pass is remembered but not reported while
+     * there is no release, so an installation whose recorded history holds nothing stays silent instead of
+     * announcing its unchanged behaviour once per start.
+     *
+     * Named after the reserve rather than after the reservation, because the same release also answers the ac
+     * block - and it does so around the clock, while the reservation only applies in daylight.
+     * @param release - The release of this pass, or undefined while the measured consumption cannot carry one.
+     */
+    private logMorningRelease;
     private turnOnAdditionalConsumer;
     private turnOffAdditionalConsumer;
     private persist;

package/lib/devices/victron/victron-device.js

@@ -50,6 +50,16 @@ class VictronDevice extends BaseDevice_1.BaseDevice {
         if (!this.settings.hasBattery) {
             return false;
         }
+        if (this.morningRelease(this.morningOutlook) !== undefined) {
+            // Where the plant's measured consumption alone shows the coming morning clears the reserve, that
+            // statement decides and the clock does not. The ladder below is a stand-in for the same question, and
+            // its sunny morning branch cannot answer the case it was built for: it reads the day's mean cloud
+            // cover, which a day that is dull in the morning and clears up at noon never falls below.
+            //
+            // Only the release direction. Blocking on the model would mean acting on the fitted band, which is
+            // exactly what the shadow exists to defer.
+            return false;
+        }
         const hours = new Date().getHours();
         if (hours > 18) {
             return this.batteryLevel < this.settings.minimumNightTimeAcBatteryLevel;
@@ -81,6 +91,25 @@ class VictronDevice extends BaseDevice_1.BaseDevice {
         }
         return level;
     }
+    /**
+     * Delegated rather than written here, exactly the way this device delegates its consumer switching to
+     * {@link EnergyManagerUtils.turnOnAdditionalConsumer}: the answer is about the **plant**, and every energy
+     * manager owes the same one - so it is written once and no manager is left with a copy or a stub. What this
+     * device keeps for itself is the policy: the rungs, the reservation and the ac block.
+     * @inheritDoc
+     */
+    get morningOutlook() {
+        return utils_1.EnergyManagerUtils.morningOutlook(this);
+    }
+    /**
+     * Delegated for the same reason {@link morningOutlook} is: the judgement is about the plant's battery and
+     * every manager owes the same one. What this device keeps for itself is what it *does* with the verdict -
+     * the reservation and the ac block below.
+     * @inheritDoc
+     */
+    get morningReserveVerdict() {
+        return utils_1.EnergyManagerUtils.morningReserveVerdict(this, this.morningOutlook);
+    }
     get victronConsumer() {
         return this._victronConsumer;
     }
@@ -124,8 +153,16 @@ class VictronDevice extends BaseDevice_1.BaseDevice {
             this._iCalculationInterval = null;
         }
     }
+    /** @inheritDoc */
     getReport() {
-        return '';
+        var _a;
+        const response = [];
+        response.push(`Production: ${(_a = this.data.pvInverter.power) !== null && _a !== void 0 ? _a : 0}W`);
+        response.push(`Drawing Wattage: ${this.drawingWattage}W`);
+        response.push(`Injecting Wattage: ${this.injectingWattage}W`);
+        response.push(`Self Consuming Wattage: ${this.selfConsumingWattage}W`);
+        response.push(`Battery Level: ${this.batteryLevel}%`);
+        return response.join('\n');
     }
     recalculatePowerSharing() {
         this.calculateExcessEnergy();
@@ -167,6 +204,19 @@ class VictronDevice extends BaseDevice_1.BaseDevice {
             this.log(enums_1.LogLevel.Debug, 'No data available from Victron device.');
             return;
         }
+        // The manager's loop is what drives the plant's one reading, for every consumer of it. Asked, not
+        // scheduled: what it costs is decided by the data situation rather than by a setting, and each of the
+        // reads behind this throttles itself, so asking on every pass of the five second loop costs the same
+        // number of queries as asking once an hour.
+        utils_1.EnergyManagerUtils.refreshEnergyHistory(this);
+        // Read once and handed on, rather than each of the three asking again: the projection is arithmetic over
+        // one read, and three passes over it would still have to agree with each other.
+        const outlook = this.morningOutlook;
+        const release = this.morningRelease(outlook);
+        this.logMorningRelease(release);
+        // Fed from here and from nowhere else. `acBlocked` is a getter anyone may read at any rate, and a tally
+        // that counts reads rather than evaluations measures the callers instead of the model.
+        utils_1.EnergyManagerUtils.observeModelShadow(this, outlook, release !== undefined);
         // Step 1: Calculate battery need
         const hoursTilSunset = services_1.TimeCallbackService.hoursTilSunset();
         let neededBatteryWattage = 0;
@@ -176,7 +226,7 @@ class VictronDevice extends BaseDevice_1.BaseDevice {
                 this.log(enums_1.LogLevel.Debug, 'No battery data available from Victron device.');
                 return;
             }
-            neededBatteryWattage = ((1 - this.batteryLevel / 100.0) * this.settings.batteryCapacityWattage) / hoursTilSunset;
+            neededBatteryWattage = this.neededBatteryWattage(release !== undefined, hoursTilSunset);
             // Step 2: Calculate expected solar output
             const solarOutput = (_a = this.data.pvInverter.power) !== null && _a !== void 0 ? _a : 0;
             // Step 3: Calculate expected base consumption
@@ -205,6 +255,100 @@ class VictronDevice extends BaseDevice_1.BaseDevice {
         }
         this.calculatePersistenceValues();
     }
+    /**
+     * Rung 1, the only rung of the recorded history that decides: if the state of charge carries past the
+     * coming morning low even when no further yield arrives, nothing has to be held back and no consumer has to
+     * be kept off.
+     *
+     * This manager's own policy and rightly here rather than in the shared utils: what a plant does with the
+     * outlook is the manager's judgement, and the reservation and ac block it feeds are this device's.
+     *
+     * Arithmetic over the plant's own measured consumption - no fit, no weights, no window length. That is what
+     * separates it from the rung below, which measures against the lower edge of the fitted band and therefore
+     * only records (see {@link EnergyManagerUtils.observeModelShadow}).
+     * @param outlook - What the plant said, or undefined while it cannot say anything - which includes the
+     * absent charge level, so the guard against it stays in the shared utils alone.
+     * @returns The release, or undefined while the measured consumption cannot carry it.
+     */
+    morningRelease(outlook) {
+        if (outlook === undefined) {
+            // The fallback holds back more, not less.
+            return undefined;
+        }
+        const reserve = this.settings.minimumMorningSocReserve;
+        const worstCaseLowSoc = outlook.worstCaseLowSoc;
+        if (worstCaseLowSoc === undefined || worstCaseLowSoc < reserve) {
+            return undefined;
+        }
+        return {
+            reason: `worst case low ${utils_1.Utils.round(worstCaseLowSoc, 2)}% holds the reserve ${reserve}% ` +
+                'without any further yield',
+        };
+    }
+    /**
+     * How much of the production is held back for the battery.
+     *
+     * With the release nothing is held back: the coming morning clears the reserve on measured consumption
+     * alone. Without it the calculation is the one that was here before - it aims at a full battery by sunset,
+     * which over-reserves, and that is what an installation without a usable recorded history keeps.
+     * @param released - Whether rung 1 carried the coming morning.
+     * @param hoursTilSunset - The horizon the shortfall is spread over.
+     * @returns The wattage to hold back.
+     */
+    neededBatteryWattage(released, hoursTilSunset) {
+        if (released) {
+            return 0;
+        }
+        const missingShare = 1 - this.batteryLevel / 100.0;
+        return (missingShare * this.settings.batteryCapacityWattage) / this.reserveHorizonHours(hoursTilSunset);
+    }
+    /**
+     * The horizon the shortfall is actually spread over: the remaining sun hours, but never less than
+     * {@link VictronDevice.minimumReserveHorizonHours}.
+     *
+     * The raw horizon is a difference against the next sunset and runs to zero, while the part of day this
+     * calculation is entered under is derived separately from today's sunset plus its own offsets - so the two
+     * do not turn at the same instant. In the gap the divisor is first tiny and then negative: a shortfall of a
+     * few percent becomes a rate in the megawatt range, at exactly zero an `Infinity` that leaves the process
+     * through `toJSON`, and past the turn a *negative* reservation that is added to the excess and offers
+     * energy the plant does not have. Every five seconds, and since the horizon is counted in hours rather than
+     * minutes, sixty times as large as when this was harmless.
+     *
+     * The bound is a rate bound, not a schedule: below half an hour of daylight there is nothing left to charge
+     * in, so the quotient stops describing a charging rate and only its magnitude still moves. Half an hour
+     * caps the reservation at twice the battery capacity per hour - still above anything the plant can take in,
+     * therefore never loosening a reservation that was meaningful, while keeping the value finite and signed
+     * the way the rest of the calculation assumes.
+     * @param hoursTilSunset - The raw remaining sun hours, which may be zero or negative.
+     * @returns The horizon to divide by, at least the minimum.
+     */
+    reserveHorizonHours(hoursTilSunset) {
+        return Math.max(hoursTilSunset, VictronDevice.minimumReserveHorizonHours);
+    }
+    /**
+     * Reports the release whenever it changes, and never otherwise: this runs every five seconds, and a line
+     * per pass would bury the change nobody must miss. The very first pass is remembered but not reported while
+     * there is no release, so an installation whose recorded history holds nothing stays silent instead of
+     * announcing its unchanged behaviour once per start.
+     *
+     * Named after the reserve rather than after the reservation, because the same release also answers the ac
+     * block - and it does so around the clock, while the reservation only applies in daylight.
+     * @param release - The release of this pass, or undefined while the measured consumption cannot carry one.
+     */
+    logMorningRelease(release) {
+        const line = release === undefined
+            ? 'no model free release, aiming at a full battery by sunset'
+            : `released: ${release.reason}`;
+        if (line === this._lastReleaseLine) {
+            return;
+        }
+        const first = this._lastReleaseLine === undefined;
+        this._lastReleaseLine = line;
+        if (first && release === undefined) {
+            return;
+        }
+        this.log(enums_1.LogLevel.Info, `Morning reserve decision: ${line}`);
+    }
     turnOnAdditionalConsumer() {
         const result = utils_1.EnergyManagerUtils.turnOnAdditionalConsumer(this._excessEnergyConsumer, this._lastDeviceChange);
         if (result == undefined) {
@@ -249,3 +393,8 @@ class VictronDevice extends BaseDevice_1.BaseDevice {
     }
 }
 exports.VictronDevice = VictronDevice;
+/**
+ * The shortest horizon the battery reservation is spread over, in hours. Not a setting: it is a bound on
+ * the arithmetic rather than a dial of the plant - see {@link VictronDevice.reserveHorizonHours}.
+ */
+VictronDevice.minimumReserveHorizonHours = 0.5;

package/lib/devices/victron/victron-morning-release.d.ts

@@ -0,0 +1,16 @@
+/**
+ * The one statement the plant's recorded history is allowed to act on in the victron manager: that the coming
+ * morning low clears the reserve on measured consumption alone, with no further yield assumed and no model
+ * involved.
+ *
+ * There is no counterpart for "the morning falls short". Saying so needs the fitted model, and the model runs
+ * in the shadow; the absent value therefore means the previous calculation applies, which needs nothing from
+ * the history.
+ *
+ * Not part of the published surface: it is how this manager carries its own decision from one private method
+ * to the next, not something a consumer of the library reads.
+ */
+export interface iVictronMorningRelease {
+    /** What an operator reads the release by. */
+    reason: string;
+}

package/lib/devices/victron/victron-morning-release.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/devices/zigbee/BaseDevices/index.d.ts

@@ -6,6 +6,7 @@ export * from './zigbeeLedRGBCCT';
 export * from './zigbeeMagnetContact';
 export * from './zigbeeMotionSensor';
 export * from './zigbeeShutter';
+export * from './zigbeeSoilSensor';
 export * from './zigbeeSwitch';
 export { ZigbeeLamp } from './zigbeeLamp';
 export { ZigbeeWindowHandle } from './zigbeeWindowHandle';

package/lib/devices/zigbee/BaseDevices/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./zigbeeLedRGBCCT"), exports);
 __exportStar(require("./zigbeeMagnetContact"), exports);
 __exportStar(require("./zigbeeMotionSensor"), exports);
 __exportStar(require("./zigbeeShutter"), exports);
+__exportStar(require("./zigbeeSoilSensor"), exports);
 __exportStar(require("./zigbeeSwitch"), exports);
 var zigbeeLamp_1 = require("./zigbeeLamp");
 Object.defineProperty(exports, "ZigbeeLamp", { enumerable: true, get: function () { return zigbeeLamp_1.ZigbeeLamp; } });

package/lib/devices/zigbee/BaseDevices/zigbeeSoilSensor.d.ts

@@ -0,0 +1,33 @@
+import { iBatteryDevice, iSoilCollector, iSoilSensor } from '../../../interfaces';
+import { BatteryLevelChangeAction, SoilSensorChangeAction } from '../../../action';
+import { ZigbeeDevice } from './zigbeeDevice';
+import { Battery } from '../../sharedFunctions';
+import { IoBrokerDeviceInfo } from '../../IoBrokerDeviceInfo';
+import { DeviceType } from '../../../enums';
+/**
+ * The common part of every zigbee device measuring the moisture of the soil it sits in.
+ *
+ * Carries the smallest honest contract: soil moisture and battery, the two states every such sensor reports.
+ * Ambient temperature and humidity are deliberately NOT here - a sensor that only reads the soil would then
+ * claim capabilities it does not have. A device that measures them adds those axes itself, see
+ * {@link ZigbeeCooloSoilSensor}.
+ */
+export declare class ZigbeeSoilSensor extends ZigbeeDevice implements iSoilCollector, iBatteryDevice {
+    /** @inheritDoc */
+    soilSensor: iSoilSensor;
+    /** @inheritDoc */
+    battery: Battery;
+    constructor(pInfo: IoBrokerDeviceInfo, pType: DeviceType);
+    /** @inheritDoc */
+    get batteryLevel(): number;
+    /** @inheritDoc */
+    get soilMoisture(): number;
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback: (action: BatteryLevelChangeAction) => void): void;
+    /** @inheritDoc */
+    addSoilMoistureCallback(pCallback: (action: SoilSensorChangeAction) => void): void;
+    /** @inheritDoc */
+    update(idSplit: string[], state: ioBroker.State, initial?: boolean): void;
+    /** @inheritDoc */
+    dispose(): void;
+}

package/lib/devices/zigbee/BaseDevices/zigbeeSoilSensor.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZigbeeSoilSensor = void 0;
+const zigbeeDevice_1 = require("./zigbeeDevice");
+const sharedFunctions_1 = require("../../sharedFunctions");
+const enums_1 = require("../../../enums");
+/**
+ * The common part of every zigbee device measuring the moisture of the soil it sits in.
+ *
+ * Carries the smallest honest contract: soil moisture and battery, the two states every such sensor reports.
+ * Ambient temperature and humidity are deliberately NOT here - a sensor that only reads the soil would then
+ * claim capabilities it does not have. A device that measures them adds those axes itself, see
+ * {@link ZigbeeCooloSoilSensor}.
+ */
+class ZigbeeSoilSensor extends zigbeeDevice_1.ZigbeeDevice {
+    constructor(pInfo, pType) {
+        super(pInfo, pType);
+        /** @inheritDoc */
+        this.soilSensor = new sharedFunctions_1.SoilSensor(this);
+        /** @inheritDoc */
+        this.battery = new sharedFunctions_1.Battery(this);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.soilSensor);
+        this.deviceCapabilities.push(enums_1.DeviceCapability.batteryDriven);
+    }
+    /** @inheritDoc */
+    get batteryLevel() {
+        return this.battery.level;
+    }
+    /** @inheritDoc */
+    get soilMoisture() {
+        return this.soilSensor.soilMoisture;
+    }
+    /** @inheritDoc */
+    addBatteryLevelCallback(pCallback) {
+        this.battery.addBatteryLevelCallback(pCallback);
+    }
+    /** @inheritDoc */
+    addSoilMoistureCallback(pCallback) {
+        this.soilSensor.addSoilMoistureCallback(pCallback);
+    }
+    /** @inheritDoc */
+    update(idSplit, state, initial = false) {
+        super.update(idSplit, state, initial, true);
+        switch (idSplit[3]) {
+            case 'battery':
+                this.battery.level = state.val;
+                if (this.batteryLevel < 20) {
+                    this.log(enums_1.LogLevel.Warn, 'Das Zigbee Gerät hat unter 20% Batterie.');
+                }
+                break;
+            case 'soil_moisture':
+                this.soilSensor.soilMoisture = state.val;
+                break;
+        }
+    }
+    /** @inheritDoc */
+    dispose() {
+        this.soilSensor.dispose();
+        super.dispose();
+    }
+}
+exports.ZigbeeSoilSensor = ZigbeeSoilSensor;

package/lib/devices/zigbee/index.d.ts

@@ -6,6 +6,7 @@ export * from './zigbeeAqaraPresence';
 export * from './zigbeeAquaraVibra';
 export * from './zigbeeAquaraWater';
 export * from './zigbeeBlitzShp';
+export * from './zigbeeCooloSoilSensor';
 export * from './zigbeeEuroHeater';
 export * from './zigbeeHeimanSmoke';
 export * from './zigbeeIkeaSteckdose';

package/lib/devices/zigbee/index.js

@@ -23,6 +23,7 @@ __exportStar(require("./zigbeeAqaraPresence"), exports);
 __exportStar(require("./zigbeeAquaraVibra"), exports);
 __exportStar(require("./zigbeeAquaraWater"), exports);
 __exportStar(require("./zigbeeBlitzShp"), exports);
+__exportStar(require("./zigbeeCooloSoilSensor"), exports);
 __exportStar(require("./zigbeeEuroHeater"), exports);
 __exportStar(require("./zigbeeHeimanSmoke"), exports);
 __exportStar(require("./zigbeeIkeaSteckdose"), exports);