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/15 17:11:12 UTC
[plc4x] 02/02: feat(plc4py/codegen): More updates for complex type template
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
commit da00533d19db9f6b2d54afd600e4f2853f3963c7
Author: Ben Hutcheson <be...@gmail.com>
AuthorDate: Tue Nov 15 11:09:50 2022 -0600
feat(plc4py/codegen): More updates for complex type template
---
.../python/PythonLanguageTemplateHelper.java | 53 +++++
.../python/complex-type-template.python.ftlh | 256 +++++++++++----------
sandbox/plc4py/plc4py/protocols/__init__.py | 18 ++
sandbox/plc4py/plc4py/protocols/modbus/__init__.py | 18 ++
.../protocols/modbus/readwrite/ModbusAsciiADU.py | 90 ++++----
.../protocols/modbus/readwrite/ModbusConstants.py | 53 +++--
.../readwrite/ModbusDeviceInformationObject.py | 78 +++----
.../plc4py/protocols/modbus/readwrite/ModbusPDU.py | 243 ++++++++++++-------
.../modbus/readwrite/ModbusPDUDiagnosticRequest.py | 77 +++----
.../readwrite/ModbusPDUDiagnosticResponse.py | 77 +++----
.../protocols/modbus/readwrite/ModbusPDUError.py | 64 +++---
.../ModbusPDUGetComEventCounterRequest.py | 52 ++---
.../ModbusPDUGetComEventCounterResponse.py | 77 +++----
.../readwrite/ModbusPDUGetComEventLogRequest.py | 52 ++---
.../readwrite/ModbusPDUGetComEventLogResponse.py | 110 ++++-----
.../ModbusPDUMaskWriteHoldingRegisterRequest.py | 88 ++++---
.../ModbusPDUMaskWriteHoldingRegisterResponse.py | 88 ++++---
.../modbus/readwrite/ModbusPDUReadCoilsRequest.py | 77 +++----
.../modbus/readwrite/ModbusPDUReadCoilsResponse.py | 72 +++---
.../ModbusPDUReadDeviceIdentificationRequest.py | 83 +++----
.../ModbusPDUReadDeviceIdentificationResponse.py | 140 +++++------
.../ModbusPDUReadDiscreteInputsRequest.py | 77 +++----
.../ModbusPDUReadDiscreteInputsResponse.py | 72 +++---
.../ModbusPDUReadExceptionStatusRequest.py | 52 ++---
.../ModbusPDUReadExceptionStatusResponse.py | 63 +++--
.../readwrite/ModbusPDUReadFifoQueueRequest.py | 64 +++---
.../readwrite/ModbusPDUReadFifoQueueResponse.py | 80 +++----
.../readwrite/ModbusPDUReadFileRecordRequest.py | 72 +++---
.../ModbusPDUReadFileRecordRequestItem.py | 94 ++++----
.../readwrite/ModbusPDUReadFileRecordResponse.py | 72 +++---
.../ModbusPDUReadFileRecordResponseItem.py | 78 +++----
.../ModbusPDUReadHoldingRegistersRequest.py | 77 +++----
.../ModbusPDUReadHoldingRegistersResponse.py | 72 +++---
.../ModbusPDUReadInputRegistersRequest.py | 77 +++----
.../ModbusPDUReadInputRegistersResponse.py | 72 +++---
...sPDUReadWriteMultipleHoldingRegistersRequest.py | 121 +++++-----
...PDUReadWriteMultipleHoldingRegistersResponse.py | 72 +++---
.../readwrite/ModbusPDUReportServerIdRequest.py | 52 ++---
.../readwrite/ModbusPDUReportServerIdResponse.py | 72 +++---
.../readwrite/ModbusPDUWriteFileRecordRequest.py | 72 +++---
.../ModbusPDUWriteFileRecordRequestItem.py | 103 ++++-----
.../readwrite/ModbusPDUWriteFileRecordResponse.py | 72 +++---
.../ModbusPDUWriteFileRecordResponseItem.py | 103 ++++-----
.../ModbusPDUWriteMultipleCoilsRequest.py | 99 ++++----
.../ModbusPDUWriteMultipleCoilsResponse.py | 77 +++----
...odbusPDUWriteMultipleHoldingRegistersRequest.py | 99 ++++----
...dbusPDUWriteMultipleHoldingRegistersResponse.py | 77 +++----
.../readwrite/ModbusPDUWriteSingleCoilRequest.py | 77 +++----
.../readwrite/ModbusPDUWriteSingleCoilResponse.py | 77 +++----
.../ModbusPDUWriteSingleRegisterRequest.py | 77 +++----
.../ModbusPDUWriteSingleRegisterResponse.py | 77 +++----
.../protocols/modbus/readwrite/ModbusRtuADU.py | 91 ++++----
.../protocols/modbus/readwrite/ModbusTcpADU.py | 110 ++++-----
.../plc4py/protocols/modbus/readwrite/__init__.py | 18 ++
54 files changed, 2179 insertions(+), 2255 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 025019994f..7cc7e621f3 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
@@ -37,12 +37,20 @@ import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.*;
import java.util.function.Function;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
@SuppressWarnings({"unused", "WeakerAccess"})
public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplateHelper {
+ private static final Logger LOGGER = LoggerFactory.getLogger(PythonLanguageTemplateHelper.class);
+
private final Map<String, String> options;
+ public SortedSet<String> requiredImports = new TreeSet<>();
+
+ public SortedSet<String> requiredImportsForDataIo = new TreeSet<>();
+
public PythonLanguageTemplateHelper(TypeDefinition thisType, String protocolName, String flavorName, Map<String, TypeDefinition> types,
Map<String, String> options) {
super(thisType, protocolName, flavorName, types);
@@ -72,6 +80,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
ComplexTypeReference complexTypeReference = propertyField.getType().asComplexTypeReference().orElseThrow(IllegalStateException::new);
final TypeDefinition typeDefinition = getTypeDefinitions().get(complexTypeReference.getName());
if (typeDefinition instanceof DataIoTypeDefinition) {
+ emitRequiredImport(complexTypeReference.getName());
return "PlcValue";
}
}
@@ -103,54 +112,70 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
return "[]" + getLanguageTypeNameForTypeReference(elementTypeReference);
}
if (typeReference.isNonSimpleTypeReference()) {
+ emitRequiredImport("from plc4py.protocols." + protocolName + "." + flavorName.replace("-", "") + "." + typeReference.asNonSimpleTypeReference().orElseThrow().getName() + " import " + typeReference.asNonSimpleTypeReference().orElseThrow().getName());
return typeReference.asNonSimpleTypeReference().orElseThrow().getName();
}
SimpleTypeReference simpleTypeReference = typeReference.asSimpleTypeReference().orElseThrow();
switch (simpleTypeReference.getBaseType()) {
case BIT:
+ emitRequiredImport("from ctypes import c_bool");
return "c_bool";
case BYTE:
+ emitRequiredImport("from ctypes import c_byte");
return "c_byte";
case UINT:
IntegerTypeReference unsignedIntegerTypeReference = simpleTypeReference.asIntegerTypeReference().orElseThrow();
if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
+ emitRequiredImport("from ctypes import c_uint8");
return "c_uint8";
}
if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
+ emitRequiredImport("from ctypes import c_uint16");
return "c_uint16";
}
if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
+ emitRequiredImport("from ctypes import c_uint32");
return "c_uint32";
}
if (unsignedIntegerTypeReference.getSizeInBits() <= 64) {
+ emitRequiredImport("from ctypes import c_uint64");
return "c_uint64";
}
+ emitRequiredImport("from ctypes import c_longlong");
return "c_longlong";
case INT:
IntegerTypeReference integerTypeReference = simpleTypeReference.asIntegerTypeReference().orElseThrow();
if (integerTypeReference.getSizeInBits() <= 8) {
+ emitRequiredImport("from ctypes import c_int8");
return "c_int8";
}
if (integerTypeReference.getSizeInBits() <= 16) {
+ emitRequiredImport("from ctypes import c_int16");
return "c_int16";
}
if (integerTypeReference.getSizeInBits() <= 32) {
+ emitRequiredImport("from ctypes import c_int32");
return "c_int32";
}
if (integerTypeReference.getSizeInBits() <= 64) {
+ emitRequiredImport("from ctypes import c_int64");
return "c_int64";
}
+ emitRequiredImport("from ctypes import c_longlong");
return "c_longlong";
case FLOAT:
case UFLOAT:
FloatTypeReference floatTypeReference = simpleTypeReference.asFloatTypeReference().orElseThrow();
int sizeInBits = floatTypeReference.getSizeInBits();
if (sizeInBits <= 32) {
+ emitRequiredImport("from ctypes import c_float");
return "c_float";
}
if (sizeInBits <= 64) {
+ emitRequiredImport("from ctypes import c_double");
return "c_double";
}
+ emitRequiredImport("from ctypes import c_longdouble");
return "c_longdouble";
case STRING:
case VSTRING:
@@ -1252,4 +1277,32 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
return baseTypeReference.isPresent() && baseTypeReference.get().isIntegerTypeReference() && baseTypeReference.get().asIntegerTypeReference().orElseThrow().getSizeInBits() >= 32;
}
+ public void emitRequiredImport(String requiredImport) {
+ LOGGER.debug("emitting import '\"{}\"'", requiredImport);
+ requiredImports.add(requiredImport);
+ }
+
+ public void emitRequiredImport(String alias, String requiredImport) {
+ LOGGER.debug("emitting import '{} \"{}'\"", alias, requiredImport);
+ requiredImports.add(alias + ' ' + '"' + requiredImport + '"');
+ }
+
+ public Set<String> getRequiredImports() {
+ return requiredImports;
+ }
+
+ public void emitDataIoRequiredImport(String requiredImport) {
+ LOGGER.debug("emitting io import '\"{}\"'", requiredImport);
+ requiredImportsForDataIo.add(requiredImport);
+ }
+
+ public void emitDataIoRequiredImport(String alias, String requiredImport) {
+ LOGGER.debug("emitting data io import '{} \"{}'\"", alias, requiredImport);
+ requiredImportsForDataIo.add(alias + ' ' + '"' + requiredImport + '"');
+ }
+
+ public Set<String> getRequiredImportsForDataIo() {
+ return requiredImportsForDataIo;
+ }
+
}
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 8cb5498136..33f2ace3e4 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
@@ -50,10 +50,24 @@ ${helper.packageName(protocolName, languageName, outputFlavor)?replace(".", "/")
from abc import ABC, abstractmethod
from dataclasses import dataclass
+<#macro importSectionWithContentBelow>
+ <#local sectionContent><#nested></#local>
+ <#if helper.getRequiredImports()?has_content>
+ <#list helper.getRequiredImports() as import>
+${import}
+ </#list>
+ </#if>
+
+ ${sectionContent}
+</#macro>
+<#macro emitImport import>${helper.emitRequiredImport(import)}</#macro>
+
+<@importSectionWithContentBelow>
<#-- TODO: the code below implies that parserArguments will be null if not present... not pretty -->
<#if type.parserArguments.isPresent()><#assign parserArguments=type.allParserArguments.orElseThrow()></#if>
+<@emitImport import="from plc4py.api.messages.PlcMessage import PlcMessage" />
@dataclass
class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if type.isDiscriminatedParentTypeDefinition()>ABC, </#if>PlcMessage<#if type.parentType.isPresent()>,${type.parentType.orElseThrow().name}</#if>):
<#if parserArguments?has_content>
@@ -62,26 +76,26 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#-- Property fields are fields that require a property in the pojo -->
<#if type.propertyFields?has_content>
<#list type.propertyFields as field>
- ${field.name}: ${helper.getLanguageTypeNameForTypeReference(field.type, !field.isOptionalField())}
+ ${field.name}: ${helper.getLanguageTypeNameForTypeReference(field.type, !field.isOptionalField())}
</#list>
</#if>
<#if filteredParserArguments?has_content>
- # Arguments.
+ # Arguments.
<#list filteredParserArguments as parserArgument>
- ${parserArgument.name}: ${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}
+ ${parserArgument.name}: ${helper.getLanguageTypeNameForTypeReference(parserArgument.type)}
</#list>
</#if>
<#assign reservedFields=type.getFields()?filter(f->f.isReservedField())>
<#if reservedFields?has_content>
- # Reserved Fields
+ # Reserved Fields
<#list reservedFields as reservedField>
- reservedField${reservedField?index}: ${helper.getLanguageTypeNameForTypeReference(reservedField.asReservedField().orElseThrow().type, false)}
+ reservedField${reservedField?index}: ${helper.getLanguageTypeNameForTypeReference(reservedField.asReservedField().orElseThrow().type, false)}
</#list>
</#if>
<#-- If the current type contains "const" fields, generate some Python constants for holing their values -->
<#if type.constFields?has_content>
<#list type.constFields as field>
- ${field.name?upper_case}: ${helper.getLanguageTypeNameForTypeReference(field.type)} = ${helper.toParseExpression(field, field.type, field.referenceValue, parserArguments)}
+ ${field.name?upper_case}: ${helper.getLanguageTypeNameForTypeReference(field.type)} = ${helper.toParseExpression(field, field.type, field.referenceValue, parserArguments)}
</#list>
</#if>
@@ -106,7 +120,6 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#else>
return ${helper.getNullValueForTypeReference(discriminatorType)}
</#if>
- }
</#if>
</#list>
</#if>
@@ -114,8 +127,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#-- getAllPropertyFields() returns not only the property fields of this type but also of it's parents -->
def __post_init__(self):
- <@compress single_line=true>
- super().__init__(
+ <@compress single_line=true> super().__init__(
<#if type.parentPropertyFields?has_content>
<#list type.parentPropertyFields as field>
self.${field.name}
@@ -149,6 +161,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#if !type.isNonDiscriminatorField(discriminatorName)><#-- && !type.isParserArgument(discriminatorName)-->
@abstractmethod
def get${discriminatorName?cap_first}(self) -> ${helper.getLanguageTypeNameForTypeReference(discriminatorType)}:
+ pass
</#if>
</#list>
</#if>
@@ -200,10 +213,10 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
</#if>
positionAware: PositionAware = writeBuffer
<#if helper.hasFieldOfType("unknown")>
- raise SerializationException("Unknown field not serializable")
+ raise SerializationException("Unknown field not serializable")
<#else>
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("${type.name}")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("${type.name}")
<#assign reservedFieldIndex=0>
<#list type.fields as field>
<#switch field.typeName>
@@ -212,13 +225,13 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Array Field (${arrayField.name})
+ # Array Field (${arrayField.name})
<#if arrayField.type.elementTypeReference.isByteBased()>
- writeByteArrayField("${namedField.name}", ${namedField.name}, writeByteArray(writeBuffer, 8))
+ writeByteArrayField("${namedField.name}", ${namedField.name}, writeByteArray(writeBuffer, 8))
<#elseif arrayField.type.elementTypeReference.isSimpleTypeReference()>
- writeSimpleTypeArrayField("${namedField.name}", ${namedField.name}, ${helper.getDataWriterCall(arrayField.type.elementTypeReference, namedField.name)})
+ writeSimpleTypeArrayField("${namedField.name}", ${namedField.name}, ${helper.getDataWriterCall(arrayField.type.elementTypeReference, namedField.name)})
<#else>
- writeComplexTypeArrayField("${namedField.name}", ${namedField.name}, writeBuffer)
+ writeComplexTypeArrayField("${namedField.name}", ${namedField.name}, writeBuffer)
</#if>
<#break>
<#case "checksum">
@@ -226,15 +239,15 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Checksum Field (checksum) (Calculated)
- writeChecksumField("${namedField.name}", (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)}), ${helper.getDataWriterCall(typedField.type, namedField.name)})
+ # Checksum Field (checksum) (Calculated)
+ writeChecksumField("${namedField.name}", (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)}), ${helper.getDataWriterCall(typedField.type, namedField.name)})
<#break>
<#case "const">
<#assign constField = field.asConstField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Const Field (${constField.name})
+ # 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>
<#break>
<#case "discriminator">
@@ -242,109 +255,114 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Discriminator Field (${discriminatorField.name}) (Used as input to a switch field)
- <#if typedField.type.isEnumTypeReference()>writeDiscriminatorEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", get${discriminatorField.name?cap_first}(), ${helper.getEnumDataWriterCall(typedField.type, namedField.name, "value")})<#else>writeDiscriminatorField("${namedField.name}", get${discriminatorField.name?cap_first}(), ${helper.getDataWriterCall(typedField.type, namedField.name)})</#if>
+ # Discriminator Field (${discriminatorField.name}) (Used as input to a switch field)
+ <#if typedField.type.isEnumTypeReference()>
+ writeDiscriminatorEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", get${discriminatorField.name?cap_first}(), ${helper.getEnumDataWriterCall(typedField.type, namedField.name, "value")})
+ <#else>
+ writeDiscriminatorField("${namedField.name}", get${discriminatorField.name?cap_first}(), ${helper.getDataWriterCall(typedField.type, namedField.name)})
+ </#if>
<#break>
<#case "enum">
<#assign enumField = field.asEnumField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Enum field (${namedField.name})
- writeEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${namedField.name}, ${helper.getEnumDataWriterCall(typedField.type, namedField.name, enumField.fieldName)})
+ # Enum field (${namedField.name})
+ writeEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${namedField.name}, ${helper.getEnumDataWriterCall(typedField.type, namedField.name, enumField.fieldName)})
<#break>
<#case "implicit">
<#assign implicitField = field.asImplicitField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Implicit Field (${implicitField.name}) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
+ # 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)})
- writeImplicitField("${namedField.name}", ${implicitField.name}, ${helper.getDataWriterCall(typedField.type, namedField.name)})
+ ${helper.getLanguageTypeNameForField(field)} ${implicitField.name} = (${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">
<#assign manualArrayField = field.asManualArrayField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Manual Array Field (${manualArrayField.name})
- writeManualArrayField("${namedField.name}", ${namedField.name}, (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)} _value) -> ${helper.toParseExpression(manualArrayField, manualArrayField.type.elementTypeReference, manualArrayField.serializeExpression, parserArguments)}, writeBuffer)
+ # Manual Array Field (${manualArrayField.name})
+ writeManualArrayField("${namedField.name}", ${namedField.name}, (${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)} _value) -> ${helper.toParseExpression(manualArrayField, manualArrayField.type.elementTypeReference, manualArrayField.serializeExpression, parserArguments)}, writeBuffer)
<#break>
<#case "manual">
<#assign manualField = field.asManualField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Manual Field (${manualField.name})
- writeManualField("${namedField.name}", () -> ${helper.toParseExpression(manualField, manualField.type, manualField.serializeExpression, parserArguments)}, writeBuffer)
+ # Manual Field (${manualField.name})
+ writeManualField("${namedField.name}", () -> ${helper.toParseExpression(manualField, manualField.type, manualField.serializeExpression, parserArguments)}, writeBuffer)
<#break>
<#case "optional">
<#assign optionalField = field.asOptionalField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Optional Field (${optionalField.name}) (Can be skipped, if the value is null)
+ # Optional Field (${optionalField.name}) (Can be skipped, if the value is null)
<#if optionalField.type.isEnumTypeReference()>
- writeOptionalEnumField("${optionalField.name}", "${helper.getLanguageTypeNameForField(field)}", ${optionalField.name}, ${helper.getEnumDataWriterCall(optionalField.type, optionalField.name, "value")}<#if optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>)
+ writeOptionalEnumField("${optionalField.name}", "${helper.getLanguageTypeNameForField(field)}", ${optionalField.name}, ${helper.getEnumDataWriterCall(optionalField.type, optionalField.name, "value")}<#if optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>)
<#elseif optionalField.type.isDataIoTypeReference()>
- writeOptionalField("${optionalField.name}", ${optionalField.name}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${optionalField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, p [...]
+ writeOptionalField("${optionalField.name}", ${optionalField.name}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${optionalField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if optionalField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list optionalField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(optionalField, helper.anyTypeReference, param, parserArguments)}<#se [...]
<#else>
- writeOptionalField("${optionalField.name}", ${optionalField.name}, ${helper.getDataWriterCall(typedField.type, optionalField.name)}<#if optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>)
+ writeOptionalField("${optionalField.name}", ${optionalField.name}, ${helper.getDataWriterCall(typedField.type, optionalField.name)}<#if optionalField.conditionExpression.present>, ${helper.toSerializationExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>)
</#if>
<#break>
<#case "padding">
<#assign paddingField = field.asPaddingField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
- # Padding Field (padding)
- writePaddingField("padding", (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)}), (${helper.getLanguageTypeNameForField(field)}) ${helper.toSerializationExpression(paddingField, paddingField.type, paddingField.paddingValue, parserArguments)}, ${helper.getDataWriterCall(typedField.type, "padding")})
+ # Padding Field (padding)
+ writePaddingField("padding", (int) (${helper.toParseExpression(paddingField, helper.intTypeReference, paddingField.paddingCondition, parserArguments)}), (${helper.getLanguageTypeNameForField(field)}) ${helper.toSerializationExpression(paddingField, paddingField.type, paddingField.paddingValue, parserArguments)}, ${helper.getDataWriterCall(typedField.type, "padding")})
<#break>
<#case "reserved">
<#assign reservedField = field.asReservedField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
- # Reserved Field (reserved)
- writeReservedField("reserved", reservedField${reservedFieldIndex}!=null?reservedField${reservedFieldIndex}:${helper.getReservedValue(reservedField)}, ${helper.getDataWriterCall(typedField.type, "reserved")})<#assign reservedFieldIndex=reservedFieldIndex+1>
+ # Reserved Field (reserved)
+ writeReservedField("reserved", reservedField${reservedFieldIndex}!=null?reservedField${reservedFieldIndex}:${helper.getReservedValue(reservedField)}, ${helper.getDataWriterCall(typedField.type, "reserved")})<#assign reservedFieldIndex=reservedFieldIndex+1>
<#break>
<#case "simple">
<#assign simpleField = field.asSimpleField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Simple Field (${namedField.name})
+ # Simple Field (${namedField.name})
<#if typedField.type.isEnumTypeReference()>
- writeSimpleEnumField("${simpleField.name}", "${helper.getLanguageTypeNameForField(field)}", ${simpleField.name}, ${helper.getEnumDataWriterCall(simpleField.type, simpleField.name, "value")})
+ writeSimpleEnumField("${simpleField.name}", "${helper.getLanguageTypeNameForField(field)}", ${simpleField.name}, ${helper.getEnumDataWriterCall(simpleField.type, simpleField.name, "value")})
<#elseif simpleField.type.isDataIoTypeReference()>
- writeSimpleField("${simpleField.name}", ${simpleField.name}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${simpleField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(simpleField, helper.anyTypeReference, param, parserArguments [...]
+ writeSimpleField("${simpleField.name}", ${simpleField.name}, new DataWriterDataIoDefault(writeBuffer, (wb, val) -> ${simpleField.type.asComplexTypeReference().orElseThrow().name}.staticSerialize(wb, val<#if simpleField.type.asComplexTypeReference().orElseThrow().params?has_content>, <#list simpleField.type.asComplexTypeReference().orElseThrow().params.orElseThrow() as param>${helper.toParseExpression(simpleField, helper.anyTypeReference, param, parserArguments)}<#sep>, </#sep></# [...]
<#else>
- writeSimpleField("${simpleField.name}", ${simpleField.name}, ${helper.getDataWriterCall(typedField.type, simpleField.name)}${helper.getFieldOptions(typedField, parserArguments)})</#if>
+ writeSimpleField("${simpleField.name}", ${simpleField.name}, ${helper.getDataWriterCall(typedField.type, simpleField.name)}${helper.getFieldOptions(typedField, parserArguments)})</#if>
<#break>
<#case "switch">
<#assign switchField = field.asSwitchField().orElseThrow()>
- # Switch field (Serialize the sub-type)
- serialize${type.name?cap_first}Child(writeBuffer)
+ # Switch field (Serialize the sub-type)
+ self.serialize${type.name?cap_first}Child(writeBuffer)
<#break>
<#case "virtual">
<#assign virtualField = field.asVirtualField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- # Virtual field (doesn't actually serialize anything, just makes the value available)
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = get${namedField.name?cap_first}()
- writeBuffer.writeVirtual("${namedField.name}", ${namedField.name})
+ # Virtual field (doesn't actually serialize anything, just makes the value available)
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = get${namedField.name?cap_first}()
+ writeBuffer.writeVirtual("${namedField.name}", ${namedField.name})
<#break>
</#switch>
</#list>
- writeBuffer.popContext("${type.name}")
+ writeBuffer.popContext("${type.name}")
</#if>
</#if>
+ <@emitImport import="import math" />
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = <#if type.parentType.isPresent()>super().getLengthInBits()<#else>0</#if>
@@ -501,7 +519,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#case "switch">
<#assign switchField = field.asSwitchField().orElseThrow()>
- # Length of sub-type elements will be added by sub-type...
+ # Length of subtype elements will be added by sub-type...
<#break>
<#case "unknown">
<#assign unknownField = field.asUnknownField().orElseThrow()>
@@ -535,7 +553,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
if isinstance(args[${parserArgument?index}], ${languageName}):
${parserArgument.name} = ${languageName}(args[${parserArgument?index}])
<#if parserArgument.type.isSimpleTypeReference() || parserArgument.type.isEnumTypeReference()>
- elif isinstance(args[${parserArgument?index}], String):
+ elif isinstance(args[${parserArgument?index}], str):
${parserArgument.name} = ${languageName}.valueOf(str(args[${parserArgument?index}]))
</#if>
else:
@@ -544,13 +562,14 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
</#list>
</#if>
return staticParse(readBuffer<#if parserArguments?has_content>, <#list parserArguments as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>)
- }
+
</#if>
<#-- Here come the actual parse and serialize methods that actually do the parsing and serlaizing -->
<#assign hasParserArguments=parserArguments?has_content/>
- <#assign parserArgumentList><#if hasParserArguments><#list parserArguments as parserArgument>${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)} ${parserArgument.name}<#sep>, </#sep></#list></#if></#assign>
- def <#if type.isDiscriminatedChildTypeDefinition()> staticParseBuilder<#else> staticParse</#if>(readBuffer: ReadBuffer<#if hasParserArguments>, ${parserArgumentList}</#if>) -> ${type.name}<#if type.isDiscriminatedChildTypeDefinition()>Builder</#if>:
+ <#assign parserArgumentList><#if hasParserArguments><#list parserArguments as parserArgument>${parserArgument.name}: ${helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)}<#sep>, </#sep></#list></#if></#assign>
+ @staticmethod
+ def <#if type.isDiscriminatedChildTypeDefinition()>staticParseBuilder<#else>staticParseContext</#if>(readBuffer: ReadBuffer<#if hasParserArguments>, ${parserArgumentList}</#if>) -> ${type.name}<#if type.isDiscriminatedChildTypeDefinition()>Builder</#if>:
readBuffer.pullContext("${type.name}")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -566,21 +585,21 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#if arrayElementTypeReference.isByteBased()>
<#if !field.isCountArrayField() && !field.isLengthArrayField()>
- raise ParseException("array fields of type byte only support 'count' and 'length' loop-types.")
+ 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)})
+ ${namedField.name}: byte[] = readBuffer.readByteArray("${namedField.name}", Math.toIntExact(${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()>
- ${arrayField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} = readCountArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${arrayField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} = readCountArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
<#-- In all other cases do we have to work with a list, that is later converted to an array -->
<#else>
<#-- For a length array, we read data till the read position of the buffer reaches a given position -->
<#if field.isLengthArrayField()>
- ${arrayField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} = readLengthArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${arrayField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} = readLengthArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, ${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
<#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
<#elseif field.isTerminatedArrayField()>
- ${arrayField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} = readTerminatedArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, () -> ((boolean) (${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}))${helper.getFieldOptions(typedField, parserArguments)})
+ ${arrayField.name}: ${helper.getNonPrimitiveLanguageTypeNameForField(arrayField)} = readTerminatedArrayField("${arrayField.name}", ${helper.getDataReaderCall(arrayField.type)}, () -> ((boolean) (${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}))${helper.getFieldOptions(typedField, parserArguments)})
</#if>
</#if>
</#if>
@@ -590,42 +609,42 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(assertField, assertField.type, assertField.conditionExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(assertField, assertField.type, assertField.conditionExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "checksum">
<#assign checksumField = field.asChecksumField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "const">
<#assign constField = field.asConstField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, ${type.name}.${namedField.name?upper_case}${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, ${type.name}.${namedField.name?upper_case}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "discriminator">
<#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "enum">
<#assign enumField = field.asEnumField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", "${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}", readEnum(${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}::firstEnumForField${enumField.fieldName?cap_first}, ${helper.getDataReaderCall(helper.getEnumFieldTypeReference(enumField.type, enumField.fieldName))})${helper.getFieldOptions(type [...]
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", "${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}", readEnum(${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}::firstEnumForField${enumField.fieldName?cap_first}, ${helper.getDataReaderCall(helper.getEnumFieldTypeReference(enumField.type, enumField.fieldName))})${helper.getFieldOptions(typedField, [...]
<#break>
<#case "implicit">
<#assign implicitField = field.asImplicitField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "manualArray">
<#assign manualArrayField = field.asManualArrayField().orElseThrow()>
@@ -634,9 +653,9 @@ 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)})
+ ${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)})
<#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.toP [...]
+ ${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>
<#break>
<#case "manual">
@@ -644,44 +663,43 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${manualField.name}: ${helper.getLanguageTypeNameForField(field)} = readManualField("${namedField.name}", readBuffer, () -> (${helper.getLanguageTypeNameForField(manualField)}) (${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ ${manualField.name}: ${helper.getLanguageTypeNameForField(field)} = readManualField("${namedField.name}", readBuffer, () -> (${helper.getLanguageTypeNameForField(manualField)}) (${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "optional">
<#assign optionalField = field.asOptionalField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if optionalField.conditionExpression.present>, ${helper.toParseExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if optionalField.conditionExpression.present>, ${helper.toParseExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "padding">
<#assign paddingField = field.asPaddingField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
- read${field.typeName?cap_first}Field(${helper.getDataReaderCall(typedField.type)}, (int) (${helper.toParseExpression(paddingField, paddingField.type, paddingField.paddingCondition, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ read${field.typeName?cap_first}Field(${helper.getDataReaderCall(typedField.type)}, (int) (${helper.toParseExpression(paddingField, paddingField.type, paddingField.paddingCondition, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "reserved">
<#assign reservedField = field.asReservedField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
- ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedFieldIndex}<#assign reservedFieldIndex=reservedFieldIndex+1> = read${field.typeName?cap_first}Field("reserved", ${helper.getDataReaderCall(typedField.type)}, ${helper.getReservedValue(reservedField)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedFieldIndex}<#assign reservedFieldIndex=reservedFieldIndex+1> = read${field.typeName?cap_first}Field("reserved", ${helper.getDataReaderCall(typedField.type)}, ${helper.getReservedValue(reservedField)}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "simple">
<#assign simpleField = field.asSimpleField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = <#if typedField.type.isEnumTypeReference()>readEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})<#else>read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})</#if>
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = <#if typedField.type.isEnumTypeReference()>readEnumField("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})<#else>read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})</#if>
<#break>
<#case "switch">
<#assign switchField = field.asSwitchField().orElseThrow()>
- # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
- builder: ${type.name}Builder = None
+ # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ builder: ${type.name}Builder = None
<#list switchField.cases as case>
- <@compress single_line=true>
- <#if case.discriminatorValueTerms?has_content>
- if<#sep>
+ <#if case.discriminatorValueTerms?has_content>
+ if <@compress single_line=true><#sep>
<#list case.discriminatorValueTerms as discriminatorValueTerm>
<#if helper.isWildcard(discriminatorValueTerm)>
true
@@ -695,43 +713,42 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#else>
(${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}) ${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
</#if>
- )
</#if>
<#sep> and </#sep>
</#list>
- )
- </#if>:
- </...@compress>
- <@compress single_line=true>
+ ):</...@compress>
+ </#if>
+
+ builder = <@compress single_line=true>
<#assign hasCaseParseArguments=case.allParserArguments.isPresent() && case.allParserArguments.orElseThrow()?has_content>
<#assign caseParseArguments><#if hasCaseParseArguments><#list case.allParserArguments.orElseThrow() as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if></#assign>
- builder = ${case.name}.staticParseBuilder(readBuffer<#if hasCaseParseArguments>, ${tracer.dive("case parse arguments")} ${caseParseArguments}</#if>)
+ ${case.name}.staticParseBuilder(readBuffer<#if hasCaseParseArguments>, ${tracer.dive("case parse arguments")} ${caseParseArguments}</#if>)
</...@compress>
- <#sep> else:</#sep>
- </#list>
- if builder is None:
- raise ParseException("Unsupported case for discriminated type"<#if switchField.getDiscriminatorExpressions()?has_content>+" parameters ["<#list switchField.getDiscriminatorExpressions() as discriminatorExpression>+"${discriminatorExpression.stringRepresentation()}="+${helper.toParseExpression(null, null, discriminatorExpression, parserArguments)}<#sep>+" "</#sep></#list>+"]"</#if>)
+
+ </#list>
+ if builder is None:
+ raise ParseException("Unsupported case for discriminated type"<#if switchField.getDiscriminatorExpressions()?has_content>+" parameters ["<#list switchField.getDiscriminatorExpressions() as discriminatorExpression>+"${discriminatorExpression.stringRepresentation()}="+${helper.toParseExpression(null, null, discriminatorExpression, parserArguments)}<#sep>+" "</#sep></#list>+"]"</#if>)
<#break>
<#case "unknown">
<#assign unknownField = field.asUnknownField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
- read${field.typeName?cap_first}Field("unknown", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
+ read${field.typeName?cap_first}Field("unknown", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "virtual">
<#assign virtualField = field.asVirtualField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getLanguageTypeNameForField(field)}.class, ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getLanguageTypeNameForField(field)}.class, ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "validation">
<#assign validationField = field.asValidationField().orElseThrow()>
- # Validation
- if not ${helper.toParseExpression(validationField, helper.boolTypeReference, validationField.getValidationExpression(), null)}):
- <#assign errorType="ParseValidationException">
- <#if !validationField.shouldFail()><#assign errorType="ParseAssertException"></#if>
- raise ${errorType}(${validationField.getDescription().orElse("\"Validation failed\"")})
+ # Validation
+ if not ${helper.toParseExpression(validationField, helper.boolTypeReference, validationField.getValidationExpression(), null)}):
+ <#assign errorType="ParseValidationException">
+ <#if !validationField.shouldFail()><#assign errorType="ParseAssertException"></#if>
+ raise ${errorType}(${validationField.getDescription().orElse("\"Validation failed\"")})
<#break>
<#case "peek">
@@ -739,15 +756,15 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if peekField.offsetExpression.present>, ${helper.toParseExpression(peekField, helper.boolTypeReference, peekField.offsetExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if peekField.offsetExpression.present>, ${helper.toParseExpression(peekField, helper.boolTypeReference, peekField.offsetExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
<#break>
</#switch>
</#list>
- readBuffer.closeContext("${type.name}")
- # Create the instance
+ readBuffer.closeContext("${type.name}")
+ # Create the instance
<#if type.isDiscriminatedChildTypeDefinition()>
- return ${type.name}Builder(
+ return ${type.name}Builder(<@compress single_line=true>
<#list type.propertyFields as field>
${field.name}<#sep>, </#sep>
</#list>
@@ -760,9 +777,9 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#list reservedFields as reservedField>
reservedField${reservedField?index}<#sep>, </#sep>
</#list>
- )
+ )</...@compress>
<#elseif type.isDiscriminatedParentTypeDefinition()>
- _${type.name?uncap_first}: ${type.name} = builder.build(
+ _${type.name?uncap_first}: ${type.name} = builder.build(<@compress single_line=true>
<#list type.propertyFields as field>
${field.name}<#sep>, </#sep>
</#list>
@@ -772,13 +789,13 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
${arg.name}<#sep>, </#sep>
</#list>
</#if>
- )
+ )</...@compress>
<#list reservedFields as reservedField>
_${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index}
</#list>
return _${type.name?uncap_first}
<#else>
- _${type.name?uncap_first}: ${type.name} = ${type.name}(
+ _${type.name?uncap_first}: ${type.name} = ${type.name}(<@compress single_line=true>
<#list type.propertyFields as field>
${field.name}<#sep>, </#sep>
</#list>
@@ -788,23 +805,23 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
${arg.name}<#sep>, </#sep>
</#list>
</#if>
- )
+ )</...@compress>
<#list reservedFields as reservedField>
- _${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index}
+ _${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index}
</#list>
return _${type.name?uncap_first}
</#if>
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ${type.name}):
+ if not isinstance(o, ${type.name}):
return False
that: ${type.name} = ${type.name}(o)
- return
+ 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}()) &&
@@ -813,10 +830,10 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#if type.parentType.isPresent()>
super().equals(that) &&
</#if>
- True
+ True</...@compress>
def hashCode(self) -> int:
- return Objects.hash(
+ return hash(<@compress single_line=true>
<#if type.parentType.isPresent()>
super().hashCode()<#if type.propertyFields?has_content>,</#if>
</#if>
@@ -825,27 +842,27 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
get${field.name?cap_first}()<#sep>,</#sep>
</#list>
</#if>
- )
+ )</...@compress>
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
<#if type.isDiscriminatedParentTypeDefinition()>
class ${type.name}Builder:
<@compress single_line=true>def build(
<#list type.propertyFields as field>
- ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
+ ${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>
+ ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}<#sep>, </#sep>
</#list>
</#if>
) -> ${type.name}:</...@compress>
@@ -902,12 +919,12 @@ class ${type.name}Builder(${type.parentType.orElseThrow().name}${type.parentType
def build(
<#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().propertyFields as field>
- ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
+ ${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>
- ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name}<#sep>, </#sep>
+ ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}<#sep>, </#sep>
</#list>
</#if>
) -> ${type.name}:
@@ -927,5 +944,6 @@ class ${type.name}Builder(${type.parentType.orElseThrow().name}${type.parentType
return ${type.name?uncap_first}
</#if>
+</...@importSectionWithContentBelow>
</#outputformat>
\ No newline at end of file
diff --git a/sandbox/plc4py/plc4py/protocols/__init__.py b/sandbox/plc4py/plc4py/protocols/__init__.py
new file mode 100644
index 0000000000..342be71799
--- /dev/null
+++ b/sandbox/plc4py/plc4py/protocols/__init__.py
@@ -0,0 +1,18 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/__init__.py b/sandbox/plc4py/plc4py/protocols/modbus/__init__.py
new file mode 100644
index 0000000000..342be71799
--- /dev/null
+++ b/sandbox/plc4py/plc4py/protocols/modbus/__init__.py
@@ -0,0 +1,18 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
index eb0ac8bfaa..c382ac97e6 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
@@ -22,22 +22,28 @@ from abc import ABC, abstractmethod
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.DriverType import DriverType
+from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
+import math
+
+
@dataclass
class ModbusAsciiADU(PlcMessage,ModbusADU):
- address: c_uint8
- pdu: ModbusPDU
- # Arguments.
- response: c_bool
+ address: c_uint8
+ pdu: ModbusPDU
+ # Arguments.
+ response: c_bool
# Accessors for discriminator values.
def DriverType getDriverType() {
return DriverType.MODBUS_ASCII
- }
def __post_init__(self):
-super().__init__( self.response )
+ super().__init__( self.response )
@@ -50,23 +56,23 @@ super().__init__( self.response )
def serializeModbusADUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusAsciiADU")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusAsciiADU")
- # Simple Field (address)
- writeSimpleField("address", address, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ # Simple Field (address)
+ writeSimpleField("address", address, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
- # Simple Field (pdu)
- writeSimpleField("pdu", pdu, new DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ # Simple Field (pdu)
+ writeSimpleField("pdu", pdu, new 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))
+ # Checksum Field (checksum) (Calculated)
+ writeChecksumField("crc", (c_uint8) (modbus.readwrite.utils.StaticHelper.asciiLrcCheck(address, pdu)), writeUnsignedShort(writeBuffer, 8))
- writeBuffer.popContext("ModbusAsciiADU")
+ writeBuffer.popContext("ModbusAsciiADU")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -84,58 +90,45 @@ super().__init__( self.response )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, c_bool response) -> ModbusAsciiADUBuilder:
+ @staticmethod
+ 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", new DataReaderComplexDefault<>(() -> ModbusPDU.staticParse(readBuffer, (c_bool) (response)), readBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ pdu: ModbusPDU = readSimpleField("pdu", new 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
-
- )
+ readBuffer.closeContext("ModbusAsciiADU")
+ # Create the instance
+ return ModbusAsciiADUBuilder(address, pdu , response )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusAsciiADU):
+ if not isinstance(o, ModbusAsciiADU):
return False
that: ModbusAsciiADU = ModbusAsciiADU(o)
- return
- (getAddress() == that.getAddress()) &&
- (getPdu() == that.getPdu()) &&
- super().equals(that) &&
- True
+ return (getAddress() == that.getAddress()) && (getPdu() == that.getPdu()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getAddress(),
- getPdu()
- )
+ return hash(super().hashCode(), getAddress(), getPdu() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,7 +138,7 @@ class ModbusAsciiADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: Mod
def build(
- c_bool response
+ response: c_bool
) -> ModbusAsciiADU:
modbusAsciiADU: ModbusAsciiADU = ModbusAsciiADU(
address,
@@ -156,3 +149,4 @@ class ModbusAsciiADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: Mod
return modbusAsciiADU
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
index f54de1e3f7..75ddd1e121 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
@@ -22,15 +22,19 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_uint16
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusConstants(PlcMessage):
- MODBUSTCPDEFAULTPORT: c_uint16 = 502
+ MODBUSTCPDEFAULTPORT: c_uint16 = 502
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -40,17 +44,17 @@ super().__init__( )
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusConstants")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusConstants")
- # Const Field (modbusTcpDefaultPort)
+ # Const Field (modbusTcpDefaultPort)
writeConstField("modbusTcpDefaultPort", MODBUSTCPDEFAULTPORT, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusConstants")
+ writeBuffer.popContext("ModbusConstants")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = 0
@@ -65,46 +69,45 @@ super().__init__( )
def staticParse(readBuffer: ReadBuffer , args) -> ModbusConstants:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
- }
- def staticParse(readBuffer: ReadBuffer) -> ModbusConstants:
+
+ @staticmethod
+ def staticParseContext(readBuffer: ReadBuffer) -> ModbusConstants:
readBuffer.pullContext("ModbusConstants")
positionAware: PositionAware = readBuffer
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(
- )
+ readBuffer.closeContext("ModbusConstants")
+ # Create the instance
+ _modbusConstants: ModbusConstants = ModbusConstants()
return _modbusConstants
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusConstants):
+ if not isinstance(o, ModbusConstants):
return False
that: ModbusConstants = ModbusConstants(o)
- return
- True
+ return True
def hashCode(self) -> int:
- return Objects.hash(
- )
+ return hash()
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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 b0d22f4189..58529e41fc 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
@@ -22,16 +22,21 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusDeviceInformationObject(PlcMessage):
- objectId: c_uint8
- data: []c_byte
+ objectId: c_uint8
+ data: []c_byte
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -44,24 +49,24 @@ super().__init__( )
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusDeviceInformationObject")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusDeviceInformationObject")
- # Simple Field (objectId)
- writeSimpleField("objectId", objectId, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (objectId)
+ 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))
+ # 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))
- # Array Field (data)
- writeByteArrayField("data", data, writeByteArray(writeBuffer, 8))
+ # Array Field (data)
+ writeByteArrayField("data", data, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusDeviceInformationObject")
+ writeBuffer.popContext("ModbusDeviceInformationObject")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = 0
@@ -84,56 +89,49 @@ super().__init__( )
def staticParse(readBuffer: ReadBuffer , args) -> ModbusDeviceInformationObject:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
- }
- def staticParse(readBuffer: ReadBuffer) -> ModbusDeviceInformationObject:
+
+ @staticmethod
+ def staticParseContext(readBuffer: ReadBuffer) -> ModbusDeviceInformationObject:
readBuffer.pullContext("ModbusDeviceInformationObject")
positionAware: PositionAware = readBuffer
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: byte[] = readBuffer.readByteArray("data", Math.toIntExact(objectLength))
- readBuffer.closeContext("ModbusDeviceInformationObject")
- # Create the instance
- _modbusDeviceInformationObject: ModbusDeviceInformationObject = ModbusDeviceInformationObject(
- objectId,
- data
- )
+ readBuffer.closeContext("ModbusDeviceInformationObject")
+ # Create the instance
+ _modbusDeviceInformationObject: ModbusDeviceInformationObject = ModbusDeviceInformationObject(objectId, data )
return _modbusDeviceInformationObject
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusDeviceInformationObject):
+ if not isinstance(o, ModbusDeviceInformationObject):
return False
that: ModbusDeviceInformationObject = ModbusDeviceInformationObject(o)
- return
- (getObjectId() == that.getObjectId()) &&
- (getData() == that.getData()) &&
- True
+ return (getObjectId() == that.getObjectId()) && (getData() == that.getData()) && True
def hashCode(self) -> int:
- return Objects.hash(
- getObjectId(),
- getData()
- )
+ return hash(getObjectId(), getData() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
index 65b2581d19..2cedcd91eb 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
@@ -22,22 +22,30 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDU(ABC, PlcMessage):
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
# Abstract accessors for discriminator values.
@abstractmethod
def getErrorFlag(self) -> c_bool:
+ pass
@abstractmethod
def getFunctionFlag(self) -> c_uint8:
+ pass
@abstractmethod
def getResponse(self) -> c_bool:
+ pass
@@ -47,23 +55,23 @@ super().__init__( )
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDU")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDU")
- # Discriminator Field (errorFlag) (Used as input to a switch field)
- writeDiscriminatorField("errorFlag", getErrorFlag(), writeBoolean(writeBuffer))
+ # Discriminator Field (errorFlag) (Used as input to a switch field)
+ writeDiscriminatorField("errorFlag", getErrorFlag(), writeBoolean(writeBuffer))
- # Discriminator Field (functionFlag) (Used as input to a switch field)
- writeDiscriminatorField("functionFlag", getFunctionFlag(), writeUnsignedShort(writeBuffer, 7))
+ # Discriminator Field (functionFlag) (Used as input to a switch field)
+ writeDiscriminatorField("functionFlag", getFunctionFlag(), writeUnsignedShort(writeBuffer, 7))
- # Switch field (Serialize the sub-type)
- serializeModbusPDUChild(writeBuffer)
+ # Switch field (Serialize the sub-type)
+ self.serializeModbusPDUChild(writeBuffer)
- writeBuffer.popContext("ModbusPDU")
+ writeBuffer.popContext("ModbusPDU")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = 0
@@ -75,7 +83,7 @@ super().__init__( )
# Discriminator Field (functionFlag)
lengthInBits += 7
- # Length of sub-type elements will be added by sub-type...
+ # Length of subtype elements will be added by sub-type...
return lengthInBits
@@ -88,99 +96,175 @@ super().__init__( )
response: c_bool = None
if isinstance(args[0], c_bool):
response = c_bool(args[0])
- elif isinstance(args[0], String):
+ elif isinstance(args[0], str):
response = c_bool.valueOf(str(args[0]))
else:
raise PlcRuntimeException("Argument 0 expected to be of type c_bool or a string which is parseable but was " + args[0].getClass().getName())
return staticParse(readBuffer, response)
- }
- def staticParse(readBuffer: ReadBuffer, c_bool response) -> ModbusPDU:
+
+ @staticmethod
+ def staticParseContext(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDU:
readBuffer.pullContext("ModbusPDU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- errorFlag: c_bool = readDiscriminatorField("errorFlag", readBoolean(readBuffer))
-
- functionFlag: c_uint8 = readDiscriminatorField("functionFlag", readUnsignedShort(readBuffer, 7))
-
- # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
- builder: ModbusPDUBuilder = None
-if EvaluationHelper.equals( errorFlag, (c_bool) true ) ) :builder = ModbusPDUError.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x02 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadDiscreteInputsRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x02 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadDiscreteInputsResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x01 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadCoilsRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x01 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadCoilsResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x05 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUWriteSingleCoilRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x05 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUWriteSingleCoilResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0F ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUWriteMultipleCoilsRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0F ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUWriteMultipleCoilsResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x04 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadInputRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x04 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadInputRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x03 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadHoldingRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x03 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadHoldingRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x06 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUWriteSingleRegisterRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x06 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUWriteSingleRegisterResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x10 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUWriteMultipleHoldingRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x10 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUWriteMultipleHoldingRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x17 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadWriteMultipleHoldingRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x17 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadWriteMultipleHoldingRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x16 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUMaskWriteHoldingRegisterRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x16 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUMaskWriteHoldingRegisterResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x18 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadFifoQueueRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x18 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadFifoQueueResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x14 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadFileRecordRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x14 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadFileRecordResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x15 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUWriteFileRecordRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x15 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUWriteFileRecordResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x07 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadExceptionStatusRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x07 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReadExceptionStatusResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x08 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUDiagnosticRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x08 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUDiagnosticResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0B ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUGetComEventCounterRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0B ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUGetComEventCounterResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0C ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUGetComEventLogRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0C ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUGetComEventLogResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x11 ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReportServerIdRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x11 ) and EvaluationHelper.equals( response, (c_bool) true ) ) :builder = ModbusPDUReportServerIdResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (c_bool) false ) and EvaluationHelper.equals( functionFlag, (c_uint8) 0x2B ) and EvaluationHelper.equals( response, (c_bool) false ) ) :builder = ModbusPDUReadDeviceIdentificationRequest.staticParseBuilder(readBuffer, response) else:
-if:builder = ModbusPDUReadDeviceIdentificationResponse.staticParseBuilder(readBuffer, response)
- if builder is None:
- raise ParseException("Unsupported case for discriminated type"+" parameters ["+"errorFlag="+errorFlag+" "+"functionFlag="+functionFlag+" "+"response="+response+"]")
-
-
- readBuffer.closeContext("ModbusPDU")
- # Create the instance
- _modbusPDU: ModbusPDU = builder.build(
- )
+ errorFlag: c_bool = readDiscriminatorField("errorFlag", readBoolean(readBuffer))
+
+ functionFlag: c_uint8 = readDiscriminatorField("functionFlag", readUnsignedShort(readBuffer, 7))
+
+ # Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
+ builder: ModbusPDUBuilder = None
+ if EvaluationHelper.equals( errorFlag, (c_bool) true ):
+
+ builder = ModbusPDUError.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x02 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadDiscreteInputsRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x02 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadDiscreteInputsResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x01 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadCoilsRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x01 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadCoilsResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x05 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUWriteSingleCoilRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x05 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUWriteSingleCoilResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0F and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUWriteMultipleCoilsRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0F and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUWriteMultipleCoilsResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x04 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadInputRegistersRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x04 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadInputRegistersResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x03 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadHoldingRegistersRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x03 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadHoldingRegistersResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x06 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUWriteSingleRegisterRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x06 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUWriteSingleRegisterResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x10 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUWriteMultipleHoldingRegistersRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x10 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUWriteMultipleHoldingRegistersResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x17 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadWriteMultipleHoldingRegistersRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x17 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadWriteMultipleHoldingRegistersResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x16 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUMaskWriteHoldingRegisterRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x16 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUMaskWriteHoldingRegisterResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x18 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadFifoQueueRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x18 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadFifoQueueResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x14 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadFileRecordRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x14 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadFileRecordResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x15 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUWriteFileRecordRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x15 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUWriteFileRecordResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x07 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadExceptionStatusRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x07 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReadExceptionStatusResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x08 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUDiagnosticRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x08 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUDiagnosticResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0B and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUGetComEventCounterRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0B and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUGetComEventCounterResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0C and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUGetComEventLogRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x0C and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUGetComEventLogResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x11 and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReportServerIdRequest.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x11 and EvaluationHelper.equals( response, (c_bool) true ):
+
+ builder = ModbusPDUReportServerIdResponse.staticParseBuilder(readBuffer, response)
+ if EvaluationHelper.equals( errorFlag, (c_bool) false and EvaluationHelper.equals( functionFlag, (c_uint8) 0x2B and EvaluationHelper.equals( response, (c_bool) false ):
+
+ builder = ModbusPDUReadDeviceIdentificationRequest.staticParseBuilder(readBuffer, response)
+ if
+
+ builder = ModbusPDUReadDeviceIdentificationResponse.staticParseBuilder(readBuffer, response)
+ if builder is None:
+ raise ParseException("Unsupported case for discriminated type"+" parameters ["+"errorFlag="+errorFlag+" "+"functionFlag="+functionFlag+" "+"response="+response+"]")
+
+
+ readBuffer.closeContext("ModbusPDU")
+ # Create the instance
+ _modbusPDU: ModbusPDU = builder.build()
return _modbusPDU
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDU):
+ if not isinstance(o, ModbusPDU):
return False
that: ModbusPDU = ModbusPDU(o)
- return
- True
+ return True
def hashCode(self) -> int:
- return Objects.hash(
- )
+ return hash()
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUBuilder:
def build( ) -> ModbusPDU:
@@ -188,3 +272,4 @@ class ModbusPDUBuilder:
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
index 3a51471402..b5463ef062 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
- subFunction: c_uint16
- data: c_uint16
+ subFunction: c_uint16
+ data: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x08
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUDiagnosticRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUDiagnosticRequest")
- # Simple Field (subFunction)
- writeSimpleField("subFunction", subFunction, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (subFunction)
+ writeSimpleField("subFunction", subFunction, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (data)
- writeSimpleField("data", data, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (data)
+ writeSimpleField("data", data, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUDiagnosticRequest")
+ writeBuffer.popContext("ModbusPDUDiagnosticRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUDiagnosticRequestBuilder:
+ @staticmethod
+ 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))
+ data: c_uint16 = readSimpleField("data", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUDiagnosticRequest")
- # Create the instance
- return ModbusPDUDiagnosticRequestBuilder(
- subFunction,
- data
-
- )
+ readBuffer.closeContext("ModbusPDUDiagnosticRequest")
+ # Create the instance
+ return ModbusPDUDiagnosticRequestBuilder(subFunction, data )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUDiagnosticRequest):
+ if not isinstance(o, ModbusPDUDiagnosticRequest):
return False
that: ModbusPDUDiagnosticRequest = ModbusPDUDiagnosticRequest(o)
- return
- (getSubFunction() == that.getSubFunction()) &&
- (getData() == that.getData()) &&
- super().equals(that) &&
- True
+ return (getSubFunction() == that.getSubFunction()) && (getData() == that.getData()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getSubFunction(),
- getData()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getSubFunction(), getData() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUDiagnosticRequestBuilder(ModbusPDUModbusPDUBuilder: subFunction:
return modbusPDUDiagnosticRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
index 8338e2f9c1..9ccd199a68 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
- subFunction: c_uint16
- data: c_uint16
+ subFunction: c_uint16
+ data: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x08
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUDiagnosticResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUDiagnosticResponse")
- # Simple Field (subFunction)
- writeSimpleField("subFunction", subFunction, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (subFunction)
+ writeSimpleField("subFunction", subFunction, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (data)
- writeSimpleField("data", data, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (data)
+ writeSimpleField("data", data, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUDiagnosticResponse")
+ writeBuffer.popContext("ModbusPDUDiagnosticResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUDiagnosticResponseBuilder:
+ @staticmethod
+ 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))
+ data: c_uint16 = readSimpleField("data", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUDiagnosticResponse")
- # Create the instance
- return ModbusPDUDiagnosticResponseBuilder(
- subFunction,
- data
-
- )
+ readBuffer.closeContext("ModbusPDUDiagnosticResponse")
+ # Create the instance
+ return ModbusPDUDiagnosticResponseBuilder(subFunction, data )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUDiagnosticResponse):
+ if not isinstance(o, ModbusPDUDiagnosticResponse):
return False
that: ModbusPDUDiagnosticResponse = ModbusPDUDiagnosticResponse(o)
- return
- (getSubFunction() == that.getSubFunction()) &&
- (getData() == that.getData()) &&
- super().equals(that) &&
- True
+ return (getSubFunction() == that.getSubFunction()) && (getData() == that.getData()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getSubFunction(),
- getData()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getSubFunction(), getData() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUDiagnosticResponseBuilder(ModbusPDUModbusPDUBuilder: subFunction:
return modbusPDUDiagnosticResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
index 89eb0ff9b2..babe9f52d5 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
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.ModbusErrorCode import ModbusErrorCode
+import math
+
@dataclass
class ModbusPDUError(PlcMessage,ModbusPDU):
- exceptionCode: ModbusErrorCode
+ exceptionCode: ModbusErrorCode
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) true
- }
def c_uint8 getFunctionFlag() {
return 0
- }
def c_bool getResponse() {
return False
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,18 +53,18 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUError")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUError")
- # Simple Field (exceptionCode)
- writeSimpleEnumField("exceptionCode", "ModbusErrorCode", exceptionCode, new DataWriterEnumDefault<>(ModbusErrorCode::getValue, ModbusErrorCode::name, writeUnsignedShort(writeBuffer, 8)))
+ # Simple Field (exceptionCode)
+ writeSimpleEnumField("exceptionCode", "ModbusErrorCode", exceptionCode, new DataWriterEnumDefault<>(ModbusErrorCode::getValue, ModbusErrorCode::name, writeUnsignedShort(writeBuffer, 8)))
- writeBuffer.popContext("ModbusPDUError")
+ writeBuffer.popContext("ModbusPDUError")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -73,49 +76,41 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUErrorBuilder:
+ @staticmethod
+ 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", new DataReaderEnumDefault<>(ModbusErrorCode::enumForValue, readUnsignedShort(readBuffer, 8)))
+ exceptionCode: ModbusErrorCode = readEnumField("exceptionCode", "ModbusErrorCode", new DataReaderEnumDefault<>(ModbusErrorCode::enumForValue, readUnsignedShort(readBuffer, 8)))
- readBuffer.closeContext("ModbusPDUError")
- # Create the instance
- return ModbusPDUErrorBuilder(
- exceptionCode
-
- )
+ readBuffer.closeContext("ModbusPDUError")
+ # Create the instance
+ return ModbusPDUErrorBuilder(exceptionCode )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUError):
+ if not isinstance(o, ModbusPDUError):
return False
that: ModbusPDUError = ModbusPDUError(o)
- return
- (getExceptionCode() == that.getExceptionCode()) &&
- super().equals(that) &&
- True
+ return (getExceptionCode() == that.getExceptionCode()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getExceptionCode()
- )
+ return hash(super().hashCode(), getExceptionCode() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUErrorBuilder(ModbusPDUModbusPDUBuilder: exceptionCode: ModbusErrorCodedef ModbusPDUErrorBuilder( ModbusErrorCode exceptionCode ): self.exceptionCode = exceptionCode
@@ -129,3 +124,4 @@ class ModbusPDUErrorBuilder(ModbusPDUModbusPDUBuilder: exceptionCode: ModbusErro
return modbusPDUError
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
index 19a2fa3f30..013d704276 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
@@ -22,38 +22,40 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x0B
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUGetComEventCounterRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUGetComEventCounterRequest")
- writeBuffer.popContext("ModbusPDUGetComEventCounterRequest")
+ writeBuffer.popContext("ModbusPDUGetComEventCounterRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -62,44 +64,39 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventCounterRequestBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUGetComEventCounterRequestBuilder:
readBuffer.pullContext("ModbusPDUGetComEventCounterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- readBuffer.closeContext("ModbusPDUGetComEventCounterRequest")
- # Create the instance
- return ModbusPDUGetComEventCounterRequestBuilder(
-
- )
+ readBuffer.closeContext("ModbusPDUGetComEventCounterRequest")
+ # Create the instance
+ return ModbusPDUGetComEventCounterRequestBuilder()
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUGetComEventCounterRequest):
+ if not isinstance(o, ModbusPDUGetComEventCounterRequest):
return False
that: ModbusPDUGetComEventCounterRequest = ModbusPDUGetComEventCounterRequest(o)
- return
- super().equals(that) &&
- True
+ return super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode()
- )
+ return hash(super().hashCode() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUGetComEventCounterRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUGetComEventCounterRequestBuilder( ):
@@ -111,3 +108,4 @@ class ModbusPDUGetComEventCounterRequestBuilder(ModbusPDUModbusPDUBuilder:def Mo
return modbusPDUGetComEventCounterRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
index 7d4597cc89..0de6226ce7 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
- status: c_uint16
- eventCount: c_uint16
+ status: c_uint16
+ eventCount: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x0B
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUGetComEventCounterResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUGetComEventCounterResponse")
- # Simple Field (status)
- writeSimpleField("status", status, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (status)
+ writeSimpleField("status", status, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (eventCount)
- writeSimpleField("eventCount", eventCount, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (eventCount)
+ writeSimpleField("eventCount", eventCount, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUGetComEventCounterResponse")
+ writeBuffer.popContext("ModbusPDUGetComEventCounterResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventCounterResponseBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUGetComEventCounterResponseBuilder:
readBuffer.pullContext("ModbusPDUGetComEventCounterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- status: c_uint16 = readSimpleField("status", readUnsignedInt(readBuffer, 16))
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUGetComEventCounterResponse")
+ # Create the instance
+ return ModbusPDUGetComEventCounterResponseBuilder(status, eventCount )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUGetComEventCounterResponse):
+ if not isinstance(o, ModbusPDUGetComEventCounterResponse):
return False
that: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(o)
- return
- (getStatus() == that.getStatus()) &&
- (getEventCount() == that.getEventCount()) &&
- super().equals(that) &&
- True
+ return (getStatus() == that.getStatus()) && (getEventCount() == that.getEventCount()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStatus(),
- getEventCount()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStatus(), getEventCount() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUGetComEventCounterResponseBuilder(ModbusPDUModbusPDUBuilder: stat
return modbusPDUGetComEventCounterResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
index a021f89d18..399b487b59 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
@@ -22,38 +22,40 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x0C
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUGetComEventLogRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUGetComEventLogRequest")
- writeBuffer.popContext("ModbusPDUGetComEventLogRequest")
+ writeBuffer.popContext("ModbusPDUGetComEventLogRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -62,44 +64,39 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventLogRequestBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUGetComEventLogRequestBuilder:
readBuffer.pullContext("ModbusPDUGetComEventLogRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- readBuffer.closeContext("ModbusPDUGetComEventLogRequest")
- # Create the instance
- return ModbusPDUGetComEventLogRequestBuilder(
-
- )
+ readBuffer.closeContext("ModbusPDUGetComEventLogRequest")
+ # Create the instance
+ return ModbusPDUGetComEventLogRequestBuilder()
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUGetComEventLogRequest):
+ if not isinstance(o, ModbusPDUGetComEventLogRequest):
return False
that: ModbusPDUGetComEventLogRequest = ModbusPDUGetComEventLogRequest(o)
- return
- super().equals(that) &&
- True
+ return super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode()
- )
+ return hash(super().hashCode() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUGetComEventLogRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUGetComEventLogRequestBuilder( ):
@@ -111,3 +108,4 @@ class ModbusPDUGetComEventLogRequestBuilder(ModbusPDUModbusPDUBuilder:def Modbus
return modbusPDUGetComEventLogRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
index 33d4163795..1840d81fe0 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
@@ -22,28 +22,32 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
-
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
+
@dataclass
class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
- status: c_uint16
- eventCount: c_uint16
- messageCount: c_uint16
- events: []c_byte
+ status: c_uint16
+ eventCount: c_uint16
+ messageCount: c_uint16
+ events: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x0C
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -62,30 +66,30 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUGetComEventLogResponse")
+ 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))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Simple Field (status)
- writeSimpleField("status", status, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (status)
+ writeSimpleField("status", status, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (eventCount)
- writeSimpleField("eventCount", eventCount, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (eventCount)
+ writeSimpleField("eventCount", eventCount, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (messageCount)
- writeSimpleField("messageCount", messageCount, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (messageCount)
+ writeSimpleField("messageCount", messageCount, writeUnsignedInt(writeBuffer, 16))
- # Array Field (events)
- writeByteArrayField("events", events, writeByteArray(writeBuffer, 8))
+ # Array Field (events)
+ writeByteArrayField("events", events, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUGetComEventLogResponse")
+ writeBuffer.popContext("ModbusPDUGetComEventLogResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -111,66 +115,49 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventLogResponseBuilder:
+ @staticmethod
+ 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))
+ 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: byte[] = readBuffer.readByteArray("events", Math.toIntExact((byteCount) - (6)))
- readBuffer.closeContext("ModbusPDUGetComEventLogResponse")
- # Create the instance
- return ModbusPDUGetComEventLogResponseBuilder(
- status,
- eventCount,
- messageCount,
- events
-
- )
+ readBuffer.closeContext("ModbusPDUGetComEventLogResponse")
+ # Create the instance
+ return ModbusPDUGetComEventLogResponseBuilder(status, eventCount, messageCount, events )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUGetComEventLogResponse):
+ if not isinstance(o, ModbusPDUGetComEventLogResponse):
return False
that: ModbusPDUGetComEventLogResponse = ModbusPDUGetComEventLogResponse(o)
- return
- (getStatus() == that.getStatus()) &&
- (getEventCount() == that.getEventCount()) &&
- (getMessageCount() == that.getMessageCount()) &&
- (getEvents() == that.getEvents()) &&
- super().equals(that) &&
- True
+ return (getStatus() == that.getStatus()) && (getEventCount() == that.getEventCount()) && (getMessageCount() == that.getMessageCount()) && (getEvents() == that.getEvents()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStatus(),
- getEventCount(),
- getMessageCount(),
- getEvents()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStatus(), getEventCount(), getMessageCount(), getEvents() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -190,3 +177,4 @@ class ModbusPDUGetComEventLogResponseBuilder(ModbusPDUModbusPDUBuilder: status:
return modbusPDUGetComEventLogResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
index 69129809c7..9367a9fee8 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
@@ -22,27 +22,30 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
- referenceAddress: c_uint16
- andMask: c_uint16
- orMask: c_uint16
+ referenceAddress: c_uint16
+ andMask: c_uint16
+ orMask: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x16
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -58,23 +61,23 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUMaskWriteHoldingRegisterRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUMaskWriteHoldingRegisterRequest")
- # Simple Field (referenceAddress)
- writeSimpleField("referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (referenceAddress)
+ writeSimpleField("referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (andMask)
- writeSimpleField("andMask", andMask, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (andMask)
+ writeSimpleField("andMask", andMask, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (orMask)
- writeSimpleField("orMask", orMask, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (orMask)
+ writeSimpleField("orMask", orMask, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUMaskWriteHoldingRegisterRequest")
+ writeBuffer.popContext("ModbusPDUMaskWriteHoldingRegisterRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -92,59 +95,45 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUMaskWriteHoldingRegisterRequestBuilder:
+ @staticmethod
+ 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))
+ andMask: c_uint16 = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
- orMask: c_uint16 = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
+ orMask: c_uint16 = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterRequest")
- # Create the instance
- return ModbusPDUMaskWriteHoldingRegisterRequestBuilder(
- referenceAddress,
- andMask,
- orMask
-
- )
+ readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterRequest")
+ # Create the instance
+ return ModbusPDUMaskWriteHoldingRegisterRequestBuilder(referenceAddress, andMask, orMask )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUMaskWriteHoldingRegisterRequest):
+ 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
+ return (getReferenceAddress() == that.getReferenceAddress()) && (getAndMask() == that.getAndMask()) && (getOrMask() == that.getOrMask()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getReferenceAddress(),
- getAndMask(),
- getOrMask()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getReferenceAddress(), getAndMask(), getOrMask() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -162,3 +151,4 @@ class ModbusPDUMaskWriteHoldingRegisterRequestBuilder(ModbusPDUModbusPDUBuilder:
return modbusPDUMaskWriteHoldingRegisterRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
index 7d5b2d8f38..d50827c20f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
@@ -22,27 +22,30 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
- referenceAddress: c_uint16
- andMask: c_uint16
- orMask: c_uint16
+ referenceAddress: c_uint16
+ andMask: c_uint16
+ orMask: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x16
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -58,23 +61,23 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUMaskWriteHoldingRegisterResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUMaskWriteHoldingRegisterResponse")
- # Simple Field (referenceAddress)
- writeSimpleField("referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (referenceAddress)
+ writeSimpleField("referenceAddress", referenceAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (andMask)
- writeSimpleField("andMask", andMask, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (andMask)
+ writeSimpleField("andMask", andMask, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (orMask)
- writeSimpleField("orMask", orMask, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (orMask)
+ writeSimpleField("orMask", orMask, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUMaskWriteHoldingRegisterResponse")
+ writeBuffer.popContext("ModbusPDUMaskWriteHoldingRegisterResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -92,59 +95,45 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUMaskWriteHoldingRegisterResponseBuilder:
+ @staticmethod
+ 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))
+ andMask: c_uint16 = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
- orMask: c_uint16 = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
+ orMask: c_uint16 = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterResponse")
- # Create the instance
- return ModbusPDUMaskWriteHoldingRegisterResponseBuilder(
- referenceAddress,
- andMask,
- orMask
-
- )
+ readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterResponse")
+ # Create the instance
+ return ModbusPDUMaskWriteHoldingRegisterResponseBuilder(referenceAddress, andMask, orMask )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUMaskWriteHoldingRegisterResponse):
+ 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
+ return (getReferenceAddress() == that.getReferenceAddress()) && (getAndMask() == that.getAndMask()) && (getOrMask() == that.getOrMask()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getReferenceAddress(),
- getAndMask(),
- getOrMask()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getReferenceAddress(), getAndMask(), getOrMask() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -162,3 +151,4 @@ class ModbusPDUMaskWriteHoldingRegisterResponseBuilder(ModbusPDUModbusPDUBuilder
return modbusPDUMaskWriteHoldingRegisterResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
index e58c96de32..8210385c7f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadCoilsRequest(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x01
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadCoilsRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadCoilsRequest")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (quantity)
+ writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUReadCoilsRequest")
+ writeBuffer.popContext("ModbusPDUReadCoilsRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadCoilsRequestBuilder:
+ @staticmethod
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUReadCoilsRequest")
+ # Create the instance
+ return ModbusPDUReadCoilsRequestBuilder(startingAddress, quantity )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadCoilsRequest):
+ if not isinstance(o, ModbusPDUReadCoilsRequest):
return False
that: ModbusPDUReadCoilsRequest = ModbusPDUReadCoilsRequest(o)
- return
- (getStartingAddress() == that.getStartingAddress()) &&
- (getQuantity() == that.getQuantity()) &&
- super().equals(that) &&
- True
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUReadCoilsRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddres
return modbusPDUReadCoilsRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
index de9f3b1b8d..174408a776 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadCoilsResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x01
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadCoilsResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadCoilsResponse")
+ writeBuffer.popContext("ModbusPDUReadCoilsResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -81,51 +84,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadCoilsResponseBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUReadCoilsResponse")
- # Create the instance
- return ModbusPDUReadCoilsResponseBuilder(
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReadCoilsResponse")
+ # Create the instance
+ return ModbusPDUReadCoilsResponseBuilder(value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadCoilsResponse):
+ if not isinstance(o, ModbusPDUReadCoilsResponse):
return False
that: ModbusPDUReadCoilsResponse = ModbusPDUReadCoilsResponse(o)
- return
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getValue()
- )
+ return hash(super().hashCode(), getValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadCoilsResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadCoilsResponseBuilder( []c_byte value ): self.value = value
@@ -139,3 +134,4 @@ class ModbusPDUReadCoilsResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_by
return modbusPDUReadCoilsResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
index edb10be80a..a8d7223a18 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
@@ -22,27 +22,30 @@ from abc import ABC, abstractmethod
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
+import math
+
@dataclass
class ModbusPDUReadDeviceIdentificationRequest(PlcMessage,ModbusPDU):
- level: ModbusDeviceInformationLevel
- objectId: c_uint8
- MEITYPE: c_uint8 = 0x0E
+ level: ModbusDeviceInformationLevel
+ objectId: c_uint8
+ MEITYPE: c_uint8 = 0x0E
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x2B
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -58,24 +61,24 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadDeviceIdentificationRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadDeviceIdentificationRequest")
- # Const Field (meiType)
+ # Const Field (meiType)
writeConstField("meiType", MEITYPE, writeUnsignedShort(writeBuffer, 8))
- # Simple Field (level)
- writeSimpleEnumField("level", "ModbusDeviceInformationLevel", level, new DataWriterEnumDefault<>(ModbusDeviceInformationLevel::getValue, ModbusDeviceInformationLevel::name, writeUnsignedShort(writeBuffer, 8)))
+ # Simple Field (level)
+ writeSimpleEnumField("level", "ModbusDeviceInformationLevel", level, new DataWriterEnumDefault<>(ModbusDeviceInformationLevel::getValue, ModbusDeviceInformationLevel::name, writeUnsignedShort(writeBuffer, 8)))
- # Simple Field (objectId)
- writeSimpleField("objectId", objectId, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (objectId)
+ writeSimpleField("objectId", objectId, writeUnsignedShort(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadDeviceIdentificationRequest")
+ writeBuffer.popContext("ModbusPDUReadDeviceIdentificationRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -93,56 +96,45 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDeviceIdentificationRequestBuilder:
+ @staticmethod
+ 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)
+ meiType: c_uint8 = readConstField("meiType", readUnsignedShort(readBuffer, 8), ModbusPDUReadDeviceIdentificationRequest.MEITYPE)
- level: ModbusDeviceInformationLevel = readEnumField("level", "ModbusDeviceInformationLevel", new DataReaderEnumDefault<>(ModbusDeviceInformationLevel::enumForValue, readUnsignedShort(readBuffer, 8)))
+ level: ModbusDeviceInformationLevel = readEnumField("level", "ModbusDeviceInformationLevel", new DataReaderEnumDefault<>(ModbusDeviceInformationLevel::enumForValue, readUnsignedShort(readBuffer, 8)))
- objectId: c_uint8 = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
+ objectId: c_uint8 = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
- readBuffer.closeContext("ModbusPDUReadDeviceIdentificationRequest")
- # Create the instance
- return ModbusPDUReadDeviceIdentificationRequestBuilder(
- level,
- objectId
-
- )
+ readBuffer.closeContext("ModbusPDUReadDeviceIdentificationRequest")
+ # Create the instance
+ return ModbusPDUReadDeviceIdentificationRequestBuilder(level, objectId )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadDeviceIdentificationRequest):
+ if not isinstance(o, ModbusPDUReadDeviceIdentificationRequest):
return False
that: ModbusPDUReadDeviceIdentificationRequest = ModbusPDUReadDeviceIdentificationRequest(o)
- return
- (getLevel() == that.getLevel()) &&
- (getObjectId() == that.getObjectId()) &&
- super().equals(that) &&
- True
+ return (getLevel() == that.getLevel()) && (getObjectId() == that.getObjectId()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getLevel(),
- getObjectId()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getLevel(), getObjectId() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadDeviceIdentificationRequestBuilder(ModbusPDUModbusPDUBuilder: level: ModbusDeviceInformationLevel objectId: c_uint8def ModbusPDUReadDeviceIdentificationRequestBuilder( ModbusDeviceInformationLevel level, c_uint8 objectId ): self.level = level
@@ -158,3 +150,4 @@ class ModbusPDUReadDeviceIdentificationRequestBuilder(ModbusPDUModbusPDUBuilder:
return modbusPDUReadDeviceIdentificationRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
index 0746e072a8..684c571a64 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
@@ -22,31 +22,37 @@ from abc import ABC, abstractmethod
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
+import math
+
+
@dataclass
class ModbusPDUReadDeviceIdentificationResponse(PlcMessage,ModbusPDU):
- level: ModbusDeviceInformationLevel
- individualAccess: c_bool
- conformityLevel: ModbusDeviceInformationConformityLevel
- moreFollows: ModbusDeviceInformationMoreFollows
- nextObjectId: c_uint8
- objects: []ModbusDeviceInformationObject
- MEITYPE: c_uint8 = 0x0E
+ level: ModbusDeviceInformationLevel
+ individualAccess: c_bool
+ conformityLevel: ModbusDeviceInformationConformityLevel
+ moreFollows: ModbusDeviceInformationMoreFollows
+ nextObjectId: c_uint8
+ objects: []ModbusDeviceInformationObject
+ MEITYPE: c_uint8 = 0x0E
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x2B
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -74,42 +80,42 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadDeviceIdentificationResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadDeviceIdentificationResponse")
- # Const Field (meiType)
+ # Const Field (meiType)
writeConstField("meiType", MEITYPE, writeUnsignedShort(writeBuffer, 8))
- # Simple Field (level)
- writeSimpleEnumField("level", "ModbusDeviceInformationLevel", level, new DataWriterEnumDefault<>(ModbusDeviceInformationLevel::getValue, ModbusDeviceInformationLevel::name, writeUnsignedShort(writeBuffer, 8)))
+ # Simple Field (level)
+ writeSimpleEnumField("level", "ModbusDeviceInformationLevel", level, new DataWriterEnumDefault<>(ModbusDeviceInformationLevel::getValue, ModbusDeviceInformationLevel::name, writeUnsignedShort(writeBuffer, 8)))
- # Simple Field (individualAccess)
- writeSimpleField("individualAccess", individualAccess, writeBoolean(writeBuffer))
+ # Simple Field (individualAccess)
+ writeSimpleField("individualAccess", individualAccess, writeBoolean(writeBuffer))
- # Simple Field (conformityLevel)
- writeSimpleEnumField("conformityLevel", "ModbusDeviceInformationConformityLevel", conformityLevel, new DataWriterEnumDefault<>(ModbusDeviceInformationConformityLevel::getValue, ModbusDeviceInformationConformityLevel::name, writeUnsignedShort(writeBuffer, 7)))
+ # Simple Field (conformityLevel)
+ writeSimpleEnumField("conformityLevel", "ModbusDeviceInformationConformityLevel", conformityLevel, new DataWriterEnumDefault<>(ModbusDeviceInformationConformityLevel::getValue, ModbusDeviceInformationConformityLevel::name, writeUnsignedShort(writeBuffer, 7)))
- # Simple Field (moreFollows)
- writeSimpleEnumField("moreFollows", "ModbusDeviceInformationMoreFollows", moreFollows, new DataWriterEnumDefault<>(ModbusDeviceInformationMoreFollows::getValue, ModbusDeviceInformationMoreFollows::name, writeUnsignedShort(writeBuffer, 8)))
+ # Simple Field (moreFollows)
+ writeSimpleEnumField("moreFollows", "ModbusDeviceInformationMoreFollows", moreFollows, new DataWriterEnumDefault<>(ModbusDeviceInformationMoreFollows::getValue, ModbusDeviceInformationMoreFollows::name, writeUnsignedShort(writeBuffer, 8)))
- # Simple Field (nextObjectId)
- writeSimpleField("nextObjectId", nextObjectId, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (nextObjectId)
+ 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))
+ # 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))
- # Array Field (objects)
- writeComplexTypeArrayField("objects", objects, writeBuffer)
+ # Array Field (objects)
+ writeComplexTypeArrayField("objects", objects, writeBuffer)
- writeBuffer.popContext("ModbusPDUReadDeviceIdentificationResponse")
+ writeBuffer.popContext("ModbusPDUReadDeviceIdentificationResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -148,78 +154,55 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDeviceIdentificationResponseBuilder:
+ @staticmethod
+ 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)
+ meiType: c_uint8 = readConstField("meiType", readUnsignedShort(readBuffer, 8), ModbusPDUReadDeviceIdentificationResponse.MEITYPE)
- level: ModbusDeviceInformationLevel = readEnumField("level", "ModbusDeviceInformationLevel", new DataReaderEnumDefault<>(ModbusDeviceInformationLevel::enumForValue, readUnsignedShort(readBuffer, 8)))
+ level: ModbusDeviceInformationLevel = readEnumField("level", "ModbusDeviceInformationLevel", new DataReaderEnumDefault<>(ModbusDeviceInformationLevel::enumForValue, readUnsignedShort(readBuffer, 8)))
- individualAccess: c_bool = readSimpleField("individualAccess", readBoolean(readBuffer))
+ individualAccess: c_bool = readSimpleField("individualAccess", readBoolean(readBuffer))
- conformityLevel: ModbusDeviceInformationConformityLevel = readEnumField("conformityLevel", "ModbusDeviceInformationConformityLevel", new DataReaderEnumDefault<>(ModbusDeviceInformationConformityLevel::enumForValue, readUnsignedShort(readBuffer, 7)))
+ conformityLevel: ModbusDeviceInformationConformityLevel = readEnumField("conformityLevel", "ModbusDeviceInformationConformityLevel", new DataReaderEnumDefault<>(ModbusDeviceInformationConformityLevel::enumForValue, readUnsignedShort(readBuffer, 7)))
- moreFollows: ModbusDeviceInformationMoreFollows = readEnumField("moreFollows", "ModbusDeviceInformationMoreFollows", new DataReaderEnumDefault<>(ModbusDeviceInformationMoreFollows::enumForValue, readUnsignedShort(readBuffer, 8)))
+ moreFollows: ModbusDeviceInformationMoreFollows = readEnumField("moreFollows", "ModbusDeviceInformationMoreFollows", new DataReaderEnumDefault<>(ModbusDeviceInformationMoreFollows::enumForValue, readUnsignedShort(readBuffer, 8)))
- nextObjectId: c_uint8 = readSimpleField("nextObjectId", readUnsignedShort(readBuffer, 8))
+ nextObjectId: c_uint8 = readSimpleField("nextObjectId", readUnsignedShort(readBuffer, 8))
- numberOfObjects: c_uint8 = readImplicitField("numberOfObjects", readUnsignedShort(readBuffer, 8))
+ numberOfObjects: c_uint8 = readImplicitField("numberOfObjects", readUnsignedShort(readBuffer, 8))
- objects: []ModbusDeviceInformationObject = readCountArrayField("objects", new DataReaderComplexDefault<>(() -> ModbusDeviceInformationObject.staticParse(readBuffer), readBuffer), numberOfObjects)
+ objects: []ModbusDeviceInformationObject = readCountArrayField("objects", new DataReaderComplexDefault<>(() -> ModbusDeviceInformationObject.staticParse(readBuffer), readBuffer), numberOfObjects)
- readBuffer.closeContext("ModbusPDUReadDeviceIdentificationResponse")
- # Create the instance
- return ModbusPDUReadDeviceIdentificationResponseBuilder(
- level,
- individualAccess,
- conformityLevel,
- moreFollows,
- nextObjectId,
- objects
-
- )
+ readBuffer.closeContext("ModbusPDUReadDeviceIdentificationResponse")
+ # Create the instance
+ return ModbusPDUReadDeviceIdentificationResponseBuilder(level, individualAccess, conformityLevel, moreFollows, nextObjectId, objects )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadDeviceIdentificationResponse):
+ 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
+ return (getLevel() == that.getLevel()) && (getIndividualAccess() == that.getIndividualAccess()) && (getConformityLevel() == that.getConformityLevel()) && (getMoreFollows() == that.getMoreFollows()) && (getNextObjectId() == that.getNextObjectId()) && (getObjects() == that.getObjects()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getLevel(),
- getIndividualAccess(),
- getConformityLevel(),
- getMoreFollows(),
- getNextObjectId(),
- getObjects()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getLevel(), getIndividualAccess(), getConformityLevel(), getMoreFollows(), getNextObjectId(), getObjects() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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 [...]
@@ -243,3 +226,4 @@ class ModbusPDUReadDeviceIdentificationResponseBuilder(ModbusPDUModbusPDUBuilder
return modbusPDUReadDeviceIdentificationResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
index 13efd277c0..f2d1fa5ec3 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadDiscreteInputsRequest(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x02
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadDiscreteInputsRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadDiscreteInputsRequest")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (quantity)
+ writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUReadDiscreteInputsRequest")
+ writeBuffer.popContext("ModbusPDUReadDiscreteInputsRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDiscreteInputsRequestBuilder:
+ @staticmethod
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUReadDiscreteInputsRequest")
+ # Create the instance
+ return ModbusPDUReadDiscreteInputsRequestBuilder(startingAddress, quantity )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadDiscreteInputsRequest):
+ if not isinstance(o, ModbusPDUReadDiscreteInputsRequest):
return False
that: ModbusPDUReadDiscreteInputsRequest = ModbusPDUReadDiscreteInputsRequest(o)
- return
- (getStartingAddress() == that.getStartingAddress()) &&
- (getQuantity() == that.getQuantity()) &&
- super().equals(that) &&
- True
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUReadDiscreteInputsRequestBuilder(ModbusPDUModbusPDUBuilder: start
return modbusPDUReadDiscreteInputsRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
index 5f413e91b0..d2b44bc34d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadDiscreteInputsResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x02
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadDiscreteInputsResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadDiscreteInputsResponse")
+ writeBuffer.popContext("ModbusPDUReadDiscreteInputsResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -81,51 +84,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDiscreteInputsResponseBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUReadDiscreteInputsResponse")
- # Create the instance
- return ModbusPDUReadDiscreteInputsResponseBuilder(
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReadDiscreteInputsResponse")
+ # Create the instance
+ return ModbusPDUReadDiscreteInputsResponseBuilder(value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadDiscreteInputsResponse):
+ if not isinstance(o, ModbusPDUReadDiscreteInputsResponse):
return False
that: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(o)
- return
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getValue()
- )
+ return hash(super().hashCode(), getValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadDiscreteInputsResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadDiscreteInputsResponseBuilder( []c_byte value ): self.value = value
@@ -139,3 +134,4 @@ class ModbusPDUReadDiscreteInputsResponseBuilder(ModbusPDUModbusPDUBuilder: valu
return modbusPDUReadDiscreteInputsResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
index a73da93018..23907eb15a 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
@@ -22,38 +22,40 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x07
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadExceptionStatusRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadExceptionStatusRequest")
- writeBuffer.popContext("ModbusPDUReadExceptionStatusRequest")
+ writeBuffer.popContext("ModbusPDUReadExceptionStatusRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -62,44 +64,39 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadExceptionStatusRequestBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadExceptionStatusRequestBuilder:
readBuffer.pullContext("ModbusPDUReadExceptionStatusRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- readBuffer.closeContext("ModbusPDUReadExceptionStatusRequest")
- # Create the instance
- return ModbusPDUReadExceptionStatusRequestBuilder(
-
- )
+ readBuffer.closeContext("ModbusPDUReadExceptionStatusRequest")
+ # Create the instance
+ return ModbusPDUReadExceptionStatusRequestBuilder()
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadExceptionStatusRequest):
+ if not isinstance(o, ModbusPDUReadExceptionStatusRequest):
return False
that: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest(o)
- return
- super().equals(that) &&
- True
+ return super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode()
- )
+ return hash(super().hashCode() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadExceptionStatusRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUReadExceptionStatusRequestBuilder( ):
@@ -111,3 +108,4 @@ class ModbusPDUReadExceptionStatusRequestBuilder(ModbusPDUModbusPDUBuilder:def M
return modbusPDUReadExceptionStatusRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
index 19156ab831..b08dce126f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
@@ -22,25 +22,27 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
- value: c_uint8
+ value: c_uint8
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x07
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,17 +52,17 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadExceptionStatusResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadExceptionStatusResponse")
- # Simple Field (value)
- writeSimpleField("value", value, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (value)
+ writeSimpleField("value", value, writeUnsignedShort(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadExceptionStatusResponse")
+ writeBuffer.popContext("ModbusPDUReadExceptionStatusResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -72,49 +74,41 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadExceptionStatusResponseBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReadExceptionStatusResponseBuilder:
readBuffer.pullContext("ModbusPDUReadExceptionStatusResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- value: c_uint8 = readSimpleField("value", readUnsignedShort(readBuffer, 8))
+ value: c_uint8 = readSimpleField("value", readUnsignedShort(readBuffer, 8))
- readBuffer.closeContext("ModbusPDUReadExceptionStatusResponse")
- # Create the instance
- return ModbusPDUReadExceptionStatusResponseBuilder(
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReadExceptionStatusResponse")
+ # Create the instance
+ return ModbusPDUReadExceptionStatusResponseBuilder(value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadExceptionStatusResponse):
+ if not isinstance(o, ModbusPDUReadExceptionStatusResponse):
return False
that: ModbusPDUReadExceptionStatusResponse = ModbusPDUReadExceptionStatusResponse(o)
- return
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getValue()
- )
+ return hash(super().hashCode(), getValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadExceptionStatusResponseBuilder(ModbusPDUModbusPDUBuilder: value: c_uint8def ModbusPDUReadExceptionStatusResponseBuilder( c_uint8 value ): self.value = value
@@ -128,3 +122,4 @@ class ModbusPDUReadExceptionStatusResponseBuilder(ModbusPDUModbusPDUBuilder: val
return modbusPDUReadExceptionStatusResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
index 82a4c73c65..d5f3365f5a 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadFifoQueueRequest(PlcMessage,ModbusPDU):
- fifoPointerAddress: c_uint16
+ fifoPointerAddress: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x18
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,17 +53,17 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadFifoQueueRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadFifoQueueRequest")
- # Simple Field (fifoPointerAddress)
- writeSimpleField("fifoPointerAddress", fifoPointerAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (fifoPointerAddress)
+ writeSimpleField("fifoPointerAddress", fifoPointerAddress, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUReadFifoQueueRequest")
+ writeBuffer.popContext("ModbusPDUReadFifoQueueRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -72,49 +75,41 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFifoQueueRequestBuilder:
+ @staticmethod
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUReadFifoQueueRequest")
+ # Create the instance
+ return ModbusPDUReadFifoQueueRequestBuilder(fifoPointerAddress )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadFifoQueueRequest):
+ if not isinstance(o, ModbusPDUReadFifoQueueRequest):
return False
that: ModbusPDUReadFifoQueueRequest = ModbusPDUReadFifoQueueRequest(o)
- return
- (getFifoPointerAddress() == that.getFifoPointerAddress()) &&
- super().equals(that) &&
- True
+ return (getFifoPointerAddress() == that.getFifoPointerAddress()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getFifoPointerAddress()
- )
+ return hash(super().hashCode(), getFifoPointerAddress() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadFifoQueueRequestBuilder(ModbusPDUModbusPDUBuilder: fifoPointerAddress: c_uint16def ModbusPDUReadFifoQueueRequestBuilder( c_uint16 fifoPointerAddress ): self.fifoPointerAddress = fifoPointerAddress
@@ -128,3 +123,4 @@ class ModbusPDUReadFifoQueueRequestBuilder(ModbusPDUModbusPDUBuilder: fifoPointe
return modbusPDUReadFifoQueueRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
index 70abbdda1a..a534debd40 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadFifoQueueResponse(PlcMessage,ModbusPDU):
- fifoValue: []c_uint16
+ fifoValue: []c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x18
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,25 +53,25 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadFifoQueueResponse")
+ 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))
- writeImplicitField("byteCount", byteCount, 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_uint16 byteCount = (c_uint16) ((((COUNT(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))
- writeImplicitField("fifoCount", fifoCount, 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))
+ writeImplicitField("fifoCount", fifoCount, writeUnsignedInt(writeBuffer, 16))
- # Array Field (fifoValue)
- writeSimpleTypeArrayField("fifoValue", fifoValue, writeUnsignedInt(writeBuffer, 16))
+ # Array Field (fifoValue)
+ writeSimpleTypeArrayField("fifoValue", fifoValue, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUReadFifoQueueResponse")
+ writeBuffer.popContext("ModbusPDUReadFifoQueueResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -88,53 +91,45 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFifoQueueResponseBuilder:
+ @staticmethod
+ 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: []c_uint16 = readCountArrayField("fifoValue", readUnsignedInt(readBuffer, 16), fifoCount)
- readBuffer.closeContext("ModbusPDUReadFifoQueueResponse")
- # Create the instance
- return ModbusPDUReadFifoQueueResponseBuilder(
- fifoValue
-
- )
+ readBuffer.closeContext("ModbusPDUReadFifoQueueResponse")
+ # Create the instance
+ return ModbusPDUReadFifoQueueResponseBuilder(fifoValue )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadFifoQueueResponse):
+ if not isinstance(o, ModbusPDUReadFifoQueueResponse):
return False
that: ModbusPDUReadFifoQueueResponse = ModbusPDUReadFifoQueueResponse(o)
- return
- (getFifoValue() == that.getFifoValue()) &&
- super().equals(that) &&
- True
+ return (getFifoValue() == that.getFifoValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getFifoValue()
- )
+ return hash(super().hashCode(), getFifoValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadFifoQueueResponseBuilder(ModbusPDUModbusPDUBuilder: fifoValue: []c_uint16def ModbusPDUReadFifoQueueResponseBuilder( []c_uint16 fifoValue ): self.fifoValue = fifoValue
@@ -148,3 +143,4 @@ class ModbusPDUReadFifoQueueResponseBuilder(ModbusPDUModbusPDUBuilder: fifoValue
return modbusPDUReadFifoQueueResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
index f4f69f796a..f91461e4e1 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
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
+import math
+
@dataclass
class ModbusPDUReadFileRecordRequest(PlcMessage,ModbusPDU):
- items: []ModbusPDUReadFileRecordRequestItem
+ items: []ModbusPDUReadFileRecordRequestItem
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x14
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadFileRecordRequest")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (items)
- writeComplexTypeArrayField("items", items, writeBuffer)
+ # Array Field (items)
+ writeComplexTypeArrayField("items", items, writeBuffer)
- writeBuffer.popContext("ModbusPDUReadFileRecordRequest")
+ writeBuffer.popContext("ModbusPDUReadFileRecordRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -83,51 +86,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFileRecordRequestBuilder:
+ @staticmethod
+ 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", new DataReaderComplexDefault<>(() -> ModbusPDUReadFileRecordRequestItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: []ModbusPDUReadFileRecordRequestItem = readLengthArrayField("items", new DataReaderComplexDefault<>(() -> ModbusPDUReadFileRecordRequestItem.staticParse(readBuffer), readBuffer), byteCount)
- readBuffer.closeContext("ModbusPDUReadFileRecordRequest")
- # Create the instance
- return ModbusPDUReadFileRecordRequestBuilder(
- items
-
- )
+ readBuffer.closeContext("ModbusPDUReadFileRecordRequest")
+ # Create the instance
+ return ModbusPDUReadFileRecordRequestBuilder(items )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadFileRecordRequest):
+ if not isinstance(o, ModbusPDUReadFileRecordRequest):
return False
that: ModbusPDUReadFileRecordRequest = ModbusPDUReadFileRecordRequest(o)
- return
- (getItems() == that.getItems()) &&
- super().equals(that) &&
- True
+ return (getItems() == that.getItems()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getItems()
- )
+ return hash(super().hashCode(), getItems() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUReadFileRecordRequestItemdef ModbusPDUReadFileRecordRequestBuilder( []ModbusPDUReadFileRecordRequestItem items ): self.items = items
@@ -141,3 +136,4 @@ class ModbusPDUReadFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: []
return modbusPDUReadFileRecordRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
index 5c5f4c1991..88f253cde5 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
@@ -22,18 +22,23 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadFileRecordRequestItem(PlcMessage):
- referenceType: c_uint8
- fileNumber: c_uint16
- recordNumber: c_uint16
- recordLength: c_uint16
+ referenceType: c_uint8
+ fileNumber: c_uint16
+ recordNumber: c_uint16
+ recordLength: c_uint16
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -52,26 +57,26 @@ super().__init__( )
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadFileRecordRequestItem")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadFileRecordRequestItem")
- # Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (referenceType)
+ writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
- # Simple Field (fileNumber)
- writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (fileNumber)
+ writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (recordNumber)
- writeSimpleField("recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (recordNumber)
+ writeSimpleField("recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (recordLength)
- writeSimpleField("recordLength", recordLength, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (recordLength)
+ writeSimpleField("recordLength", recordLength, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUReadFileRecordRequestItem")
+ writeBuffer.popContext("ModbusPDUReadFileRecordRequestItem")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = 0
@@ -95,64 +100,51 @@ super().__init__( )
def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUReadFileRecordRequestItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
- }
- def staticParse(readBuffer: ReadBuffer) -> ModbusPDUReadFileRecordRequestItem:
+
+ @staticmethod
+ 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
- )
+ readBuffer.closeContext("ModbusPDUReadFileRecordRequestItem")
+ # Create the instance
+ _modbusPDUReadFileRecordRequestItem: ModbusPDUReadFileRecordRequestItem = ModbusPDUReadFileRecordRequestItem(referenceType, fileNumber, recordNumber, recordLength )
return _modbusPDUReadFileRecordRequestItem
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadFileRecordRequestItem):
+ if not isinstance(o, ModbusPDUReadFileRecordRequestItem):
return False
that: ModbusPDUReadFileRecordRequestItem = ModbusPDUReadFileRecordRequestItem(o)
- return
- (getReferenceType() == that.getReferenceType()) &&
- (getFileNumber() == that.getFileNumber()) &&
- (getRecordNumber() == that.getRecordNumber()) &&
- (getRecordLength() == that.getRecordLength()) &&
- True
+ return (getReferenceType() == that.getReferenceType()) && (getFileNumber() == that.getFileNumber()) && (getRecordNumber() == that.getRecordNumber()) && (getRecordLength() == that.getRecordLength()) && True
def hashCode(self) -> int:
- return Objects.hash(
- getReferenceType(),
- getFileNumber(),
- getRecordNumber(),
- getRecordLength()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(getReferenceType(), getFileNumber(), getRecordNumber(), getRecordLength() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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 afc7f0342b..db4a1c62df 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
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
+import math
+
@dataclass
class ModbusPDUReadFileRecordResponse(PlcMessage,ModbusPDU):
- items: []ModbusPDUReadFileRecordResponseItem
+ items: []ModbusPDUReadFileRecordResponseItem
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x14
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadFileRecordResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (items)
- writeComplexTypeArrayField("items", items, writeBuffer)
+ # Array Field (items)
+ writeComplexTypeArrayField("items", items, writeBuffer)
- writeBuffer.popContext("ModbusPDUReadFileRecordResponse")
+ writeBuffer.popContext("ModbusPDUReadFileRecordResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -83,51 +86,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFileRecordResponseBuilder:
+ @staticmethod
+ 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", new DataReaderComplexDefault<>(() -> ModbusPDUReadFileRecordResponseItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: []ModbusPDUReadFileRecordResponseItem = readLengthArrayField("items", new DataReaderComplexDefault<>(() -> ModbusPDUReadFileRecordResponseItem.staticParse(readBuffer), readBuffer), byteCount)
- readBuffer.closeContext("ModbusPDUReadFileRecordResponse")
- # Create the instance
- return ModbusPDUReadFileRecordResponseBuilder(
- items
-
- )
+ readBuffer.closeContext("ModbusPDUReadFileRecordResponse")
+ # Create the instance
+ return ModbusPDUReadFileRecordResponseBuilder(items )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadFileRecordResponse):
+ if not isinstance(o, ModbusPDUReadFileRecordResponse):
return False
that: ModbusPDUReadFileRecordResponse = ModbusPDUReadFileRecordResponse(o)
- return
- (getItems() == that.getItems()) &&
- super().equals(that) &&
- True
+ return (getItems() == that.getItems()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getItems()
- )
+ return hash(super().hashCode(), getItems() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUReadFileRecordResponseItemdef ModbusPDUReadFileRecordResponseBuilder( []ModbusPDUReadFileRecordResponseItem items ): self.items = items
@@ -141,3 +136,4 @@ class ModbusPDUReadFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items: [
return modbusPDUReadFileRecordResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
index 78a429265d..d1a18b976f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
@@ -22,16 +22,21 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadFileRecordResponseItem(PlcMessage):
- referenceType: c_uint8
- data: []c_byte
+ referenceType: c_uint8
+ data: []c_byte
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -44,24 +49,24 @@ super().__init__( )
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadFileRecordResponseItem")
+ 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))
- writeImplicitField("dataLength", dataLength, writeUnsignedShort(writeBuffer, 8))
+ # 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))
+ writeImplicitField("dataLength", dataLength, writeUnsignedShort(writeBuffer, 8))
- # Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (referenceType)
+ writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
- # Array Field (data)
- writeByteArrayField("data", data, writeByteArray(writeBuffer, 8))
+ # Array Field (data)
+ writeByteArrayField("data", data, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadFileRecordResponseItem")
+ writeBuffer.popContext("ModbusPDUReadFileRecordResponseItem")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = 0
@@ -84,56 +89,49 @@ super().__init__( )
def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUReadFileRecordResponseItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
- }
- def staticParse(readBuffer: ReadBuffer) -> ModbusPDUReadFileRecordResponseItem:
+
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("data", Math.toIntExact((dataLength) - (1)))
- readBuffer.closeContext("ModbusPDUReadFileRecordResponseItem")
- # Create the instance
- _modbusPDUReadFileRecordResponseItem: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(
- referenceType,
- data
- )
+ readBuffer.closeContext("ModbusPDUReadFileRecordResponseItem")
+ # Create the instance
+ _modbusPDUReadFileRecordResponseItem: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(referenceType, data )
return _modbusPDUReadFileRecordResponseItem
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadFileRecordResponseItem):
+ if not isinstance(o, ModbusPDUReadFileRecordResponseItem):
return False
that: ModbusPDUReadFileRecordResponseItem = ModbusPDUReadFileRecordResponseItem(o)
- return
- (getReferenceType() == that.getReferenceType()) &&
- (getData() == that.getData()) &&
- True
+ return (getReferenceType() == that.getReferenceType()) && (getData() == that.getData()) && True
def hashCode(self) -> int:
- return Objects.hash(
- getReferenceType(),
- getData()
- )
+ return hash(getReferenceType(), getData() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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 3e9f675013..03344f91f9 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadHoldingRegistersRequest(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x03
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadHoldingRegistersRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadHoldingRegistersRequest")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (quantity)
+ writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUReadHoldingRegistersRequest")
+ writeBuffer.popContext("ModbusPDUReadHoldingRegistersRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadHoldingRegistersRequestBuilder:
+ @staticmethod
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUReadHoldingRegistersRequest")
+ # Create the instance
+ return ModbusPDUReadHoldingRegistersRequestBuilder(startingAddress, quantity )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadHoldingRegistersRequest):
+ if not isinstance(o, ModbusPDUReadHoldingRegistersRequest):
return False
that: ModbusPDUReadHoldingRegistersRequest = ModbusPDUReadHoldingRegistersRequest(o)
- return
- (getStartingAddress() == that.getStartingAddress()) &&
- (getQuantity() == that.getQuantity()) &&
- super().equals(that) &&
- True
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUReadHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: sta
return modbusPDUReadHoldingRegistersRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
index 470a0166bf..549358da16 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadHoldingRegistersResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x03
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadHoldingRegistersResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadHoldingRegistersResponse")
+ writeBuffer.popContext("ModbusPDUReadHoldingRegistersResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -81,51 +84,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadHoldingRegistersResponseBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUReadHoldingRegistersResponse")
- # Create the instance
- return ModbusPDUReadHoldingRegistersResponseBuilder(
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReadHoldingRegistersResponse")
+ # Create the instance
+ return ModbusPDUReadHoldingRegistersResponseBuilder(value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadHoldingRegistersResponse):
+ if not isinstance(o, ModbusPDUReadHoldingRegistersResponse):
return False
that: ModbusPDUReadHoldingRegistersResponse = ModbusPDUReadHoldingRegistersResponse(o)
- return
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getValue()
- )
+ return hash(super().hashCode(), getValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadHoldingRegistersResponseBuilder( []c_byte value ): self.value = value
@@ -139,3 +134,4 @@ class ModbusPDUReadHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: va
return modbusPDUReadHoldingRegistersResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
index 3c96143591..bade93954f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadInputRegistersRequest(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x04
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadInputRegistersRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadInputRegistersRequest")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (quantity)
+ writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUReadInputRegistersRequest")
+ writeBuffer.popContext("ModbusPDUReadInputRegistersRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadInputRegistersRequestBuilder:
+ @staticmethod
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUReadInputRegistersRequest")
+ # Create the instance
+ return ModbusPDUReadInputRegistersRequestBuilder(startingAddress, quantity )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadInputRegistersRequest):
+ if not isinstance(o, ModbusPDUReadInputRegistersRequest):
return False
that: ModbusPDUReadInputRegistersRequest = ModbusPDUReadInputRegistersRequest(o)
- return
- (getStartingAddress() == that.getStartingAddress()) &&
- (getQuantity() == that.getQuantity()) &&
- super().equals(that) &&
- True
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUReadInputRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: start
return modbusPDUReadInputRegistersRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
index efcdbd7ff9..3cebf62e01 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadInputRegistersResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x04
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadInputRegistersResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadInputRegistersResponse")
+ writeBuffer.popContext("ModbusPDUReadInputRegistersResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -81,51 +84,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadInputRegistersResponseBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUReadInputRegistersResponse")
- # Create the instance
- return ModbusPDUReadInputRegistersResponseBuilder(
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReadInputRegistersResponse")
+ # Create the instance
+ return ModbusPDUReadInputRegistersResponseBuilder(value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadInputRegistersResponse):
+ if not isinstance(o, ModbusPDUReadInputRegistersResponse):
return False
that: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(o)
- return
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getValue()
- )
+ return hash(super().hashCode(), getValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadInputRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadInputRegistersResponseBuilder( []c_byte value ): self.value = value
@@ -139,3 +134,4 @@ class ModbusPDUReadInputRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: valu
return modbusPDUReadInputRegistersResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
index 2f7427fc4e..0d82fdb479 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
@@ -22,29 +22,33 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
-
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
+
@dataclass
class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
- readStartingAddress: c_uint16
- readQuantity: c_uint16
- writeStartingAddress: c_uint16
- writeQuantity: c_uint16
- value: []c_byte
+ readStartingAddress: c_uint16
+ readQuantity: c_uint16
+ writeStartingAddress: c_uint16
+ writeQuantity: c_uint16
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x17
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -66,33 +70,33 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
- # Simple Field (readStartingAddress)
- writeSimpleField("readStartingAddress", readStartingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (readStartingAddress)
+ writeSimpleField("readStartingAddress", readStartingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (readQuantity)
- writeSimpleField("readQuantity", readQuantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (readQuantity)
+ writeSimpleField("readQuantity", readQuantity, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (writeStartingAddress)
- writeSimpleField("writeStartingAddress", writeStartingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (writeStartingAddress)
+ writeSimpleField("writeStartingAddress", writeStartingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (writeQuantity)
- writeSimpleField("writeQuantity", writeQuantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (writeQuantity)
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
+ writeBuffer.popContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -121,71 +125,51 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
- # Create the instance
- return ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(
- readStartingAddress,
- readQuantity,
- writeStartingAddress,
- writeQuantity,
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
+ # Create the instance
+ return ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(readStartingAddress, readQuantity, writeStartingAddress, writeQuantity, value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadWriteMultipleHoldingRegistersRequest):
+ 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
+ return (getReadStartingAddress() == that.getReadStartingAddress()) && (getReadQuantity() == that.getReadQuantity()) && (getWriteStartingAddress() == that.getWriteStartingAddress()) && (getWriteQuantity() == that.getWriteQuantity()) && (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getReadStartingAddress(),
- getReadQuantity(),
- getWriteStartingAddress(),
- getWriteQuantity(),
- getValue()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getReadStartingAddress(), getReadQuantity(), getWriteStartingAddress(), getWriteQuantity(), getValue() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -207,3 +191,4 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPD
return modbusPDUReadWriteMultipleHoldingRegistersRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
index 1b453003f1..a2074f2640 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x17
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
+ writeBuffer.popContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -81,51 +84,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
- # Create the instance
- return ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
+ # Create the instance
+ return ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReadWriteMultipleHoldingRegistersResponse):
+ if not isinstance(o, ModbusPDUReadWriteMultipleHoldingRegistersResponse):
return False
that: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ModbusPDUReadWriteMultipleHoldingRegistersResponse(o)
- return
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getValue()
- )
+ return hash(super().hashCode(), getValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder( []c_byte value ): self.value = value
@@ -139,3 +134,4 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusP
return modbusPDUReadWriteMultipleHoldingRegistersResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
index e9c45fc5e0..4cf62b80ca 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
@@ -22,38 +22,40 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x11
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReportServerIdRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUReportServerIdRequest")
- writeBuffer.popContext("ModbusPDUReportServerIdRequest")
+ writeBuffer.popContext("ModbusPDUReportServerIdRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -62,44 +64,39 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReportServerIdRequestBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUReportServerIdRequestBuilder:
readBuffer.pullContext("ModbusPDUReportServerIdRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- readBuffer.closeContext("ModbusPDUReportServerIdRequest")
- # Create the instance
- return ModbusPDUReportServerIdRequestBuilder(
-
- )
+ readBuffer.closeContext("ModbusPDUReportServerIdRequest")
+ # Create the instance
+ return ModbusPDUReportServerIdRequestBuilder()
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReportServerIdRequest):
+ if not isinstance(o, ModbusPDUReportServerIdRequest):
return False
that: ModbusPDUReportServerIdRequest = ModbusPDUReportServerIdRequest(o)
- return
- super().equals(that) &&
- True
+ return super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode()
- )
+ return hash(super().hashCode() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReportServerIdRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUReportServerIdRequestBuilder( ):
@@ -111,3 +108,4 @@ class ModbusPDUReportServerIdRequestBuilder(ModbusPDUModbusPDUBuilder:def Modbus
return modbusPDUReportServerIdRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
index 98416354ca..f4b027bf73 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUReportServerIdResponse(PlcMessage,ModbusPDU):
- value: []c_byte
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x11
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUReportServerIdResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUReportServerIdResponse")
+ writeBuffer.popContext("ModbusPDUReportServerIdResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -81,51 +84,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReportServerIdResponseBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUReportServerIdResponse")
- # Create the instance
- return ModbusPDUReportServerIdResponseBuilder(
- value
-
- )
+ readBuffer.closeContext("ModbusPDUReportServerIdResponse")
+ # Create the instance
+ return ModbusPDUReportServerIdResponseBuilder(value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUReportServerIdResponse):
+ if not isinstance(o, ModbusPDUReportServerIdResponse):
return False
that: ModbusPDUReportServerIdResponse = ModbusPDUReportServerIdResponse(o)
- return
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getValue()
- )
+ return hash(super().hashCode(), getValue() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUReportServerIdResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReportServerIdResponseBuilder( []c_byte value ): self.value = value
@@ -139,3 +134,4 @@ class ModbusPDUReportServerIdResponseBuilder(ModbusPDUModbusPDUBuilder: value: [
return modbusPDUReportServerIdResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
index ce5c7fdb57..3c5b68da8e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
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
+import math
+
@dataclass
class ModbusPDUWriteFileRecordRequest(PlcMessage,ModbusPDU):
- items: []ModbusPDUWriteFileRecordRequestItem
+ items: []ModbusPDUWriteFileRecordRequestItem
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x15
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteFileRecordRequest")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (items)
- writeComplexTypeArrayField("items", items, writeBuffer)
+ # Array Field (items)
+ writeComplexTypeArrayField("items", items, writeBuffer)
- writeBuffer.popContext("ModbusPDUWriteFileRecordRequest")
+ writeBuffer.popContext("ModbusPDUWriteFileRecordRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -83,51 +86,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteFileRecordRequestBuilder:
+ @staticmethod
+ 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", new DataReaderComplexDefault<>(() -> ModbusPDUWriteFileRecordRequestItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: []ModbusPDUWriteFileRecordRequestItem = readLengthArrayField("items", new DataReaderComplexDefault<>(() -> ModbusPDUWriteFileRecordRequestItem.staticParse(readBuffer), readBuffer), byteCount)
- readBuffer.closeContext("ModbusPDUWriteFileRecordRequest")
- # Create the instance
- return ModbusPDUWriteFileRecordRequestBuilder(
- items
-
- )
+ readBuffer.closeContext("ModbusPDUWriteFileRecordRequest")
+ # Create the instance
+ return ModbusPDUWriteFileRecordRequestBuilder(items )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteFileRecordRequest):
+ if not isinstance(o, ModbusPDUWriteFileRecordRequest):
return False
that: ModbusPDUWriteFileRecordRequest = ModbusPDUWriteFileRecordRequest(o)
- return
- (getItems() == that.getItems()) &&
- super().equals(that) &&
- True
+ return (getItems() == that.getItems()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getItems()
- )
+ return hash(super().hashCode(), getItems() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUWriteFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUWriteFileRecordRequestItemdef ModbusPDUWriteFileRecordRequestBuilder( []ModbusPDUWriteFileRecordRequestItem items ): self.items = items
@@ -141,3 +136,4 @@ class ModbusPDUWriteFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: [
return modbusPDUWriteFileRecordRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
index 76d870827e..8ac692d87f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
@@ -22,18 +22,24 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_byte
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
- referenceType: c_uint8
- fileNumber: c_uint16
- recordNumber: c_uint16
- recordData: []c_byte
+ referenceType: c_uint8
+ fileNumber: c_uint16
+ recordNumber: c_uint16
+ recordData: []c_byte
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -52,30 +58,30 @@ super().__init__( )
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteFileRecordRequestItem")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteFileRecordRequestItem")
- # Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (referenceType)
+ writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
- # Simple Field (fileNumber)
- writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (fileNumber)
+ writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (recordNumber)
- writeSimpleField("recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (recordNumber)
+ 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))
+ # 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))
- # Array Field (recordData)
- writeByteArrayField("recordData", recordData, writeByteArray(writeBuffer, 8))
+ # Array Field (recordData)
+ writeByteArrayField("recordData", recordData, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUWriteFileRecordRequestItem")
+ writeBuffer.popContext("ModbusPDUWriteFileRecordRequestItem")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = 0
@@ -104,66 +110,53 @@ super().__init__( )
def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUWriteFileRecordRequestItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
- }
- def staticParse(readBuffer: ReadBuffer) -> ModbusPDUWriteFileRecordRequestItem:
+
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("recordData", Math.toIntExact((recordLength) * (2)))
- readBuffer.closeContext("ModbusPDUWriteFileRecordRequestItem")
- # Create the instance
- _modbusPDUWriteFileRecordRequestItem: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem(
- referenceType,
- fileNumber,
- recordNumber,
- recordData
- )
+ readBuffer.closeContext("ModbusPDUWriteFileRecordRequestItem")
+ # Create the instance
+ _modbusPDUWriteFileRecordRequestItem: ModbusPDUWriteFileRecordRequestItem = ModbusPDUWriteFileRecordRequestItem(referenceType, fileNumber, recordNumber, recordData )
return _modbusPDUWriteFileRecordRequestItem
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteFileRecordRequestItem):
+ 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
+ return (getReferenceType() == that.getReferenceType()) && (getFileNumber() == that.getFileNumber()) && (getRecordNumber() == that.getRecordNumber()) && (getRecordData() == that.getRecordData()) && True
def hashCode(self) -> int:
- return Objects.hash(
- getReferenceType(),
- getFileNumber(),
- getRecordNumber(),
- getRecordData()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(getReferenceType(), getFileNumber(), getRecordNumber(), getRecordData() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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 e042bed82e..f406063a5f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
@@ -22,25 +22,28 @@ from abc import ABC, abstractmethod
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
+import math
+
@dataclass
class ModbusPDUWriteFileRecordResponse(PlcMessage,ModbusPDU):
- items: []ModbusPDUWriteFileRecordResponseItem
+ items: []ModbusPDUWriteFileRecordResponseItem
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x15
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -50,21 +53,21 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteFileRecordResponse")
+ 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (items)
- writeComplexTypeArrayField("items", items, writeBuffer)
+ # Array Field (items)
+ writeComplexTypeArrayField("items", items, writeBuffer)
- writeBuffer.popContext("ModbusPDUWriteFileRecordResponse")
+ writeBuffer.popContext("ModbusPDUWriteFileRecordResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -83,51 +86,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteFileRecordResponseBuilder:
+ @staticmethod
+ 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", new DataReaderComplexDefault<>(() -> ModbusPDUWriteFileRecordResponseItem.staticParse(readBuffer), readBuffer), byteCount)
+ items: []ModbusPDUWriteFileRecordResponseItem = readLengthArrayField("items", new DataReaderComplexDefault<>(() -> ModbusPDUWriteFileRecordResponseItem.staticParse(readBuffer), readBuffer), byteCount)
- readBuffer.closeContext("ModbusPDUWriteFileRecordResponse")
- # Create the instance
- return ModbusPDUWriteFileRecordResponseBuilder(
- items
-
- )
+ readBuffer.closeContext("ModbusPDUWriteFileRecordResponse")
+ # Create the instance
+ return ModbusPDUWriteFileRecordResponseBuilder(items )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteFileRecordResponse):
+ if not isinstance(o, ModbusPDUWriteFileRecordResponse):
return False
that: ModbusPDUWriteFileRecordResponse = ModbusPDUWriteFileRecordResponse(o)
- return
- (getItems() == that.getItems()) &&
- super().equals(that) &&
- True
+ return (getItems() == that.getItems()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getItems()
- )
+ return hash(super().hashCode(), getItems() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ return "\n" + str(writeBufferBoxBased.getBox()) + "\n"
class ModbusPDUWriteFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUWriteFileRecordResponseItemdef ModbusPDUWriteFileRecordResponseBuilder( []ModbusPDUWriteFileRecordResponseItem items ): self.items = items
@@ -141,3 +136,4 @@ class ModbusPDUWriteFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items:
return modbusPDUWriteFileRecordResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
index f2f0dff289..b5d25b3d82 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
@@ -22,18 +22,24 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_byte
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
- referenceType: c_uint8
- fileNumber: c_uint16
- recordNumber: c_uint16
- recordData: []c_byte
+ referenceType: c_uint8
+ fileNumber: c_uint16
+ recordNumber: c_uint16
+ recordData: []c_byte
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -52,30 +58,30 @@ super().__init__( )
def serialize(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteFileRecordResponseItem")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteFileRecordResponseItem")
- # Simple Field (referenceType)
- writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
+ # Simple Field (referenceType)
+ writeSimpleField("referenceType", referenceType, writeUnsignedShort(writeBuffer, 8))
- # Simple Field (fileNumber)
- writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (fileNumber)
+ writeSimpleField("fileNumber", fileNumber, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (recordNumber)
- writeSimpleField("recordNumber", recordNumber, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (recordNumber)
+ 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))
+ # 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))
- # Array Field (recordData)
- writeByteArrayField("recordData", recordData, writeByteArray(writeBuffer, 8))
+ # Array Field (recordData)
+ writeByteArrayField("recordData", recordData, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUWriteFileRecordResponseItem")
+ writeBuffer.popContext("ModbusPDUWriteFileRecordResponseItem")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = 0
@@ -104,66 +110,53 @@ super().__init__( )
def staticParse(readBuffer: ReadBuffer , args) -> ModbusPDUWriteFileRecordResponseItem:
positionAware: PositionAware = readBuffer
return staticParse(readBuffer)
- }
- def staticParse(readBuffer: ReadBuffer) -> ModbusPDUWriteFileRecordResponseItem:
+
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("recordData", Math.toIntExact(recordLength))
- readBuffer.closeContext("ModbusPDUWriteFileRecordResponseItem")
- # Create the instance
- _modbusPDUWriteFileRecordResponseItem: ModbusPDUWriteFileRecordResponseItem = ModbusPDUWriteFileRecordResponseItem(
- referenceType,
- fileNumber,
- recordNumber,
- recordData
- )
+ readBuffer.closeContext("ModbusPDUWriteFileRecordResponseItem")
+ # Create the instance
+ _modbusPDUWriteFileRecordResponseItem: ModbusPDUWriteFileRecordResponseItem = ModbusPDUWriteFileRecordResponseItem(referenceType, fileNumber, recordNumber, recordData )
return _modbusPDUWriteFileRecordResponseItem
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteFileRecordResponseItem):
+ 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
+ return (getReferenceType() == that.getReferenceType()) && (getFileNumber() == that.getFileNumber()) && (getRecordNumber() == that.getRecordNumber()) && (getRecordData() == that.getRecordData()) && True
def hashCode(self) -> int:
- return Objects.hash(
- getReferenceType(),
- getFileNumber(),
- getRecordNumber(),
- getRecordData()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(getReferenceType(), getFileNumber(), getRecordNumber(), getRecordData() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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 bb4870612f..2149f2b88d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
@@ -22,27 +22,31 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
-
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
+
@dataclass
class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
- value: []c_byte
+ startingAddress: c_uint16
+ quantity: c_uint16
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x0F
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -58,27 +62,27 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteMultipleCoilsRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteMultipleCoilsRequest")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUWriteMultipleCoilsRequest")
+ writeBuffer.popContext("ModbusPDUWriteMultipleCoilsRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -101,61 +105,47 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleCoilsRequestBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUWriteMultipleCoilsRequest")
- # Create the instance
- return ModbusPDUWriteMultipleCoilsRequestBuilder(
- startingAddress,
- quantity,
- value
-
- )
+ readBuffer.closeContext("ModbusPDUWriteMultipleCoilsRequest")
+ # Create the instance
+ return ModbusPDUWriteMultipleCoilsRequestBuilder(startingAddress, quantity, value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteMultipleCoilsRequest):
+ if not isinstance(o, ModbusPDUWriteMultipleCoilsRequest):
return False
that: ModbusPDUWriteMultipleCoilsRequest = ModbusPDUWriteMultipleCoilsRequest(o)
- return
- (getStartingAddress() == that.getStartingAddress()) &&
- (getQuantity() == that.getQuantity()) &&
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity(),
- getValue()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity(), getValue() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -173,3 +163,4 @@ class ModbusPDUWriteMultipleCoilsRequestBuilder(ModbusPDUModbusPDUBuilder: start
return modbusPDUWriteMultipleCoilsRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
index ccb3aed568..52f77ba225 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteMultipleCoilsResponse(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x0F
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteMultipleCoilsResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteMultipleCoilsResponse")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (quantity)
+ writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUWriteMultipleCoilsResponse")
+ writeBuffer.popContext("ModbusPDUWriteMultipleCoilsResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleCoilsResponseBuilder:
+ @staticmethod
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUWriteMultipleCoilsResponse")
+ # Create the instance
+ return ModbusPDUWriteMultipleCoilsResponseBuilder(startingAddress, quantity )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteMultipleCoilsResponse):
+ if not isinstance(o, ModbusPDUWriteMultipleCoilsResponse):
return False
that: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(o)
- return
- (getStartingAddress() == that.getStartingAddress()) &&
- (getQuantity() == that.getQuantity()) &&
- super().equals(that) &&
- True
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUWriteMultipleCoilsResponseBuilder(ModbusPDUModbusPDUBuilder: star
return modbusPDUWriteMultipleCoilsResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
index db6d448a97..0944ccc83f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
@@ -22,27 +22,31 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
-
+from ctypes import c_bool
+from ctypes import c_byte
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
+
@dataclass
class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
- value: []c_byte
+ startingAddress: c_uint16
+ quantity: c_uint16
+ value: []c_byte
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x10
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -58,27 +62,27 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, 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()))
- writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
+ # 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()))
+ writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
- # Array Field (value)
- writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
+ # Array Field (value)
+ writeByteArrayField("value", value, writeByteArray(writeBuffer, 8))
- writeBuffer.popContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
+ writeBuffer.popContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -101,61 +105,47 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleHoldingRegistersRequestBuilder:
+ @staticmethod
+ 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: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
- readBuffer.closeContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
- # Create the instance
- return ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(
- startingAddress,
- quantity,
- value
-
- )
+ readBuffer.closeContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
+ # Create the instance
+ return ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(startingAddress, quantity, value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteMultipleHoldingRegistersRequest):
+ 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
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity(),
- getValue()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity(), getValue() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -173,3 +163,4 @@ class ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBui
return modbusPDUWriteMultipleHoldingRegistersRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
index 949cd69bd3..768302b5d2 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
- startingAddress: c_uint16
- quantity: c_uint16
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x10
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
- # Simple Field (startingAddress)
- writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (startingAddress)
+ writeSimpleField("startingAddress", startingAddress, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (quantity)
- writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (quantity)
+ writeSimpleField("quantity", quantity, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
+ writeBuffer.popContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleHoldingRegistersResponseBuilder:
+ @staticmethod
+ 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
-
- )
+ readBuffer.closeContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
+ # Create the instance
+ return ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(startingAddress, quantity )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteMultipleHoldingRegistersResponse):
+ if not isinstance(o, ModbusPDUWriteMultipleHoldingRegistersResponse):
return False
that: ModbusPDUWriteMultipleHoldingRegistersResponse = ModbusPDUWriteMultipleHoldingRegistersResponse(o)
- return
- (getStartingAddress() == that.getStartingAddress()) &&
- (getQuantity() == that.getQuantity()) &&
- super().equals(that) &&
- True
+ return (getStartingAddress() == that.getStartingAddress()) && (getQuantity() == that.getQuantity()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getStartingAddress(),
- getQuantity()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getStartingAddress(), getQuantity() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBu
return modbusPDUWriteMultipleHoldingRegistersResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
index 0f0832698f..80e4253a7d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
- address: c_uint16
- value: c_uint16
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x05
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteSingleCoilRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteSingleCoilRequest")
- # Simple Field (address)
- writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (address)
+ writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (value)
- writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (value)
+ writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUWriteSingleCoilRequest")
+ writeBuffer.popContext("ModbusPDUWriteSingleCoilRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleCoilRequestBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleCoilRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleCoilRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUWriteSingleCoilRequest")
- # Create the instance
- return ModbusPDUWriteSingleCoilRequestBuilder(
- address,
- value
-
- )
+ readBuffer.closeContext("ModbusPDUWriteSingleCoilRequest")
+ # Create the instance
+ return ModbusPDUWriteSingleCoilRequestBuilder(address, value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteSingleCoilRequest):
+ if not isinstance(o, ModbusPDUWriteSingleCoilRequest):
return False
that: ModbusPDUWriteSingleCoilRequest = ModbusPDUWriteSingleCoilRequest(o)
- return
- (getAddress() == that.getAddress()) &&
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getAddress(),
- getValue()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getAddress(), getValue() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUWriteSingleCoilRequestBuilder(ModbusPDUModbusPDUBuilder: address:
return modbusPDUWriteSingleCoilRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
index 8cc5045515..becfadd4a7 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
- address: c_uint16
- value: c_uint16
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x05
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteSingleCoilResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteSingleCoilResponse")
- # Simple Field (address)
- writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (address)
+ writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (value)
- writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (value)
+ writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUWriteSingleCoilResponse")
+ writeBuffer.popContext("ModbusPDUWriteSingleCoilResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleCoilResponseBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleCoilResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleCoilResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUWriteSingleCoilResponse")
- # Create the instance
- return ModbusPDUWriteSingleCoilResponseBuilder(
- address,
- value
-
- )
+ readBuffer.closeContext("ModbusPDUWriteSingleCoilResponse")
+ # Create the instance
+ return ModbusPDUWriteSingleCoilResponseBuilder(address, value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteSingleCoilResponse):
+ if not isinstance(o, ModbusPDUWriteSingleCoilResponse):
return False
that: ModbusPDUWriteSingleCoilResponse = ModbusPDUWriteSingleCoilResponse(o)
- return
- (getAddress() == that.getAddress()) &&
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getAddress(),
- getValue()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getAddress(), getValue() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUWriteSingleCoilResponseBuilder(ModbusPDUModbusPDUBuilder: address
return modbusPDUWriteSingleCoilResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
index f607668f29..03263f59b9 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
- address: c_uint16
- value: c_uint16
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x06
- }
def c_bool getResponse() {
return (c_bool) false
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteSingleRegisterRequest")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteSingleRegisterRequest")
- # Simple Field (address)
- writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (address)
+ writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (value)
- writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (value)
+ writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUWriteSingleRegisterRequest")
+ writeBuffer.popContext("ModbusPDUWriteSingleRegisterRequest")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleRegisterRequestBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleRegisterRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleRegisterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUWriteSingleRegisterRequest")
- # Create the instance
- return ModbusPDUWriteSingleRegisterRequestBuilder(
- address,
- value
-
- )
+ readBuffer.closeContext("ModbusPDUWriteSingleRegisterRequest")
+ # Create the instance
+ return ModbusPDUWriteSingleRegisterRequestBuilder(address, value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteSingleRegisterRequest):
+ if not isinstance(o, ModbusPDUWriteSingleRegisterRequest):
return False
that: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(o)
- return
- (getAddress() == that.getAddress()) &&
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getAddress(),
- getValue()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getAddress(), getValue() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUWriteSingleRegisterRequestBuilder(ModbusPDUModbusPDUBuilder: addr
return modbusPDUWriteSingleRegisterRequest
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
index 9d225c7802..6d2bf2b965 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
@@ -22,26 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+import math
+
@dataclass
class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
- address: c_uint16
- value: c_uint16
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
def c_bool getErrorFlag() {
return (c_bool) false
- }
def c_uint8 getFunctionFlag() {
return (c_uint8) 0x06
- }
def c_bool getResponse() {
return (c_bool) true
- }
def __post_init__(self):
-super().__init__( )
+ super().__init__( )
@@ -54,20 +57,20 @@ super().__init__( )
def serializeModbusPDUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusPDUWriteSingleRegisterResponse")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusPDUWriteSingleRegisterResponse")
- # Simple Field (address)
- writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (address)
+ writeSimpleField("address", address, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (value)
- writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
+ # Simple Field (value)
+ writeSimpleField("value", value, writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusPDUWriteSingleRegisterResponse")
+ writeBuffer.popContext("ModbusPDUWriteSingleRegisterResponse")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -82,54 +85,43 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleRegisterResponseBuilder:
+ @staticmethod
+ def staticParseBuilder(readBuffer: ReadBuffer, response: c_bool) -> ModbusPDUWriteSingleRegisterResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleRegisterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
- readBuffer.closeContext("ModbusPDUWriteSingleRegisterResponse")
- # Create the instance
- return ModbusPDUWriteSingleRegisterResponseBuilder(
- address,
- value
-
- )
+ readBuffer.closeContext("ModbusPDUWriteSingleRegisterResponse")
+ # Create the instance
+ return ModbusPDUWriteSingleRegisterResponseBuilder(address, value )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusPDUWriteSingleRegisterResponse):
+ if not isinstance(o, ModbusPDUWriteSingleRegisterResponse):
return False
that: ModbusPDUWriteSingleRegisterResponse = ModbusPDUWriteSingleRegisterResponse(o)
- return
- (getAddress() == that.getAddress()) &&
- (getValue() == that.getValue()) &&
- super().equals(that) &&
- True
+ return (getAddress() == that.getAddress()) && (getValue() == that.getValue()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getAddress(),
- getValue()
- )
-
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ return hash(super().hashCode(), getAddress(), getValue() )
+
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,3 +137,4 @@ class ModbusPDUWriteSingleRegisterResponseBuilder(ModbusPDUModbusPDUBuilder: add
return modbusPDUWriteSingleRegisterResponse
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
index a5a1a43a91..d0896a7a77 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
@@ -22,22 +22,29 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
-
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+from plc4py.protocols.modbus.readwrite.DriverType import DriverType
+from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
+import math
+
+
@dataclass
class ModbusRtuADU(PlcMessage,ModbusADU):
- address: c_uint8
- pdu: ModbusPDU
- # Arguments.
- response: c_bool
+ address: c_uint8
+ pdu: ModbusPDU
+ # Arguments.
+ response: c_bool
# Accessors for discriminator values.
def DriverType getDriverType() {
return DriverType.MODBUS_RTU
- }
def __post_init__(self):
-super().__init__( self.response )
+ super().__init__( self.response )
@@ -50,23 +57,23 @@ super().__init__( self.response )
def serializeModbusADUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusRtuADU")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusRtuADU")
- # Simple Field (address)
- writeSimpleField("address", address, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ # Simple Field (address)
+ writeSimpleField("address", address, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
- # Simple Field (pdu)
- writeSimpleField("pdu", pdu, new DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ # Simple Field (pdu)
+ writeSimpleField("pdu", pdu, new 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))
+ # Checksum Field (checksum) (Calculated)
+ writeChecksumField("crc", (c_uint16) (modbus.readwrite.utils.StaticHelper.rtuCrcCheck(address, pdu)), writeUnsignedInt(writeBuffer, 16))
- writeBuffer.popContext("ModbusRtuADU")
+ writeBuffer.popContext("ModbusRtuADU")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -84,58 +91,45 @@ super().__init__( self.response )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, c_bool response) -> ModbusRtuADUBuilder:
+ @staticmethod
+ 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", new DataReaderComplexDefault<>(() -> ModbusPDU.staticParse(readBuffer, (c_bool) (response)), readBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ pdu: ModbusPDU = readSimpleField("pdu", new 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
-
- )
+ readBuffer.closeContext("ModbusRtuADU")
+ # Create the instance
+ return ModbusRtuADUBuilder(address, pdu , response )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusRtuADU):
+ if not isinstance(o, ModbusRtuADU):
return False
that: ModbusRtuADU = ModbusRtuADU(o)
- return
- (getAddress() == that.getAddress()) &&
- (getPdu() == that.getPdu()) &&
- super().equals(that) &&
- True
+ return (getAddress() == that.getAddress()) && (getPdu() == that.getPdu()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getAddress(),
- getPdu()
- )
+ return hash(super().hashCode(), getAddress(), getPdu() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -145,7 +139,7 @@ class ModbusRtuADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: Modbu
def build(
- c_bool response
+ response: c_bool
) -> ModbusRtuADU:
modbusRtuADU: ModbusRtuADU = ModbusRtuADU(
address,
@@ -156,3 +150,4 @@ class ModbusRtuADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: Modbu
return modbusRtuADU
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
index 709677b675..9e188e65a9 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
@@ -22,24 +22,31 @@ from abc import ABC, abstractmethod
from dataclasses import dataclass
-
+from ctypes import c_bool
+from ctypes import c_uint16
+from ctypes import c_uint8
+from plc4py.api.messages.PlcMessage import PlcMessage
+from plc4py.protocols.modbus.readwrite.DriverType import DriverType
+from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
+import math
+
+
@dataclass
class ModbusTcpADU(PlcMessage,ModbusADU):
- transactionIdentifier: c_uint16
- unitIdentifier: c_uint8
- pdu: ModbusPDU
- # Arguments.
- response: c_bool
- PROTOCOLIDENTIFIER: c_uint16 = 0x0000
+ transactionIdentifier: c_uint16
+ unitIdentifier: c_uint8
+ pdu: ModbusPDU
+ # Arguments.
+ response: c_bool
+ PROTOCOLIDENTIFIER: c_uint16 = 0x0000
# Accessors for discriminator values.
def DriverType getDriverType() {
return DriverType.MODBUS_TCP
- }
def __post_init__(self):
-super().__init__( self.response )
+ super().__init__( self.response )
@@ -58,30 +65,30 @@ super().__init__( self.response )
def serializeModbusADUChild(self, writeBuffer: WriteBuffer):
positionAware: PositionAware = writeBuffer
- startPos: int = positionAware.getPos()
- writeBuffer.pushContext("ModbusTcpADU")
+ startPos: int = positionAware.getPos()
+ writeBuffer.pushContext("ModbusTcpADU")
- # Simple Field (transactionIdentifier)
- writeSimpleField("transactionIdentifier", transactionIdentifier, writeUnsignedInt(writeBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ # Simple Field (transactionIdentifier)
+ writeSimpleField("transactionIdentifier", transactionIdentifier, writeUnsignedInt(writeBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
- # Const Field (protocolIdentifier)
+ # Const Field (protocolIdentifier)
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))
- writeImplicitField("length", length, 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))
+ writeImplicitField("length", length, writeUnsignedInt(writeBuffer, 16))
- # Simple Field (unitIdentifier)
- writeSimpleField("unitIdentifier", unitIdentifier, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ # Simple Field (unitIdentifier)
+ writeSimpleField("unitIdentifier", unitIdentifier, writeUnsignedShort(writeBuffer, 8), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
- # Simple Field (pdu)
- writeSimpleField("pdu", pdu, new DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ # Simple Field (pdu)
+ writeSimpleField("pdu", pdu, new DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
- writeBuffer.popContext("ModbusTcpADU")
+ writeBuffer.popContext("ModbusTcpADU")
def getLengthInBytes(self) -> int:
- return int(math.ceil(float(getLengthInBits() / 8.0)))
+ return int(math.ceil(float(self.getLengthInBits() / 8.0)))
def getLengthInBits(self) -> int:
lengthInBits: int = super().getLengthInBits()
@@ -105,65 +112,49 @@ super().__init__( self.response )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, c_bool response) -> ModbusTcpADUBuilder:
+ @staticmethod
+ 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", new DataReaderComplexDefault<>(() -> ModbusPDU.staticParse(readBuffer, (c_bool) (response)), readBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ pdu: ModbusPDU = readSimpleField("pdu", new 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
-
- )
+ readBuffer.closeContext("ModbusTcpADU")
+ # Create the instance
+ return ModbusTcpADUBuilder(transactionIdentifier, unitIdentifier, pdu , response )
def equals(self, o: object) -> bool:
- if this == o:
+ if self == o:
return True
- if not (instanceof(o, ModbusTcpADU):
+ if not isinstance(o, ModbusTcpADU):
return False
that: ModbusTcpADU = ModbusTcpADU(o)
- return
- (getTransactionIdentifier() == that.getTransactionIdentifier()) &&
- (getUnitIdentifier() == that.getUnitIdentifier()) &&
- (getPdu() == that.getPdu()) &&
- super().equals(that) &&
- True
+ return (getTransactionIdentifier() == that.getTransactionIdentifier()) && (getUnitIdentifier() == that.getUnitIdentifier()) && (getPdu() == that.getPdu()) && super().equals(that) && True
def hashCode(self) -> int:
- return Objects.hash(
- super().hashCode(),
- getTransactionIdentifier(),
- getUnitIdentifier(),
- getPdu()
- )
+ return hash(super().hashCode(), getTransactionIdentifier(), getUnitIdentifier(), getPdu() )
- def toString(self) -> str:
- writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(true, true)
+ def __str__(self) -> str:
+ writeBufferBoxBased: WriteBufferBoxBased = WriteBufferBoxBased(True, True)
try:
- writeBufferBoxBased.writeSerializable(this)
- except SerializationException:
+ writeBufferBoxBased.writeSerializable(self)
+ except SerializationException as e:
raise RuntimeException(e)
- return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+ 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
@@ -174,7 +165,7 @@ class ModbusTcpADUBuilder(ModbusADUModbusADUBuilder: transactionIdentifier: c_ui
def build(
- c_bool response
+ response: c_bool
) -> ModbusTcpADU:
modbusTcpADU: ModbusTcpADU = ModbusTcpADU(
transactionIdentifier,
@@ -186,3 +177,4 @@ class ModbusTcpADUBuilder(ModbusADUModbusADUBuilder: transactionIdentifier: c_ui
return modbusTcpADU
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/__init__.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/__init__.py
new file mode 100644
index 0000000000..342be71799
--- /dev/null
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/__init__.py
@@ -0,0 +1,18 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#