Modbus coding issues

[5546doug]

I need help with modbus coding . I need to change a 4 hex to a float.
The code I have uses no floats.

[sonofcy]

Post your code in code tags.

[sterretje]

Topic moved. Please do not post in "Uncategorized"; see the sticky topics in Uncategorized - Arduino Forum.

[StefanL38]

finally I found a useful application where AI can support a forum like the arduino forum that is working with real humans.

Make users see that posting a precise and specific question combined with the complete sketch will accelerate solving their problem.

@5546doug

I put your very foggy question into AI deepseek
it answered with a lot of text.

Now you have two choices:
taking 20 minutes reading the answer and then taking another 180 minutes to understand it

or taking just a 1/20th of the time by taking 5 minutes to post your complete sketch as a code-section and taking another 5 minutes to post datasheets and links to the detail information of the other device you want to connect with.

Make experienced users help: two ways to quickly post code as a code-section

Hi newcomer, This thread wants to show you how you can speed-up getting helpful answers with small effort. If you manage at least to post this way. You have the sympathy of the experienced users. If you are willing to invest another 20 minutes these 20 minutes extra-time will save you a minimum of 200 minutes to finish your project. always post your full sketch. As a code-section from the very first to the very last line A code-section has a small height => keeps your posting "short" but e…

here is the covering all possabilities answer from deepseek

deep seek write me a code that converts 4 bytes received from modbus into a float

deepseeks answer
Okay, I need to write a Python function that converts 4 bytes received from Modbus into a float. Let me think about how Modbus handles data and how floating-point numbers are represented.

First, Modbus typically sends data in 16-bit registers. So, if we're dealing with a 32-bit float, that would be two registers, each consisting of 2 bytes. Therefore, 4 bytes total. The user mentioned receiving 4 bytes, so maybe those are already combined from two registers.

Next, the byte order. Modbus can use different byte orders depending on the system. Common ones are big-endian or little-endian, and sometimes there's a mix where the word order is different from the byte order. For example, the bytes within each register might be big-endian, but the registers themselves could be in reverse order. So I need to consider the endianness.

The user didn't specify the endianness, so maybe the function should take that into account as a parameter. Let me recall the possible formats. For a 32-bit float, there are a few possibilities:

1. Big-endian (ABCD)

2. Little-endian (DCBA)

3. Big-endian byte swap (BADC)

4. Little-endian byte swap (CDAB)

Wait, sometimes in Modbus, the high and low words are swapped. For example, if the float is stored as two 16-bit registers, the first register might be the high-order bytes and the second the low, or vice versa. So combining the two words in the wrong order would give incorrect results.

So the steps would be:

1. Take the 4 bytes as input, possibly arranged in a specific order.

2. Depending on the endianness and word order, rearrange the bytes into the correct order.

3. Pack the bytes into a binary format.

4. Unpack them as a float.

In Python, the struct module can handle packing and unpacking. The struct.unpack function requires a format string. For example, '>f' is big-endian float, '<f' is little-endian.

So the function should take the bytes and the byte order. Let's think about parameters. The user might pass a list of four bytes, or two registers (each being a 16-bit value). Wait, the question says "4 bytes received from Modbus". So maybe the input is a byte array of length 4. But in Modbus, when reading registers, each register is 16 bits, so two bytes. So to get 4 bytes, you read two registers. But depending on the device, the order of the registers could be high word first or low word first. For example, if the float is split into two 16-bit registers, the order of these two registers matters.

Wait, perhaps the 4 bytes are already in the correct order, but maybe the endianness of the bytes within each 16-bit register is different from the overall 32-bit float. For example, each 16-bit register is big-endian, but the two registers are in the wrong order. So combining them directly would require reordering.

Alternatively, maybe the bytes are in the order that when combined, they form the correct 32-bit representation. But the user might need to specify whether it's big-endian or little-endian.

So the function needs to handle different byte orders. Let's outline possible scenarios:

Case 1: The 4 bytes are in the order that, when read as a 32-bit big-endian, form the correct float. So bytes [b3, b2, b1, b0] (if the original float is big-endian, then the bytes are ordered from most significant to least significant). Wait, struct.pack('>f', value) would give the bytes in big-endian order. For example, if the float is 1.0, the bytes would be 0x3f 0x80 0x00 0x00 in big-endian. So the first byte is 0x3f, then 0x80, etc.

