Run SerialServer only with custom PDU

[lovetheguitar]

Hello,

first of all thanks for the great library! 😺

I use version 3.10 and start a server like this:

    devices = {  # create the six devices (channels) we want to emulate
        address: datastore.ModbusDeviceContext(di=None, co=None, hr=None, ir=None)
        for address in range(1, 7)
    }
    server_context = datastore.ModbusServerContext(devices=devices, single=False)  # type: ignore[no-untyped-call]
    
    _log.debug(f"Starting Modbus Server on {port=}.")
    server.StartSerialServer(
        context=server_context,
        port=port,
        framer="rtu",
        stopbits=1,
        bytesize=8,
        parity="N",
        baudrate=115200,
        timeout=1,
        custom_pdu=[CustomModbusRequest],
    )

In CustomModbusRequest I register my custom function code and use it to handle a separate protocol which is just using modbus as a transport protocol.

For single requests and not a lot of data being sent everything works well. Only if a lot of requests with a large amount of data are being sent problems occur.
Then the modbus server sometimes detects one of the default function codes and acts upon it and thus bricking the communication (see log message below).

2025-08-07 17:55:35.157 [DEBUG] pymodbus.logging: decoded PDU function_code(2 sub -1) -> ReadDiscreteInputsRequest(dev_id=0, transaction_id=0, address=2571, count=162, bits=[], registers=[], status=1retries=0)  (decoders.py:113)

My current hack is to disable the lookup of the "default" function codes here

pymodbus/pymodbus/pdu/decoders.py

Lines 75 to 82 in b9731ec

	if func_code & 0x80:
	return base.ExceptionResponse
	if func_code == 0x2B: # mei message, sub_function_code is 1 byte
	sub_func_code = int(data[2])
	return self.sub_lookup[func_code].get(sub_func_code, None)
	if func_code == 0x08: # diag message, sub_function_code is 2 bytes
	sub_func_code = int(data[3])
	return self.sub_lookup[func_code].get(sub_func_code, None)

.

Is there any supported way to do this? If not could we add one?

Thanks for your time!

[janiversen]

v3.10 is a non functional release, please upgrade to v3.11.

When you register a request/response the function code + sub function code in the class are appended to the lookup tables. . You can create new function codes or overwrite existing ones, and if overwriting existing ones your class should be called instead of the default one. Since the registration updates the lookup tables, that is the supported way.

You do not share your customRequest so I cannot see if it is a new function code, or you inherit from an existing one.

I assume you are aware that "large amounts of data" are limited be fit within the 255byte frame size ? If you try send send a frame bigger than 255bytes, then you will encounter problems.

What is really disturbing is that it only happens under load...that seems like a concurrency problem, but since the lookup table is static I cannot see what could cause a wrong lookup.

So in total please attach at least the top part of your customRequest, together with a debug log (you can use the Pymodbus call to activate debugging), allowing me to see what is happening and analyze what the problem could be.

[lovetheguitar]

With larger frames I mean like 100 bytes or 200, never more than the limit (not even close to). Just some simple messages of a few bytes work fine, but when sending larger ones like in the logs above, stuff blows up.

Since your problem is reproducible, why not try to lower the speed to e.g. 19.2 and see if the problem is solved.

In my testing now I run at 19.2k baudrate. Stuff sadly still fails and I still get quite a lot of frame check errors.

That depend how you define your custom component, some PDU´s have a length field, some have fixed length, a few have a more complex length calculation.....that is all something that is defined in the PDU.

Interesting, is that related to rtu_frame_size?
From my implementation above rtu_frame_size = 8 # todo: which? The messages in the protocol can have sizes between a few bytes and up to 100 bytes (configured now).

I think I just encountered a new error: my custom function code is recognized, but seemingly only the decode method gets called but not the update_datastore method (in which I process my custom protocol stuff). I got a log message at the start of both methods, and only the one in decode was logged.

2025-08-11 13:05:22.580 [   DEBUG] pymodbus.logging: decoded PDU function_code(66 sub -1) -> CustomModbusRequest(dev_id=1, transaction_id=0, address=0, count=0, bits=[], registers=[], status=1retries=0)  (decoders.py:113)

[janiversen]

rtu_frame_size is for fixed size PDUs. I suggest you take a look at the different PDUs. you cannot use rtu_frame_size for variable frame sizes, so I wonder how you configured that.

update_datastore is always called, but only in the request not response.

Looks a but like you custom pdu is not defined correctly, that will have all kinds of side effects !!!

Did you try with the lower bps I suggested, to see if the load error is related to that ?

[lovetheguitar]

rtu_frame_size is for fixed size PDUs. I suggest you take a look at the different PDUs. you cannot use rtu_frame_size for variable frame sizes, so I wonder how you configured that.
Looks a but like you custom pdu is not defined correctly, that will have all kinds of side effects !!!

It is implemented as shown in #2719 (reply in thread).
I looked through the repository and did not understand how to set the frame size dynamically. Would you have any hints or links to help me out?

update_datastore is always called, but only in the request not response.

Yes that's what I experienced so far, but the lack of the log messages (initial one + of all the processing I usually do in there) signify that it was somehow not called?

Did you try with the lower bps I suggested, to see if the load error is related to that ?

Yes I run everything at 19.2k baudrate now.

[lovetheguitar]

Uh oh, I figured out how to set it dynamically. I added a calculateRtuFrameSize method to my CustomModbusRequest:

@classmethod
def calculateRtuFrameSize(cls, data: bytes) -> int:
    """Calculate the size of a PDU."""
    modbus_header_size = 2  # address (1) + function code (1)
    modbus_crc_size = 2  # CRC (2)
    modbus_overhead_size = modbus_header_size + modbus_crc_size
    if len(data) < modbus_header_size + HEADER_SIZE:
        return 8

    try:
        # read packet_size from the header (skipping Modbus address & function code)
        (packet_size,) = struct.unpack_from("<H", data, modbus_header_size)

        # reject absurd sizes
        if packet_size < HEADER_SIZE or packet_size > 255:
            _log.warning(f"Unrealistic {packet_size=}, defaulting to 8.")
            return 8

        frame_size = packet_size + modbus_overhead_size
        _log.debug(f"Calculated RTU {frame_size=}")
        return frame_size

    except struct.error as e:
        _log.debug(f"Failed to unpack packet size, defaulting to 8 ({e}).")
        return 8

Need to do some more testing, but so far it looks like that got rid of all the Frame check failed errors. 🥳

Going to investigate further if that now solves all my problems and I can drop my dirty little hack.