Cyclic Write (CW) does not work without Poll enabled — registers silently excluded

[mtibke]

Environment

• Adapter version: 8.0.3
• Node.js: v22.22.2
• js-controller: 7.0.7

Description

Cyclic Write (CW) on Holding Registers does not work when the "Poll" checkbox is disabled for the register. The CW write never fires, even though cw: true is set in the config. No error or warning is logged — the register is silently excluded.

Root Cause (Source Code Analysis)

Bug 1: Config filter excludes non-polled registers

In src/main.ts (index.ts compiled), the holdingRegs config is filtered before iterateAddresses() processes CW flags:

// ~line 1218
device.holdingRegs.config = (this.config.holdingRegs as Modbus.RegisterInternal[]).filter(
    e => e.poll && e.deviceId === deviceId,
);

Registers without poll: true are excluded from the config array entirely. When iterateAddresses() later processes the config to populate the cyclicWrite array, the CW register is simply not there.

Bug 2: ackObjects dependency prevents write even if filter is bypassed

In src/lib/Master.ts, the CW write method reads from ackObjects:

// ~line 643
if (this.ackObjects[id]) {
    await this.#writeValue(id, this.ackObjects[id].val);
}

ackObjects is only populated during the READ (poll) phase. If a register is never polled, ackObjects[id] is undefined, and the write is silently skipped.

Expected Behavior

A register with cw: true and poll: false should still be written cyclically. The adapter should:

1. Not filter out CW registers from the config just because poll is disabled
2. For CW-only registers (no poll), use the last setState value (from ioBroker state DB) instead of requiring a polled ackObjects entry

Steps to Reproduce

1. Add a Holding Register with CW enabled and Poll disabled
2. Set the ioBroker state value to any number (e.g., 1) with ack: true
3. Enable debug logging
4. Observe: no write appears in the debug log for that register

Use Case

This is critical for devices that require a periodic heartbeat write (e.g., Vestel EVC04 EV charger, which expects a write to register 6000 every few seconds to keep the TCP connection alive). CW would be the perfect built-in mechanism for this, but currently requires a workaround script.

Workaround

Use an ioBroker JavaScript script to periodically write the value:

setInterval(() => {
    setState('modbus.0.holdingRegisters.46001_Heartbeat', 1, false);
}, 5000);

[mtibke]

Update: v8.1.x fix attempt is incomplete

First of all: thanks @GermanBluefox for jumping on this so quickly. Three releases the day after the issue was opened is impressive.

Unfortunately the fix does not work yet in practice. Tested with iobroker.modbus@8.1.3 (depending on @iobroker/modbus@7.2.6, where the actual logic lives): Cyclic Write still does not fire for non-polled holding registers, even though the changelog mentions "Write cyclic values even if they are not polled".

What was fixed in v8.1.x

1. index.js line 1015: filter changed to (e.poll || e.cw) so cw-only registers are no longer dropped from device.holdingRegs.config. Confirmed: cyclicWrite[] array is correctly populated at runtime.
2. Master.js line 591: a fallback path was added that reads the value from the ioBroker state DB via getStateAsync(id) when ackObjects[id] is empty.

What is still broken

The new fallback path uses an id that is computed incorrectly:

// Master.js, around line 584
async #writeFloatsReg(fullId) {
    const obj = this.objects[fullId];
    if (obj?.native?.len) {
        const id = obj._id.substring(this.adapter.namespace.length + 1);
        ...
        const state = await this.adapter.getStateAsync(id);

The substring call assumes obj._id starts with <namespace>. and strips that prefix. But obj._id does NOT contain the namespace at all. Look at how this.objects[id] is initialized:

// index.js, around line 647
const id = `${this.namespace}.${regs[i].id || i}`;
this.objects[id] = {
    _id: regs[i].id,   // relative id only, e.g. "holdingRegisters.46001_Heartbeat"
    ...
};

So obj._id = "holdingRegisters.46001_Heartbeat" (32 chars, no namespace).
this.adapter.namespace.length + 1 = 9 (for namespace modbus.0).
substring(9) therefore returns "gisters.46001_Heartbeat" (the first 9 chars are silently chopped off).

getStateAsync("gisters.46001_Heartbeat") finds nothing and returns null, so the cyclic write never fires.

Diagnostic evidence

Live debug logging on a Vestel EVC04 wallbox setup (the original use case in this issue) with one register configured cw:true, poll:false:

[DEBUG-CW] holdingRegs.cyclicWrite=["modbus.0.holdingRegisters.46001_Heartbeat"] maxBlock=100
[DEBUG-WFR] fullId=modbus.0.holdingRegisters.46001_Heartbeat hasObj=true len=1 hasAck=false
[DEBUG-WFR2] id=gisters.46001_Heartbeat
              state=null
              fullStateFromForeign={"val":1,"ack":true,...}

getStateAsync(id) with the truncated id returns null. getForeignStateAsync(fullId) with the proper path returns the actual value {val:1, ack:true}.

Suggested fix

#writeFloatsReg already receives the correctly-namespaced fullId. The simplest fix is to use it directly for the state lookup and for #writeValue (which also needs the full id, since this.objects is keyed by full id):

async #writeFloatsReg(fullId) {
    const obj = this.objects[fullId];
    if (obj?.native?.len) {
        if (!this.modbusClient || !this.connected || this.isStop) {
            throw new Error('client disconnected');
        }
        const id = obj._id; // relative id, used only for ackObjects lookup
        if (this.ackObjects[id]) {
            await this.#writeValue(fullId, this.ackObjects[id].val);
        } else {
            const state = await this.adapter.getForeignStateAsync(fullId);
            if (state?.val !== undefined && state?.val !== null) {
                await this.#writeValue(fullId, state.val);
            }
        }
    }
}

Verified locally on iobroker.modbus@8.1.3: with this patch, the wallbox heartbeat register gets a write every 5s and the TCP socket stays open indefinitely. Without the patch, the socket drops every 60s due to the wallbox failsafe.

Side note: state-reset issue affects manual writes

For completeness: Master.js line 833 also has a related issue. After a manual setState(id, val, false) (ack:false) on a cw-only holding register, write() resets the state to null:

await this.adapter.setState(id, this.ackObjects[_id] ? this.ackObjects[_id].val : null, true);

Because ackObjects[_id] is empty (poll:false means no read-back), the state gets nulled. Subsequent cyclic writes then have nothing to send. Not strictly a bug if the cyclic write fix above lands and users prime the state with ack:true, but worth flagging.