But if the Modbus sends the two registers as [0x3f80, 0x0000], which is two 16-bit registers, each in big-endian. Then the bytes are 0x3f, 0x80, 0x00, 0x00. So combining them as a 32-bit big-endian gives the correct float.

However, if the device sends the registers in reverse order, like [0x0000, 0x3f80], then the bytes would be 0x00, 0x00, 0x3f, 0x80. If we read those as big-endian 32-bit, that would be 0x00003f80, which is a different float.

So the user might need to swap the words (the two 16-bit parts) before combining into 32-bit. Therefore, the function should have a parameter to indicate whether to swap the words.

Alternatively, the function can accept the two registers (each as integers) and then handle the conversion, but the question says the input is 4 bytes. Hmm.

But the user says "4 bytes received from Modbus". Let's assume that the 4 bytes are in the order that they were received from the Modbus response. For example, reading two registers gives four bytes in the order [A, B, C, D], where each register is two bytes. So the first register's high byte is A, low byte B, and the second register's high byte C, low byte D. Then the 32-bit value would be ABCD. But if the float is stored as CDAB, then we need to reorder.

Alternatively, perhaps the registers are stored in little-endian word order, so the first register is the lower 16 bits. So the bytes would be [C, D, A, B], which is different.

So, possible combinations:

• Byte order within each register (big-endian or little-endian)

• Word order (whether the first register is high or low)

But in Modbus, the standard is that each register is big-endian. So each 16-bit register is sent as high byte first. So when you read two registers, the bytes are [A, B, C, D], where A and B are the first register (high byte, low byte), and C and D are the second register. But the overall 32-bit value could be stored in the device as ABCD, or as CDAB (if the device stores the 32-bit value in little-endian word order). So to handle that, the user might need to swap the two registers.

So, for example, if the device's 32-bit float is stored as two registers in big-endian order (high word first, then low word), then the bytes are ABCD. If it's stored as little-endian word order (low word first), the bytes are CDAB.

Therefore, the code needs to account for whether the words are swapped.

But the user's input is 4 bytes. So perhaps the function should take those 4 bytes and a byte order parameter that indicates how to interpret them.

So the function could have parameters like byte_order, which could be 'big' or 'little', but since there are more possibilities (like middle-endian), perhaps using the struct module's format characters would be better. For example, '>f' for big-endian, '<f' for little-endian, or maybe other formats.

Wait, but when dealing with Modbus, sometimes the word order is swapped. For example, if the 4 bytes are ordered as [B, A, D, C], that's a different case. So perhaps the code should allow the user to specify the endianness of the 32-bit value.

Alternatively, perhaps the user can pass the two registers (as integers) and the code will combine them into the 4 bytes with possible word swap.

But the user's input is 4 bytes, so maybe it's a byte array. Let's proceed.

So the plan is:

1. Take the 4-byte array.

2. Depending on the endianness and word order, rearrange the bytes into the correct order.

3. Use struct.unpack to convert the bytes into a float.

Possible endianness cases:

Case 1: Big-endian (ABCD) – no swapping needed. Use '>f'.

Case 2: Little-endian (DCBA) – reverse all bytes. Use '<f'.

Case 3: Big-endian byte swap within words (BADC) – swap the two 16-bit words. For example, if the bytes are [A, B, C, D], then BADC would be [B, A, D, C]. Wait, no. Wait, if the two words are swapped, then the first 16-bit word is CD and the second is AB. So the bytes would be [C, D, A, B]. Wait, this is getting complicated.

Alternatively, common scenarios are:

• Modbus transmits the two registers in the same order as the 32-bit float's bytes. So, if the float is stored in big-endian, then the first register is the high 16 bits, second the low. So bytes are [A, B, C, D], which when combined as ABCD, becomes the 32-bit float.

Alternatively, if the float is stored in big-endian but the words are swapped (low word first), then the bytes would be [C, D, A, B]. So to get ABCD, you need to swap the two words.

Wait, let's take an example. Suppose the 32-bit float in big-endian is bytes A, B, C, D. Then the two registers (each 16 bits) would be (A << 8 | B) as the first register (high word) and (C << 8 | D) as the second register (low word). So the bytes in order are [A, B, C, D]. But if the device stores the 32-bit value in little-endian, then the bytes would be D, C, B, A. But when split into two 16-bit registers, each stored as big-endian, the first register is DC, and the second is BA. So the bytes would be D, C, B, A. If we read those as two 16-bit registers and combine them as DCBA, that's the little-endian 32-bit float.

