Huabang DDS228 Modbus Parser

import serial
import struct
import time

# CRC-16 calculation function (Modbus flavor)
def crc16(data):
    crc = 0xFFFF
    for byte in data:
        crc ^= byte
        for _ in range(8):
            if crc & 0x0001:
                crc = (crc >> 1) ^ 0xA001
            else:
                crc >>= 1
    return crc

# Function to convert IEEE 754 floating point bytes to a float value
def ieee754_to_float(bytes):
    return struct.unpack('>f', struct.pack('>L', bytes))[0]

# Function to parse a Modbus response
def parse_modbus_response(response_bytes):
    # Slave ID
    slave_id = response_bytes[0]

    # Function code
    function_code = response_bytes[1]

    # Byte count
    byte_count = response_bytes[2]

    # Data bytes
    data_bytes = response_bytes[3:-2]

    # CRC bytes
    crc_bytes = response_bytes[-2:]

    # Calculate CRC and check
    calculated_crc = crc16(response_bytes[:-2])
    received_crc = int.from_bytes(crc_bytes, byteorder='little')
    if calculated_crc != received_crc:
        print("CRC error in the response")
        return

    # Check for error response
    if function_code == 0x83:
        exception_code = data_bytes[0]
        print(f"Error response: Exception code {exception_code}")
        return

    # Parse data based on expected data type
    if function_code == 0x03:  # Read holding registers
        if byte_count == 4:  # 32-bit float
            value = ieee754_to_float(int.from_bytes(data_bytes, byteorder='big'))
            print(f"32-bit float value: {value}")
        elif byte_count == 2:  # 16-bit unsigned int
            value = int.from_bytes(data_bytes, byteorder='big')
            print(f"16-bit unsigned int value: {value}")
        else:
            print("Unexpected byte count for read holding registers response")
    else:
        print(f"Unhandled function code: {function_code}")

# Function to construct a Modbus request
def construct_modbus_request(register_choice, slave_id=0x01):
    requests = {
        1: bytes.fromhex(f'01 03 00 00 00 02'),  # Total active energy (kWh)
        2: bytes.fromhex(f'01 03 00 0A 00 02'),  # Reverse active energy (kWh)
        3: bytes.fromhex(f'01 03 00 64 00 02'),  # Voltage (V)
        4: bytes.fromhex(f'01 03 00 6A 00 02'),  # Current (A)
        5: bytes.fromhex(f'01 03 00 76 00 02'),  # Active power (kW)
        6: bytes.fromhex(f'01 03 00 8E 00 02'),  # Power factor
        7: bytes.fromhex(f'01 03 00 90 00 02'),  # Grid frequency (Hz)
    }

    if register_choice in requests:
        request_bytes = requests[register_choice]
        crc = crc16(request_bytes)
        crc_bytes = crc.to_bytes(2, byteorder='little')
        return request_bytes + crc_bytes
    else:
        print("Invalid choice, please try again.")
        return None

# Main program
# Get the COM port from the user
com_port = input("Enter the COM port (e.g., COM1, /dev/ttyUSB0): ")

# Device ID is fixed to 26
device_id = 26

# Open the serial port
try:
    ser = serial.Serial(com_port, baudrate=9600, bytesize=8, parity=serial.PARITY_EVEN, stopbits=1)
except serial.SerialException as e:
    print(f"Error opening serial port: {e}")
    exit(1)

while True:
    print("\nSelect the register you want to request:")
    print("1. Total active energy (kWh)")
    print("2. Reverse active energy (kWh)")
    print("3. Voltage (V)")
    print("4. Current (A)")
    print("5. Active power (kW)")
    print("6. Power factor")
    print("7. Grid frequency (Hz)")
    print("0. Exit")

    choice = int(input("Enter your choice (0-7): "))

    if choice == 0:
        break

    request_bytes = construct_modbus_request(choice, device_id)

    if request_bytes:
        print(f"Modbus request: {request_bytes.hex()}")

        # Send the request over the serial port
        ser.write(request_bytes)

        # Wait for the response
        response_bytes = ser.read(size=9)

        if len(response_bytes) == 9:
            parse_modbus_response(response_bytes)
        else:
            print("Invalid response length")

        # Add a delay to avoid flooding the meter with requests
        time.sleep(0.1)

print("Exiting program...")
ser.close()