[Bug]: Cannot define DO and RO for more than 16 channels (coil/register overflow issue)

[kratochvil01]

Prerequisites

• I am running the latest Evok version
• I have searched other issues

Describe the bug

Currently, EVOK does not support defining Digital Outputs (DO) or Relay Outputs (RO) for more than 16 channels.

The implementation uses coils for writing and registers for reading, but it fails to handle cases where the channel index exceeds 16. In such situations, the logic does not properly manage the overflow into the next register/coil block, making it impossible to work with devices that expose more than 16 outputs.

Evok log

No response

Steps to reproduce

1. Configure a device with more than 16 DO/RO channels.
2. Attempt to access channel 17 (or higher).
3. Observe that the operation fails, as EVOK does not process the overflow into the next register.

Expected behavior

EVOK should handle more than 16 DO/RO channels correctly by managing the overflow into subsequent coil/register addresses.

Actual behavior

Attempts to use channels beyond 16 fail, as EVOK only considers the first register/coil block.

[kratochvil01]

Proposed Solution

It is necessary to add register iteration when creating RO and DO devices.

This iteration must always be performed at the 16th channel.
However, the relay name must still correspond to the channel number.
This will ensure the functionality of DO and RO with more than 16 channels.

[cleveHEX]

duplicate of #195 ?

[kratochvil01]

duplicate of #195 ?

It seems so.
The issue you mention describes a specific error on a specific device. Here is a general description of how and when the error occurs.

I suggest set up the issue you mention as the parent of this one.

[Baggz]

@kratochvil01 @cleveHEX

Any chance of this getting fixed? This seems like a critical bug.

Had to install the latest version of Evok on Neuron M403 which rendered the whole device useless... Instead of 28 ROs it showed only 16 visible ROs. Worse the _01…_12 ROs were silently driving coils 116–127 (relays 17–28), not 1–12. The same latent bug exists in the DO and LED parsers.

Please have a look at the patch below.

diff --git a/evok/modbus_slave.py b/evok/modbus_slave.py
index 72dd1ce..eb867a6 100644
--- a/evok/modbus_slave.py
+++ b/evok/modbus_slave.py
@@ -289,6 +289,24 @@ class Board(object):
         self.modbus_slave: ModbusSlave = modbus_slave
         self.major_group = major_group
         self.modbus_address = modbus_address
+        # Running per-devtype channel offset, used to number consecutive
+        # feature blocks of the same type without colliding on circuit names
+        # (e.g. M403 board 2 defines two RO blocks of 16 + 12 = 28 relays).
+        self.feature_index_offsets = {}
+
+    def _next_start_index(self, m_feature, devtype):
+        """Return the circuit-name offset for the next feature block.
+
+        Honors an explicit ``start_index`` from the HW definition (as the DI
+        parser already does); otherwise continues numbering after the channels
+        of the same ``devtype`` already created for this board. This lets a
+        device split its outputs into several feature blocks (needed for more
+        than 16 DO/RO channels) without the per-block counter resetting to 1
+        and overwriting earlier channels. See GitHub issue #209.
+        """
+        if 'start_index' in m_feature:
+            return m_feature['start_index']
+        return self.feature_index_offsets.get(devtype, 0)
 
     async def set(self, alias=None):
         if not alias is None:
@@ -335,32 +353,38 @@ class Board(object):
             counter+=1
 
     def parse_feature_ro(self, max_count, m_feature):
+        start_index = self._next_start_index(m_feature, RO)
         counter = 0
         while counter < max_count:
             board_val_reg = m_feature['val_reg']