Alternatively, if the device stores the 32-bit value as two 16-bit registers in little-endian word order (low word first), but each register is stored as big-endian, then the bytes would be C, D, A, B. Because the low word (CD) comes first, and each word is stored as big-endian (C is high byte, D low byte). So combining them as CDAB would be the correct 32-bit value. But if the actual float is stored in big-endian format, then CDAB would be incorrect and need to be swapped to ABCD.

This is getting a bit confusing. Maybe the best approach is to create a function that allows the user to specify the byte order, including whether to swap the words.

Wait, but the struct module can handle different byte orders. For example, if the 4 bytes are in the order that corresponds to '>f' (big-endian), then struct.unpack('>f', bytes) would work. If they are in the order of little-endian, then '<f'. But sometimes, the two 16-bit words are swapped. For example, if the bytes are [C, D, A, B], which is the low word followed by the high word, each in big-endian. Then, the correct approach is to swap the two words, resulting in [A, B, C, D], then use '>f'.

So, perhaps the function can take a parameter indicating the endianness and whether to swap the words. For example, 'big' for big-endian, 'little' for little-endian, 'big_word_swap' for when the words are swapped in a big-endian context.

Alternatively, the user can pass the byte_order as a format string for struct.unpack, but they have to rearrange the bytes accordingly.

So the steps in code would be:

• Receive the 4-byte array.

• Depending on the endianness and word order, rearrange the bytes into the correct order.

• Use struct.unpack with the appropriate format to get the float.

For example, if the bytes are [A, B, C, D], and the desired format is big-endian, then the bytes are correct. If the words are swapped, the bytes are [C, D, A, B], and need to be reordered to [A, B, C, D].

Wait, no. If the 32-bit value is stored as two registers with the first being the low word (little-endian word order), then the bytes would be [C, D, A, B], which when combined as CDAB would be the 32-bit value. To convert that to the correct float, we need to swap the words to get ABCD, then use '>f' to unpack.

So the code would need to swap the first two bytes with the last two bytes.

So, possible code steps:

If the word order is swapped (i.e., the two 16-bit registers are in reverse order), then swap the first two bytes with the last two bytes.

Wait, no. Let's take an example. Suppose the 32-bit value is 0x12345678 in big-endian. The bytes are [0x12, 0x34, 0x56, 0x78]. If stored as two 16-bit registers in big-endian, the registers are 0x1234 and 0x5678. If the device instead stores them in reverse order (low word first), the registers would be 0x5678 and 0x1234, so the bytes are [0x56, 0x78, 0x12, 0x34]. So the 4-byte sequence is 0x56, 0x78, 0x12, 0x34. To get back to the original 0x12345678, we need to swap the first two bytes with the last two bytes, resulting in 0x12, 0x34, 0x56, 0x78. Then struct.unpack('>f', bytes) would work.

So in code, if the words are swapped, we can reverse the order of the two 16-bit parts. So the 4-byte array is split into two 16-bit parts, swap them, then concatenate.

But how to do that in Python with a byte array?

For example, if bytes are [0x56, 0x78, 0x12, 0x34], swapping the words would split into [0x56, 0x78] and [0x12, 0x34], then swap to [0x12, 0x34, 0x56, 0x78].

So in code:

swapped_bytes = bytes[2:] + bytes[:2]

Then, struct.unpack('>f', swapped_bytes) would give the correct value.

Therefore, the function can take a parameter indicating whether to swap the words.

Putting it all together, the function can be something like:

def modbus_bytes_to_float(bytes, byte_order='big', word_order='big'):

process based on byte_order and word_order

but perhaps it's easier to take a format string and a swap flag.

But maybe it's better to handle common cases. For example:

Common cases in Modbus:

1. Modbus uses big-endian for registers, and the 32-bit value is stored in big-endian with the high word first. So the bytes are [A, B, C, D]. Use '>f'.

2. Modbus uses big-endian for registers, but the 32-bit value is stored with low word first. So the bytes are [C, D, A, B]. Swap the words to get [A, B, C, D], then use '>f'.

3. The 32-bit value is stored as little-endian, so the bytes are [D, C, B, A]. Use '<f'.

4. The 32-bit value is little-endian but stored as two registers in reverse order. So bytes [B, A, D, C]. Swap the words to [D, C, B, A], then use '<f'.

But this can get complex. To simplify, perhaps the function can accept a 'byte_order' parameter (like 'big', 'little', 'big_word_swap', 'little_word_swap').

Alternatively, a better approach is to allow the user to specify the endianness and whether to swap the words.

