You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by hu...@apache.org on 2022/11/16 14:17:42 UTC
[plc4x] branch plc4py-codegen updated: feat(plc4py/codegen): All complex types are now syntactically correct
This is an automated email from the ASF dual-hosted git repository.
hutcheb pushed a commit to branch plc4py-codegen
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/plc4py-codegen by this push:
new 95fd626c6e feat(plc4py/codegen): All complex types are now syntactically correct
95fd626c6e is described below
commit 95fd626c6e2c2f409241160eea21ce94b9921d5c
Author: Ben Hutcheson <be...@gmail.com>
AuthorDate: Wed Nov 16 08:16:28 2022 -0600
feat(plc4py/codegen): All complex types are now syntactically correct
---
.../python/PythonLanguageTemplateHelper.java | 17 +-
.../python/complex-type-template.python.ftlh | 95 +++------
.../protocols/modbus/readwrite/ModbusAsciiADU.py | 92 +++++---
.../protocols/modbus/readwrite/ModbusConstants.py | 31 ++-
.../readwrite/ModbusDeviceInformationObject.py | 57 +++--
.../modbus/readwrite/ModbusPDUDiagnosticRequest.py | 65 +++---
.../readwrite/ModbusPDUDiagnosticResponse.py | 65 +++---
.../protocols/modbus/readwrite/ModbusPDUError.py | 69 +++---
.../ModbusPDUGetComEventCounterRequest.py | 49 +++--
.../ModbusPDUGetComEventCounterResponse.py | 69 +++---
.../readwrite/ModbusPDUGetComEventLogRequest.py | 49 +++--
.../readwrite/ModbusPDUGetComEventLogResponse.py | 109 ++++++----
.../ModbusPDUMaskWriteHoldingRegisterRequest.py | 80 ++++---
.../ModbusPDUMaskWriteHoldingRegisterResponse.py | 80 ++++---
.../modbus/readwrite/ModbusPDUReadCoilsRequest.py | 73 ++++---
.../modbus/readwrite/ModbusPDUReadCoilsResponse.py | 71 ++++---
.../ModbusPDUReadDeviceIdentificationRequest.py | 102 +++++----
.../ModbusPDUReadDeviceIdentificationResponse.py | 236 ++++++++++++++-------
.../ModbusPDUReadDiscreteInputsRequest.py | 73 ++++---
.../ModbusPDUReadDiscreteInputsResponse.py | 75 +++----
.../ModbusPDUReadExceptionStatusRequest.py | 53 ++---
.../ModbusPDUReadExceptionStatusResponse.py | 57 ++---
.../readwrite/ModbusPDUReadFifoQueueRequest.py | 65 +++---
.../readwrite/ModbusPDUReadFifoQueueResponse.py | 87 ++++----
.../readwrite/ModbusPDUReadFileRecordRequest.py | 80 +++----
.../ModbusPDUReadFileRecordRequestItem.py | 72 ++++---
.../readwrite/ModbusPDUReadFileRecordResponse.py | 80 +++----
.../ModbusPDUReadFileRecordResponseItem.py | 67 +++---
.../ModbusPDUReadHoldingRegistersRequest.py | 77 ++++---
.../ModbusPDUReadHoldingRegistersResponse.py | 75 +++----
.../ModbusPDUReadInputRegistersRequest.py | 73 ++++---
.../ModbusPDUReadInputRegistersResponse.py | 75 +++----
...sPDUReadWriteMultipleHoldingRegistersRequest.py | 146 ++++++++-----
...PDUReadWriteMultipleHoldingRegistersResponse.py | 73 ++++---
.../readwrite/ModbusPDUReportServerIdRequest.py | 49 +++--
.../readwrite/ModbusPDUReportServerIdResponse.py | 71 ++++---
.../readwrite/ModbusPDUWriteFileRecordRequest.py | 80 +++----
.../ModbusPDUWriteFileRecordRequestItem.py | 94 +++++---
.../readwrite/ModbusPDUWriteFileRecordResponse.py | 80 +++----
.../ModbusPDUWriteFileRecordResponseItem.py | 94 +++++---
.../ModbusPDUWriteMultipleCoilsRequest.py | 104 +++++----
.../ModbusPDUWriteMultipleCoilsResponse.py | 77 ++++---
...odbusPDUWriteMultipleHoldingRegistersRequest.py | 102 +++++----
...dbusPDUWriteMultipleHoldingRegistersResponse.py | 75 ++++---
.../readwrite/ModbusPDUWriteSingleCoilRequest.py | 61 +++---
.../readwrite/ModbusPDUWriteSingleCoilResponse.py | 61 +++---
.../ModbusPDUWriteSingleRegisterRequest.py | 65 +++---
.../ModbusPDUWriteSingleRegisterResponse.py | 65 +++---
.../protocols/modbus/readwrite/ModbusRtuADU.py | 94 ++++----
.../protocols/modbus/readwrite/ModbusTcpADU.py | 120 +++++++----
50 files changed, 2246 insertions(+), 1683 deletions(-)
diff --git a/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java b/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java
index ab67d817f4..caa0091c81 100644
--- a/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java
+++ b/code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java
@@ -109,7 +109,8 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if (typeReference.isArrayTypeReference()) {
final ArrayTypeReference arrayTypeReference = (ArrayTypeReference) typeReference;
TypeReference elementTypeReference = arrayTypeReference.getElementTypeReference();
- return "[]" + getLanguageTypeNameForTypeReference(elementTypeReference);
+ emitRequiredImport("from typing import List");
+ return "List[" + getLanguageTypeNameForTypeReference(elementTypeReference) + "]";
}
if (typeReference.isNonSimpleTypeReference()) {
emitRequiredImport("from plc4py.protocols." + protocolName + "." + flavorName.replace("-", "") + "." + typeReference.asNonSimpleTypeReference().orElseThrow().getName() + " import " + typeReference.asNonSimpleTypeReference().orElseThrow().getName());
@@ -393,7 +394,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if (typeReference.isEnumTypeReference()) {
final String languageTypeName = getLanguageTypeNameForTypeReference(typeReference);
final SimpleTypeReference enumBaseTypeReference = getEnumBaseTypeReference(typeReference);
- return "DataReaderEnumDefault<>(" + languageTypeName + "::" + resolverMethod + ", " + getDataReaderCall(enumBaseTypeReference) + ")";
+ return "DataReaderEnumDefault(" + languageTypeName + "." + resolverMethod + ", " + getDataReaderCall(enumBaseTypeReference) + ")";
} else if (typeReference.isArrayTypeReference()) {
final ArrayTypeReference arrayTypeReference = typeReference.asArrayTypeReference().orElseThrow();
return getDataReaderCall(arrayTypeReference.getElementTypeReference(), resolverMethod);
@@ -418,13 +419,13 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
Term paramTerm = paramTerms.get(i);
final TypeReference argumentType = getArgumentType(complexTypeReference, i);
paramsString
- .append(", (")
+ .append(", ")
.append(getLanguageTypeNameForTypeReference(argumentType, true))
- .append(") (")
+ .append("(")
.append(toParseExpression(null, argumentType, paramTerm, null))
.append(")");
}
- return "DataReaderComplexDefault<>(() -> " + parserCallString + ".staticParse(readBuffer" + paramsString + "), readBuffer)";
+ return "DataReaderComplexDefault(" + parserCallString + ".staticParse(readBuffer" + paramsString + "), readBuffer)";
} else {
throw new IllegalStateException("What is this type? " + typeReference);
}
@@ -477,7 +478,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
final ArrayTypeReference arrayTypeReference = typeReference.asArrayTypeReference().orElseThrow();
return getDataWriterCall(arrayTypeReference.getElementTypeReference(), fieldName);
} else if (typeReference.isComplexTypeReference()) {
- return "DataWriterComplexDefault<>(writeBuffer)";
+ return "DataWriterComplexDefault(writeBuffer)";
} else {
throw new IllegalStateException("What is this type? " + typeReference);
}
@@ -494,7 +495,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
} else {
outputTypeReference = getEnumFieldSimpleTypeReference(typeReference.asNonSimpleTypeReference().orElseThrow(), attributeName);
}
- return "DataWriterEnumDefault<>(" + languageTypeName + "::get" + StringUtils.capitalize(attributeName) + ", " + languageTypeName + "::name, " + getDataWriterCall(outputTypeReference, fieldName) + ")";
+ return "DataWriterEnumDefault(" + languageTypeName + ".get" + StringUtils.capitalize(attributeName) + ", " + languageTypeName + ".name, " + getDataWriterCall(outputTypeReference, fieldName) + ")";
}
public String getDataWriterCall(SimpleTypeReference simpleTypeReference) {
@@ -1181,7 +1182,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
return tracer + variableLiteralName + "()" + ((variableLiteral.getIndex().isPresent() ? ".get(" + variableLiteral.getIndex().orElseThrow() + ")" : "") +
variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse(""));
}
- return tracer + "get" + WordUtils.capitalize(variableLiteralName) + "()" + ((variableLiteral.getIndex().isPresent() ? ".get(" + variableLiteral.getIndex().orElseThrow() + ")" : "") +
+ return tracer + "self.get" + WordUtils.capitalize(variableLiteralName) + "()" + ((variableLiteral.getIndex().isPresent() ? ".get(" + variableLiteral.getIndex().orElseThrow() + ")" : "") +
variableLiteral.getChild().map(child -> "." + toVariableExpressionRest(field, resultType, child)).orElse(""));
}
diff --git a/code-generation/language-python/src/main/resources/templates/python/complex-type-template.python.ftlh b/code-generation/language-python/src/main/resources/templates/python/complex-type-template.python.ftlh
index 957a08e851..4a199ffe98 100644
--- a/code-generation/language-python/src/main/resources/templates/python/complex-type-template.python.ftlh
+++ b/code-generation/language-python/src/main/resources/templates/python/complex-type-template.python.ftlh
@@ -115,7 +115,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#if discriminatorType.isEnumTypeReference()>
return ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(null, discriminatorType, discriminatorValue, parserArguments)}
<#else>
- return (${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(null, discriminatorType, discriminatorValue, parserArguments)}
+ return ${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}(${helper.toParseExpression(null, discriminatorType, discriminatorValue, parserArguments)})
</#if>
<#else>
return ${helper.getNullValueForTypeReference(discriminatorType)}
@@ -248,7 +248,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign namedField = field.asNamedField().orElseThrow()>
# Const Field (${constField.name})
- <#if typedField.type.isEnumTypeReference()>writeConstField("${constField.name}", ${namedField.name?upper_case}.getValue(), ${helper.getDataWriterCall(helper.getEnumBaseTypeReference(typedField.type), namedField.name)})<#else>writeConstField("${constField.name}", ${namedField.name?upper_case}, ${helper.getDataWriterCall(typedField.type, namedField.name)})</#if>
+ <#if typedField.type.isEnumTypeReference()>writeConstField("${constField.name}", ${namedField.name?upper_case}.getValue(), ${helper.getDataWriterCall(helper.getEnumBaseTypeReference(typedField.type), namedField.name)})<#else>writeConstField("${constField.name}", ${namedField.name?upper_case}, ${helper.getDataWriterCall(typedField.type, namedField.name)})</#if>
<#break>
<#case "discriminator">
<#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
@@ -277,7 +277,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
# Implicit Field (${implicitField.name}) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
<#-- Implicit field values might be used in expressions, in order to avoid problems, we generate a temporary variable with the given name. -->
- ${helper.getLanguageTypeNameForField(field)} ${implicitField.name} = (${helper.getLanguageTypeNameForField(field)}) (${helper.toSerializationExpression(implicitField, implicitField.type, implicitField.serializeExpression, parserArguments)})
+ ${implicitField.name}: ${helper.getLanguageTypeNameForField(field)} = ${helper.getLanguageTypeNameForField(field)}((${helper.toSerializationExpression(implicitField, implicitField.type, implicitField.serializeExpression, parserArguments)}))
writeImplicitField("${namedField.name}", ${implicitField.name}, ${helper.getDataWriterCall(typedField.type, namedField.name)})
<#break>
<#case "manualArray">
@@ -374,10 +374,10 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
# Array field
- if ${arrayField.name} is not None):
+ if self.${arrayField.name} is not None:
<#if arrayElementTypeReference.isSimpleTypeReference()>
<#assign simpleTypeReference = arrayElementTypeReference.asSimpleTypeReference().orElseThrow()>
- lengthInBits += ${simpleTypeReference.sizeInBits} * ${arrayField.name}.<#if arrayElementTypeReference.isByteBased()>length<#else>size()</#if>
+ lengthInBits += ${simpleTypeReference.sizeInBits} * self.${arrayField.name}.<#if arrayElementTypeReference.isByteBased()>length<#else>size()</#if>
<#elseif arrayField.isCountArrayField()>
i: int = 0
<#assign nonSimpleTypeReference = arrayElementTypeReference.asNonSimpleTypeReference().orElseThrow()>
@@ -587,7 +587,8 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#if !field.isCountArrayField() && !field.isLengthArrayField()>
raise ParseException("array fields of type byte only support 'count' and 'length' loop-types.")
</#if>
- ${namedField.name}: byte[] = readBuffer.readByteArray("${namedField.name}", Math.toIntExact(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ <@emitImport import="from typing import List" />
+ ${namedField.name}: List[c_byte] = readBuffer.readByteArray("${namedField.name}", int(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#else>
<#-- If this is a count array, we can directly initialize an array with the given size -->
<#if field.isCountArrayField()>
@@ -653,7 +654,8 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign arrayElementTypeReference = manualArrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
<#if arrayElementTypeReference.isByteBased()>
- ${namedField.name}: byte[] = readManualByteArrayField("${namedField.name}", readBuffer, (byte[] _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (byte) (${helper.toParseExpression(manualArrayField, manualArrayField.type, manualArrayField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ <@emitImport import="from typing import List" />
+ ${namedField.name}: List[c_byte] = readManualByteArrayField("${namedField.name}", readBuffer, lambda _values: bool(${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), lambda : byte(${helper.toParseExpression(manualArrayField, manualArrayField.type, manualArrayField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#else>
${namedField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} = readManualArrayField("${namedField.name}", readBuffer, (${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} _values) -> (boolean) (${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), () -> (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)}) (${helper.toParseExpressi [...]
</#if>
@@ -824,11 +826,11 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
return <@compress single_line=true>
<#if type.propertyFields?has_content>
<#list type.propertyFields as field>
- (get${field.name?cap_first}() == that.get${field.name?cap_first}()) &&
+ (self.get${field.name?cap_first}() == that.get${field.name?cap_first}()) and
</#list>
</#if>
<#if type.parentType.isPresent()>
- super().equals(that) &&
+ super().equals(that) and
</#if>
True</...@compress>
@@ -839,7 +841,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
</#if>
<#if type.propertyFields?has_content>
<#list type.propertyFields as field>
- get${field.name?cap_first}()<#sep>,</#sep>
+ self.get${field.name?cap_first}()<#sep>,</#sep>
</#list>
</#if>
)</...@compress>
@@ -871,76 +873,49 @@ class ${type.name}Builder:
</#if>
<#if type.isDiscriminatedChildTypeDefinition()>
-<@compress single_line=true>
-class ${type.name}Builder(${type.parentType.orElseThrow().name}${type.parentType.orElseThrow().name}Builder:
+@dataclass
+class ${type.name}Builder(${type.parentType.orElseThrow().name}${type.parentType.orElseThrow().name}Builder):
<#if type.propertyFields?has_content>
<#list type.propertyFields as field>
- ${field.name}: ${helper.getLanguageTypeNameForField(field)}
+ ${field.name}: ${helper.getLanguageTypeNameForField(field)}
</#list>
</#if>
<#if filteredParserArguments?has_content>
<#list filteredParserArguments as arg>
- ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}
+ ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}
</#list>
</#if>
<#list reservedFields as reservedField>
reservedField${reservedField?index}: ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)}
</#list>
-</...@compress>
- <@compress single_line=true>
- def ${type.name}Builder(
- <#list type.propertyFields as field>
- ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
+
+ def __post_init__(self):
+ pass
+
+ def build(self,<@compress single_line=true>
+ <#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().propertyFields as field>
+ ${field.name}: ${helper.getLanguageTypeNameForField(field)}<#sep>, </#sep>
</#list>
- <#if filteredParserArguments?has_content>
- <#if type.propertyFields?has_content>, </#if>
- <#list filteredParserArguments as arg>
- ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name}<#sep>, </#sep>
+ <#if filteredParentParserArguments?has_content>
+ <#if type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().propertyFields?has_content>, </#if>
+ <#list filteredParentParserArguments as arg>
+ ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}<#sep>, </#sep>
</#list>
</#if>
- <#if (type.propertyFields?has_content || filteredParentParserArguments?has_content) && reservedFields?has_content>,</#if>
- <#list reservedFields as reservedField>
- ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedField?index}<#sep>, </#sep>
- </#list>
- ):
- </...@compress>
- <#list type.propertyFields as field>
- self.${field.name} = ${field.name}
+ ) -> ${type.name}:</...@compress>
+ ${type.name?uncap_first}: ${type.name} = ${type.name}(<@compress single_line=true>
+ <#list type.allPropertyFields as field>
+ self.${field.name}<#sep>, </#sep>
</#list>
<#if filteredParserArguments?has_content>
+ <#if type.allPropertyFields?has_content>, </#if>
<#list filteredParserArguments as arg>
- self.${arg.name} = ${arg.name}
+ ${arg.name}<#sep>, </#sep>
</#list>
- </#if>
+ </#...@compress>
<#list reservedFields as reservedField>
- self.reservedField${reservedField?index} = reservedField${reservedField?index}
+ ${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index}
</#list>
-
-
- def build(self,
- <#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().propertyFields as field>
- ${field.name}: ${helper.getLanguageTypeNameForField(field)}<#sep>, </#sep>
- </#list>
- <#if filteredParentParserArguments?has_content>
- <#if type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().propertyFields?has_content>, </#if>
- <#list filteredParentParserArguments as arg>
- ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}<#sep>, </#sep>
- </#list>
- </#if>
- ) -> ${type.name}:
- ${type.name?uncap_first}: ${type.name} = ${type.name}(
- <#list type.allPropertyFields as field>
- ${field.name}<#sep>, </#sep>
- </#list>
- <#if filteredParserArguments?has_content>
- <#if type.allPropertyFields?has_content>, </#if>
- <#list filteredParserArguments as arg>
- ${arg.name}<#sep>, </#sep>
- </#list>
- </#if>)
- <#list reservedFields as reservedField>
- ${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index}
- </#list>
return ${type.name?uncap_first}
</#if>
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
index daab1145a8..5d2c603e78 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
@@ -29,9 +29,9 @@ from plc4py.protocols.modbus.readwrite.DriverType import DriverType
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
import math
-
+
@dataclass
-class ModbusAsciiADU(PlcMessage,ModbusADU):
+class ModbusAsciiADU(PlcMessage, ModbusADU):
address: c_uint8
pdu: ModbusPDU
# Arguments.
@@ -41,11 +41,8 @@ class ModbusAsciiADU(PlcMessage,ModbusADU):
def getDriverType(self) -> DriverType:
return DriverType.MODBUS_ASCII
-
def __post_init__(self):
- super().__init__( self.response )
-
-
+ super().__init__(self.response)
def getAddress(self) -> c_uint8:
return self.address
@@ -53,24 +50,36 @@ class ModbusAsciiADU(PlcMessage,ModbusADU):
def getPdu(self) -> ModbusPDU:
return self.pdu
-
def serializeModbusADUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusAsciiADU")
# Simple Field (address)
- writeSimpleField("address", address, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ writeSimpleField(
+ "address",
+ address,
+ writeUnsignedShort(writeBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
# Simple Field (pdu)
- writeSimpleField("pdu", pdu, DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ writeSimpleField(
+ "pdu",
+ pdu,
+ DataWriterComplexDefault(writeBuffer),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
# Checksum Field (checksum) (Calculated)
- writeChecksumField("crc", (c_uint8) (modbus.readwrite.utils.StaticHelper.asciiLrcCheck(address, pdu)), writeUnsignedShort(writeBuffer, 8))
+ writeChecksumField(
+ "crc",
+ (c_uint8)(modbus.readwrite.utils.StaticHelper.asciiLrcCheck(address, pdu)),
+ writeUnsignedShort(writeBuffer, 8),
+ )
writeBuffer.popContext("ModbusAsciiADU")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -89,24 +98,39 @@ class ModbusAsciiADU(PlcMessage,ModbusADU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, driverType: DriverType, response: c_bool) -> ModbusAsciiADUBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, driverType: DriverType, response: c_bool
+ ) -> ModbusAsciiADUBuilder:
readBuffer.pullContext("ModbusAsciiADU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: c_uint8 = readSimpleField("address", readUnsignedShort(readBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ address: c_uint8 = readSimpleField(
+ "address",
+ readUnsignedShort(readBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- pdu: ModbusPDU = readSimpleField("pdu", DataReaderComplexDefault<>(() -> ModbusPDU.staticParse(readBuffer, (c_bool) (response)), readBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ pdu: ModbusPDU = readSimpleField(
+ "pdu",
+ DataReaderComplexDefault(
+ ModbusPDU.staticParse(readBuffer, c_bool(response)), readBuffer
+ ),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- crc: c_uint8 = readChecksumField("crc", readUnsignedShort(readBuffer, 8), (c_uint8) (modbus.readwrite.utils.StaticHelper.asciiLrcCheck(address, pdu)), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ crc: c_uint8 = readChecksumField(
+ "crc",
+ readUnsignedShort(readBuffer, 8),
+ (c_uint8)(modbus.readwrite.utils.StaticHelper.asciiLrcCheck(address, pdu)),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
readBuffer.closeContext("ModbusAsciiADU")
# Create the instance
- return ModbusAsciiADUBuilder(address, pdu , response )
-
+ return ModbusAsciiADUBuilder(address, pdu, response)
def equals(self, o: object) -> bool:
if self == o:
@@ -116,10 +140,15 @@ class ModbusAsciiADU(PlcMessage,ModbusADU):
return False
that: ModbusAsciiADU = ModbusAsciiADU(o)
- return (getAddress() == that.getAddress()) && (getPdu() == that.getPdu()) && super().equals(that) && True
+ return (
+ (self.getAddress() == that.getAddress())
+ and (self.getPdu() == that.getPdu())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getAddress(), getPdu() )
+ return hash(super().hashCode(), self.getAddress(), self.getPdu())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -131,22 +160,17 @@ class ModbusAsciiADU(PlcMessage,ModbusADU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusAsciiADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: ModbusPDU response: c_booldef ModbusAsciiADUBuilder( c_uint8 address, ModbusPDU pdu , c_bool response ): self.address = address
- self.pdu = pdu
- self.response = response
+@dataclass
+class ModbusAsciiADUBuilder(ModbusADUModbusADUBuilder):
+ address: c_uint8
+ pdu: ModbusPDU
+ response: c_bool
+ def __post_init__(self):
+ pass
- def build(self,
-
- response: c_bool
- ) -> ModbusAsciiADU:
+ def build(self, response: c_bool) -> ModbusAsciiADU:
modbusAsciiADU: ModbusAsciiADU = ModbusAsciiADU(
- address,
- pdu
- ,
- response
+ self.address, self.pdu, response
)
return modbusAsciiADU
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
index 75ddd1e121..809eebb03c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
@@ -26,33 +26,31 @@ from ctypes import c_uint16
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
class ModbusConstants(PlcMessage):
MODBUSTCPDEFAULTPORT: c_uint16 = 502
-
-
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getModbusTcpDefaultPort(self) -> c_uint16:
return MODBUSTCPDEFAULTPORT
-
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusConstants")
# Const Field (modbusTcpDefaultPort)
- writeConstField("modbusTcpDefaultPort", MODBUSTCPDEFAULTPORT, writeUnsignedInt(writeBuffer, 16))
+ writeConstField(
+ "modbusTcpDefaultPort",
+ MODBUSTCPDEFAULTPORT,
+ writeUnsignedInt(writeBuffer, 16),
+ )
writeBuffer.popContext("ModbusConstants")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -65,12 +63,10 @@ class ModbusConstants(PlcMessage):
return lengthInBits
-
- def staticParse(readBuffer: ReadBuffer , args) -> ModbusConstants:
+ def staticParse(readBuffer: ReadBuffer, args) -> ModbusConstants:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
-
@staticmethod
def staticParseContext(readBuffer: ReadBuffer) -> ModbusConstants:
readBuffer.pullContext("ModbusConstants")
@@ -78,14 +74,17 @@ class ModbusConstants(PlcMessage):
startPos: int = positionAware.getPos()
curPos: int = 0
- modbusTcpDefaultPort: c_uint16 = readConstField("modbusTcpDefaultPort", readUnsignedInt(readBuffer, 16), ModbusConstants.MODBUSTCPDEFAULTPORT)
+ modbusTcpDefaultPort: c_uint16 = readConstField(
+ "modbusTcpDefaultPort",
+ readUnsignedInt(readBuffer, 16),
+ ModbusConstants.MODBUSTCPDEFAULTPORT,
+ )
readBuffer.closeContext("ModbusConstants")
# Create the instance
_modbusConstants: ModbusConstants = ModbusConstants()
return _modbusConstants
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -107,7 +106,3 @@ class ModbusConstants(PlcMessage):
raise RuntimeException(e)
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
index 44b6639982..6ec95faf98 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
@@ -25,28 +25,24 @@ from dataclasses import dataclass
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
class ModbusDeviceInformationObject(PlcMessage):
objectId: c_uint8
- data: []c_byte
-
-
+ data: List[c_byte]
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getObjectId(self) -> c_uint8:
return self.objectId
- def getData(self) -> []c_byte:
+ def getData(self) -> List[c_byte]:
return self.data
-
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -56,15 +52,16 @@ class ModbusDeviceInformationObject(PlcMessage):
writeSimpleField("objectId", objectId, writeUnsignedShort(writeBuffer, 8))
# Implicit Field (objectLength) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 objectLength = (c_uint8) (COUNT(getData()))
- writeImplicitField("objectLength", objectLength, writeUnsignedShort(writeBuffer, 8))
+ objectLength: c_uint8 = c_uint8((COUNT(self.getData())))
+ writeImplicitField(
+ "objectLength", objectLength, writeUnsignedShort(writeBuffer, 8)
+ )
# Array Field (data)
writeByteArrayField("data", data, writeByteArray(writeBuffer, 8))
writeBuffer.popContext("ModbusDeviceInformationObject")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -79,18 +76,15 @@ class ModbusDeviceInformationObject(PlcMessage):
lengthInBits += 8
# Array field
- if data is not None):
- lengthInBits += 8 * data.length
-
+ if self.data is not None:
+ lengthInBits += 8 * self.data.length
return lengthInBits
-
- def staticParse(readBuffer: ReadBuffer , args) -> ModbusDeviceInformationObject:
+ def staticParse(readBuffer: ReadBuffer, args) -> ModbusDeviceInformationObject:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
-
@staticmethod
def staticParseContext(readBuffer: ReadBuffer) -> ModbusDeviceInformationObject:
readBuffer.pullContext("ModbusDeviceInformationObject")
@@ -98,18 +92,23 @@ class ModbusDeviceInformationObject(PlcMessage):
startPos: int = positionAware.getPos()
curPos: int = 0
- objectId: c_uint8 = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
+ objectId: c_uint8 = readSimpleField(
+ "objectId", readUnsignedShort(readBuffer, 8)
+ )
- objectLength: c_uint8 = readImplicitField("objectLength", readUnsignedShort(readBuffer, 8))
+ objectLength: c_uint8 = readImplicitField(
+ "objectLength", readUnsignedShort(readBuffer, 8)
+ )
- data: byte[] = readBuffer.readByteArray("data", Math.toIntExact(objectLength))
+ data: List[byte] = readBuffer.readByteArray("data", int(objectLength))
readBuffer.closeContext("ModbusDeviceInformationObject")
# Create the instance
- _modbusDeviceInformationObject: ModbusDeviceInformationObject = ModbusDeviceInformationObject(objectId, data )
+ _modbusDeviceInformationObject: ModbusDeviceInformationObject = (
+ ModbusDeviceInformationObject(objectId, data)
+ )
return _modbusDeviceInformationObject
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -118,10 +117,14 @@ class ModbusDeviceInformationObject(PlcMessage):
return False
that: ModbusDeviceInformationObject = ModbusDeviceInformationObject(o)
- return (getObjectId() == that.getObjectId()) && (getData() == that.getData()) && True
+ return (
+ (self.getObjectId() == that.getObjectId())
+ and (self.getData() == that.getData())
+ and True
+ )
def hashCode(self) -> int:
- return hash(getObjectId(), getData() )
+ return hash(self.getObjectId(), self.getData())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -131,7 +134,3 @@ class ModbusDeviceInformationObject(PlcMessage):
raise RuntimeException(e)
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
index dfc22a5fa8..c9e8cc9130 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
+class ModbusPDUDiagnosticRequest(PlcMessage, ModbusPDU):
subFunction: c_uint16
data: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x08
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x08)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getSubFunction(self) -> c_uint16:
return self.subFunction
@@ -54,7 +53,6 @@ class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
def getData(self) -> c_uint16:
return self.data
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -68,7 +66,6 @@ class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUDiagnosticRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +81,24 @@ class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUDiagnosticRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUDiagnosticRequestBuilder:
readBuffer.pullContext("ModbusPDUDiagnosticRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- subFunction: c_uint16 = readSimpleField("subFunction", readUnsignedInt(readBuffer, 16))
+ subFunction: c_uint16 = readSimpleField(
+ "subFunction", readUnsignedInt(readBuffer, 16)
+ )
data: c_uint16 = readSimpleField("data", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUDiagnosticRequest")
# Create the instance
- return ModbusPDUDiagnosticRequestBuilder(subFunction, data )
-
+ return ModbusPDUDiagnosticRequestBuilder(subFunction, data)
def equals(self, o: object) -> bool:
if self == o:
@@ -109,10 +108,15 @@ class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUDiagnosticRequest = ModbusPDUDiagnosticRequest(o)
- return (getSubFunction() == that.getSubFunction()) && (getData() == that.getData()) && super().equals(that) && True
+ return (
+ (self.getSubFunction() == that.getSubFunction())
+ and (self.getData() == that.getData())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getSubFunction(), getData() )
+ return hash(super().hashCode(), self.getSubFunction(), self.getData())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +128,18 @@ class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUDiagnosticRequestBuilder(ModbusPDUModbusPDUBuilder: subFunction: c_uint16 data: c_uint16def ModbusPDUDiagnosticRequestBuilder( c_uint16 subFunction, c_uint16 data ): self.subFunction = subFunction
- self.data = data
-
+@dataclass
+class ModbusPDUDiagnosticRequestBuilder(ModbusPDUModbusPDUBuilder):
+ subFunction: c_uint16
+ data: c_uint16
- def build(self,
- ) -> ModbusPDUDiagnosticRequest:
- modbusPDUDiagnosticRequest: ModbusPDUDiagnosticRequest = ModbusPDUDiagnosticRequest(
- subFunction,
- data
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUDiagnosticRequest:
+ modbusPDUDiagnosticRequest: ModbusPDUDiagnosticRequest = (
+ ModbusPDUDiagnosticRequest(self.subFunction, self.data)
+ )
return modbusPDUDiagnosticRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
index 4a167de766..5eac2ec9a6 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
+class ModbusPDUDiagnosticResponse(PlcMessage, ModbusPDU):
subFunction: c_uint16
data: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x08
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x08)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getSubFunction(self) -> c_uint16:
return self.subFunction
@@ -54,7 +53,6 @@ class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
def getData(self) -> c_uint16:
return self.data
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -68,7 +66,6 @@ class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUDiagnosticResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +81,24 @@ class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUDiagnosticResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUDiagnosticResponseBuilder:
readBuffer.pullContext("ModbusPDUDiagnosticResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- subFunction: c_uint16 = readSimpleField("subFunction", readUnsignedInt(readBuffer, 16))
+ subFunction: c_uint16 = readSimpleField(
+ "subFunction", readUnsignedInt(readBuffer, 16)
+ )
data: c_uint16 = readSimpleField("data", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUDiagnosticResponse")
# Create the instance
- return ModbusPDUDiagnosticResponseBuilder(subFunction, data )
-
+ return ModbusPDUDiagnosticResponseBuilder(subFunction, data)
def equals(self, o: object) -> bool:
if self == o:
@@ -109,10 +108,15 @@ class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUDiagnosticResponse = ModbusPDUDiagnosticResponse(o)
- return (getSubFunction() == that.getSubFunction()) && (getData() == that.getData()) && super().equals(that) && True
+ return (
+ (self.getSubFunction() == that.getSubFunction())
+ and (self.getData() == that.getData())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getSubFunction(), getData() )
+ return hash(super().hashCode(), self.getSubFunction(), self.getData())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +128,18 @@ class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUDiagnosticResponseBuilder(ModbusPDUModbusPDUBuilder: subFunction: c_uint16 data: c_uint16def ModbusPDUDiagnosticResponseBuilder( c_uint16 subFunction, c_uint16 data ): self.subFunction = subFunction
- self.data = data
-
+@dataclass
+class ModbusPDUDiagnosticResponseBuilder(ModbusPDUModbusPDUBuilder):
+ subFunction: c_uint16
+ data: c_uint16
- def build(self,
- ) -> ModbusPDUDiagnosticResponse:
- modbusPDUDiagnosticResponse: ModbusPDUDiagnosticResponse = ModbusPDUDiagnosticResponse(
- subFunction,
- data
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUDiagnosticResponse:
+ modbusPDUDiagnosticResponse: ModbusPDUDiagnosticResponse = (
+ ModbusPDUDiagnosticResponse(self.subFunction, self.data)
+ )
return modbusPDUDiagnosticResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
index b2ade0b779..4c38f67b9c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
@@ -28,41 +28,46 @@ from plc4py.api.messages.PlcMessage import PlcMessage
from plc4py.protocols.modbus.readwrite.ModbusErrorCode import ModbusErrorCode
import math
-
+
@dataclass
-class ModbusPDUError(PlcMessage,ModbusPDU):
+class ModbusPDUError(PlcMessage, ModbusPDU):
exceptionCode: ModbusErrorCode
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) True
+ return c_bool(True)
+
def getFunctionFlag(self) -> c_uint8:
return 0
+
def getResponse(self) -> c_bool:
return False
-
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getExceptionCode(self) -> ModbusErrorCode:
return self.exceptionCode
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUError")
# Simple Field (exceptionCode)
- writeSimpleEnumField("exceptionCode", "ModbusErrorCode", exceptionCode, DataWriterEnumDefault<>(ModbusErrorCode::getValue, ModbusErrorCode::name, writeUnsignedShort(writeBuffer, 8)))
-
+ writeSimpleEnumField(
+ "exceptionCode",
+ "ModbusErrorCode",
+ exceptionCode,
+ DataWriterEnumDefault(
+ ModbusErrorCode.getValue,
+ ModbusErrorCode.name,
+ writeUnsignedShort(writeBuffer, 8),
+ ),
+ )
writeBuffer.popContext("ModbusPDUError")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -75,20 +80,26 @@ class ModbusPDUError(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUErrorBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUErrorBuilder:
readBuffer.pullContext("ModbusPDUError")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- exceptionCode: ModbusErrorCode = readEnumField("exceptionCode", "ModbusErrorCode", DataReaderEnumDefault<>(ModbusErrorCode::enumForValue, readUnsignedShort(readBuffer, 8)))
+ exceptionCode: ModbusErrorCode = readEnumField(
+ "exceptionCode",
+ "ModbusErrorCode",
+ DataReaderEnumDefault(
+ ModbusErrorCode.enumForValue, readUnsignedShort(readBuffer, 8)
+ ),
+ )
readBuffer.closeContext("ModbusPDUError")
# Create the instance
- return ModbusPDUErrorBuilder(exceptionCode )
-
+ return ModbusPDUErrorBuilder(exceptionCode)
def equals(self, o: object) -> bool:
if self == o:
@@ -98,10 +109,14 @@ class ModbusPDUError(PlcMessage,ModbusPDU):
return False
that: ModbusPDUError = ModbusPDUError(o)
- return (getExceptionCode() == that.getExceptionCode()) && super().equals(that) && True
+ return (
+ (self.getExceptionCode() == that.getExceptionCode())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getExceptionCode() )
+ return hash(super().hashCode(), self.getExceptionCode())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -113,15 +128,15 @@ class ModbusPDUError(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUErrorBuilder(ModbusPDUModbusPDUBuilder: exceptionCode: ModbusErrorCodedef ModbusPDUErrorBuilder( ModbusErrorCode exceptionCode ): self.exceptionCode = exceptionCode
+@dataclass
+class ModbusPDUErrorBuilder(ModbusPDUModbusPDUBuilder):
+ exceptionCode: ModbusErrorCode
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUError:
- modbusPDUError: ModbusPDUError = ModbusPDUError(
- exceptionCode
-)
+ def build(
+ self,
+ ) -> ModbusPDUError:
+ modbusPDUError: ModbusPDUError = ModbusPDUError(self.exceptionCode)
return modbusPDUError
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
index d45f1b8425..48ba3edab4 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
@@ -27,24 +27,22 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
+class ModbusPDUGetComEventCounterRequest(PlcMessage, ModbusPDU):
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x0B
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x0B)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
-
+ super().__init__()
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
@@ -53,7 +51,6 @@ class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUGetComEventCounterRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -63,9 +60,10 @@ class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUGetComEventCounterRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUGetComEventCounterRequestBuilder:
readBuffer.pullContext("ModbusPDUGetComEventCounterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -75,7 +73,6 @@ class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
# Create the instance
return ModbusPDUGetComEventCounterRequestBuilder()
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -84,10 +81,10 @@ class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUGetComEventCounterRequest = ModbusPDUGetComEventCounterRequest(o)
- return super().equals(that) && True
+ return super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode() )
+ return hash(super().hashCode())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -99,13 +96,15 @@ class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUGetComEventCounterRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUGetComEventCounterRequestBuilder( ):
-
- def build(self,
- ) -> ModbusPDUGetComEventCounterRequest:
- modbusPDUGetComEventCounterRequest: ModbusPDUGetComEventCounterRequest = ModbusPDUGetComEventCounterRequest(
-)
+@dataclass
+class ModbusPDUGetComEventCounterRequestBuilder(ModbusPDUModbusPDUBuilder):
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUGetComEventCounterRequest:
+ modbusPDUGetComEventCounterRequest: ModbusPDUGetComEventCounterRequest = (
+ ModbusPDUGetComEventCounterRequest()
+ )
return modbusPDUGetComEventCounterRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
index 35d16612d1..13a95f8634 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
+class ModbusPDUGetComEventCounterResponse(PlcMessage, ModbusPDU):
status: c_uint16
eventCount: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x0B
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x0B)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStatus(self) -> c_uint16:
return self.status
@@ -54,7 +53,6 @@ class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
def getEventCount(self) -> c_uint16:
return self.eventCount
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -68,7 +66,6 @@ class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUGetComEventCounterResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,9 +81,10 @@ class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUGetComEventCounterResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUGetComEventCounterResponseBuilder:
readBuffer.pullContext("ModbusPDUGetComEventCounterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -94,12 +92,13 @@ class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
status: c_uint16 = readSimpleField("status", readUnsignedInt(readBuffer, 16))
- eventCount: c_uint16 = readSimpleField("eventCount", readUnsignedInt(readBuffer, 16))
+ eventCount: c_uint16 = readSimpleField(
+ "eventCount", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUGetComEventCounterResponse")
# Create the instance
- return ModbusPDUGetComEventCounterResponseBuilder(status, eventCount )
-
+ return ModbusPDUGetComEventCounterResponseBuilder(status, eventCount)
def equals(self, o: object) -> bool:
if self == o:
@@ -108,11 +107,18 @@ class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUGetComEventCounterResponse):
return False
- that: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(o)
- return (getStatus() == that.getStatus()) && (getEventCount() == that.getEventCount()) && super().equals(that) && True
+ that: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(
+ o
+ )
+ return (
+ (self.getStatus() == that.getStatus())
+ and (self.getEventCount() == that.getEventCount())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStatus(), getEventCount() )
+ return hash(super().hashCode(), self.getStatus(), self.getEventCount())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +130,18 @@ class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUGetComEventCounterResponseBuilder(ModbusPDUModbusPDUBuilder: status: c_uint16 eventCount: c_uint16def ModbusPDUGetComEventCounterResponseBuilder( c_uint16 status, c_uint16 eventCount ): self.status = status
- self.eventCount = eventCount
-
+@dataclass
+class ModbusPDUGetComEventCounterResponseBuilder(ModbusPDUModbusPDUBuilder):
+ status: c_uint16
+ eventCount: c_uint16
- def build(self,
- ) -> ModbusPDUGetComEventCounterResponse:
- modbusPDUGetComEventCounterResponse: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(
- status,
- eventCount
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUGetComEventCounterResponse:
+ modbusPDUGetComEventCounterResponse: ModbusPDUGetComEventCounterResponse = (
+ ModbusPDUGetComEventCounterResponse(self.status, self.eventCount)
+ )
return modbusPDUGetComEventCounterResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
index 8781362fb8..19a3418597 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
@@ -27,24 +27,22 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
+class ModbusPDUGetComEventLogRequest(PlcMessage, ModbusPDU):
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x0C
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x0C)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
-
+ super().__init__()
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
@@ -53,7 +51,6 @@ class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUGetComEventLogRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -63,9 +60,10 @@ class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUGetComEventLogRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUGetComEventLogRequestBuilder:
readBuffer.pullContext("ModbusPDUGetComEventLogRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -75,7 +73,6 @@ class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
# Create the instance
return ModbusPDUGetComEventLogRequestBuilder()
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -84,10 +81,10 @@ class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUGetComEventLogRequest = ModbusPDUGetComEventLogRequest(o)
- return super().equals(that) && True
+ return super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode() )
+ return hash(super().hashCode())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -99,13 +96,15 @@ class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUGetComEventLogRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUGetComEventLogRequestBuilder( ):
-
- def build(self,
- ) -> ModbusPDUGetComEventLogRequest:
- modbusPDUGetComEventLogRequest: ModbusPDUGetComEventLogRequest = ModbusPDUGetComEventLogRequest(
-)
+@dataclass
+class ModbusPDUGetComEventLogRequestBuilder(ModbusPDUModbusPDUBuilder):
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUGetComEventLogRequest:
+ modbusPDUGetComEventLogRequest: ModbusPDUGetComEventLogRequest = (
+ ModbusPDUGetComEventLogRequest()
+ )
return modbusPDUGetComEventLogRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
index 9db1d52598..6fd36fe9e2 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
@@ -27,29 +27,29 @@ from ctypes import c_byte
from ctypes import c_uint16
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
+class ModbusPDUGetComEventLogResponse(PlcMessage, ModbusPDU):
status: c_uint16
eventCount: c_uint16
messageCount: c_uint16
- events: []c_byte
+ events: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x0C
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x0C)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStatus(self) -> c_uint16:
return self.status
@@ -60,17 +60,16 @@ class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
def getMessageCount(self) -> c_uint16:
return self.messageCount
- def getEvents(self) -> []c_byte:
+ def getEvents(self) -> List[c_byte]:
return self.events
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUGetComEventLogResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) ((COUNT(getEvents())) + (6))
+ byteCount: c_uint8 = c_uint8(((COUNT(self.getEvents())) + (6)))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Simple Field (status)
@@ -80,14 +79,15 @@ class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
writeSimpleField("eventCount", eventCount, writeUnsignedInt(writeBuffer, 16))
# Simple Field (messageCount)
- writeSimpleField("messageCount", messageCount, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "messageCount", messageCount, writeUnsignedInt(writeBuffer, 16)
+ )
# Array Field (events)
writeByteArrayField("events", events, writeByteArray(writeBuffer, 8))
writeBuffer.popContext("ModbusPDUGetComEventLogResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -108,34 +108,41 @@ class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
lengthInBits += 16
# Array field
- if events is not None):
- lengthInBits += 8 * events.length
-
+ if self.events is not None:
+ lengthInBits += 8 * self.events.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUGetComEventLogResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUGetComEventLogResponseBuilder:
readBuffer.pullContext("ModbusPDUGetComEventLogResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
status: c_uint16 = readSimpleField("status", readUnsignedInt(readBuffer, 16))
- eventCount: c_uint16 = readSimpleField("eventCount", readUnsignedInt(readBuffer, 16))
+ eventCount: c_uint16 = readSimpleField(
+ "eventCount", readUnsignedInt(readBuffer, 16)
+ )
- messageCount: c_uint16 = readSimpleField("messageCount", readUnsignedInt(readBuffer, 16))
+ messageCount: c_uint16 = readSimpleField(
+ "messageCount", readUnsignedInt(readBuffer, 16)
+ )
- events: byte[] = readBuffer.readByteArray("events", Math.toIntExact((byteCount) - (6)))
+ events: List[byte] = readBuffer.readByteArray("events", int((byteCount) - (6)))
readBuffer.closeContext("ModbusPDUGetComEventLogResponse")
# Create the instance
- return ModbusPDUGetComEventLogResponseBuilder(status, eventCount, messageCount, events )
-
+ return ModbusPDUGetComEventLogResponseBuilder(
+ status, eventCount, messageCount, events
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -145,10 +152,23 @@ class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUGetComEventLogResponse = ModbusPDUGetComEventLogResponse(o)
- return (getStatus() == that.getStatus()) && (getEventCount() == that.getEventCount()) && (getMessageCount() == that.getMessageCount()) && (getEvents() == that.getEvents()) && super().equals(that) && True
+ return (
+ (self.getStatus() == that.getStatus())
+ and (self.getEventCount() == that.getEventCount())
+ and (self.getMessageCount() == that.getMessageCount())
+ and (self.getEvents() == that.getEvents())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStatus(), getEventCount(), getMessageCount(), getEvents() )
+ return hash(
+ super().hashCode(),
+ self.getStatus(),
+ self.getEventCount(),
+ self.getMessageCount(),
+ self.getEvents(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -160,21 +180,22 @@ class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUGetComEventLogResponseBuilder(ModbusPDUModbusPDUBuilder: status: c_uint16 eventCount: c_uint16 messageCount: c_uint16 events: []c_bytedef ModbusPDUGetComEventLogResponseBuilder( c_uint16 status, c_uint16 eventCount, c_uint16 messageCount, []c_byte events ): self.status = status
- self.eventCount = eventCount
- self.messageCount = messageCount
- self.events = events
-
+@dataclass
+class ModbusPDUGetComEventLogResponseBuilder(ModbusPDUModbusPDUBuilder):
+ status: c_uint16
+ eventCount: c_uint16
+ messageCount: c_uint16
+ events: List[c_byte]
- def build(self,
- ) -> ModbusPDUGetComEventLogResponse:
- modbusPDUGetComEventLogResponse: ModbusPDUGetComEventLogResponse = ModbusPDUGetComEventLogResponse(
- status,
- eventCount,
- messageCount,
- events
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUGetComEventLogResponse:
+ modbusPDUGetComEventLogResponse: ModbusPDUGetComEventLogResponse = (
+ ModbusPDUGetComEventLogResponse(
+ self.status, self.eventCount, self.messageCount, self.events
+ )
+ )
return modbusPDUGetComEventLogResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
index c760713b0d..18036d365e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
@@ -28,26 +28,25 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
+class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage, ModbusPDU):
referenceAddress: c_uint16
andMask: c_uint16
orMask: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x16
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x16)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getReferenceAddress(self) -> c_uint16:
return self.referenceAddress
@@ -58,14 +57,15 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
def getOrMask(self) -> c_uint16:
return self.orMask
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUMaskWriteHoldingRegisterRequest")
# Simple Field (referenceAddress)
- writeSimpleField("referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (andMask)
writeSimpleField("andMask", andMask, writeUnsignedInt(writeBuffer, 16))
@@ -75,7 +75,6 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUMaskWriteHoldingRegisterRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -94,15 +93,18 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUMaskWriteHoldingRegisterRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUMaskWriteHoldingRegisterRequestBuilder:
readBuffer.pullContext("ModbusPDUMaskWriteHoldingRegisterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceAddress: c_uint16 = readSimpleField("referenceAddress", readUnsignedInt(readBuffer, 16))
+ referenceAddress: c_uint16 = readSimpleField(
+ "referenceAddress", readUnsignedInt(readBuffer, 16)
+ )
andMask: c_uint16 = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
@@ -110,8 +112,9 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterRequest")
# Create the instance
- return ModbusPDUMaskWriteHoldingRegisterRequestBuilder(referenceAddress, andMask, orMask )
-
+ return ModbusPDUMaskWriteHoldingRegisterRequestBuilder(
+ referenceAddress, andMask, orMask
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -120,11 +123,24 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUMaskWriteHoldingRegisterRequest):
return False
- that: ModbusPDUMaskWriteHoldingRegisterRequest = ModbusPDUMaskWriteHoldingRegisterRequest(o)
- return (getReferenceAddress() == that.getReferenceAddress()) && (getAndMask() == that.getAndMask()) && (getOrMask() == that.getOrMask()) && super().equals(that) && True
+ that: ModbusPDUMaskWriteHoldingRegisterRequest = (
+ ModbusPDUMaskWriteHoldingRegisterRequest(o)
+ )
+ return (
+ (self.getReferenceAddress() == that.getReferenceAddress())
+ and (self.getAndMask() == that.getAndMask())
+ and (self.getOrMask() == that.getOrMask())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getReferenceAddress(), getAndMask(), getOrMask() )
+ return hash(
+ super().hashCode(),
+ self.getReferenceAddress(),
+ self.getAndMask(),
+ self.getOrMask(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -136,19 +152,19 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUMaskWriteHoldingRegisterRequestBuilder(ModbusPDUModbusPDUBuilder: referenceAddress: c_uint16 andMask: c_uint16 orMask: c_uint16def ModbusPDUMaskWriteHoldingRegisterRequestBuilder( c_uint16 referenceAddress, c_uint16 andMask, c_uint16 orMask ): self.referenceAddress = referenceAddress
- self.andMask = andMask
- self.orMask = orMask
+@dataclass
+class ModbusPDUMaskWriteHoldingRegisterRequestBuilder(ModbusPDUModbusPDUBuilder):
+ referenceAddress: c_uint16
+ andMask: c_uint16
+ orMask: c_uint16
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUMaskWriteHoldingRegisterRequest:
+ def build(
+ self,
+ ) -> ModbusPDUMaskWriteHoldingRegisterRequest:
modbusPDUMaskWriteHoldingRegisterRequest: ModbusPDUMaskWriteHoldingRegisterRequest = ModbusPDUMaskWriteHoldingRegisterRequest(
- referenceAddress,
- andMask,
- orMask
-)
+ self.referenceAddress, self.andMask, self.orMask
+ )
return modbusPDUMaskWriteHoldingRegisterRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
index edd73957b5..ae2421ce3d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
@@ -28,26 +28,25 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
+class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage, ModbusPDU):
referenceAddress: c_uint16
andMask: c_uint16
orMask: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x16
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x16)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getReferenceAddress(self) -> c_uint16:
return self.referenceAddress
@@ -58,14 +57,15 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
def getOrMask(self) -> c_uint16:
return self.orMask
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUMaskWriteHoldingRegisterResponse")
# Simple Field (referenceAddress)
- writeSimpleField("referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (andMask)
writeSimpleField("andMask", andMask, writeUnsignedInt(writeBuffer, 16))
@@ -75,7 +75,6 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUMaskWriteHoldingRegisterResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -94,15 +93,18 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUMaskWriteHoldingRegisterResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUMaskWriteHoldingRegisterResponseBuilder:
readBuffer.pullContext("ModbusPDUMaskWriteHoldingRegisterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceAddress: c_uint16 = readSimpleField("referenceAddress", readUnsignedInt(readBuffer, 16))
+ referenceAddress: c_uint16 = readSimpleField(
+ "referenceAddress", readUnsignedInt(readBuffer, 16)
+ )
andMask: c_uint16 = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
@@ -110,8 +112,9 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterResponse")
# Create the instance
- return ModbusPDUMaskWriteHoldingRegisterResponseBuilder(referenceAddress, andMask, orMask )
-
+ return ModbusPDUMaskWriteHoldingRegisterResponseBuilder(
+ referenceAddress, andMask, orMask
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -120,11 +123,24 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUMaskWriteHoldingRegisterResponse):
return False
- that: ModbusPDUMaskWriteHoldingRegisterResponse = ModbusPDUMaskWriteHoldingRegisterResponse(o)
- return (getReferenceAddress() == that.getReferenceAddress()) && (getAndMask() == that.getAndMask()) && (getOrMask() == that.getOrMask()) && super().equals(that) && True
+ that: ModbusPDUMaskWriteHoldingRegisterResponse = (
+ ModbusPDUMaskWriteHoldingRegisterResponse(o)
+ )
+ return (
+ (self.getReferenceAddress() == that.getReferenceAddress())
+ and (self.getAndMask() == that.getAndMask())
+ and (self.getOrMask() == that.getOrMask())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getReferenceAddress(), getAndMask(), getOrMask() )
+ return hash(
+ super().hashCode(),
+ self.getReferenceAddress(),
+ self.getAndMask(),
+ self.getOrMask(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -136,19 +152,19 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUMaskWriteHoldingRegisterResponseBuilder(ModbusPDUModbusPDUBuilder: referenceAddress: c_uint16 andMask: c_uint16 orMask: c_uint16def ModbusPDUMaskWriteHoldingRegisterResponseBuilder( c_uint16 referenceAddress, c_uint16 andMask, c_uint16 orMask ): self.referenceAddress = referenceAddress
- self.andMask = andMask
- self.orMask = orMask
+@dataclass
+class ModbusPDUMaskWriteHoldingRegisterResponseBuilder(ModbusPDUModbusPDUBuilder):
+ referenceAddress: c_uint16
+ andMask: c_uint16
+ orMask: c_uint16
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUMaskWriteHoldingRegisterResponse:
+ def build(
+ self,
+ ) -> ModbusPDUMaskWriteHoldingRegisterResponse:
modbusPDUMaskWriteHoldingRegisterResponse: ModbusPDUMaskWriteHoldingRegisterResponse = ModbusPDUMaskWriteHoldingRegisterResponse(
- referenceAddress,
- andMask,
- orMask
-)
+ self.referenceAddress, self.andMask, self.orMask
+ )
return modbusPDUMaskWriteHoldingRegisterResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
index d6bd1484d6..61de326a6d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReadCoilsRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadCoilsRequest(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x01
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x01)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -54,21 +53,21 @@ class ModbusPDUReadCoilsRequest(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadCoilsRequest")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
writeBuffer.popContext("ModbusPDUReadCoilsRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +83,26 @@ class ModbusPDUReadCoilsRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadCoilsRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadCoilsRequestBuilder:
readBuffer.pullContext("ModbusPDUReadCoilsRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUReadCoilsRequest")
# Create the instance
- return ModbusPDUReadCoilsRequestBuilder(startingAddress, quantity )
-
+ return ModbusPDUReadCoilsRequestBuilder(startingAddress, quantity)
def equals(self, o: object) -> bool:
if self == o:
@@ -109,10 +112,15 @@ class ModbusPDUReadCoilsRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadCoilsRequest = ModbusPDUReadCoilsRequest(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+ return hash(super().hashCode(), self.getStartingAddress(), self.getQuantity())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +132,18 @@ class ModbusPDUReadCoilsRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadCoilsRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadCoilsRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
- self.quantity = quantity
-
+@dataclass
+class ModbusPDUReadCoilsRequestBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
- def build(self,
- ) -> ModbusPDUReadCoilsRequest:
- modbusPDUReadCoilsRequest: ModbusPDUReadCoilsRequest = ModbusPDUReadCoilsRequest(
- startingAddress,
- quantity
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadCoilsRequest:
+ modbusPDUReadCoilsRequest: ModbusPDUReadCoilsRequest = (
+ ModbusPDUReadCoilsRequest(self.startingAddress, self.quantity)
+ )
return modbusPDUReadCoilsRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
index 3a7b607e44..419e6f8523 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
@@ -26,38 +26,37 @@ from ctypes import c_bool
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadCoilsResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+class ModbusPDUReadCoilsResponse(PlcMessage, ModbusPDU):
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x01
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x01)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
+ super().__init__()
-
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadCoilsResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -65,7 +64,6 @@ class ModbusPDUReadCoilsResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadCoilsResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,28 +75,29 @@ class ModbusPDUReadCoilsResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadCoilsResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadCoilsResponseBuilder:
readBuffer.pullContext("ModbusPDUReadCoilsResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUReadCoilsResponse")
# Create the instance
- return ModbusPDUReadCoilsResponseBuilder(value )
-
+ return ModbusPDUReadCoilsResponseBuilder(value)
def equals(self, o: object) -> bool:
if self == o:
@@ -108,10 +107,10 @@ class ModbusPDUReadCoilsResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadCoilsResponse = ModbusPDUReadCoilsResponse(o)
- return (getValue() == that.getValue()) && super().equals(that) && True
+ return (self.getValue() == that.getValue()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getValue() )
+ return hash(super().hashCode(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -123,15 +122,17 @@ class ModbusPDUReadCoilsResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadCoilsResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadCoilsResponseBuilder( []c_byte value ): self.value = value
-
+@dataclass
+class ModbusPDUReadCoilsResponseBuilder(ModbusPDUModbusPDUBuilder):
+ value: List[c_byte]
- def build(self,
- ) -> ModbusPDUReadCoilsResponse:
- modbusPDUReadCoilsResponse: ModbusPDUReadCoilsResponse = ModbusPDUReadCoilsResponse(
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadCoilsResponse:
+ modbusPDUReadCoilsResponse: ModbusPDUReadCoilsResponse = (
+ ModbusPDUReadCoilsResponse(self.value)
+ )
return modbusPDUReadCoilsResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
index 5afcab877f..ed1ebb3a46 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
@@ -25,29 +25,30 @@ from dataclasses import dataclass
from ctypes import c_bool
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
-from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationLevel import ModbusDeviceInformationLevel
+from plc4py.protocols.modbus.readwrite.ModbusDeviceInformationLevel import (
+ ModbusDeviceInformationLevel,
+)
import math
-
+
@dataclass
-class ModbusPDUReadDeviceIdentificationRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadDeviceIdentificationRequest(PlcMessage, ModbusPDU):
level: ModbusDeviceInformationLevel
objectId: c_uint8
MEITYPE: c_uint8 = 0x0E
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x2B
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x2B)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getLevel(self) -> ModbusDeviceInformationLevel:
return self.level
@@ -58,25 +59,31 @@ class ModbusPDUReadDeviceIdentificationRequest(PlcMessage,ModbusPDU):
def getMeiType(self) -> c_uint8:
return MEITYPE
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadDeviceIdentificationRequest")
# Const Field (meiType)
- writeConstField("meiType", MEITYPE, writeUnsignedShort(writeBuffer, 8))
+ writeConstField("meiType", MEITYPE, writeUnsignedShort(writeBuffer, 8))
# Simple Field (level)
- writeSimpleEnumField("level", "ModbusDeviceInformationLevel", level, DataWriterEnumDefault<>(ModbusDeviceInformationLevel::getValue, ModbusDeviceInformationLevel::name, writeUnsignedShort(writeBuffer, 8)))
-
+ writeSimpleEnumField(
+ "level",
+ "ModbusDeviceInformationLevel",
+ level,
+ DataWriterEnumDefault(
+ ModbusDeviceInformationLevel.getValue,
+ ModbusDeviceInformationLevel.name,
+ writeUnsignedShort(writeBuffer, 8),
+ ),
+ )
# Simple Field (objectId)
writeSimpleField("objectId", objectId, writeUnsignedShort(writeBuffer, 8))
writeBuffer.popContext("ModbusPDUReadDeviceIdentificationRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -95,24 +102,37 @@ class ModbusPDUReadDeviceIdentificationRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadDeviceIdentificationRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadDeviceIdentificationRequestBuilder:
readBuffer.pullContext("ModbusPDUReadDeviceIdentificationRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- meiType: c_uint8 = readConstField("meiType", readUnsignedShort(readBuffer, 8), ModbusPDUReadDeviceIdentificationRequest.MEITYPE)
-
- level: ModbusDeviceInformationLevel = readEnumField("level", "ModbusDeviceInformationLevel", DataReaderEnumDefault<>(ModbusDeviceInformationLevel::enumForValue, readUnsignedShort(readBuffer, 8)))
-
- objectId: c_uint8 = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
+ meiType: c_uint8 = readConstField(
+ "meiType",
+ readUnsignedShort(readBuffer, 8),
+ ModbusPDUReadDeviceIdentificationRequest.MEITYPE,
+ )
+
+ level: ModbusDeviceInformationLevel = readEnumField(
+ "level",
+ "ModbusDeviceInformationLevel",
+ DataReaderEnumDefault(
+ ModbusDeviceInformationLevel.enumForValue,
+ readUnsignedShort(readBuffer, 8),
+ ),
+ )
+
+ objectId: c_uint8 = readSimpleField(
+ "objectId", readUnsignedShort(readBuffer, 8)
+ )
readBuffer.closeContext("ModbusPDUReadDeviceIdentificationRequest")
# Create the instance
- return ModbusPDUReadDeviceIdentificationRequestBuilder(level, objectId )
-
+ return ModbusPDUReadDeviceIdentificationRequestBuilder(level, objectId)
def equals(self, o: object) -> bool:
if self == o:
@@ -121,11 +141,18 @@ class ModbusPDUReadDeviceIdentificationRequest(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadDeviceIdentificationRequest):
return False
- that: ModbusPDUReadDeviceIdentificationRequest = ModbusPDUReadDeviceIdentificationRequest(o)
- return (getLevel() == that.getLevel()) && (getObjectId() == that.getObjectId()) && super().equals(that) && True
+ that: ModbusPDUReadDeviceIdentificationRequest = (
+ ModbusPDUReadDeviceIdentificationRequest(o)
+ )
+ return (
+ (self.getLevel() == that.getLevel())
+ and (self.getObjectId() == that.getObjectId())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getLevel(), getObjectId() )
+ return hash(super().hashCode(), self.getLevel(), self.getObjectId())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -137,17 +164,18 @@ class ModbusPDUReadDeviceIdentificationRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadDeviceIdentificationRequestBuilder(ModbusPDUModbusPDUBuilder: level: ModbusDeviceInformationLevel objectId: c_uint8def ModbusPDUReadDeviceIdentificationRequestBuilder( ModbusDeviceInformationLevel level, c_uint8 objectId ): self.level = level
- self.objectId = objectId
+@dataclass
+class ModbusPDUReadDeviceIdentificationRequestBuilder(ModbusPDUModbusPDUBuilder):
+ level: ModbusDeviceInformationLevel
+ objectId: c_uint8
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUReadDeviceIdentificationRequest:
+ def build(
+ self,
+ ) -> ModbusPDUReadDeviceIdentificationRequest:
modbusPDUReadDeviceIdentificationRequest: ModbusPDUReadDeviceIdentificationRequest = ModbusPDUReadDeviceIdentificationRequest(
- level,
- objectId
-)
+ self.level, self.objectId
+ )
return modbusPDUReadDeviceIdentificationRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
index a04048dcc6..6afb8fed84 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
@@ -25,36 +25,44 @@ from dataclasses import dataclass
from ctypes import c_bool
from ctypes import c_uint8
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 typing import List
import math
-
+
@dataclass
-class ModbusPDUReadDeviceIdentificationResponse(PlcMessage,ModbusPDU):
+class ModbusPDUReadDeviceIdentificationResponse(PlcMessage, ModbusPDU):
level: ModbusDeviceInformationLevel
individualAccess: c_bool
conformityLevel: ModbusDeviceInformationConformityLevel
moreFollows: ModbusDeviceInformationMoreFollows
nextObjectId: c_uint8
- objects: []ModbusDeviceInformationObject
+ objects: List[ModbusDeviceInformationObject]
MEITYPE: c_uint8 = 0x0E
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x2B
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x2B)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getLevel(self) -> ModbusDeviceInformationLevel:
return self.level
@@ -71,49 +79,77 @@ class ModbusPDUReadDeviceIdentificationResponse(PlcMessage,ModbusPDU):
def getNextObjectId(self) -> c_uint8:
return self.nextObjectId
- def getObjects(self) -> []ModbusDeviceInformationObject:
+ def getObjects(self) -> List[ModbusDeviceInformationObject]:
return self.objects
def getMeiType(self) -> c_uint8:
return MEITYPE
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadDeviceIdentificationResponse")
# Const Field (meiType)
- writeConstField("meiType", MEITYPE, writeUnsignedShort(writeBuffer, 8))
+ writeConstField("meiType", MEITYPE, writeUnsignedShort(writeBuffer, 8))
# Simple Field (level)
- writeSimpleEnumField("level", "ModbusDeviceInformationLevel", level, DataWriterEnumDefault<>(ModbusDeviceInformationLevel::getValue, ModbusDeviceInformationLevel::name, writeUnsignedShort(writeBuffer, 8)))
-
+ writeSimpleEnumField(
+ "level",
+ "ModbusDeviceInformationLevel",
+ level,
+ DataWriterEnumDefault(
+ ModbusDeviceInformationLevel.getValue,
+ ModbusDeviceInformationLevel.name,
+ writeUnsignedShort(writeBuffer, 8),
+ ),
+ )
# Simple Field (individualAccess)
- writeSimpleField("individualAccess", individualAccess, writeBoolean(writeBuffer))
+ writeSimpleField(
+ "individualAccess", individualAccess, writeBoolean(writeBuffer)
+ )
# Simple Field (conformityLevel)
- writeSimpleEnumField("conformityLevel", "ModbusDeviceInformationConformityLevel", conformityLevel, DataWriterEnumDefault<>(ModbusDeviceInformationConformityLevel::getValue, ModbusDeviceInformationConformityLevel::name, writeUnsignedShort(writeBuffer, 7)))
-
+ writeSimpleEnumField(
+ "conformityLevel",
+ "ModbusDeviceInformationConformityLevel",
+ conformityLevel,
+ DataWriterEnumDefault(
+ ModbusDeviceInformationConformityLevel.getValue,
+ ModbusDeviceInformationConformityLevel.name,
+ writeUnsignedShort(writeBuffer, 7),
+ ),
+ )
# Simple Field (moreFollows)
- writeSimpleEnumField("moreFollows", "ModbusDeviceInformationMoreFollows", moreFollows, DataWriterEnumDefault<>(ModbusDeviceInformationMoreFollows::getValue, ModbusDeviceInformationMoreFollows::name, writeUnsignedShort(writeBuffer, 8)))
-
+ writeSimpleEnumField(
+ "moreFollows",
+ "ModbusDeviceInformationMoreFollows",
+ moreFollows,
+ DataWriterEnumDefault(
+ ModbusDeviceInformationMoreFollows.getValue,
+ ModbusDeviceInformationMoreFollows.name,
+ writeUnsignedShort(writeBuffer, 8),
+ ),
+ )
# Simple Field (nextObjectId)
- writeSimpleField("nextObjectId", nextObjectId, writeUnsignedShort(writeBuffer, 8))
+ writeSimpleField(
+ "nextObjectId", nextObjectId, writeUnsignedShort(writeBuffer, 8)
+ )
# Implicit Field (numberOfObjects) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 numberOfObjects = (c_uint8) (COUNT(getObjects()))
- writeImplicitField("numberOfObjects", numberOfObjects, writeUnsignedShort(writeBuffer, 8))
+ numberOfObjects: c_uint8 = c_uint8((COUNT(self.getObjects())))
+ writeImplicitField(
+ "numberOfObjects", numberOfObjects, writeUnsignedShort(writeBuffer, 8)
+ )
# Array Field (objects)
writeComplexTypeArrayField("objects", objects, writeBuffer)
writeBuffer.popContext("ModbusPDUReadDeviceIdentificationResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -143,44 +179,81 @@ class ModbusPDUReadDeviceIdentificationResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if objects is not None):
+ if self.objects is not None:
i: int = 0
for element in objects:
last: boolean = ++i >= objects.size()
lengthInBits += element.getLengthInBits()
-
-
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadDeviceIdentificationResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadDeviceIdentificationResponseBuilder:
readBuffer.pullContext("ModbusPDUReadDeviceIdentificationResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- meiType: c_uint8 = readConstField("meiType", readUnsignedShort(readBuffer, 8), ModbusPDUReadDeviceIdentificationResponse.MEITYPE)
-
- level: ModbusDeviceInformationLevel = readEnumField("level", "ModbusDeviceInformationLevel", DataReaderEnumDefault<>(ModbusDeviceInformationLevel::enumForValue, readUnsignedShort(readBuffer, 8)))
-
- individualAccess: c_bool = readSimpleField("individualAccess", readBoolean(readBuffer))
-
- conformityLevel: ModbusDeviceInformationConformityLevel = readEnumField("conformityLevel", "ModbusDeviceInformationConformityLevel", DataReaderEnumDefault<>(ModbusDeviceInformationConformityLevel::enumForValue, readUnsignedShort(readBuffer, 7)))
-
- moreFollows: ModbusDeviceInformationMoreFollows = readEnumField("moreFollows", "ModbusDeviceInformationMoreFollows", DataReaderEnumDefault<>(ModbusDeviceInformationMoreFollows::enumForValue, readUnsignedShort(readBuffer, 8)))
-
- nextObjectId: c_uint8 = readSimpleField("nextObjectId", readUnsignedShort(readBuffer, 8))
-
- numberOfObjects: c_uint8 = readImplicitField("numberOfObjects", readUnsignedShort(readBuffer, 8))
-
- objects: []ModbusDeviceInformationObject = readCountArrayField("objects", DataReaderComplexDefault<>(() -> ModbusDeviceInformationObject.staticParse(readBuffer), readBuffer), numberOfObjects)
+ meiType: c_uint8 = readConstField(
+ "meiType",
+ readUnsignedShort(readBuffer, 8),
+ ModbusPDUReadDeviceIdentificationResponse.MEITYPE,
+ )
+
+ level: ModbusDeviceInformationLevel = readEnumField(
+ "level",
+ "ModbusDeviceInformationLevel",
+ DataReaderEnumDefault(
+ ModbusDeviceInformationLevel.enumForValue,
+ readUnsignedShort(readBuffer, 8),
+ ),
+ )
+
+ individualAccess: c_bool = readSimpleField(
+ "individualAccess", readBoolean(readBuffer)
+ )
+
+ conformityLevel: ModbusDeviceInformationConformityLevel = readEnumField(
+ "conformityLevel",
+ "ModbusDeviceInformationConformityLevel",
+ DataReaderEnumDefault(
+ ModbusDeviceInformationConformityLevel.enumForValue,
+ readUnsignedShort(readBuffer, 7),
+ ),
+ )
+
+ moreFollows: ModbusDeviceInformationMoreFollows = readEnumField(
+ "moreFollows",
+ "ModbusDeviceInformationMoreFollows",
+ DataReaderEnumDefault(
+ ModbusDeviceInformationMoreFollows.enumForValue,
+ readUnsignedShort(readBuffer, 8),
+ ),
+ )
+
+ nextObjectId: c_uint8 = readSimpleField(
+ "nextObjectId", readUnsignedShort(readBuffer, 8)
+ )
+
+ numberOfObjects: c_uint8 = readImplicitField(
+ "numberOfObjects", readUnsignedShort(readBuffer, 8)
+ )
+
+ objects: List[ModbusDeviceInformationObject] = readCountArrayField(
+ "objects",
+ DataReaderComplexDefault(
+ ModbusDeviceInformationObject.staticParse(readBuffer), readBuffer
+ ),
+ numberOfObjects,
+ )
readBuffer.closeContext("ModbusPDUReadDeviceIdentificationResponse")
# Create the instance
- return ModbusPDUReadDeviceIdentificationResponseBuilder(level, individualAccess, conformityLevel, moreFollows, nextObjectId, objects )
-
+ return ModbusPDUReadDeviceIdentificationResponseBuilder(
+ level, individualAccess, conformityLevel, moreFollows, nextObjectId, objects
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -189,11 +262,30 @@ class ModbusPDUReadDeviceIdentificationResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadDeviceIdentificationResponse):
return False
- that: ModbusPDUReadDeviceIdentificationResponse = ModbusPDUReadDeviceIdentificationResponse(o)
- return (getLevel() == that.getLevel()) && (getIndividualAccess() == that.getIndividualAccess()) && (getConformityLevel() == that.getConformityLevel()) && (getMoreFollows() == that.getMoreFollows()) && (getNextObjectId() == that.getNextObjectId()) && (getObjects() == that.getObjects()) && super().equals(that) && True
+ that: ModbusPDUReadDeviceIdentificationResponse = (
+ ModbusPDUReadDeviceIdentificationResponse(o)
+ )
+ return (
+ (self.getLevel() == that.getLevel())
+ and (self.getIndividualAccess() == that.getIndividualAccess())
+ and (self.getConformityLevel() == that.getConformityLevel())
+ and (self.getMoreFollows() == that.getMoreFollows())
+ and (self.getNextObjectId() == that.getNextObjectId())
+ and (self.getObjects() == that.getObjects())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getLevel(), getIndividualAccess(), getConformityLevel(), getMoreFollows(), getNextObjectId(), getObjects() )
+ return hash(
+ super().hashCode(),
+ self.getLevel(),
+ self.getIndividualAccess(),
+ self.getConformityLevel(),
+ self.getMoreFollows(),
+ self.getNextObjectId(),
+ self.getObjects(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -205,25 +297,27 @@ class ModbusPDUReadDeviceIdentificationResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadDeviceIdentificationResponseBuilder(ModbusPDUModbusPDUBuilder: level: ModbusDeviceInformationLevel individualAccess: c_bool conformityLevel: ModbusDeviceInformationConformityLevel moreFollows: ModbusDeviceInformationMoreFollows nextObjectId: c_uint8 objects: []ModbusDeviceInformationObjectdef ModbusPDUReadDeviceIdentificationResponseBuilder( ModbusDeviceInformationLevel level, c_bool individualAccess, ModbusDeviceInformationConformityLevel conformityLevel, ModbusDevice [...]
- self.individualAccess = individualAccess
- self.conformityLevel = conformityLevel
- self.moreFollows = moreFollows
- self.nextObjectId = nextObjectId
- self.objects = objects
+@dataclass
+class ModbusPDUReadDeviceIdentificationResponseBuilder(ModbusPDUModbusPDUBuilder):
+ level: ModbusDeviceInformationLevel
+ individualAccess: c_bool
+ conformityLevel: ModbusDeviceInformationConformityLevel
+ moreFollows: ModbusDeviceInformationMoreFollows
+ nextObjectId: c_uint8
+ objects: List[ModbusDeviceInformationObject]
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUReadDeviceIdentificationResponse:
+ def build(
+ self,
+ ) -> ModbusPDUReadDeviceIdentificationResponse:
modbusPDUReadDeviceIdentificationResponse: ModbusPDUReadDeviceIdentificationResponse = ModbusPDUReadDeviceIdentificationResponse(
- level,
- individualAccess,
- conformityLevel,
- moreFollows,
- nextObjectId,
- objects
-)
+ self.level,
+ self.individualAccess,
+ self.conformityLevel,
+ self.moreFollows,
+ self.nextObjectId,
+ self.objects,
+ )
return modbusPDUReadDeviceIdentificationResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
index 63a3d29172..8f5dbe1146 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReadDiscreteInputsRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadDiscreteInputsRequest(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x02
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x02)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -54,21 +53,21 @@ class ModbusPDUReadDiscreteInputsRequest(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadDiscreteInputsRequest")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
writeBuffer.popContext("ModbusPDUReadDiscreteInputsRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +83,26 @@ class ModbusPDUReadDiscreteInputsRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadDiscreteInputsRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadDiscreteInputsRequestBuilder:
readBuffer.pullContext("ModbusPDUReadDiscreteInputsRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUReadDiscreteInputsRequest")
# Create the instance
- return ModbusPDUReadDiscreteInputsRequestBuilder(startingAddress, quantity )
-
+ return ModbusPDUReadDiscreteInputsRequestBuilder(startingAddress, quantity)
def equals(self, o: object) -> bool:
if self == o:
@@ -109,10 +112,15 @@ class ModbusPDUReadDiscreteInputsRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadDiscreteInputsRequest = ModbusPDUReadDiscreteInputsRequest(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+ return hash(super().hashCode(), self.getStartingAddress(), self.getQuantity())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +132,18 @@ class ModbusPDUReadDiscreteInputsRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadDiscreteInputsRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadDiscreteInputsRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
- self.quantity = quantity
-
+@dataclass
+class ModbusPDUReadDiscreteInputsRequestBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
- def build(self,
- ) -> ModbusPDUReadDiscreteInputsRequest:
- modbusPDUReadDiscreteInputsRequest: ModbusPDUReadDiscreteInputsRequest = ModbusPDUReadDiscreteInputsRequest(
- startingAddress,
- quantity
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadDiscreteInputsRequest:
+ modbusPDUReadDiscreteInputsRequest: ModbusPDUReadDiscreteInputsRequest = (
+ ModbusPDUReadDiscreteInputsRequest(self.startingAddress, self.quantity)
+ )
return modbusPDUReadDiscreteInputsRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
index 17cd5980b0..cc22d3addd 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
@@ -26,38 +26,37 @@ from ctypes import c_bool
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadDiscreteInputsResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+class ModbusPDUReadDiscreteInputsResponse(PlcMessage, ModbusPDU):
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x02
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x02)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
+ super().__init__()
-
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadDiscreteInputsResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -65,7 +64,6 @@ class ModbusPDUReadDiscreteInputsResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadDiscreteInputsResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,28 +75,29 @@ class ModbusPDUReadDiscreteInputsResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadDiscreteInputsResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadDiscreteInputsResponseBuilder:
readBuffer.pullContext("ModbusPDUReadDiscreteInputsResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUReadDiscreteInputsResponse")
# Create the instance
- return ModbusPDUReadDiscreteInputsResponseBuilder(value )
-
+ return ModbusPDUReadDiscreteInputsResponseBuilder(value)
def equals(self, o: object) -> bool:
if self == o:
@@ -107,11 +106,13 @@ class ModbusPDUReadDiscreteInputsResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadDiscreteInputsResponse):
return False
- that: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(o)
- return (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(
+ o
+ )
+ return (self.getValue() == that.getValue()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getValue() )
+ return hash(super().hashCode(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -123,15 +124,17 @@ class ModbusPDUReadDiscreteInputsResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadDiscreteInputsResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadDiscreteInputsResponseBuilder( []c_byte value ): self.value = value
-
+@dataclass
+class ModbusPDUReadDiscreteInputsResponseBuilder(ModbusPDUModbusPDUBuilder):
+ value: List[c_byte]
- def build(self,
- ) -> ModbusPDUReadDiscreteInputsResponse:
- modbusPDUReadDiscreteInputsResponse: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadDiscreteInputsResponse:
+ modbusPDUReadDiscreteInputsResponse: ModbusPDUReadDiscreteInputsResponse = (
+ ModbusPDUReadDiscreteInputsResponse(self.value)
+ )
return modbusPDUReadDiscreteInputsResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
index 19725331be..895abad1db 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
@@ -27,24 +27,22 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadExceptionStatusRequest(PlcMessage, ModbusPDU):
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x07
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x07)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
-
+ super().__init__()
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
@@ -53,7 +51,6 @@ class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadExceptionStatusRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -63,9 +60,10 @@ class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadExceptionStatusRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadExceptionStatusRequestBuilder:
readBuffer.pullContext("ModbusPDUReadExceptionStatusRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -75,7 +73,6 @@ class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
# Create the instance
return ModbusPDUReadExceptionStatusRequestBuilder()
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -83,11 +80,13 @@ class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadExceptionStatusRequest):
return False
- that: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest(o)
- return super().equals(that) && True
+ that: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest(
+ o
+ )
+ return super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode() )
+ return hash(super().hashCode())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -99,13 +98,15 @@ class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadExceptionStatusRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUReadExceptionStatusRequestBuilder( ):
-
- def build(self,
- ) -> ModbusPDUReadExceptionStatusRequest:
- modbusPDUReadExceptionStatusRequest: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest(
-)
+@dataclass
+class ModbusPDUReadExceptionStatusRequestBuilder(ModbusPDUModbusPDUBuilder):
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadExceptionStatusRequest:
+ modbusPDUReadExceptionStatusRequest: ModbusPDUReadExceptionStatusRequest = (
+ ModbusPDUReadExceptionStatusRequest()
+ )
return modbusPDUReadExceptionStatusRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
index 0c8f25a6f5..0c7ef2380c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
@@ -27,29 +27,27 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
+class ModbusPDUReadExceptionStatusResponse(PlcMessage, ModbusPDU):
value: c_uint8
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x07
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x07)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getValue(self) -> c_uint8:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -60,7 +58,6 @@ class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadExceptionStatusResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -73,9 +70,10 @@ class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadExceptionStatusResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadExceptionStatusResponseBuilder:
readBuffer.pullContext("ModbusPDUReadExceptionStatusResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -85,8 +83,7 @@ class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
readBuffer.closeContext("ModbusPDUReadExceptionStatusResponse")
# Create the instance
- return ModbusPDUReadExceptionStatusResponseBuilder(value )
-
+ return ModbusPDUReadExceptionStatusResponseBuilder(value)
def equals(self, o: object) -> bool:
if self == o:
@@ -95,11 +92,13 @@ class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadExceptionStatusResponse):
return False
- that: ModbusPDUReadExceptionStatusResponse = ModbusPDUReadExceptionStatusResponse(o)
- return (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUReadExceptionStatusResponse = (
+ ModbusPDUReadExceptionStatusResponse(o)
+ )
+ return (self.getValue() == that.getValue()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getValue() )
+ return hash(super().hashCode(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -111,15 +110,17 @@ class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadExceptionStatusResponseBuilder(ModbusPDUModbusPDUBuilder: value: c_uint8def ModbusPDUReadExceptionStatusResponseBuilder( c_uint8 value ): self.value = value
-
+@dataclass
+class ModbusPDUReadExceptionStatusResponseBuilder(ModbusPDUModbusPDUBuilder):
+ value: c_uint8
- def build(self,
- ) -> ModbusPDUReadExceptionStatusResponse:
- modbusPDUReadExceptionStatusResponse: ModbusPDUReadExceptionStatusResponse = ModbusPDUReadExceptionStatusResponse(
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadExceptionStatusResponse:
+ modbusPDUReadExceptionStatusResponse: ModbusPDUReadExceptionStatusResponse = (
+ ModbusPDUReadExceptionStatusResponse(self.value)
+ )
return modbusPDUReadExceptionStatusResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
index 838a0c5d24..2d76a2f115 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
@@ -28,40 +28,39 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReadFifoQueueRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadFifoQueueRequest(PlcMessage, ModbusPDU):
fifoPointerAddress: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x18
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x18)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getFifoPointerAddress(self) -> c_uint16:
return self.fifoPointerAddress
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadFifoQueueRequest")
# Simple Field (fifoPointerAddress)
- writeSimpleField("fifoPointerAddress", fifoPointerAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "fifoPointerAddress", fifoPointerAddress, writeUnsignedInt(writeBuffer, 16)
+ )
writeBuffer.popContext("ModbusPDUReadFifoQueueRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -74,20 +73,22 @@ class ModbusPDUReadFifoQueueRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadFifoQueueRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadFifoQueueRequestBuilder:
readBuffer.pullContext("ModbusPDUReadFifoQueueRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- fifoPointerAddress: c_uint16 = readSimpleField("fifoPointerAddress", readUnsignedInt(readBuffer, 16))
+ fifoPointerAddress: c_uint16 = readSimpleField(
+ "fifoPointerAddress", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUReadFifoQueueRequest")
# Create the instance
- return ModbusPDUReadFifoQueueRequestBuilder(fifoPointerAddress )
-
+ return ModbusPDUReadFifoQueueRequestBuilder(fifoPointerAddress)
def equals(self, o: object) -> bool:
if self == o:
@@ -97,10 +98,14 @@ class ModbusPDUReadFifoQueueRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadFifoQueueRequest = ModbusPDUReadFifoQueueRequest(o)
- return (getFifoPointerAddress() == that.getFifoPointerAddress()) && super().equals(that) && True
+ return (
+ (self.getFifoPointerAddress() == that.getFifoPointerAddress())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getFifoPointerAddress() )
+ return hash(super().hashCode(), self.getFifoPointerAddress())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -112,15 +117,17 @@ class ModbusPDUReadFifoQueueRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadFifoQueueRequestBuilder(ModbusPDUModbusPDUBuilder: fifoPointerAddress: c_uint16def ModbusPDUReadFifoQueueRequestBuilder( c_uint16 fifoPointerAddress ): self.fifoPointerAddress = fifoPointerAddress
-
+@dataclass
+class ModbusPDUReadFifoQueueRequestBuilder(ModbusPDUModbusPDUBuilder):
+ fifoPointerAddress: c_uint16
- def build(self,
- ) -> ModbusPDUReadFifoQueueRequest:
- modbusPDUReadFifoQueueRequest: ModbusPDUReadFifoQueueRequest = ModbusPDUReadFifoQueueRequest(
- fifoPointerAddress
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadFifoQueueRequest:
+ modbusPDUReadFifoQueueRequest: ModbusPDUReadFifoQueueRequest = (
+ ModbusPDUReadFifoQueueRequest(self.fifoPointerAddress)
+ )
return modbusPDUReadFifoQueueRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
index e2e3b4412a..07b64b3362 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
@@ -26,50 +26,50 @@ from ctypes import c_bool
from ctypes import c_uint16
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadFifoQueueResponse(PlcMessage,ModbusPDU):
- fifoValue: []c_uint16
+class ModbusPDUReadFifoQueueResponse(PlcMessage, ModbusPDU):
+ fifoValue: List[c_uint16]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x18
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x18)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
+ super().__init__()
-
- def getFifoValue(self) -> []c_uint16:
+ def getFifoValue(self) -> List[c_uint16]:
return self.fifoValue
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadFifoQueueResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint16 byteCount = (c_uint16) ((((COUNT(getFifoValue())) * (2))) + (2))
+ byteCount: c_uint16 = c_uint16(((((COUNT(self.getFifoValue())) * (2))) + (2)))
writeImplicitField("byteCount", byteCount, writeUnsignedInt(writeBuffer, 16))
# Implicit Field (fifoCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint16 fifoCount = (c_uint16) ((((COUNT(getFifoValue())) * (2))) / (2))
+ fifoCount: c_uint16 = c_uint16(((((COUNT(self.getFifoValue())) * (2))) / (2)))
writeImplicitField("fifoCount", fifoCount, writeUnsignedInt(writeBuffer, 16))
# Array Field (fifoValue)
- writeSimpleTypeArrayField("fifoValue", fifoValue, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleTypeArrayField(
+ "fifoValue", fifoValue, writeUnsignedInt(writeBuffer, 16)
+ )
writeBuffer.popContext("ModbusPDUReadFifoQueueResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,30 +84,35 @@ class ModbusPDUReadFifoQueueResponse(PlcMessage,ModbusPDU):
lengthInBits += 16
# Array field
- if fifoValue is not None):
- lengthInBits += 16 * fifoValue.size()
-
+ if self.fifoValue is not None:
+ lengthInBits += 16 * self.fifoValue.size()
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadFifoQueueResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadFifoQueueResponseBuilder:
readBuffer.pullContext("ModbusPDUReadFifoQueueResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint16 = readImplicitField("byteCount", readUnsignedInt(readBuffer, 16))
+ byteCount: c_uint16 = readImplicitField(
+ "byteCount", readUnsignedInt(readBuffer, 16)
+ )
- fifoCount: c_uint16 = readImplicitField("fifoCount", readUnsignedInt(readBuffer, 16))
+ fifoCount: c_uint16 = readImplicitField(
+ "fifoCount", readUnsignedInt(readBuffer, 16)
+ )
- fifoValue: []c_uint16 = readCountArrayField("fifoValue", readUnsignedInt(readBuffer, 16), fifoCount)
+ fifoValue: List[c_uint16] = readCountArrayField(
+ "fifoValue", readUnsignedInt(readBuffer, 16), fifoCount
+ )
readBuffer.closeContext("ModbusPDUReadFifoQueueResponse")
# Create the instance
- return ModbusPDUReadFifoQueueResponseBuilder(fifoValue )
-
+ return ModbusPDUReadFifoQueueResponseBuilder(fifoValue)
def equals(self, o: object) -> bool:
if self == o:
@@ -117,10 +122,14 @@ class ModbusPDUReadFifoQueueResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadFifoQueueResponse = ModbusPDUReadFifoQueueResponse(o)
- return (getFifoValue() == that.getFifoValue()) && super().equals(that) && True
+ return (
+ (self.getFifoValue() == that.getFifoValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getFifoValue() )
+ return hash(super().hashCode(), self.getFifoValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -132,15 +141,17 @@ class ModbusPDUReadFifoQueueResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadFifoQueueResponseBuilder(ModbusPDUModbusPDUBuilder: fifoValue: []c_uint16def ModbusPDUReadFifoQueueResponseBuilder( []c_uint16 fifoValue ): self.fifoValue = fifoValue
-
+@dataclass
+class ModbusPDUReadFifoQueueResponseBuilder(ModbusPDUModbusPDUBuilder):
+ fifoValue: List[c_uint16]
- def build(self,
- ) -> ModbusPDUReadFifoQueueResponse:
- modbusPDUReadFifoQueueResponse: ModbusPDUReadFifoQueueResponse = ModbusPDUReadFifoQueueResponse(
- fifoValue
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadFifoQueueResponse:
+ modbusPDUReadFifoQueueResponse: ModbusPDUReadFifoQueueResponse = (
+ ModbusPDUReadFifoQueueResponse(self.fifoValue)
+ )
return modbusPDUReadFifoQueueResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
index a2db41403a..6d85bc262d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
@@ -25,39 +25,40 @@ from dataclasses import dataclass
from ctypes import c_bool
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
-from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordRequestItem import ModbusPDUReadFileRecordRequestItem
+from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordRequestItem import (
+ ModbusPDUReadFileRecordRequestItem,
+)
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadFileRecordRequest(PlcMessage,ModbusPDU):
- items: []ModbusPDUReadFileRecordRequestItem
+class ModbusPDUReadFileRecordRequest(PlcMessage, ModbusPDU):
+ items: List[ModbusPDUReadFileRecordRequestItem]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x14
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x14)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
+ super().__init__()
-
-
- def getItems(self) -> []ModbusPDUReadFileRecordRequestItem:
+ def getItems(self) -> List[ModbusPDUReadFileRecordRequestItem]:
return self.items
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadFileRecordRequest")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
+ byteCount: c_uint8 = c_uint8((ARRAY_SIZE_IN_BYTES(self.getItems())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -65,7 +66,6 @@ class ModbusPDUReadFileRecordRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadFileRecordRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,30 +77,36 @@ class ModbusPDUReadFileRecordRequest(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if items is not None):
+ if self.items is not None:
for element in items:
lengthInBits += element.getLengthInBits()
-
-
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadFileRecordRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadFileRecordRequestBuilder:
readBuffer.pullContext("ModbusPDUReadFileRecordRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- items: []ModbusPDUReadFileRecordRequestItem = readLengthArrayField("items", DataReaderComplexDefault<>(() -> ModbusPDUReadFileRecordRequestItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: List[ModbusPDUReadFileRecordRequestItem] = readLengthArrayField(
+ "items",
+ DataReaderComplexDefault(
+ ModbusPDUReadFileRecordRequestItem.staticParse(readBuffer), readBuffer
+ ),
+ byteCount,
+ )
readBuffer.closeContext("ModbusPDUReadFileRecordRequest")
# Create the instance
- return ModbusPDUReadFileRecordRequestBuilder(items )
-
+ return ModbusPDUReadFileRecordRequestBuilder(items)
def equals(self, o: object) -> bool:
if self == o:
@@ -110,10 +116,10 @@ class ModbusPDUReadFileRecordRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadFileRecordRequest = ModbusPDUReadFileRecordRequest(o)
- return (getItems() == that.getItems()) && super().equals(that) && True
+ return (self.getItems() == that.getItems()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getItems() )
+ return hash(super().hashCode(), self.getItems())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -125,15 +131,17 @@ class ModbusPDUReadFileRecordRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUReadFileRecordRequestItemdef ModbusPDUReadFileRecordRequestBuilder( []ModbusPDUReadFileRecordRequestItem items ): self.items = items
-
+@dataclass
+class ModbusPDUReadFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder):
+ items: List[ModbusPDUReadFileRecordRequestItem]
- def build(self,
- ) -> ModbusPDUReadFileRecordRequest:
- modbusPDUReadFileRecordRequest: ModbusPDUReadFileRecordRequest = ModbusPDUReadFileRecordRequest(
- items
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadFileRecordRequest:
+ modbusPDUReadFileRecordRequest: ModbusPDUReadFileRecordRequest = (
+ ModbusPDUReadFileRecordRequest(self.items)
+ )
return modbusPDUReadFileRecordRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
index e273dc5d9c..ff6973649f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
@@ -27,7 +27,7 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
class ModbusPDUReadFileRecordRequestItem(PlcMessage):
referenceType: c_uint8
@@ -35,12 +35,8 @@ class ModbusPDUReadFileRecordRequestItem(PlcMessage):
recordNumber: c_uint16
recordLength: c_uint16
-
-
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getReferenceType(self) -> c_uint8:
return self.referenceType
@@ -54,27 +50,31 @@ class ModbusPDUReadFileRecordRequestItem(PlcMessage):
def getRecordLength(self) -> c_uint16:
return self.recordLength
-
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadFileRecordRequestItem")
# Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ writeSimpleField(
+ "referenceType", referenceType, writeUnsignedShort(writeBuffer, 8)
+ )
# Simple Field (fileNumber)
writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
# Simple Field (recordNumber)
- writeSimpleField("recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (recordLength)
- writeSimpleField("recordLength", recordLength, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "recordLength", recordLength, writeUnsignedInt(writeBuffer, 16)
+ )
writeBuffer.popContext("ModbusPDUReadFileRecordRequestItem")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -96,33 +96,44 @@ class ModbusPDUReadFileRecordRequestItem(PlcMessage):
return lengthInBits
-
- def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUReadFileRecordRequestItem:
+ def staticParse(readBuffer: ReadBuffer, args) -> ModbusPDUReadFileRecordRequestItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
-
@staticmethod
- def staticParseContext(readBuffer: ReadBuffer) -> ModbusPDUReadFileRecordRequestItem:
+ def staticParseContext(
+ readBuffer: ReadBuffer,
+ ) -> ModbusPDUReadFileRecordRequestItem:
readBuffer.pullContext("ModbusPDUReadFileRecordRequestItem")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField(
+ "referenceType", readUnsignedShort(readBuffer, 8)
+ )
- fileNumber: c_uint16 = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
+ fileNumber: c_uint16 = readSimpleField(
+ "fileNumber", readUnsignedInt(readBuffer, 16)
+ )
- recordNumber: c_uint16 = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
+ recordNumber: c_uint16 = readSimpleField(
+ "recordNumber", readUnsignedInt(readBuffer, 16)
+ )
- recordLength: c_uint16 = readSimpleField("recordLength", readUnsignedInt(readBuffer, 16))
+ recordLength: c_uint16 = readSimpleField(
+ "recordLength", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUReadFileRecordRequestItem")
# Create the instance
- _modbusPDUReadFileRecordRequestItem: ModbusPDUReadFileRecordRequestItem = ModbusPDUReadFileRecordRequestItem(referenceType, fileNumber, recordNumber, recordLength )
+ _modbusPDUReadFileRecordRequestItem: ModbusPDUReadFileRecordRequestItem = (
+ ModbusPDUReadFileRecordRequestItem(
+ referenceType, fileNumber, recordNumber, recordLength
+ )
+ )
return _modbusPDUReadFileRecordRequestItem
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -131,10 +142,21 @@ class ModbusPDUReadFileRecordRequestItem(PlcMessage):
return False
that: ModbusPDUReadFileRecordRequestItem = ModbusPDUReadFileRecordRequestItem(o)
- return (getReferenceType() == that.getReferenceType()) && (getFileNumber() == that.getFileNumber()) && (getRecordNumber() == that.getRecordNumber()) && (getRecordLength() == that.getRecordLength()) && True
+ return (
+ (self.getReferenceType() == that.getReferenceType())
+ and (self.getFileNumber() == that.getFileNumber())
+ and (self.getRecordNumber() == that.getRecordNumber())
+ and (self.getRecordLength() == that.getRecordLength())
+ and True
+ )
def hashCode(self) -> int:
- return hash(getReferenceType(), getFileNumber(), getRecordNumber(), getRecordLength() )
+ return hash(
+ self.getReferenceType(),
+ self.getFileNumber(),
+ self.getRecordNumber(),
+ self.getRecordLength(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -144,7 +166,3 @@ class ModbusPDUReadFileRecordRequestItem(PlcMessage):
raise RuntimeException(e)
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
index d20c98bec8..a3493d0fdb 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
@@ -25,39 +25,40 @@ from dataclasses import dataclass
from ctypes import c_bool
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
-from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordResponseItem import ModbusPDUReadFileRecordResponseItem
+from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordResponseItem import (
+ ModbusPDUReadFileRecordResponseItem,
+)
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadFileRecordResponse(PlcMessage,ModbusPDU):
- items: []ModbusPDUReadFileRecordResponseItem
+class ModbusPDUReadFileRecordResponse(PlcMessage, ModbusPDU):
+ items: List[ModbusPDUReadFileRecordResponseItem]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x14
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x14)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
+ super().__init__()
-
-
- def getItems(self) -> []ModbusPDUReadFileRecordResponseItem:
+ def getItems(self) -> List[ModbusPDUReadFileRecordResponseItem]:
return self.items
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadFileRecordResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
+ byteCount: c_uint8 = c_uint8((ARRAY_SIZE_IN_BYTES(self.getItems())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -65,7 +66,6 @@ class ModbusPDUReadFileRecordResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadFileRecordResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,30 +77,36 @@ class ModbusPDUReadFileRecordResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if items is not None):
+ if self.items is not None:
for element in items:
lengthInBits += element.getLengthInBits()
-
-
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadFileRecordResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadFileRecordResponseBuilder:
readBuffer.pullContext("ModbusPDUReadFileRecordResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- items: []ModbusPDUReadFileRecordResponseItem = readLengthArrayField("items", DataReaderComplexDefault<>(() -> ModbusPDUReadFileRecordResponseItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: List[ModbusPDUReadFileRecordResponseItem] = readLengthArrayField(
+ "items",
+ DataReaderComplexDefault(
+ ModbusPDUReadFileRecordResponseItem.staticParse(readBuffer), readBuffer
+ ),
+ byteCount,
+ )
readBuffer.closeContext("ModbusPDUReadFileRecordResponse")
# Create the instance
- return ModbusPDUReadFileRecordResponseBuilder(items )
-
+ return ModbusPDUReadFileRecordResponseBuilder(items)
def equals(self, o: object) -> bool:
if self == o:
@@ -110,10 +116,10 @@ class ModbusPDUReadFileRecordResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadFileRecordResponse = ModbusPDUReadFileRecordResponse(o)
- return (getItems() == that.getItems()) && super().equals(that) && True
+ return (self.getItems() == that.getItems()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getItems() )
+ return hash(super().hashCode(), self.getItems())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -125,15 +131,17 @@ class ModbusPDUReadFileRecordResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUReadFileRecordResponseItemdef ModbusPDUReadFileRecordResponseBuilder( []ModbusPDUReadFileRecordResponseItem items ): self.items = items
-
+@dataclass
+class ModbusPDUReadFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder):
+ items: List[ModbusPDUReadFileRecordResponseItem]
- def build(self,
- ) -> ModbusPDUReadFileRecordResponse:
- modbusPDUReadFileRecordResponse: ModbusPDUReadFileRecordResponse = ModbusPDUReadFileRecordResponse(
- items
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadFileRecordResponse:
+ modbusPDUReadFileRecordResponse: ModbusPDUReadFileRecordResponse = (
+ ModbusPDUReadFileRecordResponse(self.items)
+ )
return modbusPDUReadFileRecordResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
index 82023aa782..00bc975741 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
@@ -25,46 +25,43 @@ from dataclasses import dataclass
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
class ModbusPDUReadFileRecordResponseItem(PlcMessage):
referenceType: c_uint8
- data: []c_byte
-
-
+ data: List[c_byte]
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getReferenceType(self) -> c_uint8:
return self.referenceType
- def getData(self) -> []c_byte:
+ def getData(self) -> List[c_byte]:
return self.data
-
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadFileRecordResponseItem")
# Implicit Field (dataLength) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 dataLength = (c_uint8) ((COUNT(getData())) + (1))
+ dataLength: c_uint8 = c_uint8(((COUNT(self.getData())) + (1)))
writeImplicitField("dataLength", dataLength, writeUnsignedShort(writeBuffer, 8))
# Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ writeSimpleField(
+ "referenceType", referenceType, writeUnsignedShort(writeBuffer, 8)
+ )
# Array Field (data)
writeByteArrayField("data", data, writeByteArray(writeBuffer, 8))
writeBuffer.popContext("ModbusPDUReadFileRecordResponseItem")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -79,37 +76,43 @@ class ModbusPDUReadFileRecordResponseItem(PlcMessage):
lengthInBits += 8
# Array field
- if data is not None):
- lengthInBits += 8 * data.length
-
+ if self.data is not None:
+ lengthInBits += 8 * self.data.length
return lengthInBits
-
- def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUReadFileRecordResponseItem:
+ def staticParse(
+ readBuffer: ReadBuffer, args
+ ) -> ModbusPDUReadFileRecordResponseItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
-
@staticmethod
- def staticParseContext(readBuffer: ReadBuffer) -> ModbusPDUReadFileRecordResponseItem:
+ def staticParseContext(
+ readBuffer: ReadBuffer,
+ ) -> ModbusPDUReadFileRecordResponseItem:
readBuffer.pullContext("ModbusPDUReadFileRecordResponseItem")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- dataLength: c_uint8 = readImplicitField("dataLength", readUnsignedShort(readBuffer, 8))
+ dataLength: c_uint8 = readImplicitField(
+ "dataLength", readUnsignedShort(readBuffer, 8)
+ )
- referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField(
+ "referenceType", readUnsignedShort(readBuffer, 8)
+ )
- data: byte[] = readBuffer.readByteArray("data", Math.toIntExact((dataLength) - (1)))
+ data: List[byte] = readBuffer.readByteArray("data", int((dataLength) - (1)))
readBuffer.closeContext("ModbusPDUReadFileRecordResponseItem")
# Create the instance
- _modbusPDUReadFileRecordResponseItem: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(referenceType, data )
+ _modbusPDUReadFileRecordResponseItem: ModbusPDUReadFileRecordResponseItem = (
+ ModbusPDUReadFileRecordResponseItem(referenceType, data)
+ )
return _modbusPDUReadFileRecordResponseItem
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -117,11 +120,17 @@ class ModbusPDUReadFileRecordResponseItem(PlcMessage):
if not isinstance(o, ModbusPDUReadFileRecordResponseItem):
return False
- that: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(o)
- return (getReferenceType() == that.getReferenceType()) && (getData() == that.getData()) && True
+ that: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(
+ o
+ )
+ return (
+ (self.getReferenceType() == that.getReferenceType())
+ and (self.getData() == that.getData())
+ and True
+ )
def hashCode(self) -> int:
- return hash(getReferenceType(), getData() )
+ return hash(self.getReferenceType(), self.getData())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -131,7 +140,3 @@ class ModbusPDUReadFileRecordResponseItem(PlcMessage):
raise RuntimeException(e)
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
index 1f466a80c3..cedad66bee 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReadHoldingRegistersRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadHoldingRegistersRequest(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x03
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x03)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -54,21 +53,21 @@ class ModbusPDUReadHoldingRegistersRequest(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadHoldingRegistersRequest")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
writeBuffer.popContext("ModbusPDUReadHoldingRegistersRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +83,26 @@ class ModbusPDUReadHoldingRegistersRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadHoldingRegistersRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadHoldingRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUReadHoldingRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUReadHoldingRegistersRequest")
# Create the instance
- return ModbusPDUReadHoldingRegistersRequestBuilder(startingAddress, quantity )
-
+ return ModbusPDUReadHoldingRegistersRequestBuilder(startingAddress, quantity)
def equals(self, o: object) -> bool:
if self == o:
@@ -108,11 +111,18 @@ class ModbusPDUReadHoldingRegistersRequest(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadHoldingRegistersRequest):
return False
- that: ModbusPDUReadHoldingRegistersRequest = ModbusPDUReadHoldingRegistersRequest(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
+ that: ModbusPDUReadHoldingRegistersRequest = (
+ ModbusPDUReadHoldingRegistersRequest(o)
+ )
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+ return hash(super().hashCode(), self.getStartingAddress(), self.getQuantity())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +134,18 @@ class ModbusPDUReadHoldingRegistersRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadHoldingRegistersRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
- self.quantity = quantity
-
+@dataclass
+class ModbusPDUReadHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
- def build(self,
- ) -> ModbusPDUReadHoldingRegistersRequest:
- modbusPDUReadHoldingRegistersRequest: ModbusPDUReadHoldingRegistersRequest = ModbusPDUReadHoldingRegistersRequest(
- startingAddress,
- quantity
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadHoldingRegistersRequest:
+ modbusPDUReadHoldingRegistersRequest: ModbusPDUReadHoldingRegistersRequest = (
+ ModbusPDUReadHoldingRegistersRequest(self.startingAddress, self.quantity)
+ )
return modbusPDUReadHoldingRegistersRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
index 287d840838..8dcedc1a60 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
@@ -26,38 +26,37 @@ from ctypes import c_bool
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadHoldingRegistersResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+class ModbusPDUReadHoldingRegistersResponse(PlcMessage, ModbusPDU):
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x03
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x03)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
+ super().__init__()
-
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadHoldingRegistersResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -65,7 +64,6 @@ class ModbusPDUReadHoldingRegistersResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadHoldingRegistersResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,28 +75,29 @@ class ModbusPDUReadHoldingRegistersResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadHoldingRegistersResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadHoldingRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUReadHoldingRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUReadHoldingRegistersResponse")
# Create the instance
- return ModbusPDUReadHoldingRegistersResponseBuilder(value )
-
+ return ModbusPDUReadHoldingRegistersResponseBuilder(value)
def equals(self, o: object) -> bool:
if self == o:
@@ -107,11 +106,13 @@ class ModbusPDUReadHoldingRegistersResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadHoldingRegistersResponse):
return False
- that: ModbusPDUReadHoldingRegistersResponse = ModbusPDUReadHoldingRegistersResponse(o)
- return (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUReadHoldingRegistersResponse = (
+ ModbusPDUReadHoldingRegistersResponse(o)
+ )
+ return (self.getValue() == that.getValue()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getValue() )
+ return hash(super().hashCode(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -123,15 +124,17 @@ class ModbusPDUReadHoldingRegistersResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadHoldingRegistersResponseBuilder( []c_byte value ): self.value = value
-
+@dataclass
+class ModbusPDUReadHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder):
+ value: List[c_byte]
- def build(self,
- ) -> ModbusPDUReadHoldingRegistersResponse:
- modbusPDUReadHoldingRegistersResponse: ModbusPDUReadHoldingRegistersResponse = ModbusPDUReadHoldingRegistersResponse(
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadHoldingRegistersResponse:
+ modbusPDUReadHoldingRegistersResponse: ModbusPDUReadHoldingRegistersResponse = (
+ ModbusPDUReadHoldingRegistersResponse(self.value)
+ )
return modbusPDUReadHoldingRegistersResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
index 6d3380241a..0a63e804a5 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReadInputRegistersRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadInputRegistersRequest(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x04
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x04)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -54,21 +53,21 @@ class ModbusPDUReadInputRegistersRequest(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadInputRegistersRequest")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
writeBuffer.popContext("ModbusPDUReadInputRegistersRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +83,26 @@ class ModbusPDUReadInputRegistersRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadInputRegistersRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadInputRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUReadInputRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUReadInputRegistersRequest")
# Create the instance
- return ModbusPDUReadInputRegistersRequestBuilder(startingAddress, quantity )
-
+ return ModbusPDUReadInputRegistersRequestBuilder(startingAddress, quantity)
def equals(self, o: object) -> bool:
if self == o:
@@ -109,10 +112,15 @@ class ModbusPDUReadInputRegistersRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReadInputRegistersRequest = ModbusPDUReadInputRegistersRequest(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+ return hash(super().hashCode(), self.getStartingAddress(), self.getQuantity())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +132,18 @@ class ModbusPDUReadInputRegistersRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadInputRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadInputRegistersRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
- self.quantity = quantity
-
+@dataclass
+class ModbusPDUReadInputRegistersRequestBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
- def build(self,
- ) -> ModbusPDUReadInputRegistersRequest:
- modbusPDUReadInputRegistersRequest: ModbusPDUReadInputRegistersRequest = ModbusPDUReadInputRegistersRequest(
- startingAddress,
- quantity
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadInputRegistersRequest:
+ modbusPDUReadInputRegistersRequest: ModbusPDUReadInputRegistersRequest = (
+ ModbusPDUReadInputRegistersRequest(self.startingAddress, self.quantity)
+ )
return modbusPDUReadInputRegistersRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
index d1db29bb77..d819bfbc70 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
@@ -26,38 +26,37 @@ from ctypes import c_bool
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadInputRegistersResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+class ModbusPDUReadInputRegistersResponse(PlcMessage, ModbusPDU):
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x04
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x04)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
+ super().__init__()
-
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadInputRegistersResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -65,7 +64,6 @@ class ModbusPDUReadInputRegistersResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadInputRegistersResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,28 +75,29 @@ class ModbusPDUReadInputRegistersResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadInputRegistersResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadInputRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUReadInputRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUReadInputRegistersResponse")
# Create the instance
- return ModbusPDUReadInputRegistersResponseBuilder(value )
-
+ return ModbusPDUReadInputRegistersResponseBuilder(value)
def equals(self, o: object) -> bool:
if self == o:
@@ -107,11 +106,13 @@ class ModbusPDUReadInputRegistersResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadInputRegistersResponse):
return False
- that: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(o)
- return (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(
+ o
+ )
+ return (self.getValue() == that.getValue()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getValue() )
+ return hash(super().hashCode(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -123,15 +124,17 @@ class ModbusPDUReadInputRegistersResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadInputRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadInputRegistersResponseBuilder( []c_byte value ): self.value = value
-
+@dataclass
+class ModbusPDUReadInputRegistersResponseBuilder(ModbusPDUModbusPDUBuilder):
+ value: List[c_byte]
- def build(self,
- ) -> ModbusPDUReadInputRegistersResponse:
- modbusPDUReadInputRegistersResponse: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReadInputRegistersResponse:
+ modbusPDUReadInputRegistersResponse: ModbusPDUReadInputRegistersResponse = (
+ ModbusPDUReadInputRegistersResponse(self.value)
+ )
return modbusPDUReadInputRegistersResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
index 643505087b..4dadbfc4de 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
@@ -27,30 +27,30 @@ from ctypes import c_byte
from ctypes import c_uint16
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage, ModbusPDU):
readStartingAddress: c_uint16
readQuantity: c_uint16
writeStartingAddress: c_uint16
writeQuantity: c_uint16
- value: []c_byte
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x17
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x17)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getReadStartingAddress(self) -> c_uint16:
return self.readStartingAddress
@@ -64,29 +64,40 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
def getWriteQuantity(self) -> c_uint16:
return self.writeQuantity
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
# Simple Field (readStartingAddress)
- writeSimpleField("readStartingAddress", readStartingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "readStartingAddress",
+ readStartingAddress,
+ writeUnsignedInt(writeBuffer, 16),
+ )
# Simple Field (readQuantity)
- writeSimpleField("readQuantity", readQuantity, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "readQuantity", readQuantity, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (writeStartingAddress)
- writeSimpleField("writeStartingAddress", writeStartingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "writeStartingAddress",
+ writeStartingAddress,
+ writeUnsignedInt(writeBuffer, 16),
+ )
# Simple Field (writeQuantity)
- writeSimpleField("writeQuantity", writeQuantity, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "writeQuantity", writeQuantity, writeUnsignedInt(writeBuffer, 16)
+ )
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -94,7 +105,6 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -118,36 +128,51 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- readStartingAddress: c_uint16 = readSimpleField("readStartingAddress", readUnsignedInt(readBuffer, 16))
+ readStartingAddress: c_uint16 = readSimpleField(
+ "readStartingAddress", readUnsignedInt(readBuffer, 16)
+ )
- readQuantity: c_uint16 = readSimpleField("readQuantity", readUnsignedInt(readBuffer, 16))
+ readQuantity: c_uint16 = readSimpleField(
+ "readQuantity", readUnsignedInt(readBuffer, 16)
+ )
- writeStartingAddress: c_uint16 = readSimpleField("writeStartingAddress", readUnsignedInt(readBuffer, 16))
+ writeStartingAddress: c_uint16 = readSimpleField(
+ "writeStartingAddress", readUnsignedInt(readBuffer, 16)
+ )
- writeQuantity: c_uint16 = readSimpleField("writeQuantity", readUnsignedInt(readBuffer, 16))
+ writeQuantity: c_uint16 = readSimpleField(
+ "writeQuantity", readUnsignedInt(readBuffer, 16)
+ )
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
# Create the instance
- return ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(readStartingAddress, readQuantity, writeStartingAddress, writeQuantity, value )
-
+ return ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(
+ readStartingAddress,
+ readQuantity,
+ writeStartingAddress,
+ writeQuantity,
+ value,
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -156,11 +181,28 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadWriteMultipleHoldingRegistersRequest):
return False
- that: ModbusPDUReadWriteMultipleHoldingRegistersRequest = ModbusPDUReadWriteMultipleHoldingRegistersRequest(o)
- return (getReadStartingAddress() == that.getReadStartingAddress()) && (getReadQuantity() == that.getReadQuantity()) && (getWriteStartingAddress() == that.getWriteStartingAddress()) && (getWriteQuantity() == that.getWriteQuantity()) && (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUReadWriteMultipleHoldingRegistersRequest = (
+ ModbusPDUReadWriteMultipleHoldingRegistersRequest(o)
+ )
+ return (
+ (self.getReadStartingAddress() == that.getReadStartingAddress())
+ and (self.getReadQuantity() == that.getReadQuantity())
+ and (self.getWriteStartingAddress() == that.getWriteStartingAddress())
+ and (self.getWriteQuantity() == that.getWriteQuantity())
+ and (self.getValue() == that.getValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getReadStartingAddress(), getReadQuantity(), getWriteStartingAddress(), getWriteQuantity(), getValue() )
+ return hash(
+ super().hashCode(),
+ self.getReadStartingAddress(),
+ self.getReadQuantity(),
+ self.getWriteStartingAddress(),
+ self.getWriteQuantity(),
+ self.getValue(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -172,23 +214,27 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: readStartingAddress: c_uint16 readQuantity: c_uint16 writeStartingAddress: c_uint16 writeQuantity: c_uint16 value: []c_bytedef ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder( c_uint16 readStartingAddress, c_uint16 readQuantity, c_uint16 writeStartingAddress, c_uint16 writeQuantity, []c_byte value ): self.readStartingAddress = readStartingAddress
- self.readQuantity = readQuantity
- self.writeStartingAddress = writeStartingAddress
- self.writeQuantity = writeQuantity
- self.value = value
+@dataclass
+class ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(
+ ModbusPDUModbusPDUBuilder
+):
+ readStartingAddress: c_uint16
+ readQuantity: c_uint16
+ writeStartingAddress: c_uint16
+ writeQuantity: c_uint16
+ value: List[c_byte]
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUReadWriteMultipleHoldingRegistersRequest:
+ def build(
+ self,
+ ) -> ModbusPDUReadWriteMultipleHoldingRegistersRequest:
modbusPDUReadWriteMultipleHoldingRegistersRequest: ModbusPDUReadWriteMultipleHoldingRegistersRequest = ModbusPDUReadWriteMultipleHoldingRegistersRequest(
- readStartingAddress,
- readQuantity,
- writeStartingAddress,
- writeQuantity,
- value
-)
+ self.readStartingAddress,
+ self.readQuantity,
+ self.writeStartingAddress,
+ self.writeQuantity,
+ self.value,
+ )
return modbusPDUReadWriteMultipleHoldingRegistersRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
index becce42ab1..b3a07b4012 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
@@ -26,38 +26,37 @@ from ctypes import c_bool
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage, ModbusPDU):
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x17
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x17)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
+ super().__init__()
-
-
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -65,7 +64,6 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,28 +75,29 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
# Create the instance
- return ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(value )
-
+ return ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(value)
def equals(self, o: object) -> bool:
if self == o:
@@ -107,11 +106,13 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUReadWriteMultipleHoldingRegistersResponse):
return False
- that: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ModbusPDUReadWriteMultipleHoldingRegistersResponse(o)
- return (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUReadWriteMultipleHoldingRegistersResponse = (
+ ModbusPDUReadWriteMultipleHoldingRegistersResponse(o)
+ )
+ return (self.getValue() == that.getValue()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getValue() )
+ return hash(super().hashCode(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -123,15 +124,19 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder( []c_byte value ): self.value = value
+@dataclass
+class ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(
+ ModbusPDUModbusPDUBuilder
+):
+ value: List[c_byte]
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUReadWriteMultipleHoldingRegistersResponse:
+ def build(
+ self,
+ ) -> ModbusPDUReadWriteMultipleHoldingRegistersResponse:
modbusPDUReadWriteMultipleHoldingRegistersResponse: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ModbusPDUReadWriteMultipleHoldingRegistersResponse(
- value
-)
+ self.value
+ )
return modbusPDUReadWriteMultipleHoldingRegistersResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
index 704eb18e91..520370db60 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
@@ -27,24 +27,22 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
+class ModbusPDUReportServerIdRequest(PlcMessage, ModbusPDU):
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x11
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x11)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
-
+ super().__init__()
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
@@ -53,7 +51,6 @@ class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReportServerIdRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -63,9 +60,10 @@ class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReportServerIdRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReportServerIdRequestBuilder:
readBuffer.pullContext("ModbusPDUReportServerIdRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -75,7 +73,6 @@ class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
# Create the instance
return ModbusPDUReportServerIdRequestBuilder()
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -84,10 +81,10 @@ class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReportServerIdRequest = ModbusPDUReportServerIdRequest(o)
- return super().equals(that) && True
+ return super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode() )
+ return hash(super().hashCode())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -99,13 +96,15 @@ class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReportServerIdRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUReportServerIdRequestBuilder( ):
-
- def build(self,
- ) -> ModbusPDUReportServerIdRequest:
- modbusPDUReportServerIdRequest: ModbusPDUReportServerIdRequest = ModbusPDUReportServerIdRequest(
-)
+@dataclass
+class ModbusPDUReportServerIdRequestBuilder(ModbusPDUModbusPDUBuilder):
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReportServerIdRequest:
+ modbusPDUReportServerIdRequest: ModbusPDUReportServerIdRequest = (
+ ModbusPDUReportServerIdRequest()
+ )
return modbusPDUReportServerIdRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
index 4e8f380f68..cacb4dd02b 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
@@ -26,38 +26,37 @@ from ctypes import c_bool
from ctypes import c_byte
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUReportServerIdResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+class ModbusPDUReportServerIdResponse(PlcMessage, ModbusPDU):
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x11
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x11)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
+ super().__init__()
-
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUReportServerIdResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -65,7 +64,6 @@ class ModbusPDUReportServerIdResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUReportServerIdResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,28 +75,29 @@ class ModbusPDUReportServerIdResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReportServerIdResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUReportServerIdResponseBuilder:
readBuffer.pullContext("ModbusPDUReportServerIdResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUReportServerIdResponse")
# Create the instance
- return ModbusPDUReportServerIdResponseBuilder(value )
-
+ return ModbusPDUReportServerIdResponseBuilder(value)
def equals(self, o: object) -> bool:
if self == o:
@@ -108,10 +107,10 @@ class ModbusPDUReportServerIdResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUReportServerIdResponse = ModbusPDUReportServerIdResponse(o)
- return (getValue() == that.getValue()) && super().equals(that) && True
+ return (self.getValue() == that.getValue()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getValue() )
+ return hash(super().hashCode(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -123,15 +122,17 @@ class ModbusPDUReportServerIdResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUReportServerIdResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReportServerIdResponseBuilder( []c_byte value ): self.value = value
-
+@dataclass
+class ModbusPDUReportServerIdResponseBuilder(ModbusPDUModbusPDUBuilder):
+ value: List[c_byte]
- def build(self,
- ) -> ModbusPDUReportServerIdResponse:
- modbusPDUReportServerIdResponse: ModbusPDUReportServerIdResponse = ModbusPDUReportServerIdResponse(
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUReportServerIdResponse:
+ modbusPDUReportServerIdResponse: ModbusPDUReportServerIdResponse = (
+ ModbusPDUReportServerIdResponse(self.value)
+ )
return modbusPDUReportServerIdResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
index 56edf21492..d1129b4ccc 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
@@ -25,39 +25,40 @@ from dataclasses import dataclass
from ctypes import c_bool
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
-from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordRequestItem import ModbusPDUWriteFileRecordRequestItem
+from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordRequestItem import (
+ ModbusPDUWriteFileRecordRequestItem,
+)
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUWriteFileRecordRequest(PlcMessage,ModbusPDU):
- items: []ModbusPDUWriteFileRecordRequestItem
+class ModbusPDUWriteFileRecordRequest(PlcMessage, ModbusPDU):
+ items: List[ModbusPDUWriteFileRecordRequestItem]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x15
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x15)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
+ super().__init__()
-
-
- def getItems(self) -> []ModbusPDUWriteFileRecordRequestItem:
+ def getItems(self) -> List[ModbusPDUWriteFileRecordRequestItem]:
return self.items
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteFileRecordRequest")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
+ byteCount: c_uint8 = c_uint8((ARRAY_SIZE_IN_BYTES(self.getItems())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -65,7 +66,6 @@ class ModbusPDUWriteFileRecordRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteFileRecordRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,30 +77,36 @@ class ModbusPDUWriteFileRecordRequest(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if items is not None):
+ if self.items is not None:
for element in items:
lengthInBits += element.getLengthInBits()
-
-
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteFileRecordRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteFileRecordRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteFileRecordRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- items: []ModbusPDUWriteFileRecordRequestItem = readLengthArrayField("items", DataReaderComplexDefault<>(() -> ModbusPDUWriteFileRecordRequestItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: List[ModbusPDUWriteFileRecordRequestItem] = readLengthArrayField(
+ "items",
+ DataReaderComplexDefault(
+ ModbusPDUWriteFileRecordRequestItem.staticParse(readBuffer), readBuffer
+ ),
+ byteCount,
+ )
readBuffer.closeContext("ModbusPDUWriteFileRecordRequest")
# Create the instance
- return ModbusPDUWriteFileRecordRequestBuilder(items )
-
+ return ModbusPDUWriteFileRecordRequestBuilder(items)
def equals(self, o: object) -> bool:
if self == o:
@@ -110,10 +116,10 @@ class ModbusPDUWriteFileRecordRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUWriteFileRecordRequest = ModbusPDUWriteFileRecordRequest(o)
- return (getItems() == that.getItems()) && super().equals(that) && True
+ return (self.getItems() == that.getItems()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getItems() )
+ return hash(super().hashCode(), self.getItems())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -125,15 +131,17 @@ class ModbusPDUWriteFileRecordRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUWriteFileRecordRequestItemdef ModbusPDUWriteFileRecordRequestBuilder( []ModbusPDUWriteFileRecordRequestItem items ): self.items = items
-
+@dataclass
+class ModbusPDUWriteFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder):
+ items: List[ModbusPDUWriteFileRecordRequestItem]
- def build(self,
- ) -> ModbusPDUWriteFileRecordRequest:
- modbusPDUWriteFileRecordRequest: ModbusPDUWriteFileRecordRequest = ModbusPDUWriteFileRecordRequest(
- items
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteFileRecordRequest:
+ modbusPDUWriteFileRecordRequest: ModbusPDUWriteFileRecordRequest = (
+ ModbusPDUWriteFileRecordRequest(self.items)
+ )
return modbusPDUWriteFileRecordRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
index 17a6f1d062..e801c596af 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
@@ -26,22 +26,19 @@ from ctypes import c_byte
from ctypes import c_uint16
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
referenceType: c_uint8
fileNumber: c_uint16
recordNumber: c_uint16
- recordData: []c_byte
-
-
+ recordData: List[c_byte]
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getReferenceType(self) -> c_uint8:
return self.referenceType
@@ -52,34 +49,38 @@ class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
def getRecordNumber(self) -> c_uint16:
return self.recordNumber
- def getRecordData(self) -> []c_byte:
+ def getRecordData(self) -> List[c_byte]:
return self.recordData
-
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteFileRecordRequestItem")
# Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ writeSimpleField(
+ "referenceType", referenceType, writeUnsignedShort(writeBuffer, 8)
+ )
# Simple Field (fileNumber)
writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
# Simple Field (recordNumber)
- writeSimpleField("recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16)
+ )
# Implicit Field (recordLength) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint16 recordLength = (c_uint16) ((COUNT(getRecordData())) / (2))
- writeImplicitField("recordLength", recordLength, writeUnsignedInt(writeBuffer, 16))
+ recordLength: c_uint16 = c_uint16(((COUNT(self.getRecordData())) / (2)))
+ writeImplicitField(
+ "recordLength", recordLength, writeUnsignedInt(writeBuffer, 16)
+ )
# Array Field (recordData)
writeByteArrayField("recordData", recordData, writeByteArray(writeBuffer, 8))
writeBuffer.popContext("ModbusPDUWriteFileRecordRequestItem")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -100,41 +101,55 @@ class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
lengthInBits += 16
# Array field
- if recordData is not None):
- lengthInBits += 8 * recordData.length
-
+ if self.recordData is not None:
+ lengthInBits += 8 * self.recordData.length
return lengthInBits
-
- def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUWriteFileRecordRequestItem:
+ def staticParse(
+ readBuffer: ReadBuffer, args
+ ) -> ModbusPDUWriteFileRecordRequestItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
-
@staticmethod
- def staticParseContext(readBuffer: ReadBuffer) -> ModbusPDUWriteFileRecordRequestItem:
+ def staticParseContext(
+ readBuffer: ReadBuffer,
+ ) -> ModbusPDUWriteFileRecordRequestItem:
readBuffer.pullContext("ModbusPDUWriteFileRecordRequestItem")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField(
+ "referenceType", readUnsignedShort(readBuffer, 8)
+ )
- fileNumber: c_uint16 = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
+ fileNumber: c_uint16 = readSimpleField(
+ "fileNumber", readUnsignedInt(readBuffer, 16)
+ )
- recordNumber: c_uint16 = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
+ recordNumber: c_uint16 = readSimpleField(
+ "recordNumber", readUnsignedInt(readBuffer, 16)
+ )
- recordLength: c_uint16 = readImplicitField("recordLength", readUnsignedInt(readBuffer, 16))
+ recordLength: c_uint16 = readImplicitField(
+ "recordLength", readUnsignedInt(readBuffer, 16)
+ )
- recordData: byte[] = readBuffer.readByteArray("recordData", Math.toIntExact((recordLength) * (2)))
+ recordData: List[byte] = readBuffer.readByteArray(
+ "recordData", int((recordLength) * (2))
+ )
readBuffer.closeContext("ModbusPDUWriteFileRecordRequestItem")
# Create the instance
- _modbusPDUWriteFileRecordRequestItem: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem(referenceType, fileNumber, recordNumber, recordData )
+ _modbusPDUWriteFileRecordRequestItem: ModbusPDUWriteFileRecordRequestItem = (
+ ModbusPDUWriteFileRecordRequestItem(
+ referenceType, fileNumber, recordNumber, recordData
+ )
+ )
return _modbusPDUWriteFileRecordRequestItem
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -142,11 +157,24 @@ class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
if not isinstance(o, ModbusPDUWriteFileRecordRequestItem):
return False
- that: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem(o)
- return (getReferenceType() == that.getReferenceType()) && (getFileNumber() == that.getFileNumber()) && (getRecordNumber() == that.getRecordNumber()) && (getRecordData() == that.getRecordData()) && True
+ that: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem(
+ o
+ )
+ return (
+ (self.getReferenceType() == that.getReferenceType())
+ and (self.getFileNumber() == that.getFileNumber())
+ and (self.getRecordNumber() == that.getRecordNumber())
+ and (self.getRecordData() == that.getRecordData())
+ and True
+ )
def hashCode(self) -> int:
- return hash(getReferenceType(), getFileNumber(), getRecordNumber(), getRecordData() )
+ return hash(
+ self.getReferenceType(),
+ self.getFileNumber(),
+ self.getRecordNumber(),
+ self.getRecordData(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -156,7 +184,3 @@ class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
raise RuntimeException(e)
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
index 060dc0ec4c..7e57d46dd4 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
@@ -25,39 +25,40 @@ from dataclasses import dataclass
from ctypes import c_bool
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
-from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordResponseItem import ModbusPDUWriteFileRecordResponseItem
+from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordResponseItem import (
+ ModbusPDUWriteFileRecordResponseItem,
+)
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUWriteFileRecordResponse(PlcMessage,ModbusPDU):
- items: []ModbusPDUWriteFileRecordResponseItem
+class ModbusPDUWriteFileRecordResponse(PlcMessage, ModbusPDU):
+ items: List[ModbusPDUWriteFileRecordResponseItem]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x15
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x15)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
+ super().__init__()
-
-
- def getItems(self) -> []ModbusPDUWriteFileRecordResponseItem:
+ def getItems(self) -> List[ModbusPDUWriteFileRecordResponseItem]:
return self.items
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteFileRecordResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
+ byteCount: c_uint8 = c_uint8((ARRAY_SIZE_IN_BYTES(self.getItems())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -65,7 +66,6 @@ class ModbusPDUWriteFileRecordResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteFileRecordResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -77,30 +77,36 @@ class ModbusPDUWriteFileRecordResponse(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if items is not None):
+ if self.items is not None:
for element in items:
lengthInBits += element.getLengthInBits()
-
-
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteFileRecordResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteFileRecordResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteFileRecordResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- items: []ModbusPDUWriteFileRecordResponseItem = readLengthArrayField("items", DataReaderComplexDefault<>(() -> ModbusPDUWriteFileRecordResponseItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: List[ModbusPDUWriteFileRecordResponseItem] = readLengthArrayField(
+ "items",
+ DataReaderComplexDefault(
+ ModbusPDUWriteFileRecordResponseItem.staticParse(readBuffer), readBuffer
+ ),
+ byteCount,
+ )
readBuffer.closeContext("ModbusPDUWriteFileRecordResponse")
# Create the instance
- return ModbusPDUWriteFileRecordResponseBuilder(items )
-
+ return ModbusPDUWriteFileRecordResponseBuilder(items)
def equals(self, o: object) -> bool:
if self == o:
@@ -110,10 +116,10 @@ class ModbusPDUWriteFileRecordResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUWriteFileRecordResponse = ModbusPDUWriteFileRecordResponse(o)
- return (getItems() == that.getItems()) && super().equals(that) && True
+ return (self.getItems() == that.getItems()) and super().equals(that) and True
def hashCode(self) -> int:
- return hash(super().hashCode(), getItems() )
+ return hash(super().hashCode(), self.getItems())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -125,15 +131,17 @@ class ModbusPDUWriteFileRecordResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUWriteFileRecordResponseItemdef ModbusPDUWriteFileRecordResponseBuilder( []ModbusPDUWriteFileRecordResponseItem items ): self.items = items
-
+@dataclass
+class ModbusPDUWriteFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder):
+ items: List[ModbusPDUWriteFileRecordResponseItem]
- def build(self,
- ) -> ModbusPDUWriteFileRecordResponse:
- modbusPDUWriteFileRecordResponse: ModbusPDUWriteFileRecordResponse = ModbusPDUWriteFileRecordResponse(
- items
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteFileRecordResponse:
+ modbusPDUWriteFileRecordResponse: ModbusPDUWriteFileRecordResponse = (
+ ModbusPDUWriteFileRecordResponse(self.items)
+ )
return modbusPDUWriteFileRecordResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
index 423b3a0085..88e26ef59c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
@@ -26,22 +26,19 @@ from ctypes import c_byte
from ctypes import c_uint16
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
referenceType: c_uint8
fileNumber: c_uint16
recordNumber: c_uint16
- recordData: []c_byte
-
-
+ recordData: List[c_byte]
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getReferenceType(self) -> c_uint8:
return self.referenceType
@@ -52,34 +49,38 @@ class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
def getRecordNumber(self) -> c_uint16:
return self.recordNumber
- def getRecordData(self) -> []c_byte:
+ def getRecordData(self) -> List[c_byte]:
return self.recordData
-
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteFileRecordResponseItem")
# Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ writeSimpleField(
+ "referenceType", referenceType, writeUnsignedShort(writeBuffer, 8)
+ )
# Simple Field (fileNumber)
writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
# Simple Field (recordNumber)
- writeSimpleField("recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16)
+ )
# Implicit Field (recordLength) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint16 recordLength = (c_uint16) ((COUNT(getRecordData())) / (2))
- writeImplicitField("recordLength", recordLength, writeUnsignedInt(writeBuffer, 16))
+ recordLength: c_uint16 = c_uint16(((COUNT(self.getRecordData())) / (2)))
+ writeImplicitField(
+ "recordLength", recordLength, writeUnsignedInt(writeBuffer, 16)
+ )
# Array Field (recordData)
writeByteArrayField("recordData", recordData, writeByteArray(writeBuffer, 8))
writeBuffer.popContext("ModbusPDUWriteFileRecordResponseItem")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -100,41 +101,55 @@ class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
lengthInBits += 16
# Array field
- if recordData is not None):
- lengthInBits += 8 * recordData.length
-
+ if self.recordData is not None:
+ lengthInBits += 8 * self.recordData.length
return lengthInBits
-
- def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUWriteFileRecordResponseItem:
+ def staticParse(
+ readBuffer: ReadBuffer, args
+ ) -> ModbusPDUWriteFileRecordResponseItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
-
@staticmethod
- def staticParseContext(readBuffer: ReadBuffer) -> ModbusPDUWriteFileRecordResponseItem:
+ def staticParseContext(
+ readBuffer: ReadBuffer,
+ ) -> ModbusPDUWriteFileRecordResponseItem:
readBuffer.pullContext("ModbusPDUWriteFileRecordResponseItem")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField(
+ "referenceType", readUnsignedShort(readBuffer, 8)
+ )
- fileNumber: c_uint16 = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
+ fileNumber: c_uint16 = readSimpleField(
+ "fileNumber", readUnsignedInt(readBuffer, 16)
+ )
- recordNumber: c_uint16 = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
+ recordNumber: c_uint16 = readSimpleField(
+ "recordNumber", readUnsignedInt(readBuffer, 16)
+ )
- recordLength: c_uint16 = readImplicitField("recordLength", readUnsignedInt(readBuffer, 16))
+ recordLength: c_uint16 = readImplicitField(
+ "recordLength", readUnsignedInt(readBuffer, 16)
+ )
- recordData: byte[] = readBuffer.readByteArray("recordData", Math.toIntExact(recordLength))
+ recordData: List[byte] = readBuffer.readByteArray(
+ "recordData", int(recordLength)
+ )
readBuffer.closeContext("ModbusPDUWriteFileRecordResponseItem")
# Create the instance
- _modbusPDUWriteFileRecordResponseItem: ModbusPDUWriteFileRecordResponseItem = ModbusPDUWriteFileRecordResponseItem(referenceType, fileNumber, recordNumber, recordData )
+ _modbusPDUWriteFileRecordResponseItem: ModbusPDUWriteFileRecordResponseItem = (
+ ModbusPDUWriteFileRecordResponseItem(
+ referenceType, fileNumber, recordNumber, recordData
+ )
+ )
return _modbusPDUWriteFileRecordResponseItem
-
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -142,11 +157,24 @@ class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
if not isinstance(o, ModbusPDUWriteFileRecordResponseItem):
return False
- that: ModbusPDUWriteFileRecordResponseItem = ModbusPDUWriteFileRecordResponseItem(o)
- return (getReferenceType() == that.getReferenceType()) && (getFileNumber() == that.getFileNumber()) && (getRecordNumber() == that.getRecordNumber()) && (getRecordData() == that.getRecordData()) && True
+ that: ModbusPDUWriteFileRecordResponseItem = (
+ ModbusPDUWriteFileRecordResponseItem(o)
+ )
+ return (
+ (self.getReferenceType() == that.getReferenceType())
+ and (self.getFileNumber() == that.getFileNumber())
+ and (self.getRecordNumber() == that.getRecordNumber())
+ and (self.getRecordData() == that.getRecordData())
+ and True
+ )
def hashCode(self) -> int:
- return hash(getReferenceType(), getFileNumber(), getRecordNumber(), getRecordData() )
+ return hash(
+ self.getReferenceType(),
+ self.getFileNumber(),
+ self.getRecordNumber(),
+ self.getRecordData(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -156,7 +184,3 @@ class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
raise RuntimeException(e)
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
index fd0ff9b60d..a750e04f02 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
@@ -27,28 +27,28 @@ from ctypes import c_byte
from ctypes import c_uint16
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
+class ModbusPDUWriteMultipleCoilsRequest(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
- value: []c_byte
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x0F
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x0F)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -56,23 +56,24 @@ class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteMultipleCoilsRequest")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -80,7 +81,6 @@ class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteMultipleCoilsRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -98,32 +98,39 @@ class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteMultipleCoilsRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteMultipleCoilsRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleCoilsRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUWriteMultipleCoilsRequest")
# Create the instance
- return ModbusPDUWriteMultipleCoilsRequestBuilder(startingAddress, quantity, value )
-
+ return ModbusPDUWriteMultipleCoilsRequestBuilder(
+ startingAddress, quantity, value
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -133,10 +140,21 @@ class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUWriteMultipleCoilsRequest = ModbusPDUWriteMultipleCoilsRequest(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && (getValue() == that.getValue()) && super().equals(that) && True
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and (self.getValue() == that.getValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity(), getValue() )
+ return hash(
+ super().hashCode(),
+ self.getStartingAddress(),
+ self.getQuantity(),
+ self.getValue(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -148,19 +166,21 @@ class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteMultipleCoilsRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16 value: []c_bytedef ModbusPDUWriteMultipleCoilsRequestBuilder( c_uint16 startingAddress, c_uint16 quantity, []c_byte value ): self.startingAddress = startingAddress
- self.quantity = quantity
- self.value = value
-
+@dataclass
+class ModbusPDUWriteMultipleCoilsRequestBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
+ value: List[c_byte]
- def build(self,
- ) -> ModbusPDUWriteMultipleCoilsRequest:
- modbusPDUWriteMultipleCoilsRequest: ModbusPDUWriteMultipleCoilsRequest = ModbusPDUWriteMultipleCoilsRequest(
- startingAddress,
- quantity,
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteMultipleCoilsRequest:
+ modbusPDUWriteMultipleCoilsRequest: ModbusPDUWriteMultipleCoilsRequest = (
+ ModbusPDUWriteMultipleCoilsRequest(
+ self.startingAddress, self.quantity, self.value
+ )
+ )
return modbusPDUWriteMultipleCoilsRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
index 87c94da0b6..9aad7c44b7 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUWriteMultipleCoilsResponse(PlcMessage,ModbusPDU):
+class ModbusPDUWriteMultipleCoilsResponse(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x0F
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x0F)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -54,21 +53,21 @@ class ModbusPDUWriteMultipleCoilsResponse(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteMultipleCoilsResponse")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
writeBuffer.popContext("ModbusPDUWriteMultipleCoilsResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +83,26 @@ class ModbusPDUWriteMultipleCoilsResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteMultipleCoilsResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteMultipleCoilsResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleCoilsResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUWriteMultipleCoilsResponse")
# Create the instance
- return ModbusPDUWriteMultipleCoilsResponseBuilder(startingAddress, quantity )
-
+ return ModbusPDUWriteMultipleCoilsResponseBuilder(startingAddress, quantity)
def equals(self, o: object) -> bool:
if self == o:
@@ -108,11 +111,18 @@ class ModbusPDUWriteMultipleCoilsResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUWriteMultipleCoilsResponse):
return False
- that: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
+ that: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(
+ o
+ )
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+ return hash(super().hashCode(), self.getStartingAddress(), self.getQuantity())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +134,18 @@ class ModbusPDUWriteMultipleCoilsResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteMultipleCoilsResponseBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUWriteMultipleCoilsResponseBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
- self.quantity = quantity
-
+@dataclass
+class ModbusPDUWriteMultipleCoilsResponseBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
- def build(self,
- ) -> ModbusPDUWriteMultipleCoilsResponse:
- modbusPDUWriteMultipleCoilsResponse: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(
- startingAddress,
- quantity
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteMultipleCoilsResponse:
+ modbusPDUWriteMultipleCoilsResponse: ModbusPDUWriteMultipleCoilsResponse = (
+ ModbusPDUWriteMultipleCoilsResponse(self.startingAddress, self.quantity)
+ )
return modbusPDUWriteMultipleCoilsResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
index d0b3b43b9e..e325d35fc7 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
@@ -27,28 +27,28 @@ from ctypes import c_byte
from ctypes import c_uint16
from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
+from typing import List
import math
-
+
@dataclass
-class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
+class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
- value: []c_byte
+ value: List[c_byte]
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x10
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x10)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -56,23 +56,24 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
- def getValue(self) -> []c_byte:
+ def getValue(self) -> List[c_byte]:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
+ byteCount: c_uint8 = c_uint8((COUNT(self.getValue())))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -80,7 +81,6 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -98,32 +98,39 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
lengthInBits += 8
# Array field
- if value is not None):
- lengthInBits += 8 * value.length
-
+ if self.value is not None:
+ lengthInBits += 8 * self.value.length
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteMultipleHoldingRegistersRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteMultipleHoldingRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
- byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField(
+ "byteCount", readUnsignedShort(readBuffer, 8)
+ )
- value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
+ value: List[c_byte] = readBuffer.readByteArray("value", int(byteCount))
readBuffer.closeContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
# Create the instance
- return ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(startingAddress, quantity, value )
-
+ return ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(
+ startingAddress, quantity, value
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -132,11 +139,24 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUWriteMultipleHoldingRegistersRequest):
return False
- that: ModbusPDUWriteMultipleHoldingRegistersRequest = ModbusPDUWriteMultipleHoldingRegistersRequest(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUWriteMultipleHoldingRegistersRequest = (
+ ModbusPDUWriteMultipleHoldingRegistersRequest(o)
+ )
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and (self.getValue() == that.getValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity(), getValue() )
+ return hash(
+ super().hashCode(),
+ self.getStartingAddress(),
+ self.getQuantity(),
+ self.getValue(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -148,19 +168,19 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16 value: []c_bytedef ModbusPDUWriteMultipleHoldingRegistersRequestBuilder( c_uint16 startingAddress, c_uint16 quantity, []c_byte value ): self.startingAddress = startingAddress
- self.quantity = quantity
- self.value = value
+@dataclass
+class ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
+ value: List[c_byte]
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUWriteMultipleHoldingRegistersRequest:
+ def build(
+ self,
+ ) -> ModbusPDUWriteMultipleHoldingRegistersRequest:
modbusPDUWriteMultipleHoldingRegistersRequest: ModbusPDUWriteMultipleHoldingRegistersRequest = ModbusPDUWriteMultipleHoldingRegistersRequest(
- startingAddress,
- quantity,
- value
-)
+ self.startingAddress, self.quantity, self.value
+ )
return modbusPDUWriteMultipleHoldingRegistersRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
index 09cdfd87ee..35b508551e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
+class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage, ModbusPDU):
startingAddress: c_uint16
quantity: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x10
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x10)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getStartingAddress(self) -> c_uint16:
return self.startingAddress
@@ -54,21 +53,21 @@ class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
def getQuantity(self) -> c_uint16:
return self.quantity
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
# Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ writeSimpleField(
+ "startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16)
+ )
# Simple Field (quantity)
writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
writeBuffer.popContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,22 +83,28 @@ class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteMultipleHoldingRegistersResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteMultipleHoldingRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField(
+ "startingAddress", readUnsignedInt(readBuffer, 16)
+ )
- quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField(
+ "quantity", readUnsignedInt(readBuffer, 16)
+ )
readBuffer.closeContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
# Create the instance
- return ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(startingAddress, quantity )
-
+ return ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(
+ startingAddress, quantity
+ )
def equals(self, o: object) -> bool:
if self == o:
@@ -108,11 +113,18 @@ class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUWriteMultipleHoldingRegistersResponse):
return False
- that: ModbusPDUWriteMultipleHoldingRegistersResponse = ModbusPDUWriteMultipleHoldingRegistersResponse(o)
- return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
+ that: ModbusPDUWriteMultipleHoldingRegistersResponse = (
+ ModbusPDUWriteMultipleHoldingRegistersResponse(o)
+ )
+ return (
+ (self.getStartingAddress() == that.getStartingAddress())
+ and (self.getQuantity() == that.getQuantity())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+ return hash(super().hashCode(), self.getStartingAddress(), self.getQuantity())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +136,18 @@ class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUWriteMultipleHoldingRegistersResponseBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
- self.quantity = quantity
+@dataclass
+class ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder):
+ startingAddress: c_uint16
+ quantity: c_uint16
+ def __post_init__(self):
+ pass
- def build(self,
- ) -> ModbusPDUWriteMultipleHoldingRegistersResponse:
+ def build(
+ self,
+ ) -> ModbusPDUWriteMultipleHoldingRegistersResponse:
modbusPDUWriteMultipleHoldingRegistersResponse: ModbusPDUWriteMultipleHoldingRegistersResponse = ModbusPDUWriteMultipleHoldingRegistersResponse(
- startingAddress,
- quantity
-)
+ self.startingAddress, self.quantity
+ )
return modbusPDUWriteMultipleHoldingRegistersResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
index 05174f8004..535caf6e8c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
+class ModbusPDUWriteSingleCoilRequest(PlcMessage, ModbusPDU):
address: c_uint16
value: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x05
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x05)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getAddress(self) -> c_uint16:
return self.address
@@ -54,7 +53,6 @@ class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
def getValue(self) -> c_uint16:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -68,7 +66,6 @@ class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteSingleCoilRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,9 +81,10 @@ class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleCoilRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteSingleCoilRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleCoilRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -98,8 +96,7 @@ class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
readBuffer.closeContext("ModbusPDUWriteSingleCoilRequest")
# Create the instance
- return ModbusPDUWriteSingleCoilRequestBuilder(address, value )
-
+ return ModbusPDUWriteSingleCoilRequestBuilder(address, value)
def equals(self, o: object) -> bool:
if self == o:
@@ -109,10 +106,15 @@ class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
return False
that: ModbusPDUWriteSingleCoilRequest = ModbusPDUWriteSingleCoilRequest(o)
- return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
+ return (
+ (self.getAddress() == that.getAddress())
+ and (self.getValue() == that.getValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getAddress(), getValue() )
+ return hash(super().hashCode(), self.getAddress(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +126,18 @@ class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteSingleCoilRequestBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleCoilRequestBuilder( c_uint16 address, c_uint16 value ): self.address = address
- self.value = value
-
+@dataclass
+class ModbusPDUWriteSingleCoilRequestBuilder(ModbusPDUModbusPDUBuilder):
+ address: c_uint16
+ value: c_uint16
- def build(self,
- ) -> ModbusPDUWriteSingleCoilRequest:
- modbusPDUWriteSingleCoilRequest: ModbusPDUWriteSingleCoilRequest = ModbusPDUWriteSingleCoilRequest(
- address,
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteSingleCoilRequest:
+ modbusPDUWriteSingleCoilRequest: ModbusPDUWriteSingleCoilRequest = (
+ ModbusPDUWriteSingleCoilRequest(self.address, self.value)
+ )
return modbusPDUWriteSingleCoilRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
index 1a3791418a..61a0af089e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
+class ModbusPDUWriteSingleCoilResponse(PlcMessage, ModbusPDU):
address: c_uint16
value: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x05
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x05)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getAddress(self) -> c_uint16:
return self.address
@@ -54,7 +53,6 @@ class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
def getValue(self) -> c_uint16:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -68,7 +66,6 @@ class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteSingleCoilResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,9 +81,10 @@ class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleCoilResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteSingleCoilResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleCoilResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -98,8 +96,7 @@ class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
readBuffer.closeContext("ModbusPDUWriteSingleCoilResponse")
# Create the instance
- return ModbusPDUWriteSingleCoilResponseBuilder(address, value )
-
+ return ModbusPDUWriteSingleCoilResponseBuilder(address, value)
def equals(self, o: object) -> bool:
if self == o:
@@ -109,10 +106,15 @@ class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
return False
that: ModbusPDUWriteSingleCoilResponse = ModbusPDUWriteSingleCoilResponse(o)
- return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
+ return (
+ (self.getAddress() == that.getAddress())
+ and (self.getValue() == that.getValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getAddress(), getValue() )
+ return hash(super().hashCode(), self.getAddress(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +126,18 @@ class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteSingleCoilResponseBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleCoilResponseBuilder( c_uint16 address, c_uint16 value ): self.address = address
- self.value = value
-
+@dataclass
+class ModbusPDUWriteSingleCoilResponseBuilder(ModbusPDUModbusPDUBuilder):
+ address: c_uint16
+ value: c_uint16
- def build(self,
- ) -> ModbusPDUWriteSingleCoilResponse:
- modbusPDUWriteSingleCoilResponse: ModbusPDUWriteSingleCoilResponse = ModbusPDUWriteSingleCoilResponse(
- address,
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteSingleCoilResponse:
+ modbusPDUWriteSingleCoilResponse: ModbusPDUWriteSingleCoilResponse = (
+ ModbusPDUWriteSingleCoilResponse(self.address, self.value)
+ )
return modbusPDUWriteSingleCoilResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
index 36416dad0c..0fd090fa08 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
+class ModbusPDUWriteSingleRegisterRequest(PlcMessage, ModbusPDU):
address: c_uint16
value: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x06
- def getResponse(self) -> c_bool:
- return (c_bool) False
+ return c_uint8(0x06)
+ def getResponse(self) -> c_bool:
+ return c_bool(False)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getAddress(self) -> c_uint16:
return self.address
@@ -54,7 +53,6 @@ class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
def getValue(self) -> c_uint16:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -68,7 +66,6 @@ class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteSingleRegisterRequest")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,9 +81,10 @@ class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleRegisterRequestBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteSingleRegisterRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleRegisterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -98,8 +96,7 @@ class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
readBuffer.closeContext("ModbusPDUWriteSingleRegisterRequest")
# Create the instance
- return ModbusPDUWriteSingleRegisterRequestBuilder(address, value )
-
+ return ModbusPDUWriteSingleRegisterRequestBuilder(address, value)
def equals(self, o: object) -> bool:
if self == o:
@@ -108,11 +105,18 @@ class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUWriteSingleRegisterRequest):
return False
- that: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(o)
- return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(
+ o
+ )
+ return (
+ (self.getAddress() == that.getAddress())
+ and (self.getValue() == that.getValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getAddress(), getValue() )
+ return hash(super().hashCode(), self.getAddress(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +128,18 @@ class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteSingleRegisterRequestBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleRegisterRequestBuilder( c_uint16 address, c_uint16 value ): self.address = address
- self.value = value
-
+@dataclass
+class ModbusPDUWriteSingleRegisterRequestBuilder(ModbusPDUModbusPDUBuilder):
+ address: c_uint16
+ value: c_uint16
- def build(self,
- ) -> ModbusPDUWriteSingleRegisterRequest:
- modbusPDUWriteSingleRegisterRequest: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(
- address,
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteSingleRegisterRequest:
+ modbusPDUWriteSingleRegisterRequest: ModbusPDUWriteSingleRegisterRequest = (
+ ModbusPDUWriteSingleRegisterRequest(self.address, self.value)
+ )
return modbusPDUWriteSingleRegisterRequest
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
index fff4c2e841..8436caa228 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
@@ -28,25 +28,24 @@ from ctypes import c_uint8
from plc4py.api.messages.PlcMessage import PlcMessage
import math
-
+
@dataclass
-class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
+class ModbusPDUWriteSingleRegisterResponse(PlcMessage, ModbusPDU):
address: c_uint16
value: c_uint16
# Accessors for discriminator values.
def getErrorFlag(self) -> c_bool:
- return (c_bool) False
+ return c_bool(False)
+
def getFunctionFlag(self) -> c_uint8:
- return (c_uint8) 0x06
- def getResponse(self) -> c_bool:
- return (c_bool) True
+ return c_uint8(0x06)
+ def getResponse(self) -> c_bool:
+ return c_bool(True)
def __post_init__(self):
- super().__init__( )
-
-
+ super().__init__()
def getAddress(self) -> c_uint16:
return self.address
@@ -54,7 +53,6 @@ class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
def getValue(self) -> c_uint16:
return self.value
-
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
@@ -68,7 +66,6 @@ class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
writeBuffer.popContext("ModbusPDUWriteSingleRegisterResponse")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -84,9 +81,10 @@ class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleRegisterResponseBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, response: c_bool
+ ) -> ModbusPDUWriteSingleRegisterResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleRegisterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -98,8 +96,7 @@ class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
readBuffer.closeContext("ModbusPDUWriteSingleRegisterResponse")
# Create the instance
- return ModbusPDUWriteSingleRegisterResponseBuilder(address, value )
-
+ return ModbusPDUWriteSingleRegisterResponseBuilder(address, value)
def equals(self, o: object) -> bool:
if self == o:
@@ -108,11 +105,18 @@ class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
if not isinstance(o, ModbusPDUWriteSingleRegisterResponse):
return False
- that: ModbusPDUWriteSingleRegisterResponse = ModbusPDUWriteSingleRegisterResponse(o)
- return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
+ that: ModbusPDUWriteSingleRegisterResponse = (
+ ModbusPDUWriteSingleRegisterResponse(o)
+ )
+ return (
+ (self.getAddress() == that.getAddress())
+ and (self.getValue() == that.getValue())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getAddress(), getValue() )
+ return hash(super().hashCode(), self.getAddress(), self.getValue())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -124,17 +128,18 @@ class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusPDUWriteSingleRegisterResponseBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleRegisterResponseBuilder( c_uint16 address, c_uint16 value ): self.address = address
- self.value = value
-
+@dataclass
+class ModbusPDUWriteSingleRegisterResponseBuilder(ModbusPDUModbusPDUBuilder):
+ address: c_uint16
+ value: c_uint16
- def build(self,
- ) -> ModbusPDUWriteSingleRegisterResponse:
- modbusPDUWriteSingleRegisterResponse: ModbusPDUWriteSingleRegisterResponse = ModbusPDUWriteSingleRegisterResponse(
- address,
- value
-)
+ def __post_init__(self):
+ pass
+
+ def build(
+ self,
+ ) -> ModbusPDUWriteSingleRegisterResponse:
+ modbusPDUWriteSingleRegisterResponse: ModbusPDUWriteSingleRegisterResponse = (
+ ModbusPDUWriteSingleRegisterResponse(self.address, self.value)
+ )
return modbusPDUWriteSingleRegisterResponse
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
index 93bc3975a5..313d160c6d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
@@ -30,9 +30,9 @@ from plc4py.protocols.modbus.readwrite.DriverType import DriverType
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
import math
-
+
@dataclass
-class ModbusRtuADU(PlcMessage,ModbusADU):
+class ModbusRtuADU(PlcMessage, ModbusADU):
address: c_uint8
pdu: ModbusPDU
# Arguments.
@@ -42,11 +42,8 @@ class ModbusRtuADU(PlcMessage,ModbusADU):
def getDriverType(self) -> DriverType:
return DriverType.MODBUS_RTU
-
def __post_init__(self):
- super().__init__( self.response )
-
-
+ super().__init__(self.response)
def getAddress(self) -> c_uint8:
return self.address
@@ -54,24 +51,36 @@ class ModbusRtuADU(PlcMessage,ModbusADU):
def getPdu(self) -> ModbusPDU:
return self.pdu
-
def serializeModbusADUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusRtuADU")
# Simple Field (address)
- writeSimpleField("address", address, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ writeSimpleField(
+ "address",
+ address,
+ writeUnsignedShort(writeBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
# Simple Field (pdu)
- writeSimpleField("pdu", pdu, DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ writeSimpleField(
+ "pdu",
+ pdu,
+ DataWriterComplexDefault(writeBuffer),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
# Checksum Field (checksum) (Calculated)
- writeChecksumField("crc", (c_uint16) (modbus.readwrite.utils.StaticHelper.rtuCrcCheck(address, pdu)), writeUnsignedInt(writeBuffer, 16))
+ writeChecksumField(
+ "crc",
+ (c_uint16)(modbus.readwrite.utils.StaticHelper.rtuCrcCheck(address, pdu)),
+ writeUnsignedInt(writeBuffer, 16),
+ )
writeBuffer.popContext("ModbusRtuADU")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -90,24 +99,39 @@ class ModbusRtuADU(PlcMessage,ModbusADU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, driverType: DriverType, response: c_bool) -> ModbusRtuADUBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, driverType: DriverType, response: c_bool
+ ) -> ModbusRtuADUBuilder:
readBuffer.pullContext("ModbusRtuADU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: c_uint8 = readSimpleField("address", readUnsignedShort(readBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ address: c_uint8 = readSimpleField(
+ "address",
+ readUnsignedShort(readBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- pdu: ModbusPDU = readSimpleField("pdu", DataReaderComplexDefault<>(() -> ModbusPDU.staticParse(readBuffer, (c_bool) (response)), readBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ pdu: ModbusPDU = readSimpleField(
+ "pdu",
+ DataReaderComplexDefault(
+ ModbusPDU.staticParse(readBuffer, c_bool(response)), readBuffer
+ ),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- crc: c_uint16 = readChecksumField("crc", readUnsignedInt(readBuffer, 16), (c_uint16) (modbus.readwrite.utils.StaticHelper.rtuCrcCheck(address, pdu)), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ crc: c_uint16 = readChecksumField(
+ "crc",
+ readUnsignedInt(readBuffer, 16),
+ (c_uint16)(modbus.readwrite.utils.StaticHelper.rtuCrcCheck(address, pdu)),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
readBuffer.closeContext("ModbusRtuADU")
# Create the instance
- return ModbusRtuADUBuilder(address, pdu , response )
-
+ return ModbusRtuADUBuilder(address, pdu, response)
def equals(self, o: object) -> bool:
if self == o:
@@ -117,10 +141,15 @@ class ModbusRtuADU(PlcMessage,ModbusADU):
return False
that: ModbusRtuADU = ModbusRtuADU(o)
- return (getAddress() == that.getAddress()) && (getPdu() == that.getPdu()) && super().equals(that) && True
+ return (
+ (self.getAddress() == that.getAddress())
+ and (self.getPdu() == that.getPdu())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getAddress(), getPdu() )
+ return hash(super().hashCode(), self.getAddress(), self.getPdu())
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -132,22 +161,15 @@ class ModbusRtuADU(PlcMessage,ModbusADU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusRtuADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: ModbusPDU response: c_booldef ModbusRtuADUBuilder( c_uint8 address, ModbusPDU pdu , c_bool response ): self.address = address
- self.pdu = pdu
- self.response = response
+@dataclass
+class ModbusRtuADUBuilder(ModbusADUModbusADUBuilder):
+ address: c_uint8
+ pdu: ModbusPDU
+ response: c_bool
+ def __post_init__(self):
+ pass
- def build(self,
-
- response: c_bool
- ) -> ModbusRtuADU:
- modbusRtuADU: ModbusRtuADU = ModbusRtuADU(
- address,
- pdu
- ,
- response
- )
+ def build(self, response: c_bool) -> ModbusRtuADU:
+ modbusRtuADU: ModbusRtuADU = ModbusRtuADU(self.address, self.pdu, response)
return modbusRtuADU
-
-
-
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
index 45ab22b9d2..cbb4002985 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
@@ -30,9 +30,9 @@ from plc4py.protocols.modbus.readwrite.DriverType import DriverType
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
import math
-
+
@dataclass
-class ModbusTcpADU(PlcMessage,ModbusADU):
+class ModbusTcpADU(PlcMessage, ModbusADU):
transactionIdentifier: c_uint16
unitIdentifier: c_uint8
pdu: ModbusPDU
@@ -44,11 +44,8 @@ class ModbusTcpADU(PlcMessage,ModbusADU):
def getDriverType(self) -> DriverType:
return DriverType.MODBUS_TCP
-
def __post_init__(self):
- super().__init__( self.response )
-
-
+ super().__init__(self.response)
def getTransactionIdentifier(self) -> c_uint16:
return self.transactionIdentifier
@@ -62,31 +59,46 @@ class ModbusTcpADU(PlcMessage,ModbusADU):
def getProtocolIdentifier(self) -> c_uint16:
return PROTOCOLIDENTIFIER
-
def serializeModbusADUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
startPos: int = positionAware.getPos()
writeBuffer.pushContext("ModbusTcpADU")
# Simple Field (transactionIdentifier)
- writeSimpleField("transactionIdentifier", transactionIdentifier, writeUnsignedInt(writeBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ writeSimpleField(
+ "transactionIdentifier",
+ transactionIdentifier,
+ writeUnsignedInt(writeBuffer, 16),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
# Const Field (protocolIdentifier)
- writeConstField("protocolIdentifier", PROTOCOLIDENTIFIER, writeUnsignedInt(writeBuffer, 16))
+ writeConstField(
+ "protocolIdentifier", PROTOCOLIDENTIFIER, writeUnsignedInt(writeBuffer, 16)
+ )
# Implicit Field (length) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- c_uint16 length = (c_uint16) ((getPdu().getLengthInBytes()) + (1))
+ length: c_uint16 = c_uint16(((self.getPdu().self.getLengthInBytes()) + (1)))
writeImplicitField("length", length, writeUnsignedInt(writeBuffer, 16))
# Simple Field (unitIdentifier)
- writeSimpleField("unitIdentifier", unitIdentifier, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ writeSimpleField(
+ "unitIdentifier",
+ unitIdentifier,
+ writeUnsignedShort(writeBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
# Simple Field (pdu)
- writeSimpleField("pdu", pdu, DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ writeSimpleField(
+ "pdu",
+ pdu,
+ DataWriterComplexDefault(writeBuffer),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
writeBuffer.popContext("ModbusTcpADU")
-
def getLengthInBytes(self) -> int:
return int(math.ceil(float(self.getLengthInBits() / 8.0)))
@@ -111,28 +123,51 @@ class ModbusTcpADU(PlcMessage,ModbusADU):
return lengthInBits
-
@staticmethod
- def staticParseBuilder(readBuffer: ReadBuffer, driverType: DriverType, response: c_bool) -> ModbusTcpADUBuilder:
+ def staticParseBuilder(
+ readBuffer: ReadBuffer, driverType: DriverType, response: c_bool
+ ) -> ModbusTcpADUBuilder:
readBuffer.pullContext("ModbusTcpADU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- transactionIdentifier: c_uint16 = readSimpleField("transactionIdentifier", readUnsignedInt(readBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ transactionIdentifier: c_uint16 = readSimpleField(
+ "transactionIdentifier",
+ readUnsignedInt(readBuffer, 16),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- protocolIdentifier: c_uint16 = readConstField("protocolIdentifier", readUnsignedInt(readBuffer, 16), ModbusTcpADU.PROTOCOLIDENTIFIER, WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ protocolIdentifier: c_uint16 = readConstField(
+ "protocolIdentifier",
+ readUnsignedInt(readBuffer, 16),
+ ModbusTcpADU.PROTOCOLIDENTIFIER,
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- length: c_uint16 = readImplicitField("length", readUnsignedInt(readBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ length: c_uint16 = readImplicitField(
+ "length",
+ readUnsignedInt(readBuffer, 16),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- unitIdentifier: c_uint8 = readSimpleField("unitIdentifier", readUnsignedShort(readBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ unitIdentifier: c_uint8 = readSimpleField(
+ "unitIdentifier",
+ readUnsignedShort(readBuffer, 8),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
- pdu: ModbusPDU = readSimpleField("pdu", DataReaderComplexDefault<>(() -> ModbusPDU.staticParse(readBuffer, (c_bool) (response)), readBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ pdu: ModbusPDU = readSimpleField(
+ "pdu",
+ DataReaderComplexDefault(
+ ModbusPDU.staticParse(readBuffer, c_bool(response)), readBuffer
+ ),
+ WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN),
+ )
readBuffer.closeContext("ModbusTcpADU")
# Create the instance
- return ModbusTcpADUBuilder(transactionIdentifier, unitIdentifier, pdu , response )
-
+ return ModbusTcpADUBuilder(transactionIdentifier, unitIdentifier, pdu, response)
def equals(self, o: object) -> bool:
if self == o:
@@ -142,10 +177,21 @@ class ModbusTcpADU(PlcMessage,ModbusADU):
return False
that: ModbusTcpADU = ModbusTcpADU(o)
- return (getTransactionIdentifier() == that.getTransactionIdentifier()) && (getUnitIdentifier() == that.getUnitIdentifier()) && (getPdu() == that.getPdu()) && super().equals(that) && True
+ return (
+ (self.getTransactionIdentifier() == that.getTransactionIdentifier())
+ and (self.getUnitIdentifier() == that.getUnitIdentifier())
+ and (self.getPdu() == that.getPdu())
+ and super().equals(that)
+ and True
+ )
def hashCode(self) -> int:
- return hash(super().hashCode(), getTransactionIdentifier(), getUnitIdentifier(), getPdu() )
+ return hash(
+ super().hashCode(),
+ self.getTransactionIdentifier(),
+ self.getUnitIdentifier(),
+ self.getPdu(),
+ )
def __str__(self) -> str:
writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
@@ -157,24 +203,18 @@ class ModbusTcpADU(PlcMessage,ModbusADU):
return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
-class ModbusTcpADUBuilder(ModbusADUModbusADUBuilder: transactionIdentifier: c_uint16 unitIdentifier: c_uint8 pdu: ModbusPDU response: c_booldef ModbusTcpADUBuilder( c_uint16 transactionIdentifier, c_uint8 unitIdentifier, ModbusPDU pdu , c_bool response ): self.transactionIdentifier = transactionIdentifier
- self.unitIdentifier = unitIdentifier
- self.pdu = pdu
- self.response = response
+@dataclass
+class ModbusTcpADUBuilder(ModbusADUModbusADUBuilder):
+ transactionIdentifier: c_uint16
+ unitIdentifier: c_uint8
+ pdu: ModbusPDU
+ response: c_bool
+ def __post_init__(self):
+ pass
- def build(self,
-
- response: c_bool
- ) -> ModbusTcpADU:
+ def build(self, response: c_bool) -> ModbusTcpADU:
modbusTcpADU: ModbusTcpADU = ModbusTcpADU(
- transactionIdentifier,
- unitIdentifier,
- pdu
- ,
- response
+ self.transactionIdentifier, self.unitIdentifier, self.pdu, response
)
return modbusTcpADU
-
-
-