Wrong number of Bytes for DATATYPE FLOAT32?

[toggm]

Based on the Implementation the DATATYPE FLOAT32 is represented by 2 Bytes and is packed using the pythons f format.

 FLOAT32 = ("f", 2)

Reading the pyhtons doc the pythons f format is defined by 4 bytes.
This leads to wrong register values as we the method convert_to_registers and indirectly the underlying pack method accepts bigger numbers than those which are reflected in the result.

Following small example shows the wrong behaviour:

"""."""

import numpy as np
from pymodbus.client import ModbusTcpClient

max_float = float(np.finfo(dtype=np.float32).max)
print(
    "Max",
    max_float,
    ModbusTcpClient.convert_to_registers(max_float, ModbusTcpClient.DATATYPE.FLOAT32),
)
print(
    "Max+1",
    max_float + 1,
    ModbusTcpClient.convert_to_registers(
        max_float + 1, ModbusTcpClient.DATATYPE.FLOAT32
    ),
)
print(
    "Max-1",
    max_float - 1,
    ModbusTcpClient.convert_to_registers(
        max_float - 1, ModbusTcpClient.DATATYPE.FLOAT32
    ),
)

# example with random bigger float numbers
float1 = -1.037543222108975e38
float2 = -1.03754321526517e38
reg1 = ModbusTcpClient.convert_to_registers(float1, ModbusTcpClient.DATATYPE.FLOAT32)
reg2 = ModbusTcpClient.convert_to_registers(float2, ModbusTcpClient.DATATYPE.FLOAT32)

val = ModbusTcpClient.convert_from_registers(reg1, ModbusTcpClient.DATATYPE.FLOAT32)
print("Value1", float1, reg1)
print("Value2", float2, reg2)
print("Re-converted", val)

with the following output as result:

Max 3.4028234663852886e+38 [32639, 65535]
Max+1 3.4028234663852886e+38 [32639, 65535]
Max-1 3.4028234663852886e+38 [32639, 65535]
Value1 -1.037543222108975e+38 [65180, 7350]
Value2 -1.03754321526517e+38 [65180, 7350]
Re-converted -1.0375432152651686e+38

Shouldn't the number of bytes accepted by the datatype be in sync with the struct format? In the example of a float32 this should be represented by the pyhton structs e format?

[janiversen]

Float32 contains as the name says 32bits which is 4 bytes (2 registers), so I am not sure where you see a problem ?

If you look at float64 it's the double size.

Python only knows float, and do not care about the size, but at protocol level we need to.

[janiversen]

Please also be aware that due to only having 32/64 bits converting to/from will often show differences on some distant decimal.

"e" is defined as 2 bytes not 4.

Could it be you are confusing registers with bytes, the functions are *_registers and they work on registers which is not the same as bytes.

[toggm]

@janiversen Thanks for the clarification. I was confused as the api doc on DATATYPE says:

Datatype enum (name and number of bytes), used for convert_* calls.

And in the case of a FLOAT32 this value is set to 2. So it should be names number of registers instead.

I still don't understand why the convertion to registers of a max_float32 and max_float32 results in the same register values?

[janiversen]

Text could be better, pull requests are welcome.

I really cannot help you with float conversions are not precise, if you do not understand how float is represented as bytes, that is standard computer science.

Just try to convert 2/3, that simple fraction, will always be different.