So here's a possible approach:

def modbus_bytes_to_float(data, byte_order='big', word_order='big'):

"""

Converts 4 bytes to a float.

data: bytes (length 4)

byte_order: 'big' or 'little' (endianness of the 32-bit float)

word_order: 'big' (high word first) or 'little' (low word first)

"""

Check if word order requires swapping

if word_order == 'little':

Swap the two 16-bit words

data = data[2:] + data[:2]

Now handle byte order

if byte_order == 'big':

format_str = '>f'

else:

format_str = '<f'

return struct.unpack(format_str, data)[0]

Wait, but in this case, the 'word_order' parameter indicates whether the first word is high (big) or low (little). So if the data is received with low word first (little word order), we swap the words. Then, the byte_order determines how the resulting bytes are interpreted as a float.

But wait, after swapping the words (if needed), the bytes are ordered as high word followed by low word, but each word is in the original byte order. Wait, perhaps this isn't the case. Let's test with an example.

Example:

Suppose the original 32-bit float is 0x12345678 (big-endian). Bytes are [0x12, 0x34, 0x56, 0x78].

If the word_order is 'little', then the data is stored as [0x56, 0x78, 0x12, 0x34]. So when we swap the words (since word_order is 'little'), we get back [0x12, 0x34, 0x56, 0x78]. Then, using byte_order 'big', we unpack to the correct float.

But wait, how does the byte_order parameter affect the result? Let's say the data after word swap is [0x12, 0x34, 0x56, 0x78]. If byte_order is 'big', struct.unpack('>f') will correctly interpret this as big-endian. If the byte_order is 'little', it would interpret as little-endian, which is 0x78563412, which is different.

So the function allows specifying the endianness of the 32-bit float after any necessary word swapping.

But maybe the parameters should be separate. For example, some devices store the 32-bit value with words swapped, but each word is in big-endian. So the function can first swap the words if needed, then pack into bytes and unpack with the given byte order.

Alternatively, perhaps the 'byte_order' refers to the endianness of the entire 32-bit value. For example, if the 32-bit value is in big-endian, but split into two big-endian words, but stored in the wrong order (low word first), then you need to swap the words first and then treat the combined bytes as big-endian.

So the function above swaps the words if word_order is 'little', then unpacks according to the byte_order.

But I'm not sure. Let's test with an example.

Case 1: data is [0x12, 0x34, 0x56, 0x78], byte_order 'big', word_order 'big' → no swap. struct.unpack('>f') → correct.

Case 2: data is [0x56, 0x78, 0x12, 0x34], word_order 'little' → swap to [0x12, 0x34, 0x56, 0x78], then '>f' → correct.

Case 3: data is [0x78, 0x56, 0x34, 0x12], byte_order 'little', word_order 'big' → no swap. struct.unpack('<f') → correct.

Case 4: data is [0x34, 0x12, 0x78, 0x56], byte_order 'little', word_order 'little' → swap to [0x78, 0x56, 0x34, 0x12], then '<f' → correct.

This seems to work.

But the function's parameters may need clearer names. Perhaps word_order could be called 'word_swap' as a boolean. For example:

def modbus_bytes_to_float(data, byte_order='big', swap_words=False):

if swap_words:

data = data[2:] + data[:2]

format_str = '>' if byte_order == 'big' else '<'

return struct.unpack(format_str + 'f', data)[0]

But this way, if the user knows that the words are swapped (i.e., the two registers are in reverse order), they can set swap_words=True.

This is perhaps a better approach, as the swap_words parameter is a boolean indicating whether to swap the two 16-bit words.

So, for example, if the data comes as two registers where the first is the low word and the second is the high word, then swap_words=True would correct that.

Another example: suppose the 32-bit float is stored as two registers in big-endian, but the order of the registers is reversed. So the data bytes are [C, D, A, B]. By setting swap_words=True, the code would swap the first two bytes (C, D) with the last two (A, B), resulting in [A, B, C, D], then unpack as big-endian.

Yes, that makes sense.

So the function can be written with parameters for byte_order and swap_words.

So the steps are:

1. Check if swap_words is True. If so, swap the first two bytes with the last two.

2. Use struct.unpack with the appropriate byte_order to convert the bytes to float.

Now, in Python, struct.unpack requires a bytes object. So the input data must be a bytes-like object of length 4.

Putting it all together:

import struct

def modbus_bytes_to_float(data, byte_order='big', swap_words=False):

if len(data) != 4:

