iobroker.idm-multitalent_002 2.2.0 → 2.2.1

package/README.md

@@ -56,6 +56,9 @@ Example screenshots of objects:
 ![Status](resources/ioBrokerAdapter-Status.jpg)
 
 ## Changelog
+### 2.2.1 (2026-09-13)
+* (zloe) the per-sweep log line introduced in 2.2.0 (`sensor sweep done in ...`) is now logged at debug level instead of info - in normal operation a sensor sweep completes roughly every 10s, which was far too chatty for info level. In its place, a new info-level summary is logged once every 10 minutes with a small statistic (sweep count, min/avg/max duration) per group covering that window
+
 ### 2.2.0 (2026-09-11)
 * (zloe) sensor and settings are no longer polled in lockstep: sensor is read as fast as the protocol allows (throttled to at most once every 10s), settings only once every 60s plus once right away after any value is written to the heat pump - both intervals measured from the start of one full sweep to the start of the next, and neither configurable. This noticeably reduces how often the heat pump's own control gets polled for the slower-changing settings data, without making sensor data any less fresh
 * (zloe) a group's sweep (round-robin or multi-block alike) is never interrupted by the other group becoming due partway through - previously only a multi-block collection had this guarantee; the classic one-block-at-a-time round-robin now gets it too
@@ -265,13 +268,20 @@ sequenceDiagram
 ```
 
 Each completed sweep logs its own actual elapsed time plus a rolling average over the last 10
-sweeps, e.g. `sensor sweep done in 1400ms (avg of last 10: 1360ms)` - one line per group, logged
-the moment that group's sweep finishes. This replaces the earlier combined "full-coverage cycle"
-line: now that the two groups run on independent schedules there is no single shared interval left
-to time them together, so each gets its own line instead. As before, this is driven by data
+sweeps at **debug** level, e.g. `sensor sweep done in 1400ms (avg of last 10: 1360ms)` - one line
+per group, logged the moment that group's sweep finishes. As before, this is driven by data
 actually being *received* (`recordBlockRead()`), not merely requested - a block that was asked for
 but never got a reply (a retry, a response-watchdog reset, the periodic resync) does not count.
 
+Since a sensor sweep normally completes roughly every 10s, debug is the right level for that
+per-sweep detail - logging it at info would flood the log in normal operation. Instead, once every
+10 minutes (fixed), one small **info**-level summary line reports both groups' activity over that
+window, e.g. `last 10min - sensor: 58 sweep(s), 1360ms avg (min 1210ms, max 1890ms); settings: 9
+sweep(s), 640ms avg (min 600ms, max 720ms)` - or `0 sweeps` for a group that hasn't completed one
+in that window. This is the only sweep-related log at info level now; it replaces the earlier
+combined "full-coverage cycle" line, which no longer made sense once the two groups started running
+on independent schedules.
+
 #### Multi-block requests, per group
 
 The serial protocol allows requesting several data blocks in one `0171` message, combined in a

package/io-package.json

@@ -1,8 +1,21 @@
 {
   "common": {
     "name": "idm-multitalent_002",
-    "version": "2.2.0",
+    "version": "2.2.1",
     "news": {
+      "2.2.1": {
+        "en": "the per-sweep log line introduced in 2.2.0 (\"sensor sweep done in ...\") is now logged at debug level instead of info - a sensor sweep normally completes roughly every 10s, which was too chatty for info level. In its place, a small info-level summary is now logged once every 10 minutes, with a statistic (sweep count, min/avg/max duration) per group covering that window",
+        "de": "die in 2.2.0 eingeführte Log-Zeile pro Durchlauf (\"sensor sweep done in ...\") wird jetzt auf Debug-Level statt Info protokolliert - ein Sensor-Durchlauf ist normalerweise etwa alle 10s abgeschlossen, was auf Info-Level zu viel Rauschen erzeugte. Stattdessen wird jetzt alle 10 Minuten eine kleine Info-Level-Zusammenfassung protokolliert, mit einer Statistik (Anzahl Durchläufe, min/durchschnittliche/max Dauer) pro Gruppe für dieses Zeitfenster",
+        "ru": "строка журнала для каждого прохода, добавленная в 2.2.0 (\"sensor sweep done in ...\"), теперь записывается на уровне debug вместо info - проход сенсоров обычно завершается примерно каждые 10с, что было слишком часто для уровня info. Вместо этого теперь раз в 10 минут записывается небольшая сводка на уровне info со статистикой (количество проходов, мин/среднее/макс длительность) по каждой группе за этот период",
+        "pt": "a linha de log por varredura introduzida na 2.2.0 (\"sensor sweep done in ...\") agora é registrada em nível debug em vez de info - uma varredura de sensores normalmente é concluída a cada 10s, o que era muito frequente para o nível info. Em seu lugar, agora é registrado um pequeno resumo em nível info a cada 10 minutos, com uma estatística (contagem de varreduras, duração mín/média/máx) por grupo naquele período",
+        "nl": "de per-ronde logregel die in 2.2.0 werd geïntroduceerd (\"sensor sweep done in ...\") wordt nu op debug-niveau gelogd in plaats van info - een sensorronde is normaal ongeveer elke 10s voltooid, wat te veel ruis gaf op info-niveau. In plaats daarvan wordt nu elke 10 minuten een kleine samenvatting op info-niveau gelogd, met een statistiek (aantal rondes, min/gemiddelde/max duur) per groep over die periode",
+        "fr": "la ligne de journal par tour introduite dans la 2.2.0 (\"sensor sweep done in ...\") est désormais enregistrée au niveau debug au lieu de info - un tour des capteurs se termine normalement environ toutes les 10s, ce qui était trop fréquent pour le niveau info. À la place, un petit résumé de niveau info est maintenant enregistré toutes les 10 minutes, avec une statistique (nombre de tours, durée min/moyenne/max) par groupe sur cette période",
+        "it": "la riga di log per giro introdotta nella 2.2.0 (\"sensor sweep done in ...\") viene ora registrata a livello debug invece che info - un giro dei sensori normalmente si completa circa ogni 10s, il che era troppo frequente per il livello info. Al suo posto, ora viene registrato un piccolo riepilogo a livello info ogni 10 minuti, con una statistica (numero di giri, durata min/media/max) per gruppo relativa a quel periodo",
+        "es": "la línea de registro por pasada introducida en la 2.2.0 (\"sensor sweep done in ...\") ahora se registra en nivel debug en lugar de info - una pasada de sensores normalmente se completa cada 10s aproximadamente, lo cual era demasiado frecuente para el nivel info. En su lugar, ahora se registra un pequeño resumen en nivel info cada 10 minutos, con una estadística (número de pasadas, duración mín/media/máx) por grupo durante ese periodo",
+        "pl": "linia dziennika dla każdego przebiegu wprowadzona w 2.2.0 (\"sensor sweep done in ...\") jest teraz zapisywana na poziomie debug zamiast info - przebieg czujników zwykle kończy się co około 10s, co było zbyt częste dla poziomu info. Zamiast tego co 10 minut zapisywane jest teraz małe podsumowanie na poziomie info, ze statystyką (liczba przebiegów, min/średni/maks czas trwania) dla każdej grupy w tym okresie",
+        "zh-cn": "2.2.0 中引入的每轮采集日志行(\"sensor sweep done in ...\")现在改为以 debug 级别记录,而不是 info 级别——传感器一轮采集通常约每10秒完成一次,这在 info 级别下过于频繁。取而代之的是,现在每10分钟记录一条小型 info 级别摘要,包含该分组在此期间的统计信息(采集次数、最小/平均/最大耗时)",
+        "uk": "рядок журналу для кожного проходу, доданий у 2.2.0 (\"sensor sweep done in ...\"), тепер записується на рівні debug замість info - прохід датчиків зазвичай завершується приблизно кожні 10с, що було занадто часто для рівня info. Натомість тепер раз на 10 хвилин записується невеликий підсумок на рівні info зі статистикою (кількість проходів, мін/середня/макс тривалість) для кожної групи за цей період"
+      },
       "2.2.0": {
         "en": "sensor and settings are no longer polled in lockstep: sensor is read as fast as the protocol allows (throttled to at most once every 10s), while settings is only read once every 60s, plus once right away after any value is written to the heat pump - reducing how often the heat pump's own control gets polled for the slower-changing settings data, without making sensor data any less fresh. A group's sweep - round-robin or multi-block alike - is never interrupted by the other group becoming due partway through. The combined \"full-coverage cycle\" log line is replaced by one line per group, logged the moment that group's own sweep completes, showing its actual elapsed time and a rolling average over its last 10 sweeps",
         "de": "Sensor- und Settings-Abfragen laufen nicht mehr im Gleichschritt: Sensor wird so schnell wie das Protokoll es erlaubt gelesen (gedrosselt auf höchstens einmal alle 10s), während Settings nur alle 60s gelesen wird, plus einmal sofort nachdem ein Wert zur Wärmepumpe geschrieben wurde - das reduziert, wie oft die Steuerung der Wärmepumpe für die sich selten ändernden Settings-Daten abgefragt wird, ohne dass Sensordaten dadurch weniger aktuell werden. Ein Durchlauf einer Gruppe - egal ob round-robin oder multi-block - wird nie unterbrochen, nur weil die andere Gruppe währenddessen fällig wird. Die kombinierte \"full-coverage cycle\"-Logzeile wird durch eine Zeile pro Gruppe ersetzt, die genau dann protokolliert wird, wenn der Durchlauf dieser Gruppe abgeschlossen ist, und die tatsächliche verstrichene Zeit sowie einen gleitenden Durchschnitt der letzten 10 Durchläufe zeigt",
@@ -80,19 +93,6 @@
         "pl": "dla S_H726100 wartości ustawień są teraz zbierane w jednym połączonym żądaniu zamiast jednego bloku na cykl odpytywania - pełne odświeżenie ustawień trwa teraz sekundy zamiast około minuty. Pozostałe obsługiwane firmware nie są tym dotknięte",
         "zh-cn": "对于 S_H726100,设置值现在通过一次合并请求一次性收集,而不再是每个轮询周期只读取一个区块——完整刷新一次设置现在只需几秒钟,而不是大约一分钟。其他所有受支持的固件均不受影响",
         "uk": "для S_H726100 значення налаштувань тепер збираються одним об'єднаним запитом замість одного блоку за цикл опитування - повне оновлення налаштувань тепер триває секунди замість приблизно хвилини. Усі інші підтримувані прошивки це не стосується"
-      },
-      "1.3.10": {
-        "en": "fix: a retry on an already finely-tuned data block no longer jumps the delay up by the full coarse step - it now corrects by the same small step the tuning had converged to, and only escalates back up if retries keep actually recurring",
-        "de": "fix: ein Retry auf einen bereits fein eingestellten Datenblock springt das Delay nicht mehr um den vollen groben Schritt hoch - er korrigiert jetzt um denselben kleinen Schritt, auf den die Feinabstimmung bereits konvergiert war, und eskaliert nur weiter, wenn Retries tatsächlich wiederholt auftreten",
-        "ru": "исправление: повтор для уже точно настроенного блока данных больше не увеличивает задержку сразу на весь грубый шаг - теперь коррекция происходит на тот же малый шаг, до которого сошлась точная настройка, и шаг увеличивается снова только при повторяющихся сбоях",
-        "pt": "correção: uma nova tentativa em um bloco de dados já ajustado finamente não aumenta mais o atraso pelo passo grosseiro completo - agora corrige pelo mesmo passo pequeno ao qual o ajuste havia convergido, e só aumenta novamente se as tentativas realmente se repetirem",
-        "nl": "fix: een retry op een al fijn afgesteld datablok verhoogt de vertraging niet meer met de volledige grove stap - er wordt nu gecorrigeerd met dezelfde kleine stap waarnaar de afstelling al was geconvergeerd, en de stap wordt alleen weer groter als retries daadwerkelijk blijven terugkomen",
-        "fr": "correctif : une nouvelle tentative sur un bloc de données déjà finement ajusté n'augmente plus le délai du pas grossier complet - elle corrige désormais du même petit pas vers lequel l'ajustement avait convergé, et n'escalade à nouveau que si les tentatives se répètent réellement",
-        "it": "correzione: un retry su un blocco dati già finemente calibrato non aumenta più il ritardo dell'intero passo grossolano - ora corregge con lo stesso piccolo passo a cui la calibrazione era convergente, e aumenta di nuovo solo se i retry continuano davvero a ripetersi",
-        "es": "corrección: un reintento en un bloque de datos ya ajustado finamente ya no aumenta el retardo en el paso grueso completo - ahora corrige con el mismo paso pequeño al que había convergido el ajuste, y solo vuelve a escalar si los reintentos realmente siguen repitiéndose",
-        "pl": "poprawka: ponowna próba dla już precyzyjnie dostrojonego bloku danych nie zwiększa już opóźnienia o pełny, zgrubny krok - teraz koryguje o ten sam mały krok, do którego zbiegło dostrajanie, i eskaluje ponownie tylko wtedy, gdy próby faktycznie się powtarzają",
-        "zh-cn": "修复:对已经精细调优的数据块进行重试时,不再将延迟直接跳增整个粗略步长——现在会按照调优已收敛到的相同小步长进行修正,只有在重试确实反复发生时才会重新升级步长",
-        "uk": "виправлення: повторна спроба для вже точно налаштованого блока даних більше не збільшує затримку одразу на весь грубий крок - тепер вона коригується тим самим малим кроком, до якого зійшло налаштування, і знову зростає лише якщо повтори справді повторюються"
       }
     },
     "titleLang": {

package/lib/idm-session.js

@@ -185,6 +185,18 @@ class IdmSession {
         // finishSweep(), the only place this is read from and pushed to.
         this.recentSweepDurationsMs = { sensor: [], settings: [] };
         this.sweepAverageWindow = 10;
+        // Per-sweep completions are only logged at debug level (see finishSweep()) - in normal
+        // operation a sensor sweep finishes roughly every sensorMinIntervalMs, which is far too
+        // chatty for info level. Instead reportSweepStats() (started by start(), see
+        // statsReportTimer below) logs one small info-level summary every statsReportIntervalMs,
+        // built from the counters below - reset to zero each time it reports.
+        this.statsReportIntervalMs = 10 * 60 * 1000; // fixed, not configurable - see class comment
+        this.statsReportTimer = null;
+        /** @type {{sensor: {count: number, totalMs: number, minMs: number | null, maxMs: number | null}, settings: {count: number, totalMs: number, minMs: number | null, maxMs: number | null}}} */
+        this.sweepStatsSinceReport = {
+            sensor: { count: 0, totalMs: 0, minMs: null, maxMs: null },
+            settings: { count: 0, totalMs: 0, minMs: null, maxMs: null },
+        };
         // Set by enqueueWrite(); consumed (and cleared) the next time chooseNextGroup() is asked -
         // forces a settings turn right after the WHOLE write queue has fully drained (request_data()
         // is only ever reached once nothing is left to send - see write_data_to_heatpump()'s
@@ -394,6 +406,8 @@ class IdmSession {
     /** Starts (or restarts) the connection process. Call once the adapter is ready. */
     start() {
         this.connectAndRead();
+        if (this.statsReportTimer) this.hooks.clearInterval(this.statsReportTimer);
+        this.statsReportTimer = this.hooks.setInterval(this.reportSweepStats.bind(this), this.statsReportIntervalMs);
     }
 
     connectAndRead() {
@@ -724,13 +738,14 @@ class IdmSession {
     /**
      * Called once `group`'s sweep has actually covered every one of its blocks (see
      * recordBlockRead(), the only caller) - logs the sweep's actual elapsed duration and a rolling
-     * average over the last sweepAverageWindow sweeps (replacing the old combined "full-coverage
-     * cycle" log, which no longer makes sense now that sensor and settings run on independent
-     * cadences - see the constructor's turn-scheduling comment), and clears blocksReadThisSweep so
-     * the NEXT sweep starts counting from zero. Does NOT touch sweepStartedAt[group] itself -
-     * chooseNextGroup() restamps it fresh the moment this group's next sweep actually begins
-     * (beginGroupCollection() for a multi-block group, or the first block request of a new
-     * round-robin lap), since only then is "now" meaningful as that sweep's start.
+     * average over the last sweepAverageWindow sweeps at debug level (a sensor sweep normally
+     * completes roughly every sensorMinIntervalMs, far too often for info - the periodic info-level
+     * summary is reportSweepStats() instead), feeds sweepStatsSinceReport for that summary, and
+     * clears blocksReadThisSweep so the NEXT sweep starts counting from zero. Does NOT touch
+     * sweepStartedAt[group] itself - chooseNextGroup() restamps it fresh the moment this group's
+     * next sweep actually begins (beginGroupCollection() for a multi-block group, or the first
+     * block request of a new round-robin lap), since only then is "now" meaningful as that sweep's
+     * start.
      * @param {'sensor'|'settings'} group
      */
     finishSweep(group) {
@@ -745,8 +760,34 @@ class IdmSession {
         const avgMs = Math.round(recent.reduce((sum, ms) => sum + ms, 0) / recent.length);
         // Short on purpose (see request_data_block()'s block-07 line for the same reasoning) -
         // this only ever logs once per completed sweep, never more often than that group's own
-        // sweep actually takes.
-        this.log.info(group + ' sweep done in ' + elapsedMs + 'ms (avg of last ' + recent.length + ': ' + avgMs + 'ms)');
+        // sweep actually takes. debug level only (see reportSweepStats() for the info-level
+        // summary) - too frequent for info in normal operation.
+        this.log.debug(group + ' sweep done in ' + elapsedMs + 'ms (avg of last ' + recent.length + ': ' + avgMs + 'ms)');
+
+        const stats = this.sweepStatsSinceReport[group];
+        stats.count++;
+        stats.totalMs += elapsedMs;
+        stats.minMs = stats.minMs == null ? elapsedMs : Math.min(stats.minMs, elapsedMs);
+        stats.maxMs = stats.maxMs == null ? elapsedMs : Math.max(stats.maxMs, elapsedMs);
+    }
+
+    /**
+     * Logs one small info-level summary of both groups' sweep activity over the last
+     * statsReportIntervalMs (fixed at 10 minutes - see the constructor), then resets
+     * sweepStatsSinceReport so the next summary only covers the following window. Started as a
+     * fixed interval by start() and cleared by stop(); this is the only info-level sweep-related
+     * log in normal operation now that finishSweep() logs at debug level.
+     */
+    reportSweepStats() {
+        const describe = (group) => {
+            const stats = this.sweepStatsSinceReport[group];
+            if (stats.count === 0) return group + ': 0 sweeps';
+            const avgMs = Math.round(stats.totalMs / stats.count);
+            return group + ': ' + stats.count + ' sweep(s), ' + avgMs + 'ms avg (min ' + stats.minMs + 'ms, max ' + stats.maxMs + 'ms)';
+        };
+        this.log.info('last ' + Math.round(this.statsReportIntervalMs / 60000) + 'min - ' + describe('sensor') + '; ' + describe('settings'));
+        this.sweepStatsSinceReport.sensor = { count: 0, totalMs: 0, minMs: null, maxMs: null };
+        this.sweepStatsSinceReport.settings = { count: 0, totalMs: 0, minMs: null, maxMs: null };
     }
 
     /**
@@ -1355,6 +1396,7 @@ class IdmSession {
         if (this.sendSetValueMessageTimeout1) { this.hooks.clearTimeout(this.sendSetValueMessageTimeout1); this.sendSetValueMessageTimeout1 = null; }
         if (this.sendSetValueMessageTimeout2) { this.hooks.clearTimeout(this.sendSetValueMessageTimeout2); this.sendSetValueMessageTimeout2 = null; }
         if (this.pollScheduleTimer) { this.hooks.clearTimeout(this.pollScheduleTimer); this.pollScheduleTimer = null; }
+        if (this.statsReportTimer) { this.hooks.clearInterval(this.statsReportTimer); this.statsReportTimer = null; }
         if (this.client) this.client.destroy();
     }
 }

package/lib/idm-session.test.js

@@ -233,6 +233,16 @@ describe('idm-session (connection + request/response state machine)', () => {
         expect(clock.countTimers()).to.equal(0);
     });
 
+    it('also clears the periodic statsReportTimer started by start() on stop()', () => {
+        connect();
+        expect(session.statsReportTimer, 'start() should have scheduled the periodic stats report').to.be.ok;
+
+        session.stop();
+
+        expect(session.statsReportTimer, 'statsReportTimer').to.not.be.ok;
+        expect(clock.countTimers()).to.equal(0);
+    });
+
     describe('sweep tracking reset on disconnect (see setConnected())', () => {
         it('resets both groups\' sweepStartedAt and cancels a pending idle recheck when the connection drops', () => {
             connect();
@@ -268,7 +278,7 @@ describe('idm-session (connection + request/response state machine)', () => {
             // idm701100 has 4 sensor blocks (07,09,0A,0B) - sweepIncomplete() keeps every turn on
             // sensor until all 4 have been read at least once (see the constructor's "sweep"
             // comment), regardless of settings' own due-ness in the meantime.
-            const sensorSweepLogs = () => log.info.getCalls().filter(c => /^sensor sweep done in /.test(c.args[0]));
+            const sensorSweepLogs = () => log.debug.getCalls().filter(c => /^sensor sweep done in /.test(c.args[0]));
 
             socket.emit('data', versionResponse('idm701100')); // sensor block 07 in flight (1st of 4)
 
@@ -309,7 +319,7 @@ describe('idm-session (connection + request/response state machine)', () => {
         it('logs the settings sweep the same way, and its rolling average reflects multiple completed sweeps', () => {
             session.version = 'idm701100'; // 5 settings blocks: 03,04,05,06,08
             const settingsBlocks = ['03', '04', '05', '06', '08'];
-            const settingsSweepLogs = () => log.info.getCalls().filter(c => /^settings sweep done in /.test(c.args[0]));
+            const settingsSweepLogs = () => log.debug.getCalls().filter(c => /^settings sweep done in /.test(c.args[0]));
 
             session.sweepStartedAt.settings = Date.now();
             clock.tick(1000);
@@ -328,7 +338,7 @@ describe('idm-session (connection + request/response state machine)', () => {
         it('caps the rolling average window at the last 10 completed sweeps', () => {
             session.version = 'idm701100';
             const settingsBlocks = ['03', '04', '05', '06', '08'];
-            const settingsSweepLogs = () => log.info.getCalls().filter(c => /^settings sweep done in /.test(c.args[0]));
+            const settingsSweepLogs = () => log.debug.getCalls().filter(c => /^settings sweep done in /.test(c.args[0]));
             const doSweep = (ms) => {
                 session.sweepStartedAt.settings = Date.now();
                 clock.tick(ms);
@@ -343,6 +353,58 @@ describe('idm-session (connection + request/response state machine)', () => {
         });
     });
 
+    describe('periodic sweep stats summary (info level, every statsReportIntervalMs, see reportSweepStats())', () => {
+        const statsLogs = () => log.info.getCalls().filter(c => /^last \d+min - /.test(c.args[0]));
+
+        it('is started by start() and logs nothing until statsReportIntervalMs has actually elapsed', () => {
+            session.start();
+            expect(session.statsReportTimer, 'start() should schedule the periodic report').to.be.ok;
+
+            clock.tick(session.statsReportIntervalMs - 1);
+            expect(statsLogs()).to.have.lengthOf(0);
+
+            clock.tick(1);
+            expect(statsLogs()).to.have.lengthOf(1);
+        });
+
+        it('reports "0 sweeps" for a group that never completed a sweep in the window', () => {
+            session.start();
+            clock.tick(session.statsReportIntervalMs);
+
+            expect(statsLogs()[0].args[0]).to.equal('last 10min - sensor: 0 sweeps; settings: 0 sweeps');
+        });
+
+        it('summarizes count/min/avg/max per group and resets the counters afterwards', () => {
+            session.version = 'idm701100'; // 5 settings blocks: 03,04,05,06,08
+            const settingsBlocks = ['03', '04', '05', '06', '08'];
+            session.start();
+
+            session.sweepStartedAt.settings = Date.now();
+            clock.tick(1000);
+            for (const b of settingsBlocks) session.recordBlockRead('settings', b);
+
+            session.sweepStartedAt.settings = Date.now();
+            clock.tick(3000);
+            for (const b of settingsBlocks) session.recordBlockRead('settings', b);
+
+            clock.tick(session.statsReportIntervalMs - 4000);
+            const logs = statsLogs();
+            expect(logs).to.have.lengthOf(1);
+            expect(logs[0].args[0]).to.equal('last 10min - sensor: 0 sweeps; settings: 2 sweep(s), 2000ms avg (min 1000ms, max 3000ms)');
+
+            // Counters must have been reset - a second full window with no further sweeps reports
+            // "0 sweeps" again rather than carrying the previous window's numbers forward.
+            clock.tick(session.statsReportIntervalMs);
+            expect(statsLogs()[1].args[0]).to.equal('last 10min - sensor: 0 sweeps; settings: 0 sweeps');
+        });
+
+        it('keeps firing every statsReportIntervalMs for as long as the session runs', () => {
+            session.start();
+            clock.tick(session.statsReportIntervalMs * 3);
+            expect(statsLogs()).to.have.lengthOf(3);
+        });
+    });
+
     describe('adaptive per-data-block content delay (hill-climbs a sweet spot, not "wait forever")', () => {
         const dataBlock07 = '00000000000000000000000000000000000000000B270000000000000000';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.idm-multitalent_002",
-  "version": "2.2.0",
+  "version": "2.2.1",
   "description": "Read and write values of a iDM heatpump with multitalent.002 control.",
   "author": {
     "name": "zloe",