From c190229409412f71a2dca0c52b0d8a3d87574cc3 Mon Sep 17 00:00:00 2001 From: hutcheb Date: Thu, 5 Sep 2024 04:06:12 +0800 Subject: [PATCH] fix(plc4py): Update the data io code gen to fix issue with byte based arrays --- .../python/data-io-template.python.ftlh | 10 +- .../protocols/modbus/readwrite/DataItem.py | 696 ++++++++++------- .../protocols/modbus/readwrite/DriverType.py | 8 +- .../protocols/modbus/readwrite/ModbusADU.py | 74 +- .../modbus/readwrite/ModbusAsciiADU.py | 83 +- .../modbus/readwrite/ModbusConstants.py | 33 +- .../modbus/readwrite/ModbusDataType.py | 64 +- .../ModbusDeviceInformationConformityLevel.py | 8 +- .../readwrite/ModbusDeviceInformationLevel.py | 8 +- .../ModbusDeviceInformationMoreFollows.py | 8 +- .../ModbusDeviceInformationObject.py | 52 +- .../modbus/readwrite/ModbusErrorCode.py | 8 +- .../protocols/modbus/readwrite/ModbusPDU.py | 725 +++++++++++++----- .../readwrite/ModbusPDUDiagnosticRequest.py | 55 +- .../readwrite/ModbusPDUDiagnosticResponse.py | 55 +- .../modbus/readwrite/ModbusPDUError.py | 47 +- .../ModbusPDUGetComEventCounterRequest.py | 28 +- .../ModbusPDUGetComEventCounterResponse.py | 61 +- .../ModbusPDUGetComEventLogRequest.py | 28 +- .../ModbusPDUGetComEventLogResponse.py | 87 ++- ...odbusPDUMaskWriteHoldingRegisterRequest.py | 76 +- ...dbusPDUMaskWriteHoldingRegisterResponse.py | 76 +- .../readwrite/ModbusPDUReadCoilsRequest.py | 57 +- .../readwrite/ModbusPDUReadCoilsResponse.py | 44 +- ...odbusPDUReadDeviceIdentificationRequest.py | 68 +- ...dbusPDUReadDeviceIdentificationResponse.py | 165 ++-- .../ModbusPDUReadDiscreteInputsRequest.py | 57 +- .../ModbusPDUReadDiscreteInputsResponse.py | 48 +- .../ModbusPDUReadExceptionStatusRequest.py | 32 +- .../ModbusPDUReadExceptionStatusResponse.py | 42 +- .../ModbusPDUReadFifoQueueRequest.py | 46 +- .../ModbusPDUReadFifoQueueResponse.py | 56 +- .../ModbusPDUReadFileRecordRequest.py | 49 +- .../ModbusPDUReadFileRecordRequestItem.py | 79 +- .../ModbusPDUReadFileRecordResponse.py | 49 +- .../ModbusPDUReadFileRecordResponseItem.py | 58 +- .../ModbusPDUReadHoldingRegistersRequest.py | 61 +- .../ModbusPDUReadHoldingRegistersResponse.py | 48 +- .../ModbusPDUReadInputRegistersRequest.py | 57 +- .../ModbusPDUReadInputRegistersResponse.py | 48 +- ...eadWriteMultipleHoldingRegistersRequest.py | 114 ++- ...adWriteMultipleHoldingRegistersResponse.py | 48 +- .../ModbusPDUReportServerIdRequest.py | 28 +- .../ModbusPDUReportServerIdResponse.py | 44 +- .../ModbusPDUWriteFileRecordRequest.py | 49 +- .../ModbusPDUWriteFileRecordRequestItem.py | 86 ++- .../ModbusPDUWriteFileRecordResponse.py | 49 +- .../ModbusPDUWriteFileRecordResponseItem.py | 86 ++- .../ModbusPDUWriteMultipleCoilsRequest.py | 76 +- .../ModbusPDUWriteMultipleCoilsResponse.py | 61 +- ...PDUWriteMultipleHoldingRegistersRequest.py | 80 +- ...DUWriteMultipleHoldingRegistersResponse.py | 65 +- .../ModbusPDUWriteSingleCoilRequest.py | 57 +- .../ModbusPDUWriteSingleCoilResponse.py | 57 +- .../ModbusPDUWriteSingleRegisterRequest.py | 61 +- .../ModbusPDUWriteSingleRegisterResponse.py | 61 +- .../modbus/readwrite/ModbusRtuADU.py | 81 +- .../modbus/readwrite/ModbusTcpADU.py | 113 ++- .../protocols/simulated/readwrite/DataItem.py | 467 +++++------ .../protocols/simulated/readwrite/Dummy.py | 37 +- .../readwrite/SimulatedDataTypeSizes.py | 60 +- .../protocols/umas/readwrite/DataItem.py | 262 ++++--- .../umas/readwrite/ModbusErrorCode.py | 8 +- .../protocols/umas/readwrite/ModbusPDU.py | 101 ++- .../umas/readwrite/ModbusPDUError.py | 56 +- .../protocols/umas/readwrite/ModbusTcpADU.py | 92 ++- .../umas/readwrite/PlcMemoryBlockIdent.py | 73 +- .../protocols/umas/readwrite/UmasConstants.py | 33 +- .../protocols/umas/readwrite/UmasDataType.py | 56 +- .../umas/readwrite/UmasDatatypeReference.py | 105 +-- .../UmasDeviceInformationConformityLevel.py | 8 +- .../readwrite/UmasDeviceInformationLevel.py | 8 +- .../UmasDeviceInformationMoreFollows.py | 8 +- .../umas/readwrite/UmasInitCommsRequest.py | 52 +- .../umas/readwrite/UmasInitCommsResponse.py | 151 ++-- .../umas/readwrite/UmasMemoryBlock.py | 64 +- .../readwrite/UmasMemoryBlockBasicInfo.py | 94 ++- .../protocols/umas/readwrite/UmasPDU.py | 47 +- .../protocols/umas/readwrite/UmasPDUItem.py | 293 ++++--- .../umas/readwrite/UmasPDUPlcIdentRequest.py | 31 +- .../umas/readwrite/UmasPDUPlcIdentResponse.py | 285 +++++-- .../umas/readwrite/UmasPDUPlcStatusRequest.py | 31 +- .../readwrite/UmasPDUPlcStatusResponse.py | 112 ++- .../readwrite/UmasPDUProjectInfoRequest.py | 46 +- .../UmasPDUReadDatatypeNamesResponse.py | 84 +- .../UmasPDUReadMemoryBlockRequest.py | 128 ++-- .../UmasPDUReadMemoryBlockResponse.py | 86 ++- .../UmasPDUReadUmasUDTDefinitionResponse.py | 77 +- ...masPDUReadUnlocatedVariableNamesRequest.py | 143 ++-- ...asPDUReadUnlocatedVariableNamesResponse.py | 96 ++- .../UmasPDUReadUnlocatedVariableResponse.py | 52 +- .../readwrite/UmasPDUReadVariableRequest.py | 87 ++- .../readwrite/UmasPDUReadVariableResponse.py | 46 +- .../readwrite/UmasPDUWriteVariableRequest.py | 87 ++- .../readwrite/UmasPDUWriteVariableResponse.py | 46 +- .../umas/readwrite/UmasUDTDefinition.py | 92 ++- .../UmasUnlocatedVariableReference.py | 136 ++-- .../readwrite/VariableReadRequestReference.py | 98 +-- .../VariableWriteRequestReference.py | 118 +-- 99 files changed, 5096 insertions(+), 3430 deletions(-) diff --git a/code-generation/language-python/src/main/resources/templates/python/data-io-template.python.ftlh b/code-generation/language-python/src/main/resources/templates/python/data-io-template.python.ftlh index 38464d206cd..029c4854085 100644 --- a/code-generation/language-python/src/main/resources/templates/python/data-io-template.python.ftlh +++ b/code-generation/language-python/src/main/resources/templates/python/data-io-template.python.ftlh @@ -76,7 +76,7 @@ class ${type.name}: <#if discriminatorType.isEnumTypeReference()> ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)} <#else> - ${helper.camelCaseToSnakeCase(helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments))} + ${helper.toParseExpression(dataIoTypeDefinition.switchField.orElseThrow(), discriminatorType, discriminatorValueTerm, parserArguments)} <#sep> and @@ -131,7 +131,7 @@ class ${type.name}: ) - <#-- A terminated array keeps on reading data as long as the termination expression evaluates to false --> + <#-- A terminated array keeps on reading data as long as the termination expression evaluates to False --> <#elseif arrayField.isTerminatedArrayField()> # Terminated array ${arrayField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} = new LinkedList<>() @@ -377,8 +377,8 @@ class ${type.name}: for val in values.get_list(): <#if elementTypeReference.isByteBased()> <@emitImport import="from typing import List" /> - value: list[byte] = val.get_raw() - write_buffer.write_byte_array("", value) + value: ${helper.getLanguageTypeNameForField(arrayField)} = val.get_raw() + write_buffer.write_byte_array("", value) <#else> value: ${helper.getLanguageTypeNameForTypeReference(elementTypeReference)} = val.get_${helper.camelCaseToSnakeCase(helper.getLanguageTypeNameForTypeReference(elementTypeReference)?cap_first)}() ${helper.getWriteBufferWriteMethodCall(elementTypeReference.asSimpleTypeReference().orElseThrow(), "(" + arrayField.name + ")", arrayField)} @@ -387,7 +387,7 @@ class ${type.name}: <#if case.name == "BOOL"> while write_buffer.getPos() < len(write_buffer.get_data()): - write_buffer.write_bit(false) + write_buffer.write_bit(False) <#break> <#case "const"> diff --git a/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py b/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py index e9a2d169ebf..d3082fabeec 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py @@ -47,28 +47,53 @@ from typing import cast import logging import math - + class DataItem: @staticmethod - def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_values: int, big_endian: bool): - if data_type == ModbusDataType.BOOL and number_of_values == int(1) and big_endian == true : # BOOL + def static_parse( + read_buffer: ReadBuffer, + data_type: ModbusDataType, + number_of_values: int, + big_endian: bool, + ): + if ( + data_type == ModbusDataType.BOOL + and number_of_values == int(1) + and big_endian == True + ): # BOOL # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_int(15, logical_name="") if reserved != int(0x0000): - logging.warning("Expected constant value " + str(0x0000) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x0000) + + " but got " + + str(reserved) + + " for reserved field." + ) # Simple Field (value) value: bool = read_buffer.read_bit("") return PlcBOOL(value) - if data_type == ModbusDataType.BOOL and number_of_values == int(1) and big_endian == false : # BOOL + if ( + data_type == ModbusDataType.BOOL + and number_of_values == int(1) + and big_endian == False + ): # BOOL # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(7, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) # Simple Field (value) value: bool = read_buffer.read_bit("") @@ -76,10 +101,16 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(8, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) return PlcBOOL(value) - if data_type == ModbusDataType.BOOL : # List + if data_type == ModbusDataType.BOOL: # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -87,20 +118,33 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v for _ in range(item_count): value.append(PlcBOOL(bool(read_buffer.read_bit("")))) - return PlcList(value) - if data_type == ModbusDataType.BYTE and number_of_values == int(1) and big_endian == true : # BYTE + if ( + data_type == ModbusDataType.BYTE + and number_of_values == int(1) + and big_endian == True + ): # BYTE # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(8, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) # Simple Field (value) value: int = read_buffer.read_unsigned_short(8, logical_name="") return PlcBYTE(value) - if data_type == ModbusDataType.BYTE and number_of_values == int(1) and big_endian == false : # BYTE + if ( + data_type == ModbusDataType.BYTE + and number_of_values == int(1) + and big_endian == False + ): # BYTE # Simple Field (value) value: int = read_buffer.read_unsigned_short(8, logical_name="") @@ -108,49 +152,68 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(8, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) return PlcBYTE(value) - if data_type == ModbusDataType.BYTE : # List + if data_type == ModbusDataType.BYTE: # List # Array field (value) # Count array - item_count: int = int(number_of_values* int(8)) + item_count: int = int(number_of_values * int(8)) value: List[PlcValue] = [] for _ in range(item_count): value.append(PlcBOOL(bool(read_buffer.read_bit("")))) - return PlcList(value) - if data_type == ModbusDataType.WORD : # WORD + if data_type == ModbusDataType.WORD: # WORD # Simple Field (value) value: int = read_buffer.read_unsigned_int(16, logical_name="") return PlcWORD(value) - if data_type == ModbusDataType.DWORD : # DWORD + if data_type == ModbusDataType.DWORD: # DWORD # Simple Field (value) value: int = read_buffer.read_unsigned_long(32, logical_name="") return PlcDWORD(value) - if data_type == ModbusDataType.LWORD : # LWORD + if data_type == ModbusDataType.LWORD: # LWORD # Simple Field (value) value: int = read_buffer.read_unsigned_long(64, logical_name="") return PlcLWORD(value) - if data_type == ModbusDataType.SINT and number_of_values == int(1) and big_endian == true : # SINT + if ( + data_type == ModbusDataType.SINT + and number_of_values == int(1) + and big_endian == True + ): # SINT # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(8, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) # Simple Field (value) value: int = read_buffer.read_signed_byte(8, logical_name="") return PlcSINT(value) - if data_type == ModbusDataType.SINT and number_of_values == int(1) and big_endian == false : # SINT + if ( + data_type == ModbusDataType.SINT + and number_of_values == int(1) + and big_endian == False + ): # SINT # Simple Field (value) value: int = read_buffer.read_signed_byte(8, logical_name="") @@ -158,26 +221,33 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(8, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) return PlcSINT(value) - if data_type == ModbusDataType.SINT : # List + if data_type == ModbusDataType.SINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcSINT(int(read_buffer.read_signed_byte(8, logical_name="")))) - + value.append( + PlcSINT(int(read_buffer.read_signed_byte(8, logical_name=""))) + ) return PlcList(value) - if data_type == ModbusDataType.INT and number_of_values == int(1) : # INT + if data_type == ModbusDataType.INT and number_of_values == int(1): # INT # Simple Field (value) value: int = read_buffer.read_short(16, logical_name="") return PlcINT(value) - if data_type == ModbusDataType.INT : # List + if data_type == ModbusDataType.INT: # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -185,15 +255,14 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v for _ in range(item_count): value.append(PlcINT(int(read_buffer.read_short(16, logical_name="")))) - return PlcList(value) - if data_type == ModbusDataType.DINT and number_of_values == int(1) : # DINT + if data_type == ModbusDataType.DINT and number_of_values == int(1): # DINT # Simple Field (value) value: int = read_buffer.read_int(32, logical_name="") return PlcDINT(value) - if data_type == ModbusDataType.DINT : # List + if data_type == ModbusDataType.DINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -201,15 +270,14 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v for _ in range(item_count): value.append(PlcDINT(int(read_buffer.read_int(32, logical_name="")))) - return PlcList(value) - if data_type == ModbusDataType.LINT and number_of_values == int(1) : # LINT + if data_type == ModbusDataType.LINT and number_of_values == int(1): # LINT # Simple Field (value) value: int = read_buffer.read_long(64, logical_name="") return PlcLINT(value) - if data_type == ModbusDataType.LINT : # List + if data_type == ModbusDataType.LINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -217,20 +285,33 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v for _ in range(item_count): value.append(PlcLINT(int(read_buffer.read_long(64, logical_name="")))) - return PlcList(value) - if data_type == ModbusDataType.USINT and number_of_values == int(1) and big_endian == true : # USINT + if ( + data_type == ModbusDataType.USINT + and number_of_values == int(1) + and big_endian == True + ): # USINT # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(8, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) # Simple Field (value) value: int = read_buffer.read_unsigned_short(8, logical_name="") return PlcUSINT(value) - if data_type == ModbusDataType.USINT and number_of_values == int(1) and big_endian == false : # USINT + if ( + data_type == ModbusDataType.USINT + and number_of_values == int(1) + and big_endian == False + ): # USINT # Simple Field (value) value: int = read_buffer.read_unsigned_short(8, logical_name="") @@ -238,163 +319,194 @@ def static_parse(read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_v # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(8, logical_name="") if reserved != int(0x00): - logging.warning("Expected constant value " + str(0x00) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x00) + + " but got " + + str(reserved) + + " for reserved field." + ) return PlcUSINT(value) - if data_type == ModbusDataType.USINT : # List + if data_type == ModbusDataType.USINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcUINT(int(read_buffer.read_unsigned_short(8, logical_name="")))) - + value.append( + PlcUINT(int(read_buffer.read_unsigned_short(8, logical_name=""))) + ) return PlcList(value) - if data_type == ModbusDataType.UINT and number_of_values == int(1) : # UINT + if data_type == ModbusDataType.UINT and number_of_values == int(1): # UINT # Simple Field (value) value: int = read_buffer.read_unsigned_int(16, logical_name="") return PlcUINT(value) - if data_type == ModbusDataType.UINT : # List + if data_type == ModbusDataType.UINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name="")))) - + value.append( + PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name=""))) + ) return PlcList(value) - if data_type == ModbusDataType.UDINT and number_of_values == int(1) : # UDINT + if data_type == ModbusDataType.UDINT and number_of_values == int(1): # UDINT # Simple Field (value) value: int = read_buffer.read_unsigned_long(32, logical_name="") return PlcUDINT(value) - if data_type == ModbusDataType.UDINT : # List + if data_type == ModbusDataType.UDINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name="")))) - + value.append( + PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name=""))) + ) return PlcList(value) - if data_type == ModbusDataType.ULINT and number_of_values == int(1) : # ULINT + if data_type == ModbusDataType.ULINT and number_of_values == int(1): # ULINT # Simple Field (value) value: int = read_buffer.read_unsigned_long(64, logical_name="") return PlcULINT(value) - if data_type == ModbusDataType.ULINT : # List + if data_type == ModbusDataType.ULINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcLINT(int(read_buffer.read_unsigned_long(64, logical_name="")))) - + value.append( + PlcLINT(int(read_buffer.read_unsigned_long(64, logical_name=""))) + ) return PlcList(value) - if data_type == ModbusDataType.REAL and number_of_values == int(1) : # REAL + if data_type == ModbusDataType.REAL and number_of_values == int(1): # REAL # Simple Field (value) value: float = read_buffer.read_float(32, logical_name="") return PlcREAL(value) - if data_type == ModbusDataType.REAL : # List + if data_type == ModbusDataType.REAL: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcREAL(float(read_buffer.read_float(32, logical_name="")))) - + value.append( + PlcREAL(float(read_buffer.read_float(32, logical_name=""))) + ) return PlcList(value) - if data_type == ModbusDataType.LREAL and number_of_values == int(1) : # LREAL + if data_type == ModbusDataType.LREAL and number_of_values == int(1): # LREAL # Simple Field (value) value: float = read_buffer.read_double(64, logical_name="") return PlcLREAL(value) - if data_type == ModbusDataType.LREAL : # List + if data_type == ModbusDataType.LREAL: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcLREAL(float(read_buffer.read_double(64, logical_name="")))) - + value.append( + PlcLREAL(float(read_buffer.read_double(64, logical_name=""))) + ) return PlcList(value) - if data_type == ModbusDataType.CHAR and number_of_values == int(1) : # CHAR + if data_type == ModbusDataType.CHAR and number_of_values == int(1): # CHAR # Simple Field (value) value: str = read_buffer.read_str(8, logical_name="", encoding="") return PlcCHAR(value) - if data_type == ModbusDataType.CHAR : # List + if data_type == ModbusDataType.CHAR: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcSTRING(str(read_buffer.read_str(8, logical_name="", encoding="")))) - + value.append( + PlcSTRING( + str(read_buffer.read_str(8, logical_name="", encoding="")) + ) + ) return PlcList(value) - if data_type == ModbusDataType.WCHAR and number_of_values == int(1) : # WCHAR + if data_type == ModbusDataType.WCHAR and number_of_values == int(1): # WCHAR # Simple Field (value) value: str = read_buffer.read_str(16, logical_name="", encoding="") return PlcWCHAR(value) - if data_type == ModbusDataType.WCHAR : # List + if data_type == ModbusDataType.WCHAR: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcSTRING(str(read_buffer.read_str(16, logical_name="", encoding="")))) - + value.append( + PlcSTRING( + str(read_buffer.read_str(16, logical_name="", encoding="")) + ) + ) return PlcList(value) - if data_type == ModbusDataType.RAW_COIL : # RawByteArray + if data_type == ModbusDataType.RAW_COIL: # RawByteArray # Array field (value) # Count array - item_count: int = int(ceil(number_of_values/ float(8))) + item_count: int = int(ceil(number_of_values / float(8))) value: List[PlcValue] = [] for _ in range(item_count): value.append(PlcSINT(int(read_buffer.read_byte("")))) - return PlcRawByteArray(value) - if data_type == ModbusDataType.RAW_REGISTER : # RawByteArray + if data_type == ModbusDataType.RAW_REGISTER: # RawByteArray # Array field (value) # Count array - item_count: int = int(number_of_values* int(2)) + item_count: int = int(number_of_values * int(2)) value: List[PlcValue] = [] for _ in range(item_count): value.append(PlcSINT(int(read_buffer.read_byte("")))) - return PlcRawByteArray(value) return None @staticmethod - def static_serialize(write_buffer: WriteBuffer, _value: PlcValue, data_type: ModbusDataType, number_of_values: int, big_endian: bool, byte_order: ByteOrder) -> None: - if data_type == ModbusDataType.BOOL and number_of_values == int(1) and big_endian == True : # BOOL + def static_serialize( + write_buffer: WriteBuffer, + _value: PlcValue, + data_type: ModbusDataType, + number_of_values: int, + big_endian: bool, + byte_order: ByteOrder, + ) -> None: + if ( + data_type == ModbusDataType.BOOL + and number_of_values == int(1) + and big_endian == True + ): # BOOL # Reserved Field write_buffer.write_unsigned_short(int(0x0000), 15, "int0x0000") # Simple Field (value) value: bool = _value.get_bool() write_buffer.write_bit((value), "value") - elif data_type == ModbusDataType.BOOL and number_of_values == int(1) and big_endian == False : # BOOL + elif ( + data_type == ModbusDataType.BOOL + and number_of_values == int(1) + and big_endian == False + ): # BOOL # Reserved Field write_buffer.write_byte(int(0x00), 7, "int0x00") # Simple Field (value) @@ -403,351 +515,419 @@ def static_serialize(write_buffer: WriteBuffer, _value: PlcValue, data_type: Mod # Reserved Field write_buffer.write_byte(int(0x00), 8, "int0x00") - elif data_type == ModbusDataType.BOOL : # List + elif data_type == ModbusDataType.BOOL: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: bool = val.get_bool() write_buffer.write_bit((value), "value") - elif data_type == ModbusDataType.BYTE and number_of_values == int(1) and big_endian == True : # BYTE + elif ( + data_type == ModbusDataType.BYTE + and number_of_values == int(1) + and big_endian == True + ): # BYTE # Reserved Field write_buffer.write_byte(int(0x00), 8, "int0x00") # Simple Field (value) value: int = _value.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == ModbusDataType.BYTE and number_of_values == int(1) and big_endian == False : # BYTE + elif ( + data_type == ModbusDataType.BYTE + and number_of_values == int(1) + and big_endian == False + ): # BYTE # Simple Field (value) value: int = _value.get_int() write_buffer.write_byte((value), 8, "value") # Reserved Field write_buffer.write_byte(int(0x00), 8, "int0x00") - elif data_type == ModbusDataType.BYTE : # List + elif data_type == ModbusDataType.BYTE: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: bool = val.get_bool() write_buffer.write_bit((value), "value") - elif data_type == ModbusDataType.WORD : # WORD + elif data_type == ModbusDataType.WORD: # WORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == ModbusDataType.DWORD : # DWORD + elif data_type == ModbusDataType.DWORD: # DWORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == ModbusDataType.LWORD : # LWORD + elif data_type == ModbusDataType.LWORD: # LWORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_long((value), 64, "value") - elif data_type == ModbusDataType.SINT and number_of_values == int(1) and big_endian == True : # SINT + elif ( + data_type == ModbusDataType.SINT + and number_of_values == int(1) + and big_endian == True + ): # SINT # Reserved Field write_buffer.write_byte(int(0x00), 8, "int0x00") # Simple Field (value) value: int = _value.get_int() write_buffer.write_signed_byte((value), 8, "value") - elif data_type == ModbusDataType.SINT and number_of_values == int(1) and big_endian == False : # SINT + elif ( + data_type == ModbusDataType.SINT + and number_of_values == int(1) + and big_endian == False + ): # SINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_signed_byte((value), 8, "value") # Reserved Field write_buffer.write_byte(int(0x00), 8, "int0x00") - elif data_type == ModbusDataType.SINT : # List + elif data_type == ModbusDataType.SINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_signed_byte((value), 8, "value") - elif data_type == ModbusDataType.INT and number_of_values == int(1) : # INT + elif data_type == ModbusDataType.INT and number_of_values == int(1): # INT # Simple Field (value) value: int = _value.get_int() write_buffer.write_short((value), 16, "value") - elif data_type == ModbusDataType.INT : # List + elif data_type == ModbusDataType.INT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_short((value), 16, "value") - elif data_type == ModbusDataType.DINT and number_of_values == int(1) : # DINT + elif data_type == ModbusDataType.DINT and number_of_values == int(1): # DINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_int((value), 32, "value") - elif data_type == ModbusDataType.DINT : # List + elif data_type == ModbusDataType.DINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_int((value), 32, "value") - elif data_type == ModbusDataType.LINT and number_of_values == int(1) : # LINT + elif data_type == ModbusDataType.LINT and number_of_values == int(1): # LINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_long((value), 64, "value") - elif data_type == ModbusDataType.LINT : # List + elif data_type == ModbusDataType.LINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_long((value), 64, "value") - elif data_type == ModbusDataType.USINT and number_of_values == int(1) and big_endian == True : # USINT + elif ( + data_type == ModbusDataType.USINT + and number_of_values == int(1) + and big_endian == True + ): # USINT # Reserved Field write_buffer.write_byte(int(0x00), 8, "int0x00") # Simple Field (value) value: int = _value.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == ModbusDataType.USINT and number_of_values == int(1) and big_endian == False : # USINT + elif ( + data_type == ModbusDataType.USINT + and number_of_values == int(1) + and big_endian == False + ): # USINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_byte((value), 8, "value") # Reserved Field write_buffer.write_byte(int(0x00), 8, "int0x00") - elif data_type == ModbusDataType.USINT : # List + elif data_type == ModbusDataType.USINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == ModbusDataType.UINT and number_of_values == int(1) : # UINT + elif data_type == ModbusDataType.UINT and number_of_values == int(1): # UINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == ModbusDataType.UINT : # List + elif data_type == ModbusDataType.UINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == ModbusDataType.UDINT and number_of_values == int(1) : # UDINT + elif data_type == ModbusDataType.UDINT and number_of_values == int(1): # UDINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == ModbusDataType.UDINT : # List + elif data_type == ModbusDataType.UDINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == ModbusDataType.ULINT and number_of_values == int(1) : # ULINT + elif data_type == ModbusDataType.ULINT and number_of_values == int(1): # ULINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_long((value), 64, "value") - elif data_type == ModbusDataType.ULINT : # List + elif data_type == ModbusDataType.ULINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_long((value), 64, "value") - elif data_type == ModbusDataType.REAL and number_of_values == int(1) : # REAL + elif data_type == ModbusDataType.REAL and number_of_values == int(1): # REAL # Simple Field (value) value: float = _value.get_float() write_buffer.write_float((value), 32, "value") - elif data_type == ModbusDataType.REAL : # List + elif data_type == ModbusDataType.REAL: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: float = val.get_float() write_buffer.write_float((value), 32, "value") - elif data_type == ModbusDataType.LREAL and number_of_values == int(1) : # LREAL + elif data_type == ModbusDataType.LREAL and number_of_values == int(1): # LREAL # Simple Field (value) value: float = _value.get_float() write_buffer.write_double((value), 64, "value") - elif data_type == ModbusDataType.LREAL : # List + elif data_type == ModbusDataType.LREAL: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: float = val.get_float() write_buffer.write_double((value), 64, "value") - elif data_type == ModbusDataType.CHAR and number_of_values == int(1) : # CHAR + elif data_type == ModbusDataType.CHAR and number_of_values == int(1): # CHAR # Simple Field (value) value: str = _value.get_str() write_buffer.write_str((value), 8, "UTF-8", "value") - elif data_type == ModbusDataType.CHAR : # List + elif data_type == ModbusDataType.CHAR: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: str = val.get_str() write_buffer.write_str((value), 8, "UTF-8", "value") - elif data_type == ModbusDataType.WCHAR and number_of_values == int(1) : # WCHAR + elif data_type == ModbusDataType.WCHAR and number_of_values == int(1): # WCHAR # Simple Field (value) value: str = _value.get_str() write_buffer.write_str((value), 16, "UTF-16", "value") - elif data_type == ModbusDataType.WCHAR : # List + elif data_type == ModbusDataType.WCHAR: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: str = val.get_str() write_buffer.write_str((value), 16, "UTF-16", "value") - elif data_type == ModbusDataType.RAW_COIL : # RawByteArray + elif data_type == ModbusDataType.RAW_COIL: # RawByteArray values: PlcList = cast(PlcList, _value) for val in values.get_list(): - value: list[byte] = val.get_raw() - write_buffer.write_byte_array("", value) + value: List[int] = val.get_raw() + write_buffer.write_byte_array("", value) - elif data_type == ModbusDataType.RAW_REGISTER : # RawByteArray + elif data_type == ModbusDataType.RAW_REGISTER: # RawByteArray values: PlcList = cast(PlcList, _value) for val in values.get_list(): - value: list[byte] = val.get_raw() - write_buffer.write_byte_array("", value) - - + value: List[int] = val.get_raw() + write_buffer.write_byte_array("", value) @staticmethod - def get_length_in_bytes(_value: PlcValue, data_type: ModbusDataType, number_of_values: int, big_endian: bool) -> int: - return int(math.ceil(float(DataItem.get_length_in_bits(_value, data_type, number_of_values, big_endian)) / 8.0)) - + def get_length_in_bytes( + _value: PlcValue, + data_type: ModbusDataType, + number_of_values: int, + big_endian: bool, + ) -> int: + return int( + math.ceil( + float( + DataItem.get_length_in_bits( + _value, data_type, number_of_values, big_endian + ) + ) + / 8.0 + ) + ) @staticmethod - def get_length_in_bits(_value: PlcValue, data_type: ModbusDataType, number_of_values: int, big_endian: bool) -> int: + def get_length_in_bits( + _value: PlcValue, + data_type: ModbusDataType, + number_of_values: int, + big_endian: bool, + ) -> int: size_in_bits: int = 0 - if data_type == ModbusDataType.BOOL and number_of_values == int(1) and big_endian == True: # BOOL - # Reserved Field - size_in_bits += 15 - # Simple Field (value) - size_in_bits += 1 - elif data_type == ModbusDataType.BOOL and number_of_values == int(1) and big_endian == False: # BOOL - # Reserved Field - size_in_bits += 7 - # Simple Field (value) - size_in_bits += 1 - # Reserved Field - size_in_bits += 8 - elif data_type == ModbusDataType.BOOL: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 1 - elif data_type == ModbusDataType.BYTE and number_of_values == int(1) and big_endian == True: # BYTE - # Reserved Field - size_in_bits += 8 - # Simple Field (value) - size_in_bits += 8 - elif data_type == ModbusDataType.BYTE and number_of_values == int(1) and big_endian == False: # BYTE - # Simple Field (value) - size_in_bits += 8 - # Reserved Field - size_in_bits += 8 - elif data_type == ModbusDataType.BYTE: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 1 - elif data_type == ModbusDataType.WORD: # WORD - # Simple Field (value) - size_in_bits += 16 - elif data_type == ModbusDataType.DWORD: # DWORD - # Simple Field (value) - size_in_bits += 32 - elif data_type == ModbusDataType.LWORD: # LWORD - # Simple Field (value) - size_in_bits += 64 - elif data_type == ModbusDataType.SINT and number_of_values == int(1) and big_endian == True: # SINT - # Reserved Field - size_in_bits += 8 - # Simple Field (value) - size_in_bits += 8 - elif data_type == ModbusDataType.SINT and number_of_values == int(1) and big_endian == False: # SINT - # Simple Field (value) - size_in_bits += 8 - # Reserved Field - size_in_bits += 8 - elif data_type == ModbusDataType.SINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == ModbusDataType.INT and number_of_values == int(1): # INT - # Simple Field (value) - size_in_bits += 16 - elif data_type == ModbusDataType.INT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == ModbusDataType.DINT and number_of_values == int(1): # DINT - # Simple Field (value) - size_in_bits += 32 - elif data_type == ModbusDataType.DINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == ModbusDataType.LINT and number_of_values == int(1): # LINT - # Simple Field (value) - size_in_bits += 64 - elif data_type == ModbusDataType.LINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 64 - elif data_type == ModbusDataType.USINT and number_of_values == int(1) and big_endian == True: # USINT - # Reserved Field - size_in_bits += 8 - # Simple Field (value) - size_in_bits += 8 - elif data_type == ModbusDataType.USINT and number_of_values == int(1) and big_endian == False: # USINT - # Simple Field (value) - size_in_bits += 8 - # Reserved Field - size_in_bits += 8 - elif data_type == ModbusDataType.USINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == ModbusDataType.UINT and number_of_values == int(1): # UINT - # Simple Field (value) - size_in_bits += 16 - elif data_type == ModbusDataType.UINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == ModbusDataType.UDINT and number_of_values == int(1): # UDINT - # Simple Field (value) - size_in_bits += 32 - elif data_type == ModbusDataType.UDINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == ModbusDataType.ULINT and number_of_values == int(1): # ULINT - # Simple Field (value) - size_in_bits += 64 - elif data_type == ModbusDataType.ULINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 64 - elif data_type == ModbusDataType.REAL and number_of_values == int(1): # REAL - # Simple Field (value) - size_in_bits += 32 - elif data_type == ModbusDataType.REAL: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == ModbusDataType.LREAL and number_of_values == int(1): # LREAL - # Simple Field (value) - size_in_bits += 64 - elif data_type == ModbusDataType.LREAL: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 64 - elif data_type == ModbusDataType.CHAR and number_of_values == int(1): # CHAR - # Simple Field (value) - size_in_bits += 8 - elif data_type == ModbusDataType.CHAR: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == ModbusDataType.WCHAR and number_of_values == int(1): # WCHAR - # Simple Field (value) - size_in_bits += 16 - elif data_type == ModbusDataType.WCHAR: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == ModbusDataType.RAW_COIL: # RawByteArray - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == ModbusDataType.RAW_REGISTER: # RawByteArray - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - - return size_in_bits - - - + if ( + data_type == ModbusDataType.BOOL + and number_of_values == int(1) + and big_endian == True + ): # BOOL + # Reserved Field + size_in_bits += 15 + # Simple Field (value) + size_in_bits += 1 + elif ( + data_type == ModbusDataType.BOOL + and number_of_values == int(1) + and big_endian == False + ): # BOOL + # Reserved Field + size_in_bits += 7 + # Simple Field (value) + size_in_bits += 1 + # Reserved Field + size_in_bits += 8 + elif data_type == ModbusDataType.BOOL: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 1 + elif ( + data_type == ModbusDataType.BYTE + and number_of_values == int(1) + and big_endian == True + ): # BYTE + # Reserved Field + size_in_bits += 8 + # Simple Field (value) + size_in_bits += 8 + elif ( + data_type == ModbusDataType.BYTE + and number_of_values == int(1) + and big_endian == False + ): # BYTE + # Simple Field (value) + size_in_bits += 8 + # Reserved Field + size_in_bits += 8 + elif data_type == ModbusDataType.BYTE: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 1 + elif data_type == ModbusDataType.WORD: # WORD + # Simple Field (value) + size_in_bits += 16 + elif data_type == ModbusDataType.DWORD: # DWORD + # Simple Field (value) + size_in_bits += 32 + elif data_type == ModbusDataType.LWORD: # LWORD + # Simple Field (value) + size_in_bits += 64 + elif ( + data_type == ModbusDataType.SINT + and number_of_values == int(1) + and big_endian == True + ): # SINT + # Reserved Field + size_in_bits += 8 + # Simple Field (value) + size_in_bits += 8 + elif ( + data_type == ModbusDataType.SINT + and number_of_values == int(1) + and big_endian == False + ): # SINT + # Simple Field (value) + size_in_bits += 8 + # Reserved Field + size_in_bits += 8 + elif data_type == ModbusDataType.SINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == ModbusDataType.INT and number_of_values == int(1): # INT + # Simple Field (value) + size_in_bits += 16 + elif data_type == ModbusDataType.INT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == ModbusDataType.DINT and number_of_values == int(1): # DINT + # Simple Field (value) + size_in_bits += 32 + elif data_type == ModbusDataType.DINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == ModbusDataType.LINT and number_of_values == int(1): # LINT + # Simple Field (value) + size_in_bits += 64 + elif data_type == ModbusDataType.LINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 64 + elif ( + data_type == ModbusDataType.USINT + and number_of_values == int(1) + and big_endian == True + ): # USINT + # Reserved Field + size_in_bits += 8 + # Simple Field (value) + size_in_bits += 8 + elif ( + data_type == ModbusDataType.USINT + and number_of_values == int(1) + and big_endian == False + ): # USINT + # Simple Field (value) + size_in_bits += 8 + # Reserved Field + size_in_bits += 8 + elif data_type == ModbusDataType.USINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == ModbusDataType.UINT and number_of_values == int(1): # UINT + # Simple Field (value) + size_in_bits += 16 + elif data_type == ModbusDataType.UINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == ModbusDataType.UDINT and number_of_values == int(1): # UDINT + # Simple Field (value) + size_in_bits += 32 + elif data_type == ModbusDataType.UDINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == ModbusDataType.ULINT and number_of_values == int(1): # ULINT + # Simple Field (value) + size_in_bits += 64 + elif data_type == ModbusDataType.ULINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 64 + elif data_type == ModbusDataType.REAL and number_of_values == int(1): # REAL + # Simple Field (value) + size_in_bits += 32 + elif data_type == ModbusDataType.REAL: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == ModbusDataType.LREAL and number_of_values == int(1): # LREAL + # Simple Field (value) + size_in_bits += 64 + elif data_type == ModbusDataType.LREAL: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 64 + elif data_type == ModbusDataType.CHAR and number_of_values == int(1): # CHAR + # Simple Field (value) + size_in_bits += 8 + elif data_type == ModbusDataType.CHAR: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == ModbusDataType.WCHAR and number_of_values == int(1): # WCHAR + # Simple Field (value) + size_in_bits += 16 + elif data_type == ModbusDataType.WCHAR: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == ModbusDataType.RAW_COIL: # RawByteArray + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == ModbusDataType.RAW_REGISTER: # RawByteArray + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + return size_in_bits diff --git a/plc4py/plc4py/protocols/modbus/readwrite/DriverType.py b/plc4py/plc4py/protocols/modbus/readwrite/DriverType.py index c3ad3cf7008..229dc8761e1 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/DriverType.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/DriverType.py @@ -19,12 +19,10 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - + + class DriverType(AutoNumberEnum): - + MODBUS_TCP: int = 0x01 MODBUS_RTU: int = 0x02 MODBUS_ASCII: int = 0x03 - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py index 8fd89d19c15..573c097d9c6 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py @@ -30,7 +30,8 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass class ModbusADU(ABC, PlcMessage): # Arguments. @@ -41,7 +42,6 @@ class ModbusADU(ABC, PlcMessage): def driver_type(self) -> DriverType: pass - @abstractmethod def serialize_modbus_adu_child(self, write_buffer: WriteBuffer) -> None: pass @@ -54,7 +54,6 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusADU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -66,12 +65,13 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): if kwargs is None: - raise PlcRuntimeException("Wrong number of arguments, expected 2, but got None") + raise PlcRuntimeException( + "Wrong number of arguments, expected 2, but got None" + ) driver_type: DriverType = 0 if isinstance(kwargs.get("driver_type"), DriverType): @@ -79,7 +79,10 @@ def static_parse(read_buffer: ReadBuffer, **kwargs): elif isinstance(kwargs.get("driver_type"), str): driver_type = DriverType(str(kwargs.get("driver_type"))) else: - raise PlcRuntimeException("Argument 0 expected to be of type DriverType or a string which is parseable but was " + kwargs.get("driver_type").getClass().getName()) + raise PlcRuntimeException( + "Argument 0 expected to be of type DriverType or a string which is parseable but was " + + kwargs.get("driver_type").getClass().getName() + ) response: bool = False if isinstance(kwargs.get("response"), bool): @@ -87,13 +90,17 @@ def static_parse(read_buffer: ReadBuffer, **kwargs): elif isinstance(kwargs.get("response"), str): response = bool(str(kwargs.get("response"))) else: - raise PlcRuntimeException("Argument 1 expected to be of type bool or a string which is parseable but was " + kwargs.get("response").getClass().getName()) + raise PlcRuntimeException( + "Argument 1 expected to be of type bool or a string which is parseable but was " + + kwargs.get("response").getClass().getName() + ) return ModbusADU.static_parse_context(read_buffer, driver_type, response) - @staticmethod - def static_parse_context(read_buffer: ReadBuffer, driver_type: DriverType, response: bool): + def static_parse_context( + read_buffer: ReadBuffer, driver_type: DriverType, response: bool + ): read_buffer.push_context("ModbusADU") if isinstance(driver_type, str): @@ -101,31 +108,43 @@ def static_parse_context(read_buffer: ReadBuffer, driver_type: DriverType, respo if isinstance(response, str): response = bool(strtobool(response)) - # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type) builder: ModbusADUBuilder = None from plc4py.protocols.modbus.readwrite.ModbusTcpADU import ModbusTcpADU - if driver_type == DriverType.MODBUS_TCP : - builder = ModbusTcpADU.static_parse_builder(read_buffer, driver_type, response) + if driver_type == DriverType.MODBUS_TCP: + + builder = ModbusTcpADU.static_parse_builder( + read_buffer, driver_type, response + ) from plc4py.protocols.modbus.readwrite.ModbusRtuADU import ModbusRtuADU - if driver_type == DriverType.MODBUS_RTU : - builder = ModbusRtuADU.static_parse_builder(read_buffer, driver_type, response) + if driver_type == DriverType.MODBUS_RTU: + + builder = ModbusRtuADU.static_parse_builder( + read_buffer, driver_type, response + ) from plc4py.protocols.modbus.readwrite.ModbusAsciiADU import ModbusAsciiADU - if driver_type == DriverType.MODBUS_ASCII : - builder = ModbusAsciiADU.static_parse_builder(read_buffer, driver_type, response) - if builder is None: - raise ParseException("Unsupported case for discriminated type"+" parameters ["+"driverType="+str(driver_type)+"]") + if driver_type == DriverType.MODBUS_ASCII: + builder = ModbusAsciiADU.static_parse_builder( + read_buffer, driver_type, response + ) + if builder is None: + raise ParseException( + "Unsupported case for discriminated type" + + " parameters [" + + "driverType=" + + str(driver_type) + + "]" + ) read_buffer.pop_context("ModbusADU") # Create the instance - _modbus_adu: ModbusADU = builder.build(response ) + _modbus_adu: ModbusADU = builder.build(response) return _modbus_adu - def equals(self, o: object) -> bool: if self == o: return True @@ -141,19 +160,16 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" + @dataclass class ModbusADUBuilder: - def build(self, response: bool ) -> ModbusADU: + def build(self, response: bool) -> ModbusADU: pass - - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py index a027fced441..855549d401c 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py @@ -32,7 +32,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class ModbusAsciiADU(ModbusADU): address: int @@ -42,23 +43,24 @@ class ModbusAsciiADU(ModbusADU): # Accessors for discriminator values. driver_type: ClassVar[DriverType] = DriverType.MODBUS_ASCII - - def serialize_modbus_adu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusAsciiADU") # Simple Field (address) - write_buffer.write_unsigned_byte(self.address,bit_length=8,logical_name="address") + write_buffer.write_unsigned_byte( + self.address, bit_length=8, logical_name="address" + ) # Simple Field (pdu) - write_buffer.write_serializable(self.pdu,logical_name="pdu") + write_buffer.write_serializable(self.pdu, logical_name="pdu") # Checksum Field (checksum) (Calculated) - write_buffer.write_unsigned_byte(int(StaticHelper.ascii_lrc_check(address, pdu)), logical_name="crc") + write_buffer.write_unsigned_byte( + int(StaticHelper.ascii_lrc_check(address, pdu)), logical_name="crc" + ) write_buffer.pop_context("ModbusAsciiADU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -77,9 +79,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, driver_type: DriverType, response: bool): + def static_parse_builder( + read_buffer: ReadBuffer, driver_type: DriverType, response: bool + ): read_buffer.push_context("ModbusAsciiADU") if isinstance(driver_type, str): @@ -87,21 +90,32 @@ def static_parse_builder(read_buffer: ReadBuffer, driver_type: DriverType, respo if isinstance(response, str): response = bool(strtobool(response)) - - address: int = read_buffer.read_unsigned_byte(logical_name="address", bit_length=8, byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - - - pdu: ModbusPDU = read_buffer.read_complex(read_function=ModbusPDU.static_parse, logical_name="pdu", byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - - - crc: int = read_buffer.read_unsigned_byte(logical_name="crc", byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) + address: int = read_buffer.read_unsigned_byte( + logical_name="address", + bit_length=8, + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + pdu: ModbusPDU = read_buffer.read_complex( + read_function=ModbusPDU.static_parse, + logical_name="pdu", + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + crc: int = read_buffer.read_unsigned_byte( + logical_name="crc", + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) read_buffer.pop_context("ModbusAsciiADU") # Create the instance - return ModbusAsciiADUBuilder(address, pdu ) - + return ModbusAsciiADUBuilder(address, pdu) def equals(self, o: object) -> bool: if self == o: @@ -111,20 +125,25 @@ def equals(self, o: object) -> bool: return False that: ModbusAsciiADU = ModbusAsciiADU(o) - return (self.address == that.address) and (self.pdu == that.pdu) and super().equals(that) and True + return ( + (self.address == that.address) + and (self.pdu == that.pdu) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -132,9 +151,11 @@ class ModbusAsciiADUBuilder: address: int pdu: ModbusPDU - def build(self,response: bool , ) -> ModbusAsciiADU: - modbus_ascii_adu: ModbusAsciiADU = ModbusAsciiADU(response , self.address, self.pdu ) + def build( + self, + response: bool, + ) -> ModbusAsciiADU: + modbus_ascii_adu: ModbusAsciiADU = ModbusAsciiADU( + response, self.address, self.pdu + ) return modbus_ascii_adu - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py index 746bef1b82a..3047aab843c 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py @@ -25,22 +25,22 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - -@dataclass -class ModbusConstants(): - MODBUS_TCP_DEFAULT_PORT: int = int(502) +@dataclass +class ModbusConstants: + MODBUS_TCP_DEFAULT_PORT: int = int(502) def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusConstants") # Const Field (modbusTcpDefaultPort) - write_buffer.write_unsigned_short(self.MODBUS_TCP_DEFAULT_PORT, logical_name="modbusTcpDefaultPort") + write_buffer.write_unsigned_short( + self.MODBUS_TCP_DEFAULT_PORT, logical_name="modbusTcpDefaultPort" + ) write_buffer.pop_context("ModbusConstants") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,26 +53,23 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return ModbusConstants.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("ModbusConstants") - - - MODBUS_TCP_DEFAULT_PORT: int = read_buffer.read_unsigned_short(logical_name="modbus_tcp_default_port") + MODBUS_TCP_DEFAULT_PORT: int = read_buffer.read_unsigned_short( + logical_name="modbus_tcp_default_port" + ) read_buffer.pop_context("ModbusConstants") # Create the instance _modbus_constants: ModbusConstants = ModbusConstants() return _modbus_constants - def equals(self, o: object) -> bool: if self == o: return True @@ -88,14 +85,10 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py index ba37b720fe7..9bc61ebba4e 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py @@ -19,38 +19,36 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - -class ModbusDataType(AutoNumberEnum): - _init_ = "value, data_type_size" - BOOL = (1 , int(2) ) - BYTE = (2 , int(2) ) - WORD = (3 , int(2) ) - DWORD = (4 , int(4) ) - LWORD = (5 , int(8) ) - SINT = (6 , int(2) ) - INT = (7 , int(2) ) - DINT = (8 , int(4) ) - LINT = (9 , int(8) ) - USINT = (10 , int(2) ) - UINT = (11 , int(2) ) - UDINT = (12 , int(4) ) - ULINT = (13 , int(8) ) - REAL = (14 , int(4) ) - LREAL = (15 , int(8) ) - TIME = (16 , int(8) ) - LTIME = (17 , int(8) ) - DATE = (18 , int(8) ) - LDATE = (19 , int(8) ) - TIME_OF_DAY = (20 , int(8) ) - LTIME_OF_DAY = (21 , int(8) ) - DATE_AND_TIME = (22 , int(8) ) - LDATE_AND_TIME = (23 , int(8) ) - CHAR = (24 , int(1) ) - WCHAR = (25 , int(2) ) - STRING = (26 , int(1) ) - WSTRING = (27 , int(2) ) - RAW_COIL = (98 , int(1) ) - RAW_REGISTER = (99 , int(2) ) - +class ModbusDataType(AutoNumberEnum): + _init_ = "value, data_type_size" + BOOL = (1, int(2)) + BYTE = (2, int(2)) + WORD = (3, int(2)) + DWORD = (4, int(4)) + LWORD = (5, int(8)) + SINT = (6, int(2)) + INT = (7, int(2)) + DINT = (8, int(4)) + LINT = (9, int(8)) + USINT = (10, int(2)) + UINT = (11, int(2)) + UDINT = (12, int(4)) + ULINT = (13, int(8)) + REAL = (14, int(4)) + LREAL = (15, int(8)) + TIME = (16, int(8)) + LTIME = (17, int(8)) + DATE = (18, int(8)) + LDATE = (19, int(8)) + TIME_OF_DAY = (20, int(8)) + LTIME_OF_DAY = (21, int(8)) + DATE_AND_TIME = (22, int(8)) + LDATE_AND_TIME = (23, int(8)) + CHAR = (24, int(1)) + WCHAR = (25, int(2)) + STRING = (26, int(1)) + WSTRING = (27, int(2)) + RAW_COIL = (98, int(1)) + RAW_REGISTER = (99, int(2)) diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py index c637a32421a..1c6b6c2e15c 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py @@ -19,12 +19,10 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - + + class ModbusDeviceInformationConformityLevel(AutoNumberEnum): - + BASIC_STREAM_ONLY: int = 0x01 REGULAR_STREAM_ONLY: int = 0x02 EXTENDED_STREAM_ONLY: int = 0x03 - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py index eca833ecf48..34300606ba5 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py @@ -19,13 +19,11 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - + + class ModbusDeviceInformationLevel(AutoNumberEnum): - + BASIC: int = 0x01 REGULAR: int = 0x02 EXTENDED: int = 0x03 INDIVIDUAL: int = 0x04 - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py index 9162add3032..1c613af6ecb 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py @@ -19,11 +19,9 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - -class ModbusDeviceInformationMoreFollows(AutoNumberEnum): - - NO_MORE_OBJECTS_AVAILABLE: int = 0x00 - MORE_OBJECTS_AVAILABLE: int = 0xFF +class ModbusDeviceInformationMoreFollows(AutoNumberEnum): + NO_MORE_OBJECTS_AVAILABLE: int = 0x00 + MORE_OBJECTS_AVAILABLE: int = 0xFF diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py index 39fbae97e22..f862361bd62 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py @@ -27,22 +27,23 @@ from typing import Any from typing import List import math - + + @dataclass -class ModbusDeviceInformationObject(): +class ModbusDeviceInformationObject: object_id: int data: List[int] - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusDeviceInformationObject") # Simple Field (objectId) - write_buffer.write_unsigned_byte(self.object_id,bit_length=8,logical_name="objectId") + write_buffer.write_unsigned_byte( + self.object_id, bit_length=8, logical_name="objectId" + ) # Implicit Field (object_length) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - object_length: int = (int(len(self.data))) + object_length: int = int(len(self.data)) write_buffer.write_unsigned_byte(object_length, logical_name="object_length") # Array Field (data) @@ -50,7 +51,6 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusDeviceInformationObject") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,35 +68,37 @@ def length_in_bits(self) -> int: if self.data is not None: length_in_bits += 8 * len(self.data) - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return ModbusDeviceInformationObject.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("ModbusDeviceInformationObject") + object_id: int = read_buffer.read_unsigned_byte( + logical_name="object_id", bit_length=8 + ) + object_length: int = read_buffer.read_unsigned_byte( + logical_name="object_length" + ) - object_id: int = read_buffer.read_unsigned_byte(logical_name="object_id", bit_length=8) - - - - object_length: int = read_buffer.read_unsigned_byte(logical_name="object_length") - - data: List[Any] = read_buffer.read_array_field(logical_name="data", read_function=read_buffer.read_byte, count=object_length) + data: List[Any] = read_buffer.read_array_field( + logical_name="data", + read_function=read_buffer.read_byte, + count=object_length, + ) read_buffer.pop_context("ModbusDeviceInformationObject") # Create the instance - _modbus_device_information_object: ModbusDeviceInformationObject = ModbusDeviceInformationObject(object_id, data ) + _modbus_device_information_object: ModbusDeviceInformationObject = ( + ModbusDeviceInformationObject(object_id, data) + ) return _modbus_device_information_object - def equals(self, o: object) -> bool: if self == o: return True @@ -112,14 +114,10 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py index 3f626e23744..bfbad8d872b 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py @@ -19,9 +19,10 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - + + class ModbusErrorCode(AutoNumberEnum): - + ILLEGAL_FUNCTION: int = 1 ILLEGAL_DATA_ADDRESS: int = 2 ILLEGAL_DATA_VALUE: int = 3 @@ -32,6 +33,3 @@ class ModbusErrorCode(AutoNumberEnum): MEMORY_PARITY_ERROR: int = 8 GATEWAY_PATH_UNAVAILABLE: int = 10 GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND: int = 11 - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py index bf75a36da6b..f9d904881ff 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py @@ -29,7 +29,8 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass class ModbusPDU(ABC, PlcMessage): @@ -37,14 +38,15 @@ class ModbusPDU(ABC, PlcMessage): @property def error_flag(self) -> bool: pass + @property def function_flag(self) -> int: pass + @property def response(self) -> bool: pass - @abstractmethod def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer) -> None: pass @@ -53,17 +55,18 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDU") # Discriminator Field (errorFlag) (Used as input to a switch field) - write_buffer.write_bit(self.error_flag, logical_name="error_flag", bit_length=1 ) + write_buffer.write_bit(self.error_flag, logical_name="error_flag", bit_length=1) # Discriminator Field (functionFlag) (Used as input to a switch field) - write_buffer.write_unsigned_byte(self.function_flag, logical_name="function_flag", bit_length=7 ) + write_buffer.write_unsigned_byte( + self.function_flag, logical_name="function_flag", bit_length=7 + ) # Switch field (Serialize the sub-type) self.serialize_modbus_pdu_child(write_buffer) write_buffer.pop_context("ModbusPDU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -81,12 +84,13 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): if kwargs is None: - raise PlcRuntimeException("Wrong number of arguments, expected 1, but got None") + raise PlcRuntimeException( + "Wrong number of arguments, expected 1, but got None" + ) response: bool = False if isinstance(kwargs.get("response"), bool): @@ -94,11 +98,13 @@ def static_parse(read_buffer: ReadBuffer, **kwargs): elif isinstance(kwargs.get("response"), str): response = bool(str(kwargs.get("response"))) else: - raise PlcRuntimeException("Argument 0 expected to be of type bool or a string which is parseable but was " + kwargs.get("response").getClass().getName()) + raise PlcRuntimeException( + "Argument 0 expected to be of type bool or a string which is parseable but was " + + kwargs.get("response").getClass().getName() + ) return ModbusPDU.static_parse_context(read_buffer, response) - @staticmethod def static_parse_context(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDU") @@ -106,181 +112,543 @@ def static_parse_context(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - error_flag: bool = read_buffer.read_bit(logical_name="error_flag", bit_length=1, response=response) - - - function_flag: int = read_buffer.read_unsigned_byte(logical_name="function_flag", bit_length=7, response=response) - + error_flag: bool = read_buffer.read_bit( + logical_name="error_flag", bit_length=1, response=response + ) + function_flag: int = read_buffer.read_unsigned_byte( + logical_name="function_flag", bit_length=7, response=response + ) # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type) builder: ModbusPDUBuilder = None from plc4py.protocols.modbus.readwrite.ModbusPDUError import ModbusPDUError - if error_flag == bool(True) : - - builder = ModbusPDUError.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadDiscreteInputsRequest import ModbusPDUReadDiscreteInputsRequest - if error_flag == bool(False) and function_flag == int(0x02) and response == bool(False) : - - builder = ModbusPDUReadDiscreteInputsRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadDiscreteInputsResponse import ModbusPDUReadDiscreteInputsResponse - if error_flag == bool(False) and function_flag == int(0x02) and response == bool(True) : - - builder = ModbusPDUReadDiscreteInputsResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadCoilsRequest import ModbusPDUReadCoilsRequest - if error_flag == bool(False) and function_flag == int(0x01) and response == bool(False) : - - builder = ModbusPDUReadCoilsRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadCoilsResponse import ModbusPDUReadCoilsResponse - if error_flag == bool(False) and function_flag == int(0x01) and response == bool(True) : - - builder = ModbusPDUReadCoilsResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleCoilRequest import ModbusPDUWriteSingleCoilRequest - if error_flag == bool(False) and function_flag == int(0x05) and response == bool(False) : - - builder = ModbusPDUWriteSingleCoilRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleCoilResponse import ModbusPDUWriteSingleCoilResponse - if error_flag == bool(False) and function_flag == int(0x05) and response == bool(True) : - - builder = ModbusPDUWriteSingleCoilResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleCoilsRequest import ModbusPDUWriteMultipleCoilsRequest - if error_flag == bool(False) and function_flag == int(0x0F) and response == bool(False) : - - builder = ModbusPDUWriteMultipleCoilsRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleCoilsResponse import ModbusPDUWriteMultipleCoilsResponse - if error_flag == bool(False) and function_flag == int(0x0F) and response == bool(True) : - - builder = ModbusPDUWriteMultipleCoilsResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadInputRegistersRequest import ModbusPDUReadInputRegistersRequest - if error_flag == bool(False) and function_flag == int(0x04) and response == bool(False) : - - builder = ModbusPDUReadInputRegistersRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadInputRegistersResponse import ModbusPDUReadInputRegistersResponse - if error_flag == bool(False) and function_flag == int(0x04) and response == bool(True) : - - builder = ModbusPDUReadInputRegistersResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadHoldingRegistersRequest import ModbusPDUReadHoldingRegistersRequest - if error_flag == bool(False) and function_flag == int(0x03) and response == bool(False) : - - builder = ModbusPDUReadHoldingRegistersRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadHoldingRegistersResponse import ModbusPDUReadHoldingRegistersResponse - if error_flag == bool(False) and function_flag == int(0x03) and response == bool(True) : - - builder = ModbusPDUReadHoldingRegistersResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleRegisterRequest import ModbusPDUWriteSingleRegisterRequest - if error_flag == bool(False) and function_flag == int(0x06) and response == bool(False) : - - builder = ModbusPDUWriteSingleRegisterRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleRegisterResponse import ModbusPDUWriteSingleRegisterResponse - if error_flag == bool(False) and function_flag == int(0x06) and response == bool(True) : - - builder = ModbusPDUWriteSingleRegisterResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleHoldingRegistersRequest import ModbusPDUWriteMultipleHoldingRegistersRequest - if error_flag == bool(False) and function_flag == int(0x10) and response == bool(False) : - - builder = ModbusPDUWriteMultipleHoldingRegistersRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleHoldingRegistersResponse import ModbusPDUWriteMultipleHoldingRegistersResponse - if error_flag == bool(False) and function_flag == int(0x10) and response == bool(True) : - - builder = ModbusPDUWriteMultipleHoldingRegistersResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadWriteMultipleHoldingRegistersRequest import ModbusPDUReadWriteMultipleHoldingRegistersRequest - if error_flag == bool(False) and function_flag == int(0x17) and response == bool(False) : - builder = ModbusPDUReadWriteMultipleHoldingRegistersRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadWriteMultipleHoldingRegistersResponse import ModbusPDUReadWriteMultipleHoldingRegistersResponse - if error_flag == bool(False) and function_flag == int(0x17) and response == bool(True) : + if error_flag == bool(True): - builder = ModbusPDUReadWriteMultipleHoldingRegistersResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUMaskWriteHoldingRegisterRequest import ModbusPDUMaskWriteHoldingRegisterRequest - if error_flag == bool(False) and function_flag == int(0x16) and response == bool(False) : - - builder = ModbusPDUMaskWriteHoldingRegisterRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUMaskWriteHoldingRegisterResponse import ModbusPDUMaskWriteHoldingRegisterResponse - if error_flag == bool(False) and function_flag == int(0x16) and response == bool(True) : - - builder = ModbusPDUMaskWriteHoldingRegisterResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadFifoQueueRequest import ModbusPDUReadFifoQueueRequest - if error_flag == bool(False) and function_flag == int(0x18) and response == bool(False) : - - builder = ModbusPDUReadFifoQueueRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadFifoQueueResponse import ModbusPDUReadFifoQueueResponse - if error_flag == bool(False) and function_flag == int(0x18) and response == bool(True) : - - builder = ModbusPDUReadFifoQueueResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordRequest import ModbusPDUReadFileRecordRequest - if error_flag == bool(False) and function_flag == int(0x14) and response == bool(False) : - - builder = ModbusPDUReadFileRecordRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordResponse import ModbusPDUReadFileRecordResponse - if error_flag == bool(False) and function_flag == int(0x14) and response == bool(True) : - - builder = ModbusPDUReadFileRecordResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordRequest import ModbusPDUWriteFileRecordRequest - if error_flag == bool(False) and function_flag == int(0x15) and response == bool(False) : - - builder = ModbusPDUWriteFileRecordRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordResponse import ModbusPDUWriteFileRecordResponse - if error_flag == bool(False) and function_flag == int(0x15) and response == bool(True) : - - builder = ModbusPDUWriteFileRecordResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadExceptionStatusRequest import ModbusPDUReadExceptionStatusRequest - if error_flag == bool(False) and function_flag == int(0x07) and response == bool(False) : - - builder = ModbusPDUReadExceptionStatusRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadExceptionStatusResponse import ModbusPDUReadExceptionStatusResponse - if error_flag == bool(False) and function_flag == int(0x07) and response == bool(True) : - - builder = ModbusPDUReadExceptionStatusResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUDiagnosticRequest import ModbusPDUDiagnosticRequest - if error_flag == bool(False) and function_flag == int(0x08) and response == bool(False) : - - builder = ModbusPDUDiagnosticRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUDiagnosticResponse import ModbusPDUDiagnosticResponse - if error_flag == bool(False) and function_flag == int(0x08) and response == bool(True) : - - builder = ModbusPDUDiagnosticResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventCounterRequest import ModbusPDUGetComEventCounterRequest - if error_flag == bool(False) and function_flag == int(0x0B) and response == bool(False) : - - builder = ModbusPDUGetComEventCounterRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventCounterResponse import ModbusPDUGetComEventCounterResponse - if error_flag == bool(False) and function_flag == int(0x0B) and response == bool(True) : - - builder = ModbusPDUGetComEventCounterResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventLogRequest import ModbusPDUGetComEventLogRequest - if error_flag == bool(False) and function_flag == int(0x0C) and response == bool(False) : - - builder = ModbusPDUGetComEventLogRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventLogResponse import ModbusPDUGetComEventLogResponse - if error_flag == bool(False) and function_flag == int(0x0C) and response == bool(True) : - - builder = ModbusPDUGetComEventLogResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReportServerIdRequest import ModbusPDUReportServerIdRequest - if error_flag == bool(False) and function_flag == int(0x11) and response == bool(False) : - - builder = ModbusPDUReportServerIdRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReportServerIdResponse import ModbusPDUReportServerIdResponse - if error_flag == bool(False) and function_flag == int(0x11) and response == bool(True) : - - builder = ModbusPDUReportServerIdResponse.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadDeviceIdentificationRequest import ModbusPDUReadDeviceIdentificationRequest - if error_flag == bool(False) and function_flag == int(0x2B) and response == bool(False) : - - builder = ModbusPDUReadDeviceIdentificationRequest.static_parse_builder(read_buffer, response) - from plc4py.protocols.modbus.readwrite.ModbusPDUReadDeviceIdentificationResponse import ModbusPDUReadDeviceIdentificationResponse - if error_flag == bool(False) and function_flag == int(0x2B) and response == bool(True) : - - builder = ModbusPDUReadDeviceIdentificationResponse.static_parse_builder(read_buffer, response) + builder = ModbusPDUError.static_parse_builder(read_buffer, response) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadDiscreteInputsRequest import ( + ModbusPDUReadDiscreteInputsRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x02) + and response == bool(False) + ): + + builder = ModbusPDUReadDiscreteInputsRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadDiscreteInputsResponse import ( + ModbusPDUReadDiscreteInputsResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x02) + and response == bool(True) + ): + + builder = ModbusPDUReadDiscreteInputsResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadCoilsRequest import ( + ModbusPDUReadCoilsRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x01) + and response == bool(False) + ): + + builder = ModbusPDUReadCoilsRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadCoilsResponse import ( + ModbusPDUReadCoilsResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x01) + and response == bool(True) + ): + + builder = ModbusPDUReadCoilsResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleCoilRequest import ( + ModbusPDUWriteSingleCoilRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x05) + and response == bool(False) + ): + + builder = ModbusPDUWriteSingleCoilRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleCoilResponse import ( + ModbusPDUWriteSingleCoilResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x05) + and response == bool(True) + ): + + builder = ModbusPDUWriteSingleCoilResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleCoilsRequest import ( + ModbusPDUWriteMultipleCoilsRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x0F) + and response == bool(False) + ): + + builder = ModbusPDUWriteMultipleCoilsRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleCoilsResponse import ( + ModbusPDUWriteMultipleCoilsResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x0F) + and response == bool(True) + ): + + builder = ModbusPDUWriteMultipleCoilsResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadInputRegistersRequest import ( + ModbusPDUReadInputRegistersRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x04) + and response == bool(False) + ): + + builder = ModbusPDUReadInputRegistersRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadInputRegistersResponse import ( + ModbusPDUReadInputRegistersResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x04) + and response == bool(True) + ): + + builder = ModbusPDUReadInputRegistersResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadHoldingRegistersRequest import ( + ModbusPDUReadHoldingRegistersRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x03) + and response == bool(False) + ): + + builder = ModbusPDUReadHoldingRegistersRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadHoldingRegistersResponse import ( + ModbusPDUReadHoldingRegistersResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x03) + and response == bool(True) + ): + + builder = ModbusPDUReadHoldingRegistersResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleRegisterRequest import ( + ModbusPDUWriteSingleRegisterRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x06) + and response == bool(False) + ): + + builder = ModbusPDUWriteSingleRegisterRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteSingleRegisterResponse import ( + ModbusPDUWriteSingleRegisterResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x06) + and response == bool(True) + ): + + builder = ModbusPDUWriteSingleRegisterResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleHoldingRegistersRequest import ( + ModbusPDUWriteMultipleHoldingRegistersRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x10) + and response == bool(False) + ): + + builder = ( + ModbusPDUWriteMultipleHoldingRegistersRequest.static_parse_builder( + read_buffer, response + ) + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteMultipleHoldingRegistersResponse import ( + ModbusPDUWriteMultipleHoldingRegistersResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x10) + and response == bool(True) + ): + + builder = ( + ModbusPDUWriteMultipleHoldingRegistersResponse.static_parse_builder( + read_buffer, response + ) + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadWriteMultipleHoldingRegistersRequest import ( + ModbusPDUReadWriteMultipleHoldingRegistersRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x17) + and response == bool(False) + ): + + builder = ( + ModbusPDUReadWriteMultipleHoldingRegistersRequest.static_parse_builder( + read_buffer, response + ) + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadWriteMultipleHoldingRegistersResponse import ( + ModbusPDUReadWriteMultipleHoldingRegistersResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x17) + and response == bool(True) + ): + + builder = ( + ModbusPDUReadWriteMultipleHoldingRegistersResponse.static_parse_builder( + read_buffer, response + ) + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUMaskWriteHoldingRegisterRequest import ( + ModbusPDUMaskWriteHoldingRegisterRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x16) + and response == bool(False) + ): + + builder = ModbusPDUMaskWriteHoldingRegisterRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUMaskWriteHoldingRegisterResponse import ( + ModbusPDUMaskWriteHoldingRegisterResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x16) + and response == bool(True) + ): + + builder = ModbusPDUMaskWriteHoldingRegisterResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadFifoQueueRequest import ( + ModbusPDUReadFifoQueueRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x18) + and response == bool(False) + ): + + builder = ModbusPDUReadFifoQueueRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadFifoQueueResponse import ( + ModbusPDUReadFifoQueueResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x18) + and response == bool(True) + ): + + builder = ModbusPDUReadFifoQueueResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordRequest import ( + ModbusPDUReadFileRecordRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x14) + and response == bool(False) + ): + + builder = ModbusPDUReadFileRecordRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordResponse import ( + ModbusPDUReadFileRecordResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x14) + and response == bool(True) + ): + + builder = ModbusPDUReadFileRecordResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordRequest import ( + ModbusPDUWriteFileRecordRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x15) + and response == bool(False) + ): + + builder = ModbusPDUWriteFileRecordRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordResponse import ( + ModbusPDUWriteFileRecordResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x15) + and response == bool(True) + ): + + builder = ModbusPDUWriteFileRecordResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadExceptionStatusRequest import ( + ModbusPDUReadExceptionStatusRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x07) + and response == bool(False) + ): + + builder = ModbusPDUReadExceptionStatusRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadExceptionStatusResponse import ( + ModbusPDUReadExceptionStatusResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x07) + and response == bool(True) + ): + + builder = ModbusPDUReadExceptionStatusResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUDiagnosticRequest import ( + ModbusPDUDiagnosticRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x08) + and response == bool(False) + ): + + builder = ModbusPDUDiagnosticRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUDiagnosticResponse import ( + ModbusPDUDiagnosticResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x08) + and response == bool(True) + ): + + builder = ModbusPDUDiagnosticResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventCounterRequest import ( + ModbusPDUGetComEventCounterRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x0B) + and response == bool(False) + ): + + builder = ModbusPDUGetComEventCounterRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventCounterResponse import ( + ModbusPDUGetComEventCounterResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x0B) + and response == bool(True) + ): + + builder = ModbusPDUGetComEventCounterResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventLogRequest import ( + ModbusPDUGetComEventLogRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x0C) + and response == bool(False) + ): + + builder = ModbusPDUGetComEventLogRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUGetComEventLogResponse import ( + ModbusPDUGetComEventLogResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x0C) + and response == bool(True) + ): + + builder = ModbusPDUGetComEventLogResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReportServerIdRequest import ( + ModbusPDUReportServerIdRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x11) + and response == bool(False) + ): + + builder = ModbusPDUReportServerIdRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReportServerIdResponse import ( + ModbusPDUReportServerIdResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x11) + and response == bool(True) + ): + + builder = ModbusPDUReportServerIdResponse.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadDeviceIdentificationRequest import ( + ModbusPDUReadDeviceIdentificationRequest, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x2B) + and response == bool(False) + ): + + builder = ModbusPDUReadDeviceIdentificationRequest.static_parse_builder( + read_buffer, response + ) + from plc4py.protocols.modbus.readwrite.ModbusPDUReadDeviceIdentificationResponse import ( + ModbusPDUReadDeviceIdentificationResponse, + ) + + if ( + error_flag == bool(False) + and function_flag == int(0x2B) + and response == bool(True) + ): + + builder = ModbusPDUReadDeviceIdentificationResponse.static_parse_builder( + read_buffer, response + ) if builder is None: - raise ParseException("Unsupported case for discriminated type"+" parameters ["+"errorFlag="+str(error_flag)+" "+"functionFlag="+str(function_flag)+" "+"response="+str(response)+"]") - + raise ParseException( + "Unsupported case for discriminated type" + + " parameters [" + + "errorFlag=" + + str(error_flag) + + " " + + "functionFlag=" + + str(function_flag) + + " " + + "response=" + + str(response) + + "]" + ) read_buffer.pop_context("ModbusPDU") # Create the instance _modbus_pdu: ModbusPDU = builder.build() return _modbus_pdu - def equals(self, o: object) -> bool: if self == o: return True @@ -296,19 +664,18 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" + @dataclass class ModbusPDUBuilder: - def build(self, ) -> ModbusPDU: + def build( + self, + ) -> ModbusPDU: pass - - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py index 8b77a6b8e92..3015f728eab 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUDiagnosticRequest(ModbusPDU): sub_function: int @@ -38,20 +39,19 @@ class ModbusPDUDiagnosticRequest(ModbusPDU): function_flag: ClassVar[int] = 0x08 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUDiagnosticRequest") # Simple Field (subFunction) - write_buffer.write_unsigned_short(self.sub_function,bit_length=16,logical_name="subFunction") + write_buffer.write_unsigned_short( + self.sub_function, bit_length=16, logical_name="subFunction" + ) # Simple Field (data) - write_buffer.write_unsigned_short(self.data,bit_length=16,logical_name="data") + write_buffer.write_unsigned_short(self.data, bit_length=16, logical_name="data") write_buffer.pop_context("ModbusPDUDiagnosticRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +67,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUDiagnosticRequest") @@ -75,19 +74,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + sub_function: int = read_buffer.read_unsigned_short( + logical_name="sub_function", bit_length=16, response=response + ) - sub_function: int = read_buffer.read_unsigned_short(logical_name="sub_function", bit_length=16, response=response) - - - - data: int = read_buffer.read_unsigned_short(logical_name="data", bit_length=16, response=response) - - + data: int = read_buffer.read_unsigned_short( + logical_name="data", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUDiagnosticRequest") # Create the instance - return ModbusPDUDiagnosticRequestBuilder(sub_function, data ) - + return ModbusPDUDiagnosticRequestBuilder(sub_function, data) def equals(self, o: object) -> bool: if self == o: @@ -97,20 +94,25 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUDiagnosticRequest = ModbusPDUDiagnosticRequest(o) - return (self.sub_function == that.sub_function) and (self.data == that.data) and super().equals(that) and True + return ( + (self.sub_function == that.sub_function) + and (self.data == that.data) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +120,10 @@ class ModbusPDUDiagnosticRequestBuilder: sub_function: int data: int - def build(self,) -> ModbusPDUDiagnosticRequest: - modbus_pdudiagnostic_request: ModbusPDUDiagnosticRequest = ModbusPDUDiagnosticRequest(self.sub_function, self.data ) + def build( + self, + ) -> ModbusPDUDiagnosticRequest: + modbus_pdudiagnostic_request: ModbusPDUDiagnosticRequest = ( + ModbusPDUDiagnosticRequest(self.sub_function, self.data) + ) return modbus_pdudiagnostic_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py index 92907da71b6..cec882ff007 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUDiagnosticResponse(ModbusPDU): sub_function: int @@ -38,20 +39,19 @@ class ModbusPDUDiagnosticResponse(ModbusPDU): function_flag: ClassVar[int] = 0x08 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUDiagnosticResponse") # Simple Field (subFunction) - write_buffer.write_unsigned_short(self.sub_function,bit_length=16,logical_name="subFunction") + write_buffer.write_unsigned_short( + self.sub_function, bit_length=16, logical_name="subFunction" + ) # Simple Field (data) - write_buffer.write_unsigned_short(self.data,bit_length=16,logical_name="data") + write_buffer.write_unsigned_short(self.data, bit_length=16, logical_name="data") write_buffer.pop_context("ModbusPDUDiagnosticResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +67,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUDiagnosticResponse") @@ -75,19 +74,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + sub_function: int = read_buffer.read_unsigned_short( + logical_name="sub_function", bit_length=16, response=response + ) - sub_function: int = read_buffer.read_unsigned_short(logical_name="sub_function", bit_length=16, response=response) - - - - data: int = read_buffer.read_unsigned_short(logical_name="data", bit_length=16, response=response) - - + data: int = read_buffer.read_unsigned_short( + logical_name="data", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUDiagnosticResponse") # Create the instance - return ModbusPDUDiagnosticResponseBuilder(sub_function, data ) - + return ModbusPDUDiagnosticResponseBuilder(sub_function, data) def equals(self, o: object) -> bool: if self == o: @@ -97,20 +94,25 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUDiagnosticResponse = ModbusPDUDiagnosticResponse(o) - return (self.sub_function == that.sub_function) and (self.data == that.data) and super().equals(that) and True + return ( + (self.sub_function == that.sub_function) + and (self.data == that.data) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +120,10 @@ class ModbusPDUDiagnosticResponseBuilder: sub_function: int data: int - def build(self,) -> ModbusPDUDiagnosticResponse: - modbus_pdudiagnostic_response: ModbusPDUDiagnosticResponse = ModbusPDUDiagnosticResponse(self.sub_function, self.data ) + def build( + self, + ) -> ModbusPDUDiagnosticResponse: + modbus_pdudiagnostic_response: ModbusPDUDiagnosticResponse = ( + ModbusPDUDiagnosticResponse(self.sub_function, self.data) + ) return modbus_pdudiagnostic_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py index cbb107e3910..db1c6b8e81e 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py @@ -29,7 +29,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUError(ModbusPDU): exception_code: ModbusErrorCode @@ -38,17 +39,16 @@ class ModbusPDUError(ModbusPDU): function_flag: ClassVar[int] = 0 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUError") # Simple Field (exceptionCode) - write_buffer.write_unsigned_byte(self.exception_code, logical_name="exceptionCode") + write_buffer.write_unsigned_byte( + self.exception_code, logical_name="exceptionCode" + ) write_buffer.pop_context("ModbusPDUError") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -61,7 +61,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUError") @@ -69,15 +68,16 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - - exception_code: ModbusErrorCode = read_buffer.read_enum(read_function=ModbusErrorCode,bit_length=8, logical_name="exception_code", response=response) - - + exception_code: ModbusErrorCode = read_buffer.read_enum( + read_function=ModbusErrorCode, + bit_length=8, + logical_name="exception_code", + response=response, + ) read_buffer.pop_context("ModbusPDUError") # Create the instance - return ModbusPDUErrorBuilder(exception_code ) - + return ModbusPDUErrorBuilder(exception_code) def equals(self, o: object) -> bool: if self == o: @@ -87,29 +87,32 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUError = ModbusPDUError(o) - return (self.exception_code == that.exception_code) and super().equals(that) and True + return ( + (self.exception_code == that.exception_code) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUErrorBuilder: exception_code: ModbusErrorCode - def build(self,) -> ModbusPDUError: - modbus_pduerror: ModbusPDUError = ModbusPDUError(self.exception_code ) + def build( + self, + ) -> ModbusPDUError: + modbus_pduerror: ModbusPDUError = ModbusPDUError(self.exception_code) return modbus_pduerror - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py index 19eb40853a9..013e4fec3fb 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUGetComEventCounterRequest(ModbusPDU): # Accessors for discriminator values. @@ -36,14 +37,11 @@ class ModbusPDUGetComEventCounterRequest(ModbusPDU): function_flag: ClassVar[int] = 0x0B response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUGetComEventCounterRequest") write_buffer.pop_context("ModbusPDUGetComEventCounterRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,7 +51,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUGetComEventCounterRequest") @@ -61,12 +58,10 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - read_buffer.pop_context("ModbusPDUGetComEventCounterRequest") # Create the instance return ModbusPDUGetComEventCounterRequestBuilder() - def equals(self, o: object) -> bool: if self == o: return True @@ -82,21 +77,22 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUGetComEventCounterRequestBuilder: - def build(self,) -> ModbusPDUGetComEventCounterRequest: - modbus_pduget_com_event_counter_request: ModbusPDUGetComEventCounterRequest = ModbusPDUGetComEventCounterRequest() + def build( + self, + ) -> ModbusPDUGetComEventCounterRequest: + modbus_pduget_com_event_counter_request: ModbusPDUGetComEventCounterRequest = ( + ModbusPDUGetComEventCounterRequest() + ) return modbus_pduget_com_event_counter_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py index 3a28a3189d7..04e11662f55 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUGetComEventCounterResponse(ModbusPDU): status: int @@ -38,20 +39,21 @@ class ModbusPDUGetComEventCounterResponse(ModbusPDU): function_flag: ClassVar[int] = 0x0B response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUGetComEventCounterResponse") # Simple Field (status) - write_buffer.write_unsigned_short(self.status,bit_length=16,logical_name="status") + write_buffer.write_unsigned_short( + self.status, bit_length=16, logical_name="status" + ) # Simple Field (eventCount) - write_buffer.write_unsigned_short(self.event_count,bit_length=16,logical_name="eventCount") + write_buffer.write_unsigned_short( + self.event_count, bit_length=16, logical_name="eventCount" + ) write_buffer.pop_context("ModbusPDUGetComEventCounterResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUGetComEventCounterResponse") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + status: int = read_buffer.read_unsigned_short( + logical_name="status", bit_length=16, response=response + ) - status: int = read_buffer.read_unsigned_short(logical_name="status", bit_length=16, response=response) - - - - event_count: int = read_buffer.read_unsigned_short(logical_name="event_count", bit_length=16, response=response) - - + event_count: int = read_buffer.read_unsigned_short( + logical_name="event_count", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUGetComEventCounterResponse") # Create the instance - return ModbusPDUGetComEventCounterResponseBuilder(status, event_count ) - + return ModbusPDUGetComEventCounterResponseBuilder(status, event_count) def equals(self, o: object) -> bool: if self == o: @@ -96,21 +95,28 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUGetComEventCounterResponse): return False - that: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(o) - return (self.status == that.status) and (self.event_count == that.event_count) and super().equals(that) and True + that: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse( + o + ) + return ( + (self.status == that.status) + and (self.event_count == that.event_count) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +124,10 @@ class ModbusPDUGetComEventCounterResponseBuilder: status: int event_count: int - def build(self,) -> ModbusPDUGetComEventCounterResponse: - modbus_pduget_com_event_counter_response: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(self.status, self.event_count ) + def build( + self, + ) -> ModbusPDUGetComEventCounterResponse: + modbus_pduget_com_event_counter_response: ( + ModbusPDUGetComEventCounterResponse + ) = ModbusPDUGetComEventCounterResponse(self.status, self.event_count) return modbus_pduget_com_event_counter_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py index 982f531d6a4..e185d9a61fa 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUGetComEventLogRequest(ModbusPDU): # Accessors for discriminator values. @@ -36,14 +37,11 @@ class ModbusPDUGetComEventLogRequest(ModbusPDU): function_flag: ClassVar[int] = 0x0C response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUGetComEventLogRequest") write_buffer.pop_context("ModbusPDUGetComEventLogRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,7 +51,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUGetComEventLogRequest") @@ -61,12 +58,10 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - read_buffer.pop_context("ModbusPDUGetComEventLogRequest") # Create the instance return ModbusPDUGetComEventLogRequestBuilder() - def equals(self, o: object) -> bool: if self == o: return True @@ -82,21 +77,22 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUGetComEventLogRequestBuilder: - def build(self,) -> ModbusPDUGetComEventLogRequest: - modbus_pduget_com_event_log_request: ModbusPDUGetComEventLogRequest = ModbusPDUGetComEventLogRequest() + def build( + self, + ) -> ModbusPDUGetComEventLogRequest: + modbus_pduget_com_event_log_request: ModbusPDUGetComEventLogRequest = ( + ModbusPDUGetComEventLogRequest() + ) return modbus_pduget_com_event_log_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py index 44e7895a35c..47be82ad935 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUGetComEventLogResponse(ModbusPDU): status: int @@ -42,30 +43,33 @@ class ModbusPDUGetComEventLogResponse(ModbusPDU): function_flag: ClassVar[int] = 0x0C response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUGetComEventLogResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.events))+ int(6)) + byte_count: int = int(len(self.events)) + int(6) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Simple Field (status) - write_buffer.write_unsigned_short(self.status,bit_length=16,logical_name="status") + write_buffer.write_unsigned_short( + self.status, bit_length=16, logical_name="status" + ) # Simple Field (eventCount) - write_buffer.write_unsigned_short(self.event_count,bit_length=16,logical_name="eventCount") + write_buffer.write_unsigned_short( + self.event_count, bit_length=16, logical_name="eventCount" + ) # Simple Field (messageCount) - write_buffer.write_unsigned_short(self.message_count,bit_length=16,logical_name="messageCount") + write_buffer.write_unsigned_short( + self.message_count, bit_length=16, logical_name="messageCount" + ) # Array Field (events) write_buffer.write_byte_array(self.events, logical_name="events") write_buffer.pop_context("ModbusPDUGetComEventLogResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -89,10 +93,8 @@ def length_in_bits(self) -> int: if self.events is not None: length_in_bits += 8 * len(self.events) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUGetComEventLogResponse") @@ -100,27 +102,34 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - status: int = read_buffer.read_unsigned_short(logical_name="status", bit_length=16, response=response) - + status: int = read_buffer.read_unsigned_short( + logical_name="status", bit_length=16, response=response + ) + event_count: int = read_buffer.read_unsigned_short( + logical_name="event_count", bit_length=16, response=response + ) - event_count: int = read_buffer.read_unsigned_short(logical_name="event_count", bit_length=16, response=response) + message_count: int = read_buffer.read_unsigned_short( + logical_name="message_count", bit_length=16, response=response + ) - - - message_count: int = read_buffer.read_unsigned_short(logical_name="message_count", bit_length=16, response=response) - - - - events: List[Any] = read_buffer.read_array_field(logical_name="events", read_function=read_buffer.read_byte, count=byte_count- int(6), response=response) + events: List[Any] = read_buffer.read_array_field( + logical_name="events", + read_function=read_buffer.read_byte, + count=byte_count - int(6), + response=response, + ) read_buffer.pop_context("ModbusPDUGetComEventLogResponse") # Create the instance - return ModbusPDUGetComEventLogResponseBuilder(status, event_count, message_count, events ) - + return ModbusPDUGetComEventLogResponseBuilder( + status, event_count, message_count, events + ) def equals(self, o: object) -> bool: if self == o: @@ -130,20 +139,27 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUGetComEventLogResponse = ModbusPDUGetComEventLogResponse(o) - return (self.status == that.status) and (self.event_count == that.event_count) and (self.message_count == that.message_count) and (self.events == that.events) and super().equals(that) and True + return ( + (self.status == that.status) + and (self.event_count == that.event_count) + and (self.message_count == that.message_count) + and (self.events == that.events) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -153,9 +169,12 @@ class ModbusPDUGetComEventLogResponseBuilder: message_count: int events: List[int] - def build(self,) -> ModbusPDUGetComEventLogResponse: - modbus_pduget_com_event_log_response: ModbusPDUGetComEventLogResponse = ModbusPDUGetComEventLogResponse(self.status, self.event_count, self.message_count, self.events ) + def build( + self, + ) -> ModbusPDUGetComEventLogResponse: + modbus_pduget_com_event_log_response: ModbusPDUGetComEventLogResponse = ( + ModbusPDUGetComEventLogResponse( + self.status, self.event_count, self.message_count, self.events + ) + ) return modbus_pduget_com_event_log_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py index b1760dbdfe7..74d37ddf1bb 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUMaskWriteHoldingRegisterRequest(ModbusPDU): reference_address: int @@ -39,23 +40,26 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(ModbusPDU): function_flag: ClassVar[int] = 0x16 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUMaskWriteHoldingRegisterRequest") # Simple Field (referenceAddress) - write_buffer.write_unsigned_short(self.reference_address,bit_length=16,logical_name="referenceAddress") + write_buffer.write_unsigned_short( + self.reference_address, bit_length=16, logical_name="referenceAddress" + ) # Simple Field (andMask) - write_buffer.write_unsigned_short(self.and_mask,bit_length=16,logical_name="andMask") + write_buffer.write_unsigned_short( + self.and_mask, bit_length=16, logical_name="andMask" + ) # Simple Field (orMask) - write_buffer.write_unsigned_short(self.or_mask,bit_length=16,logical_name="orMask") + write_buffer.write_unsigned_short( + self.or_mask, bit_length=16, logical_name="orMask" + ) write_buffer.pop_context("ModbusPDUMaskWriteHoldingRegisterRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -74,7 +78,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUMaskWriteHoldingRegisterRequest") @@ -82,23 +85,23 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + reference_address: int = read_buffer.read_unsigned_short( + logical_name="reference_address", bit_length=16, response=response + ) - reference_address: int = read_buffer.read_unsigned_short(logical_name="reference_address", bit_length=16, response=response) - - - - and_mask: int = read_buffer.read_unsigned_short(logical_name="and_mask", bit_length=16, response=response) - - - - or_mask: int = read_buffer.read_unsigned_short(logical_name="or_mask", bit_length=16, response=response) - + and_mask: int = read_buffer.read_unsigned_short( + logical_name="and_mask", bit_length=16, response=response + ) + or_mask: int = read_buffer.read_unsigned_short( + logical_name="or_mask", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUMaskWriteHoldingRegisterRequest") # Create the instance - return ModbusPDUMaskWriteHoldingRegisterRequestBuilder(reference_address, and_mask, or_mask ) - + return ModbusPDUMaskWriteHoldingRegisterRequestBuilder( + reference_address, and_mask, or_mask + ) def equals(self, o: object) -> bool: if self == o: @@ -107,21 +110,29 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUMaskWriteHoldingRegisterRequest): return False - that: ModbusPDUMaskWriteHoldingRegisterRequest = ModbusPDUMaskWriteHoldingRegisterRequest(o) - return (self.reference_address == that.reference_address) and (self.and_mask == that.and_mask) and (self.or_mask == that.or_mask) and super().equals(that) and True + that: ModbusPDUMaskWriteHoldingRegisterRequest = ( + ModbusPDUMaskWriteHoldingRegisterRequest(o) + ) + return ( + (self.reference_address == that.reference_address) + and (self.and_mask == that.and_mask) + and (self.or_mask == that.or_mask) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -130,9 +141,12 @@ class ModbusPDUMaskWriteHoldingRegisterRequestBuilder: and_mask: int or_mask: int - def build(self,) -> ModbusPDUMaskWriteHoldingRegisterRequest: - modbus_pdumask_write_holding_register_request: ModbusPDUMaskWriteHoldingRegisterRequest = ModbusPDUMaskWriteHoldingRegisterRequest(self.reference_address, self.and_mask, self.or_mask ) + def build( + self, + ) -> ModbusPDUMaskWriteHoldingRegisterRequest: + modbus_pdumask_write_holding_register_request: ( + ModbusPDUMaskWriteHoldingRegisterRequest + ) = ModbusPDUMaskWriteHoldingRegisterRequest( + self.reference_address, self.and_mask, self.or_mask + ) return modbus_pdumask_write_holding_register_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py index c1b76cb1e22..6c927cc9366 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUMaskWriteHoldingRegisterResponse(ModbusPDU): reference_address: int @@ -39,23 +40,26 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(ModbusPDU): function_flag: ClassVar[int] = 0x16 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUMaskWriteHoldingRegisterResponse") # Simple Field (referenceAddress) - write_buffer.write_unsigned_short(self.reference_address,bit_length=16,logical_name="referenceAddress") + write_buffer.write_unsigned_short( + self.reference_address, bit_length=16, logical_name="referenceAddress" + ) # Simple Field (andMask) - write_buffer.write_unsigned_short(self.and_mask,bit_length=16,logical_name="andMask") + write_buffer.write_unsigned_short( + self.and_mask, bit_length=16, logical_name="andMask" + ) # Simple Field (orMask) - write_buffer.write_unsigned_short(self.or_mask,bit_length=16,logical_name="orMask") + write_buffer.write_unsigned_short( + self.or_mask, bit_length=16, logical_name="orMask" + ) write_buffer.pop_context("ModbusPDUMaskWriteHoldingRegisterResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -74,7 +78,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUMaskWriteHoldingRegisterResponse") @@ -82,23 +85,23 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + reference_address: int = read_buffer.read_unsigned_short( + logical_name="reference_address", bit_length=16, response=response + ) - reference_address: int = read_buffer.read_unsigned_short(logical_name="reference_address", bit_length=16, response=response) - - - - and_mask: int = read_buffer.read_unsigned_short(logical_name="and_mask", bit_length=16, response=response) - - - - or_mask: int = read_buffer.read_unsigned_short(logical_name="or_mask", bit_length=16, response=response) - + and_mask: int = read_buffer.read_unsigned_short( + logical_name="and_mask", bit_length=16, response=response + ) + or_mask: int = read_buffer.read_unsigned_short( + logical_name="or_mask", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUMaskWriteHoldingRegisterResponse") # Create the instance - return ModbusPDUMaskWriteHoldingRegisterResponseBuilder(reference_address, and_mask, or_mask ) - + return ModbusPDUMaskWriteHoldingRegisterResponseBuilder( + reference_address, and_mask, or_mask + ) def equals(self, o: object) -> bool: if self == o: @@ -107,21 +110,29 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUMaskWriteHoldingRegisterResponse): return False - that: ModbusPDUMaskWriteHoldingRegisterResponse = ModbusPDUMaskWriteHoldingRegisterResponse(o) - return (self.reference_address == that.reference_address) and (self.and_mask == that.and_mask) and (self.or_mask == that.or_mask) and super().equals(that) and True + that: ModbusPDUMaskWriteHoldingRegisterResponse = ( + ModbusPDUMaskWriteHoldingRegisterResponse(o) + ) + return ( + (self.reference_address == that.reference_address) + and (self.and_mask == that.and_mask) + and (self.or_mask == that.or_mask) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -130,9 +141,12 @@ class ModbusPDUMaskWriteHoldingRegisterResponseBuilder: and_mask: int or_mask: int - def build(self,) -> ModbusPDUMaskWriteHoldingRegisterResponse: - modbus_pdumask_write_holding_register_response: ModbusPDUMaskWriteHoldingRegisterResponse = ModbusPDUMaskWriteHoldingRegisterResponse(self.reference_address, self.and_mask, self.or_mask ) + def build( + self, + ) -> ModbusPDUMaskWriteHoldingRegisterResponse: + modbus_pdumask_write_holding_register_response: ( + ModbusPDUMaskWriteHoldingRegisterResponse + ) = ModbusPDUMaskWriteHoldingRegisterResponse( + self.reference_address, self.and_mask, self.or_mask + ) return modbus_pdumask_write_holding_register_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py index f1b47e43f4e..0ca0b2c92aa 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadCoilsRequest(ModbusPDU): starting_address: int @@ -38,20 +39,21 @@ class ModbusPDUReadCoilsRequest(ModbusPDU): function_flag: ClassVar[int] = 0x01 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadCoilsRequest") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) write_buffer.pop_context("ModbusPDUReadCoilsRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadCoilsRequest") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - - - - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUReadCoilsRequest") # Create the instance - return ModbusPDUReadCoilsRequestBuilder(starting_address, quantity ) - + return ModbusPDUReadCoilsRequestBuilder(starting_address, quantity) def equals(self, o: object) -> bool: if self == o: @@ -97,20 +96,25 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUReadCoilsRequest = ModbusPDUReadCoilsRequest(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and super().equals(that) and True + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +122,10 @@ class ModbusPDUReadCoilsRequestBuilder: starting_address: int quantity: int - def build(self,) -> ModbusPDUReadCoilsRequest: - modbus_pduread_coils_request: ModbusPDUReadCoilsRequest = ModbusPDUReadCoilsRequest(self.starting_address, self.quantity ) + def build( + self, + ) -> ModbusPDUReadCoilsRequest: + modbus_pduread_coils_request: ModbusPDUReadCoilsRequest = ( + ModbusPDUReadCoilsRequest(self.starting_address, self.quantity) + ) return modbus_pduread_coils_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py index e9aa3507882..2f08efdc1a9 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadCoilsResponse(ModbusPDU): value: List[int] @@ -39,13 +40,11 @@ class ModbusPDUReadCoilsResponse(ModbusPDU): function_flag: ClassVar[int] = 0x01 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadCoilsResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -53,7 +52,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadCoilsResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,10 +66,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadCoilsResponse") @@ -79,15 +75,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadCoilsResponse") # Create the instance - return ModbusPDUReadCoilsResponseBuilder(value ) - + return ModbusPDUReadCoilsResponseBuilder(value) def equals(self, o: object) -> bool: if self == o: @@ -104,22 +105,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadCoilsResponseBuilder: value: List[int] - def build(self,) -> ModbusPDUReadCoilsResponse: - modbus_pduread_coils_response: ModbusPDUReadCoilsResponse = ModbusPDUReadCoilsResponse(self.value ) + def build( + self, + ) -> ModbusPDUReadCoilsResponse: + modbus_pduread_coils_response: ModbusPDUReadCoilsResponse = ( + ModbusPDUReadCoilsResponse(self.value) + ) return modbus_pduread_coils_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py index 6b1a6cc95b8..ff2838f1318 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py @@ -23,13 +23,16 @@ from plc4py.api.exceptions.exceptions import PlcRuntimeException from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage -from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationLevel import ModbusDeviceInformationLevel +from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationLevel import ( + ModbusDeviceInformationLevel, +) from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadDeviceIdentificationRequest(ModbusPDU): level: ModbusDeviceInformationLevel @@ -40,8 +43,6 @@ class ModbusPDUReadDeviceIdentificationRequest(ModbusPDU): function_flag: ClassVar[int] = 0x2B response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadDeviceIdentificationRequest") @@ -52,11 +53,12 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.write_unsigned_byte(self.level, logical_name="level") # Simple Field (objectId) - write_buffer.write_unsigned_byte(self.object_id,bit_length=8,logical_name="objectId") + write_buffer.write_unsigned_byte( + self.object_id, bit_length=8, logical_name="objectId" + ) write_buffer.pop_context("ModbusPDUReadDeviceIdentificationRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -75,7 +77,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadDeviceIdentificationRequest") @@ -83,21 +84,24 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + MEI_TYPE: int = read_buffer.read_unsigned_byte( + logical_name="mei_type", response=response + ) - MEI_TYPE: int = read_buffer.read_unsigned_byte(logical_name="mei_type", response=response) - - level: ModbusDeviceInformationLevel = read_buffer.read_enum(read_function=ModbusDeviceInformationLevel,bit_length=8, logical_name="level", response=response) - - - - object_id: int = read_buffer.read_unsigned_byte(logical_name="object_id", bit_length=8, response=response) - + level: ModbusDeviceInformationLevel = read_buffer.read_enum( + read_function=ModbusDeviceInformationLevel, + bit_length=8, + logical_name="level", + response=response, + ) + object_id: int = read_buffer.read_unsigned_byte( + logical_name="object_id", bit_length=8, response=response + ) read_buffer.pop_context("ModbusPDUReadDeviceIdentificationRequest") # Create the instance - return ModbusPDUReadDeviceIdentificationRequestBuilder(level, object_id ) - + return ModbusPDUReadDeviceIdentificationRequestBuilder(level, object_id) def equals(self, o: object) -> bool: if self == o: @@ -106,21 +110,28 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadDeviceIdentificationRequest): return False - that: ModbusPDUReadDeviceIdentificationRequest = ModbusPDUReadDeviceIdentificationRequest(o) - return (self.level == that.level) and (self.object_id == that.object_id) and super().equals(that) and True + that: ModbusPDUReadDeviceIdentificationRequest = ( + ModbusPDUReadDeviceIdentificationRequest(o) + ) + return ( + (self.level == that.level) + and (self.object_id == that.object_id) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -128,9 +139,10 @@ class ModbusPDUReadDeviceIdentificationRequestBuilder: level: ModbusDeviceInformationLevel object_id: int - def build(self,) -> ModbusPDUReadDeviceIdentificationRequest: - modbus_pduread_device_identification_request: ModbusPDUReadDeviceIdentificationRequest = ModbusPDUReadDeviceIdentificationRequest(self.level, self.object_id ) + def build( + self, + ) -> ModbusPDUReadDeviceIdentificationRequest: + modbus_pduread_device_identification_request: ( + ModbusPDUReadDeviceIdentificationRequest + ) = ModbusPDUReadDeviceIdentificationRequest(self.level, self.object_id) return modbus_pduread_device_identification_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py index aca7d6a74fb..5b14e8da360 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py @@ -23,10 +23,18 @@ from plc4py.api.exceptions.exceptions import PlcRuntimeException from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage -from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationConformityLevel import ModbusDeviceInformationConformityLevel -from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationLevel import ModbusDeviceInformationLevel -from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationMoreFollows import ModbusDeviceInformationMoreFollows -from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationObject import ModbusDeviceInformationObject +from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationConformityLevel import ( + ModbusDeviceInformationConformityLevel, +) +from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationLevel import ( + ModbusDeviceInformationLevel, +) +from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationMoreFollows import ( + ModbusDeviceInformationMoreFollows, +) +from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationObject import ( + ModbusDeviceInformationObject, +) from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer @@ -34,7 +42,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadDeviceIdentificationResponse(ModbusPDU): level: ModbusDeviceInformationLevel @@ -49,8 +58,6 @@ class ModbusPDUReadDeviceIdentificationResponse(ModbusPDU): function_flag: ClassVar[int] = 0x2B response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadDeviceIdentificationResponse") @@ -61,27 +68,34 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.write_unsigned_byte(self.level, logical_name="level") # Simple Field (individualAccess) - write_buffer.write_bit(self.individual_access,bit_length=1,logical_name="individualAccess") + write_buffer.write_bit( + self.individual_access, bit_length=1, logical_name="individualAccess" + ) # Simple Field (conformityLevel) - write_buffer.write_unsigned_byte(self.conformity_level, logical_name="conformityLevel") + write_buffer.write_unsigned_byte( + self.conformity_level, logical_name="conformityLevel" + ) # Simple Field (moreFollows) write_buffer.write_unsigned_byte(self.more_follows, logical_name="moreFollows") # Simple Field (nextObjectId) - write_buffer.write_unsigned_byte(self.next_object_id,bit_length=8,logical_name="nextObjectId") + write_buffer.write_unsigned_byte( + self.next_object_id, bit_length=8, logical_name="nextObjectId" + ) # Implicit Field (number_of_objects) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - number_of_objects: int = (int(len(self.objects))) - write_buffer.write_unsigned_byte(number_of_objects, logical_name="number_of_objects") + number_of_objects: int = int(len(self.objects)) + write_buffer.write_unsigned_byte( + number_of_objects, logical_name="number_of_objects" + ) # Array Field (objects) write_buffer.write_complex_array(self.objects, logical_name="objects") write_buffer.pop_context("ModbusPDUReadDeviceIdentificationResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -115,11 +129,8 @@ def length_in_bits(self) -> int: for element in self.objects: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadDeviceIdentificationResponse") @@ -127,37 +138,62 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - - MEI_TYPE: int = read_buffer.read_unsigned_byte(logical_name="mei_type", response=response) - - level: ModbusDeviceInformationLevel = read_buffer.read_enum(read_function=ModbusDeviceInformationLevel,bit_length=8, logical_name="level", response=response) - - - - individual_access: bool = read_buffer.read_bit(logical_name="individual_access", bit_length=1, response=response) - - - - conformity_level: ModbusDeviceInformationConformityLevel = read_buffer.read_enum(read_function=ModbusDeviceInformationConformityLevel,bit_length=7, logical_name="conformity_level", response=response) - - - - more_follows: ModbusDeviceInformationMoreFollows = read_buffer.read_enum(read_function=ModbusDeviceInformationMoreFollows,bit_length=8, logical_name="more_follows", response=response) - - - - next_object_id: int = read_buffer.read_unsigned_byte(logical_name="next_object_id", bit_length=8, response=response) - - - - number_of_objects: int = read_buffer.read_unsigned_byte(logical_name="number_of_objects", response=response) - - objects: List[Any] = read_buffer.read_array_field(logical_name="objects", read_function=ModbusDeviceInformationObject.static_parse, count=number_of_objects, response=response) + MEI_TYPE: int = read_buffer.read_unsigned_byte( + logical_name="mei_type", response=response + ) + + level: ModbusDeviceInformationLevel = read_buffer.read_enum( + read_function=ModbusDeviceInformationLevel, + bit_length=8, + logical_name="level", + response=response, + ) + + individual_access: bool = read_buffer.read_bit( + logical_name="individual_access", bit_length=1, response=response + ) + + conformity_level: ModbusDeviceInformationConformityLevel = ( + read_buffer.read_enum( + read_function=ModbusDeviceInformationConformityLevel, + bit_length=7, + logical_name="conformity_level", + response=response, + ) + ) + + more_follows: ModbusDeviceInformationMoreFollows = read_buffer.read_enum( + read_function=ModbusDeviceInformationMoreFollows, + bit_length=8, + logical_name="more_follows", + response=response, + ) + + next_object_id: int = read_buffer.read_unsigned_byte( + logical_name="next_object_id", bit_length=8, response=response + ) + + number_of_objects: int = read_buffer.read_unsigned_byte( + logical_name="number_of_objects", response=response + ) + + objects: List[Any] = read_buffer.read_array_field( + logical_name="objects", + read_function=ModbusDeviceInformationObject.static_parse, + count=number_of_objects, + response=response, + ) read_buffer.pop_context("ModbusPDUReadDeviceIdentificationResponse") # Create the instance - return ModbusPDUReadDeviceIdentificationResponseBuilder(level, individual_access, conformity_level, more_follows, next_object_id, objects ) - + return ModbusPDUReadDeviceIdentificationResponseBuilder( + level, + individual_access, + conformity_level, + more_follows, + next_object_id, + objects, + ) def equals(self, o: object) -> bool: if self == o: @@ -166,21 +202,32 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadDeviceIdentificationResponse): return False - that: ModbusPDUReadDeviceIdentificationResponse = ModbusPDUReadDeviceIdentificationResponse(o) - return (self.level == that.level) and (self.individual_access == that.individual_access) and (self.conformity_level == that.conformity_level) and (self.more_follows == that.more_follows) and (self.next_object_id == that.next_object_id) and (self.objects == that.objects) and super().equals(that) and True + that: ModbusPDUReadDeviceIdentificationResponse = ( + ModbusPDUReadDeviceIdentificationResponse(o) + ) + return ( + (self.level == that.level) + and (self.individual_access == that.individual_access) + and (self.conformity_level == that.conformity_level) + and (self.more_follows == that.more_follows) + and (self.next_object_id == that.next_object_id) + and (self.objects == that.objects) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -192,9 +239,17 @@ class ModbusPDUReadDeviceIdentificationResponseBuilder: next_object_id: int objects: List[ModbusDeviceInformationObject] - def build(self,) -> ModbusPDUReadDeviceIdentificationResponse: - modbus_pduread_device_identification_response: ModbusPDUReadDeviceIdentificationResponse = ModbusPDUReadDeviceIdentificationResponse(self.level, self.individual_access, self.conformity_level, self.more_follows, self.next_object_id, self.objects ) + def build( + self, + ) -> ModbusPDUReadDeviceIdentificationResponse: + modbus_pduread_device_identification_response: ( + ModbusPDUReadDeviceIdentificationResponse + ) = ModbusPDUReadDeviceIdentificationResponse( + self.level, + self.individual_access, + self.conformity_level, + self.more_follows, + self.next_object_id, + self.objects, + ) return modbus_pduread_device_identification_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py index 228ca5cd932..d4b0be00670 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadDiscreteInputsRequest(ModbusPDU): starting_address: int @@ -38,20 +39,21 @@ class ModbusPDUReadDiscreteInputsRequest(ModbusPDU): function_flag: ClassVar[int] = 0x02 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadDiscreteInputsRequest") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) write_buffer.pop_context("ModbusPDUReadDiscreteInputsRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadDiscreteInputsRequest") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - - - - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUReadDiscreteInputsRequest") # Create the instance - return ModbusPDUReadDiscreteInputsRequestBuilder(starting_address, quantity ) - + return ModbusPDUReadDiscreteInputsRequestBuilder(starting_address, quantity) def equals(self, o: object) -> bool: if self == o: @@ -97,20 +96,25 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUReadDiscreteInputsRequest = ModbusPDUReadDiscreteInputsRequest(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and super().equals(that) and True + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +122,10 @@ class ModbusPDUReadDiscreteInputsRequestBuilder: starting_address: int quantity: int - def build(self,) -> ModbusPDUReadDiscreteInputsRequest: - modbus_pduread_discrete_inputs_request: ModbusPDUReadDiscreteInputsRequest = ModbusPDUReadDiscreteInputsRequest(self.starting_address, self.quantity ) + def build( + self, + ) -> ModbusPDUReadDiscreteInputsRequest: + modbus_pduread_discrete_inputs_request: ModbusPDUReadDiscreteInputsRequest = ( + ModbusPDUReadDiscreteInputsRequest(self.starting_address, self.quantity) + ) return modbus_pduread_discrete_inputs_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py index 57726d5ca2a..530fdea9512 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadDiscreteInputsResponse(ModbusPDU): value: List[int] @@ -39,13 +40,11 @@ class ModbusPDUReadDiscreteInputsResponse(ModbusPDU): function_flag: ClassVar[int] = 0x02 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadDiscreteInputsResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -53,7 +52,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadDiscreteInputsResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,10 +66,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadDiscreteInputsResponse") @@ -79,15 +75,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadDiscreteInputsResponse") # Create the instance - return ModbusPDUReadDiscreteInputsResponseBuilder(value ) - + return ModbusPDUReadDiscreteInputsResponseBuilder(value) def equals(self, o: object) -> bool: if self == o: @@ -96,7 +97,9 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadDiscreteInputsResponse): return False - that: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(o) + that: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse( + o + ) return (self.value == that.value) and super().equals(that) and True def hash_code(self) -> int: @@ -104,22 +107,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadDiscreteInputsResponseBuilder: value: List[int] - def build(self,) -> ModbusPDUReadDiscreteInputsResponse: - modbus_pduread_discrete_inputs_response: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(self.value ) + def build( + self, + ) -> ModbusPDUReadDiscreteInputsResponse: + modbus_pduread_discrete_inputs_response: ModbusPDUReadDiscreteInputsResponse = ( + ModbusPDUReadDiscreteInputsResponse(self.value) + ) return modbus_pduread_discrete_inputs_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py index eb44ec5086d..e209eb70950 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadExceptionStatusRequest(ModbusPDU): # Accessors for discriminator values. @@ -36,14 +37,11 @@ class ModbusPDUReadExceptionStatusRequest(ModbusPDU): function_flag: ClassVar[int] = 0x07 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadExceptionStatusRequest") write_buffer.pop_context("ModbusPDUReadExceptionStatusRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,7 +51,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadExceptionStatusRequest") @@ -61,12 +58,10 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - read_buffer.pop_context("ModbusPDUReadExceptionStatusRequest") # Create the instance return ModbusPDUReadExceptionStatusRequestBuilder() - def equals(self, o: object) -> bool: if self == o: return True @@ -74,7 +69,9 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadExceptionStatusRequest): return False - that: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest(o) + that: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest( + o + ) return super().equals(that) and True def hash_code(self) -> int: @@ -82,21 +79,22 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadExceptionStatusRequestBuilder: - def build(self,) -> ModbusPDUReadExceptionStatusRequest: - modbus_pduread_exception_status_request: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest() + def build( + self, + ) -> ModbusPDUReadExceptionStatusRequest: + modbus_pduread_exception_status_request: ModbusPDUReadExceptionStatusRequest = ( + ModbusPDUReadExceptionStatusRequest() + ) return modbus_pduread_exception_status_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py index 5f3130d1911..9a4e0aaaca7 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadExceptionStatusResponse(ModbusPDU): value: int @@ -37,17 +38,14 @@ class ModbusPDUReadExceptionStatusResponse(ModbusPDU): function_flag: ClassVar[int] = 0x07 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadExceptionStatusResponse") # Simple Field (value) - write_buffer.write_unsigned_byte(self.value,bit_length=8,logical_name="value") + write_buffer.write_unsigned_byte(self.value, bit_length=8, logical_name="value") write_buffer.pop_context("ModbusPDUReadExceptionStatusResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -60,7 +58,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadExceptionStatusResponse") @@ -68,15 +65,13 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - - value: int = read_buffer.read_unsigned_byte(logical_name="value", bit_length=8, response=response) - - + value: int = read_buffer.read_unsigned_byte( + logical_name="value", bit_length=8, response=response + ) read_buffer.pop_context("ModbusPDUReadExceptionStatusResponse") # Create the instance - return ModbusPDUReadExceptionStatusResponseBuilder(value ) - + return ModbusPDUReadExceptionStatusResponseBuilder(value) def equals(self, o: object) -> bool: if self == o: @@ -85,7 +80,9 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadExceptionStatusResponse): return False - that: ModbusPDUReadExceptionStatusResponse = ModbusPDUReadExceptionStatusResponse(o) + that: ModbusPDUReadExceptionStatusResponse = ( + ModbusPDUReadExceptionStatusResponse(o) + ) return (self.value == that.value) and super().equals(that) and True def hash_code(self) -> int: @@ -93,22 +90,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadExceptionStatusResponseBuilder: value: int - def build(self,) -> ModbusPDUReadExceptionStatusResponse: - modbus_pduread_exception_status_response: ModbusPDUReadExceptionStatusResponse = ModbusPDUReadExceptionStatusResponse(self.value ) + def build( + self, + ) -> ModbusPDUReadExceptionStatusResponse: + modbus_pduread_exception_status_response: ( + ModbusPDUReadExceptionStatusResponse + ) = ModbusPDUReadExceptionStatusResponse(self.value) return modbus_pduread_exception_status_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py index a214a67d5c8..5731478e4bc 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadFifoQueueRequest(ModbusPDU): fifo_pointer_address: int @@ -37,17 +38,16 @@ class ModbusPDUReadFifoQueueRequest(ModbusPDU): function_flag: ClassVar[int] = 0x18 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadFifoQueueRequest") # Simple Field (fifoPointerAddress) - write_buffer.write_unsigned_short(self.fifo_pointer_address,bit_length=16,logical_name="fifoPointerAddress") + write_buffer.write_unsigned_short( + self.fifo_pointer_address, bit_length=16, logical_name="fifoPointerAddress" + ) write_buffer.pop_context("ModbusPDUReadFifoQueueRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -60,7 +60,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadFifoQueueRequest") @@ -68,15 +67,13 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - - fifo_pointer_address: int = read_buffer.read_unsigned_short(logical_name="fifo_pointer_address", bit_length=16, response=response) - - + fifo_pointer_address: int = read_buffer.read_unsigned_short( + logical_name="fifo_pointer_address", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUReadFifoQueueRequest") # Create the instance - return ModbusPDUReadFifoQueueRequestBuilder(fifo_pointer_address ) - + return ModbusPDUReadFifoQueueRequestBuilder(fifo_pointer_address) def equals(self, o: object) -> bool: if self == o: @@ -86,29 +83,34 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUReadFifoQueueRequest = ModbusPDUReadFifoQueueRequest(o) - return (self.fifo_pointer_address == that.fifo_pointer_address) and super().equals(that) and True + return ( + (self.fifo_pointer_address == that.fifo_pointer_address) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadFifoQueueRequestBuilder: fifo_pointer_address: int - def build(self,) -> ModbusPDUReadFifoQueueRequest: - modbus_pduread_fifo_queue_request: ModbusPDUReadFifoQueueRequest = ModbusPDUReadFifoQueueRequest(self.fifo_pointer_address ) + def build( + self, + ) -> ModbusPDUReadFifoQueueRequest: + modbus_pduread_fifo_queue_request: ModbusPDUReadFifoQueueRequest = ( + ModbusPDUReadFifoQueueRequest(self.fifo_pointer_address) + ) return modbus_pduread_fifo_queue_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py index c9305901b68..52d49ecf63c 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadFifoQueueResponse(ModbusPDU): fifo_value: List[int] @@ -39,25 +40,26 @@ class ModbusPDUReadFifoQueueResponse(ModbusPDU): function_flag: ClassVar[int] = 0x18 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadFifoQueueResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = ((int(len(self.fifo_value))* int(2))+ int(2)) + byte_count: int = (int(len(self.fifo_value)) * int(2)) + int(2) write_buffer.write_unsigned_short(byte_count, logical_name="byte_count") # Implicit Field (fifo_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - fifo_count: int = ((int(len(self.fifo_value))* int(2))/ int(2)) + fifo_count: int = (int(len(self.fifo_value)) * int(2)) / int(2) write_buffer.write_unsigned_short(fifo_count, logical_name="fifo_count") # Array Field (fifoValue) - write_buffer.write_simple_array(self.fifo_value, write_buffer.write_unsigned_short, logical_name="fifo_value") + write_buffer.write_simple_array( + self.fifo_value, + write_buffer.write_unsigned_short, + logical_name="fifo_value", + ) write_buffer.pop_context("ModbusPDUReadFifoQueueResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -75,10 +77,8 @@ def length_in_bits(self) -> int: if self.fifo_value is not None: length_in_bits += 16 * len(self.fifo_value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadFifoQueueResponse") @@ -86,17 +86,24 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_short( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_short(logical_name="byte_count", response=response) - - fifo_count: int = read_buffer.read_unsigned_short(logical_name="fifo_count", response=response) + fifo_count: int = read_buffer.read_unsigned_short( + logical_name="fifo_count", response=response + ) - fifo_value: List[Any] = read_buffer.read_array_field(logical_name="fifoValue", read_function=read_buffer.read_unsigned_short, count=fifo_count, response=response) + fifo_value: List[Any] = read_buffer.read_array_field( + logical_name="fifoValue", + read_function=read_buffer.read_unsigned_short, + count=fifo_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadFifoQueueResponse") # Create the instance - return ModbusPDUReadFifoQueueResponseBuilder(fifo_value ) - + return ModbusPDUReadFifoQueueResponseBuilder(fifo_value) def equals(self, o: object) -> bool: if self == o: @@ -113,22 +120,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadFifoQueueResponseBuilder: fifo_value: List[int] - def build(self,) -> ModbusPDUReadFifoQueueResponse: - modbus_pduread_fifo_queue_response: ModbusPDUReadFifoQueueResponse = ModbusPDUReadFifoQueueResponse(self.fifo_value ) + def build( + self, + ) -> ModbusPDUReadFifoQueueResponse: + modbus_pduread_fifo_queue_response: ModbusPDUReadFifoQueueResponse = ( + ModbusPDUReadFifoQueueResponse(self.fifo_value) + ) return modbus_pduread_fifo_queue_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py index 0d9128c1c56..9e017d50bf8 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py @@ -24,7 +24,9 @@ from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU -from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordRequestItem import ModbusPDUReadFileRecordRequestItem +from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordRequestItem import ( + ModbusPDUReadFileRecordRequestItem, +) from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.spi.values.Common import get_size_of_array @@ -32,7 +34,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadFileRecordRequest(ModbusPDU): items: List[ModbusPDUReadFileRecordRequestItem] @@ -41,13 +44,11 @@ class ModbusPDUReadFileRecordRequest(ModbusPDU): function_flag: ClassVar[int] = 0x14 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadFileRecordRequest") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(get_size_of_array(self.items))) + byte_count: int = int(get_size_of_array(self.items)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (items) @@ -55,7 +56,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadFileRecordRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -71,11 +71,8 @@ def length_in_bits(self) -> int: for element in self.items: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadFileRecordRequest") @@ -83,15 +80,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - items: List[Any] = read_buffer.read_array_field(logical_name="items", read_function=ModbusPDUReadFileRecordRequestItem.static_parse, length=byte_count, response=response) + items: List[Any] = read_buffer.read_array_field( + logical_name="items", + read_function=ModbusPDUReadFileRecordRequestItem.static_parse, + length=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadFileRecordRequest") # Create the instance - return ModbusPDUReadFileRecordRequestBuilder(items ) - + return ModbusPDUReadFileRecordRequestBuilder(items) def equals(self, o: object) -> bool: if self == o: @@ -108,22 +110,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadFileRecordRequestBuilder: items: List[ModbusPDUReadFileRecordRequestItem] - def build(self,) -> ModbusPDUReadFileRecordRequest: - modbus_pduread_file_record_request: ModbusPDUReadFileRecordRequest = ModbusPDUReadFileRecordRequest(self.items ) + def build( + self, + ) -> ModbusPDUReadFileRecordRequest: + modbus_pduread_file_record_request: ModbusPDUReadFileRecordRequest = ( + ModbusPDUReadFileRecordRequest(self.items) + ) return modbus_pduread_file_record_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py index 241498bb7d6..82edeabe688 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py @@ -25,34 +25,40 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass -class ModbusPDUReadFileRecordRequestItem(): +class ModbusPDUReadFileRecordRequestItem: reference_type: int file_number: int record_number: int record_length: int - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadFileRecordRequestItem") # Simple Field (referenceType) - write_buffer.write_unsigned_byte(self.reference_type,bit_length=8,logical_name="referenceType") + write_buffer.write_unsigned_byte( + self.reference_type, bit_length=8, logical_name="referenceType" + ) # Simple Field (fileNumber) - write_buffer.write_unsigned_short(self.file_number,bit_length=16,logical_name="fileNumber") + write_buffer.write_unsigned_short( + self.file_number, bit_length=16, logical_name="fileNumber" + ) # Simple Field (recordNumber) - write_buffer.write_unsigned_short(self.record_number,bit_length=16,logical_name="recordNumber") + write_buffer.write_unsigned_short( + self.record_number, bit_length=16, logical_name="recordNumber" + ) # Simple Field (recordLength) - write_buffer.write_unsigned_short(self.record_length,bit_length=16,logical_name="recordLength") + write_buffer.write_unsigned_short( + self.record_length, bit_length=16, logical_name="recordLength" + ) write_buffer.pop_context("ModbusPDUReadFileRecordRequestItem") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -74,40 +80,39 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return ModbusPDUReadFileRecordRequestItem.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("ModbusPDUReadFileRecordRequestItem") + reference_type: int = read_buffer.read_unsigned_byte( + logical_name="reference_type", bit_length=8 + ) + file_number: int = read_buffer.read_unsigned_short( + logical_name="file_number", bit_length=16 + ) - reference_type: int = read_buffer.read_unsigned_byte(logical_name="reference_type", bit_length=8) - - - - file_number: int = read_buffer.read_unsigned_short(logical_name="file_number", bit_length=16) - - - - record_number: int = read_buffer.read_unsigned_short(logical_name="record_number", bit_length=16) - - - - record_length: int = read_buffer.read_unsigned_short(logical_name="record_length", bit_length=16) - + record_number: int = read_buffer.read_unsigned_short( + logical_name="record_number", bit_length=16 + ) + record_length: int = read_buffer.read_unsigned_short( + logical_name="record_length", bit_length=16 + ) read_buffer.pop_context("ModbusPDUReadFileRecordRequestItem") # Create the instance - _modbus_pduread_file_record_request_item: ModbusPDUReadFileRecordRequestItem = ModbusPDUReadFileRecordRequestItem(reference_type, file_number, record_number, record_length ) + _modbus_pduread_file_record_request_item: ModbusPDUReadFileRecordRequestItem = ( + ModbusPDUReadFileRecordRequestItem( + reference_type, file_number, record_number, record_length + ) + ) return _modbus_pduread_file_record_request_item - def equals(self, o: object) -> bool: if self == o: return True @@ -116,21 +121,23 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUReadFileRecordRequestItem = ModbusPDUReadFileRecordRequestItem(o) - return (self.reference_type == that.reference_type) and (self.file_number == that.file_number) and (self.record_number == that.record_number) and (self.record_length == that.record_length) and True + return ( + (self.reference_type == that.reference_type) + and (self.file_number == that.file_number) + and (self.record_number == that.record_number) + and (self.record_length == that.record_length) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py index ce7ee2546e7..1b5f16b5726 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py @@ -24,7 +24,9 @@ from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU -from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordResponseItem import ModbusPDUReadFileRecordResponseItem +from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordResponseItem import ( + ModbusPDUReadFileRecordResponseItem, +) from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.spi.values.Common import get_size_of_array @@ -32,7 +34,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadFileRecordResponse(ModbusPDU): items: List[ModbusPDUReadFileRecordResponseItem] @@ -41,13 +44,11 @@ class ModbusPDUReadFileRecordResponse(ModbusPDU): function_flag: ClassVar[int] = 0x14 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadFileRecordResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(get_size_of_array(self.items))) + byte_count: int = int(get_size_of_array(self.items)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (items) @@ -55,7 +56,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadFileRecordResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -71,11 +71,8 @@ def length_in_bits(self) -> int: for element in self.items: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadFileRecordResponse") @@ -83,15 +80,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - items: List[Any] = read_buffer.read_array_field(logical_name="items", read_function=ModbusPDUReadFileRecordResponseItem.static_parse, length=byte_count, response=response) + items: List[Any] = read_buffer.read_array_field( + logical_name="items", + read_function=ModbusPDUReadFileRecordResponseItem.static_parse, + length=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadFileRecordResponse") # Create the instance - return ModbusPDUReadFileRecordResponseBuilder(items ) - + return ModbusPDUReadFileRecordResponseBuilder(items) def equals(self, o: object) -> bool: if self == o: @@ -108,22 +110,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadFileRecordResponseBuilder: items: List[ModbusPDUReadFileRecordResponseItem] - def build(self,) -> ModbusPDUReadFileRecordResponse: - modbus_pduread_file_record_response: ModbusPDUReadFileRecordResponse = ModbusPDUReadFileRecordResponse(self.items ) + def build( + self, + ) -> ModbusPDUReadFileRecordResponse: + modbus_pduread_file_record_response: ModbusPDUReadFileRecordResponse = ( + ModbusPDUReadFileRecordResponse(self.items) + ) return modbus_pduread_file_record_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py index 93a14df8aa7..33c52df5c45 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py @@ -27,30 +27,30 @@ from typing import Any from typing import List import math - + + @dataclass -class ModbusPDUReadFileRecordResponseItem(): +class ModbusPDUReadFileRecordResponseItem: reference_type: int data: List[int] - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadFileRecordResponseItem") # Implicit Field (data_length) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - data_length: int = (int(len(self.data))+ int(1)) + data_length: int = int(len(self.data)) + int(1) write_buffer.write_unsigned_byte(data_length, logical_name="data_length") # Simple Field (referenceType) - write_buffer.write_unsigned_byte(self.reference_type,bit_length=8,logical_name="referenceType") + write_buffer.write_unsigned_byte( + self.reference_type, bit_length=8, logical_name="referenceType" + ) # Array Field (data) write_buffer.write_byte_array(self.data, logical_name="data") write_buffer.pop_context("ModbusPDUReadFileRecordResponseItem") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,35 +68,35 @@ def length_in_bits(self) -> int: if self.data is not None: length_in_bits += 8 * len(self.data) - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return ModbusPDUReadFileRecordResponseItem.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("ModbusPDUReadFileRecordResponseItem") - - data_length: int = read_buffer.read_unsigned_byte(logical_name="data_length") - reference_type: int = read_buffer.read_unsigned_byte(logical_name="reference_type", bit_length=8) - + reference_type: int = read_buffer.read_unsigned_byte( + logical_name="reference_type", bit_length=8 + ) - - data: List[Any] = read_buffer.read_array_field(logical_name="data", read_function=read_buffer.read_byte, count=data_length- int(1)) + data: List[Any] = read_buffer.read_array_field( + logical_name="data", + read_function=read_buffer.read_byte, + count=data_length - int(1), + ) read_buffer.pop_context("ModbusPDUReadFileRecordResponseItem") # Create the instance - _modbus_pduread_file_record_response_item: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(reference_type, data ) + _modbus_pduread_file_record_response_item: ( + ModbusPDUReadFileRecordResponseItem + ) = ModbusPDUReadFileRecordResponseItem(reference_type, data) return _modbus_pduread_file_record_response_item - def equals(self, o: object) -> bool: if self == o: return True @@ -104,22 +104,24 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadFileRecordResponseItem): return False - that: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(o) - return (self.reference_type == that.reference_type) and (self.data == that.data) and True + that: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem( + o + ) + return ( + (self.reference_type == that.reference_type) + and (self.data == that.data) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py index 1c5e5dbe33f..59ffd92603d 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadHoldingRegistersRequest(ModbusPDU): starting_address: int @@ -38,20 +39,21 @@ class ModbusPDUReadHoldingRegistersRequest(ModbusPDU): function_flag: ClassVar[int] = 0x03 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadHoldingRegistersRequest") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) write_buffer.pop_context("ModbusPDUReadHoldingRegistersRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadHoldingRegistersRequest") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - - - - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUReadHoldingRegistersRequest") # Create the instance - return ModbusPDUReadHoldingRegistersRequestBuilder(starting_address, quantity ) - + return ModbusPDUReadHoldingRegistersRequestBuilder(starting_address, quantity) def equals(self, o: object) -> bool: if self == o: @@ -96,21 +95,28 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadHoldingRegistersRequest): return False - that: ModbusPDUReadHoldingRegistersRequest = ModbusPDUReadHoldingRegistersRequest(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and super().equals(that) and True + that: ModbusPDUReadHoldingRegistersRequest = ( + ModbusPDUReadHoldingRegistersRequest(o) + ) + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +124,10 @@ class ModbusPDUReadHoldingRegistersRequestBuilder: starting_address: int quantity: int - def build(self,) -> ModbusPDUReadHoldingRegistersRequest: - modbus_pduread_holding_registers_request: ModbusPDUReadHoldingRegistersRequest = ModbusPDUReadHoldingRegistersRequest(self.starting_address, self.quantity ) + def build( + self, + ) -> ModbusPDUReadHoldingRegistersRequest: + modbus_pduread_holding_registers_request: ( + ModbusPDUReadHoldingRegistersRequest + ) = ModbusPDUReadHoldingRegistersRequest(self.starting_address, self.quantity) return modbus_pduread_holding_registers_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py index 916f7d069aa..f65ccf85978 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadHoldingRegistersResponse(ModbusPDU): value: List[int] @@ -39,13 +40,11 @@ class ModbusPDUReadHoldingRegistersResponse(ModbusPDU): function_flag: ClassVar[int] = 0x03 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadHoldingRegistersResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -53,7 +52,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadHoldingRegistersResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,10 +66,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadHoldingRegistersResponse") @@ -79,15 +75,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadHoldingRegistersResponse") # Create the instance - return ModbusPDUReadHoldingRegistersResponseBuilder(value ) - + return ModbusPDUReadHoldingRegistersResponseBuilder(value) def equals(self, o: object) -> bool: if self == o: @@ -96,7 +97,9 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadHoldingRegistersResponse): return False - that: ModbusPDUReadHoldingRegistersResponse = ModbusPDUReadHoldingRegistersResponse(o) + that: ModbusPDUReadHoldingRegistersResponse = ( + ModbusPDUReadHoldingRegistersResponse(o) + ) return (self.value == that.value) and super().equals(that) and True def hash_code(self) -> int: @@ -104,22 +107,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadHoldingRegistersResponseBuilder: value: List[int] - def build(self,) -> ModbusPDUReadHoldingRegistersResponse: - modbus_pduread_holding_registers_response: ModbusPDUReadHoldingRegistersResponse = ModbusPDUReadHoldingRegistersResponse(self.value ) + def build( + self, + ) -> ModbusPDUReadHoldingRegistersResponse: + modbus_pduread_holding_registers_response: ( + ModbusPDUReadHoldingRegistersResponse + ) = ModbusPDUReadHoldingRegistersResponse(self.value) return modbus_pduread_holding_registers_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py index faac3a30b42..2e413e60bf4 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReadInputRegistersRequest(ModbusPDU): starting_address: int @@ -38,20 +39,21 @@ class ModbusPDUReadInputRegistersRequest(ModbusPDU): function_flag: ClassVar[int] = 0x04 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadInputRegistersRequest") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) write_buffer.pop_context("ModbusPDUReadInputRegistersRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadInputRegistersRequest") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - - - - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUReadInputRegistersRequest") # Create the instance - return ModbusPDUReadInputRegistersRequestBuilder(starting_address, quantity ) - + return ModbusPDUReadInputRegistersRequestBuilder(starting_address, quantity) def equals(self, o: object) -> bool: if self == o: @@ -97,20 +96,25 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUReadInputRegistersRequest = ModbusPDUReadInputRegistersRequest(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and super().equals(that) and True + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +122,10 @@ class ModbusPDUReadInputRegistersRequestBuilder: starting_address: int quantity: int - def build(self,) -> ModbusPDUReadInputRegistersRequest: - modbus_pduread_input_registers_request: ModbusPDUReadInputRegistersRequest = ModbusPDUReadInputRegistersRequest(self.starting_address, self.quantity ) + def build( + self, + ) -> ModbusPDUReadInputRegistersRequest: + modbus_pduread_input_registers_request: ModbusPDUReadInputRegistersRequest = ( + ModbusPDUReadInputRegistersRequest(self.starting_address, self.quantity) + ) return modbus_pduread_input_registers_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py index 2a1d0026c26..1839af2c49d 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadInputRegistersResponse(ModbusPDU): value: List[int] @@ -39,13 +40,11 @@ class ModbusPDUReadInputRegistersResponse(ModbusPDU): function_flag: ClassVar[int] = 0x04 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadInputRegistersResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -53,7 +52,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadInputRegistersResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,10 +66,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadInputRegistersResponse") @@ -79,15 +75,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadInputRegistersResponse") # Create the instance - return ModbusPDUReadInputRegistersResponseBuilder(value ) - + return ModbusPDUReadInputRegistersResponseBuilder(value) def equals(self, o: object) -> bool: if self == o: @@ -96,7 +97,9 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadInputRegistersResponse): return False - that: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(o) + that: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse( + o + ) return (self.value == that.value) and super().equals(that) and True def hash_code(self) -> int: @@ -104,22 +107,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadInputRegistersResponseBuilder: value: List[int] - def build(self,) -> ModbusPDUReadInputRegistersResponse: - modbus_pduread_input_registers_response: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(self.value ) + def build( + self, + ) -> ModbusPDUReadInputRegistersResponse: + modbus_pduread_input_registers_response: ModbusPDUReadInputRegistersResponse = ( + ModbusPDUReadInputRegistersResponse(self.value) + ) return modbus_pduread_input_registers_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py index ac8ea3769d3..83eec3b6966 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadWriteMultipleHoldingRegistersRequest(ModbusPDU): read_starting_address: int @@ -43,25 +44,35 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(ModbusPDU): function_flag: ClassVar[int] = 0x17 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadWriteMultipleHoldingRegistersRequest") # Simple Field (readStartingAddress) - write_buffer.write_unsigned_short(self.read_starting_address,bit_length=16,logical_name="readStartingAddress") + write_buffer.write_unsigned_short( + self.read_starting_address, + bit_length=16, + logical_name="readStartingAddress", + ) # Simple Field (readQuantity) - write_buffer.write_unsigned_short(self.read_quantity,bit_length=16,logical_name="readQuantity") + write_buffer.write_unsigned_short( + self.read_quantity, bit_length=16, logical_name="readQuantity" + ) # Simple Field (writeStartingAddress) - write_buffer.write_unsigned_short(self.write_starting_address,bit_length=16,logical_name="writeStartingAddress") + write_buffer.write_unsigned_short( + self.write_starting_address, + bit_length=16, + logical_name="writeStartingAddress", + ) # Simple Field (writeQuantity) - write_buffer.write_unsigned_short(self.write_quantity,bit_length=16,logical_name="writeQuantity") + write_buffer.write_unsigned_short( + self.write_quantity, bit_length=16, logical_name="writeQuantity" + ) # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -69,7 +80,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadWriteMultipleHoldingRegistersRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -96,10 +106,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadWriteMultipleHoldingRegistersRequest") @@ -107,31 +115,42 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + read_starting_address: int = read_buffer.read_unsigned_short( + logical_name="read_starting_address", bit_length=16, response=response + ) - read_starting_address: int = read_buffer.read_unsigned_short(logical_name="read_starting_address", bit_length=16, response=response) - - - - read_quantity: int = read_buffer.read_unsigned_short(logical_name="read_quantity", bit_length=16, response=response) + read_quantity: int = read_buffer.read_unsigned_short( + logical_name="read_quantity", bit_length=16, response=response + ) + write_starting_address: int = read_buffer.read_unsigned_short( + logical_name="write_starting_address", bit_length=16, response=response + ) + write_quantity: int = read_buffer.read_unsigned_short( + logical_name="write_quantity", bit_length=16, response=response + ) - write_starting_address: int = read_buffer.read_unsigned_short(logical_name="write_starting_address", bit_length=16, response=response) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - - - write_quantity: int = read_buffer.read_unsigned_short(logical_name="write_quantity", bit_length=16, response=response) - - - - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadWriteMultipleHoldingRegistersRequest") # Create the instance - return ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(read_starting_address, read_quantity, write_starting_address, write_quantity, value ) - + return ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder( + read_starting_address, + read_quantity, + write_starting_address, + write_quantity, + value, + ) def equals(self, o: object) -> bool: if self == o: @@ -140,21 +159,31 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadWriteMultipleHoldingRegistersRequest): return False - that: ModbusPDUReadWriteMultipleHoldingRegistersRequest = ModbusPDUReadWriteMultipleHoldingRegistersRequest(o) - return (self.read_starting_address == that.read_starting_address) and (self.read_quantity == that.read_quantity) and (self.write_starting_address == that.write_starting_address) and (self.write_quantity == that.write_quantity) and (self.value == that.value) and super().equals(that) and True + that: ModbusPDUReadWriteMultipleHoldingRegistersRequest = ( + ModbusPDUReadWriteMultipleHoldingRegistersRequest(o) + ) + return ( + (self.read_starting_address == that.read_starting_address) + and (self.read_quantity == that.read_quantity) + and (self.write_starting_address == that.write_starting_address) + and (self.write_quantity == that.write_quantity) + and (self.value == that.value) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -165,9 +194,16 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder: write_quantity: int value: List[int] - def build(self,) -> ModbusPDUReadWriteMultipleHoldingRegistersRequest: - modbus_pduread_write_multiple_holding_registers_request: ModbusPDUReadWriteMultipleHoldingRegistersRequest = ModbusPDUReadWriteMultipleHoldingRegistersRequest(self.read_starting_address, self.read_quantity, self.write_starting_address, self.write_quantity, self.value ) + def build( + self, + ) -> ModbusPDUReadWriteMultipleHoldingRegistersRequest: + modbus_pduread_write_multiple_holding_registers_request: ( + ModbusPDUReadWriteMultipleHoldingRegistersRequest + ) = ModbusPDUReadWriteMultipleHoldingRegistersRequest( + self.read_starting_address, + self.read_quantity, + self.write_starting_address, + self.write_quantity, + self.value, + ) return modbus_pduread_write_multiple_holding_registers_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py index ee8e2c2ebac..d6bc4a12021 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReadWriteMultipleHoldingRegistersResponse(ModbusPDU): value: List[int] @@ -39,13 +40,11 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponse(ModbusPDU): function_flag: ClassVar[int] = 0x17 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReadWriteMultipleHoldingRegistersResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -53,7 +52,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReadWriteMultipleHoldingRegistersResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,10 +66,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReadWriteMultipleHoldingRegistersResponse") @@ -79,15 +75,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReadWriteMultipleHoldingRegistersResponse") # Create the instance - return ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(value ) - + return ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(value) def equals(self, o: object) -> bool: if self == o: @@ -96,7 +97,9 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUReadWriteMultipleHoldingRegistersResponse): return False - that: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ModbusPDUReadWriteMultipleHoldingRegistersResponse(o) + that: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ( + ModbusPDUReadWriteMultipleHoldingRegistersResponse(o) + ) return (self.value == that.value) and super().equals(that) and True def hash_code(self) -> int: @@ -104,22 +107,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder: value: List[int] - def build(self,) -> ModbusPDUReadWriteMultipleHoldingRegistersResponse: - modbus_pduread_write_multiple_holding_registers_response: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ModbusPDUReadWriteMultipleHoldingRegistersResponse(self.value ) + def build( + self, + ) -> ModbusPDUReadWriteMultipleHoldingRegistersResponse: + modbus_pduread_write_multiple_holding_registers_response: ( + ModbusPDUReadWriteMultipleHoldingRegistersResponse + ) = ModbusPDUReadWriteMultipleHoldingRegistersResponse(self.value) return modbus_pduread_write_multiple_holding_registers_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py index 5775e703e90..5488fff5100 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUReportServerIdRequest(ModbusPDU): # Accessors for discriminator values. @@ -36,14 +37,11 @@ class ModbusPDUReportServerIdRequest(ModbusPDU): function_flag: ClassVar[int] = 0x11 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReportServerIdRequest") write_buffer.pop_context("ModbusPDUReportServerIdRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,7 +51,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReportServerIdRequest") @@ -61,12 +58,10 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) - read_buffer.pop_context("ModbusPDUReportServerIdRequest") # Create the instance return ModbusPDUReportServerIdRequestBuilder() - def equals(self, o: object) -> bool: if self == o: return True @@ -82,21 +77,22 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReportServerIdRequestBuilder: - def build(self,) -> ModbusPDUReportServerIdRequest: - modbus_pdureport_server_id_request: ModbusPDUReportServerIdRequest = ModbusPDUReportServerIdRequest() + def build( + self, + ) -> ModbusPDUReportServerIdRequest: + modbus_pdureport_server_id_request: ModbusPDUReportServerIdRequest = ( + ModbusPDUReportServerIdRequest() + ) return modbus_pdureport_server_id_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py index 43a8f78ba6e..ef0521fff30 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUReportServerIdResponse(ModbusPDU): value: List[int] @@ -39,13 +40,11 @@ class ModbusPDUReportServerIdResponse(ModbusPDU): function_flag: ClassVar[int] = 0x11 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUReportServerIdResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -53,7 +52,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUReportServerIdResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -68,10 +66,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUReportServerIdResponse") @@ -79,15 +75,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUReportServerIdResponse") # Create the instance - return ModbusPDUReportServerIdResponseBuilder(value ) - + return ModbusPDUReportServerIdResponseBuilder(value) def equals(self, o: object) -> bool: if self == o: @@ -104,22 +105,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUReportServerIdResponseBuilder: value: List[int] - def build(self,) -> ModbusPDUReportServerIdResponse: - modbus_pdureport_server_id_response: ModbusPDUReportServerIdResponse = ModbusPDUReportServerIdResponse(self.value ) + def build( + self, + ) -> ModbusPDUReportServerIdResponse: + modbus_pdureport_server_id_response: ModbusPDUReportServerIdResponse = ( + ModbusPDUReportServerIdResponse(self.value) + ) return modbus_pdureport_server_id_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py index 6b8fe9a7785..2ca35b44d31 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py @@ -24,7 +24,9 @@ from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU -from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordRequestItem import ModbusPDUWriteFileRecordRequestItem +from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordRequestItem import ( + ModbusPDUWriteFileRecordRequestItem, +) from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.spi.values.Common import get_size_of_array @@ -32,7 +34,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUWriteFileRecordRequest(ModbusPDU): items: List[ModbusPDUWriteFileRecordRequestItem] @@ -41,13 +44,11 @@ class ModbusPDUWriteFileRecordRequest(ModbusPDU): function_flag: ClassVar[int] = 0x15 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteFileRecordRequest") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(get_size_of_array(self.items))) + byte_count: int = int(get_size_of_array(self.items)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (items) @@ -55,7 +56,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUWriteFileRecordRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -71,11 +71,8 @@ def length_in_bits(self) -> int: for element in self.items: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteFileRecordRequest") @@ -83,15 +80,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - items: List[Any] = read_buffer.read_array_field(logical_name="items", read_function=ModbusPDUWriteFileRecordRequestItem.static_parse, length=byte_count, response=response) + items: List[Any] = read_buffer.read_array_field( + logical_name="items", + read_function=ModbusPDUWriteFileRecordRequestItem.static_parse, + length=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUWriteFileRecordRequest") # Create the instance - return ModbusPDUWriteFileRecordRequestBuilder(items ) - + return ModbusPDUWriteFileRecordRequestBuilder(items) def equals(self, o: object) -> bool: if self == o: @@ -108,22 +110,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUWriteFileRecordRequestBuilder: items: List[ModbusPDUWriteFileRecordRequestItem] - def build(self,) -> ModbusPDUWriteFileRecordRequest: - modbus_pduwrite_file_record_request: ModbusPDUWriteFileRecordRequest = ModbusPDUWriteFileRecordRequest(self.items ) + def build( + self, + ) -> ModbusPDUWriteFileRecordRequest: + modbus_pduwrite_file_record_request: ModbusPDUWriteFileRecordRequest = ( + ModbusPDUWriteFileRecordRequest(self.items) + ) return modbus_pduwrite_file_record_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py index 9c591347c09..5ad57733eba 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py @@ -27,30 +27,35 @@ from typing import Any from typing import List import math - + + @dataclass -class ModbusPDUWriteFileRecordRequestItem(): +class ModbusPDUWriteFileRecordRequestItem: reference_type: int file_number: int record_number: int record_data: List[int] - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteFileRecordRequestItem") # Simple Field (referenceType) - write_buffer.write_unsigned_byte(self.reference_type,bit_length=8,logical_name="referenceType") + write_buffer.write_unsigned_byte( + self.reference_type, bit_length=8, logical_name="referenceType" + ) # Simple Field (fileNumber) - write_buffer.write_unsigned_short(self.file_number,bit_length=16,logical_name="fileNumber") + write_buffer.write_unsigned_short( + self.file_number, bit_length=16, logical_name="fileNumber" + ) # Simple Field (recordNumber) - write_buffer.write_unsigned_short(self.record_number,bit_length=16,logical_name="recordNumber") + write_buffer.write_unsigned_short( + self.record_number, bit_length=16, logical_name="recordNumber" + ) # Implicit Field (record_length) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - record_length: int = (int(len(self.record_data))/ int(2)) + record_length: int = int(len(self.record_data)) / int(2) write_buffer.write_unsigned_short(record_length, logical_name="record_length") # Array Field (recordData) @@ -58,7 +63,6 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUWriteFileRecordRequestItem") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -82,43 +86,47 @@ def length_in_bits(self) -> int: if self.record_data is not None: length_in_bits += 8 * len(self.record_data) - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return ModbusPDUWriteFileRecordRequestItem.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("ModbusPDUWriteFileRecordRequestItem") + reference_type: int = read_buffer.read_unsigned_byte( + logical_name="reference_type", bit_length=8 + ) + file_number: int = read_buffer.read_unsigned_short( + logical_name="file_number", bit_length=16 + ) - reference_type: int = read_buffer.read_unsigned_byte(logical_name="reference_type", bit_length=8) - - - - file_number: int = read_buffer.read_unsigned_short(logical_name="file_number", bit_length=16) + record_number: int = read_buffer.read_unsigned_short( + logical_name="record_number", bit_length=16 + ) + record_length: int = read_buffer.read_unsigned_short( + logical_name="record_length" + ) - - record_number: int = read_buffer.read_unsigned_short(logical_name="record_number", bit_length=16) - - - - record_length: int = read_buffer.read_unsigned_short(logical_name="record_length") - - record_data: List[Any] = read_buffer.read_array_field(logical_name="recordData", read_function=read_buffer.read_byte, count=record_length* int(2)) + record_data: List[Any] = read_buffer.read_array_field( + logical_name="recordData", + read_function=read_buffer.read_byte, + count=record_length * int(2), + ) read_buffer.pop_context("ModbusPDUWriteFileRecordRequestItem") # Create the instance - _modbus_pduwrite_file_record_request_item: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem(reference_type, file_number, record_number, record_data ) + _modbus_pduwrite_file_record_request_item: ( + ModbusPDUWriteFileRecordRequestItem + ) = ModbusPDUWriteFileRecordRequestItem( + reference_type, file_number, record_number, record_data + ) return _modbus_pduwrite_file_record_request_item - def equals(self, o: object) -> bool: if self == o: return True @@ -126,22 +134,26 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUWriteFileRecordRequestItem): return False - that: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem(o) - return (self.reference_type == that.reference_type) and (self.file_number == that.file_number) and (self.record_number == that.record_number) and (self.record_data == that.record_data) and True + that: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem( + o + ) + return ( + (self.reference_type == that.reference_type) + and (self.file_number == that.file_number) + and (self.record_number == that.record_number) + and (self.record_data == that.record_data) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py index 3af73fddf9f..d016f721985 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py @@ -24,7 +24,9 @@ from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU -from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordResponseItem import ModbusPDUWriteFileRecordResponseItem +from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordResponseItem import ( + ModbusPDUWriteFileRecordResponseItem, +) from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.spi.values.Common import get_size_of_array @@ -32,7 +34,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUWriteFileRecordResponse(ModbusPDU): items: List[ModbusPDUWriteFileRecordResponseItem] @@ -41,13 +44,11 @@ class ModbusPDUWriteFileRecordResponse(ModbusPDU): function_flag: ClassVar[int] = 0x15 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteFileRecordResponse") # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(get_size_of_array(self.items))) + byte_count: int = int(get_size_of_array(self.items)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (items) @@ -55,7 +56,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUWriteFileRecordResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -71,11 +71,8 @@ def length_in_bits(self) -> int: for element in self.items: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteFileRecordResponse") @@ -83,15 +80,20 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - items: List[Any] = read_buffer.read_array_field(logical_name="items", read_function=ModbusPDUWriteFileRecordResponseItem.static_parse, length=byte_count, response=response) + items: List[Any] = read_buffer.read_array_field( + logical_name="items", + read_function=ModbusPDUWriteFileRecordResponseItem.static_parse, + length=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUWriteFileRecordResponse") # Create the instance - return ModbusPDUWriteFileRecordResponseBuilder(items ) - + return ModbusPDUWriteFileRecordResponseBuilder(items) def equals(self, o: object) -> bool: if self == o: @@ -108,22 +110,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUWriteFileRecordResponseBuilder: items: List[ModbusPDUWriteFileRecordResponseItem] - def build(self,) -> ModbusPDUWriteFileRecordResponse: - modbus_pduwrite_file_record_response: ModbusPDUWriteFileRecordResponse = ModbusPDUWriteFileRecordResponse(self.items ) + def build( + self, + ) -> ModbusPDUWriteFileRecordResponse: + modbus_pduwrite_file_record_response: ModbusPDUWriteFileRecordResponse = ( + ModbusPDUWriteFileRecordResponse(self.items) + ) return modbus_pduwrite_file_record_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py index e4c910e0d3c..a64f30ee959 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py @@ -27,30 +27,35 @@ from typing import Any from typing import List import math - + + @dataclass -class ModbusPDUWriteFileRecordResponseItem(): +class ModbusPDUWriteFileRecordResponseItem: reference_type: int file_number: int record_number: int record_data: List[int] - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteFileRecordResponseItem") # Simple Field (referenceType) - write_buffer.write_unsigned_byte(self.reference_type,bit_length=8,logical_name="referenceType") + write_buffer.write_unsigned_byte( + self.reference_type, bit_length=8, logical_name="referenceType" + ) # Simple Field (fileNumber) - write_buffer.write_unsigned_short(self.file_number,bit_length=16,logical_name="fileNumber") + write_buffer.write_unsigned_short( + self.file_number, bit_length=16, logical_name="fileNumber" + ) # Simple Field (recordNumber) - write_buffer.write_unsigned_short(self.record_number,bit_length=16,logical_name="recordNumber") + write_buffer.write_unsigned_short( + self.record_number, bit_length=16, logical_name="recordNumber" + ) # Implicit Field (record_length) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - record_length: int = (int(len(self.record_data))/ int(2)) + record_length: int = int(len(self.record_data)) / int(2) write_buffer.write_unsigned_short(record_length, logical_name="record_length") # Array Field (recordData) @@ -58,7 +63,6 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUWriteFileRecordResponseItem") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -82,43 +86,47 @@ def length_in_bits(self) -> int: if self.record_data is not None: length_in_bits += 8 * len(self.record_data) - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return ModbusPDUWriteFileRecordResponseItem.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("ModbusPDUWriteFileRecordResponseItem") + reference_type: int = read_buffer.read_unsigned_byte( + logical_name="reference_type", bit_length=8 + ) + file_number: int = read_buffer.read_unsigned_short( + logical_name="file_number", bit_length=16 + ) - reference_type: int = read_buffer.read_unsigned_byte(logical_name="reference_type", bit_length=8) - - - - file_number: int = read_buffer.read_unsigned_short(logical_name="file_number", bit_length=16) + record_number: int = read_buffer.read_unsigned_short( + logical_name="record_number", bit_length=16 + ) + record_length: int = read_buffer.read_unsigned_short( + logical_name="record_length" + ) - - record_number: int = read_buffer.read_unsigned_short(logical_name="record_number", bit_length=16) - - - - record_length: int = read_buffer.read_unsigned_short(logical_name="record_length") - - record_data: List[Any] = read_buffer.read_array_field(logical_name="recordData", read_function=read_buffer.read_byte, count=record_length) + record_data: List[Any] = read_buffer.read_array_field( + logical_name="recordData", + read_function=read_buffer.read_byte, + count=record_length, + ) read_buffer.pop_context("ModbusPDUWriteFileRecordResponseItem") # Create the instance - _modbus_pduwrite_file_record_response_item: ModbusPDUWriteFileRecordResponseItem = ModbusPDUWriteFileRecordResponseItem(reference_type, file_number, record_number, record_data ) + _modbus_pduwrite_file_record_response_item: ( + ModbusPDUWriteFileRecordResponseItem + ) = ModbusPDUWriteFileRecordResponseItem( + reference_type, file_number, record_number, record_data + ) return _modbus_pduwrite_file_record_response_item - def equals(self, o: object) -> bool: if self == o: return True @@ -126,22 +134,26 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUWriteFileRecordResponseItem): return False - that: ModbusPDUWriteFileRecordResponseItem = ModbusPDUWriteFileRecordResponseItem(o) - return (self.reference_type == that.reference_type) and (self.file_number == that.file_number) and (self.record_number == that.record_number) and (self.record_data == that.record_data) and True + that: ModbusPDUWriteFileRecordResponseItem = ( + ModbusPDUWriteFileRecordResponseItem(o) + ) + return ( + (self.reference_type == that.reference_type) + and (self.file_number == that.file_number) + and (self.record_number == that.record_number) + and (self.record_data == that.record_data) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py index 44555933ea7..0b995fd82ad 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUWriteMultipleCoilsRequest(ModbusPDU): starting_address: int @@ -41,19 +42,21 @@ class ModbusPDUWriteMultipleCoilsRequest(ModbusPDU): function_flag: ClassVar[int] = 0x0F response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteMultipleCoilsRequest") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -61,7 +64,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUWriteMultipleCoilsRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -82,10 +84,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteMultipleCoilsRequest") @@ -93,23 +93,30 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - - - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUWriteMultipleCoilsRequest") # Create the instance - return ModbusPDUWriteMultipleCoilsRequestBuilder(starting_address, quantity, value ) - + return ModbusPDUWriteMultipleCoilsRequestBuilder( + starting_address, quantity, value + ) def equals(self, o: object) -> bool: if self == o: @@ -119,20 +126,26 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUWriteMultipleCoilsRequest = ModbusPDUWriteMultipleCoilsRequest(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and (self.value == that.value) and super().equals(that) and True + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and (self.value == that.value) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -141,9 +154,12 @@ class ModbusPDUWriteMultipleCoilsRequestBuilder: quantity: int value: List[int] - def build(self,) -> ModbusPDUWriteMultipleCoilsRequest: - modbus_pduwrite_multiple_coils_request: ModbusPDUWriteMultipleCoilsRequest = ModbusPDUWriteMultipleCoilsRequest(self.starting_address, self.quantity, self.value ) + def build( + self, + ) -> ModbusPDUWriteMultipleCoilsRequest: + modbus_pduwrite_multiple_coils_request: ModbusPDUWriteMultipleCoilsRequest = ( + ModbusPDUWriteMultipleCoilsRequest( + self.starting_address, self.quantity, self.value + ) + ) return modbus_pduwrite_multiple_coils_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py index 96fb2267c99..430a7080fd3 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUWriteMultipleCoilsResponse(ModbusPDU): starting_address: int @@ -38,20 +39,21 @@ class ModbusPDUWriteMultipleCoilsResponse(ModbusPDU): function_flag: ClassVar[int] = 0x0F response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteMultipleCoilsResponse") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) write_buffer.pop_context("ModbusPDUWriteMultipleCoilsResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteMultipleCoilsResponse") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - - - - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUWriteMultipleCoilsResponse") # Create the instance - return ModbusPDUWriteMultipleCoilsResponseBuilder(starting_address, quantity ) - + return ModbusPDUWriteMultipleCoilsResponseBuilder(starting_address, quantity) def equals(self, o: object) -> bool: if self == o: @@ -96,21 +95,28 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUWriteMultipleCoilsResponse): return False - that: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and super().equals(that) and True + that: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse( + o + ) + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +124,10 @@ class ModbusPDUWriteMultipleCoilsResponseBuilder: starting_address: int quantity: int - def build(self,) -> ModbusPDUWriteMultipleCoilsResponse: - modbus_pduwrite_multiple_coils_response: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(self.starting_address, self.quantity ) + def build( + self, + ) -> ModbusPDUWriteMultipleCoilsResponse: + modbus_pduwrite_multiple_coils_response: ModbusPDUWriteMultipleCoilsResponse = ( + ModbusPDUWriteMultipleCoilsResponse(self.starting_address, self.quantity) + ) return modbus_pduwrite_multiple_coils_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py index b1425479f3d..f11fc4f54ad 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class ModbusPDUWriteMultipleHoldingRegistersRequest(ModbusPDU): starting_address: int @@ -41,19 +42,21 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(ModbusPDU): function_flag: ClassVar[int] = 0x10 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteMultipleHoldingRegistersRequest") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) # Implicit Field (byte_count) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - byte_count: int = (int(len(self.value))) + byte_count: int = int(len(self.value)) write_buffer.write_unsigned_byte(byte_count, logical_name="byte_count") # Array Field (value) @@ -61,7 +64,6 @@ def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.pop_context("ModbusPDUWriteMultipleHoldingRegistersRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -82,10 +84,8 @@ def length_in_bits(self) -> int: if self.value is not None: length_in_bits += 8 * len(self.value) - return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteMultipleHoldingRegistersRequest") @@ -93,23 +93,30 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) + byte_count: int = read_buffer.read_unsigned_byte( + logical_name="byte_count", response=response + ) - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - - - byte_count: int = read_buffer.read_unsigned_byte(logical_name="byte_count", response=response) - - value: List[Any] = read_buffer.read_array_field(logical_name="value", read_function=read_buffer.read_byte, count=byte_count, response=response) + value: List[Any] = read_buffer.read_array_field( + logical_name="value", + read_function=read_buffer.read_byte, + count=byte_count, + response=response, + ) read_buffer.pop_context("ModbusPDUWriteMultipleHoldingRegistersRequest") # Create the instance - return ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(starting_address, quantity, value ) - + return ModbusPDUWriteMultipleHoldingRegistersRequestBuilder( + starting_address, quantity, value + ) def equals(self, o: object) -> bool: if self == o: @@ -118,21 +125,29 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUWriteMultipleHoldingRegistersRequest): return False - that: ModbusPDUWriteMultipleHoldingRegistersRequest = ModbusPDUWriteMultipleHoldingRegistersRequest(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and (self.value == that.value) and super().equals(that) and True + that: ModbusPDUWriteMultipleHoldingRegistersRequest = ( + ModbusPDUWriteMultipleHoldingRegistersRequest(o) + ) + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and (self.value == that.value) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -141,9 +156,12 @@ class ModbusPDUWriteMultipleHoldingRegistersRequestBuilder: quantity: int value: List[int] - def build(self,) -> ModbusPDUWriteMultipleHoldingRegistersRequest: - modbus_pduwrite_multiple_holding_registers_request: ModbusPDUWriteMultipleHoldingRegistersRequest = ModbusPDUWriteMultipleHoldingRegistersRequest(self.starting_address, self.quantity, self.value ) + def build( + self, + ) -> ModbusPDUWriteMultipleHoldingRegistersRequest: + modbus_pduwrite_multiple_holding_registers_request: ( + ModbusPDUWriteMultipleHoldingRegistersRequest + ) = ModbusPDUWriteMultipleHoldingRegistersRequest( + self.starting_address, self.quantity, self.value + ) return modbus_pduwrite_multiple_holding_registers_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py index 4be34ef8891..fdb448a7008 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUWriteMultipleHoldingRegistersResponse(ModbusPDU): starting_address: int @@ -38,20 +39,21 @@ class ModbusPDUWriteMultipleHoldingRegistersResponse(ModbusPDU): function_flag: ClassVar[int] = 0x10 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteMultipleHoldingRegistersResponse") # Simple Field (startingAddress) - write_buffer.write_unsigned_short(self.starting_address,bit_length=16,logical_name="startingAddress") + write_buffer.write_unsigned_short( + self.starting_address, bit_length=16, logical_name="startingAddress" + ) # Simple Field (quantity) - write_buffer.write_unsigned_short(self.quantity,bit_length=16,logical_name="quantity") + write_buffer.write_unsigned_short( + self.quantity, bit_length=16, logical_name="quantity" + ) write_buffer.pop_context("ModbusPDUWriteMultipleHoldingRegistersResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteMultipleHoldingRegistersResponse") @@ -75,19 +76,19 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + starting_address: int = read_buffer.read_unsigned_short( + logical_name="starting_address", bit_length=16, response=response + ) - starting_address: int = read_buffer.read_unsigned_short(logical_name="starting_address", bit_length=16, response=response) - - - - quantity: int = read_buffer.read_unsigned_short(logical_name="quantity", bit_length=16, response=response) - - + quantity: int = read_buffer.read_unsigned_short( + logical_name="quantity", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUWriteMultipleHoldingRegistersResponse") # Create the instance - return ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(starting_address, quantity ) - + return ModbusPDUWriteMultipleHoldingRegistersResponseBuilder( + starting_address, quantity + ) def equals(self, o: object) -> bool: if self == o: @@ -96,21 +97,28 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUWriteMultipleHoldingRegistersResponse): return False - that: ModbusPDUWriteMultipleHoldingRegistersResponse = ModbusPDUWriteMultipleHoldingRegistersResponse(o) - return (self.starting_address == that.starting_address) and (self.quantity == that.quantity) and super().equals(that) and True + that: ModbusPDUWriteMultipleHoldingRegistersResponse = ( + ModbusPDUWriteMultipleHoldingRegistersResponse(o) + ) + return ( + (self.starting_address == that.starting_address) + and (self.quantity == that.quantity) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +126,12 @@ class ModbusPDUWriteMultipleHoldingRegistersResponseBuilder: starting_address: int quantity: int - def build(self,) -> ModbusPDUWriteMultipleHoldingRegistersResponse: - modbus_pduwrite_multiple_holding_registers_response: ModbusPDUWriteMultipleHoldingRegistersResponse = ModbusPDUWriteMultipleHoldingRegistersResponse(self.starting_address, self.quantity ) + def build( + self, + ) -> ModbusPDUWriteMultipleHoldingRegistersResponse: + modbus_pduwrite_multiple_holding_registers_response: ( + ModbusPDUWriteMultipleHoldingRegistersResponse + ) = ModbusPDUWriteMultipleHoldingRegistersResponse( + self.starting_address, self.quantity + ) return modbus_pduwrite_multiple_holding_registers_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py index 1e8223375a9..d49318ffc3a 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUWriteSingleCoilRequest(ModbusPDU): address: int @@ -38,20 +39,21 @@ class ModbusPDUWriteSingleCoilRequest(ModbusPDU): function_flag: ClassVar[int] = 0x05 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteSingleCoilRequest") # Simple Field (address) - write_buffer.write_unsigned_short(self.address,bit_length=16,logical_name="address") + write_buffer.write_unsigned_short( + self.address, bit_length=16, logical_name="address" + ) # Simple Field (value) - write_buffer.write_unsigned_short(self.value,bit_length=16,logical_name="value") + write_buffer.write_unsigned_short( + self.value, bit_length=16, logical_name="value" + ) write_buffer.pop_context("ModbusPDUWriteSingleCoilRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteSingleCoilRequest") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + address: int = read_buffer.read_unsigned_short( + logical_name="address", bit_length=16, response=response + ) - address: int = read_buffer.read_unsigned_short(logical_name="address", bit_length=16, response=response) - - - - value: int = read_buffer.read_unsigned_short(logical_name="value", bit_length=16, response=response) - - + value: int = read_buffer.read_unsigned_short( + logical_name="value", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUWriteSingleCoilRequest") # Create the instance - return ModbusPDUWriteSingleCoilRequestBuilder(address, value ) - + return ModbusPDUWriteSingleCoilRequestBuilder(address, value) def equals(self, o: object) -> bool: if self == o: @@ -97,20 +96,25 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUWriteSingleCoilRequest = ModbusPDUWriteSingleCoilRequest(o) - return (self.address == that.address) and (self.value == that.value) and super().equals(that) and True + return ( + (self.address == that.address) + and (self.value == that.value) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +122,10 @@ class ModbusPDUWriteSingleCoilRequestBuilder: address: int value: int - def build(self,) -> ModbusPDUWriteSingleCoilRequest: - modbus_pduwrite_single_coil_request: ModbusPDUWriteSingleCoilRequest = ModbusPDUWriteSingleCoilRequest(self.address, self.value ) + def build( + self, + ) -> ModbusPDUWriteSingleCoilRequest: + modbus_pduwrite_single_coil_request: ModbusPDUWriteSingleCoilRequest = ( + ModbusPDUWriteSingleCoilRequest(self.address, self.value) + ) return modbus_pduwrite_single_coil_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py index 0e91de96601..70b6f3295bd 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUWriteSingleCoilResponse(ModbusPDU): address: int @@ -38,20 +39,21 @@ class ModbusPDUWriteSingleCoilResponse(ModbusPDU): function_flag: ClassVar[int] = 0x05 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteSingleCoilResponse") # Simple Field (address) - write_buffer.write_unsigned_short(self.address,bit_length=16,logical_name="address") + write_buffer.write_unsigned_short( + self.address, bit_length=16, logical_name="address" + ) # Simple Field (value) - write_buffer.write_unsigned_short(self.value,bit_length=16,logical_name="value") + write_buffer.write_unsigned_short( + self.value, bit_length=16, logical_name="value" + ) write_buffer.pop_context("ModbusPDUWriteSingleCoilResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteSingleCoilResponse") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + address: int = read_buffer.read_unsigned_short( + logical_name="address", bit_length=16, response=response + ) - address: int = read_buffer.read_unsigned_short(logical_name="address", bit_length=16, response=response) - - - - value: int = read_buffer.read_unsigned_short(logical_name="value", bit_length=16, response=response) - - + value: int = read_buffer.read_unsigned_short( + logical_name="value", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUWriteSingleCoilResponse") # Create the instance - return ModbusPDUWriteSingleCoilResponseBuilder(address, value ) - + return ModbusPDUWriteSingleCoilResponseBuilder(address, value) def equals(self, o: object) -> bool: if self == o: @@ -97,20 +96,25 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUWriteSingleCoilResponse = ModbusPDUWriteSingleCoilResponse(o) - return (self.address == that.address) and (self.value == that.value) and super().equals(that) and True + return ( + (self.address == that.address) + and (self.value == that.value) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +122,10 @@ class ModbusPDUWriteSingleCoilResponseBuilder: address: int value: int - def build(self,) -> ModbusPDUWriteSingleCoilResponse: - modbus_pduwrite_single_coil_response: ModbusPDUWriteSingleCoilResponse = ModbusPDUWriteSingleCoilResponse(self.address, self.value ) + def build( + self, + ) -> ModbusPDUWriteSingleCoilResponse: + modbus_pduwrite_single_coil_response: ModbusPDUWriteSingleCoilResponse = ( + ModbusPDUWriteSingleCoilResponse(self.address, self.value) + ) return modbus_pduwrite_single_coil_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py index 6d3d6789bc1..2cdf4cf5496 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUWriteSingleRegisterRequest(ModbusPDU): address: int @@ -38,20 +39,21 @@ class ModbusPDUWriteSingleRegisterRequest(ModbusPDU): function_flag: ClassVar[int] = 0x06 response: ClassVar[bool] = False - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteSingleRegisterRequest") # Simple Field (address) - write_buffer.write_unsigned_short(self.address,bit_length=16,logical_name="address") + write_buffer.write_unsigned_short( + self.address, bit_length=16, logical_name="address" + ) # Simple Field (value) - write_buffer.write_unsigned_short(self.value,bit_length=16,logical_name="value") + write_buffer.write_unsigned_short( + self.value, bit_length=16, logical_name="value" + ) write_buffer.pop_context("ModbusPDUWriteSingleRegisterRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteSingleRegisterRequest") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + address: int = read_buffer.read_unsigned_short( + logical_name="address", bit_length=16, response=response + ) - address: int = read_buffer.read_unsigned_short(logical_name="address", bit_length=16, response=response) - - - - value: int = read_buffer.read_unsigned_short(logical_name="value", bit_length=16, response=response) - - + value: int = read_buffer.read_unsigned_short( + logical_name="value", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUWriteSingleRegisterRequest") # Create the instance - return ModbusPDUWriteSingleRegisterRequestBuilder(address, value ) - + return ModbusPDUWriteSingleRegisterRequestBuilder(address, value) def equals(self, o: object) -> bool: if self == o: @@ -96,21 +95,28 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUWriteSingleRegisterRequest): return False - that: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(o) - return (self.address == that.address) and (self.value == that.value) and super().equals(that) and True + that: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest( + o + ) + return ( + (self.address == that.address) + and (self.value == that.value) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +124,10 @@ class ModbusPDUWriteSingleRegisterRequestBuilder: address: int value: int - def build(self,) -> ModbusPDUWriteSingleRegisterRequest: - modbus_pduwrite_single_register_request: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(self.address, self.value ) + def build( + self, + ) -> ModbusPDUWriteSingleRegisterRequest: + modbus_pduwrite_single_register_request: ModbusPDUWriteSingleRegisterRequest = ( + ModbusPDUWriteSingleRegisterRequest(self.address, self.value) + ) return modbus_pduwrite_single_register_request - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py index edf5722172d..7e98410b2a0 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUWriteSingleRegisterResponse(ModbusPDU): address: int @@ -38,20 +39,21 @@ class ModbusPDUWriteSingleRegisterResponse(ModbusPDU): function_flag: ClassVar[int] = 0x06 response: ClassVar[bool] = True - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUWriteSingleRegisterResponse") # Simple Field (address) - write_buffer.write_unsigned_short(self.address,bit_length=16,logical_name="address") + write_buffer.write_unsigned_short( + self.address, bit_length=16, logical_name="address" + ) # Simple Field (value) - write_buffer.write_unsigned_short(self.value,bit_length=16,logical_name="value") + write_buffer.write_unsigned_short( + self.value, bit_length=16, logical_name="value" + ) write_buffer.pop_context("ModbusPDUWriteSingleRegisterResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -67,7 +69,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, response: bool): read_buffer.push_context("ModbusPDUWriteSingleRegisterResponse") @@ -75,19 +76,17 @@ def static_parse_builder(read_buffer: ReadBuffer, response: bool): if isinstance(response, str): response = bool(strtobool(response)) + address: int = read_buffer.read_unsigned_short( + logical_name="address", bit_length=16, response=response + ) - address: int = read_buffer.read_unsigned_short(logical_name="address", bit_length=16, response=response) - - - - value: int = read_buffer.read_unsigned_short(logical_name="value", bit_length=16, response=response) - - + value: int = read_buffer.read_unsigned_short( + logical_name="value", bit_length=16, response=response + ) read_buffer.pop_context("ModbusPDUWriteSingleRegisterResponse") # Create the instance - return ModbusPDUWriteSingleRegisterResponseBuilder(address, value ) - + return ModbusPDUWriteSingleRegisterResponseBuilder(address, value) def equals(self, o: object) -> bool: if self == o: @@ -96,21 +95,28 @@ def equals(self, o: object) -> bool: if not isinstance(o, ModbusPDUWriteSingleRegisterResponse): return False - that: ModbusPDUWriteSingleRegisterResponse = ModbusPDUWriteSingleRegisterResponse(o) - return (self.address == that.address) and (self.value == that.value) and super().equals(that) and True + that: ModbusPDUWriteSingleRegisterResponse = ( + ModbusPDUWriteSingleRegisterResponse(o) + ) + return ( + (self.address == that.address) + and (self.value == that.value) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -118,9 +124,10 @@ class ModbusPDUWriteSingleRegisterResponseBuilder: address: int value: int - def build(self,) -> ModbusPDUWriteSingleRegisterResponse: - modbus_pduwrite_single_register_response: ModbusPDUWriteSingleRegisterResponse = ModbusPDUWriteSingleRegisterResponse(self.address, self.value ) + def build( + self, + ) -> ModbusPDUWriteSingleRegisterResponse: + modbus_pduwrite_single_register_response: ( + ModbusPDUWriteSingleRegisterResponse + ) = ModbusPDUWriteSingleRegisterResponse(self.address, self.value) return modbus_pduwrite_single_register_response - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py index 391a4f06a0e..0a21a0cfd11 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py @@ -32,7 +32,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class ModbusRtuADU(ModbusADU): address: int @@ -42,23 +43,24 @@ class ModbusRtuADU(ModbusADU): # Accessors for discriminator values. driver_type: ClassVar[DriverType] = DriverType.MODBUS_RTU - - def serialize_modbus_adu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusRtuADU") # Simple Field (address) - write_buffer.write_unsigned_byte(self.address,bit_length=8,logical_name="address") + write_buffer.write_unsigned_byte( + self.address, bit_length=8, logical_name="address" + ) # Simple Field (pdu) - write_buffer.write_serializable(self.pdu,logical_name="pdu") + write_buffer.write_serializable(self.pdu, logical_name="pdu") # Checksum Field (checksum) (Calculated) - write_buffer.write_unsigned_short(int(StaticHelper.rtu_crc_check(address, pdu)), logical_name="crc") + write_buffer.write_unsigned_short( + int(StaticHelper.rtu_crc_check(address, pdu)), logical_name="crc" + ) write_buffer.pop_context("ModbusRtuADU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -77,9 +79,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, driver_type: DriverType, response: bool): + def static_parse_builder( + read_buffer: ReadBuffer, driver_type: DriverType, response: bool + ): read_buffer.push_context("ModbusRtuADU") if isinstance(driver_type, str): @@ -87,21 +90,32 @@ def static_parse_builder(read_buffer: ReadBuffer, driver_type: DriverType, respo if isinstance(response, str): response = bool(strtobool(response)) - - address: int = read_buffer.read_unsigned_byte(logical_name="address", bit_length=8, byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - - - pdu: ModbusPDU = read_buffer.read_complex(read_function=ModbusPDU.static_parse, logical_name="pdu", byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - - - crc: int = read_buffer.read_unsigned_short(logical_name="crc", byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) + address: int = read_buffer.read_unsigned_byte( + logical_name="address", + bit_length=8, + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + pdu: ModbusPDU = read_buffer.read_complex( + read_function=ModbusPDU.static_parse, + logical_name="pdu", + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + crc: int = read_buffer.read_unsigned_short( + logical_name="crc", + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) read_buffer.pop_context("ModbusRtuADU") # Create the instance - return ModbusRtuADUBuilder(address, pdu ) - + return ModbusRtuADUBuilder(address, pdu) def equals(self, o: object) -> bool: if self == o: @@ -111,20 +125,25 @@ def equals(self, o: object) -> bool: return False that: ModbusRtuADU = ModbusRtuADU(o) - return (self.address == that.address) and (self.pdu == that.pdu) and super().equals(that) and True + return ( + (self.address == that.address) + and (self.pdu == that.pdu) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -132,9 +151,9 @@ class ModbusRtuADUBuilder: address: int pdu: ModbusPDU - def build(self,response: bool , ) -> ModbusRtuADU: - modbus_rtu_adu: ModbusRtuADU = ModbusRtuADU(response , self.address, self.pdu ) + def build( + self, + response: bool, + ) -> ModbusRtuADU: + modbus_rtu_adu: ModbusRtuADU = ModbusRtuADU(response, self.address, self.pdu) return modbus_rtu_adu - - - diff --git a/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py b/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py index 4144db5773f..3501ed53960 100644 --- a/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py +++ b/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py @@ -31,7 +31,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class ModbusTcpADU(ModbusADU): transaction_identifier: int @@ -43,30 +44,35 @@ class ModbusTcpADU(ModbusADU): # Accessors for discriminator values. driver_type: ClassVar[DriverType] = DriverType.MODBUS_TCP - - def serialize_modbus_adu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusTcpADU") # Simple Field (transactionIdentifier) - write_buffer.write_unsigned_short(self.transaction_identifier,bit_length=16,logical_name="transactionIdentifier") + write_buffer.write_unsigned_short( + self.transaction_identifier, + bit_length=16, + logical_name="transactionIdentifier", + ) # Const Field (protocolIdentifier) - write_buffer.write_unsigned_short(self.PROTOCOL_IDENTIFIER, logical_name="protocolIdentifier") + write_buffer.write_unsigned_short( + self.PROTOCOL_IDENTIFIER, logical_name="protocolIdentifier" + ) # Implicit Field (length) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - length: int = (self.pdu.length_in_bytes()+ int(1)) + length: int = self.pdu.length_in_bytes() + int(1) write_buffer.write_unsigned_short(length, logical_name="length") # Simple Field (unitIdentifier) - write_buffer.write_unsigned_byte(self.unit_identifier,bit_length=8,logical_name="unitIdentifier") + write_buffer.write_unsigned_byte( + self.unit_identifier, bit_length=8, logical_name="unitIdentifier" + ) # Simple Field (pdu) - write_buffer.write_serializable(self.pdu,logical_name="pdu") + write_buffer.write_serializable(self.pdu, logical_name="pdu") write_buffer.pop_context("ModbusTcpADU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -91,9 +97,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, driver_type: DriverType, response: bool): + def static_parse_builder( + read_buffer: ReadBuffer, driver_type: DriverType, response: bool + ): read_buffer.push_context("ModbusTcpADU") if isinstance(driver_type, str): @@ -101,27 +108,47 @@ def static_parse_builder(read_buffer: ReadBuffer, driver_type: DriverType, respo if isinstance(response, str): response = bool(strtobool(response)) - - transaction_identifier: int = read_buffer.read_unsigned_short(logical_name="transaction_identifier", bit_length=16, byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - - - PROTOCOL_IDENTIFIER: int = read_buffer.read_unsigned_short(logical_name="protocol_identifier", byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - length: int = read_buffer.read_unsigned_short(logical_name="length", byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - unit_identifier: int = read_buffer.read_unsigned_byte(logical_name="unit_identifier", bit_length=8, byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - - - pdu: ModbusPDU = read_buffer.read_complex(read_function=ModbusPDU.static_parse, logical_name="pdu", byte_order=ByteOrder.BIG_ENDIAN, driver_type=driver_type, response=response) - - + transaction_identifier: int = read_buffer.read_unsigned_short( + logical_name="transaction_identifier", + bit_length=16, + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + PROTOCOL_IDENTIFIER: int = read_buffer.read_unsigned_short( + logical_name="protocol_identifier", + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + length: int = read_buffer.read_unsigned_short( + logical_name="length", + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + unit_identifier: int = read_buffer.read_unsigned_byte( + logical_name="unit_identifier", + bit_length=8, + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) + + pdu: ModbusPDU = read_buffer.read_complex( + read_function=ModbusPDU.static_parse, + logical_name="pdu", + byte_order=ByteOrder.BIG_ENDIAN, + driver_type=driver_type, + response=response, + ) read_buffer.pop_context("ModbusTcpADU") # Create the instance - return ModbusTcpADUBuilder(transaction_identifier, unit_identifier, pdu ) - + return ModbusTcpADUBuilder(transaction_identifier, unit_identifier, pdu) def equals(self, o: object) -> bool: if self == o: @@ -131,20 +158,26 @@ def equals(self, o: object) -> bool: return False that: ModbusTcpADU = ModbusTcpADU(o) - return (self.transaction_identifier == that.transaction_identifier) and (self.unit_identifier == that.unit_identifier) and (self.pdu == that.pdu) and super().equals(that) and True + return ( + (self.transaction_identifier == that.transaction_identifier) + and (self.unit_identifier == that.unit_identifier) + and (self.pdu == that.pdu) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -153,9 +186,11 @@ class ModbusTcpADUBuilder: unit_identifier: int pdu: ModbusPDU - def build(self,response: bool , ) -> ModbusTcpADU: - modbus_tcp_adu: ModbusTcpADU = ModbusTcpADU(response , self.transaction_identifier, self.unit_identifier, self.pdu ) + def build( + self, + response: bool, + ) -> ModbusTcpADU: + modbus_tcp_adu: ModbusTcpADU = ModbusTcpADU( + response, self.transaction_identifier, self.unit_identifier, self.pdu + ) return modbus_tcp_adu - - - diff --git a/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py b/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py index c05f98d3efc..f5a2dc2bbf1 100644 --- a/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py +++ b/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py @@ -43,18 +43,18 @@ from typing import List from typing import cast import math - + class DataItem: @staticmethod def static_parse(read_buffer: ReadBuffer, data_type: str, number_of_values: int): - if data_type == "_bool" and number_of_values == int(1) : # BOOL + if data_type == "BOOL" and number_of_values == int(1): # BOOL # Simple Field (value) value: bool = read_buffer.read_bit("") return PlcBOOL(value) - if data_type == "_bool" : # List + if data_type == "BOOL": # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -62,95 +62,99 @@ def static_parse(read_buffer: ReadBuffer, data_type: str, number_of_values: int) for _ in range(item_count): value.append(PlcBOOL(bool(read_buffer.read_bit("")))) - return PlcList(value) - if data_type == "_byte" and number_of_values == int(1) : # BYTE + if data_type == "BYTE" and number_of_values == int(1): # BYTE # Simple Field (value) value: int = read_buffer.read_unsigned_short(8, logical_name="") return PlcBYTE(value) - if data_type == "_byte" : # List + if data_type == "BYTE": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcUINT(int(read_buffer.read_unsigned_short(8, logical_name="")))) - + value.append( + PlcUINT(int(read_buffer.read_unsigned_short(8, logical_name=""))) + ) return PlcList(value) - if data_type == "_word" and number_of_values == int(1) : # WORD + if data_type == "WORD" and number_of_values == int(1): # WORD # Simple Field (value) value: int = read_buffer.read_unsigned_int(16, logical_name="") return PlcWORD(value) - if data_type == "_word" : # List + if data_type == "WORD": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name="")))) - + value.append( + PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name=""))) + ) return PlcList(value) - if data_type == "_dword" and number_of_values == int(1) : # DWORD + if data_type == "DWORD" and number_of_values == int(1): # DWORD # Simple Field (value) value: int = read_buffer.read_unsigned_long(32, logical_name="") return PlcDWORD(value) - if data_type == "_dword" : # List + if data_type == "DWORD": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name="")))) - + value.append( + PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name=""))) + ) return PlcList(value) - if data_type == "_lword" and number_of_values == int(1) : # LWORD + if data_type == "LWORD" and number_of_values == int(1): # LWORD # Simple Field (value) value: int = read_buffer.read_unsigned_long(64, logical_name="") return PlcLWORD(value) - if data_type == "_lword" : # List + if data_type == "LWORD": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcLINT(int(read_buffer.read_unsigned_long(64, logical_name="")))) - + value.append( + PlcLINT(int(read_buffer.read_unsigned_long(64, logical_name=""))) + ) return PlcList(value) - if data_type == "_sint" and number_of_values == int(1) : # SINT + if data_type == "SINT" and number_of_values == int(1): # SINT # Simple Field (value) value: int = read_buffer.read_signed_byte(8, logical_name="") return PlcSINT(value) - if data_type == "_sint" : # List + if data_type == "SINT": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcSINT(int(read_buffer.read_signed_byte(8, logical_name="")))) - + value.append( + PlcSINT(int(read_buffer.read_signed_byte(8, logical_name=""))) + ) return PlcList(value) - if data_type == "_int" and number_of_values == int(1) : # INT + if data_type == "INT" and number_of_values == int(1): # INT # Simple Field (value) value: int = read_buffer.read_short(16, logical_name="") return PlcINT(value) - if data_type == "_int" : # List + if data_type == "INT": # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -158,15 +162,14 @@ def static_parse(read_buffer: ReadBuffer, data_type: str, number_of_values: int) for _ in range(item_count): value.append(PlcINT(int(read_buffer.read_short(16, logical_name="")))) - return PlcList(value) - if data_type == "_dint" and number_of_values == int(1) : # DINT + if data_type == "DINT" and number_of_values == int(1): # DINT # Simple Field (value) value: int = read_buffer.read_int(32, logical_name="") return PlcDINT(value) - if data_type == "_dint" : # List + if data_type == "DINT": # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -174,15 +177,14 @@ def static_parse(read_buffer: ReadBuffer, data_type: str, number_of_values: int) for _ in range(item_count): value.append(PlcDINT(int(read_buffer.read_int(32, logical_name="")))) - return PlcList(value) - if data_type == "_lint" and number_of_values == int(1) : # LINT + if data_type == "LINT" and number_of_values == int(1): # LINT # Simple Field (value) value: int = read_buffer.read_long(64, logical_name="") return PlcLINT(value) - if data_type == "_lint" : # List + if data_type == "LINT": # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -190,143 +192,154 @@ def static_parse(read_buffer: ReadBuffer, data_type: str, number_of_values: int) for _ in range(item_count): value.append(PlcLINT(int(read_buffer.read_long(64, logical_name="")))) - return PlcList(value) - if data_type == "_usint" and number_of_values == int(1) : # USINT + if data_type == "USINT" and number_of_values == int(1): # USINT # Simple Field (value) value: int = read_buffer.read_unsigned_short(8, logical_name="") return PlcUSINT(value) - if data_type == "_usint" : # List + if data_type == "USINT": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcUINT(int(read_buffer.read_unsigned_short(8, logical_name="")))) - + value.append( + PlcUINT(int(read_buffer.read_unsigned_short(8, logical_name=""))) + ) return PlcList(value) - if data_type == "_uint" and number_of_values == int(1) : # UINT + if data_type == "UINT" and number_of_values == int(1): # UINT # Simple Field (value) value: int = read_buffer.read_unsigned_int(16, logical_name="") return PlcUINT(value) - if data_type == "_uint" : # List + if data_type == "UINT": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name="")))) - + value.append( + PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name=""))) + ) return PlcList(value) - if data_type == "_udint" and number_of_values == int(1) : # UDINT + if data_type == "UDINT" and number_of_values == int(1): # UDINT # Simple Field (value) value: int = read_buffer.read_unsigned_long(32, logical_name="") return PlcUDINT(value) - if data_type == "_udint" : # List + if data_type == "UDINT": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name="")))) - + value.append( + PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name=""))) + ) return PlcList(value) - if data_type == "_ulint" and number_of_values == int(1) : # ULINT + if data_type == "ULINT" and number_of_values == int(1): # ULINT # Simple Field (value) value: int = read_buffer.read_unsigned_long(64, logical_name="") return PlcULINT(value) - if data_type == "_ulint" : # List + if data_type == "ULINT": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcLINT(int(read_buffer.read_unsigned_long(64, logical_name="")))) - + value.append( + PlcLINT(int(read_buffer.read_unsigned_long(64, logical_name=""))) + ) return PlcList(value) - if data_type == "_real" and number_of_values == int(1) : # REAL + if data_type == "REAL" and number_of_values == int(1): # REAL # Simple Field (value) value: float = read_buffer.read_float(32, logical_name="") return PlcREAL(value) - if data_type == "_real" : # List + if data_type == "REAL": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcREAL(float(read_buffer.read_float(32, logical_name="")))) - + value.append( + PlcREAL(float(read_buffer.read_float(32, logical_name=""))) + ) return PlcList(value) - if data_type == "_lreal" and number_of_values == int(1) : # LREAL + if data_type == "LREAL" and number_of_values == int(1): # LREAL # Simple Field (value) value: float = read_buffer.read_double(64, logical_name="") return PlcLREAL(value) - if data_type == "_lreal" : # List + if data_type == "LREAL": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcLREAL(float(read_buffer.read_double(64, logical_name="")))) - + value.append( + PlcLREAL(float(read_buffer.read_double(64, logical_name=""))) + ) return PlcList(value) - if data_type == "_char" and number_of_values == int(1) : # CHAR + if data_type == "CHAR" and number_of_values == int(1): # CHAR # Simple Field (value) value: str = read_buffer.read_str(8, logical_name="", encoding="") return PlcCHAR(value) - if data_type == "_char" : # List + if data_type == "CHAR": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcSTRING(str(read_buffer.read_str(8, logical_name="", encoding="")))) - + value.append( + PlcSTRING( + str(read_buffer.read_str(8, logical_name="", encoding="")) + ) + ) return PlcList(value) - if data_type == "_wchar" and number_of_values == int(1) : # WCHAR + if data_type == "WCHAR" and number_of_values == int(1): # WCHAR # Simple Field (value) value: str = read_buffer.read_str(16, logical_name="", encoding="") return PlcWCHAR(value) - if data_type == "_wchar" : # List + if data_type == "WCHAR": # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcSTRING(str(read_buffer.read_str(16, logical_name="", encoding="")))) - + value.append( + PlcSTRING( + str(read_buffer.read_str(16, logical_name="", encoding="")) + ) + ) return PlcList(value) - if data_type == "_string" : # STRING + if data_type == "STRING": # STRING # Simple Field (value) value: str = read_buffer.read_str(255, logical_name="", encoding="") return PlcSTRING(value) - if data_type == "_wstring" : # STRING + if data_type == "WSTRING": # STRING # Simple Field (value) value: str = read_buffer.read_str(255, logical_name="", encoding="") @@ -335,325 +348,333 @@ def static_parse(read_buffer: ReadBuffer, data_type: str, number_of_values: int) return None @staticmethod - def static_serialize(write_buffer: WriteBuffer, _value: PlcValue, data_type: str, number_of_values: int, byte_order: ByteOrder) -> None: - if data_type == "BOOL" and number_of_values == int(1) : # BOOL + def static_serialize( + write_buffer: WriteBuffer, + _value: PlcValue, + data_type: str, + number_of_values: int, + byte_order: ByteOrder, + ) -> None: + if data_type == "BOOL" and number_of_values == int(1): # BOOL # Simple Field (value) value: bool = _value.get_bool() write_buffer.write_bit((value), "value") - elif data_type == "BOOL" : # List + elif data_type == "BOOL": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: bool = val.get_bool() write_buffer.write_bit((value), "value") - elif data_type == "BYTE" and number_of_values == int(1) : # BYTE + elif data_type == "BYTE" and number_of_values == int(1): # BYTE # Simple Field (value) value: int = _value.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == "BYTE" : # List + elif data_type == "BYTE": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == "WORD" and number_of_values == int(1) : # WORD + elif data_type == "WORD" and number_of_values == int(1): # WORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == "WORD" : # List + elif data_type == "WORD": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == "DWORD" and number_of_values == int(1) : # DWORD + elif data_type == "DWORD" and number_of_values == int(1): # DWORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == "DWORD" : # List + elif data_type == "DWORD": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == "LWORD" and number_of_values == int(1) : # LWORD + elif data_type == "LWORD" and number_of_values == int(1): # LWORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_long((value), 64, "value") - elif data_type == "LWORD" : # List + elif data_type == "LWORD": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_long((value), 64, "value") - elif data_type == "SINT" and number_of_values == int(1) : # SINT + elif data_type == "SINT" and number_of_values == int(1): # SINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_signed_byte((value), 8, "value") - elif data_type == "SINT" : # List + elif data_type == "SINT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_signed_byte((value), 8, "value") - elif data_type == "INT" and number_of_values == int(1) : # INT + elif data_type == "INT" and number_of_values == int(1): # INT # Simple Field (value) value: int = _value.get_int() write_buffer.write_short((value), 16, "value") - elif data_type == "INT" : # List + elif data_type == "INT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_short((value), 16, "value") - elif data_type == "DINT" and number_of_values == int(1) : # DINT + elif data_type == "DINT" and number_of_values == int(1): # DINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_int((value), 32, "value") - elif data_type == "DINT" : # List + elif data_type == "DINT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_int((value), 32, "value") - elif data_type == "LINT" and number_of_values == int(1) : # LINT + elif data_type == "LINT" and number_of_values == int(1): # LINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_long((value), 64, "value") - elif data_type == "LINT" : # List + elif data_type == "LINT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_long((value), 64, "value") - elif data_type == "USINT" and number_of_values == int(1) : # USINT + elif data_type == "USINT" and number_of_values == int(1): # USINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == "USINT" : # List + elif data_type == "USINT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == "UINT" and number_of_values == int(1) : # UINT + elif data_type == "UINT" and number_of_values == int(1): # UINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == "UINT" : # List + elif data_type == "UINT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == "UDINT" and number_of_values == int(1) : # UDINT + elif data_type == "UDINT" and number_of_values == int(1): # UDINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == "UDINT" : # List + elif data_type == "UDINT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == "ULINT" and number_of_values == int(1) : # ULINT + elif data_type == "ULINT" and number_of_values == int(1): # ULINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_long((value), 64, "value") - elif data_type == "ULINT" : # List + elif data_type == "ULINT": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_long((value), 64, "value") - elif data_type == "REAL" and number_of_values == int(1) : # REAL + elif data_type == "REAL" and number_of_values == int(1): # REAL # Simple Field (value) value: float = _value.get_float() write_buffer.write_float((value), 32, "value") - elif data_type == "REAL" : # List + elif data_type == "REAL": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: float = val.get_float() write_buffer.write_float((value), 32, "value") - elif data_type == "LREAL" and number_of_values == int(1) : # LREAL + elif data_type == "LREAL" and number_of_values == int(1): # LREAL # Simple Field (value) value: float = _value.get_float() write_buffer.write_double((value), 64, "value") - elif data_type == "LREAL" : # List + elif data_type == "LREAL": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: float = val.get_float() write_buffer.write_double((value), 64, "value") - elif data_type == "CHAR" and number_of_values == int(1) : # CHAR + elif data_type == "CHAR" and number_of_values == int(1): # CHAR # Simple Field (value) value: str = _value.get_str() write_buffer.write_str((value), 8, "UTF-8", "value") - elif data_type == "CHAR" : # List + elif data_type == "CHAR": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: str = val.get_str() write_buffer.write_str((value), 8, "UTF-8", "value") - elif data_type == "WCHAR" and number_of_values == int(1) : # WCHAR + elif data_type == "WCHAR" and number_of_values == int(1): # WCHAR # Simple Field (value) value: str = _value.get_str() write_buffer.write_str((value), 16, "UTF-16", "value") - elif data_type == "WCHAR" : # List + elif data_type == "WCHAR": # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: str = val.get_str() write_buffer.write_str((value), 16, "UTF-16", "value") - elif data_type == "STRING" : # STRING + elif data_type == "STRING": # STRING # Simple Field (value) value: str = _value.get_str() write_buffer.write_str((value), 255, "UTF-8", "value") - elif data_type == "WSTRING" : # STRING + elif data_type == "WSTRING": # STRING # Simple Field (value) value: str = _value.get_str() write_buffer.write_str((value), 255, "UTF-16", "value") - - @staticmethod - def get_length_in_bytes(_value: PlcValue, data_type: str, number_of_values: int) -> int: - return int(math.ceil(float(DataItem.get_length_in_bits(_value, data_type, number_of_values)) / 8.0)) - + def get_length_in_bytes( + _value: PlcValue, data_type: str, number_of_values: int + ) -> int: + return int( + math.ceil( + float(DataItem.get_length_in_bits(_value, data_type, number_of_values)) + / 8.0 + ) + ) @staticmethod - def get_length_in_bits(_value: PlcValue, data_type: str, number_of_values: int) -> int: + def get_length_in_bits( + _value: PlcValue, data_type: str, number_of_values: int + ) -> int: size_in_bits: int = 0 - if data_type == "BOOL" and number_of_values == int(1): # BOOL - # Simple Field (value) - size_in_bits += 1 - elif data_type == "BOOL": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 1 - elif data_type == "BYTE" and number_of_values == int(1): # BYTE - # Simple Field (value) - size_in_bits += 8 - elif data_type == "BYTE": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == "WORD" and number_of_values == int(1): # WORD - # Simple Field (value) - size_in_bits += 16 - elif data_type == "WORD": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == "DWORD" and number_of_values == int(1): # DWORD - # Simple Field (value) - size_in_bits += 32 - elif data_type == "DWORD": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == "LWORD" and number_of_values == int(1): # LWORD - # Simple Field (value) - size_in_bits += 64 - elif data_type == "LWORD": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 64 - elif data_type == "SINT" and number_of_values == int(1): # SINT - # Simple Field (value) - size_in_bits += 8 - elif data_type == "SINT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == "INT" and number_of_values == int(1): # INT - # Simple Field (value) - size_in_bits += 16 - elif data_type == "INT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == "DINT" and number_of_values == int(1): # DINT - # Simple Field (value) - size_in_bits += 32 - elif data_type == "DINT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == "LINT" and number_of_values == int(1): # LINT - # Simple Field (value) - size_in_bits += 64 - elif data_type == "LINT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 64 - elif data_type == "USINT" and number_of_values == int(1): # USINT - # Simple Field (value) - size_in_bits += 8 - elif data_type == "USINT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == "UINT" and number_of_values == int(1): # UINT - # Simple Field (value) - size_in_bits += 16 - elif data_type == "UINT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == "UDINT" and number_of_values == int(1): # UDINT - # Simple Field (value) - size_in_bits += 32 - elif data_type == "UDINT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == "ULINT" and number_of_values == int(1): # ULINT - # Simple Field (value) - size_in_bits += 64 - elif data_type == "ULINT": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 64 - elif data_type == "REAL" and number_of_values == int(1): # REAL - # Simple Field (value) - size_in_bits += 32 - elif data_type == "REAL": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == "LREAL" and number_of_values == int(1): # LREAL - # Simple Field (value) - size_in_bits += 64 - elif data_type == "LREAL": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 64 - elif data_type == "CHAR" and number_of_values == int(1): # CHAR - # Simple Field (value) - size_in_bits += 8 - elif data_type == "CHAR": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 8 - elif data_type == "WCHAR" and number_of_values == int(1): # WCHAR - # Simple Field (value) - size_in_bits += 16 - elif data_type == "WCHAR": # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == "STRING": # STRING - # Simple Field (value) - size_in_bits += 255 - elif data_type == "WSTRING": # STRING - # Simple Field (value) - size_in_bits += 255 - - return size_in_bits - - - + if data_type == "BOOL" and number_of_values == int(1): # BOOL + # Simple Field (value) + size_in_bits += 1 + elif data_type == "BOOL": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 1 + elif data_type == "BYTE" and number_of_values == int(1): # BYTE + # Simple Field (value) + size_in_bits += 8 + elif data_type == "BYTE": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == "WORD" and number_of_values == int(1): # WORD + # Simple Field (value) + size_in_bits += 16 + elif data_type == "WORD": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == "DWORD" and number_of_values == int(1): # DWORD + # Simple Field (value) + size_in_bits += 32 + elif data_type == "DWORD": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == "LWORD" and number_of_values == int(1): # LWORD + # Simple Field (value) + size_in_bits += 64 + elif data_type == "LWORD": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 64 + elif data_type == "SINT" and number_of_values == int(1): # SINT + # Simple Field (value) + size_in_bits += 8 + elif data_type == "SINT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == "INT" and number_of_values == int(1): # INT + # Simple Field (value) + size_in_bits += 16 + elif data_type == "INT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == "DINT" and number_of_values == int(1): # DINT + # Simple Field (value) + size_in_bits += 32 + elif data_type == "DINT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == "LINT" and number_of_values == int(1): # LINT + # Simple Field (value) + size_in_bits += 64 + elif data_type == "LINT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 64 + elif data_type == "USINT" and number_of_values == int(1): # USINT + # Simple Field (value) + size_in_bits += 8 + elif data_type == "USINT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == "UINT" and number_of_values == int(1): # UINT + # Simple Field (value) + size_in_bits += 16 + elif data_type == "UINT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == "UDINT" and number_of_values == int(1): # UDINT + # Simple Field (value) + size_in_bits += 32 + elif data_type == "UDINT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == "ULINT" and number_of_values == int(1): # ULINT + # Simple Field (value) + size_in_bits += 64 + elif data_type == "ULINT": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 64 + elif data_type == "REAL" and number_of_values == int(1): # REAL + # Simple Field (value) + size_in_bits += 32 + elif data_type == "REAL": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == "LREAL" and number_of_values == int(1): # LREAL + # Simple Field (value) + size_in_bits += 64 + elif data_type == "LREAL": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 64 + elif data_type == "CHAR" and number_of_values == int(1): # CHAR + # Simple Field (value) + size_in_bits += 8 + elif data_type == "CHAR": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 8 + elif data_type == "WCHAR" and number_of_values == int(1): # WCHAR + # Simple Field (value) + size_in_bits += 16 + elif data_type == "WCHAR": # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == "STRING": # STRING + # Simple Field (value) + size_in_bits += 255 + elif data_type == "WSTRING": # STRING + # Simple Field (value) + size_in_bits += 255 + return size_in_bits diff --git a/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py b/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py index a822c3f4e97..8e42d9f3507 100644 --- a/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py +++ b/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py @@ -26,22 +26,22 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.utils.GenericTypes import ByteOrder import math - -@dataclass -class Dummy(): - dummy: int +@dataclass +class Dummy: + dummy: int def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("Dummy") # Simple Field (dummy) - write_buffer.write_unsigned_short(self.dummy,bit_length=16,logical_name="dummy") + write_buffer.write_unsigned_short( + self.dummy, bit_length=16, logical_name="dummy" + ) write_buffer.pop_context("Dummy") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -54,28 +54,23 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return Dummy.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("Dummy") - - - dummy: int = read_buffer.read_unsigned_short(logical_name="dummy", bit_length=16, byte_order=ByteOrder.BIG_ENDIAN) - - + dummy: int = read_buffer.read_unsigned_short( + logical_name="dummy", bit_length=16, byte_order=ByteOrder.BIG_ENDIAN + ) read_buffer.pop_context("Dummy") # Create the instance - _dummy: Dummy = Dummy(dummy ) + _dummy: Dummy = Dummy(dummy) return _dummy - def equals(self, o: object) -> bool: if self == o: return True @@ -91,14 +86,10 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/simulated/readwrite/SimulatedDataTypeSizes.py b/plc4py/plc4py/protocols/simulated/readwrite/SimulatedDataTypeSizes.py index a3d5f40a0ea..9c391b4351e 100644 --- a/plc4py/plc4py/protocols/simulated/readwrite/SimulatedDataTypeSizes.py +++ b/plc4py/plc4py/protocols/simulated/readwrite/SimulatedDataTypeSizes.py @@ -19,36 +19,34 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - -class SimulatedDataTypeSizes(AutoNumberEnum): - _init_ = "value, data_type_size" - BOOL = (1 , int(1) ) - BYTE = (2 , int(1) ) - WORD = (3 , int(2) ) - DWORD = (4 , int(4) ) - LWORD = (5 , int(8) ) - SINT = (6 , int(1) ) - INT = (7 , int(2) ) - DINT = (8 , int(4) ) - LINT = (9 , int(8) ) - USINT = (10 , int(1) ) - UINT = (11 , int(2) ) - UDINT = (12 , int(4) ) - ULINT = (13 , int(8) ) - REAL = (14 , int(4) ) - LREAL = (15 , int(8) ) - TIME = (16 , int(8) ) - LTIME = (17 , int(8) ) - DATE = (18 , int(8) ) - LDATE = (19 , int(8) ) - TIME_OF_DAY = (20 , int(8) ) - LTIME_OF_DAY = (21 , int(8) ) - DATE_AND_TIME = (22 , int(8) ) - LDATE_AND_TIME = (23 , int(8) ) - CHAR = (24 , int(1) ) - WCHAR = (25 , int(2) ) - STRING = (26 , int(255) ) - WSTRING = (27 , int(127) ) - +class SimulatedDataTypeSizes(AutoNumberEnum): + _init_ = "value, data_type_size" + BOOL = (1, int(1)) + BYTE = (2, int(1)) + WORD = (3, int(2)) + DWORD = (4, int(4)) + LWORD = (5, int(8)) + SINT = (6, int(1)) + INT = (7, int(2)) + DINT = (8, int(4)) + LINT = (9, int(8)) + USINT = (10, int(1)) + UINT = (11, int(2)) + UDINT = (12, int(4)) + ULINT = (13, int(8)) + REAL = (14, int(4)) + LREAL = (15, int(8)) + TIME = (16, int(8)) + LTIME = (17, int(8)) + DATE = (18, int(8)) + LDATE = (19, int(8)) + TIME_OF_DAY = (20, int(8)) + LTIME_OF_DAY = (21, int(8)) + DATE_AND_TIME = (22, int(8)) + LDATE_AND_TIME = (23, int(8)) + CHAR = (24, int(1)) + WCHAR = (25, int(2)) + STRING = (26, int(255)) + WSTRING = (27, int(127)) diff --git a/plc4py/plc4py/protocols/umas/readwrite/DataItem.py b/plc4py/plc4py/protocols/umas/readwrite/DataItem.py index 9cf7e71c583..800ec4d68db 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/DataItem.py +++ b/plc4py/plc4py/protocols/umas/readwrite/DataItem.py @@ -39,23 +39,31 @@ from typing import cast import logging import math - + class DataItem: @staticmethod - def static_parse(read_buffer: ReadBuffer, data_type: UmasDataType, number_of_values: int): - if data_type == UmasDataType.BOOL and number_of_values == int(1) : # BOOL + def static_parse( + read_buffer: ReadBuffer, data_type: UmasDataType, number_of_values: int + ): + if data_type == UmasDataType.BOOL and number_of_values == int(1): # BOOL # Reserved Field (Compartmentalized so the "reserved" variable can't leak) reserved: int = read_buffer.read_unsigned_short(7, logical_name="") if reserved != int(0x0000): - logging.warning("Expected constant value " + str(0x0000) + " but got " + str(reserved) + " for reserved field.") + logging.warning( + "Expected constant value " + + str(0x0000) + + " but got " + + str(reserved) + + " for reserved field." + ) # Simple Field (value) value: bool = read_buffer.read_bit("") return PlcBOOL(value) - if data_type == UmasDataType.BOOL : # List + if data_type == UmasDataType.BOOL: # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -63,43 +71,41 @@ def static_parse(read_buffer: ReadBuffer, data_type: UmasDataType, number_of_val for _ in range(item_count): value.append(PlcBOOL(bool(read_buffer.read_bit("")))) - return PlcList(value) - if data_type == UmasDataType.BYTE and number_of_values == int(1) : # BYTE + if data_type == UmasDataType.BYTE and number_of_values == int(1): # BYTE # Simple Field (value) value: int = read_buffer.read_unsigned_short(8, logical_name="") return PlcBYTE(value) - if data_type == UmasDataType.BYTE : # List + if data_type == UmasDataType.BYTE: # List # Array field (value) # Count array - item_count: int = int(number_of_values* int(8)) + item_count: int = int(number_of_values * int(8)) value: List[PlcValue] = [] for _ in range(item_count): value.append(PlcBOOL(bool(read_buffer.read_bit("")))) - return PlcList(value) - if data_type == UmasDataType.WORD : # WORD + if data_type == UmasDataType.WORD: # WORD # Simple Field (value) value: int = read_buffer.read_unsigned_int(16, logical_name="") return PlcWORD(value) - if data_type == UmasDataType.DWORD : # DWORD + if data_type == UmasDataType.DWORD: # DWORD # Simple Field (value) value: int = read_buffer.read_unsigned_long(32, logical_name="") return PlcDWORD(value) - if data_type == UmasDataType.INT and number_of_values == int(1) : # INT + if data_type == UmasDataType.INT and number_of_values == int(1): # INT # Simple Field (value) value: int = read_buffer.read_short(16, logical_name="") return PlcINT(value) - if data_type == UmasDataType.INT : # List + if data_type == UmasDataType.INT: # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -107,15 +113,14 @@ def static_parse(read_buffer: ReadBuffer, data_type: UmasDataType, number_of_val for _ in range(item_count): value.append(PlcINT(int(read_buffer.read_short(16, logical_name="")))) - return PlcList(value) - if data_type == UmasDataType.DINT and number_of_values == int(1) : # DINT + if data_type == UmasDataType.DINT and number_of_values == int(1): # DINT # Simple Field (value) value: int = read_buffer.read_int(32, logical_name="") return PlcDINT(value) - if data_type == UmasDataType.DINT : # List + if data_type == UmasDataType.DINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) @@ -123,242 +128,257 @@ def static_parse(read_buffer: ReadBuffer, data_type: UmasDataType, number_of_val for _ in range(item_count): value.append(PlcDINT(int(read_buffer.read_int(32, logical_name="")))) - return PlcList(value) - if data_type == UmasDataType.UINT and number_of_values == int(1) : # UINT + if data_type == UmasDataType.UINT and number_of_values == int(1): # UINT # Simple Field (value) value: int = read_buffer.read_unsigned_int(16, logical_name="") return PlcUINT(value) - if data_type == UmasDataType.UINT : # List + if data_type == UmasDataType.UINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name="")))) - + value.append( + PlcUDINT(int(read_buffer.read_unsigned_int(16, logical_name=""))) + ) return PlcList(value) - if data_type == UmasDataType.UDINT and number_of_values == int(1) : # UDINT + if data_type == UmasDataType.UDINT and number_of_values == int(1): # UDINT # Simple Field (value) value: int = read_buffer.read_unsigned_long(32, logical_name="") return PlcUDINT(value) - if data_type == UmasDataType.UDINT : # List + if data_type == UmasDataType.UDINT: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name="")))) - + value.append( + PlcULINT(int(read_buffer.read_unsigned_long(32, logical_name=""))) + ) return PlcList(value) - if data_type == UmasDataType.REAL and number_of_values == int(1) : # REAL + if data_type == UmasDataType.REAL and number_of_values == int(1): # REAL # Simple Field (value) value: float = read_buffer.read_float(32, logical_name="") return PlcREAL(value) - if data_type == UmasDataType.REAL : # List + if data_type == UmasDataType.REAL: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcREAL(float(read_buffer.read_float(32, logical_name="")))) - + value.append( + PlcREAL(float(read_buffer.read_float(32, logical_name=""))) + ) return PlcList(value) - if data_type == UmasDataType.STRING and number_of_values == int(1) : # STRING + if data_type == UmasDataType.STRING and number_of_values == int(1): # STRING # Manual Field (value) - value: str = (str) (StaticHelper.parse_terminated_string_bytes(read_buffer, number_of_values)) + value: str = (str)( + StaticHelper.parse_terminated_string_bytes( + read_buffer, number_of_values + ) + ) return PlcSTRING(value) - if data_type == UmasDataType.STRING : # List + if data_type == UmasDataType.STRING: # List # Array field (value) # Count array item_count: int = int(number_of_values) value: List[PlcValue] = [] for _ in range(item_count): - value.append(PlcREAL(float(read_buffer.read_float(32, logical_name="")))) - + value.append( + PlcREAL(float(read_buffer.read_float(32, logical_name=""))) + ) return PlcList(value) return None @staticmethod - def static_serialize(write_buffer: WriteBuffer, _value: PlcValue, data_type: UmasDataType, number_of_values: int, byte_order: ByteOrder) -> None: - if data_type == UmasDataType.BOOL and number_of_values == int(1) : # BOOL + def static_serialize( + write_buffer: WriteBuffer, + _value: PlcValue, + data_type: UmasDataType, + number_of_values: int, + byte_order: ByteOrder, + ) -> None: + if data_type == UmasDataType.BOOL and number_of_values == int(1): # BOOL # Reserved Field write_buffer.write_byte(int(0x0000), 7, "int0x0000") # Simple Field (value) value: bool = _value.get_bool() write_buffer.write_bit((value), "value") - elif data_type == UmasDataType.BOOL : # List + elif data_type == UmasDataType.BOOL: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: bool = val.get_bool() write_buffer.write_bit((value), "value") - elif data_type == UmasDataType.BYTE and number_of_values == int(1) : # BYTE + elif data_type == UmasDataType.BYTE and number_of_values == int(1): # BYTE # Simple Field (value) value: int = _value.get_int() write_buffer.write_byte((value), 8, "value") - elif data_type == UmasDataType.BYTE : # List + elif data_type == UmasDataType.BYTE: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: bool = val.get_bool() write_buffer.write_bit((value), "value") - elif data_type == UmasDataType.WORD : # WORD + elif data_type == UmasDataType.WORD: # WORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == UmasDataType.DWORD : # DWORD + elif data_type == UmasDataType.DWORD: # DWORD # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == UmasDataType.INT and number_of_values == int(1) : # INT + elif data_type == UmasDataType.INT and number_of_values == int(1): # INT # Simple Field (value) value: int = _value.get_int() write_buffer.write_short((value), 16, "value") - elif data_type == UmasDataType.INT : # List + elif data_type == UmasDataType.INT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_short((value), 16, "value") - elif data_type == UmasDataType.DINT and number_of_values == int(1) : # DINT + elif data_type == UmasDataType.DINT and number_of_values == int(1): # DINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_int((value), 32, "value") - elif data_type == UmasDataType.DINT : # List + elif data_type == UmasDataType.DINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_int((value), 32, "value") - elif data_type == UmasDataType.UINT and number_of_values == int(1) : # UINT + elif data_type == UmasDataType.UINT and number_of_values == int(1): # UINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == UmasDataType.UINT : # List + elif data_type == UmasDataType.UINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_short((value), 16, "value") - elif data_type == UmasDataType.UDINT and number_of_values == int(1) : # UDINT + elif data_type == UmasDataType.UDINT and number_of_values == int(1): # UDINT # Simple Field (value) value: int = _value.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == UmasDataType.UDINT : # List + elif data_type == UmasDataType.UDINT: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: int = val.get_int() write_buffer.write_unsigned_int((value), 32, "value") - elif data_type == UmasDataType.REAL and number_of_values == int(1) : # REAL + elif data_type == UmasDataType.REAL and number_of_values == int(1): # REAL # Simple Field (value) value: float = _value.get_float() write_buffer.write_float((value), 32, "value") - elif data_type == UmasDataType.REAL : # List + elif data_type == UmasDataType.REAL: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: float = val.get_float() write_buffer.write_float((value), 32, "value") - elif data_type == UmasDataType.STRING and number_of_values == int(1) : # STRING + elif data_type == UmasDataType.STRING and number_of_values == int(1): # STRING # Manual Field (value) serialize_terminated_string(write_buffer, self.value, self.number_of_values) - elif data_type == UmasDataType.STRING : # List + elif data_type == UmasDataType.STRING: # List values: PlcList = cast(PlcList, _value) for val in values.get_list(): value: float = val.get_float() write_buffer.write_float((value), 32, "value") - - @staticmethod - def get_length_in_bytes(_value: PlcValue, data_type: UmasDataType, number_of_values: int) -> int: - return int(math.ceil(float(DataItem.get_length_in_bits(_value, data_type, number_of_values)) / 8.0)) - + def get_length_in_bytes( + _value: PlcValue, data_type: UmasDataType, number_of_values: int + ) -> int: + return int( + math.ceil( + float(DataItem.get_length_in_bits(_value, data_type, number_of_values)) + / 8.0 + ) + ) @staticmethod - def get_length_in_bits(_value: PlcValue, data_type: UmasDataType, number_of_values: int) -> int: + def get_length_in_bits( + _value: PlcValue, data_type: UmasDataType, number_of_values: int + ) -> int: size_in_bits: int = 0 - if data_type == UmasDataType.BOOL and number_of_values == int(1): # BOOL - # Reserved Field - size_in_bits += 7 - # Simple Field (value) - size_in_bits += 1 - elif data_type == UmasDataType.BOOL: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 1 - elif data_type == UmasDataType.BYTE and number_of_values == int(1): # BYTE - # Simple Field (value) - size_in_bits += 8 - elif data_type == UmasDataType.BYTE: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 1 - elif data_type == UmasDataType.WORD: # WORD - # Simple Field (value) - size_in_bits += 16 - elif data_type == UmasDataType.DWORD: # DWORD - # Simple Field (value) - size_in_bits += 32 - elif data_type == UmasDataType.INT and number_of_values == int(1): # INT - # Simple Field (value) - size_in_bits += 16 - elif data_type == UmasDataType.INT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == UmasDataType.DINT and number_of_values == int(1): # DINT - # Simple Field (value) - size_in_bits += 32 - elif data_type == UmasDataType.DINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == UmasDataType.UINT and number_of_values == int(1): # UINT - # Simple Field (value) - size_in_bits += 16 - elif data_type == UmasDataType.UINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 16 - elif data_type == UmasDataType.UDINT and number_of_values == int(1): # UDINT - # Simple Field (value) - size_in_bits += 32 - elif data_type == UmasDataType.UDINT: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == UmasDataType.REAL and number_of_values == int(1): # REAL - # Simple Field (value) - size_in_bits += 32 - elif data_type == UmasDataType.REAL: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - elif data_type == UmasDataType.STRING and number_of_values == int(1): # STRING - # Manual Field (value) - size_in_bits += (self.number_of_values* int(8)) - elif data_type == UmasDataType.STRING: # List - values: PlcList = cast(PlcList, _value) - size_in_bits += len(values.get_list()) * 32 - - return size_in_bits - - - + if data_type == UmasDataType.BOOL and number_of_values == int(1): # BOOL + # Reserved Field + size_in_bits += 7 + # Simple Field (value) + size_in_bits += 1 + elif data_type == UmasDataType.BOOL: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 1 + elif data_type == UmasDataType.BYTE and number_of_values == int(1): # BYTE + # Simple Field (value) + size_in_bits += 8 + elif data_type == UmasDataType.BYTE: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 1 + elif data_type == UmasDataType.WORD: # WORD + # Simple Field (value) + size_in_bits += 16 + elif data_type == UmasDataType.DWORD: # DWORD + # Simple Field (value) + size_in_bits += 32 + elif data_type == UmasDataType.INT and number_of_values == int(1): # INT + # Simple Field (value) + size_in_bits += 16 + elif data_type == UmasDataType.INT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == UmasDataType.DINT and number_of_values == int(1): # DINT + # Simple Field (value) + size_in_bits += 32 + elif data_type == UmasDataType.DINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == UmasDataType.UINT and number_of_values == int(1): # UINT + # Simple Field (value) + size_in_bits += 16 + elif data_type == UmasDataType.UINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 16 + elif data_type == UmasDataType.UDINT and number_of_values == int(1): # UDINT + # Simple Field (value) + size_in_bits += 32 + elif data_type == UmasDataType.UDINT: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == UmasDataType.REAL and number_of_values == int(1): # REAL + # Simple Field (value) + size_in_bits += 32 + elif data_type == UmasDataType.REAL: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + elif data_type == UmasDataType.STRING and number_of_values == int(1): # STRING + # Manual Field (value) + size_in_bits += self.number_of_values * int(8) + elif data_type == UmasDataType.STRING: # List + values: PlcList = cast(PlcList, _value) + size_in_bits += len(values.get_list()) * 32 + return size_in_bits diff --git a/plc4py/plc4py/protocols/umas/readwrite/ModbusErrorCode.py b/plc4py/plc4py/protocols/umas/readwrite/ModbusErrorCode.py index 3f626e23744..bfbad8d872b 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/ModbusErrorCode.py +++ b/plc4py/plc4py/protocols/umas/readwrite/ModbusErrorCode.py @@ -19,9 +19,10 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - + + class ModbusErrorCode(AutoNumberEnum): - + ILLEGAL_FUNCTION: int = 1 ILLEGAL_DATA_ADDRESS: int = 2 ILLEGAL_DATA_VALUE: int = 3 @@ -32,6 +33,3 @@ class ModbusErrorCode(AutoNumberEnum): MEMORY_PARITY_ERROR: int = 8 GATEWAY_PATH_UNAVAILABLE: int = 10 GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND: int = 11 - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/ModbusPDU.py b/plc4py/plc4py/protocols/umas/readwrite/ModbusPDU.py index 69652514a43..453d4277591 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/ModbusPDU.py +++ b/plc4py/plc4py/protocols/umas/readwrite/ModbusPDU.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass class ModbusPDU(ABC, PlcMessage): # Arguments. @@ -39,11 +40,11 @@ class ModbusPDU(ABC, PlcMessage): @property def error_flag(self) -> bool: pass + @property def function_flag(self) -> int: pass - @abstractmethod def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer) -> None: pass @@ -52,17 +53,18 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDU") # Discriminator Field (errorFlag) (Used as input to a switch field) - write_buffer.write_bit(self.error_flag, logical_name="error_flag", bit_length=1 ) + write_buffer.write_bit(self.error_flag, logical_name="error_flag", bit_length=1) # Discriminator Field (functionFlag) (Used as input to a switch field) - write_buffer.write_unsigned_byte(self.function_flag, logical_name="function_flag", bit_length=7 ) + write_buffer.write_unsigned_byte( + self.function_flag, logical_name="function_flag", bit_length=7 + ) # Switch field (Serialize the sub-type) self.serialize_modbus_pdu_child(write_buffer) write_buffer.pop_context("ModbusPDU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -80,20 +82,26 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): if kwargs is None: - raise PlcRuntimeException("Wrong number of arguments, expected 2, but got None") + raise PlcRuntimeException( + "Wrong number of arguments, expected 2, but got None" + ) umas_request_function_key: int = 0 if isinstance(kwargs.get("umas_request_function_key"), int): umas_request_function_key = int(kwargs.get("umas_request_function_key")) elif isinstance(kwargs.get("umas_request_function_key"), str): - umas_request_function_key = int(str(kwargs.get("umas_request_function_key"))) + umas_request_function_key = int( + str(kwargs.get("umas_request_function_key")) + ) else: - raise PlcRuntimeException("Argument 0 expected to be of type int or a string which is parseable but was " + kwargs.get("umas_request_function_key").getClass().getName()) + raise PlcRuntimeException( + "Argument 0 expected to be of type int or a string which is parseable but was " + + kwargs.get("umas_request_function_key").getClass().getName() + ) byte_length: int = 0 if isinstance(kwargs.get("byte_length"), int): @@ -101,13 +109,19 @@ def static_parse(read_buffer: ReadBuffer, **kwargs): elif isinstance(kwargs.get("byte_length"), str): byte_length = int(str(kwargs.get("byte_length"))) else: - raise PlcRuntimeException("Argument 1 expected to be of type int or a string which is parseable but was " + kwargs.get("byte_length").getClass().getName()) - - return ModbusPDU.static_parse_context(read_buffer, umas_request_function_key, byte_length) + raise PlcRuntimeException( + "Argument 1 expected to be of type int or a string which is parseable but was " + + kwargs.get("byte_length").getClass().getName() + ) + return ModbusPDU.static_parse_context( + read_buffer, umas_request_function_key, byte_length + ) @staticmethod - def static_parse_context(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_context( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("ModbusPDU") if isinstance(umas_request_function_key, str): @@ -115,33 +129,53 @@ def static_parse_context(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - error_flag: bool = read_buffer.read_bit(logical_name="error_flag", bit_length=1, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - function_flag: int = read_buffer.read_unsigned_byte(logical_name="function_flag", bit_length=7, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - + error_flag: bool = read_buffer.read_bit( + logical_name="error_flag", + bit_length=1, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + function_flag: int = read_buffer.read_unsigned_byte( + logical_name="function_flag", + bit_length=7, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type) builder: ModbusPDUBuilder = None from plc4py.protocols.umas.readwrite.ModbusPDUError import ModbusPDUError - if error_flag == bool(True) : - builder = ModbusPDUError.static_parse_builder(read_buffer, umas_request_function_key, byte_length) + if error_flag == bool(True): + + builder = ModbusPDUError.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) from plc4py.protocols.umas.readwrite.UmasPDU import UmasPDU - if error_flag == bool(False) and function_flag == int(0x5a) : - builder = UmasPDU.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - if builder is None: - raise ParseException("Unsupported case for discriminated type"+" parameters ["+"errorFlag="+str(error_flag)+" "+"functionFlag="+str(function_flag)+"]") + if error_flag == bool(False) and function_flag == int(0x5A): + builder = UmasPDU.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + if builder is None: + raise ParseException( + "Unsupported case for discriminated type" + + " parameters [" + + "errorFlag=" + + str(error_flag) + + " " + + "functionFlag=" + + str(function_flag) + + "]" + ) read_buffer.pop_context("ModbusPDU") # Create the instance - _modbus_pdu: ModbusPDU = builder.build(umas_request_function_key, byte_length ) + _modbus_pdu: ModbusPDU = builder.build(umas_request_function_key, byte_length) return _modbus_pdu - def equals(self, o: object) -> bool: if self == o: return True @@ -157,19 +191,16 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" + @dataclass class ModbusPDUBuilder: - def build(self, umas_request_function_key: int, byte_length: int ) -> ModbusPDU: + def build(self, umas_request_function_key: int, byte_length: int) -> ModbusPDU: pass - - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/ModbusPDUError.py b/plc4py/plc4py/protocols/umas/readwrite/ModbusPDUError.py index cab908ac443..98931e8671d 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/ModbusPDUError.py +++ b/plc4py/plc4py/protocols/umas/readwrite/ModbusPDUError.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class ModbusPDUError(ModbusPDU): exception_code: ModbusErrorCode @@ -39,17 +40,16 @@ class ModbusPDUError(ModbusPDU): error_flag: ClassVar[bool] = True function_flag: ClassVar[int] = 0 - - def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusPDUError") # Simple Field (exceptionCode) - write_buffer.write_unsigned_byte(self.exception_code, logical_name="exceptionCode") + write_buffer.write_unsigned_byte( + self.exception_code, logical_name="exceptionCode" + ) write_buffer.pop_context("ModbusPDUError") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -62,9 +62,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("ModbusPDUError") if isinstance(umas_request_function_key, str): @@ -72,15 +73,17 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - exception_code: ModbusErrorCode = read_buffer.read_enum(read_function=ModbusErrorCode,bit_length=8, logical_name="exception_code", umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - + exception_code: ModbusErrorCode = read_buffer.read_enum( + read_function=ModbusErrorCode, + bit_length=8, + logical_name="exception_code", + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("ModbusPDUError") # Create the instance - return ModbusPDUErrorBuilder(exception_code ) - + return ModbusPDUErrorBuilder(exception_code) def equals(self, o: object) -> bool: if self == o: @@ -90,29 +93,36 @@ def equals(self, o: object) -> bool: return False that: ModbusPDUError = ModbusPDUError(o) - return (self.exception_code == that.exception_code) and super().equals(that) and True + return ( + (self.exception_code == that.exception_code) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class ModbusPDUErrorBuilder: exception_code: ModbusErrorCode - def build(self,umas_request_function_key: int, byte_length: int , ) -> ModbusPDUError: - modbus_pduerror: ModbusPDUError = ModbusPDUError(umas_request_function_key, byte_length , self.exception_code ) + def build( + self, + umas_request_function_key: int, + byte_length: int, + ) -> ModbusPDUError: + modbus_pduerror: ModbusPDUError = ModbusPDUError( + umas_request_function_key, byte_length, self.exception_code + ) return modbus_pduerror - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/ModbusTcpADU.py b/plc4py/plc4py/protocols/umas/readwrite/ModbusTcpADU.py index 20c86623319..0b7fba1a48b 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/ModbusTcpADU.py +++ b/plc4py/plc4py/protocols/umas/readwrite/ModbusTcpADU.py @@ -28,38 +28,44 @@ from typing import Any from typing import List import math - + + @dataclass -class ModbusTcpADU(): +class ModbusTcpADU: transaction_identifier: int unit_identifier: int pdu_array: List[int] PROTOCOL_IDENTIFIER: int = 0x0000 - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("ModbusTcpADU") # Simple Field (transactionIdentifier) - write_buffer.write_unsigned_short(self.transaction_identifier,bit_length=16,logical_name="transactionIdentifier") + write_buffer.write_unsigned_short( + self.transaction_identifier, + bit_length=16, + logical_name="transactionIdentifier", + ) # Const Field (protocolIdentifier) - write_buffer.write_unsigned_short(self.PROTOCOL_IDENTIFIER, logical_name="protocolIdentifier") + write_buffer.write_unsigned_short( + self.PROTOCOL_IDENTIFIER, logical_name="protocolIdentifier" + ) # Implicit Field (length) (Used for parsing, but its value is not stored as it's implicitly given by the objects content) - length: int = (int(len(self.pdu_array))+ int(1)) + length: int = int(len(self.pdu_array)) + int(1) write_buffer.write_unsigned_short(length, logical_name="length") # Simple Field (unitIdentifier) - write_buffer.write_unsigned_byte(self.unit_identifier,bit_length=8,logical_name="unitIdentifier") + write_buffer.write_unsigned_byte( + self.unit_identifier, bit_length=8, logical_name="unitIdentifier" + ) # Array Field (pduArray) write_buffer.write_byte_array(self.pdu_array, logical_name="pdu_array") write_buffer.pop_context("ModbusTcpADU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -83,41 +89,50 @@ def length_in_bits(self) -> int: if self.pdu_array is not None: length_in_bits += 8 * len(self.pdu_array) - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return ModbusTcpADU.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("ModbusTcpADU") - - - transaction_identifier: int = read_buffer.read_unsigned_short(logical_name="transaction_identifier", bit_length=16, byte_order=ByteOrder.BIG_ENDIAN) - - - - PROTOCOL_IDENTIFIER: int = read_buffer.read_unsigned_short(logical_name="protocol_identifier", byte_order=ByteOrder.BIG_ENDIAN) - - length: int = read_buffer.read_unsigned_short(logical_name="length", byte_order=ByteOrder.BIG_ENDIAN) - - unit_identifier: int = read_buffer.read_unsigned_byte(logical_name="unit_identifier", bit_length=8, byte_order=ByteOrder.BIG_ENDIAN) - - - - pdu_array: List[Any] = read_buffer.read_array_field(logical_name="pduArray", read_function=read_buffer.read_byte, count=length- int(1), byte_order=ByteOrder.BIG_ENDIAN) + transaction_identifier: int = read_buffer.read_unsigned_short( + logical_name="transaction_identifier", + bit_length=16, + byte_order=ByteOrder.BIG_ENDIAN, + ) + + PROTOCOL_IDENTIFIER: int = read_buffer.read_unsigned_short( + logical_name="protocol_identifier", byte_order=ByteOrder.BIG_ENDIAN + ) + + length: int = read_buffer.read_unsigned_short( + logical_name="length", byte_order=ByteOrder.BIG_ENDIAN + ) + + unit_identifier: int = read_buffer.read_unsigned_byte( + logical_name="unit_identifier", + bit_length=8, + byte_order=ByteOrder.BIG_ENDIAN, + ) + + pdu_array: List[Any] = read_buffer.read_array_field( + logical_name="pduArray", + read_function=read_buffer.read_byte, + count=length - int(1), + byte_order=ByteOrder.BIG_ENDIAN, + ) read_buffer.pop_context("ModbusTcpADU") # Create the instance - _modbus_tcp_adu: ModbusTcpADU = ModbusTcpADU(transaction_identifier, unit_identifier, pdu_array ) + _modbus_tcp_adu: ModbusTcpADU = ModbusTcpADU( + transaction_identifier, unit_identifier, pdu_array + ) return _modbus_tcp_adu - def equals(self, o: object) -> bool: if self == o: return True @@ -126,21 +141,22 @@ def equals(self, o: object) -> bool: return False that: ModbusTcpADU = ModbusTcpADU(o) - return (self.transaction_identifier == that.transaction_identifier) and (self.unit_identifier == that.unit_identifier) and (self.pdu_array == that.pdu_array) and True + return ( + (self.transaction_identifier == that.transaction_identifier) + and (self.unit_identifier == that.unit_identifier) + and (self.pdu_array == that.pdu_array) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/PlcMemoryBlockIdent.py b/plc4py/plc4py/protocols/umas/readwrite/PlcMemoryBlockIdent.py index a17c8aa05db..eb02667c64f 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/PlcMemoryBlockIdent.py +++ b/plc4py/plc4py/protocols/umas/readwrite/PlcMemoryBlockIdent.py @@ -25,34 +25,38 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass -class PlcMemoryBlockIdent(): +class PlcMemoryBlockIdent: block_type: int folio: int status: int memory_length: int - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("PlcMemoryBlockIdent") # Simple Field (blockType) - write_buffer.write_unsigned_byte(self.block_type,bit_length=8,logical_name="blockType") + write_buffer.write_unsigned_byte( + self.block_type, bit_length=8, logical_name="blockType" + ) # Simple Field (folio) - write_buffer.write_unsigned_byte(self.folio,bit_length=8,logical_name="folio") + write_buffer.write_unsigned_byte(self.folio, bit_length=8, logical_name="folio") # Simple Field (status) - write_buffer.write_unsigned_short(self.status,bit_length=16,logical_name="status") + write_buffer.write_unsigned_short( + self.status, bit_length=16, logical_name="status" + ) # Simple Field (memoryLength) - write_buffer.write_unsigned_int(self.memory_length,bit_length=32,logical_name="memoryLength") + write_buffer.write_unsigned_int( + self.memory_length, bit_length=32, logical_name="memoryLength" + ) write_buffer.pop_context("PlcMemoryBlockIdent") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -74,40 +78,35 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return PlcMemoryBlockIdent.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("PlcMemoryBlockIdent") + block_type: int = read_buffer.read_unsigned_byte( + logical_name="block_type", bit_length=8 + ) + folio: int = read_buffer.read_unsigned_byte(logical_name="folio", bit_length=8) - block_type: int = read_buffer.read_unsigned_byte(logical_name="block_type", bit_length=8) - - - - folio: int = read_buffer.read_unsigned_byte(logical_name="folio", bit_length=8) - - - - status: int = read_buffer.read_unsigned_short(logical_name="status", bit_length=16) - - - - memory_length: int = read_buffer.read_unsigned_int(logical_name="memory_length", bit_length=32) - + status: int = read_buffer.read_unsigned_short( + logical_name="status", bit_length=16 + ) + memory_length: int = read_buffer.read_unsigned_int( + logical_name="memory_length", bit_length=32 + ) read_buffer.pop_context("PlcMemoryBlockIdent") # Create the instance - _plc_memory_block_ident: PlcMemoryBlockIdent = PlcMemoryBlockIdent(block_type, folio, status, memory_length ) + _plc_memory_block_ident: PlcMemoryBlockIdent = PlcMemoryBlockIdent( + block_type, folio, status, memory_length + ) return _plc_memory_block_ident - def equals(self, o: object) -> bool: if self == o: return True @@ -116,21 +115,23 @@ def equals(self, o: object) -> bool: return False that: PlcMemoryBlockIdent = PlcMemoryBlockIdent(o) - return (self.block_type == that.block_type) and (self.folio == that.folio) and (self.status == that.status) and (self.memory_length == that.memory_length) and True + return ( + (self.block_type == that.block_type) + and (self.folio == that.folio) + and (self.status == that.status) + and (self.memory_length == that.memory_length) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasConstants.py b/plc4py/plc4py/protocols/umas/readwrite/UmasConstants.py index ff4c5fb2034..bc8c7ad0727 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasConstants.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasConstants.py @@ -25,22 +25,22 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - -@dataclass -class UmasConstants(): - UMAS_TCP_DEFAULT_PORT: int = int(502) +@dataclass +class UmasConstants: + UMAS_TCP_DEFAULT_PORT: int = int(502) def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasConstants") # Const Field (UmasTcpDefaultPort) - write_buffer.write_unsigned_short(self.UMAS_TCP_DEFAULT_PORT, logical_name="UmasTcpDefaultPort") + write_buffer.write_unsigned_short( + self.UMAS_TCP_DEFAULT_PORT, logical_name="UmasTcpDefaultPort" + ) write_buffer.pop_context("UmasConstants") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,26 +53,23 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return UmasConstants.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("UmasConstants") - - - UMAS_TCP_DEFAULT_PORT: int = read_buffer.read_unsigned_short(logical_name="umas_tcp_default_port") + UMAS_TCP_DEFAULT_PORT: int = read_buffer.read_unsigned_short( + logical_name="umas_tcp_default_port" + ) read_buffer.pop_context("UmasConstants") # Create the instance _umas_constants: UmasConstants = UmasConstants() return _umas_constants - def equals(self, o: object) -> bool: if self == o: return True @@ -88,14 +85,10 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasDataType.py b/plc4py/plc4py/protocols/umas/readwrite/UmasDataType.py index 1cc917000da..69fcc90f31c 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasDataType.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasDataType.py @@ -19,34 +19,32 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - -class UmasDataType(AutoNumberEnum): - _init_ = "value, request_size, data_type_size" - BOOL = (1 , int(1) , int(1) ) - UNKNOWN2 = (2 , int(1) , int(1) ) - UNKNOWN3 = (3 , int(1) , int(1) ) - INT = (4 , int(2) , int(2) ) - UINT = (5 , int(2) , int(2) ) - DINT = (6 , int(3) , int(4) ) - UDINT = (7 , int(3) , int(4) ) - REAL = (8 , int(3) , int(4) ) - STRING = (9 , int(17) , int(1) ) - TIME = (10 , int(3) , int(4) ) - UNKNOWN11 = (11 , int(1) , int(1) ) - UNKNOWN12 = (12 , int(1) , int(1) ) - UNKNOWN13 = (13 , int(1) , int(1) ) - DATE = (14 , int(3) , int(4) ) - TOD = (15 , int(3) , int(4) ) - DT = (16 , int(3) , int(4) ) - UNKNOWN17 = (17 , int(1) , int(1) ) - UNKNOWN18 = (18 , int(1) , int(1) ) - UNKNOWN19 = (19 , int(1) , int(1) ) - UNKNOWN20 = (20 , int(1) , int(1) ) - BYTE = (21 , int(1) , int(1) ) - WORD = (22 , int(2) , int(2) ) - DWORD = (23 , int(3) , int(4) ) - UNKNOWN24 = (24 , int(1) , int(1) ) - EBOOL = (25 , int(1) , int(1) ) - +class UmasDataType(AutoNumberEnum): + _init_ = "value, request_size, data_type_size" + BOOL = (1, int(1), int(1)) + UNKNOWN2 = (2, int(1), int(1)) + UNKNOWN3 = (3, int(1), int(1)) + INT = (4, int(2), int(2)) + UINT = (5, int(2), int(2)) + DINT = (6, int(3), int(4)) + UDINT = (7, int(3), int(4)) + REAL = (8, int(3), int(4)) + STRING = (9, int(17), int(1)) + TIME = (10, int(3), int(4)) + UNKNOWN11 = (11, int(1), int(1)) + UNKNOWN12 = (12, int(1), int(1)) + UNKNOWN13 = (13, int(1), int(1)) + DATE = (14, int(3), int(4)) + TOD = (15, int(3), int(4)) + DT = (16, int(3), int(4)) + UNKNOWN17 = (17, int(1), int(1)) + UNKNOWN18 = (18, int(1), int(1)) + UNKNOWN19 = (19, int(1), int(1)) + UNKNOWN20 = (20, int(1), int(1)) + BYTE = (21, int(1), int(1)) + WORD = (22, int(2), int(2)) + DWORD = (23, int(3), int(4)) + UNKNOWN24 = (24, int(1), int(1)) + EBOOL = (25, int(1), int(1)) diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasDatatypeReference.py b/plc4py/plc4py/protocols/umas/readwrite/UmasDatatypeReference.py index 1bffeafa2ab..088894eddd2 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasDatatypeReference.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasDatatypeReference.py @@ -26,9 +26,10 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass -class UmasDatatypeReference(): +class UmasDatatypeReference: data_size: int unknown1: int class_identifier: int @@ -36,31 +37,43 @@ class UmasDatatypeReference(): string_length: int value: str - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasDatatypeReference") # Simple Field (dataSize) - write_buffer.write_unsigned_short(self.data_size,bit_length=16,logical_name="dataSize") + write_buffer.write_unsigned_short( + self.data_size, bit_length=16, logical_name="dataSize" + ) # Simple Field (unknown1) - write_buffer.write_unsigned_short(self.unknown1,bit_length=16,logical_name="unknown1") + write_buffer.write_unsigned_short( + self.unknown1, bit_length=16, logical_name="unknown1" + ) # Simple Field (classIdentifier) - write_buffer.write_unsigned_byte(self.class_identifier,bit_length=8,logical_name="classIdentifier") + write_buffer.write_unsigned_byte( + self.class_identifier, bit_length=8, logical_name="classIdentifier" + ) # Simple Field (dataType) - write_buffer.write_unsigned_byte(self.data_type,bit_length=8,logical_name="dataType") + write_buffer.write_unsigned_byte( + self.data_type, bit_length=8, logical_name="dataType" + ) # Simple Field (stringLength) - write_buffer.write_unsigned_byte(self.string_length,bit_length=8,logical_name="stringLength") + write_buffer.write_unsigned_byte( + self.string_length, bit_length=8, logical_name="stringLength" + ) # Manual Field (value) - write_buffer.write_manual(write_function=lambda : StaticHelper.serialize_terminated_string(write_buffer, self.value, self.string_length), logical_name="value") + write_buffer.write_manual( + write_function=lambda: StaticHelper.serialize_terminated_string( + write_buffer, self.value, self.string_length + ), + logical_name="value", + ) write_buffer.pop_context("UmasDatatypeReference") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -84,50 +97,52 @@ def length_in_bits(self) -> int: length_in_bits += 8 # Manual Field (value) - length_in_bits += (self.string_length* int(8)) + length_in_bits += self.string_length * int(8) return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return UmasDatatypeReference.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("UmasDatatypeReference") + data_size: int = read_buffer.read_unsigned_short( + logical_name="data_size", bit_length=16 + ) + unknown1: int = read_buffer.read_unsigned_short( + logical_name="unknown1", bit_length=16 + ) - data_size: int = read_buffer.read_unsigned_short(logical_name="data_size", bit_length=16) - - - - unknown1: int = read_buffer.read_unsigned_short(logical_name="unknown1", bit_length=16) - - + class_identifier: int = read_buffer.read_unsigned_byte( + logical_name="class_identifier", bit_length=8 + ) - class_identifier: int = read_buffer.read_unsigned_byte(logical_name="class_identifier", bit_length=8) + data_type: int = read_buffer.read_unsigned_byte( + logical_name="data_type", bit_length=8 + ) + string_length: int = read_buffer.read_unsigned_byte( + logical_name="string_length", bit_length=8 + ) - - data_type: int = read_buffer.read_unsigned_byte(logical_name="data_type", bit_length=8) - - - - string_length: int = read_buffer.read_unsigned_byte(logical_name="string_length", bit_length=8) - - - - value = read_buffer.read_manual(read_function=lambda : StaticHelper.parse_terminated_string(read_buffer, string_length), logical_name="value") + value = read_buffer.read_manual( + read_function=lambda: StaticHelper.parse_terminated_string( + read_buffer, string_length + ), + logical_name="value", + ) read_buffer.pop_context("UmasDatatypeReference") # Create the instance - _umas_datatype_reference: UmasDatatypeReference = UmasDatatypeReference(data_size, unknown1, class_identifier, data_type, string_length, value ) + _umas_datatype_reference: UmasDatatypeReference = UmasDatatypeReference( + data_size, unknown1, class_identifier, data_type, string_length, value + ) return _umas_datatype_reference - def equals(self, o: object) -> bool: if self == o: return True @@ -136,21 +151,25 @@ def equals(self, o: object) -> bool: return False that: UmasDatatypeReference = UmasDatatypeReference(o) - return (self.data_size == that.data_size) and (self.unknown1 == that.unknown1) and (self.class_identifier == that.class_identifier) and (self.data_type == that.data_type) and (self.string_length == that.string_length) and (self.value == that.value) and True + return ( + (self.data_size == that.data_size) + and (self.unknown1 == that.unknown1) + and (self.class_identifier == that.class_identifier) + and (self.data_type == that.data_type) + and (self.string_length == that.string_length) + and (self.value == that.value) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationConformityLevel.py b/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationConformityLevel.py index 59cd6def09b..9f6c0da0954 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationConformityLevel.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationConformityLevel.py @@ -19,12 +19,10 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - + + class UmasDeviceInformationConformityLevel(AutoNumberEnum): - + BASIC_STREAM_ONLY: int = 0x01 REGULAR_STREAM_ONLY: int = 0x02 EXTENDED_STREAM_ONLY: int = 0x03 - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationLevel.py b/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationLevel.py index 1f1eeb0fd04..500170e4826 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationLevel.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationLevel.py @@ -19,13 +19,11 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - + + class UmasDeviceInformationLevel(AutoNumberEnum): - + BASIC: int = 0x01 REGULAR: int = 0x02 EXTENDED: int = 0x03 INDIVIDUAL: int = 0x04 - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationMoreFollows.py b/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationMoreFollows.py index 2aa0ae7d09a..29304360a03 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationMoreFollows.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasDeviceInformationMoreFollows.py @@ -19,11 +19,9 @@ # Code generated by code-generation. DO NOT EDIT. from aenum import AutoNumberEnum - -class UmasDeviceInformationMoreFollows(AutoNumberEnum): - - NO_MORE_OBJECTS_AVAILABLE: int = 0x00 - MORE_OBJECTS_AVAILABLE: int = 0xFF +class UmasDeviceInformationMoreFollows(AutoNumberEnum): + NO_MORE_OBJECTS_AVAILABLE: int = 0x00 + MORE_OBJECTS_AVAILABLE: int = 0xFF diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsRequest.py index d1b50ee6a30..68a8b212ff5 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsRequest.py @@ -28,7 +28,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class UmasInitCommsRequest(UmasPDUItem): unknown_object: int @@ -38,17 +39,16 @@ class UmasInitCommsRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x01 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasInitCommsRequest") # Simple Field (unknownObject) - write_buffer.write_unsigned_byte(self.unknown_object,bit_length=8,logical_name="unknownObject") + write_buffer.write_unsigned_byte( + self.unknown_object, bit_length=8, logical_name="unknownObject" + ) write_buffer.pop_context("UmasInitCommsRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -61,9 +61,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasInitCommsRequest") if isinstance(umas_request_function_key, str): @@ -71,15 +72,17 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - unknown_object: int = read_buffer.read_unsigned_byte(logical_name="unknown_object", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - + unknown_object: int = read_buffer.read_unsigned_byte( + logical_name="unknown_object", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasInitCommsRequest") # Create the instance - return UmasInitCommsRequestBuilder(unknown_object ) - + return UmasInitCommsRequestBuilder(unknown_object) def equals(self, o: object) -> bool: if self == o: @@ -89,29 +92,32 @@ def equals(self, o: object) -> bool: return False that: UmasInitCommsRequest = UmasInitCommsRequest(o) - return (self.unknown_object == that.unknown_object) and super().equals(that) and True + return ( + (self.unknown_object == that.unknown_object) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasInitCommsRequestBuilder: unknown_object: int - def build(self,byte_length: int , pairing_key ) -> UmasInitCommsRequest: - umas_init_comms_request: UmasInitCommsRequest = UmasInitCommsRequest(byte_length , pairing_key , self.unknown_object ) + def build(self, byte_length: int, pairing_key) -> UmasInitCommsRequest: + umas_init_comms_request: UmasInitCommsRequest = UmasInitCommsRequest( + byte_length, pairing_key, self.unknown_object + ) return umas_init_comms_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsResponse.py index dfbde4a8d6b..45de329de1a 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasInitCommsResponse.py @@ -28,7 +28,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class UmasInitCommsResponse(UmasPDUItem): max_frame_size: int @@ -43,32 +44,39 @@ class UmasInitCommsResponse(UmasPDUItem): umas_function_key: ClassVar[int] = 0xFE umas_request_function_key: ClassVar[int] = 0x01 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasInitCommsResponse") # Simple Field (maxFrameSize) - write_buffer.write_unsigned_short(self.max_frame_size,bit_length=16,logical_name="maxFrameSize") + write_buffer.write_unsigned_short( + self.max_frame_size, bit_length=16, logical_name="maxFrameSize" + ) # Simple Field (firmwareVersion) - write_buffer.write_unsigned_short(self.firmware_version,bit_length=16,logical_name="firmwareVersion") + write_buffer.write_unsigned_short( + self.firmware_version, bit_length=16, logical_name="firmwareVersion" + ) # Simple Field (notSure) - write_buffer.write_unsigned_int(self.not_sure,bit_length=32,logical_name="notSure") + write_buffer.write_unsigned_int( + self.not_sure, bit_length=32, logical_name="notSure" + ) # Simple Field (internalCode) - write_buffer.write_unsigned_int(self.internal_code,bit_length=32,logical_name="internalCode") + write_buffer.write_unsigned_int( + self.internal_code, bit_length=32, logical_name="internalCode" + ) # Simple Field (hostnameLength) - write_buffer.write_unsigned_byte(self.hostname_length,bit_length=8,logical_name="hostnameLength") + write_buffer.write_unsigned_byte( + self.hostname_length, bit_length=8, logical_name="hostnameLength" + ) # Simple Field (hostname) - write_buffer.write_str(self.hostname,bit_length=-1,logical_name="hostname") + write_buffer.write_str(self.hostname, bit_length=-1, logical_name="hostname") write_buffer.pop_context("UmasInitCommsResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -92,13 +100,14 @@ def length_in_bits(self) -> int: length_in_bits += 8 # Simple field (hostname) - length_in_bits += self.hostname_length* int(8) + length_in_bits += self.hostname_length * int(8) return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasInitCommsResponse") if isinstance(umas_request_function_key, str): @@ -106,35 +115,64 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - max_frame_size: int = read_buffer.read_unsigned_short(logical_name="max_frame_size", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - firmware_version: int = read_buffer.read_unsigned_short(logical_name="firmware_version", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - not_sure: int = read_buffer.read_unsigned_int(logical_name="not_sure", bit_length=32, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - internal_code: int = read_buffer.read_unsigned_int(logical_name="internal_code", bit_length=32, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - hostname_length: int = read_buffer.read_unsigned_byte(logical_name="hostname_length", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - hostname: str = read_buffer.read_str(logical_name="hostname", bit_length=hostname_length* int(8), byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - + max_frame_size: int = read_buffer.read_unsigned_short( + logical_name="max_frame_size", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + firmware_version: int = read_buffer.read_unsigned_short( + logical_name="firmware_version", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + not_sure: int = read_buffer.read_unsigned_int( + logical_name="not_sure", + bit_length=32, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + internal_code: int = read_buffer.read_unsigned_int( + logical_name="internal_code", + bit_length=32, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + hostname_length: int = read_buffer.read_unsigned_byte( + logical_name="hostname_length", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + hostname: str = read_buffer.read_str( + logical_name="hostname", + bit_length=hostname_length * int(8), + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasInitCommsResponse") # Create the instance - return UmasInitCommsResponseBuilder(max_frame_size, firmware_version, not_sure, internal_code, hostname_length, hostname ) - + return UmasInitCommsResponseBuilder( + max_frame_size, + firmware_version, + not_sure, + internal_code, + hostname_length, + hostname, + ) def equals(self, o: object) -> bool: if self == o: @@ -144,20 +182,29 @@ def equals(self, o: object) -> bool: return False that: UmasInitCommsResponse = UmasInitCommsResponse(o) - return (self.max_frame_size == that.max_frame_size) and (self.firmware_version == that.firmware_version) and (self.not_sure == that.not_sure) and (self.internal_code == that.internal_code) and (self.hostname_length == that.hostname_length) and (self.hostname == that.hostname) and super().equals(that) and True + return ( + (self.max_frame_size == that.max_frame_size) + and (self.firmware_version == that.firmware_version) + and (self.not_sure == that.not_sure) + and (self.internal_code == that.internal_code) + and (self.hostname_length == that.hostname_length) + and (self.hostname == that.hostname) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -169,9 +216,15 @@ class UmasInitCommsResponseBuilder: hostname_length: int hostname: str - def build(self,byte_length: int , pairing_key ) -> UmasInitCommsResponse: - umas_init_comms_response: UmasInitCommsResponse = UmasInitCommsResponse(byte_length , pairing_key , self.max_frame_size, self.firmware_version, self.not_sure, self.internal_code, self.hostname_length, self.hostname ) + def build(self, byte_length: int, pairing_key) -> UmasInitCommsResponse: + umas_init_comms_response: UmasInitCommsResponse = UmasInitCommsResponse( + byte_length, + pairing_key, + self.max_frame_size, + self.firmware_version, + self.not_sure, + self.internal_code, + self.hostname_length, + self.hostname, + ) return umas_init_comms_response - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlock.py b/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlock.py index f99612be83b..194c8b24a4c 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlock.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlock.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass class UmasMemoryBlock(ABC, PlcMessage): @@ -36,11 +37,11 @@ class UmasMemoryBlock(ABC, PlcMessage): @property def block_number(self) -> int: pass + @property def offset(self) -> int: pass - @abstractmethod def serialize_umas_memory_block_child(self, write_buffer: WriteBuffer) -> None: pass @@ -53,7 +54,6 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.pop_context("UmasMemoryBlock") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -65,12 +65,13 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): if kwargs is None: - raise PlcRuntimeException("Wrong number of arguments, expected 2, but got None") + raise PlcRuntimeException( + "Wrong number of arguments, expected 2, but got None" + ) block_number: int = 0 if isinstance(kwargs.get("block_number"), int): @@ -78,7 +79,10 @@ def static_parse(read_buffer: ReadBuffer, **kwargs): elif isinstance(kwargs.get("block_number"), str): block_number = int(str(kwargs.get("block_number"))) else: - raise PlcRuntimeException("Argument 0 expected to be of type int or a string which is parseable but was " + kwargs.get("block_number").getClass().getName()) + raise PlcRuntimeException( + "Argument 0 expected to be of type int or a string which is parseable but was " + + kwargs.get("block_number").getClass().getName() + ) offset: int = 0 if isinstance(kwargs.get("offset"), int): @@ -86,11 +90,13 @@ def static_parse(read_buffer: ReadBuffer, **kwargs): elif isinstance(kwargs.get("offset"), str): offset = int(str(kwargs.get("offset"))) else: - raise PlcRuntimeException("Argument 1 expected to be of type int or a string which is parseable but was " + kwargs.get("offset").getClass().getName()) + raise PlcRuntimeException( + "Argument 1 expected to be of type int or a string which is parseable but was " + + kwargs.get("offset").getClass().getName() + ) return UmasMemoryBlock.static_parse_context(read_buffer, block_number, offset) - @staticmethod def static_parse_context(read_buffer: ReadBuffer, block_number: int, offset: int): read_buffer.push_context("UmasMemoryBlock") @@ -100,23 +106,34 @@ def static_parse_context(read_buffer: ReadBuffer, block_number: int, offset: int if isinstance(offset, str): offset = int(offset) - # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type) builder: UmasMemoryBlockBuilder = None - from plc4py.protocols.umas.readwrite.UmasMemoryBlockBasicInfo import UmasMemoryBlockBasicInfo - if block_number == int(0x30) and offset == int(0x00) : + from plc4py.protocols.umas.readwrite.UmasMemoryBlockBasicInfo import ( + UmasMemoryBlockBasicInfo, + ) - builder = UmasMemoryBlockBasicInfo.static_parse_builder(read_buffer, block_number, offset) - if builder is None: - raise ParseException("Unsupported case for discriminated type"+" parameters ["+"blockNumber="+str(block_number)+" "+"offset="+str(offset)+"]") + if block_number == int(0x30) and offset == int(0x00): + builder = UmasMemoryBlockBasicInfo.static_parse_builder( + read_buffer, block_number, offset + ) + if builder is None: + raise ParseException( + "Unsupported case for discriminated type" + + " parameters [" + + "blockNumber=" + + str(block_number) + + " " + + "offset=" + + str(offset) + + "]" + ) read_buffer.pop_context("UmasMemoryBlock") # Create the instance _umas_memory_block: UmasMemoryBlock = builder.build() return _umas_memory_block - def equals(self, o: object) -> bool: if self == o: return True @@ -132,19 +149,18 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" + @dataclass class UmasMemoryBlockBuilder: - def build(self, ) -> UmasMemoryBlock: + def build( + self, + ) -> UmasMemoryBlock: pass - - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlockBasicInfo.py b/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlockBasicInfo.py index 42a00433091..6fd5ef975c0 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlockBasicInfo.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasMemoryBlockBasicInfo.py @@ -27,7 +27,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class UmasMemoryBlockBasicInfo(UmasMemoryBlock): range: int @@ -38,26 +39,29 @@ class UmasMemoryBlockBasicInfo(UmasMemoryBlock): block_number: ClassVar[int] = 0x30 offset: ClassVar[int] = 0x00 - - def serialize_umas_memory_block_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasMemoryBlockBasicInfo") # Simple Field (range) - write_buffer.write_unsigned_short(self.range,bit_length=16,logical_name="range") + write_buffer.write_unsigned_short( + self.range, bit_length=16, logical_name="range" + ) # Simple Field (notSure) - write_buffer.write_unsigned_short(self.not_sure,bit_length=16,logical_name="notSure") + write_buffer.write_unsigned_short( + self.not_sure, bit_length=16, logical_name="notSure" + ) # Simple Field (index) - write_buffer.write_unsigned_byte(self.index,bit_length=8,logical_name="index") + write_buffer.write_unsigned_byte(self.index, bit_length=8, logical_name="index") # Simple Field (hardwareId) - write_buffer.write_unsigned_int(self.hardware_id,bit_length=32,logical_name="hardwareId") + write_buffer.write_unsigned_int( + self.hardware_id, bit_length=32, logical_name="hardwareId" + ) write_buffer.pop_context("UmasMemoryBlockBasicInfo") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -79,7 +83,6 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse_builder(read_buffer: ReadBuffer, block_number: int, offset: int): read_buffer.push_context("UmasMemoryBlockBasicInfo") @@ -89,27 +92,34 @@ def static_parse_builder(read_buffer: ReadBuffer, block_number: int, offset: int if isinstance(offset, str): offset = int(offset) - - range: int = read_buffer.read_unsigned_short(logical_name="range", bit_length=16, block_number=block_number, offset=offset) - - - - not_sure: int = read_buffer.read_unsigned_short(logical_name="not_sure", bit_length=16, block_number=block_number, offset=offset) - - - - index: int = read_buffer.read_unsigned_byte(logical_name="index", bit_length=8, block_number=block_number, offset=offset) - - - - hardware_id: int = read_buffer.read_unsigned_int(logical_name="hardware_id", bit_length=32, block_number=block_number, offset=offset) - - + range: int = read_buffer.read_unsigned_short( + logical_name="range", + bit_length=16, + block_number=block_number, + offset=offset, + ) + + not_sure: int = read_buffer.read_unsigned_short( + logical_name="not_sure", + bit_length=16, + block_number=block_number, + offset=offset, + ) + + index: int = read_buffer.read_unsigned_byte( + logical_name="index", bit_length=8, block_number=block_number, offset=offset + ) + + hardware_id: int = read_buffer.read_unsigned_int( + logical_name="hardware_id", + bit_length=32, + block_number=block_number, + offset=offset, + ) read_buffer.pop_context("UmasMemoryBlockBasicInfo") # Create the instance - return UmasMemoryBlockBasicInfoBuilder(range, not_sure, index, hardware_id ) - + return UmasMemoryBlockBasicInfoBuilder(range, not_sure, index, hardware_id) def equals(self, o: object) -> bool: if self == o: @@ -119,20 +129,27 @@ def equals(self, o: object) -> bool: return False that: UmasMemoryBlockBasicInfo = UmasMemoryBlockBasicInfo(o) - return (self.range == that.range) and (self.not_sure == that.not_sure) and (self.index == that.index) and (self.hardware_id == that.hardware_id) and super().equals(that) and True + return ( + (self.range == that.range) + and (self.not_sure == that.not_sure) + and (self.index == that.index) + and (self.hardware_id == that.hardware_id) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -142,9 +159,12 @@ class UmasMemoryBlockBasicInfoBuilder: index: int hardware_id: int - def build(self,) -> UmasMemoryBlockBasicInfo: - umas_memory_block_basic_info: UmasMemoryBlockBasicInfo = UmasMemoryBlockBasicInfo(self.range, self.not_sure, self.index, self.hardware_id ) + def build( + self, + ) -> UmasMemoryBlockBasicInfo: + umas_memory_block_basic_info: UmasMemoryBlockBasicInfo = ( + UmasMemoryBlockBasicInfo( + self.range, self.not_sure, self.index, self.hardware_id + ) + ) return umas_memory_block_basic_info - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDU.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDU.py index 49690a23b56..94efa46d378 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDU.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDU.py @@ -28,7 +28,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class UmasPDU(ModbusPDU): item: UmasPDUItem @@ -37,19 +38,16 @@ class UmasPDU(ModbusPDU): byte_length: int # Accessors for discriminator values. error_flag: ClassVar[bool] = False - function_flag: ClassVar[int] = 0x5a - - + function_flag: ClassVar[int] = 0x5A def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDU") # Simple Field (item) - write_buffer.write_serializable(self.item,logical_name="item") + write_buffer.write_serializable(self.item, logical_name="item") write_buffer.pop_context("UmasPDU") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -62,9 +60,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDU") if isinstance(umas_request_function_key, str): @@ -72,15 +71,16 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - item: UmasPDUItem = read_buffer.read_complex(read_function=UmasPDUItem.static_parse, logical_name="item", umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - + item: UmasPDUItem = read_buffer.read_complex( + read_function=UmasPDUItem.static_parse, + logical_name="item", + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDU") # Create the instance - return UmasPDUBuilder(item ) - + return UmasPDUBuilder(item) def equals(self, o: object) -> bool: if self == o: @@ -97,22 +97,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasPDUBuilder: item: UmasPDUItem - def build(self,umas_request_function_key: int, byte_length: int , ) -> UmasPDU: - umas_pdu: UmasPDU = UmasPDU(umas_request_function_key, byte_length , self.item ) + def build( + self, + umas_request_function_key: int, + byte_length: int, + ) -> UmasPDU: + umas_pdu: UmasPDU = UmasPDU(umas_request_function_key, byte_length, self.item) return umas_pdu - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUItem.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUItem.py index de289c70036..d5963a04ff6 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUItem.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUItem.py @@ -29,7 +29,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.utils.GenericTypes import ByteOrder import math - + + @dataclass class UmasPDUItem(ABC, PlcMessage): pairing_key: int @@ -40,11 +41,11 @@ class UmasPDUItem(ABC, PlcMessage): @property def umas_function_key(self) -> int: pass + @property def umas_request_function_key(self) -> int: pass - @abstractmethod def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer) -> None: pass @@ -53,17 +54,23 @@ def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUItem") # Simple Field (pairingKey) - write_buffer.write_unsigned_byte(self.pairing_key,bit_length=8,logical_name="pairingKey") + write_buffer.write_unsigned_byte( + self.pairing_key, bit_length=8, logical_name="pairingKey" + ) # Discriminator Field (umasFunctionKey) (Used as input to a switch field) - write_buffer.write_unsigned_byte(self.umas_function_key, logical_name="umas_function_key", bit_length=8 , byte_order=ByteOrder.LITTLE_ENDIAN) + write_buffer.write_unsigned_byte( + self.umas_function_key, + logical_name="umas_function_key", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + ) # Switch field (Serialize the sub-type) self.serialize_umas_pduitem_child(write_buffer) write_buffer.pop_context("UmasPDUItem") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -81,20 +88,26 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): if kwargs is None: - raise PlcRuntimeException("Wrong number of arguments, expected 2, but got None") + raise PlcRuntimeException( + "Wrong number of arguments, expected 2, but got None" + ) umas_request_function_key: int = 0 if isinstance(kwargs.get("umas_request_function_key"), int): umas_request_function_key = int(kwargs.get("umas_request_function_key")) elif isinstance(kwargs.get("umas_request_function_key"), str): - umas_request_function_key = int(str(kwargs.get("umas_request_function_key"))) + umas_request_function_key = int( + str(kwargs.get("umas_request_function_key")) + ) else: - raise PlcRuntimeException("Argument 0 expected to be of type int or a string which is parseable but was " + kwargs.get("umas_request_function_key").getClass().getName()) + raise PlcRuntimeException( + "Argument 0 expected to be of type int or a string which is parseable but was " + + kwargs.get("umas_request_function_key").getClass().getName() + ) byte_length: int = 0 if isinstance(kwargs.get("byte_length"), int): @@ -102,13 +115,19 @@ def static_parse(read_buffer: ReadBuffer, **kwargs): elif isinstance(kwargs.get("byte_length"), str): byte_length = int(str(kwargs.get("byte_length"))) else: - raise PlcRuntimeException("Argument 1 expected to be of type int or a string which is parseable but was " + kwargs.get("byte_length").getClass().getName()) - - return UmasPDUItem.static_parse_context(read_buffer, umas_request_function_key, byte_length) + raise PlcRuntimeException( + "Argument 1 expected to be of type int or a string which is parseable but was " + + kwargs.get("byte_length").getClass().getName() + ) + return UmasPDUItem.static_parse_context( + read_buffer, umas_request_function_key, byte_length + ) @staticmethod - def static_parse_context(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_context( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUItem") if isinstance(umas_request_function_key, str): @@ -116,86 +135,176 @@ def static_parse_context(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - pairing_key: int = read_buffer.read_unsigned_byte(logical_name="pairing_key", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - umas_function_key: int = read_buffer.read_unsigned_byte(logical_name="umas_function_key", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - + pairing_key: int = read_buffer.read_unsigned_byte( + logical_name="pairing_key", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + umas_function_key: int = read_buffer.read_unsigned_byte( + logical_name="umas_function_key", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type) builder: UmasPDUItemBuilder = None - from plc4py.protocols.umas.readwrite.UmasInitCommsRequest import UmasInitCommsRequest - if umas_function_key == int(0x01) : - - builder = UmasInitCommsRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUPlcIdentRequest import UmasPDUPlcIdentRequest - if umas_function_key == int(0x02) : - - builder = UmasPDUPlcIdentRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUProjectInfoRequest import UmasPDUProjectInfoRequest - if umas_function_key == int(0x03) : - - builder = UmasPDUProjectInfoRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUPlcStatusRequest import UmasPDUPlcStatusRequest - if umas_function_key == int(0x04) : - - builder = UmasPDUPlcStatusRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUReadMemoryBlockRequest import UmasPDUReadMemoryBlockRequest - if umas_function_key == int(0x20) : - - builder = UmasPDUReadMemoryBlockRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUReadVariableRequest import UmasPDUReadVariableRequest - if umas_function_key == int(0x22) : - - builder = UmasPDUReadVariableRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUWriteVariableRequest import UmasPDUWriteVariableRequest - if umas_function_key == int(0x23) : - - builder = UmasPDUWriteVariableRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUReadUnlocatedVariableNamesRequest import UmasPDUReadUnlocatedVariableNamesRequest - if umas_function_key == int(0x26) : - - builder = UmasPDUReadUnlocatedVariableNamesRequest.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasInitCommsResponse import UmasInitCommsResponse - if umas_function_key == int(0xFE) and umas_request_function_key == int(0x01) : - - builder = UmasInitCommsResponse.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUPlcIdentResponse import UmasPDUPlcIdentResponse - if umas_function_key == int(0xFE) and umas_request_function_key == int(0x02) : - - builder = UmasPDUPlcIdentResponse.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUPlcStatusResponse import UmasPDUPlcStatusResponse - if umas_function_key == int(0xFE) and umas_request_function_key == int(0x04) : - - builder = UmasPDUPlcStatusResponse.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUReadMemoryBlockResponse import UmasPDUReadMemoryBlockResponse - if umas_function_key == int(0xFE) and umas_request_function_key == int(0x20) : - - builder = UmasPDUReadMemoryBlockResponse.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUReadVariableResponse import UmasPDUReadVariableResponse - if umas_function_key == int(0xFE) and umas_request_function_key == int(0x22) : - - builder = UmasPDUReadVariableResponse.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUWriteVariableResponse import UmasPDUWriteVariableResponse - if umas_function_key == int(0xFE) and umas_request_function_key == int(0x23) : - - builder = UmasPDUWriteVariableResponse.static_parse_builder(read_buffer, umas_request_function_key, byte_length) - from plc4py.protocols.umas.readwrite.UmasPDUReadUnlocatedVariableResponse import UmasPDUReadUnlocatedVariableResponse - if umas_function_key == int(0xFE) and umas_request_function_key == int(0x26) : - - builder = UmasPDUReadUnlocatedVariableResponse.static_parse_builder(read_buffer, umas_request_function_key, byte_length) + from plc4py.protocols.umas.readwrite.UmasInitCommsRequest import ( + UmasInitCommsRequest, + ) + + if umas_function_key == int(0x01): + + builder = UmasInitCommsRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUPlcIdentRequest import ( + UmasPDUPlcIdentRequest, + ) + + if umas_function_key == int(0x02): + + builder = UmasPDUPlcIdentRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUProjectInfoRequest import ( + UmasPDUProjectInfoRequest, + ) + + if umas_function_key == int(0x03): + + builder = UmasPDUProjectInfoRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUPlcStatusRequest import ( + UmasPDUPlcStatusRequest, + ) + + if umas_function_key == int(0x04): + + builder = UmasPDUPlcStatusRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUReadMemoryBlockRequest import ( + UmasPDUReadMemoryBlockRequest, + ) + + if umas_function_key == int(0x20): + + builder = UmasPDUReadMemoryBlockRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUReadVariableRequest import ( + UmasPDUReadVariableRequest, + ) + + if umas_function_key == int(0x22): + + builder = UmasPDUReadVariableRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUWriteVariableRequest import ( + UmasPDUWriteVariableRequest, + ) + + if umas_function_key == int(0x23): + + builder = UmasPDUWriteVariableRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUReadUnlocatedVariableNamesRequest import ( + UmasPDUReadUnlocatedVariableNamesRequest, + ) + + if umas_function_key == int(0x26): + + builder = UmasPDUReadUnlocatedVariableNamesRequest.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasInitCommsResponse import ( + UmasInitCommsResponse, + ) + + if umas_function_key == int(0xFE) and umas_request_function_key == int(0x01): + + builder = UmasInitCommsResponse.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUPlcIdentResponse import ( + UmasPDUPlcIdentResponse, + ) + + if umas_function_key == int(0xFE) and umas_request_function_key == int(0x02): + + builder = UmasPDUPlcIdentResponse.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUPlcStatusResponse import ( + UmasPDUPlcStatusResponse, + ) + + if umas_function_key == int(0xFE) and umas_request_function_key == int(0x04): + + builder = UmasPDUPlcStatusResponse.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUReadMemoryBlockResponse import ( + UmasPDUReadMemoryBlockResponse, + ) + + if umas_function_key == int(0xFE) and umas_request_function_key == int(0x20): + + builder = UmasPDUReadMemoryBlockResponse.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUReadVariableResponse import ( + UmasPDUReadVariableResponse, + ) + + if umas_function_key == int(0xFE) and umas_request_function_key == int(0x22): + + builder = UmasPDUReadVariableResponse.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUWriteVariableResponse import ( + UmasPDUWriteVariableResponse, + ) + + if umas_function_key == int(0xFE) and umas_request_function_key == int(0x23): + + builder = UmasPDUWriteVariableResponse.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) + from plc4py.protocols.umas.readwrite.UmasPDUReadUnlocatedVariableResponse import ( + UmasPDUReadUnlocatedVariableResponse, + ) + + if umas_function_key == int(0xFE) and umas_request_function_key == int(0x26): + + builder = UmasPDUReadUnlocatedVariableResponse.static_parse_builder( + read_buffer, umas_request_function_key, byte_length + ) if builder is None: - raise ParseException("Unsupported case for discriminated type"+" parameters ["+"umasFunctionKey="+str(umas_function_key)+" "+"umasRequestFunctionKey="+str(umas_request_function_key)+"]") - + raise ParseException( + "Unsupported case for discriminated type" + + " parameters [" + + "umasFunctionKey=" + + str(umas_function_key) + + " " + + "umasRequestFunctionKey=" + + str(umas_request_function_key) + + "]" + ) read_buffer.pop_context("UmasPDUItem") # Create the instance - _umas_pduitem: UmasPDUItem = builder.build(pairing_key , byte_length ) + _umas_pduitem: UmasPDUItem = builder.build(pairing_key, byte_length) return _umas_pduitem - def equals(self, o: object) -> bool: if self == o: return True @@ -211,20 +320,18 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" + @dataclass class UmasPDUItemBuilder: pairing_key: int - def build(self, byte_length: int ) -> UmasPDUItem: - pass - - - + def build(self, byte_length: int) -> UmasPDUItem: + pass diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentRequest.py index af81825eb6b..cd9b720f98b 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentRequest.py @@ -27,7 +27,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class UmasPDUPlcIdentRequest(UmasPDUItem): # Arguments. @@ -36,14 +37,11 @@ class UmasPDUPlcIdentRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x02 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUPlcIdentRequest") write_buffer.pop_context("UmasPDUPlcIdentRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,9 +51,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUPlcIdentRequest") if isinstance(umas_request_function_key, str): @@ -63,12 +62,10 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - read_buffer.pop_context("UmasPDUPlcIdentRequest") # Create the instance return UmasPDUPlcIdentRequestBuilder() - def equals(self, o: object) -> bool: if self == o: return True @@ -84,21 +81,21 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasPDUPlcIdentRequestBuilder: - def build(self,byte_length: int , pairing_key ) -> UmasPDUPlcIdentRequest: - umas_pduplc_ident_request: UmasPDUPlcIdentRequest = UmasPDUPlcIdentRequest(byte_length , pairing_key , ) + def build(self, byte_length: int, pairing_key) -> UmasPDUPlcIdentRequest: + umas_pduplc_ident_request: UmasPDUPlcIdentRequest = UmasPDUPlcIdentRequest( + byte_length, + pairing_key, + ) return umas_pduplc_ident_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentResponse.py index 8a42a979b43..89fe46ff02b 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcIdentResponse.py @@ -31,7 +31,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUPlcIdentResponse(UmasPDUItem): range: int @@ -53,53 +54,74 @@ class UmasPDUPlcIdentResponse(UmasPDUItem): umas_function_key: ClassVar[int] = 0xFE umas_request_function_key: ClassVar[int] = 0x02 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUPlcIdentResponse") # Simple Field (range) - write_buffer.write_unsigned_short(self.range,bit_length=16,logical_name="range") + write_buffer.write_unsigned_short( + self.range, bit_length=16, logical_name="range" + ) # Simple Field (ident) - write_buffer.write_unsigned_int(self.ident,bit_length=32,logical_name="ident") + write_buffer.write_unsigned_int(self.ident, bit_length=32, logical_name="ident") # Simple Field (model) - write_buffer.write_unsigned_short(self.model,bit_length=16,logical_name="model") + write_buffer.write_unsigned_short( + self.model, bit_length=16, logical_name="model" + ) # Simple Field (comVersion) - write_buffer.write_unsigned_short(self.com_version,bit_length=16,logical_name="comVersion") + write_buffer.write_unsigned_short( + self.com_version, bit_length=16, logical_name="comVersion" + ) # Simple Field (comPatch) - write_buffer.write_unsigned_short(self.com_patch,bit_length=16,logical_name="comPatch") + write_buffer.write_unsigned_short( + self.com_patch, bit_length=16, logical_name="comPatch" + ) # Simple Field (intVersion) - write_buffer.write_unsigned_short(self.int_version,bit_length=16,logical_name="intVersion") + write_buffer.write_unsigned_short( + self.int_version, bit_length=16, logical_name="intVersion" + ) # Simple Field (hardwareVersion) - write_buffer.write_unsigned_short(self.hardware_version,bit_length=16,logical_name="hardwareVersion") + write_buffer.write_unsigned_short( + self.hardware_version, bit_length=16, logical_name="hardwareVersion" + ) # Simple Field (crashCode) - write_buffer.write_unsigned_int(self.crash_code,bit_length=32,logical_name="crashCode") + write_buffer.write_unsigned_int( + self.crash_code, bit_length=32, logical_name="crashCode" + ) # Simple Field (unknown1) - write_buffer.write_unsigned_short(self.unknown1,bit_length=16,logical_name="unknown1") + write_buffer.write_unsigned_short( + self.unknown1, bit_length=16, logical_name="unknown1" + ) # Simple Field (hostnameLength) - write_buffer.write_unsigned_byte(self.hostname_length,bit_length=8,logical_name="hostnameLength") + write_buffer.write_unsigned_byte( + self.hostname_length, bit_length=8, logical_name="hostnameLength" + ) # Simple Field (hostname) - write_buffer.write_str(self.hostname,bit_length=-1,logical_name="hostname") + write_buffer.write_str(self.hostname, bit_length=-1, logical_name="hostname") # Simple Field (numberOfMemoryBanks) - write_buffer.write_unsigned_byte(self.number_of_memory_banks,bit_length=8,logical_name="numberOfMemoryBanks") + write_buffer.write_unsigned_byte( + self.number_of_memory_banks, + bit_length=8, + logical_name="numberOfMemoryBanks", + ) # Array Field (memoryIdents) - write_buffer.write_complex_array(self.memory_idents, logical_name="memory_idents") + write_buffer.write_complex_array( + self.memory_idents, logical_name="memory_idents" + ) write_buffer.pop_context("UmasPDUPlcIdentResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -138,7 +160,7 @@ def length_in_bits(self) -> int: length_in_bits += 8 # Simple field (hostname) - length_in_bits += self.hostname_length* int(8) + length_in_bits += self.hostname_length * int(8) # Simple field (numberOfMemoryBanks) length_in_bits += 8 @@ -148,13 +170,12 @@ def length_in_bits(self) -> int: for element in self.memory_idents: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUPlcIdentResponse") if isinstance(umas_request_function_key, str): @@ -162,61 +183,128 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - range: int = read_buffer.read_unsigned_short(logical_name="range", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - ident: int = read_buffer.read_unsigned_int(logical_name="ident", bit_length=32, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - model: int = read_buffer.read_unsigned_short(logical_name="model", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - com_version: int = read_buffer.read_unsigned_short(logical_name="com_version", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - com_patch: int = read_buffer.read_unsigned_short(logical_name="com_patch", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - int_version: int = read_buffer.read_unsigned_short(logical_name="int_version", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - hardware_version: int = read_buffer.read_unsigned_short(logical_name="hardware_version", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - crash_code: int = read_buffer.read_unsigned_int(logical_name="crash_code", bit_length=32, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - unknown1: int = read_buffer.read_unsigned_short(logical_name="unknown1", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - hostname_length: int = read_buffer.read_unsigned_byte(logical_name="hostname_length", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - hostname: str = read_buffer.read_str(logical_name="hostname", bit_length=hostname_length* int(8), byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - number_of_memory_banks: int = read_buffer.read_unsigned_byte(logical_name="number_of_memory_banks", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - memory_idents: List[Any] = read_buffer.read_array_field(logical_name="memoryIdents", read_function=PlcMemoryBlockIdent.static_parse, count=number_of_memory_banks, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + range: int = read_buffer.read_unsigned_short( + logical_name="range", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + ident: int = read_buffer.read_unsigned_int( + logical_name="ident", + bit_length=32, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + model: int = read_buffer.read_unsigned_short( + logical_name="model", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + com_version: int = read_buffer.read_unsigned_short( + logical_name="com_version", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + com_patch: int = read_buffer.read_unsigned_short( + logical_name="com_patch", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + int_version: int = read_buffer.read_unsigned_short( + logical_name="int_version", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + hardware_version: int = read_buffer.read_unsigned_short( + logical_name="hardware_version", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + crash_code: int = read_buffer.read_unsigned_int( + logical_name="crash_code", + bit_length=32, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + unknown1: int = read_buffer.read_unsigned_short( + logical_name="unknown1", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + hostname_length: int = read_buffer.read_unsigned_byte( + logical_name="hostname_length", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + hostname: str = read_buffer.read_str( + logical_name="hostname", + bit_length=hostname_length * int(8), + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + number_of_memory_banks: int = read_buffer.read_unsigned_byte( + logical_name="number_of_memory_banks", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + memory_idents: List[Any] = read_buffer.read_array_field( + logical_name="memoryIdents", + read_function=PlcMemoryBlockIdent.static_parse, + count=number_of_memory_banks, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUPlcIdentResponse") # Create the instance - return UmasPDUPlcIdentResponseBuilder(range, ident, model, com_version, com_patch, int_version, hardware_version, crash_code, unknown1, hostname_length, hostname, number_of_memory_banks, memory_idents ) - + return UmasPDUPlcIdentResponseBuilder( + range, + ident, + model, + com_version, + com_patch, + int_version, + hardware_version, + crash_code, + unknown1, + hostname_length, + hostname, + number_of_memory_banks, + memory_idents, + ) def equals(self, o: object) -> bool: if self == o: @@ -226,20 +314,36 @@ def equals(self, o: object) -> bool: return False that: UmasPDUPlcIdentResponse = UmasPDUPlcIdentResponse(o) - return (self.range == that.range) and (self.ident == that.ident) and (self.model == that.model) and (self.com_version == that.com_version) and (self.com_patch == that.com_patch) and (self.int_version == that.int_version) and (self.hardware_version == that.hardware_version) and (self.crash_code == that.crash_code) and (self.unknown1 == that.unknown1) and (self.hostname_length == that.hostname_length) and (self.hostname == that.hostname) and (self.number_of_memory_banks == that.number_of_memory_banks) and (self.memory_idents == that.memory_idents) and super().equals(that) and True + return ( + (self.range == that.range) + and (self.ident == that.ident) + and (self.model == that.model) + and (self.com_version == that.com_version) + and (self.com_patch == that.com_patch) + and (self.int_version == that.int_version) + and (self.hardware_version == that.hardware_version) + and (self.crash_code == that.crash_code) + and (self.unknown1 == that.unknown1) + and (self.hostname_length == that.hostname_length) + and (self.hostname == that.hostname) + and (self.number_of_memory_banks == that.number_of_memory_banks) + and (self.memory_idents == that.memory_idents) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -258,9 +362,22 @@ class UmasPDUPlcIdentResponseBuilder: number_of_memory_banks: int memory_idents: List[PlcMemoryBlockIdent] - def build(self,byte_length: int , pairing_key ) -> UmasPDUPlcIdentResponse: - umas_pduplc_ident_response: UmasPDUPlcIdentResponse = UmasPDUPlcIdentResponse(byte_length , pairing_key , self.range, self.ident, self.model, self.com_version, self.com_patch, self.int_version, self.hardware_version, self.crash_code, self.unknown1, self.hostname_length, self.hostname, self.number_of_memory_banks, self.memory_idents ) + def build(self, byte_length: int, pairing_key) -> UmasPDUPlcIdentResponse: + umas_pduplc_ident_response: UmasPDUPlcIdentResponse = UmasPDUPlcIdentResponse( + byte_length, + pairing_key, + self.range, + self.ident, + self.model, + self.com_version, + self.com_patch, + self.int_version, + self.hardware_version, + self.crash_code, + self.unknown1, + self.hostname_length, + self.hostname, + self.number_of_memory_banks, + self.memory_idents, + ) return umas_pduplc_ident_response - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusRequest.py index bd70f888021..3a445954769 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusRequest.py @@ -27,7 +27,8 @@ from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import ClassVar import math - + + @dataclass class UmasPDUPlcStatusRequest(UmasPDUItem): # Arguments. @@ -36,14 +37,11 @@ class UmasPDUPlcStatusRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x04 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUPlcStatusRequest") write_buffer.pop_context("UmasPDUPlcStatusRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -53,9 +51,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUPlcStatusRequest") if isinstance(umas_request_function_key, str): @@ -63,12 +62,10 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - read_buffer.pop_context("UmasPDUPlcStatusRequest") # Create the instance return UmasPDUPlcStatusRequestBuilder() - def equals(self, o: object) -> bool: if self == o: return True @@ -84,21 +81,21 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasPDUPlcStatusRequestBuilder: - def build(self,byte_length: int , pairing_key ) -> UmasPDUPlcStatusRequest: - umas_pduplc_status_request: UmasPDUPlcStatusRequest = UmasPDUPlcStatusRequest(byte_length , pairing_key , ) + def build(self, byte_length: int, pairing_key) -> UmasPDUPlcStatusRequest: + umas_pduplc_status_request: UmasPDUPlcStatusRequest = UmasPDUPlcStatusRequest( + byte_length, + pairing_key, + ) return umas_pduplc_status_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusResponse.py index bb1cc17ddcc..388b8639ccf 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUPlcStatusResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUPlcStatusResponse(UmasPDUItem): not_used1: int @@ -43,26 +44,31 @@ class UmasPDUPlcStatusResponse(UmasPDUItem): umas_function_key: ClassVar[int] = 0xFE umas_request_function_key: ClassVar[int] = 0x04 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUPlcStatusResponse") # Simple Field (notUsed1) - write_buffer.write_unsigned_byte(self.not_used1,bit_length=8,logical_name="notUsed1") + write_buffer.write_unsigned_byte( + self.not_used1, bit_length=8, logical_name="notUsed1" + ) # Simple Field (notUsed2) - write_buffer.write_unsigned_short(self.not_used2,bit_length=16,logical_name="notUsed2") + write_buffer.write_unsigned_short( + self.not_used2, bit_length=16, logical_name="notUsed2" + ) # Simple Field (numberOfBlocks) - write_buffer.write_unsigned_byte(self.number_of_blocks,bit_length=8,logical_name="numberOfBlocks") + write_buffer.write_unsigned_byte( + self.number_of_blocks, bit_length=8, logical_name="numberOfBlocks" + ) # Array Field (blocks) - write_buffer.write_simple_array(self.blocks, write_buffer.write_unsigned_int, logical_name="blocks") + write_buffer.write_simple_array( + self.blocks, write_buffer.write_unsigned_int, logical_name="blocks" + ) write_buffer.pop_context("UmasPDUPlcStatusResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -83,12 +89,12 @@ def length_in_bits(self) -> int: if self.blocks is not None: length_in_bits += 32 * len(self.blocks) - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUPlcStatusResponse") if isinstance(umas_request_function_key, str): @@ -96,25 +102,44 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - not_used1: int = read_buffer.read_unsigned_byte(logical_name="not_used1", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - not_used2: int = read_buffer.read_unsigned_short(logical_name="not_used2", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - number_of_blocks: int = read_buffer.read_unsigned_byte(logical_name="number_of_blocks", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - blocks: List[Any] = read_buffer.read_array_field(logical_name="blocks", read_function=read_buffer.read_unsigned_int, count=number_of_blocks, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + not_used1: int = read_buffer.read_unsigned_byte( + logical_name="not_used1", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + not_used2: int = read_buffer.read_unsigned_short( + logical_name="not_used2", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + number_of_blocks: int = read_buffer.read_unsigned_byte( + logical_name="number_of_blocks", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + blocks: List[Any] = read_buffer.read_array_field( + logical_name="blocks", + read_function=read_buffer.read_unsigned_int, + count=number_of_blocks, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUPlcStatusResponse") # Create the instance - return UmasPDUPlcStatusResponseBuilder(not_used1, not_used2, number_of_blocks, blocks ) - + return UmasPDUPlcStatusResponseBuilder( + not_used1, not_used2, number_of_blocks, blocks + ) def equals(self, o: object) -> bool: if self == o: @@ -124,20 +149,27 @@ def equals(self, o: object) -> bool: return False that: UmasPDUPlcStatusResponse = UmasPDUPlcStatusResponse(o) - return (self.not_used1 == that.not_used1) and (self.not_used2 == that.not_used2) and (self.number_of_blocks == that.number_of_blocks) and (self.blocks == that.blocks) and super().equals(that) and True + return ( + (self.not_used1 == that.not_used1) + and (self.not_used2 == that.not_used2) + and (self.number_of_blocks == that.number_of_blocks) + and (self.blocks == that.blocks) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -147,9 +179,15 @@ class UmasPDUPlcStatusResponseBuilder: number_of_blocks: int blocks: List[int] - def build(self,byte_length: int , pairing_key ) -> UmasPDUPlcStatusResponse: - umas_pduplc_status_response: UmasPDUPlcStatusResponse = UmasPDUPlcStatusResponse(byte_length , pairing_key , self.not_used1, self.not_used2, self.number_of_blocks, self.blocks ) + def build(self, byte_length: int, pairing_key) -> UmasPDUPlcStatusResponse: + umas_pduplc_status_response: UmasPDUPlcStatusResponse = ( + UmasPDUPlcStatusResponse( + byte_length, + pairing_key, + self.not_used1, + self.not_used2, + self.number_of_blocks, + self.blocks, + ) + ) return umas_pduplc_status_response - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUProjectInfoRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUProjectInfoRequest.py index f0f5250a6c2..825ed3516c8 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUProjectInfoRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUProjectInfoRequest.py @@ -28,7 +28,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class UmasPDUProjectInfoRequest(UmasPDUItem): subcode: int @@ -38,17 +39,16 @@ class UmasPDUProjectInfoRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x03 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUProjectInfoRequest") # Simple Field (subcode) - write_buffer.write_unsigned_byte(self.subcode,bit_length=8,logical_name="subcode") + write_buffer.write_unsigned_byte( + self.subcode, bit_length=8, logical_name="subcode" + ) write_buffer.pop_context("UmasPDUProjectInfoRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -61,9 +61,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUProjectInfoRequest") if isinstance(umas_request_function_key, str): @@ -71,15 +72,17 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - subcode: int = read_buffer.read_unsigned_byte(logical_name="subcode", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - + subcode: int = read_buffer.read_unsigned_byte( + logical_name="subcode", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUProjectInfoRequest") # Create the instance - return UmasPDUProjectInfoRequestBuilder(subcode ) - + return UmasPDUProjectInfoRequestBuilder(subcode) def equals(self, o: object) -> bool: if self == o: @@ -96,22 +99,21 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasPDUProjectInfoRequestBuilder: subcode: int - def build(self,byte_length: int , pairing_key ) -> UmasPDUProjectInfoRequest: - umas_pduproject_info_request: UmasPDUProjectInfoRequest = UmasPDUProjectInfoRequest(byte_length , pairing_key , self.subcode ) + def build(self, byte_length: int, pairing_key) -> UmasPDUProjectInfoRequest: + umas_pduproject_info_request: UmasPDUProjectInfoRequest = ( + UmasPDUProjectInfoRequest(byte_length, pairing_key, self.subcode) + ) return umas_pduproject_info_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadDatatypeNamesResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadDatatypeNamesResponse.py index 6ba466b98fa..cc0ca08c7af 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadDatatypeNamesResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadDatatypeNamesResponse.py @@ -28,38 +28,42 @@ from typing import Any from typing import List import math - + + @dataclass -class UmasPDUReadDatatypeNamesResponse(): +class UmasPDUReadDatatypeNamesResponse: range: int next_address: int unknown1: int no_of_records: int records: List[UmasDatatypeReference] - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadDatatypeNamesResponse") # Simple Field (range) - write_buffer.write_unsigned_byte(self.range,bit_length=8,logical_name="range") + write_buffer.write_unsigned_byte(self.range, bit_length=8, logical_name="range") # Simple Field (nextAddress) - write_buffer.write_unsigned_short(self.next_address,bit_length=16,logical_name="nextAddress") + write_buffer.write_unsigned_short( + self.next_address, bit_length=16, logical_name="nextAddress" + ) # Simple Field (unknown1) - write_buffer.write_unsigned_byte(self.unknown1,bit_length=8,logical_name="unknown1") + write_buffer.write_unsigned_byte( + self.unknown1, bit_length=8, logical_name="unknown1" + ) # Simple Field (noOfRecords) - write_buffer.write_unsigned_short(self.no_of_records,bit_length=16,logical_name="noOfRecords") + write_buffer.write_unsigned_short( + self.no_of_records, bit_length=16, logical_name="noOfRecords" + ) # Array Field (records) write_buffer.write_complex_array(self.records, logical_name="records") write_buffer.pop_context("UmasPDUReadDatatypeNamesResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -84,46 +88,45 @@ def length_in_bits(self) -> int: for element in self.records: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return UmasPDUReadDatatypeNamesResponse.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("UmasPDUReadDatatypeNamesResponse") + range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8) + next_address: int = read_buffer.read_unsigned_short( + logical_name="next_address", bit_length=16 + ) - range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8) - - - - next_address: int = read_buffer.read_unsigned_short(logical_name="next_address", bit_length=16) + unknown1: int = read_buffer.read_unsigned_byte( + logical_name="unknown1", bit_length=8 + ) + no_of_records: int = read_buffer.read_unsigned_short( + logical_name="no_of_records", bit_length=16 + ) - - unknown1: int = read_buffer.read_unsigned_byte(logical_name="unknown1", bit_length=8) - - - - no_of_records: int = read_buffer.read_unsigned_short(logical_name="no_of_records", bit_length=16) - - - - records: List[Any] = read_buffer.read_array_field(logical_name="records", read_function=UmasDatatypeReference.static_parse, count=no_of_records) + records: List[Any] = read_buffer.read_array_field( + logical_name="records", + read_function=UmasDatatypeReference.static_parse, + count=no_of_records, + ) read_buffer.pop_context("UmasPDUReadDatatypeNamesResponse") # Create the instance - _umas_pduread_datatype_names_response: UmasPDUReadDatatypeNamesResponse = UmasPDUReadDatatypeNamesResponse(range, next_address, unknown1, no_of_records, records ) + _umas_pduread_datatype_names_response: UmasPDUReadDatatypeNamesResponse = ( + UmasPDUReadDatatypeNamesResponse( + range, next_address, unknown1, no_of_records, records + ) + ) return _umas_pduread_datatype_names_response - def equals(self, o: object) -> bool: if self == o: return True @@ -132,21 +135,24 @@ def equals(self, o: object) -> bool: return False that: UmasPDUReadDatatypeNamesResponse = UmasPDUReadDatatypeNamesResponse(o) - return (self.range == that.range) and (self.next_address == that.next_address) and (self.unknown1 == that.unknown1) and (self.no_of_records == that.no_of_records) and (self.records == that.records) and True + return ( + (self.range == that.range) + and (self.next_address == that.next_address) + and (self.unknown1 == that.unknown1) + and (self.no_of_records == that.no_of_records) + and (self.records == that.records) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockRequest.py index 48aecb4bbdd..628fe6ff89f 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockRequest.py @@ -28,7 +28,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class UmasPDUReadMemoryBlockRequest(UmasPDUItem): range: int @@ -42,29 +43,34 @@ class UmasPDUReadMemoryBlockRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x20 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadMemoryBlockRequest") # Simple Field (range) - write_buffer.write_unsigned_byte(self.range,bit_length=8,logical_name="range") + write_buffer.write_unsigned_byte(self.range, bit_length=8, logical_name="range") # Simple Field (blockNumber) - write_buffer.write_unsigned_short(self.block_number,bit_length=16,logical_name="blockNumber") + write_buffer.write_unsigned_short( + self.block_number, bit_length=16, logical_name="blockNumber" + ) # Simple Field (offset) - write_buffer.write_unsigned_short(self.offset,bit_length=16,logical_name="offset") + write_buffer.write_unsigned_short( + self.offset, bit_length=16, logical_name="offset" + ) # Simple Field (unknownObject1) - write_buffer.write_unsigned_short(self.unknown_object1,bit_length=16,logical_name="unknownObject1") + write_buffer.write_unsigned_short( + self.unknown_object1, bit_length=16, logical_name="unknownObject1" + ) # Simple Field (numberOfBytes) - write_buffer.write_unsigned_short(self.number_of_bytes,bit_length=16,logical_name="numberOfBytes") + write_buffer.write_unsigned_short( + self.number_of_bytes, bit_length=16, logical_name="numberOfBytes" + ) write_buffer.pop_context("UmasPDUReadMemoryBlockRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -89,9 +95,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUReadMemoryBlockRequest") if isinstance(umas_request_function_key, str): @@ -99,31 +106,51 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - block_number: int = read_buffer.read_unsigned_short(logical_name="block_number", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - offset: int = read_buffer.read_unsigned_short(logical_name="offset", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - unknown_object1: int = read_buffer.read_unsigned_short(logical_name="unknown_object1", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - number_of_bytes: int = read_buffer.read_unsigned_short(logical_name="number_of_bytes", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - + range: int = read_buffer.read_unsigned_byte( + logical_name="range", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + block_number: int = read_buffer.read_unsigned_short( + logical_name="block_number", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + offset: int = read_buffer.read_unsigned_short( + logical_name="offset", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + unknown_object1: int = read_buffer.read_unsigned_short( + logical_name="unknown_object1", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + number_of_bytes: int = read_buffer.read_unsigned_short( + logical_name="number_of_bytes", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUReadMemoryBlockRequest") # Create the instance - return UmasPDUReadMemoryBlockRequestBuilder(range, block_number, offset, unknown_object1, number_of_bytes ) - + return UmasPDUReadMemoryBlockRequestBuilder( + range, block_number, offset, unknown_object1, number_of_bytes + ) def equals(self, o: object) -> bool: if self == o: @@ -133,20 +160,28 @@ def equals(self, o: object) -> bool: return False that: UmasPDUReadMemoryBlockRequest = UmasPDUReadMemoryBlockRequest(o) - return (self.range == that.range) and (self.block_number == that.block_number) and (self.offset == that.offset) and (self.unknown_object1 == that.unknown_object1) and (self.number_of_bytes == that.number_of_bytes) and super().equals(that) and True + return ( + (self.range == that.range) + and (self.block_number == that.block_number) + and (self.offset == that.offset) + and (self.unknown_object1 == that.unknown_object1) + and (self.number_of_bytes == that.number_of_bytes) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -157,9 +192,16 @@ class UmasPDUReadMemoryBlockRequestBuilder: unknown_object1: int number_of_bytes: int - def build(self,byte_length: int , pairing_key ) -> UmasPDUReadMemoryBlockRequest: - umas_pduread_memory_block_request: UmasPDUReadMemoryBlockRequest = UmasPDUReadMemoryBlockRequest(byte_length , pairing_key , self.range, self.block_number, self.offset, self.unknown_object1, self.number_of_bytes ) + def build(self, byte_length: int, pairing_key) -> UmasPDUReadMemoryBlockRequest: + umas_pduread_memory_block_request: UmasPDUReadMemoryBlockRequest = ( + UmasPDUReadMemoryBlockRequest( + byte_length, + pairing_key, + self.range, + self.block_number, + self.offset, + self.unknown_object1, + self.number_of_bytes, + ) + ) return umas_pduread_memory_block_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockResponse.py index afe8f38f4f7..a80bd6b42b8 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadMemoryBlockResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUReadMemoryBlockResponse(UmasPDUItem): range: int @@ -42,23 +43,24 @@ class UmasPDUReadMemoryBlockResponse(UmasPDUItem): umas_function_key: ClassVar[int] = 0xFE umas_request_function_key: ClassVar[int] = 0x20 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadMemoryBlockResponse") # Simple Field (range) - write_buffer.write_unsigned_byte(self.range,bit_length=8,logical_name="range") + write_buffer.write_unsigned_byte(self.range, bit_length=8, logical_name="range") # Simple Field (numberOfBytes) - write_buffer.write_unsigned_short(self.number_of_bytes,bit_length=16,logical_name="numberOfBytes") + write_buffer.write_unsigned_short( + self.number_of_bytes, bit_length=16, logical_name="numberOfBytes" + ) # Array Field (block) - write_buffer.write_simple_array(self.block, write_buffer.write_unsigned_byte, logical_name="block") + write_buffer.write_simple_array( + self.block, write_buffer.write_unsigned_byte, logical_name="block" + ) write_buffer.pop_context("UmasPDUReadMemoryBlockResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -76,12 +78,12 @@ def length_in_bits(self) -> int: if self.block is not None: length_in_bits += 8 * len(self.block) - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUReadMemoryBlockResponse") if isinstance(umas_request_function_key, str): @@ -89,21 +91,34 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - number_of_bytes: int = read_buffer.read_unsigned_short(logical_name="number_of_bytes", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - block: List[Any] = read_buffer.read_array_field(logical_name="block", read_function=read_buffer.read_unsigned_byte, count=number_of_bytes, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + range: int = read_buffer.read_unsigned_byte( + logical_name="range", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + number_of_bytes: int = read_buffer.read_unsigned_short( + logical_name="number_of_bytes", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + block: List[Any] = read_buffer.read_array_field( + logical_name="block", + read_function=read_buffer.read_unsigned_byte, + count=number_of_bytes, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUReadMemoryBlockResponse") # Create the instance - return UmasPDUReadMemoryBlockResponseBuilder(range, number_of_bytes, block ) - + return UmasPDUReadMemoryBlockResponseBuilder(range, number_of_bytes, block) def equals(self, o: object) -> bool: if self == o: @@ -113,20 +128,26 @@ def equals(self, o: object) -> bool: return False that: UmasPDUReadMemoryBlockResponse = UmasPDUReadMemoryBlockResponse(o) - return (self.range == that.range) and (self.number_of_bytes == that.number_of_bytes) and (self.block == that.block) and super().equals(that) and True + return ( + (self.range == that.range) + and (self.number_of_bytes == that.number_of_bytes) + and (self.block == that.block) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -135,9 +156,10 @@ class UmasPDUReadMemoryBlockResponseBuilder: number_of_bytes: int block: List[int] - def build(self,byte_length: int , pairing_key ) -> UmasPDUReadMemoryBlockResponse: - umas_pduread_memory_block_response: UmasPDUReadMemoryBlockResponse = UmasPDUReadMemoryBlockResponse(byte_length , pairing_key , self.range, self.number_of_bytes, self.block ) + def build(self, byte_length: int, pairing_key) -> UmasPDUReadMemoryBlockResponse: + umas_pduread_memory_block_response: UmasPDUReadMemoryBlockResponse = ( + UmasPDUReadMemoryBlockResponse( + byte_length, pairing_key, self.range, self.number_of_bytes, self.block + ) + ) return umas_pduread_memory_block_response - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUmasUDTDefinitionResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUmasUDTDefinitionResponse.py index 56fe2ecee95..61518eaa21f 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUmasUDTDefinitionResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUmasUDTDefinitionResponse.py @@ -28,34 +28,36 @@ from typing import Any from typing import List import math - + + @dataclass -class UmasPDUReadUmasUDTDefinitionResponse(): +class UmasPDUReadUmasUDTDefinitionResponse: range: int unknown1: int no_of_records: int records: List[UmasUDTDefinition] - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadUmasUDTDefinitionResponse") # Simple Field (range) - write_buffer.write_unsigned_byte(self.range,bit_length=8,logical_name="range") + write_buffer.write_unsigned_byte(self.range, bit_length=8, logical_name="range") # Simple Field (unknown1) - write_buffer.write_unsigned_int(self.unknown1,bit_length=32,logical_name="unknown1") + write_buffer.write_unsigned_int( + self.unknown1, bit_length=32, logical_name="unknown1" + ) # Simple Field (noOfRecords) - write_buffer.write_unsigned_short(self.no_of_records,bit_length=16,logical_name="noOfRecords") + write_buffer.write_unsigned_short( + self.no_of_records, bit_length=16, logical_name="noOfRecords" + ) # Array Field (records) write_buffer.write_complex_array(self.records, logical_name="records") write_buffer.pop_context("UmasPDUReadUmasUDTDefinitionResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -77,42 +79,41 @@ def length_in_bits(self) -> int: for element in self.records: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return UmasPDUReadUmasUDTDefinitionResponse.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("UmasPDUReadUmasUDTDefinitionResponse") + range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8) + unknown1: int = read_buffer.read_unsigned_int( + logical_name="unknown1", bit_length=32 + ) - range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8) - - + no_of_records: int = read_buffer.read_unsigned_short( + logical_name="no_of_records", bit_length=16 + ) - unknown1: int = read_buffer.read_unsigned_int(logical_name="unknown1", bit_length=32) - - - - no_of_records: int = read_buffer.read_unsigned_short(logical_name="no_of_records", bit_length=16) - - - - records: List[Any] = read_buffer.read_array_field(logical_name="records", read_function=UmasUDTDefinition.static_parse, count=no_of_records) + records: List[Any] = read_buffer.read_array_field( + logical_name="records", + read_function=UmasUDTDefinition.static_parse, + count=no_of_records, + ) read_buffer.pop_context("UmasPDUReadUmasUDTDefinitionResponse") # Create the instance - _umas_pduread_umas_udtdefinition_response: UmasPDUReadUmasUDTDefinitionResponse = UmasPDUReadUmasUDTDefinitionResponse(range, unknown1, no_of_records, records ) + _umas_pduread_umas_udtdefinition_response: ( + UmasPDUReadUmasUDTDefinitionResponse + ) = UmasPDUReadUmasUDTDefinitionResponse( + range, unknown1, no_of_records, records + ) return _umas_pduread_umas_udtdefinition_response - def equals(self, o: object) -> bool: if self == o: return True @@ -120,22 +121,26 @@ def equals(self, o: object) -> bool: if not isinstance(o, UmasPDUReadUmasUDTDefinitionResponse): return False - that: UmasPDUReadUmasUDTDefinitionResponse = UmasPDUReadUmasUDTDefinitionResponse(o) - return (self.range == that.range) and (self.unknown1 == that.unknown1) and (self.no_of_records == that.no_of_records) and (self.records == that.records) and True + that: UmasPDUReadUmasUDTDefinitionResponse = ( + UmasPDUReadUmasUDTDefinitionResponse(o) + ) + return ( + (self.range == that.range) + and (self.unknown1 == that.unknown1) + and (self.no_of_records == that.no_of_records) + and (self.records == that.records) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesRequest.py index e0f15197c42..83f576672a1 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesRequest.py @@ -28,7 +28,8 @@ from plc4py.utils.GenericTypes import ByteOrder from typing import ClassVar import math - + + @dataclass class UmasPDUReadUnlocatedVariableNamesRequest(UmasPDUItem): record_type: int @@ -43,32 +44,37 @@ class UmasPDUReadUnlocatedVariableNamesRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x26 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadUnlocatedVariableNamesRequest") # Simple Field (recordType) - write_buffer.write_unsigned_short(self.record_type,bit_length=16,logical_name="recordType") + write_buffer.write_unsigned_short( + self.record_type, bit_length=16, logical_name="recordType" + ) # Simple Field (index) - write_buffer.write_unsigned_byte(self.index,bit_length=8,logical_name="index") + write_buffer.write_unsigned_byte(self.index, bit_length=8, logical_name="index") # Simple Field (hardwareId) - write_buffer.write_unsigned_int(self.hardware_id,bit_length=32,logical_name="hardwareId") + write_buffer.write_unsigned_int( + self.hardware_id, bit_length=32, logical_name="hardwareId" + ) # Simple Field (blockNo) - write_buffer.write_unsigned_short(self.block_no,bit_length=16,logical_name="blockNo") + write_buffer.write_unsigned_short( + self.block_no, bit_length=16, logical_name="blockNo" + ) # Simple Field (offset) - write_buffer.write_unsigned_short(self.offset,bit_length=16,logical_name="offset") + write_buffer.write_unsigned_short( + self.offset, bit_length=16, logical_name="offset" + ) # Const Field (blank) write_buffer.write_unsigned_short(self.BLANK, logical_name="blank") write_buffer.pop_context("UmasPDUReadUnlocatedVariableNamesRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -96,9 +102,10 @@ def length_in_bits(self) -> int: return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUReadUnlocatedVariableNamesRequest") if isinstance(umas_request_function_key, str): @@ -106,33 +113,58 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - record_type: int = read_buffer.read_unsigned_short(logical_name="record_type", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - index: int = read_buffer.read_unsigned_byte(logical_name="index", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - hardware_id: int = read_buffer.read_unsigned_int(logical_name="hardware_id", bit_length=32, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - block_no: int = read_buffer.read_unsigned_short(logical_name="block_no", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - offset: int = read_buffer.read_unsigned_short(logical_name="offset", bit_length=16, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - BLANK: int = read_buffer.read_unsigned_short(logical_name="blank", byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + record_type: int = read_buffer.read_unsigned_short( + logical_name="record_type", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + index: int = read_buffer.read_unsigned_byte( + logical_name="index", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + hardware_id: int = read_buffer.read_unsigned_int( + logical_name="hardware_id", + bit_length=32, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + block_no: int = read_buffer.read_unsigned_short( + logical_name="block_no", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + offset: int = read_buffer.read_unsigned_short( + logical_name="offset", + bit_length=16, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + BLANK: int = read_buffer.read_unsigned_short( + logical_name="blank", + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUReadUnlocatedVariableNamesRequest") # Create the instance - return UmasPDUReadUnlocatedVariableNamesRequestBuilder(record_type, index, hardware_id, block_no, offset ) - + return UmasPDUReadUnlocatedVariableNamesRequestBuilder( + record_type, index, hardware_id, block_no, offset + ) def equals(self, o: object) -> bool: if self == o: @@ -141,21 +173,31 @@ def equals(self, o: object) -> bool: if not isinstance(o, UmasPDUReadUnlocatedVariableNamesRequest): return False - that: UmasPDUReadUnlocatedVariableNamesRequest = UmasPDUReadUnlocatedVariableNamesRequest(o) - return (self.record_type == that.record_type) and (self.index == that.index) and (self.hardware_id == that.hardware_id) and (self.block_no == that.block_no) and (self.offset == that.offset) and super().equals(that) and True + that: UmasPDUReadUnlocatedVariableNamesRequest = ( + UmasPDUReadUnlocatedVariableNamesRequest(o) + ) + return ( + (self.record_type == that.record_type) + and (self.index == that.index) + and (self.hardware_id == that.hardware_id) + and (self.block_no == that.block_no) + and (self.offset == that.offset) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -166,9 +208,18 @@ class UmasPDUReadUnlocatedVariableNamesRequestBuilder: block_no: int offset: int - def build(self,byte_length: int , pairing_key ) -> UmasPDUReadUnlocatedVariableNamesRequest: - umas_pduread_unlocated_variable_names_request: UmasPDUReadUnlocatedVariableNamesRequest = UmasPDUReadUnlocatedVariableNamesRequest(byte_length , pairing_key , self.record_type, self.index, self.hardware_id, self.block_no, self.offset ) + def build( + self, byte_length: int, pairing_key + ) -> UmasPDUReadUnlocatedVariableNamesRequest: + umas_pduread_unlocated_variable_names_request: ( + UmasPDUReadUnlocatedVariableNamesRequest + ) = UmasPDUReadUnlocatedVariableNamesRequest( + byte_length, + pairing_key, + self.record_type, + self.index, + self.hardware_id, + self.block_no, + self.offset, + ) return umas_pduread_unlocated_variable_names_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesResponse.py index 33c58a5bbe1..d41e44d5c7a 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableNamesResponse.py @@ -22,44 +22,50 @@ from plc4py.api.exceptions.exceptions import PlcRuntimeException from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage -from plc4py.protocols.umas.readwrite.UmasUnlocatedVariableReference import UmasUnlocatedVariableReference +from plc4py.protocols.umas.readwrite.UmasUnlocatedVariableReference import ( + UmasUnlocatedVariableReference, +) from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from typing import Any from typing import List import math - + + @dataclass -class UmasPDUReadUnlocatedVariableNamesResponse(): +class UmasPDUReadUnlocatedVariableNamesResponse: range: int next_address: int unknown1: int no_of_records: int records: List[UmasUnlocatedVariableReference] - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadUnlocatedVariableNamesResponse") # Simple Field (range) - write_buffer.write_unsigned_byte(self.range,bit_length=8,logical_name="range") + write_buffer.write_unsigned_byte(self.range, bit_length=8, logical_name="range") # Simple Field (nextAddress) - write_buffer.write_unsigned_short(self.next_address,bit_length=16,logical_name="nextAddress") + write_buffer.write_unsigned_short( + self.next_address, bit_length=16, logical_name="nextAddress" + ) # Simple Field (unknown1) - write_buffer.write_unsigned_short(self.unknown1,bit_length=16,logical_name="unknown1") + write_buffer.write_unsigned_short( + self.unknown1, bit_length=16, logical_name="unknown1" + ) # Simple Field (noOfRecords) - write_buffer.write_unsigned_short(self.no_of_records,bit_length=16,logical_name="noOfRecords") + write_buffer.write_unsigned_short( + self.no_of_records, bit_length=16, logical_name="noOfRecords" + ) # Array Field (records) write_buffer.write_complex_array(self.records, logical_name="records") write_buffer.pop_context("UmasPDUReadUnlocatedVariableNamesResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -84,46 +90,47 @@ def length_in_bits(self) -> int: for element in self.records: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): - return UmasPDUReadUnlocatedVariableNamesResponse.static_parse_context(read_buffer) - + return UmasPDUReadUnlocatedVariableNamesResponse.static_parse_context( + read_buffer + ) @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("UmasPDUReadUnlocatedVariableNamesResponse") + range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8) + next_address: int = read_buffer.read_unsigned_short( + logical_name="next_address", bit_length=16 + ) - range: int = read_buffer.read_unsigned_byte(logical_name="range", bit_length=8) - - - - next_address: int = read_buffer.read_unsigned_short(logical_name="next_address", bit_length=16) + unknown1: int = read_buffer.read_unsigned_short( + logical_name="unknown1", bit_length=16 + ) + no_of_records: int = read_buffer.read_unsigned_short( + logical_name="no_of_records", bit_length=16 + ) - - unknown1: int = read_buffer.read_unsigned_short(logical_name="unknown1", bit_length=16) - - - - no_of_records: int = read_buffer.read_unsigned_short(logical_name="no_of_records", bit_length=16) - - - - records: List[Any] = read_buffer.read_array_field(logical_name="records", read_function=UmasUnlocatedVariableReference.static_parse, count=no_of_records) + records: List[Any] = read_buffer.read_array_field( + logical_name="records", + read_function=UmasUnlocatedVariableReference.static_parse, + count=no_of_records, + ) read_buffer.pop_context("UmasPDUReadUnlocatedVariableNamesResponse") # Create the instance - _umas_pduread_unlocated_variable_names_response: UmasPDUReadUnlocatedVariableNamesResponse = UmasPDUReadUnlocatedVariableNamesResponse(range, next_address, unknown1, no_of_records, records ) + _umas_pduread_unlocated_variable_names_response: ( + UmasPDUReadUnlocatedVariableNamesResponse + ) = UmasPDUReadUnlocatedVariableNamesResponse( + range, next_address, unknown1, no_of_records, records + ) return _umas_pduread_unlocated_variable_names_response - def equals(self, o: object) -> bool: if self == o: return True @@ -131,22 +138,27 @@ def equals(self, o: object) -> bool: if not isinstance(o, UmasPDUReadUnlocatedVariableNamesResponse): return False - that: UmasPDUReadUnlocatedVariableNamesResponse = UmasPDUReadUnlocatedVariableNamesResponse(o) - return (self.range == that.range) and (self.next_address == that.next_address) and (self.unknown1 == that.unknown1) and (self.no_of_records == that.no_of_records) and (self.records == that.records) and True + that: UmasPDUReadUnlocatedVariableNamesResponse = ( + UmasPDUReadUnlocatedVariableNamesResponse(o) + ) + return ( + (self.range == that.range) + and (self.next_address == that.next_address) + and (self.unknown1 == that.unknown1) + and (self.no_of_records == that.no_of_records) + and (self.records == that.records) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableResponse.py index cdf59027756..489ae66068f 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadUnlocatedVariableResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUReadUnlocatedVariableResponse(UmasPDUItem): block: List[int] @@ -40,17 +41,16 @@ class UmasPDUReadUnlocatedVariableResponse(UmasPDUItem): umas_function_key: ClassVar[int] = 0xFE umas_request_function_key: ClassVar[int] = 0x26 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadUnlocatedVariableResponse") # Array Field (block) - write_buffer.write_simple_array(self.block, write_buffer.write_unsigned_byte, logical_name="block") + write_buffer.write_simple_array( + self.block, write_buffer.write_unsigned_byte, logical_name="block" + ) write_buffer.pop_context("UmasPDUReadUnlocatedVariableResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -62,12 +62,12 @@ def length_in_bits(self) -> int: if self.block is not None: length_in_bits += 8 * len(self.block) - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUReadUnlocatedVariableResponse") if isinstance(umas_request_function_key, str): @@ -75,13 +75,18 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - block: List[Any] = read_buffer.read_array_field(logical_name="block", read_function=read_buffer.read_unsigned_byte, count=byte_length- int(2), byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + block: List[Any] = read_buffer.read_array_field( + logical_name="block", + read_function=read_buffer.read_unsigned_byte, + count=byte_length - int(2), + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUReadUnlocatedVariableResponse") # Create the instance - return UmasPDUReadUnlocatedVariableResponseBuilder(block ) - + return UmasPDUReadUnlocatedVariableResponseBuilder(block) def equals(self, o: object) -> bool: if self == o: @@ -90,7 +95,9 @@ def equals(self, o: object) -> bool: if not isinstance(o, UmasPDUReadUnlocatedVariableResponse): return False - that: UmasPDUReadUnlocatedVariableResponse = UmasPDUReadUnlocatedVariableResponse(o) + that: UmasPDUReadUnlocatedVariableResponse = ( + UmasPDUReadUnlocatedVariableResponse(o) + ) return (self.block == that.block) and super().equals(that) and True def hash_code(self) -> int: @@ -98,22 +105,23 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasPDUReadUnlocatedVariableResponseBuilder: block: List[int] - def build(self,byte_length: int , pairing_key ) -> UmasPDUReadUnlocatedVariableResponse: - umas_pduread_unlocated_variable_response: UmasPDUReadUnlocatedVariableResponse = UmasPDUReadUnlocatedVariableResponse(byte_length , pairing_key , self.block ) + def build( + self, byte_length: int, pairing_key + ) -> UmasPDUReadUnlocatedVariableResponse: + umas_pduread_unlocated_variable_response: ( + UmasPDUReadUnlocatedVariableResponse + ) = UmasPDUReadUnlocatedVariableResponse(byte_length, pairing_key, self.block) return umas_pduread_unlocated_variable_response - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableRequest.py index cc4eee79bf9..62e6134d94c 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableRequest.py @@ -23,7 +23,9 @@ from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage from plc4py.protocols.umas.readwrite.UmasPDUItem import UmasPDUItem -from plc4py.protocols.umas.readwrite.VariableReadRequestReference import VariableReadRequestReference +from plc4py.protocols.umas.readwrite.VariableReadRequestReference import ( + VariableReadRequestReference, +) from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.utils.GenericTypes import ByteOrder @@ -31,7 +33,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUReadVariableRequest(UmasPDUItem): crc: int @@ -43,23 +46,22 @@ class UmasPDUReadVariableRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x22 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadVariableRequest") # Simple Field (crc) - write_buffer.write_unsigned_int(self.crc,bit_length=32,logical_name="crc") + write_buffer.write_unsigned_int(self.crc, bit_length=32, logical_name="crc") # Simple Field (variableCount) - write_buffer.write_unsigned_byte(self.variable_count,bit_length=8,logical_name="variableCount") + write_buffer.write_unsigned_byte( + self.variable_count, bit_length=8, logical_name="variableCount" + ) # Array Field (variables) write_buffer.write_complex_array(self.variables, logical_name="variables") write_buffer.pop_context("UmasPDUReadVariableRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -78,13 +80,12 @@ def length_in_bits(self) -> int: for element in self.variables: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUReadVariableRequest") if isinstance(umas_request_function_key, str): @@ -92,21 +93,34 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - crc: int = read_buffer.read_unsigned_int(logical_name="crc", bit_length=32, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - variable_count: int = read_buffer.read_unsigned_byte(logical_name="variable_count", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - variables: List[Any] = read_buffer.read_array_field(logical_name="variables", read_function=VariableReadRequestReference.static_parse, count=variable_count, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + crc: int = read_buffer.read_unsigned_int( + logical_name="crc", + bit_length=32, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + variable_count: int = read_buffer.read_unsigned_byte( + logical_name="variable_count", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + variables: List[Any] = read_buffer.read_array_field( + logical_name="variables", + read_function=VariableReadRequestReference.static_parse, + count=variable_count, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUReadVariableRequest") # Create the instance - return UmasPDUReadVariableRequestBuilder(crc, variable_count, variables ) - + return UmasPDUReadVariableRequestBuilder(crc, variable_count, variables) def equals(self, o: object) -> bool: if self == o: @@ -116,20 +130,26 @@ def equals(self, o: object) -> bool: return False that: UmasPDUReadVariableRequest = UmasPDUReadVariableRequest(o) - return (self.crc == that.crc) and (self.variable_count == that.variable_count) and (self.variables == that.variables) and super().equals(that) and True + return ( + (self.crc == that.crc) + and (self.variable_count == that.variable_count) + and (self.variables == that.variables) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -138,9 +158,10 @@ class UmasPDUReadVariableRequestBuilder: variable_count: int variables: List[VariableReadRequestReference] - def build(self,byte_length: int , pairing_key ) -> UmasPDUReadVariableRequest: - umas_pduread_variable_request: UmasPDUReadVariableRequest = UmasPDUReadVariableRequest(byte_length , pairing_key , self.crc, self.variable_count, self.variables ) + def build(self, byte_length: int, pairing_key) -> UmasPDUReadVariableRequest: + umas_pduread_variable_request: UmasPDUReadVariableRequest = ( + UmasPDUReadVariableRequest( + byte_length, pairing_key, self.crc, self.variable_count, self.variables + ) + ) return umas_pduread_variable_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableResponse.py index 258d31b3168..d5a71040da5 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUReadVariableResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUReadVariableResponse(UmasPDUItem): block: List[int] @@ -40,17 +41,16 @@ class UmasPDUReadVariableResponse(UmasPDUItem): umas_function_key: ClassVar[int] = 0xFE umas_request_function_key: ClassVar[int] = 0x22 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUReadVariableResponse") # Array Field (block) - write_buffer.write_simple_array(self.block, write_buffer.write_unsigned_byte, logical_name="block") + write_buffer.write_simple_array( + self.block, write_buffer.write_unsigned_byte, logical_name="block" + ) write_buffer.pop_context("UmasPDUReadVariableResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -62,12 +62,12 @@ def length_in_bits(self) -> int: if self.block is not None: length_in_bits += 8 * len(self.block) - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUReadVariableResponse") if isinstance(umas_request_function_key, str): @@ -75,13 +75,18 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - block: List[Any] = read_buffer.read_array_field(logical_name="block", read_function=read_buffer.read_unsigned_byte, count=byte_length- int(2), byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + block: List[Any] = read_buffer.read_array_field( + logical_name="block", + read_function=read_buffer.read_unsigned_byte, + count=byte_length - int(2), + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUReadVariableResponse") # Create the instance - return UmasPDUReadVariableResponseBuilder(block ) - + return UmasPDUReadVariableResponseBuilder(block) def equals(self, o: object) -> bool: if self == o: @@ -98,22 +103,21 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasPDUReadVariableResponseBuilder: block: List[int] - def build(self,byte_length: int , pairing_key ) -> UmasPDUReadVariableResponse: - umas_pduread_variable_response: UmasPDUReadVariableResponse = UmasPDUReadVariableResponse(byte_length , pairing_key , self.block ) + def build(self, byte_length: int, pairing_key) -> UmasPDUReadVariableResponse: + umas_pduread_variable_response: UmasPDUReadVariableResponse = ( + UmasPDUReadVariableResponse(byte_length, pairing_key, self.block) + ) return umas_pduread_variable_response - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableRequest.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableRequest.py index f1260fa22aa..cd4cb879307 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableRequest.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableRequest.py @@ -23,7 +23,9 @@ from plc4py.api.exceptions.exceptions import SerializationException from plc4py.api.messages.PlcMessage import PlcMessage from plc4py.protocols.umas.readwrite.UmasPDUItem import UmasPDUItem -from plc4py.protocols.umas.readwrite.VariableWriteRequestReference import VariableWriteRequestReference +from plc4py.protocols.umas.readwrite.VariableWriteRequestReference import ( + VariableWriteRequestReference, +) from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer from plc4py.utils.GenericTypes import ByteOrder @@ -31,7 +33,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUWriteVariableRequest(UmasPDUItem): crc: int @@ -43,23 +46,22 @@ class UmasPDUWriteVariableRequest(UmasPDUItem): umas_function_key: ClassVar[int] = 0x23 umas_request_function_key: ClassVar[int] = 0 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUWriteVariableRequest") # Simple Field (crc) - write_buffer.write_unsigned_int(self.crc,bit_length=32,logical_name="crc") + write_buffer.write_unsigned_int(self.crc, bit_length=32, logical_name="crc") # Simple Field (variableCount) - write_buffer.write_unsigned_byte(self.variable_count,bit_length=8,logical_name="variableCount") + write_buffer.write_unsigned_byte( + self.variable_count, bit_length=8, logical_name="variableCount" + ) # Array Field (variables) write_buffer.write_complex_array(self.variables, logical_name="variables") write_buffer.pop_context("UmasPDUWriteVariableRequest") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -78,13 +80,12 @@ def length_in_bits(self) -> int: for element in self.variables: length_in_bits += element.length_in_bits() - - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUWriteVariableRequest") if isinstance(umas_request_function_key, str): @@ -92,21 +93,34 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - crc: int = read_buffer.read_unsigned_int(logical_name="crc", bit_length=32, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - variable_count: int = read_buffer.read_unsigned_byte(logical_name="variable_count", bit_length=8, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) - - - - variables: List[Any] = read_buffer.read_array_field(logical_name="variables", read_function=VariableWriteRequestReference.static_parse, count=variable_count, byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + crc: int = read_buffer.read_unsigned_int( + logical_name="crc", + bit_length=32, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + variable_count: int = read_buffer.read_unsigned_byte( + logical_name="variable_count", + bit_length=8, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) + + variables: List[Any] = read_buffer.read_array_field( + logical_name="variables", + read_function=VariableWriteRequestReference.static_parse, + count=variable_count, + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUWriteVariableRequest") # Create the instance - return UmasPDUWriteVariableRequestBuilder(crc, variable_count, variables ) - + return UmasPDUWriteVariableRequestBuilder(crc, variable_count, variables) def equals(self, o: object) -> bool: if self == o: @@ -116,20 +130,26 @@ def equals(self, o: object) -> bool: return False that: UmasPDUWriteVariableRequest = UmasPDUWriteVariableRequest(o) - return (self.crc == that.crc) and (self.variable_count == that.variable_count) and (self.variables == that.variables) and super().equals(that) and True + return ( + (self.crc == that.crc) + and (self.variable_count == that.variable_count) + and (self.variables == that.variables) + and super().equals(that) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass @@ -138,9 +158,10 @@ class UmasPDUWriteVariableRequestBuilder: variable_count: int variables: List[VariableWriteRequestReference] - def build(self,byte_length: int , pairing_key ) -> UmasPDUWriteVariableRequest: - umas_pduwrite_variable_request: UmasPDUWriteVariableRequest = UmasPDUWriteVariableRequest(byte_length , pairing_key , self.crc, self.variable_count, self.variables ) + def build(self, byte_length: int, pairing_key) -> UmasPDUWriteVariableRequest: + umas_pduwrite_variable_request: UmasPDUWriteVariableRequest = ( + UmasPDUWriteVariableRequest( + byte_length, pairing_key, self.crc, self.variable_count, self.variables + ) + ) return umas_pduwrite_variable_request - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableResponse.py b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableResponse.py index 9bf92d66d2f..fa0fcdaf033 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableResponse.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasPDUWriteVariableResponse.py @@ -30,7 +30,8 @@ from typing import ClassVar from typing import List import math - + + @dataclass class UmasPDUWriteVariableResponse(UmasPDUItem): block: List[int] @@ -40,17 +41,16 @@ class UmasPDUWriteVariableResponse(UmasPDUItem): umas_function_key: ClassVar[int] = 0xFE umas_request_function_key: ClassVar[int] = 0x23 - - def serialize_umas_pduitem_child(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasPDUWriteVariableResponse") # Array Field (block) - write_buffer.write_simple_array(self.block, write_buffer.write_unsigned_byte, logical_name="block") + write_buffer.write_simple_array( + self.block, write_buffer.write_unsigned_byte, logical_name="block" + ) write_buffer.pop_context("UmasPDUWriteVariableResponse") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -62,12 +62,12 @@ def length_in_bits(self) -> int: if self.block is not None: length_in_bits += 8 * len(self.block) - return length_in_bits - @staticmethod - def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int): + def static_parse_builder( + read_buffer: ReadBuffer, umas_request_function_key: int, byte_length: int + ): read_buffer.push_context("UmasPDUWriteVariableResponse") if isinstance(umas_request_function_key, str): @@ -75,13 +75,18 @@ def static_parse_builder(read_buffer: ReadBuffer, umas_request_function_key: int if isinstance(byte_length, str): byte_length = int(byte_length) - - block: List[Any] = read_buffer.read_array_field(logical_name="block", read_function=read_buffer.read_unsigned_byte, count=byte_length- int(2), byte_order=ByteOrder.LITTLE_ENDIAN, umas_request_function_key=umas_request_function_key, byte_length=byte_length) + block: List[Any] = read_buffer.read_array_field( + logical_name="block", + read_function=read_buffer.read_unsigned_byte, + count=byte_length - int(2), + byte_order=ByteOrder.LITTLE_ENDIAN, + umas_request_function_key=umas_request_function_key, + byte_length=byte_length, + ) read_buffer.pop_context("UmasPDUWriteVariableResponse") # Create the instance - return UmasPDUWriteVariableResponseBuilder(block ) - + return UmasPDUWriteVariableResponseBuilder(block) def equals(self, o: object) -> bool: if self == o: @@ -98,22 +103,21 @@ def hash_code(self) -> int: def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" @dataclass class UmasPDUWriteVariableResponseBuilder: block: List[int] - def build(self,byte_length: int , pairing_key ) -> UmasPDUWriteVariableResponse: - umas_pduwrite_variable_response: UmasPDUWriteVariableResponse = UmasPDUWriteVariableResponse(byte_length , pairing_key , self.block ) + def build(self, byte_length: int, pairing_key) -> UmasPDUWriteVariableResponse: + umas_pduwrite_variable_response: UmasPDUWriteVariableResponse = ( + UmasPDUWriteVariableResponse(byte_length, pairing_key, self.block) + ) return umas_pduwrite_variable_response - - - diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasUDTDefinition.py b/plc4py/plc4py/protocols/umas/readwrite/UmasUDTDefinition.py index 318b94f7a3d..9ecc4c7725a 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasUDTDefinition.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasUDTDefinition.py @@ -26,37 +26,48 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass -class UmasUDTDefinition(): +class UmasUDTDefinition: data_type: int offset: int unknown5: int unknown4: int value: str - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasUDTDefinition") # Simple Field (dataType) - write_buffer.write_unsigned_short(self.data_type,bit_length=16,logical_name="dataType") + write_buffer.write_unsigned_short( + self.data_type, bit_length=16, logical_name="dataType" + ) # Simple Field (offset) - write_buffer.write_unsigned_short(self.offset,bit_length=16,logical_name="offset") + write_buffer.write_unsigned_short( + self.offset, bit_length=16, logical_name="offset" + ) # Simple Field (unknown5) - write_buffer.write_unsigned_short(self.unknown5,bit_length=16,logical_name="unknown5") + write_buffer.write_unsigned_short( + self.unknown5, bit_length=16, logical_name="unknown5" + ) # Simple Field (unknown4) - write_buffer.write_unsigned_short(self.unknown4,bit_length=16,logical_name="unknown4") + write_buffer.write_unsigned_short( + self.unknown4, bit_length=16, logical_name="unknown4" + ) # Manual Field (value) - write_buffer.write_manual(write_function=lambda : StaticHelper.serialize_terminated_string(write_buffer, self.value, 1), logical_name="value") + write_buffer.write_manual( + write_function=lambda: StaticHelper.serialize_terminated_string( + write_buffer, self.value, 1 + ), + logical_name="value", + ) write_buffer.pop_context("UmasUDTDefinition") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -77,46 +88,46 @@ def length_in_bits(self) -> int: length_in_bits += 16 # Manual Field (value) - length_in_bits += (self.string_length* int(8)) + length_in_bits += self.string_length * int(8) return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return UmasUDTDefinition.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("UmasUDTDefinition") + data_type: int = read_buffer.read_unsigned_short( + logical_name="data_type", bit_length=16 + ) + offset: int = read_buffer.read_unsigned_short( + logical_name="offset", bit_length=16 + ) - data_type: int = read_buffer.read_unsigned_short(logical_name="data_type", bit_length=16) - - - - offset: int = read_buffer.read_unsigned_short(logical_name="offset", bit_length=16) - + unknown5: int = read_buffer.read_unsigned_short( + logical_name="unknown5", bit_length=16 + ) + unknown4: int = read_buffer.read_unsigned_short( + logical_name="unknown4", bit_length=16 + ) - unknown5: int = read_buffer.read_unsigned_short(logical_name="unknown5", bit_length=16) - - - - unknown4: int = read_buffer.read_unsigned_short(logical_name="unknown4", bit_length=16) - - - - value = read_buffer.read_manual(read_function=lambda : StaticHelper.parse_terminated_string(read_buffer, 1), logical_name="value") + value = read_buffer.read_manual( + read_function=lambda: StaticHelper.parse_terminated_string(read_buffer, 1), + logical_name="value", + ) read_buffer.pop_context("UmasUDTDefinition") # Create the instance - _umas_udtdefinition: UmasUDTDefinition = UmasUDTDefinition(data_type, offset, unknown5, unknown4, value ) + _umas_udtdefinition: UmasUDTDefinition = UmasUDTDefinition( + data_type, offset, unknown5, unknown4, value + ) return _umas_udtdefinition - def equals(self, o: object) -> bool: if self == o: return True @@ -125,21 +136,24 @@ def equals(self, o: object) -> bool: return False that: UmasUDTDefinition = UmasUDTDefinition(o) - return (self.data_type == that.data_type) and (self.offset == that.offset) and (self.unknown5 == that.unknown5) and (self.unknown4 == that.unknown4) and (self.value == that.value) and True + return ( + (self.data_type == that.data_type) + and (self.offset == that.offset) + and (self.unknown5 == that.unknown5) + and (self.unknown4 == that.unknown4) + and (self.value == that.value) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/UmasUnlocatedVariableReference.py b/plc4py/plc4py/protocols/umas/readwrite/UmasUnlocatedVariableReference.py index 5002d76648f..f6b685bfc18 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/UmasUnlocatedVariableReference.py +++ b/plc4py/plc4py/protocols/umas/readwrite/UmasUnlocatedVariableReference.py @@ -26,9 +26,10 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass -class UmasUnlocatedVariableReference(): +class UmasUnlocatedVariableReference: data_type: int unknown1: int block: int @@ -38,37 +39,53 @@ class UmasUnlocatedVariableReference(): string_length: int value: str - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("UmasUnlocatedVariableReference") # Simple Field (dataType) - write_buffer.write_unsigned_byte(self.data_type,bit_length=8,logical_name="dataType") + write_buffer.write_unsigned_byte( + self.data_type, bit_length=8, logical_name="dataType" + ) # Simple Field (unknown1) - write_buffer.write_unsigned_byte(self.unknown1,bit_length=8,logical_name="unknown1") + write_buffer.write_unsigned_byte( + self.unknown1, bit_length=8, logical_name="unknown1" + ) # Simple Field (block) - write_buffer.write_unsigned_short(self.block,bit_length=16,logical_name="block") + write_buffer.write_unsigned_short( + self.block, bit_length=16, logical_name="block" + ) # Simple Field (offset) - write_buffer.write_unsigned_byte(self.offset,bit_length=8,logical_name="offset") + write_buffer.write_unsigned_byte( + self.offset, bit_length=8, logical_name="offset" + ) # Simple Field (unknown5) - write_buffer.write_unsigned_byte(self.unknown5,bit_length=8,logical_name="unknown5") + write_buffer.write_unsigned_byte( + self.unknown5, bit_length=8, logical_name="unknown5" + ) # Simple Field (unknown4) - write_buffer.write_unsigned_short(self.unknown4,bit_length=16,logical_name="unknown4") + write_buffer.write_unsigned_short( + self.unknown4, bit_length=16, logical_name="unknown4" + ) # Simple Field (stringLength) - write_buffer.write_unsigned_short(self.string_length,bit_length=16,logical_name="stringLength") + write_buffer.write_unsigned_short( + self.string_length, bit_length=16, logical_name="stringLength" + ) # Manual Field (value) - write_buffer.write_manual(write_function=lambda : StaticHelper.serialize_terminated_string(write_buffer, self.value, self.string_length), logical_name="value") + write_buffer.write_manual( + write_function=lambda: StaticHelper.serialize_terminated_string( + write_buffer, self.value, self.string_length + ), + logical_name="value", + ) write_buffer.pop_context("UmasUnlocatedVariableReference") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -98,58 +115,69 @@ def length_in_bits(self) -> int: length_in_bits += 16 # Manual Field (value) - length_in_bits += (self.string_length* int(8)) + length_in_bits += self.string_length * int(8) return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return UmasUnlocatedVariableReference.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("UmasUnlocatedVariableReference") + data_type: int = read_buffer.read_unsigned_byte( + logical_name="data_type", bit_length=8 + ) + unknown1: int = read_buffer.read_unsigned_byte( + logical_name="unknown1", bit_length=8 + ) - data_type: int = read_buffer.read_unsigned_byte(logical_name="data_type", bit_length=8) - - - - unknown1: int = read_buffer.read_unsigned_byte(logical_name="unknown1", bit_length=8) - - - - block: int = read_buffer.read_unsigned_short(logical_name="block", bit_length=16) - + block: int = read_buffer.read_unsigned_short( + logical_name="block", bit_length=16 + ) + offset: int = read_buffer.read_unsigned_byte( + logical_name="offset", bit_length=8 + ) - offset: int = read_buffer.read_unsigned_byte(logical_name="offset", bit_length=8) + unknown5: int = read_buffer.read_unsigned_byte( + logical_name="unknown5", bit_length=8 + ) + unknown4: int = read_buffer.read_unsigned_short( + logical_name="unknown4", bit_length=16 + ) + string_length: int = read_buffer.read_unsigned_short( + logical_name="string_length", bit_length=16 + ) - unknown5: int = read_buffer.read_unsigned_byte(logical_name="unknown5", bit_length=8) - - - - unknown4: int = read_buffer.read_unsigned_short(logical_name="unknown4", bit_length=16) - - - - string_length: int = read_buffer.read_unsigned_short(logical_name="string_length", bit_length=16) - - - - value = read_buffer.read_manual(read_function=lambda : StaticHelper.parse_terminated_string(read_buffer, string_length), logical_name="value") + value = read_buffer.read_manual( + read_function=lambda: StaticHelper.parse_terminated_string( + read_buffer, string_length + ), + logical_name="value", + ) read_buffer.pop_context("UmasUnlocatedVariableReference") # Create the instance - _umas_unlocated_variable_reference: UmasUnlocatedVariableReference = UmasUnlocatedVariableReference(data_type, unknown1, block, offset, unknown5, unknown4, string_length, value ) + _umas_unlocated_variable_reference: UmasUnlocatedVariableReference = ( + UmasUnlocatedVariableReference( + data_type, + unknown1, + block, + offset, + unknown5, + unknown4, + string_length, + value, + ) + ) return _umas_unlocated_variable_reference - def equals(self, o: object) -> bool: if self == o: return True @@ -158,21 +186,27 @@ def equals(self, o: object) -> bool: return False that: UmasUnlocatedVariableReference = UmasUnlocatedVariableReference(o) - return (self.data_type == that.data_type) and (self.unknown1 == that.unknown1) and (self.block == that.block) and (self.offset == that.offset) and (self.unknown5 == that.unknown5) and (self.unknown4 == that.unknown4) and (self.string_length == that.string_length) and (self.value == that.value) and True + return ( + (self.data_type == that.data_type) + and (self.unknown1 == that.unknown1) + and (self.block == that.block) + and (self.offset == that.offset) + and (self.unknown5 == that.unknown5) + and (self.unknown4 == that.unknown4) + and (self.string_length == that.string_length) + and (self.value == that.value) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/VariableReadRequestReference.py b/plc4py/plc4py/protocols/umas/readwrite/VariableReadRequestReference.py index 4a4d40173ed..b7ab5162792 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/VariableReadRequestReference.py +++ b/plc4py/plc4py/protocols/umas/readwrite/VariableReadRequestReference.py @@ -25,9 +25,10 @@ from plc4py.spi.generation.ReadBuffer import ReadBuffer from plc4py.spi.generation.WriteBuffer import WriteBuffer import math - + + @dataclass -class VariableReadRequestReference(): +class VariableReadRequestReference: is_array: int data_size_index: int block: int @@ -36,36 +37,45 @@ class VariableReadRequestReference(): array_length: int UNKNOWN1: int = 0x01 - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("VariableReadRequestReference") # Simple Field (isArray) - write_buffer.write_unsigned_byte(self.is_array,bit_length=4,logical_name="isArray") + write_buffer.write_unsigned_byte( + self.is_array, bit_length=4, logical_name="isArray" + ) # Simple Field (dataSizeIndex) - write_buffer.write_unsigned_byte(self.data_size_index,bit_length=4,logical_name="dataSizeIndex") + write_buffer.write_unsigned_byte( + self.data_size_index, bit_length=4, logical_name="dataSizeIndex" + ) # Simple Field (block) - write_buffer.write_unsigned_short(self.block,bit_length=16,logical_name="block") + write_buffer.write_unsigned_short( + self.block, bit_length=16, logical_name="block" + ) # Const Field (unknown1) write_buffer.write_unsigned_byte(self.UNKNOWN1, logical_name="unknown1") # Simple Field (baseOffset) - write_buffer.write_unsigned_short(self.base_offset,bit_length=16,logical_name="baseOffset") + write_buffer.write_unsigned_short( + self.base_offset, bit_length=16, logical_name="baseOffset" + ) # Simple Field (offset) - write_buffer.write_unsigned_byte(self.offset,bit_length=8,logical_name="offset") + write_buffer.write_unsigned_byte( + self.offset, bit_length=8, logical_name="offset" + ) # Optional Field (arrayLength) (Can be skipped, if the value is null) if self.is_array: - write_buffer.write_unsigned_short(self.array_length, logical_name="arrayLength") + write_buffer.write_unsigned_short( + self.array_length, logical_name="arrayLength" + ) write_buffer.pop_context("VariableReadRequestReference") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -95,53 +105,51 @@ def length_in_bits(self) -> int: if self.is_array: length_in_bits += 16 - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return VariableReadRequestReference.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("VariableReadRequestReference") + is_array: int = read_buffer.read_unsigned_byte( + logical_name="is_array", bit_length=4 + ) + data_size_index: int = read_buffer.read_unsigned_byte( + logical_name="data_size_index", bit_length=4 + ) - is_array: int = read_buffer.read_unsigned_byte(logical_name="is_array", bit_length=4) - - - - data_size_index: int = read_buffer.read_unsigned_byte(logical_name="data_size_index", bit_length=4) - - - - block: int = read_buffer.read_unsigned_short(logical_name="block", bit_length=16) - - + block: int = read_buffer.read_unsigned_short( + logical_name="block", bit_length=16 + ) UNKNOWN1: int = read_buffer.read_unsigned_byte(logical_name="unknown1") - base_offset: int = read_buffer.read_unsigned_short(logical_name="base_offset", bit_length=16) - - - - offset: int = read_buffer.read_unsigned_byte(logical_name="offset", bit_length=8) - + base_offset: int = read_buffer.read_unsigned_short( + logical_name="base_offset", bit_length=16 + ) + offset: int = read_buffer.read_unsigned_byte( + logical_name="offset", bit_length=8 + ) array_length: int = None if is_array: - array_length = read_buffer.read_unsigned_short(logical_name="array_length") + array_length = read_buffer.read_unsigned_short(logical_name="array_length") read_buffer.pop_context("VariableReadRequestReference") # Create the instance - _variable_read_request_reference: VariableReadRequestReference = VariableReadRequestReference(is_array, data_size_index, block, base_offset, offset, array_length ) + _variable_read_request_reference: VariableReadRequestReference = ( + VariableReadRequestReference( + is_array, data_size_index, block, base_offset, offset, array_length + ) + ) return _variable_read_request_reference - def equals(self, o: object) -> bool: if self == o: return True @@ -150,21 +158,25 @@ def equals(self, o: object) -> bool: return False that: VariableReadRequestReference = VariableReadRequestReference(o) - return (self.is_array == that.is_array) and (self.data_size_index == that.data_size_index) and (self.block == that.block) and (self.base_offset == that.base_offset) and (self.offset == that.offset) and (self.array_length == that.array_length) and True + return ( + (self.is_array == that.is_array) + and (self.data_size_index == that.data_size_index) + and (self.block == that.block) + and (self.base_offset == that.base_offset) + and (self.offset == that.offset) + and (self.array_length == that.array_length) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n" diff --git a/plc4py/plc4py/protocols/umas/readwrite/VariableWriteRequestReference.py b/plc4py/plc4py/protocols/umas/readwrite/VariableWriteRequestReference.py index ab415da1140..09552e23c5a 100644 --- a/plc4py/plc4py/protocols/umas/readwrite/VariableWriteRequestReference.py +++ b/plc4py/plc4py/protocols/umas/readwrite/VariableWriteRequestReference.py @@ -27,9 +27,10 @@ from typing import Any from typing import List import math - + + @dataclass -class VariableWriteRequestReference(): +class VariableWriteRequestReference: is_array: int data_size_index: int block: int @@ -39,39 +40,48 @@ class VariableWriteRequestReference(): record_data: List[int] UNKNOWN1: int = 0x01 - - def serialize(self, write_buffer: WriteBuffer): write_buffer.push_context("VariableWriteRequestReference") # Simple Field (isArray) - write_buffer.write_unsigned_byte(self.is_array,bit_length=4,logical_name="isArray") + write_buffer.write_unsigned_byte( + self.is_array, bit_length=4, logical_name="isArray" + ) # Simple Field (dataSizeIndex) - write_buffer.write_unsigned_byte(self.data_size_index,bit_length=4,logical_name="dataSizeIndex") + write_buffer.write_unsigned_byte( + self.data_size_index, bit_length=4, logical_name="dataSizeIndex" + ) # Simple Field (block) - write_buffer.write_unsigned_short(self.block,bit_length=16,logical_name="block") + write_buffer.write_unsigned_short( + self.block, bit_length=16, logical_name="block" + ) # Const Field (unknown1) write_buffer.write_unsigned_byte(self.UNKNOWN1, logical_name="unknown1") # Simple Field (baseOffset) - write_buffer.write_unsigned_short(self.base_offset,bit_length=16,logical_name="baseOffset") + write_buffer.write_unsigned_short( + self.base_offset, bit_length=16, logical_name="baseOffset" + ) # Simple Field (offset) - write_buffer.write_unsigned_byte(self.offset,bit_length=8,logical_name="offset") + write_buffer.write_unsigned_byte( + self.offset, bit_length=8, logical_name="offset" + ) # Optional Field (arrayLength) (Can be skipped, if the value is null) if self.is_array: - write_buffer.write_unsigned_short(self.array_length, logical_name="arrayLength") + write_buffer.write_unsigned_short( + self.array_length, logical_name="arrayLength" + ) # Array Field (recordData) write_buffer.write_byte_array(self.record_data, logical_name="record_data") write_buffer.pop_context("VariableWriteRequestReference") - def length_in_bytes(self) -> int: return int(math.ceil(float(self.length_in_bits() / 8.0))) @@ -101,60 +111,71 @@ def length_in_bits(self) -> int: if self.is_array: length_in_bits += 16 - # Array field if self.record_data is not None: length_in_bits += 8 * len(self.record_data) - return length_in_bits - @staticmethod def static_parse(read_buffer: ReadBuffer, **kwargs): return VariableWriteRequestReference.static_parse_context(read_buffer) - @staticmethod def static_parse_context(read_buffer: ReadBuffer): read_buffer.push_context("VariableWriteRequestReference") + is_array: int = read_buffer.read_unsigned_byte( + logical_name="is_array", bit_length=4 + ) + data_size_index: int = read_buffer.read_unsigned_byte( + logical_name="data_size_index", bit_length=4 + ) - is_array: int = read_buffer.read_unsigned_byte(logical_name="is_array", bit_length=4) - - - - data_size_index: int = read_buffer.read_unsigned_byte(logical_name="data_size_index", bit_length=4) - - - - block: int = read_buffer.read_unsigned_short(logical_name="block", bit_length=16) - - + block: int = read_buffer.read_unsigned_short( + logical_name="block", bit_length=16 + ) UNKNOWN1: int = read_buffer.read_unsigned_byte(logical_name="unknown1") - base_offset: int = read_buffer.read_unsigned_short(logical_name="base_offset", bit_length=16) - - - - offset: int = read_buffer.read_unsigned_byte(logical_name="offset", bit_length=8) - + base_offset: int = read_buffer.read_unsigned_short( + logical_name="base_offset", bit_length=16 + ) + offset: int = read_buffer.read_unsigned_byte( + logical_name="offset", bit_length=8 + ) array_length: int = None if is_array: - array_length = read_buffer.read_unsigned_short(logical_name="array_length") - - record_data: List[Any] = read_buffer.read_array_field(logical_name="recordData", read_function=read_buffer.read_byte, count=data_size_index* array_length if bool((is_array) == ((1))) else data_size_index) + array_length = read_buffer.read_unsigned_short(logical_name="array_length") + + record_data: List[Any] = read_buffer.read_array_field( + logical_name="recordData", + read_function=read_buffer.read_byte, + count=( + data_size_index * array_length + if bool((is_array) == ((1))) + else data_size_index + ), + ) read_buffer.pop_context("VariableWriteRequestReference") # Create the instance - _variable_write_request_reference: VariableWriteRequestReference = VariableWriteRequestReference(is_array, data_size_index, block, base_offset, offset, array_length, record_data ) + _variable_write_request_reference: VariableWriteRequestReference = ( + VariableWriteRequestReference( + is_array, + data_size_index, + block, + base_offset, + offset, + array_length, + record_data, + ) + ) return _variable_write_request_reference - def equals(self, o: object) -> bool: if self == o: return True @@ -163,21 +184,26 @@ def equals(self, o: object) -> bool: return False that: VariableWriteRequestReference = VariableWriteRequestReference(o) - return (self.is_array == that.is_array) and (self.data_size_index == that.data_size_index) and (self.block == that.block) and (self.base_offset == that.base_offset) and (self.offset == that.offset) and (self.array_length == that.array_length) and (self.record_data == that.record_data) and True + return ( + (self.is_array == that.is_array) + and (self.data_size_index == that.data_size_index) + and (self.block == that.block) + and (self.base_offset == that.base_offset) + and (self.offset == that.offset) + and (self.array_length == that.array_length) + and (self.record_data == that.record_data) + and True + ) def hash_code(self) -> int: return hash(self) def __str__(self) -> str: pass - #write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) - #try: + # write_buffer_box_based: WriteBufferBoxBased = WriteBufferBoxBased(True, True) + # try: # write_buffer_box_based.writeSerializable(self) - #except SerializationException as e: + # except SerializationException as e: # raise PlcRuntimeException(e) - #return "\n" + str(write_buffer_box_based.get_box()) + "\n" - - - - + # return "\n" + str(write_buffer_box_based.get_box()) + "\n"