raise ValueError("Data must be exactly 4 bytes long.")

if swap_words:

Swap the two 16-bit words

data = data[2:] + data[:2]

Determine the format string

fmt = '>' if byte_order == 'big' else '<'

Unpack the bytes to float

return struct.unpack(fmt + 'f', data)[0]

Testing this function:

Test case 1: big-endian, no swap.

data = bytes([0x3f, 0x80, 0x00, 0x00]) # 1.0 in big-endian

result = modbus_bytes_to_float(data, 'big', False)

print(result) # Should be 1.0

Test case 2: big-endian, with word swap.

Original data is [0x00, 0x00, 0x3f, 0x80]. After swap, becomes [0x3f, 0x80, 0x00, 0x00]. Then unpack as big-endian, which is 1.0.

Test case 3: little-endian, no swap.

data = bytes([0x00, 0x00, 0x80, 0x3f]) # 1.0 in little-endian

result = modbus_bytes_to_float(data, 'little', False)

print(result) # 1.0

Test case 4: little-endian with word swap.

Original data is [0x80, 0x3f, 0x00, 0x00]. After swap, becomes [0x00, 0x00, 0x80, 0x3f]. Unpack as little-endian gives 0x3f800000 in little-endian, which is 1.0.

Wait, no. Wait, little-endian means the bytes are stored in reverse order. So 0x0000803f in little-endian is 3f800000, which is 1.0. Hmm, let me double-check.

Wait, struct.unpack('<f', bytes([0x00, 0x00, 0x80, 0x3f])) would interpret the bytes as 0x3f800000 in little-endian, which is 1.0. Yes.

So, yes, this function should handle these cases.

So, this function should work for converting 4 bytes from Modbus into a float, considering both byte order and word swap.

The user can call this function with their bytes, specify whether the byte order is big or little, and whether the two 16-bit words are swapped.

For example, if the device sends the two registers in reverse order (low word first), the user should set swap_words=True.

Thus, the code should handle these cases.

To convert 4 bytes received from Modbus into a float, you need to consider both the byte order (endianness) of the 32-bit float and the order of the 16-bit registers (word swap). Here's a Python function

python code

import struct

def modbus_bytes_to_float(data, byte_order='big', swap_words=False):
    """
    Converts 4 bytes from Modbus to a floating-point number.
    
    Parameters:
    data (bytes): A bytes object containing exactly 4 bytes.
    byte_order (str): 'big' for big-endian, 'little' for little-endian.
    swap_words (bool): True if the two 16-bit words need to be swapped.
    
    Returns:
    float: The decoded floating-point number.
    
    Raises:
    ValueError: If data length is not 4 bytes.
    """
    if len(data) != 4:
        raise ValueError("Data must be exactly 4 bytes long.")
    
    # Swap the two 16-bit words if required
    if swap_words:
        data = data[2:] + data[:2]
    
    # Determine the format string for struct.unpack
    fmt = '>' if byte_order == 'big' else '<'
    fmt += 'f'  # 'f' denotes float (32-bit)
    
    # Unpack the bytes to a float
    return struct.unpack(fmt, data)[0]

# Example usage:
# Assuming bytes received from Modbus are in big-endian with swapped words
modbus_data = bytes([0x00, 0x00, 0x80, 0x3f])  # Represents 1.0 when swapped and big-endian
result = modbus_bytes_to_float(modbus_data, byte_order='big', swap_words=True)
print(result)  # Output: 1.0

Explanation:

1. Byte Order: The byte_order parameter specifies whether the 32-bit float is stored as big-endian ('>f') or little-endian ('<f').
2. Word Swap: The swap_words parameter determines if the two 16-bit registers (words) are in reverse order. If True, the first two bytes are swapped with the last two bytes.
3. Struct Unpack: The struct.unpack function interprets the bytes as a float based on the specified format.

Usage Notes:

• Modbus Data Handling: Modbus typically uses big-endian for registers. If your device stores the 32-bit float with the high word first, use byte_order='big' and swap_words=False. If the low word comes first, set swap_words=True.
• Testing: Use example byte sequences to test different configurations (e.g., 0x3f800000 for 1.0 in big-endian).

[markd833]

@5546doug

I need to change a 4 hex to a float.
The code I have uses no floats.

I'm confused. Why do you want to convert the value to a float if your code doesn't use floats?

Maybe you need to read in the the value as a 32-bit float or a 64-bit float (the user guide for the device you are using will tell you which it is as well as the bit representation of the float) and convert that to an integer?