worder_order and byte_order FLOAT32

[patfrench]

Hello, I'm using Pymodbus 3.11.2. I've seen this question before but would like to get your opinion on it.

I'm receiving the following:

ReadHoldingRegistersResponse(dev_id=1, transaction_id=0, address=0, count=0, bits=[], registers=[12253, 50753], status=1, retries=0)

>>> [hex(12253), hex(50753)]
['0x2fdd', '0xc641']

To get the correct floating-point value, I had to use

>>> decoded_value = modbus_client.convert_from_registers([0xdd2f,0x41c6],data_type=modbus_client.DATATYPE.FLOAT32, word_order="little")
>>> print(decoded_value)
24.857999801635742

I had to reverse the order of my registers. My device is a standard industrial Modbus device. I have been told that the Modbus standard does not specify the byte order for values greater than 16 bits.

Is there another way to do this ?

Thank you

[janiversen]

?? it is quite normal to use from_registers I am not sure what your problem is.

Modbus specifies the byte order, but not the word (registers) order, for that reason to/from registers offer the option to swap the word order.

[patfrench]

Your library works perfectly, but before (I'll check tomorrow) I had access to byte_order

decoder = BinaryPayloadDecoder.fromRegisters(registers, byteorder=Endian.BIG, wordorder=Endian.BIG

My device works in little endian, but now I have to manipulate the bytes before using “convert_from_registers.”

Thank you

[patfrench]

Hello,
The processor is an STM32 and its memory is little endian by default.

Do you know where big-endian is specified in the modbus.org specifications?

Thank you

[janiversen]

Yes I know, please read the spec.

It does not matter what the processor are, the standard defines how the messages are build on the transmission medium. If your CPU uses little endian for byte order, then it need to convert. Just like a little endian client need to convert.

[janiversen]

Let me put that differently, pymodbus follow the modbus standard strictly....if you think pymodbus interprets the byte order wrongly, then please open an issue, where you point to the part of the modbus standard which pymodbus violates.

[patfrench]

Modbus_Application_Protocol_V1_1b3.pdf
4.2 Data Encoding

My question was a bit silly. I liked the answer lol

I am surprised for industrial devices with SIL3 software level, and it does not comply with the Modbus standard.

Thank you

[janiversen]

Well, according to your example, you applied word_order="little" and got the value you wanted, which is quite normal and within the standard. But you continue to talk about byte order which is the 2 bytes in each register. So it seems to me your device follows the modbus standard.

But you keep talking about byte order (16 bit solely), which would be violating the standard.

[patfrench]

I'm a little confused.
I have to reverse everything all the time.

def inverser_octets(liste):
    return [((val & 0xFF) << 8) | ((val >> 8) & 0xFF) for val in liste]

rr = client.read_holding_registers(52014, count=2, slave=1)
resultat = inverser_octets(rr.registers)
value_test = client.convert_from_registers(resultat, data_type=client.DATATYPE.UINT32, word_order="little")
print(f"MainBoardHW register 52014: {value_test}")

rr = client.read_holding_registers(52016, count=1, slave=1)
resultat = inverser_octets(rr.registers)
value_test = client.convert_from_registers(resultat, data_type=client.DATATYPE.UINT16, word_order="little")
print(f"MainBoardHWRev 52016: {value_test}")

If I had to use this before, (3.7.2)

resp = BinaryPayloadDecoder.fromRegisters(response.registers, byteorder=Endian.LITTLE,wordorder=Endian.LITTLE)

Is my device not compliant with the standard ?

thank you

[janiversen]

I think you are yourself, you have now presented to very different examples.

The text of the issue states you get the correct result by using from_registers with word_order little. This is a perfectly valid modbus device.

In your latest example, you introduce (some weird byte swapping, why not use the builtin python methods), which makes your device non complaint.

[patfrench]

I'm sorry, I'm not being very clear.

There are four of us testing, and we all use the minimalmodbus library. I'm the only one who switched to pymodbus

I know the expected result is 24.85

rr = client.read_holding_registers(1000, count=2, slave=1)
value_test = client.convert_from_registers(rr.registers, data_type=client.DATATYPE.FLOAT32, word_order="little")

value_test = -12396.6533203125

def inverser_octets(liste):
    return [((val & 0xFF) << 8) | ((val >> 8) & 0xFF) for val in liste]

rr = client.read_holding_registers1000, count=2, slave=1)
resultat = inverser_octets(rr.registers)
value_test = client.convert_from_registers(resultat, data_type=client.DATATYPE.FLOAT32, word_order="little")

value_test = 24.85