-            _r = Relay("%s_%02d" % (self.circuit, counter + 1), self, m_feature['val_coil'] + counter, board_val_reg, 0x1 << (counter % 16),
-                      major_group=self.major_group, legacy_mode=self.legacy_mode)
+            _r = Relay("%s_%02d" % (self.circuit, counter + 1 + start_index), self,
+                       m_feature['val_coil'] + counter, board_val_reg + (counter // 16),
+                       0x1 << (counter % 16),
+                       major_group=self.major_group, legacy_mode=self.legacy_mode)
             self.__register_eventable_device(_r)
             Devices.register_device(RO, _r)
             counter += 1
+        self.feature_index_offsets[RO] = start_index + max_count
 
     def parse_feature_do(self, max_count, m_feature):
+        start_index = self._next_start_index(m_feature, DO)
         counter = 0
         while counter < max_count:
-            board_val_reg = m_feature['val_reg']
+            board_val_reg = m_feature['val_reg'] + (counter // 16)
+            circuit = "%s_%02d" % (self.circuit, counter + 1 + start_index)
             # Hard PWM
             if m_feature.get('pwm_reg') and m_feature.get('pwm_ps_reg') and m_feature.get('pwm_c_reg'):
                 if not self.legacy_mode:
-                    _r = DigitalOutput("%s_%02d" % (self.circuit, counter + 1), self, m_feature['val_coil'] + counter, board_val_reg, 0x1 << (counter % 16),
+                    _r = DigitalOutput(circuit, self, m_feature['val_coil'] + counter, board_val_reg, 0x1 << (counter % 16),
                                        major_group=self.major_group, pwmcyclereg=m_feature['pwm_c_reg'], pwmprescalereg=m_feature['pwm_ps_reg'], digital_only=True,
                                        pwmdutyreg=m_feature['pwm_reg'] + counter, modes=m_feature['modes'], legacy_mode=self.legacy_mode)
                 else:
-                    _r = DigitalOutput("%s_%02d" % (self.circuit, counter + 1), self, m_feature['val_coil'] + counter, board_val_reg, 0x1 << (counter % 16),
+                    _r = DigitalOutput(circuit, self, m_feature['val_coil'] + counter, board_val_reg, 0x1 << (counter % 16),
                                        major_group=self.major_group, pwmcyclereg=m_feature['pwm_c_reg'], pwmprescalereg=m_feature['pwm_ps_reg'], digital_only=True,
                                        pwmdutyreg=m_feature['pwm_reg'] + counter, modes=m_feature['modes'], legacy_mode=self.legacy_mode)
             # Soft PWM
             elif m_feature.get('pwm_reg') and m_feature.get('pwm_preset_reg') and m_feature.get('pwm_cpres_reg'):
-                _r = DigitalOutput("%s_%02d" % (self.circuit, counter + 1), self, m_feature['val_coil'] + counter, board_val_reg, 0x1 << (counter % 16),
+                _r = DigitalOutput(circuit, self, m_feature['val_coil'] + counter, board_val_reg, 0x1 << (counter % 16),
                                    major_group=self.major_group, pwmpresetreg=m_feature['pwm_preset_reg'],
                                    pwmcustompresc=m_feature['pwm_cpres_reg'], digital_only=True,
                                    pwmdutyreg=m_feature['pwm_reg'] + counter, modes=m_feature['modes'], legacy_mode=self.legacy_mode)
@@ -369,16 +393,19 @@ class Board(object):
             self.__register_eventable_device(_r)
             Devices.register_device(DO, _r)
             counter += 1
+        self.feature_index_offsets[DO] = start_index + max_count
 
     def parse_feature_led(self, max_count, m_feature):
+        start_index = self._next_start_index(m_feature, LED)
         counter = 0
         while counter < max_count:
-            board_val_reg = m_feature['val_reg']
-            _led = ULED("%s_%02d" % (self.circuit, counter + 1), self, counter, board_val_reg, 0x1 << (counter % 16),
+            board_val_reg = m_feature['val_reg'] + (counter // 16)
+            _led = ULED("%s_%02d" % (self.circuit, counter + 1 + start_index), self, counter, board_val_reg, 0x1 << (counter % 16),
                         m_feature['val_coil'] + counter, major_group=self.major_group, legacy_mode=self.legacy_mode)
             self.__register_eventable_device(_led)
             Devices.register_device(LED, _led)
             counter+=1
+        self.feature_index_offsets[LED] = start_index + max_count
 
     def parse_feature_owpower(self, m_feature):
         _owpower = OwPower(f"{self.circuit}", self, m_feature['val_coil'], major_group=self.major_group)