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:10 UTC
[plc4x] branch plc4py-codegen updated (f3233d938a -> da00533d19)
This is an automated email from the ASF dual-hosted git repository.
hutcheb pushed a change to branch plc4py-codegen
in repository https://gitbox.apache.org/repos/asf/plc4x.git
from f3233d938a feat(plc4py/codegen): more updates - included generated in source files
new 5c1577eab2 feat(plc4py/codegen): More updates for template
new da00533d19 feat(plc4py/codegen): More updates for complex type template
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
.../python/PythonLanguageTemplateHelper.java | 135 ++--
.../python/complex-type-template.python.ftlh | 426 ++++++------
.../plc4py/plc4py/{api => protocols}/__init__.py | 0
.../plc4py/{api => protocols/modbus}/__init__.py | 0
.../plc4py/protocols/modbus/readwrite/DataItem.py | 718 +++++++++++++++++++++
...dbusDeviceInformationLevel.py => DriverType.py} | 20 +-
.../plc4py/protocols/modbus/readwrite/ModbusADU.py | 26 +-
.../protocols/modbus/readwrite/ModbusAsciiADU.py | 138 ++--
.../protocols/modbus/readwrite/ModbusConstants.py | 57 +-
.../protocols/modbus/readwrite/ModbusDataType.py | 24 +-
.../ModbusDeviceInformationConformityLevel.py | 16 +-
.../readwrite/ModbusDeviceInformationLevel.py | 16 +-
.../ModbusDeviceInformationMoreFollows.py | 16 +-
.../readwrite/ModbusDeviceInformationObject.py | 84 +--
.../protocols/modbus/readwrite/ModbusErrorCode.py | 16 +-
.../plc4py/protocols/modbus/readwrite/ModbusPDU.py | 269 +++++---
.../modbus/readwrite/ModbusPDUDiagnosticRequest.py | 128 ++--
.../readwrite/ModbusPDUDiagnosticResponse.py | 128 ++--
.../protocols/modbus/readwrite/ModbusPDUError.py | 103 ++-
.../ModbusPDUGetComEventCounterRequest.py | 87 ++-
.../ModbusPDUGetComEventCounterResponse.py | 128 ++--
.../readwrite/ModbusPDUGetComEventLogRequest.py | 87 ++-
.../readwrite/ModbusPDUGetComEventLogResponse.py | 177 +++--
.../ModbusPDUMaskWriteHoldingRegisterRequest.py | 147 ++---
.../ModbusPDUMaskWriteHoldingRegisterResponse.py | 147 ++---
.../modbus/readwrite/ModbusPDUReadCoilsRequest.py | 128 ++--
.../modbus/readwrite/ModbusPDUReadCoilsResponse.py | 115 ++--
.../ModbusPDUReadDeviceIdentificationRequest.py | 134 ++--
.../ModbusPDUReadDeviceIdentificationResponse.py | 219 +++----
.../ModbusPDUReadDiscreteInputsRequest.py | 128 ++--
.../ModbusPDUReadDiscreteInputsResponse.py | 115 ++--
.../ModbusPDUReadExceptionStatusRequest.py | 87 ++-
.../ModbusPDUReadExceptionStatusResponse.py | 106 ++-
.../readwrite/ModbusPDUReadFifoQueueRequest.py | 107 ++-
.../readwrite/ModbusPDUReadFifoQueueResponse.py | 123 ++--
.../readwrite/ModbusPDUReadFileRecordRequest.py | 115 ++--
.../ModbusPDUReadFileRecordRequestItem.py | 104 ++-
.../readwrite/ModbusPDUReadFileRecordResponse.py | 115 ++--
.../ModbusPDUReadFileRecordResponseItem.py | 84 +--
.../ModbusPDUReadHoldingRegistersRequest.py | 128 ++--
.../ModbusPDUReadHoldingRegistersResponse.py | 115 ++--
.../ModbusPDUReadInputRegistersRequest.py | 128 ++--
.../ModbusPDUReadInputRegistersResponse.py | 115 ++--
...sPDUReadWriteMultipleHoldingRegistersRequest.py | 196 +++---
...PDUReadWriteMultipleHoldingRegistersResponse.py | 115 ++--
.../readwrite/ModbusPDUReportServerIdRequest.py | 87 ++-
.../readwrite/ModbusPDUReportServerIdResponse.py | 115 ++--
.../readwrite/ModbusPDUWriteFileRecordRequest.py | 115 ++--
.../ModbusPDUWriteFileRecordRequestItem.py | 113 ++--
.../readwrite/ModbusPDUWriteFileRecordResponse.py | 115 ++--
.../ModbusPDUWriteFileRecordResponseItem.py | 113 ++--
.../ModbusPDUWriteMultipleCoilsRequest.py | 158 ++---
.../ModbusPDUWriteMultipleCoilsResponse.py | 128 ++--
...odbusPDUWriteMultipleHoldingRegistersRequest.py | 158 ++---
...dbusPDUWriteMultipleHoldingRegistersResponse.py | 128 ++--
.../readwrite/ModbusPDUWriteSingleCoilRequest.py | 128 ++--
.../readwrite/ModbusPDUWriteSingleCoilResponse.py | 128 ++--
.../ModbusPDUWriteSingleRegisterRequest.py | 128 ++--
.../ModbusPDUWriteSingleRegisterResponse.py | 128 ++--
.../protocols/modbus/readwrite/ModbusRtuADU.py | 139 ++--
.../protocols/modbus/readwrite/ModbusTcpADU.py | 168 +++--
.../modbus/readwrite}/__init__.py | 0
sandbox/plc4py/pom.xml | 16 +-
63 files changed, 3975 insertions(+), 3660 deletions(-)
copy sandbox/plc4py/plc4py/{api => protocols}/__init__.py (100%)
copy sandbox/plc4py/plc4py/{api => protocols/modbus}/__init__.py (100%)
create mode 100644 sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
copy sandbox/plc4py/plc4py/protocols/modbus/readwrite/{ModbusDeviceInformationLevel.py => DriverType.py} (67%)
copy sandbox/plc4py/plc4py/{api => protocols/modbus/readwrite}/__init__.py (100%)
[plc4x] 02/02: feat(plc4py/codegen): More updates for complex type template
Posted by hu...@apache.org.
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.
+#
[plc4x] 01/02: feat(plc4py/codegen): More updates for template
Posted by hu...@apache.org.
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 5c1577eab29553bc5be6d9aa277041a48567dfd6
Author: Ben Hutcheson <be...@gmail.com>
AuthorDate: Mon Nov 14 20:15:19 2022 -0600
feat(plc4py/codegen): More updates for template
---
.../python/PythonLanguageTemplateHelper.java | 82 ++-
.../python/complex-type-template.python.ftlh | 178 ++---
.../plc4py/protocols/modbus/readwrite/DataItem.py | 718 +++++++++++++++++++++
...dbusDeviceInformationLevel.py => DriverType.py} | 20 +-
.../plc4py/protocols/modbus/readwrite/ModbusADU.py | 26 +-
.../protocols/modbus/readwrite/ModbusAsciiADU.py | 64 +-
.../protocols/modbus/readwrite/ModbusConstants.py | 8 +-
.../protocols/modbus/readwrite/ModbusDataType.py | 24 +-
.../ModbusDeviceInformationConformityLevel.py | 16 +-
.../readwrite/ModbusDeviceInformationLevel.py | 16 +-
.../ModbusDeviceInformationMoreFollows.py | 16 +-
.../readwrite/ModbusDeviceInformationObject.py | 16 +-
.../protocols/modbus/readwrite/ModbusErrorCode.py | 16 +-
.../plc4py/protocols/modbus/readwrite/ModbusPDU.py | 108 ++--
.../modbus/readwrite/ModbusPDUDiagnosticRequest.py | 61 +-
.../readwrite/ModbusPDUDiagnosticResponse.py | 61 +-
.../protocols/modbus/readwrite/ModbusPDUError.py | 41 +-
.../ModbusPDUGetComEventCounterRequest.py | 37 +-
.../ModbusPDUGetComEventCounterResponse.py | 61 +-
.../readwrite/ModbusPDUGetComEventLogRequest.py | 37 +-
.../readwrite/ModbusPDUGetComEventLogResponse.py | 87 ++-
.../ModbusPDUMaskWriteHoldingRegisterRequest.py | 73 +--
.../ModbusPDUMaskWriteHoldingRegisterResponse.py | 73 +--
.../modbus/readwrite/ModbusPDUReadCoilsRequest.py | 61 +-
.../modbus/readwrite/ModbusPDUReadCoilsResponse.py | 51 +-
.../ModbusPDUReadDeviceIdentificationRequest.py | 61 +-
.../ModbusPDUReadDeviceIdentificationResponse.py | 101 ++-
.../ModbusPDUReadDiscreteInputsRequest.py | 61 +-
.../ModbusPDUReadDiscreteInputsResponse.py | 51 +-
.../ModbusPDUReadExceptionStatusRequest.py | 37 +-
.../ModbusPDUReadExceptionStatusResponse.py | 49 +-
.../readwrite/ModbusPDUReadFifoQueueRequest.py | 49 +-
.../readwrite/ModbusPDUReadFifoQueueResponse.py | 57 +-
.../readwrite/ModbusPDUReadFileRecordRequest.py | 53 +-
.../ModbusPDUReadFileRecordRequestItem.py | 26 +-
.../readwrite/ModbusPDUReadFileRecordResponse.py | 53 +-
.../ModbusPDUReadFileRecordResponseItem.py | 16 +-
.../ModbusPDUReadHoldingRegistersRequest.py | 61 +-
.../ModbusPDUReadHoldingRegistersResponse.py | 51 +-
.../ModbusPDUReadInputRegistersRequest.py | 61 +-
.../ModbusPDUReadInputRegistersResponse.py | 51 +-
...sPDUReadWriteMultipleHoldingRegistersRequest.py | 99 ++-
...PDUReadWriteMultipleHoldingRegistersResponse.py | 51 +-
.../readwrite/ModbusPDUReportServerIdRequest.py | 37 +-
.../readwrite/ModbusPDUReportServerIdResponse.py | 51 +-
.../readwrite/ModbusPDUWriteFileRecordRequest.py | 53 +-
.../ModbusPDUWriteFileRecordRequestItem.py | 28 +-
.../readwrite/ModbusPDUWriteFileRecordResponse.py | 53 +-
.../ModbusPDUWriteFileRecordResponseItem.py | 28 +-
.../ModbusPDUWriteMultipleCoilsRequest.py | 75 +--
.../ModbusPDUWriteMultipleCoilsResponse.py | 61 +-
...odbusPDUWriteMultipleHoldingRegistersRequest.py | 75 +--
...dbusPDUWriteMultipleHoldingRegistersResponse.py | 61 +-
.../readwrite/ModbusPDUWriteSingleCoilRequest.py | 61 +-
.../readwrite/ModbusPDUWriteSingleCoilResponse.py | 61 +-
.../ModbusPDUWriteSingleRegisterRequest.py | 61 +-
.../ModbusPDUWriteSingleRegisterResponse.py | 61 +-
.../protocols/modbus/readwrite/ModbusRtuADU.py | 64 +-
.../protocols/modbus/readwrite/ModbusTcpADU.py | 82 +--
sandbox/plc4py/pom.xml | 16 +-
60 files changed, 2156 insertions(+), 1711 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 5dc77675eb..025019994f 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
@@ -93,81 +93,75 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
}
public String getLanguageTypeNameForTypeReference(TypeReference typeReference, boolean allowPrimitive) {
- Objects.requireNonNull(typeReference);
- if (typeReference instanceof ArrayTypeReference) {
- final ArrayTypeReference arrayTypeReference = (ArrayTypeReference) typeReference;
- if (arrayTypeReference.getElementTypeReference().isByteBased()) {
- return getLanguageTypeNameForTypeReference(arrayTypeReference.getElementTypeReference(), allowPrimitive) + "[]";
- } else {
- return "List<" + getLanguageTypeNameForTypeReference(arrayTypeReference.getElementTypeReference(), false) + ">";
- }
+ if (typeReference == null) {
+ // TODO: shouldn't this be an error case
+ return "";
}
- // DataIo data-types always have properties of type PlcValue
- if (typeReference.isDataIoTypeReference()) {
- return "PlcValue";
+ if (typeReference.isArrayTypeReference()) {
+ final ArrayTypeReference arrayTypeReference = (ArrayTypeReference) typeReference;
+ TypeReference elementTypeReference = arrayTypeReference.getElementTypeReference();
+ return "[]" + getLanguageTypeNameForTypeReference(elementTypeReference);
}
if (typeReference.isNonSimpleTypeReference()) {
return typeReference.asNonSimpleTypeReference().orElseThrow().getName();
}
- SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
+ SimpleTypeReference simpleTypeReference = typeReference.asSimpleTypeReference().orElseThrow();
switch (simpleTypeReference.getBaseType()) {
case BIT:
- return allowPrimitive ? boolean.class.getSimpleName() : Boolean.class.getSimpleName();
+ return "c_bool";
case BYTE:
- return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
+ return "c_byte";
case UINT:
- IntegerTypeReference unsignedIntegerTypeReference = (IntegerTypeReference) simpleTypeReference;
- if (unsignedIntegerTypeReference.getSizeInBits() <= 4) {
- return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
- }
+ IntegerTypeReference unsignedIntegerTypeReference = simpleTypeReference.asIntegerTypeReference().orElseThrow();
if (unsignedIntegerTypeReference.getSizeInBits() <= 8) {
- return allowPrimitive ? short.class.getSimpleName() : Short.class.getSimpleName();
+ return "c_uint8";
}
if (unsignedIntegerTypeReference.getSizeInBits() <= 16) {
- return allowPrimitive ? int.class.getSimpleName() : Integer.class.getSimpleName();
+ return "c_uint16";
}
if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
- return allowPrimitive ? long.class.getSimpleName() : Long.class.getSimpleName();
+ return "c_uint32";
+ }
+ if (unsignedIntegerTypeReference.getSizeInBits() <= 64) {
+ return "c_uint64";
}
- return BigInteger.class.getSimpleName();
+ return "c_longlong";
case INT:
- IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
+ IntegerTypeReference integerTypeReference = simpleTypeReference.asIntegerTypeReference().orElseThrow();
if (integerTypeReference.getSizeInBits() <= 8) {
- return allowPrimitive ? byte.class.getSimpleName() : Byte.class.getSimpleName();
+ return "c_int8";
}
if (integerTypeReference.getSizeInBits() <= 16) {
- return allowPrimitive ? short.class.getSimpleName() : Short.class.getSimpleName();
+ return "c_int16";
}
if (integerTypeReference.getSizeInBits() <= 32) {
- return allowPrimitive ? int.class.getSimpleName() : Integer.class.getSimpleName();
+ return "c_int32";
}
if (integerTypeReference.getSizeInBits() <= 64) {
- return allowPrimitive ? long.class.getSimpleName() : Long.class.getSimpleName();
+ return "c_int64";
}
- return BigInteger.class.getSimpleName();
+ return "c_longlong";
case FLOAT:
case UFLOAT:
- FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
+ FloatTypeReference floatTypeReference = simpleTypeReference.asFloatTypeReference().orElseThrow();
int sizeInBits = floatTypeReference.getSizeInBits();
if (sizeInBits <= 32) {
- return allowPrimitive ? float.class.getSimpleName() : Float.class.getSimpleName();
+ return "c_float";
}
if (sizeInBits <= 64) {
- return allowPrimitive ? double.class.getSimpleName() : Double.class.getSimpleName();
+ return "c_double";
}
- return BigDecimal.class.getSimpleName();
+ return "c_longdouble";
case STRING:
case VSTRING:
- return String.class.getSimpleName();
+ return "str";
case TIME:
- return LocalTime.class.getSimpleName();
case DATE:
- return LocalDate.class.getSimpleName();
case DATETIME:
- return LocalDateTime.class.getSimpleName();
-
+ return "time.Time";
+ default:
+ throw new RuntimeException("Unsupported simple type");
}
- throw new RuntimeException("Unsupported simple type");
}
public String getPlcValueTypeForTypeReference(TypeReference typeReference) {
@@ -236,7 +230,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
SimpleTypeReference simpleTypeReference = (SimpleTypeReference) typeReference;
switch (simpleTypeReference.getBaseType()) {
case BIT:
- return "false";
+ return "False";
case BYTE:
return "0";
case UINT:
@@ -247,7 +241,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if (unsignedIntegerTypeReference.getSizeInBits() <= 32) {
return "0l";
}
- return "null";
+ return "None";
case INT:
IntegerTypeReference integerTypeReference = (IntegerTypeReference) simpleTypeReference;
if (integerTypeReference.getSizeInBits() <= 32) {
@@ -256,7 +250,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if (integerTypeReference.getSizeInBits() <= 64) {
return "0l";
}
- return "null";
+ return "None";
case FLOAT:
FloatTypeReference floatTypeReference = (FloatTypeReference) simpleTypeReference;
int sizeInBits = floatTypeReference.getSizeInBits();
@@ -266,14 +260,14 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if (sizeInBits <= 64) {
return "0.0";
}
- return "null";
+ return "None";
case STRING:
case VSTRING:
- return "null";
+ return "None";
}
throw new FreemarkerException("Unmapped base-type" + simpleTypeReference.getBaseType());
} else {
- return "null";
+ return "None";
}
}
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 b068480b34..8cb5498136 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
@@ -795,92 +795,6 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
return _${type.name?uncap_first}
</#if>
- <#if type.isDiscriminatedParentTypeDefinition()>
- class ${type.name}Builder:
- def build(
- <#list type.propertyFields as field>
- ${helper.getLanguageTypeNameForField(field)} ${field.name}<#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>
- </#list>
- </#if>
- ) -> ${type.name}:
-
- </#if>
- <#if type.isDiscriminatedChildTypeDefinition()>
- class ${type.name}Builder(${type.parentType.orElseThrow().name}${type.parentType.orElseThrow().name}Builder {
- <#if type.propertyFields?has_content>
- <#list type.propertyFields as field>
- ${field.name}: ${helper.getLanguageTypeNameForField(field)}
- </#list>
- </#if>
- <#if filteredParserArguments?has_content>
- <#list filteredParserArguments as arg>
- ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}
- </#list>
- </#if>
- <#list reservedFields as reservedField>
- reservedField${reservedField?index}: ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)}
- </#list>
-
- def ${type.name}Builder(
- <#list type.propertyFields as field>
- ${helper.getLanguageTypeNameForField(field)} ${field.name}<#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>
- </#list>
- </#if>
- <#if (type.propertyFields?has_content || filteredParentParserArguments?has_content) && reservedFields?has_content>,</#if>
- <#list reservedFields as reservedField>
- ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedField?index}<#sep>, </#sep>
- </#list>
- ):
- <#list type.propertyFields as field>
- self.${field.name} = ${field.name}
- </#list>
- <#if filteredParserArguments?has_content>
- <#list filteredParserArguments as arg>
- self.${arg.name} = ${arg.name}
- </#list>
- </#if>
- <#list reservedFields as reservedField>
- self.reservedField${reservedField?index} = reservedField${reservedField?index}
- </#list>
-
-
- def build(
- <#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().propertyFields as field>
- ${helper.getLanguageTypeNameForField(field)} ${field.name}<#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>
- </#list>
- </#if>
- ) -> ${type.name}:
- ${type.name?uncap_first}: ${type.name} = ${type.name}(
- <#list type.allPropertyFields as field>
- ${field.name}<#sep>, </#sep>
- </#list>
- <#if filteredParserArguments?has_content>
- <#if type.allPropertyFields?has_content>, </#if>
- <#list filteredParserArguments as arg>
- ${arg.name}<#sep>, </#sep>
- </#list>
- </#if>)
- <#list reservedFields as reservedField>
- ${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index}
- </#list>
- return ${type.name?uncap_first}
-
- </#if>
def equals(self, o: object) -> bool:
if this == o:
@@ -922,4 +836,96 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
return "\n" + writeBufferBoxBased.getBox().toString()+ "\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>
+</#list>
+<#if filteredParserArguments?has_content>
+ <#if type.propertyFields?has_content>, </#if>
+ <#list filteredParserArguments as arg>
+ ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name}<#sep>, </#sep>
+ </#list>
+</#if>
+) -> ${type.name}:</...@compress>
+ pass
+
+ </#if>
+
+ <#if type.isDiscriminatedChildTypeDefinition()>
+<@compress single_line=true>
+class ${type.name}Builder(${type.parentType.orElseThrow().name}${type.parentType.orElseThrow().name}Builder:
+<#if type.propertyFields?has_content>
+ <#list type.propertyFields as field>
+ ${field.name}: ${helper.getLanguageTypeNameForField(field)}
+ </#list>
+</#if>
+<#if filteredParserArguments?has_content>
+ <#list filteredParserArguments as arg>
+ ${arg.name}: ${helper.getLanguageTypeNameForTypeReference(arg.type)}
+ </#list>
+</#if>
+<#list reservedFields as reservedField>
+ reservedField${reservedField?index}: ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)}
+</#list>
+</...@compress>
+ <@compress single_line=true>
+ def ${type.name}Builder(
+ <#list type.propertyFields as field>
+ ${helper.getLanguageTypeNameForField(field)} ${field.name}<#sep>, </#sep>
+ </#list>
+ <#if filteredParserArguments?has_content>
+ <#if type.propertyFields?has_content>, </#if>
+ <#list filteredParserArguments as arg>
+ ${helper.getLanguageTypeNameForTypeReference(arg.type)} ${arg.name}<#sep>, </#sep>
+ </#list>
+ </#if>
+ <#if (type.propertyFields?has_content || filteredParentParserArguments?has_content) && reservedFields?has_content>,</#if>
+ <#list reservedFields as reservedField>
+ ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)} reservedField${reservedField?index}<#sep>, </#sep>
+ </#list>
+ ):
+ </...@compress>
+ <#list type.propertyFields as field>
+ self.${field.name} = ${field.name}
+ </#list>
+ <#if filteredParserArguments?has_content>
+ <#list filteredParserArguments as arg>
+ self.${arg.name} = ${arg.name}
+ </#list>
+ </#if>
+ <#list reservedFields as reservedField>
+ self.reservedField${reservedField?index} = reservedField${reservedField?index}
+ </#list>
+
+
+ def build(
+ <#list type.parentType.orElseThrow().asComplexTypeDefinition().orElseThrow().propertyFields as field>
+ ${helper.getLanguageTypeNameForField(field)} ${field.name}<#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>
+ </#list>
+ </#if>
+ ) -> ${type.name}:
+ ${type.name?uncap_first}: ${type.name} = ${type.name}(
+ <#list type.allPropertyFields as field>
+ ${field.name}<#sep>, </#sep>
+ </#list>
+ <#if filteredParserArguments?has_content>
+ <#if type.allPropertyFields?has_content>, </#if>
+ <#list filteredParserArguments as arg>
+ ${arg.name}<#sep>, </#sep>
+ </#list>
+ </#if>)
+ <#list reservedFields as reservedField>
+ ${type.name?uncap_first}.reservedField${reservedField?index} = reservedField${reservedField?index}
+ </#list>
+ return ${type.name?uncap_first}
+
+ </#if>
+
</#outputformat>
\ No newline at end of file
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
new file mode 100644
index 0000000000..a2213f9abe
--- /dev/null
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
@@ -0,0 +1,718 @@
+#
+# 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.
+#
+package modbus.readwrite;
+
+import static org.apache.plc4x.java.spi.generation.StaticHelper.*;
+
+import org.apache.plc4x.java.api.model.PlcTag;
+import org.apache.plc4x.java.api.value.*;
+import org.apache.plc4x.java.spi.generation.EvaluationHelper;
+import org.apache.plc4x.java.spi.generation.ParseException;
+import org.apache.plc4x.java.spi.generation.SerializationException;
+import org.apache.plc4x.java.spi.generation.ReadBuffer;
+import org.apache.plc4x.java.spi.generation.WriteBuffer;
+import org.apache.plc4x.java.spi.generation.ByteOrder;
+import modbus.readwrite.*;
+import org.apache.plc4x.java.spi.values.*;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.math.BigInteger;
+import java.time.*;
+import java.util.*;
+import java.util.function.Supplier;
+
+// Code generated by code-generation. DO NOT EDIT.
+
+public class DataItem {
+
+ private static final Logger LOGGER = LoggerFactory.getLogger(DataItem.class);
+ public static PlcValue staticParse(ReadBuffer readBuffer, ModbusDataType dataType, c_uint16 numberOfValues) throws ParseException {
+if( EvaluationHelper.equals( dataType, ModbusDataType.BOOL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // BOOL
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ c_uint16 reserved = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedInt("", 15);
+ if(reserved != (c_uint16) 0x0000) {
+ LOGGER.info("Expected constant value " + 0x0000 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (value)
+ c_bool value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readBit("");
+
+ return new PlcBOOL(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BOOL ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcBOOL((c_bool) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readBit("")));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BYTE ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // BYTE
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ c_uint8 reserved = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedShort("", 8);
+ if(reserved != (c_uint8) 0x00) {
+ LOGGER.info("Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (value)
+ c_uint8 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedShort("", 8);
+
+ return new PlcBYTE(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BYTE ) ) { // List
+ // Array field (value)
+ // Count array
+ if((numberOfValues) * (8) > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + ((numberOfValues) * (8)) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) (numberOfValues) * (8);
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcBOOL((c_bool) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readBit("")));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WORD ) ) { // WORD
+
+ // Simple Field (value)
+ c_uint16 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedInt("", 16);
+
+ return new PlcWORD(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DWORD ) ) { // DWORD
+
+ // Simple Field (value)
+ c_uint32 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedLong("", 32);
+
+ return new PlcDWORD(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LWORD ) ) { // LWORD
+
+ // Simple Field (value)
+ c_uint64 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedBigInteger("", 64);
+
+ return new PlcLWORD(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.SINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // SINT
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ c_uint8 reserved = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedShort("", 8);
+ if(reserved != (c_uint8) 0x00) {
+ LOGGER.info("Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (value)
+ c_int8 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readSignedByte("", 8);
+
+ return new PlcSINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.SINT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcSINT((c_int8) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readSignedByte("", 8)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.INT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // INT
+
+ // Simple Field (value)
+ c_int16 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readShort("", 16);
+
+ return new PlcINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.INT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcINT((c_int16) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readShort("", 16)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // DINT
+
+ // Simple Field (value)
+ c_int32 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readInt("", 32);
+
+ return new PlcDINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DINT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcDINT((c_int32) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readInt("", 32)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // LINT
+
+ // Simple Field (value)
+ c_int64 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readLong("", 64);
+
+ return new PlcLINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LINT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcLINT((c_int64) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readLong("", 64)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.USINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // USINT
+
+ // Reserved Field (Compartmentalized so the "reserved" variable can't leak)
+ {
+ c_uint8 reserved = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedShort("", 8);
+ if(reserved != (c_uint8) 0x00) {
+ LOGGER.info("Expected constant value " + 0x00 + " but got " + reserved + " for reserved field.");
+ }
+ }
+
+ // Simple Field (value)
+ c_uint8 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedShort("", 8);
+
+ return new PlcUSINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.USINT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcUINT((c_uint8) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedShort("", 8)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // UINT
+
+ // Simple Field (value)
+ c_uint16 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedInt("", 16);
+
+ return new PlcUINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UINT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcUDINT((c_uint16) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedInt("", 16)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UDINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // UDINT
+
+ // Simple Field (value)
+ c_uint32 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedLong("", 32);
+
+ return new PlcUDINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UDINT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcULINT((c_uint32) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedLong("", 32)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.ULINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // ULINT
+
+ // Simple Field (value)
+ c_uint64 value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedBigInteger("", 64);
+
+ return new PlcULINT(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.ULINT ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcLINT((c_uint64) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readUnsignedBigInteger("", 64)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.REAL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // REAL
+
+ // Simple Field (value)
+ c_float value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readFloat("", 32);
+
+ return new PlcREAL(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.REAL ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcREAL((c_float) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readFloat("", 32)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LREAL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // LREAL
+
+ // Simple Field (value)
+ c_double value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readDouble("", 64);
+
+ return new PlcLREAL(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LREAL ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcLREAL((c_double) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readDouble("", 64)));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.CHAR ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // CHAR
+
+ // Simple Field (value)
+ str value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readString("", 8, "UTF-8");
+
+ return new PlcCHAR(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.CHAR ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcSTRING((str) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readString("", 8, "UTF-8")));
+ }
+ }
+
+ return new PlcList(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WCHAR ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // WCHAR
+
+ // Simple Field (value)
+ str value = /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readString("", 16, "UTF-16");
+
+ return new PlcWCHAR(value);
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WCHAR ) ) { // List
+ // Array field (value)
+ // Count array
+ if(numberOfValues > Integer.MAX_VALUE) {
+ throw new ParseException("Array count of " + (numberOfValues) + " exceeds the maximum allowed count of " + Integer.MAX_VALUE);
+ }
+ List<PlcValue> value;
+ {
+ int itemCount = (int) numberOfValues;
+ value = new LinkedList<>();
+ for(int curItem = 0; curItem < itemCount; curItem++) {
+ value.add(new PlcSTRING((str) /*TODO: migrate me*//*TODO: migrate me*/readBuffer.readString("", 16, "UTF-16")));
+ }
+ }
+
+ return new PlcList(value);
+ }
+ return null;
+ }
+
+ public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value, ModbusDataType dataType, c_uint16 numberOfValues) throws SerializationException {
+ staticSerialize(writeBuffer, _value, dataType, numberOfValues, ByteOrder.BIG_ENDIAN);
+ }
+
+ public static void staticSerialize(WriteBuffer writeBuffer, PlcValue _value, ModbusDataType dataType, c_uint16 numberOfValues, ByteOrder byteOrder) throws SerializationException {
+if( EvaluationHelper.equals( dataType, ModbusDataType.BOOL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // BOOL
+ // Reserved Field
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedInt("", 15, ((Number) (c_uint16) 0x0000).intValue());
+ // Simple Field (value)
+ c_bool value = (c_bool) _value.getC_bool();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeBit("", (boolean) (value));
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BOOL ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_bool value = (c_bool) val.getC_bool();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeBit("", (boolean) (value));
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BYTE ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // BYTE
+ // Reserved Field
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedShort("", 8, ((Number) (c_uint8) 0x00).shortValue());
+ // Simple Field (value)
+ c_uint8 value = (c_uint8) _value.getC_uint8();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BYTE ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_bool value = (c_bool) val.getC_bool();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeBit("", (boolean) (value));
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WORD ) ) { // WORD
+ // Simple Field (value)
+ c_uint16 value = (c_uint16) _value.getC_uint16();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DWORD ) ) { // DWORD
+ // Simple Field (value)
+ c_uint32 value = (c_uint32) _value.getC_uint32();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedLong("", 32, ((Number) (value)).longValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LWORD ) ) { // LWORD
+ // Simple Field (value)
+ c_uint64 value = (c_uint64) _value.getC_uint64();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (value));
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.SINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // SINT
+ // Reserved Field
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedShort("", 8, ((Number) (c_uint8) 0x00).shortValue());
+ // Simple Field (value)
+ c_int8 value = (c_int8) _value.getC_int8();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeSignedByte("", 8, ((Number) (value)).byteValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.SINT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_int8 value = (c_int8) val.getC_int8();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeSignedByte("", 8, ((Number) (value)).byteValue());
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.INT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // INT
+ // Simple Field (value)
+ c_int16 value = (c_int16) _value.getC_int16();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeShort("", 16, ((Number) (value)).shortValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.INT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_int16 value = (c_int16) val.getC_int16();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeShort("", 16, ((Number) (value)).shortValue());
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // DINT
+ // Simple Field (value)
+ c_int32 value = (c_int32) _value.getC_int32();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeInt("", 32, ((Number) (value)).intValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DINT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_int32 value = (c_int32) val.getC_int32();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeInt("", 32, ((Number) (value)).intValue());
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // LINT
+ // Simple Field (value)
+ c_int64 value = (c_int64) _value.getC_int64();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeLong("", 64, ((Number) (value)).longValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LINT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_int64 value = (c_int64) val.getC_int64();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeLong("", 64, ((Number) (value)).longValue());
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.USINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // USINT
+ // Reserved Field
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedShort("", 8, ((Number) (c_uint8) 0x00).shortValue());
+ // Simple Field (value)
+ c_uint8 value = (c_uint8) _value.getC_uint8();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.USINT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_uint8 value = (c_uint8) val.getC_uint8();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedShort("", 8, ((Number) (value)).shortValue());
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // UINT
+ // Simple Field (value)
+ c_uint16 value = (c_uint16) _value.getC_uint16();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UINT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_uint16 value = (c_uint16) val.getC_uint16();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedInt("", 16, ((Number) (value)).intValue());
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UDINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // UDINT
+ // Simple Field (value)
+ c_uint32 value = (c_uint32) _value.getC_uint32();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedLong("", 32, ((Number) (value)).longValue());
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UDINT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_uint32 value = (c_uint32) val.getC_uint32();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedLong("", 32, ((Number) (value)).longValue());
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.ULINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // ULINT
+ // Simple Field (value)
+ c_uint64 value = (c_uint64) _value.getC_uint64();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (value));
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.ULINT ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_uint64 value = (c_uint64) val.getC_uint64();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeUnsignedBigInteger("", 64, (BigInteger) (value));
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.REAL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // REAL
+ // Simple Field (value)
+ c_float value = (c_float) _value.getC_float();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeFloat("", 32,(value));
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.REAL ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_float value = (c_float) val.getC_float();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeFloat("", 32,(value));
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LREAL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // LREAL
+ // Simple Field (value)
+ c_double value = (c_double) _value.getC_double();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeDouble("", 64,(value));
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LREAL ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ c_double value = (c_double) val.getC_double();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeDouble("", 64,(value));
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.CHAR ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // CHAR
+ // Simple Field (value)
+ str value = (str) _value.getStr();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeString("", 8, "UTF-8", (String) (value));
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.CHAR ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ str value = (str) val.getStr();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeString("", 8, "UTF-8", (String) (value));
+ }
+
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WCHAR ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // WCHAR
+ // Simple Field (value)
+ str value = (str) _value.getStr();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeString("", 16, "UTF-16", (String) (value));
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WCHAR ) ) { // List
+ PlcList values = (PlcList) _value;
+
+ for (PlcValue val : ((List<PlcValue>) values.getList())) {
+ str value = (str) val.getStr();
+ /*TODO: migrate me*//*TODO: migrate me*/writeBuffer.writeString("", 16, "UTF-16", (String) (value));
+ }
+
+ }
+ }
+
+ public static int getLengthInBytes(PlcValue _value, ModbusDataType dataType, c_uint16 numberOfValues) {
+ return (int) Math.ceil((float) getLengthInBits(_value, dataType, numberOfValues) / 8.0);
+ }
+
+ public static int getLengthInBits(PlcValue _value, ModbusDataType dataType, c_uint16 numberOfValues) {
+ int sizeInBits = 0;
+if( EvaluationHelper.equals( dataType, ModbusDataType.BOOL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // BOOL
+ // Reserved Field
+ sizeInBits += 15;
+ // Simple Field (value)
+ sizeInBits += 1;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BOOL ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 1;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BYTE ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // BYTE
+ // Reserved Field
+ sizeInBits += 8;
+ // Simple Field (value)
+ sizeInBits += 8;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.BYTE ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 1;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WORD ) ) { // WORD
+ // Simple Field (value)
+ sizeInBits += 16;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DWORD ) ) { // DWORD
+ // Simple Field (value)
+ sizeInBits += 32;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LWORD ) ) { // LWORD
+ // Simple Field (value)
+ sizeInBits += 64;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.SINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // SINT
+ // Reserved Field
+ sizeInBits += 8;
+ // Simple Field (value)
+ sizeInBits += 8;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.SINT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 8;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.INT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // INT
+ // Simple Field (value)
+ sizeInBits += 16;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.INT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 16;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // DINT
+ // Simple Field (value)
+ sizeInBits += 32;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.DINT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 32;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // LINT
+ // Simple Field (value)
+ sizeInBits += 64;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LINT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 64;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.USINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // USINT
+ // Reserved Field
+ sizeInBits += 8;
+ // Simple Field (value)
+ sizeInBits += 8;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.USINT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 8;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // UINT
+ // Simple Field (value)
+ sizeInBits += 16;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UINT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 16;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UDINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // UDINT
+ // Simple Field (value)
+ sizeInBits += 32;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.UDINT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 32;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.ULINT ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // ULINT
+ // Simple Field (value)
+ sizeInBits += 64;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.ULINT ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 64;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.REAL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // REAL
+ // Simple Field (value)
+ sizeInBits += 32;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.REAL ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 32;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LREAL ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // LREAL
+ // Simple Field (value)
+ sizeInBits += 64;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.LREAL ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 64;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.CHAR ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // CHAR
+ // Simple Field (value)
+ sizeInBits += 8;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.CHAR ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 8;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WCHAR ) && EvaluationHelper.equals( numberOfValues, 1 ) ) { // WCHAR
+ // Simple Field (value)
+ sizeInBits += 16;
+ } else if( EvaluationHelper.equals( dataType, ModbusDataType.WCHAR ) ) { // List
+ PlcList values = (PlcList) _value;
+ sizeInBits += values.getList().size() * 16;
+ }
+ return sizeInBits;
+ }
+
+}
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DriverType.py
similarity index 67%
copy from sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py
copy to sandbox/plc4py/plc4py/protocols/modbus/readwrite/DriverType.py
index a21956bba1..ede213a84a 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DriverType.py
@@ -27,32 +27,32 @@ import java.util.Map;
// Code generated by code-generation. DO NOT EDIT.
-public enum ModbusDeviceInformationLevel {
+public enum DriverType {
-BASIC( (short) 0x01 ) , REGULAR( (short) 0x02 ) , EXTENDED( (short) 0x03 ) , INDIVIDUAL( (short) 0x04 ) ;
- private static final Map<Short, ModbusDeviceInformationLevel> map;
+MODBUS_TCP( (c_uint32) 0x01L ) , MODBUS_RTU( (c_uint32) 0x02L ) , MODBUS_ASCII( (c_uint32) 0x03L ) ;
+ private static final Map<c_uint32, DriverType> map;
static {
map = new HashMap<>();
- for (ModbusDeviceInformationLevel value : ModbusDeviceInformationLevel.values()) {
- map.put((short) value.getValue(), value);
+ for (DriverType value : DriverType.values()) {
+ map.put((c_uint32) value.getValue(), value);
}
}
- private short value;
+ private c_uint32 value;
- ModbusDeviceInformationLevel(short value) {
+ DriverType(c_uint32 value) {
this.value = value;
}
- public short getValue() {
+ public c_uint32 getValue() {
return value;
}
- public static ModbusDeviceInformationLevel enumForValue(short value) {
+ public static DriverType enumForValue(c_uint32 value) {
return map.get(value);
}
- public static Boolean isDefined(short value) {
+ public static Boolean isDefined(c_uint32 value) {
return map.containsKey(value);
}
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
index 532de2001e..1948643ec3 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
@@ -26,7 +26,7 @@ from dataclasses import dataclass
@dataclass
class ModbusADU(ABC, PlcMessage):
# Arguments.
- response: Boolean
+ response: c_bool
@@ -79,18 +79,18 @@ super().__init__( )
else:
raise PlcRuntimeException("Argument 0 expected to be of type DriverType or a string which is parseable but was " + args[0].getClass().getName())
- response: Boolean = None
- if isinstance(args[1], Boolean):
- response = Boolean(args[1])
+ response: c_bool = None
+ if isinstance(args[1], c_bool):
+ response = c_bool(args[1])
elif isinstance(args[1], String):
- response = Boolean.valueOf(str(args[1]))
+ response = c_bool.valueOf(str(args[1]))
else:
- raise PlcRuntimeException("Argument 1 expected to be of type Boolean or a string which is parseable but was " + args[1].getClass().getName())
+ raise PlcRuntimeException("Argument 1 expected to be of type c_bool or a string which is parseable but was " + args[1].getClass().getName())
return staticParse(readBuffer, driverType, response)
}
- def staticParse(readBuffer: ReadBuffer, DriverType driverType, Boolean response) -> ModbusADU:
+ def staticParse(readBuffer: ReadBuffer, DriverType driverType, c_bool response) -> ModbusADU:
readBuffer.pullContext("ModbusADU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -113,12 +113,6 @@ if:builder = ModbusAsciiADU.staticParseBuilder(readBuffer, driverType, response)
)
return _modbusADU
- class ModbusADUBuilder:
- def build(
-
- Boolean response
- ) -> ModbusADU:
-
def equals(self, o: object) -> bool:
if this == o:
@@ -144,3 +138,9 @@ if:builder = ModbusAsciiADU.staticParseBuilder(readBuffer, driverType, response)
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+class ModbusADUBuilder:
+ def build( c_bool response ) -> ModbusADU:
+ pass
+
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
index 38a0a33d09..eb0ac8bfaa 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
@@ -25,10 +25,10 @@ from dataclasses import dataclass
@dataclass
class ModbusAsciiADU(PlcMessage,ModbusADU):
- address: short
+ address: c_uint8
pdu: ModbusPDU
# Arguments.
- response: Boolean
+ response: c_bool
# Accessors for discriminator values.
def DriverType getDriverType() {
@@ -41,7 +41,7 @@ super().__init__( self.response )
- def getAddress(self) -> short:
+ def getAddress(self) -> c_uint8:
return address
def getPdu(self) -> ModbusPDU:
@@ -60,7 +60,7 @@ super().__init__( self.response )
writeSimpleField("pdu", pdu, new DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
# Checksum Field (checksum) (Calculated)
- writeChecksumField("crc", (short) (modbus.readwrite.utils.StaticHelper.asciiLrcCheck(address, pdu)), writeUnsignedShort(writeBuffer, 8))
+ writeChecksumField("crc", (c_uint8) (modbus.readwrite.utils.StaticHelper.asciiLrcCheck(address, pdu)), writeUnsignedShort(writeBuffer, 8))
writeBuffer.popContext("ModbusAsciiADU")
@@ -84,17 +84,17 @@ super().__init__( self.response )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, Boolean response) -> ModbusAsciiADUBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, c_bool response) -> ModbusAsciiADUBuilder:
readBuffer.pullContext("ModbusAsciiADU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: short = 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, (boolean) (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: short = readChecksumField("crc", readUnsignedShort(readBuffer, 8), (short) (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
@@ -106,35 +106,6 @@ super().__init__( self.response )
)
- class ModbusAsciiADUBuilder(ModbusADUModbusADUBuilder {
- address: short
- pdu: ModbusPDU
- response: Boolean
-
- def ModbusAsciiADUBuilder(
- short address,
- ModbusPDU pdu
- ,
- Boolean response
-
- ):
- self.address = address
- self.pdu = pdu
- self.response = response
-
-
- def build(
-
- Boolean response
- ) -> ModbusAsciiADU:
- modbusAsciiADU: ModbusAsciiADU = ModbusAsciiADU(
- address,
- pdu
- ,
- response
- )
- return modbusAsciiADU
-
def equals(self, o: object) -> bool:
if this == o:
@@ -166,3 +137,22 @@ super().__init__( self.response )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusAsciiADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: ModbusPDU response: c_booldef ModbusAsciiADUBuilder( c_uint8 address, ModbusPDU pdu , c_bool response ): self.address = address
+ self.pdu = pdu
+ self.response = response
+
+
+ def build(
+
+ c_bool response
+ ) -> ModbusAsciiADU:
+ modbusAsciiADU: ModbusAsciiADU = ModbusAsciiADU(
+ address,
+ pdu
+ ,
+ response
+ )
+ return modbusAsciiADU
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
index be20cc264f..f54de1e3f7 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
@@ -25,7 +25,7 @@ from dataclasses import dataclass
@dataclass
class ModbusConstants(PlcMessage):
- MODBUSTCPDEFAULTPORT: Integer = 502
+ MODBUSTCPDEFAULTPORT: c_uint16 = 502
@@ -34,7 +34,7 @@ super().__init__( )
- def getModbusTcpDefaultPort(self) -> int:
+ def getModbusTcpDefaultPort(self) -> c_uint16:
return MODBUSTCPDEFAULTPORT
@@ -73,7 +73,7 @@ super().__init__( )
startPos: int = positionAware.getPos()
curPos: int = 0
- modbusTcpDefaultPort: int = readConstField("modbusTcpDefaultPort", readUnsignedInt(readBuffer, 16), ModbusConstants.MODBUSTCPDEFAULTPORT)
+ modbusTcpDefaultPort: c_uint16 = readConstField("modbusTcpDefaultPort", readUnsignedInt(readBuffer, 16), ModbusConstants.MODBUSTCPDEFAULTPORT)
readBuffer.closeContext("ModbusConstants")
# Create the instance
@@ -106,3 +106,5 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py
index f365d4a2d5..45ab565309 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDataType.py
@@ -29,32 +29,32 @@ import java.util.Map;
public enum ModbusDataType {
-BOOL( (short) 1 , (short) 2 ) , BYTE( (short) 2 , (short) 2 ) , WORD( (short) 3 , (short) 2 ) , DWORD( (short) 4 , (short) 4 ) , LWORD( (short) 5 , (short) 8 ) , SINT( (short) 6 , (short) 2 ) , INT( (short) 7 , (short) 2 ) , DINT( (short) 8 , (short) 4 ) , LINT( (short) 9 , (short) 8 ) , USINT( (short) 10 , (short) 2 ) , UINT( (short) 11 , (short) 2 ) , UDINT( (short) 12 , (short) 4 ) , ULINT( (short) 13 , (short) 8 ) , REAL( (short) 14 , (short) 4 ) , LREAL( (short) 15 , (short) 8 ) , T [...]
- private static final Map<Short, ModbusDataType> map;
+BOOL( (c_uint8) 1 , (c_uint8) 2 ) , BYTE( (c_uint8) 2 , (c_uint8) 2 ) , WORD( (c_uint8) 3 , (c_uint8) 2 ) , DWORD( (c_uint8) 4 , (c_uint8) 4 ) , LWORD( (c_uint8) 5 , (c_uint8) 8 ) , SINT( (c_uint8) 6 , (c_uint8) 2 ) , INT( (c_uint8) 7 , (c_uint8) 2 ) , DINT( (c_uint8) 8 , (c_uint8) 4 ) , LINT( (c_uint8) 9 , (c_uint8) 8 ) , USINT( (c_uint8) 10 , (c_uint8) 2 ) , UINT( (c_uint8) 11 , (c_uint8) 2 ) , UDINT( (c_uint8) 12 , (c_uint8) 4 ) , ULINT( (c_uint8) 13 , (c_uint8) 8 ) , REAL( (c_uint8) [...]
+ private static final Map<c_uint8, ModbusDataType> map;
static {
map = new HashMap<>();
for (ModbusDataType value : ModbusDataType.values()) {
- map.put((short) value.getValue(), value);
+ map.put((c_uint8) value.getValue(), value);
}
}
- private short value;
- private short dataTypeSize;
+ private c_uint8 value;
+ private c_uint8 dataTypeSize;
- ModbusDataType(short value, short dataTypeSize) {
+ ModbusDataType(c_uint8 value, c_uint8 dataTypeSize) {
this.value = value;
this.dataTypeSize = dataTypeSize;
}
- public short getValue() {
+ public c_uint8 getValue() {
return value;
}
- public short getDataTypeSize() {
+ public c_uint8 getDataTypeSize() {
return dataTypeSize;
}
- public static ModbusDataType firstEnumForFieldDataTypeSize(short fieldValue) {
+ public static ModbusDataType firstEnumForFieldDataTypeSize(c_uint8 fieldValue) {
for (ModbusDataType _val : ModbusDataType.values()) {
if(_val.getDataTypeSize() == fieldValue) {
return _val;
@@ -63,7 +63,7 @@ BOOL( (short) 1 , (short) 2 ) , BYTE( (short) 2 , (short) 2 ) , WORD( (short) 3
return null;
}
- public static List<ModbusDataType> enumsForFieldDataTypeSize(short fieldValue) {
+ public static List<ModbusDataType> enumsForFieldDataTypeSize(c_uint8 fieldValue) {
List<ModbusDataType> _values = new ArrayList();
for (ModbusDataType _val : ModbusDataType.values()) {
if(_val.getDataTypeSize() == fieldValue) {
@@ -73,11 +73,11 @@ BOOL( (short) 1 , (short) 2 ) , BYTE( (short) 2 , (short) 2 ) , WORD( (short) 3
return _values;
}
- public static ModbusDataType enumForValue(short value) {
+ public static ModbusDataType enumForValue(c_uint8 value) {
return map.get(value);
}
- public static Boolean isDefined(short value) {
+ public static Boolean isDefined(c_uint8 value) {
return map.containsKey(value);
}
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py
index a5ae88d334..165258f5cc 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationConformityLevel.py
@@ -29,30 +29,30 @@ import java.util.Map;
public enum ModbusDeviceInformationConformityLevel {
-BASIC_STREAM_ONLY( (short) 0x01 ) , REGULAR_STREAM_ONLY( (short) 0x02 ) , EXTENDED_STREAM_ONLY( (short) 0x03 ) ;
- private static final Map<Short, ModbusDeviceInformationConformityLevel> map;
+BASIC_STREAM_ONLY( (c_uint8) 0x01 ) , REGULAR_STREAM_ONLY( (c_uint8) 0x02 ) , EXTENDED_STREAM_ONLY( (c_uint8) 0x03 ) ;
+ private static final Map<c_uint8, ModbusDeviceInformationConformityLevel> map;
static {
map = new HashMap<>();
for (ModbusDeviceInformationConformityLevel value : ModbusDeviceInformationConformityLevel.values()) {
- map.put((short) value.getValue(), value);
+ map.put((c_uint8) value.getValue(), value);
}
}
- private short value;
+ private c_uint8 value;
- ModbusDeviceInformationConformityLevel(short value) {
+ ModbusDeviceInformationConformityLevel(c_uint8 value) {
this.value = value;
}
- public short getValue() {
+ public c_uint8 getValue() {
return value;
}
- public static ModbusDeviceInformationConformityLevel enumForValue(short value) {
+ public static ModbusDeviceInformationConformityLevel enumForValue(c_uint8 value) {
return map.get(value);
}
- public static Boolean isDefined(short value) {
+ public static Boolean isDefined(c_uint8 value) {
return map.containsKey(value);
}
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py
index a21956bba1..1df5bb32d9 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationLevel.py
@@ -29,30 +29,30 @@ import java.util.Map;
public enum ModbusDeviceInformationLevel {
-BASIC( (short) 0x01 ) , REGULAR( (short) 0x02 ) , EXTENDED( (short) 0x03 ) , INDIVIDUAL( (short) 0x04 ) ;
- private static final Map<Short, ModbusDeviceInformationLevel> map;
+BASIC( (c_uint8) 0x01 ) , REGULAR( (c_uint8) 0x02 ) , EXTENDED( (c_uint8) 0x03 ) , INDIVIDUAL( (c_uint8) 0x04 ) ;
+ private static final Map<c_uint8, ModbusDeviceInformationLevel> map;
static {
map = new HashMap<>();
for (ModbusDeviceInformationLevel value : ModbusDeviceInformationLevel.values()) {
- map.put((short) value.getValue(), value);
+ map.put((c_uint8) value.getValue(), value);
}
}
- private short value;
+ private c_uint8 value;
- ModbusDeviceInformationLevel(short value) {
+ ModbusDeviceInformationLevel(c_uint8 value) {
this.value = value;
}
- public short getValue() {
+ public c_uint8 getValue() {
return value;
}
- public static ModbusDeviceInformationLevel enumForValue(short value) {
+ public static ModbusDeviceInformationLevel enumForValue(c_uint8 value) {
return map.get(value);
}
- public static Boolean isDefined(short value) {
+ public static Boolean isDefined(c_uint8 value) {
return map.containsKey(value);
}
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py
index 53c76ad75c..00119423f0 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationMoreFollows.py
@@ -29,30 +29,30 @@ import java.util.Map;
public enum ModbusDeviceInformationMoreFollows {
-NO_MORE_OBJECTS_AVAILABLE( (short) 0x00 ) , MORE_OBJECTS_AVAILABLE( (short) 0xFF ) ;
- private static final Map<Short, ModbusDeviceInformationMoreFollows> map;
+NO_MORE_OBJECTS_AVAILABLE( (c_uint8) 0x00 ) , MORE_OBJECTS_AVAILABLE( (c_uint8) 0xFF ) ;
+ private static final Map<c_uint8, ModbusDeviceInformationMoreFollows> map;
static {
map = new HashMap<>();
for (ModbusDeviceInformationMoreFollows value : ModbusDeviceInformationMoreFollows.values()) {
- map.put((short) value.getValue(), value);
+ map.put((c_uint8) value.getValue(), value);
}
}
- private short value;
+ private c_uint8 value;
- ModbusDeviceInformationMoreFollows(short value) {
+ ModbusDeviceInformationMoreFollows(c_uint8 value) {
this.value = value;
}
- public short getValue() {
+ public c_uint8 getValue() {
return value;
}
- public static ModbusDeviceInformationMoreFollows enumForValue(short value) {
+ public static ModbusDeviceInformationMoreFollows enumForValue(c_uint8 value) {
return map.get(value);
}
- public static Boolean isDefined(short value) {
+ public static Boolean isDefined(c_uint8 value) {
return map.containsKey(value);
}
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
index 19fd2d318a..b0d22f4189 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
@@ -25,8 +25,8 @@ from dataclasses import dataclass
@dataclass
class ModbusDeviceInformationObject(PlcMessage):
- objectId: short
- data: byte[]
+ objectId: c_uint8
+ data: []c_byte
@@ -35,10 +35,10 @@ super().__init__( )
- def getObjectId(self) -> short:
+ def getObjectId(self) -> c_uint8:
return objectId
- def getData(self) -> byte[]:
+ def getData(self) -> []c_byte:
return data
@@ -51,7 +51,7 @@ super().__init__( )
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)
- short objectLength = (short) (COUNT(getData()))
+ c_uint8 objectLength = (c_uint8) (COUNT(getData()))
writeImplicitField("objectLength", objectLength, writeUnsignedShort(writeBuffer, 8))
# Array Field (data)
@@ -92,9 +92,9 @@ super().__init__( )
startPos: int = positionAware.getPos()
curPos: int = 0
- objectId: short = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
+ objectId: c_uint8 = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
- objectLength: short = readImplicitField("objectLength", readUnsignedShort(readBuffer, 8))
+ objectLength: c_uint8 = readImplicitField("objectLength", readUnsignedShort(readBuffer, 8))
data: byte[] = readBuffer.readByteArray("data", Math.toIntExact(objectLength))
@@ -135,3 +135,5 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py
index 83f953baed..a994a7ddc2 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusErrorCode.py
@@ -29,30 +29,30 @@ import java.util.Map;
public enum ModbusErrorCode {
-ILLEGAL_FUNCTION( (short) 1 ) , ILLEGAL_DATA_ADDRESS( (short) 2 ) , ILLEGAL_DATA_VALUE( (short) 3 ) , SLAVE_DEVICE_FAILURE( (short) 4 ) , ACKNOWLEDGE( (short) 5 ) , SLAVE_DEVICE_BUSY( (short) 6 ) , NEGATIVE_ACKNOWLEDGE( (short) 7 ) , MEMORY_PARITY_ERROR( (short) 8 ) , GATEWAY_PATH_UNAVAILABLE( (short) 10 ) , GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND( (short) 11 ) ;
- private static final Map<Short, ModbusErrorCode> map;
+ILLEGAL_FUNCTION( (c_uint8) 1 ) , ILLEGAL_DATA_ADDRESS( (c_uint8) 2 ) , ILLEGAL_DATA_VALUE( (c_uint8) 3 ) , SLAVE_DEVICE_FAILURE( (c_uint8) 4 ) , ACKNOWLEDGE( (c_uint8) 5 ) , SLAVE_DEVICE_BUSY( (c_uint8) 6 ) , NEGATIVE_ACKNOWLEDGE( (c_uint8) 7 ) , MEMORY_PARITY_ERROR( (c_uint8) 8 ) , GATEWAY_PATH_UNAVAILABLE( (c_uint8) 10 ) , GATEWAY_TARGET_DEVICE_FAILED_TO_RESPOND( (c_uint8) 11 ) ;
+ private static final Map<c_uint8, ModbusErrorCode> map;
static {
map = new HashMap<>();
for (ModbusErrorCode value : ModbusErrorCode.values()) {
- map.put((short) value.getValue(), value);
+ map.put((c_uint8) value.getValue(), value);
}
}
- private short value;
+ private c_uint8 value;
- ModbusErrorCode(short value) {
+ ModbusErrorCode(c_uint8 value) {
this.value = value;
}
- public short getValue() {
+ public c_uint8 getValue() {
return value;
}
- public static ModbusErrorCode enumForValue(short value) {
+ public static ModbusErrorCode enumForValue(c_uint8 value) {
return map.get(value);
}
- public static Boolean isDefined(short value) {
+ public static Boolean isDefined(c_uint8 value) {
return map.containsKey(value);
}
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
index 451f4503eb..65b2581d19 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
@@ -33,11 +33,11 @@ super().__init__( )
# Abstract accessors for discriminator values.
@abstractmethod
- def getErrorFlag(self) -> Boolean:
+ def getErrorFlag(self) -> c_bool:
@abstractmethod
- def getFunctionFlag(self) -> Short:
+ def getFunctionFlag(self) -> c_uint8:
@abstractmethod
- def getResponse(self) -> Boolean:
+ def getResponse(self) -> c_bool:
@@ -85,67 +85,67 @@ super().__init__( )
if (args is None) or (args.length is not 1):
raise PlcRuntimeException("Wrong number of arguments, expected 1, but got " + args.length)
- response: Boolean = None
- if isinstance(args[0], Boolean):
- response = Boolean(args[0])
+ response: c_bool = None
+ if isinstance(args[0], c_bool):
+ response = c_bool(args[0])
elif isinstance(args[0], String):
- response = Boolean.valueOf(str(args[0]))
+ response = c_bool.valueOf(str(args[0]))
else:
- raise PlcRuntimeException("Argument 0 expected to be of type Boolean or a string which is parseable but was " + args[0].getClass().getName())
+ 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, Boolean response) -> ModbusPDU:
+ def staticParse(readBuffer: ReadBuffer, c_bool response) -> ModbusPDU:
readBuffer.pullContext("ModbusPDU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- errorFlag: boolean = readDiscriminatorField("errorFlag", readBoolean(readBuffer))
+ errorFlag: c_bool = readDiscriminatorField("errorFlag", readBoolean(readBuffer))
- functionFlag: short = readDiscriminatorField("functionFlag", readUnsignedShort(readBuffer, 7))
+ 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, (boolean) true ) ) :builder = ModbusPDUError.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x02 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadDiscreteInputsRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x02 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadDiscreteInputsResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x01 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadCoilsRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x01 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadCoilsResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x05 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUWriteSingleCoilRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x05 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUWriteSingleCoilResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x0F ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUWriteMultipleCoilsRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x0F ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUWriteMultipleCoilsResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x04 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadInputRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x04 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadInputRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x03 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadHoldingRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x03 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadHoldingRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x06 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUWriteSingleRegisterRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x06 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUWriteSingleRegisterResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x10 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUWriteMultipleHoldingRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x10 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUWriteMultipleHoldingRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x17 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadWriteMultipleHoldingRegistersRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x17 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadWriteMultipleHoldingRegistersResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x16 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUMaskWriteHoldingRegisterRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x16 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUMaskWriteHoldingRegisterResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x18 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadFifoQueueRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x18 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadFifoQueueResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x14 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadFileRecordRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x14 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadFileRecordResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x15 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUWriteFileRecordRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x15 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUWriteFileRecordResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x07 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadExceptionStatusRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x07 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReadExceptionStatusResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x08 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUDiagnosticRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x08 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUDiagnosticResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x0B ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUGetComEventCounterRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x0B ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUGetComEventCounterResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x0C ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUGetComEventLogRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x0C ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUGetComEventLogResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x11 ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReportServerIdRequest.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x11 ) and EvaluationHelper.equals( response, (boolean) true ) ) :builder = ModbusPDUReportServerIdResponse.staticParseBuilder(readBuffer, response) else:
-if EvaluationHelper.equals( errorFlag, (boolean) false ) and EvaluationHelper.equals( functionFlag, (short) 0x2B ) and EvaluationHelper.equals( response, (boolean) false ) ) :builder = ModbusPDUReadDeviceIdentificationRequest.staticParseBuilder(readBuffer, response) else:
+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+"]")
@@ -157,10 +157,6 @@ if:builder = ModbusPDUReadDeviceIdentificationResponse.staticParseBuilder(readBu
)
return _modbusPDU
- class ModbusPDUBuilder:
- def build(
- ) -> ModbusPDU:
-
def equals(self, o: object) -> bool:
if this == o:
@@ -186,3 +182,9 @@ if:builder = ModbusPDUReadDeviceIdentificationResponse.staticParseBuilder(readBu
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+class ModbusPDUBuilder:
+ def build( ) -> ModbusPDU:
+ pass
+
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
index cbc9cad72f..3a51471402 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUDiagnosticRequest(PlcMessage,ModbusPDU):
- subFunction: int
- data: int
+ subFunction: c_uint16
+ data: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x08
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x08
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getSubFunction(self) -> int:
+ def getSubFunction(self) -> c_uint16:
return subFunction
- def getData(self) -> int:
+ def getData(self) -> c_uint16:
return data
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUDiagnosticRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUDiagnosticRequestBuilder:
readBuffer.pullContext("ModbusPDUDiagnosticRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- subFunction: int = readSimpleField("subFunction", readUnsignedInt(readBuffer, 16))
+ subFunction: c_uint16 = readSimpleField("subFunction", readUnsignedInt(readBuffer, 16))
- data: int = readSimpleField("data", readUnsignedInt(readBuffer, 16))
+ data: c_uint16 = readSimpleField("data", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUDiagnosticRequest")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUDiagnosticRequestBuilder(ModbusPDUModbusPDUBuilder {
- subFunction: int
- data: int
-
- def ModbusPDUDiagnosticRequestBuilder(
- int subFunction,
- int data
-
- ):
- self.subFunction = subFunction
- self.data = data
-
-
- def build(
- ) -> ModbusPDUDiagnosticRequest:
- modbusPDUDiagnosticRequest: ModbusPDUDiagnosticRequest = ModbusPDUDiagnosticRequest(
- subFunction,
- data
-)
- return modbusPDUDiagnosticRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUDiagnosticRequestBuilder(ModbusPDUModbusPDUBuilder: subFunction: c_uint16 data: c_uint16def ModbusPDUDiagnosticRequestBuilder( c_uint16 subFunction, c_uint16 data ): self.subFunction = subFunction
+ self.data = data
+
+
+ def build(
+ ) -> ModbusPDUDiagnosticRequest:
+ modbusPDUDiagnosticRequest: ModbusPDUDiagnosticRequest = ModbusPDUDiagnosticRequest(
+ subFunction,
+ data
+)
+ return modbusPDUDiagnosticRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
index 02556ed834..8338e2f9c1 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUDiagnosticResponse(PlcMessage,ModbusPDU):
- subFunction: int
- data: int
+ subFunction: c_uint16
+ data: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x08
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x08
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getSubFunction(self) -> int:
+ def getSubFunction(self) -> c_uint16:
return subFunction
- def getData(self) -> int:
+ def getData(self) -> c_uint16:
return data
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUDiagnosticResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUDiagnosticResponseBuilder:
readBuffer.pullContext("ModbusPDUDiagnosticResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- subFunction: int = readSimpleField("subFunction", readUnsignedInt(readBuffer, 16))
+ subFunction: c_uint16 = readSimpleField("subFunction", readUnsignedInt(readBuffer, 16))
- data: int = readSimpleField("data", readUnsignedInt(readBuffer, 16))
+ data: c_uint16 = readSimpleField("data", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUDiagnosticResponse")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUDiagnosticResponseBuilder(ModbusPDUModbusPDUBuilder {
- subFunction: int
- data: int
-
- def ModbusPDUDiagnosticResponseBuilder(
- int subFunction,
- int data
-
- ):
- self.subFunction = subFunction
- self.data = data
-
-
- def build(
- ) -> ModbusPDUDiagnosticResponse:
- modbusPDUDiagnosticResponse: ModbusPDUDiagnosticResponse = ModbusPDUDiagnosticResponse(
- subFunction,
- data
-)
- return modbusPDUDiagnosticResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUDiagnosticResponseBuilder(ModbusPDUModbusPDUBuilder: subFunction: c_uint16 data: c_uint16def ModbusPDUDiagnosticResponseBuilder( c_uint16 subFunction, c_uint16 data ): self.subFunction = subFunction
+ self.data = data
+
+
+ def build(
+ ) -> ModbusPDUDiagnosticResponse:
+ modbusPDUDiagnosticResponse: ModbusPDUDiagnosticResponse = ModbusPDUDiagnosticResponse(
+ subFunction,
+ data
+)
+ return modbusPDUDiagnosticResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
index f7ecbe974f..89eb0ff9b2 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
@@ -28,14 +28,14 @@ class ModbusPDUError(PlcMessage,ModbusPDU):
exceptionCode: ModbusErrorCode
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) true
+ def c_bool getErrorFlag() {
+ return (c_bool) true
}
- def Short getFunctionFlag() {
+ def c_uint8 getFunctionFlag() {
return 0
}
- def Boolean getResponse() {
- return false
+ def c_bool getResponse() {
+ return False
}
@@ -73,7 +73,7 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUErrorBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUErrorBuilder:
readBuffer.pullContext("ModbusPDUError")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -88,23 +88,6 @@ super().__init__( )
)
- class ModbusPDUErrorBuilder(ModbusPDUModbusPDUBuilder {
- exceptionCode: ModbusErrorCode
-
- def ModbusPDUErrorBuilder(
- ModbusErrorCode exceptionCode
-
- ):
- self.exceptionCode = exceptionCode
-
-
- def build(
- ) -> ModbusPDUError:
- modbusPDUError: ModbusPDUError = ModbusPDUError(
- exceptionCode
-)
- return modbusPDUError
-
def equals(self, o: object) -> bool:
if this == o:
@@ -134,3 +117,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUErrorBuilder(ModbusPDUModbusPDUBuilder: exceptionCode: ModbusErrorCodedef ModbusPDUErrorBuilder( ModbusErrorCode exceptionCode ): self.exceptionCode = exceptionCode
+
+
+ def build(
+ ) -> ModbusPDUError:
+ modbusPDUError: ModbusPDUError = ModbusPDUError(
+ exceptionCode
+)
+ return modbusPDUError
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
index ea097bc7ef..19a2fa3f30 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterRequest.py
@@ -27,14 +27,14 @@ from dataclasses import dataclass
class ModbusPDUGetComEventCounterRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x0B
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x0B
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -62,7 +62,7 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUGetComEventCounterRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventCounterRequestBuilder:
readBuffer.pullContext("ModbusPDUGetComEventCounterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -74,19 +74,6 @@ super().__init__( )
)
- class ModbusPDUGetComEventCounterRequestBuilder(ModbusPDUModbusPDUBuilder {
-
- def ModbusPDUGetComEventCounterRequestBuilder(
-
- ):
-
-
- def build(
- ) -> ModbusPDUGetComEventCounterRequest:
- modbusPDUGetComEventCounterRequest: ModbusPDUGetComEventCounterRequest = ModbusPDUGetComEventCounterRequest(
-)
- return modbusPDUGetComEventCounterRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -114,3 +101,13 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUGetComEventCounterRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUGetComEventCounterRequestBuilder( ):
+
+ def build(
+ ) -> ModbusPDUGetComEventCounterRequest:
+ modbusPDUGetComEventCounterRequest: ModbusPDUGetComEventCounterRequest = ModbusPDUGetComEventCounterRequest(
+)
+ return modbusPDUGetComEventCounterRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
index 6f911c9ead..7d4597cc89 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUGetComEventCounterResponse(PlcMessage,ModbusPDU):
- status: int
- eventCount: int
+ status: c_uint16
+ eventCount: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x0B
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x0B
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getStatus(self) -> int:
+ def getStatus(self) -> c_uint16:
return status
- def getEventCount(self) -> int:
+ def getEventCount(self) -> c_uint16:
return eventCount
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUGetComEventCounterResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventCounterResponseBuilder:
readBuffer.pullContext("ModbusPDUGetComEventCounterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- status: int = readSimpleField("status", readUnsignedInt(readBuffer, 16))
+ status: c_uint16 = readSimpleField("status", readUnsignedInt(readBuffer, 16))
- eventCount: int = readSimpleField("eventCount", readUnsignedInt(readBuffer, 16))
+ eventCount: c_uint16 = readSimpleField("eventCount", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUGetComEventCounterResponse")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUGetComEventCounterResponseBuilder(ModbusPDUModbusPDUBuilder {
- status: int
- eventCount: int
-
- def ModbusPDUGetComEventCounterResponseBuilder(
- int status,
- int eventCount
-
- ):
- self.status = status
- self.eventCount = eventCount
-
-
- def build(
- ) -> ModbusPDUGetComEventCounterResponse:
- modbusPDUGetComEventCounterResponse: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(
- status,
- eventCount
-)
- return modbusPDUGetComEventCounterResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUGetComEventCounterResponseBuilder(ModbusPDUModbusPDUBuilder: status: c_uint16 eventCount: c_uint16def ModbusPDUGetComEventCounterResponseBuilder( c_uint16 status, c_uint16 eventCount ): self.status = status
+ self.eventCount = eventCount
+
+
+ def build(
+ ) -> ModbusPDUGetComEventCounterResponse:
+ modbusPDUGetComEventCounterResponse: ModbusPDUGetComEventCounterResponse = ModbusPDUGetComEventCounterResponse(
+ status,
+ eventCount
+)
+ return modbusPDUGetComEventCounterResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
index 4a8bdfc22e..a021f89d18 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogRequest.py
@@ -27,14 +27,14 @@ from dataclasses import dataclass
class ModbusPDUGetComEventLogRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x0C
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x0C
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -62,7 +62,7 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUGetComEventLogRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventLogRequestBuilder:
readBuffer.pullContext("ModbusPDUGetComEventLogRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -74,19 +74,6 @@ super().__init__( )
)
- class ModbusPDUGetComEventLogRequestBuilder(ModbusPDUModbusPDUBuilder {
-
- def ModbusPDUGetComEventLogRequestBuilder(
-
- ):
-
-
- def build(
- ) -> ModbusPDUGetComEventLogRequest:
- modbusPDUGetComEventLogRequest: ModbusPDUGetComEventLogRequest = ModbusPDUGetComEventLogRequest(
-)
- return modbusPDUGetComEventLogRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -114,3 +101,13 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUGetComEventLogRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUGetComEventLogRequestBuilder( ):
+
+ def build(
+ ) -> ModbusPDUGetComEventLogRequest:
+ modbusPDUGetComEventLogRequest: ModbusPDUGetComEventLogRequest = ModbusPDUGetComEventLogRequest(
+)
+ return modbusPDUGetComEventLogRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
index cfb246a453..33d4163795 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
@@ -25,20 +25,20 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUGetComEventLogResponse(PlcMessage,ModbusPDU):
- status: int
- eventCount: int
- messageCount: int
- events: byte[]
+ status: c_uint16
+ eventCount: c_uint16
+ messageCount: c_uint16
+ events: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x0C
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x0C
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -47,16 +47,16 @@ super().__init__( )
- def getStatus(self) -> int:
+ def getStatus(self) -> c_uint16:
return status
- def getEventCount(self) -> int:
+ def getEventCount(self) -> c_uint16:
return eventCount
- def getMessageCount(self) -> int:
+ def getMessageCount(self) -> c_uint16:
return messageCount
- def getEvents(self) -> byte[]:
+ def getEvents(self) -> []c_byte:
return events
@@ -66,7 +66,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUGetComEventLogResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) ((COUNT(getEvents())) + (6))
+ c_uint8 byteCount = (c_uint8) ((COUNT(getEvents())) + (6))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Simple Field (status)
@@ -111,19 +111,19 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUGetComEventLogResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUGetComEventLogResponseBuilder:
readBuffer.pullContext("ModbusPDUGetComEventLogResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
- status: int = readSimpleField("status", readUnsignedInt(readBuffer, 16))
+ status: c_uint16 = readSimpleField("status", readUnsignedInt(readBuffer, 16))
- eventCount: int = readSimpleField("eventCount", readUnsignedInt(readBuffer, 16))
+ eventCount: c_uint16 = readSimpleField("eventCount", readUnsignedInt(readBuffer, 16))
- messageCount: int = readSimpleField("messageCount", readUnsignedInt(readBuffer, 16))
+ messageCount: c_uint16 = readSimpleField("messageCount", readUnsignedInt(readBuffer, 16))
events: byte[] = readBuffer.readByteArray("events", Math.toIntExact((byteCount) - (6)))
@@ -137,35 +137,6 @@ super().__init__( )
)
- class ModbusPDUGetComEventLogResponseBuilder(ModbusPDUModbusPDUBuilder {
- status: int
- eventCount: int
- messageCount: int
- events: byte[]
-
- def ModbusPDUGetComEventLogResponseBuilder(
- int status,
- int eventCount,
- int messageCount,
- byte[] events
-
- ):
- self.status = status
- self.eventCount = eventCount
- self.messageCount = messageCount
- self.events = events
-
-
- def build(
- ) -> ModbusPDUGetComEventLogResponse:
- modbusPDUGetComEventLogResponse: ModbusPDUGetComEventLogResponse = ModbusPDUGetComEventLogResponse(
- status,
- eventCount,
- messageCount,
- events
-)
- return modbusPDUGetComEventLogResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -201,3 +172,21 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUGetComEventLogResponseBuilder(ModbusPDUModbusPDUBuilder: status: c_uint16 eventCount: c_uint16 messageCount: c_uint16 events: []c_bytedef ModbusPDUGetComEventLogResponseBuilder( c_uint16 status, c_uint16 eventCount, c_uint16 messageCount, []c_byte events ): self.status = status
+ self.eventCount = eventCount
+ self.messageCount = messageCount
+ self.events = events
+
+
+ def build(
+ ) -> ModbusPDUGetComEventLogResponse:
+ modbusPDUGetComEventLogResponse: ModbusPDUGetComEventLogResponse = ModbusPDUGetComEventLogResponse(
+ status,
+ eventCount,
+ messageCount,
+ events
+)
+ return modbusPDUGetComEventLogResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
index 53a1e1c2f4..69129809c7 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
@@ -25,19 +25,19 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage,ModbusPDU):
- referenceAddress: int
- andMask: int
- orMask: int
+ referenceAddress: c_uint16
+ andMask: c_uint16
+ orMask: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x16
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x16
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -46,13 +46,13 @@ super().__init__( )
- def getReferenceAddress(self) -> int:
+ def getReferenceAddress(self) -> c_uint16:
return referenceAddress
- def getAndMask(self) -> int:
+ def getAndMask(self) -> c_uint16:
return andMask
- def getOrMask(self) -> int:
+ def getOrMask(self) -> c_uint16:
return orMask
@@ -92,17 +92,17 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUMaskWriteHoldingRegisterRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUMaskWriteHoldingRegisterRequestBuilder:
readBuffer.pullContext("ModbusPDUMaskWriteHoldingRegisterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceAddress: int = readSimpleField("referenceAddress", readUnsignedInt(readBuffer, 16))
+ referenceAddress: c_uint16 = readSimpleField("referenceAddress", readUnsignedInt(readBuffer, 16))
- andMask: int = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
+ andMask: c_uint16 = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
- orMask: int = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
+ orMask: c_uint16 = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterRequest")
# Create the instance
@@ -113,31 +113,6 @@ super().__init__( )
)
- class ModbusPDUMaskWriteHoldingRegisterRequestBuilder(ModbusPDUModbusPDUBuilder {
- referenceAddress: int
- andMask: int
- orMask: int
-
- def ModbusPDUMaskWriteHoldingRegisterRequestBuilder(
- int referenceAddress,
- int andMask,
- int orMask
-
- ):
- self.referenceAddress = referenceAddress
- self.andMask = andMask
- self.orMask = orMask
-
-
- def build(
- ) -> ModbusPDUMaskWriteHoldingRegisterRequest:
- modbusPDUMaskWriteHoldingRegisterRequest: ModbusPDUMaskWriteHoldingRegisterRequest = ModbusPDUMaskWriteHoldingRegisterRequest(
- referenceAddress,
- andMask,
- orMask
-)
- return modbusPDUMaskWriteHoldingRegisterRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -171,3 +146,19 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUMaskWriteHoldingRegisterRequestBuilder(ModbusPDUModbusPDUBuilder: referenceAddress: c_uint16 andMask: c_uint16 orMask: c_uint16def ModbusPDUMaskWriteHoldingRegisterRequestBuilder( c_uint16 referenceAddress, c_uint16 andMask, c_uint16 orMask ): self.referenceAddress = referenceAddress
+ self.andMask = andMask
+ self.orMask = orMask
+
+
+ def build(
+ ) -> ModbusPDUMaskWriteHoldingRegisterRequest:
+ modbusPDUMaskWriteHoldingRegisterRequest: ModbusPDUMaskWriteHoldingRegisterRequest = ModbusPDUMaskWriteHoldingRegisterRequest(
+ referenceAddress,
+ andMask,
+ orMask
+)
+ return modbusPDUMaskWriteHoldingRegisterRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
index 287e51656a..7d5b2d8f38 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
@@ -25,19 +25,19 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage,ModbusPDU):
- referenceAddress: int
- andMask: int
- orMask: int
+ referenceAddress: c_uint16
+ andMask: c_uint16
+ orMask: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x16
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x16
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -46,13 +46,13 @@ super().__init__( )
- def getReferenceAddress(self) -> int:
+ def getReferenceAddress(self) -> c_uint16:
return referenceAddress
- def getAndMask(self) -> int:
+ def getAndMask(self) -> c_uint16:
return andMask
- def getOrMask(self) -> int:
+ def getOrMask(self) -> c_uint16:
return orMask
@@ -92,17 +92,17 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUMaskWriteHoldingRegisterResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUMaskWriteHoldingRegisterResponseBuilder:
readBuffer.pullContext("ModbusPDUMaskWriteHoldingRegisterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceAddress: int = readSimpleField("referenceAddress", readUnsignedInt(readBuffer, 16))
+ referenceAddress: c_uint16 = readSimpleField("referenceAddress", readUnsignedInt(readBuffer, 16))
- andMask: int = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
+ andMask: c_uint16 = readSimpleField("andMask", readUnsignedInt(readBuffer, 16))
- orMask: int = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
+ orMask: c_uint16 = readSimpleField("orMask", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUMaskWriteHoldingRegisterResponse")
# Create the instance
@@ -113,31 +113,6 @@ super().__init__( )
)
- class ModbusPDUMaskWriteHoldingRegisterResponseBuilder(ModbusPDUModbusPDUBuilder {
- referenceAddress: int
- andMask: int
- orMask: int
-
- def ModbusPDUMaskWriteHoldingRegisterResponseBuilder(
- int referenceAddress,
- int andMask,
- int orMask
-
- ):
- self.referenceAddress = referenceAddress
- self.andMask = andMask
- self.orMask = orMask
-
-
- def build(
- ) -> ModbusPDUMaskWriteHoldingRegisterResponse:
- modbusPDUMaskWriteHoldingRegisterResponse: ModbusPDUMaskWriteHoldingRegisterResponse = ModbusPDUMaskWriteHoldingRegisterResponse(
- referenceAddress,
- andMask,
- orMask
-)
- return modbusPDUMaskWriteHoldingRegisterResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -171,3 +146,19 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUMaskWriteHoldingRegisterResponseBuilder(ModbusPDUModbusPDUBuilder: referenceAddress: c_uint16 andMask: c_uint16 orMask: c_uint16def ModbusPDUMaskWriteHoldingRegisterResponseBuilder( c_uint16 referenceAddress, c_uint16 andMask, c_uint16 orMask ): self.referenceAddress = referenceAddress
+ self.andMask = andMask
+ self.orMask = orMask
+
+
+ def build(
+ ) -> ModbusPDUMaskWriteHoldingRegisterResponse:
+ modbusPDUMaskWriteHoldingRegisterResponse: ModbusPDUMaskWriteHoldingRegisterResponse = ModbusPDUMaskWriteHoldingRegisterResponse(
+ referenceAddress,
+ andMask,
+ orMask
+)
+ return modbusPDUMaskWriteHoldingRegisterResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
index f57d794c05..e58c96de32 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadCoilsRequest(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x01
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x01
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadCoilsRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadCoilsRequestBuilder:
readBuffer.pullContext("ModbusPDUReadCoilsRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUReadCoilsRequest")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUReadCoilsRequestBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
-
- def ModbusPDUReadCoilsRequestBuilder(
- int startingAddress,
- int quantity
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
-
-
- def build(
- ) -> ModbusPDUReadCoilsRequest:
- modbusPDUReadCoilsRequest: ModbusPDUReadCoilsRequest = ModbusPDUReadCoilsRequest(
- startingAddress,
- quantity
-)
- return modbusPDUReadCoilsRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadCoilsRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadCoilsRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
+ self.quantity = quantity
+
+
+ def build(
+ ) -> ModbusPDUReadCoilsRequest:
+ modbusPDUReadCoilsRequest: ModbusPDUReadCoilsRequest = ModbusPDUReadCoilsRequest(
+ startingAddress,
+ quantity
+)
+ return modbusPDUReadCoilsRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
index f12d2bcdf3..de9f3b1b8d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadCoilsResponse(PlcMessage,ModbusPDU):
- value: byte[]
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x01
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x01
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadCoilsResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -81,13 +81,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadCoilsResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadCoilsResponseBuilder:
readBuffer.pullContext("ModbusPDUReadCoilsResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -98,23 +98,6 @@ super().__init__( )
)
- class ModbusPDUReadCoilsResponseBuilder(ModbusPDUModbusPDUBuilder {
- value: byte[]
-
- def ModbusPDUReadCoilsResponseBuilder(
- byte[] value
-
- ):
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReadCoilsResponse:
- modbusPDUReadCoilsResponse: ModbusPDUReadCoilsResponse = ModbusPDUReadCoilsResponse(
- value
-)
- return modbusPDUReadCoilsResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -144,3 +127,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadCoilsResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadCoilsResponseBuilder( []c_byte value ): self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReadCoilsResponse:
+ modbusPDUReadCoilsResponse: ModbusPDUReadCoilsResponse = ModbusPDUReadCoilsResponse(
+ value
+)
+ return modbusPDUReadCoilsResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
index 8ce9eb87dd..edb10be80a 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
@@ -26,18 +26,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadDeviceIdentificationRequest(PlcMessage,ModbusPDU):
level: ModbusDeviceInformationLevel
- objectId: short
- MEITYPE: Short = 0x0E
+ objectId: c_uint8
+ MEITYPE: c_uint8 = 0x0E
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x2B
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x2B
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -49,10 +49,10 @@ super().__init__( )
def getLevel(self) -> ModbusDeviceInformationLevel:
return level
- def getObjectId(self) -> short:
+ def getObjectId(self) -> c_uint8:
return objectId
- def getMeiType(self) -> short:
+ def getMeiType(self) -> c_uint8:
return MEITYPE
@@ -93,17 +93,17 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadDeviceIdentificationRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDeviceIdentificationRequestBuilder:
readBuffer.pullContext("ModbusPDUReadDeviceIdentificationRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- meiType: short = 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)))
- objectId: short = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
+ objectId: c_uint8 = readSimpleField("objectId", readUnsignedShort(readBuffer, 8))
readBuffer.closeContext("ModbusPDUReadDeviceIdentificationRequest")
# Create the instance
@@ -113,27 +113,6 @@ super().__init__( )
)
- class ModbusPDUReadDeviceIdentificationRequestBuilder(ModbusPDUModbusPDUBuilder {
- level: ModbusDeviceInformationLevel
- objectId: short
-
- def ModbusPDUReadDeviceIdentificationRequestBuilder(
- ModbusDeviceInformationLevel level,
- short objectId
-
- ):
- self.level = level
- self.objectId = objectId
-
-
- def build(
- ) -> ModbusPDUReadDeviceIdentificationRequest:
- modbusPDUReadDeviceIdentificationRequest: ModbusPDUReadDeviceIdentificationRequest = ModbusPDUReadDeviceIdentificationRequest(
- level,
- objectId
-)
- return modbusPDUReadDeviceIdentificationRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -165,3 +144,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadDeviceIdentificationRequestBuilder(ModbusPDUModbusPDUBuilder: level: ModbusDeviceInformationLevel objectId: c_uint8def ModbusPDUReadDeviceIdentificationRequestBuilder( ModbusDeviceInformationLevel level, c_uint8 objectId ): self.level = level
+ self.objectId = objectId
+
+
+ def build(
+ ) -> ModbusPDUReadDeviceIdentificationRequest:
+ modbusPDUReadDeviceIdentificationRequest: ModbusPDUReadDeviceIdentificationRequest = ModbusPDUReadDeviceIdentificationRequest(
+ level,
+ objectId
+)
+ return modbusPDUReadDeviceIdentificationRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
index edb69b3a8c..0746e072a8 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
@@ -26,22 +26,22 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadDeviceIdentificationResponse(PlcMessage,ModbusPDU):
level: ModbusDeviceInformationLevel
- individualAccess: boolean
+ individualAccess: c_bool
conformityLevel: ModbusDeviceInformationConformityLevel
moreFollows: ModbusDeviceInformationMoreFollows
- nextObjectId: short
- objects: List<ModbusDeviceInformationObject>
- MEITYPE: Short = 0x0E
+ nextObjectId: c_uint8
+ objects: []ModbusDeviceInformationObject
+ MEITYPE: c_uint8 = 0x0E
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x2B
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x2B
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -53,7 +53,7 @@ super().__init__( )
def getLevel(self) -> ModbusDeviceInformationLevel:
return level
- def getIndividualAccess(self) -> boolean:
+ def getIndividualAccess(self) -> c_bool:
return individualAccess
def getConformityLevel(self) -> ModbusDeviceInformationConformityLevel:
@@ -62,13 +62,13 @@ super().__init__( )
def getMoreFollows(self) -> ModbusDeviceInformationMoreFollows:
return moreFollows
- def getNextObjectId(self) -> short:
+ def getNextObjectId(self) -> c_uint8:
return nextObjectId
- def getObjects(self) -> List<ModbusDeviceInformationObject>:
+ def getObjects(self) -> []ModbusDeviceInformationObject:
return objects
- def getMeiType(self) -> short:
+ def getMeiType(self) -> c_uint8:
return MEITYPE
@@ -99,7 +99,7 @@ super().__init__( )
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)
- short numberOfObjects = (short) (COUNT(getObjects()))
+ c_uint8 numberOfObjects = (c_uint8) (COUNT(getObjects()))
writeImplicitField("numberOfObjects", numberOfObjects, writeUnsignedShort(writeBuffer, 8))
# Array Field (objects)
@@ -148,27 +148,27 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadDeviceIdentificationResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDeviceIdentificationResponseBuilder:
readBuffer.pullContext("ModbusPDUReadDeviceIdentificationResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- meiType: short = 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)))
- individualAccess: boolean = readSimpleField("individualAccess", readBoolean(readBuffer))
+ individualAccess: c_bool = readSimpleField("individualAccess", readBoolean(readBuffer))
conformityLevel: ModbusDeviceInformationConformityLevel = readEnumField("conformityLevel", "ModbusDeviceInformationConformityLevel", new DataReaderEnumDefault<>(ModbusDeviceInformationConformityLevel::enumForValue, readUnsignedShort(readBuffer, 7)))
moreFollows: ModbusDeviceInformationMoreFollows = readEnumField("moreFollows", "ModbusDeviceInformationMoreFollows", new DataReaderEnumDefault<>(ModbusDeviceInformationMoreFollows::enumForValue, readUnsignedShort(readBuffer, 8)))
- nextObjectId: short = readSimpleField("nextObjectId", readUnsignedShort(readBuffer, 8))
+ nextObjectId: c_uint8 = readSimpleField("nextObjectId", readUnsignedShort(readBuffer, 8))
- numberOfObjects: short = readImplicitField("numberOfObjects", readUnsignedShort(readBuffer, 8))
+ numberOfObjects: c_uint8 = readImplicitField("numberOfObjects", readUnsignedShort(readBuffer, 8))
- objects: List<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
@@ -182,43 +182,6 @@ super().__init__( )
)
- class ModbusPDUReadDeviceIdentificationResponseBuilder(ModbusPDUModbusPDUBuilder {
- level: ModbusDeviceInformationLevel
- individualAccess: boolean
- conformityLevel: ModbusDeviceInformationConformityLevel
- moreFollows: ModbusDeviceInformationMoreFollows
- nextObjectId: short
- objects: List<ModbusDeviceInformationObject>
-
- def ModbusPDUReadDeviceIdentificationResponseBuilder(
- ModbusDeviceInformationLevel level,
- boolean individualAccess,
- ModbusDeviceInformationConformityLevel conformityLevel,
- ModbusDeviceInformationMoreFollows moreFollows,
- short nextObjectId,
- List<ModbusDeviceInformationObject> objects
-
- ):
- self.level = level
- self.individualAccess = individualAccess
- self.conformityLevel = conformityLevel
- self.moreFollows = moreFollows
- self.nextObjectId = nextObjectId
- self.objects = objects
-
-
- def build(
- ) -> ModbusPDUReadDeviceIdentificationResponse:
- modbusPDUReadDeviceIdentificationResponse: ModbusPDUReadDeviceIdentificationResponse = ModbusPDUReadDeviceIdentificationResponse(
- level,
- individualAccess,
- conformityLevel,
- moreFollows,
- nextObjectId,
- objects
-)
- return modbusPDUReadDeviceIdentificationResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -258,3 +221,25 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadDeviceIdentificationResponseBuilder(ModbusPDUModbusPDUBuilder: level: ModbusDeviceInformationLevel individualAccess: c_bool conformityLevel: ModbusDeviceInformationConformityLevel moreFollows: ModbusDeviceInformationMoreFollows nextObjectId: c_uint8 objects: []ModbusDeviceInformationObjectdef ModbusPDUReadDeviceIdentificationResponseBuilder( ModbusDeviceInformationLevel level, c_bool individualAccess, ModbusDeviceInformationConformityLevel conformityLevel, ModbusDevice [...]
+ self.individualAccess = individualAccess
+ self.conformityLevel = conformityLevel
+ self.moreFollows = moreFollows
+ self.nextObjectId = nextObjectId
+ self.objects = objects
+
+
+ def build(
+ ) -> ModbusPDUReadDeviceIdentificationResponse:
+ modbusPDUReadDeviceIdentificationResponse: ModbusPDUReadDeviceIdentificationResponse = ModbusPDUReadDeviceIdentificationResponse(
+ level,
+ individualAccess,
+ conformityLevel,
+ moreFollows,
+ nextObjectId,
+ objects
+)
+ return modbusPDUReadDeviceIdentificationResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
index 02f20e92ac..13efd277c0 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadDiscreteInputsRequest(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x02
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x02
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadDiscreteInputsRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDiscreteInputsRequestBuilder:
readBuffer.pullContext("ModbusPDUReadDiscreteInputsRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUReadDiscreteInputsRequest")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUReadDiscreteInputsRequestBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
-
- def ModbusPDUReadDiscreteInputsRequestBuilder(
- int startingAddress,
- int quantity
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
-
-
- def build(
- ) -> ModbusPDUReadDiscreteInputsRequest:
- modbusPDUReadDiscreteInputsRequest: ModbusPDUReadDiscreteInputsRequest = ModbusPDUReadDiscreteInputsRequest(
- startingAddress,
- quantity
-)
- return modbusPDUReadDiscreteInputsRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadDiscreteInputsRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadDiscreteInputsRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
+ self.quantity = quantity
+
+
+ def build(
+ ) -> ModbusPDUReadDiscreteInputsRequest:
+ modbusPDUReadDiscreteInputsRequest: ModbusPDUReadDiscreteInputsRequest = ModbusPDUReadDiscreteInputsRequest(
+ startingAddress,
+ quantity
+)
+ return modbusPDUReadDiscreteInputsRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
index 1fa4d3677b..5f413e91b0 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadDiscreteInputsResponse(PlcMessage,ModbusPDU):
- value: byte[]
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x02
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x02
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadDiscreteInputsResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -81,13 +81,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadDiscreteInputsResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadDiscreteInputsResponseBuilder:
readBuffer.pullContext("ModbusPDUReadDiscreteInputsResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -98,23 +98,6 @@ super().__init__( )
)
- class ModbusPDUReadDiscreteInputsResponseBuilder(ModbusPDUModbusPDUBuilder {
- value: byte[]
-
- def ModbusPDUReadDiscreteInputsResponseBuilder(
- byte[] value
-
- ):
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReadDiscreteInputsResponse:
- modbusPDUReadDiscreteInputsResponse: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(
- value
-)
- return modbusPDUReadDiscreteInputsResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -144,3 +127,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadDiscreteInputsResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadDiscreteInputsResponseBuilder( []c_byte value ): self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReadDiscreteInputsResponse:
+ modbusPDUReadDiscreteInputsResponse: ModbusPDUReadDiscreteInputsResponse = ModbusPDUReadDiscreteInputsResponse(
+ value
+)
+ return modbusPDUReadDiscreteInputsResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
index f2b7b8f512..a73da93018 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusRequest.py
@@ -27,14 +27,14 @@ from dataclasses import dataclass
class ModbusPDUReadExceptionStatusRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x07
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x07
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -62,7 +62,7 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadExceptionStatusRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadExceptionStatusRequestBuilder:
readBuffer.pullContext("ModbusPDUReadExceptionStatusRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -74,19 +74,6 @@ super().__init__( )
)
- class ModbusPDUReadExceptionStatusRequestBuilder(ModbusPDUModbusPDUBuilder {
-
- def ModbusPDUReadExceptionStatusRequestBuilder(
-
- ):
-
-
- def build(
- ) -> ModbusPDUReadExceptionStatusRequest:
- modbusPDUReadExceptionStatusRequest: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest(
-)
- return modbusPDUReadExceptionStatusRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -114,3 +101,13 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadExceptionStatusRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUReadExceptionStatusRequestBuilder( ):
+
+ def build(
+ ) -> ModbusPDUReadExceptionStatusRequest:
+ modbusPDUReadExceptionStatusRequest: ModbusPDUReadExceptionStatusRequest = ModbusPDUReadExceptionStatusRequest(
+)
+ return modbusPDUReadExceptionStatusRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
index d111e3e43b..19156ab831 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadExceptionStatusResponse(PlcMessage,ModbusPDU):
- value: short
+ value: c_uint8
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x07
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x07
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getValue(self) -> short:
+ def getValue(self) -> c_uint8:
return value
@@ -72,13 +72,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadExceptionStatusResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadExceptionStatusResponseBuilder:
readBuffer.pullContext("ModbusPDUReadExceptionStatusResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- value: short = readSimpleField("value", readUnsignedShort(readBuffer, 8))
+ value: c_uint8 = readSimpleField("value", readUnsignedShort(readBuffer, 8))
readBuffer.closeContext("ModbusPDUReadExceptionStatusResponse")
# Create the instance
@@ -87,23 +87,6 @@ super().__init__( )
)
- class ModbusPDUReadExceptionStatusResponseBuilder(ModbusPDUModbusPDUBuilder {
- value: short
-
- def ModbusPDUReadExceptionStatusResponseBuilder(
- short value
-
- ):
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReadExceptionStatusResponse:
- modbusPDUReadExceptionStatusResponse: ModbusPDUReadExceptionStatusResponse = ModbusPDUReadExceptionStatusResponse(
- value
-)
- return modbusPDUReadExceptionStatusResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -133,3 +116,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadExceptionStatusResponseBuilder(ModbusPDUModbusPDUBuilder: value: c_uint8def ModbusPDUReadExceptionStatusResponseBuilder( c_uint8 value ): self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReadExceptionStatusResponse:
+ modbusPDUReadExceptionStatusResponse: ModbusPDUReadExceptionStatusResponse = ModbusPDUReadExceptionStatusResponse(
+ value
+)
+ return modbusPDUReadExceptionStatusResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
index c5957665e7..82a4c73c65 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadFifoQueueRequest(PlcMessage,ModbusPDU):
- fifoPointerAddress: int
+ fifoPointerAddress: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x18
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x18
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getFifoPointerAddress(self) -> int:
+ def getFifoPointerAddress(self) -> c_uint16:
return fifoPointerAddress
@@ -72,13 +72,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadFifoQueueRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFifoQueueRequestBuilder:
readBuffer.pullContext("ModbusPDUReadFifoQueueRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- fifoPointerAddress: int = readSimpleField("fifoPointerAddress", readUnsignedInt(readBuffer, 16))
+ fifoPointerAddress: c_uint16 = readSimpleField("fifoPointerAddress", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUReadFifoQueueRequest")
# Create the instance
@@ -87,23 +87,6 @@ super().__init__( )
)
- class ModbusPDUReadFifoQueueRequestBuilder(ModbusPDUModbusPDUBuilder {
- fifoPointerAddress: int
-
- def ModbusPDUReadFifoQueueRequestBuilder(
- int fifoPointerAddress
-
- ):
- self.fifoPointerAddress = fifoPointerAddress
-
-
- def build(
- ) -> ModbusPDUReadFifoQueueRequest:
- modbusPDUReadFifoQueueRequest: ModbusPDUReadFifoQueueRequest = ModbusPDUReadFifoQueueRequest(
- fifoPointerAddress
-)
- return modbusPDUReadFifoQueueRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -133,3 +116,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadFifoQueueRequestBuilder(ModbusPDUModbusPDUBuilder: fifoPointerAddress: c_uint16def ModbusPDUReadFifoQueueRequestBuilder( c_uint16 fifoPointerAddress ): self.fifoPointerAddress = fifoPointerAddress
+
+
+ def build(
+ ) -> ModbusPDUReadFifoQueueRequest:
+ modbusPDUReadFifoQueueRequest: ModbusPDUReadFifoQueueRequest = ModbusPDUReadFifoQueueRequest(
+ fifoPointerAddress
+)
+ return modbusPDUReadFifoQueueRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
index 85c96b36da..70abbdda1a 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadFifoQueueResponse(PlcMessage,ModbusPDU):
- fifoValue: List<Integer>
+ fifoValue: []c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x18
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x18
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getFifoValue(self) -> List<Integer>:
+ def getFifoValue(self) -> []c_uint16:
return fifoValue
@@ -54,11 +54,11 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadFifoQueueResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- int byteCount = (int) ((((COUNT(getFifoValue())) * (2))) + (2))
+ 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)
- int fifoCount = (int) ((((COUNT(getFifoValue())) * (2))) / (2))
+ c_uint16 fifoCount = (c_uint16) ((((COUNT(getFifoValue())) * (2))) / (2))
writeImplicitField("fifoCount", fifoCount, writeUnsignedInt(writeBuffer, 16))
# Array Field (fifoValue)
@@ -88,17 +88,17 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadFifoQueueResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFifoQueueResponseBuilder:
readBuffer.pullContext("ModbusPDUReadFifoQueueResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: int = readImplicitField("byteCount", readUnsignedInt(readBuffer, 16))
+ byteCount: c_uint16 = readImplicitField("byteCount", readUnsignedInt(readBuffer, 16))
- fifoCount: int = readImplicitField("fifoCount", readUnsignedInt(readBuffer, 16))
+ fifoCount: c_uint16 = readImplicitField("fifoCount", readUnsignedInt(readBuffer, 16))
- fifoValue: List<Integer> = readCountArrayField("fifoValue", readUnsignedInt(readBuffer, 16), fifoCount)
+ fifoValue: []c_uint16 = readCountArrayField("fifoValue", readUnsignedInt(readBuffer, 16), fifoCount)
readBuffer.closeContext("ModbusPDUReadFifoQueueResponse")
# Create the instance
@@ -107,23 +107,6 @@ super().__init__( )
)
- class ModbusPDUReadFifoQueueResponseBuilder(ModbusPDUModbusPDUBuilder {
- fifoValue: List<Integer>
-
- def ModbusPDUReadFifoQueueResponseBuilder(
- List<Integer> fifoValue
-
- ):
- self.fifoValue = fifoValue
-
-
- def build(
- ) -> ModbusPDUReadFifoQueueResponse:
- modbusPDUReadFifoQueueResponse: ModbusPDUReadFifoQueueResponse = ModbusPDUReadFifoQueueResponse(
- fifoValue
-)
- return modbusPDUReadFifoQueueResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -153,3 +136,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadFifoQueueResponseBuilder(ModbusPDUModbusPDUBuilder: fifoValue: []c_uint16def ModbusPDUReadFifoQueueResponseBuilder( []c_uint16 fifoValue ): self.fifoValue = fifoValue
+
+
+ def build(
+ ) -> ModbusPDUReadFifoQueueResponse:
+ modbusPDUReadFifoQueueResponse: ModbusPDUReadFifoQueueResponse = ModbusPDUReadFifoQueueResponse(
+ fifoValue
+)
+ return modbusPDUReadFifoQueueResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
index aef470570f..f4f69f796a 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadFileRecordRequest(PlcMessage,ModbusPDU):
- items: List<ModbusPDUReadFileRecordRequestItem>
+ items: []ModbusPDUReadFileRecordRequestItem
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x14
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x14
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getItems(self) -> List<ModbusPDUReadFileRecordRequestItem>:
+ def getItems(self) -> []ModbusPDUReadFileRecordRequestItem:
return items
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadFileRecordRequest")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (ARRAY_SIZE_IN_BYTES(getItems()))
+ c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -83,15 +83,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadFileRecordRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFileRecordRequestBuilder:
readBuffer.pullContext("ModbusPDUReadFileRecordRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
- items: List<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
@@ -100,23 +100,6 @@ super().__init__( )
)
- class ModbusPDUReadFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder {
- items: List<ModbusPDUReadFileRecordRequestItem>
-
- def ModbusPDUReadFileRecordRequestBuilder(
- List<ModbusPDUReadFileRecordRequestItem> items
-
- ):
- self.items = items
-
-
- def build(
- ) -> ModbusPDUReadFileRecordRequest:
- modbusPDUReadFileRecordRequest: ModbusPDUReadFileRecordRequest = ModbusPDUReadFileRecordRequest(
- items
-)
- return modbusPDUReadFileRecordRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -146,3 +129,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUReadFileRecordRequestItemdef ModbusPDUReadFileRecordRequestBuilder( []ModbusPDUReadFileRecordRequestItem items ): self.items = items
+
+
+ def build(
+ ) -> ModbusPDUReadFileRecordRequest:
+ modbusPDUReadFileRecordRequest: ModbusPDUReadFileRecordRequest = ModbusPDUReadFileRecordRequest(
+ items
+)
+ return modbusPDUReadFileRecordRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
index 9291e86a3d..5c5f4c1991 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
@@ -25,10 +25,10 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadFileRecordRequestItem(PlcMessage):
- referenceType: short
- fileNumber: int
- recordNumber: int
- recordLength: int
+ referenceType: c_uint8
+ fileNumber: c_uint16
+ recordNumber: c_uint16
+ recordLength: c_uint16
@@ -37,16 +37,16 @@ super().__init__( )
- def getReferenceType(self) -> short:
+ def getReferenceType(self) -> c_uint8:
return referenceType
- def getFileNumber(self) -> int:
+ def getFileNumber(self) -> c_uint16:
return fileNumber
- def getRecordNumber(self) -> int:
+ def getRecordNumber(self) -> c_uint16:
return recordNumber
- def getRecordLength(self) -> int:
+ def getRecordLength(self) -> c_uint16:
return recordLength
@@ -103,13 +103,13 @@ super().__init__( )
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceType: short = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
- fileNumber: int = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
+ fileNumber: c_uint16 = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
- recordNumber: int = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
+ recordNumber: c_uint16 = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
- recordLength: int = readSimpleField("recordLength", readUnsignedInt(readBuffer, 16))
+ recordLength: c_uint16 = readSimpleField("recordLength", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUReadFileRecordRequestItem")
# Create the instance
@@ -154,3 +154,5 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
index e9d33e9ddf..afc7f0342b 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadFileRecordResponse(PlcMessage,ModbusPDU):
- items: List<ModbusPDUReadFileRecordResponseItem>
+ items: []ModbusPDUReadFileRecordResponseItem
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x14
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x14
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getItems(self) -> List<ModbusPDUReadFileRecordResponseItem>:
+ def getItems(self) -> []ModbusPDUReadFileRecordResponseItem:
return items
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadFileRecordResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (ARRAY_SIZE_IN_BYTES(getItems()))
+ c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -83,15 +83,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadFileRecordResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadFileRecordResponseBuilder:
readBuffer.pullContext("ModbusPDUReadFileRecordResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
- items: List<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
@@ -100,23 +100,6 @@ super().__init__( )
)
- class ModbusPDUReadFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder {
- items: List<ModbusPDUReadFileRecordResponseItem>
-
- def ModbusPDUReadFileRecordResponseBuilder(
- List<ModbusPDUReadFileRecordResponseItem> items
-
- ):
- self.items = items
-
-
- def build(
- ) -> ModbusPDUReadFileRecordResponse:
- modbusPDUReadFileRecordResponse: ModbusPDUReadFileRecordResponse = ModbusPDUReadFileRecordResponse(
- items
-)
- return modbusPDUReadFileRecordResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -146,3 +129,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUReadFileRecordResponseItemdef ModbusPDUReadFileRecordResponseBuilder( []ModbusPDUReadFileRecordResponseItem items ): self.items = items
+
+
+ def build(
+ ) -> ModbusPDUReadFileRecordResponse:
+ modbusPDUReadFileRecordResponse: ModbusPDUReadFileRecordResponse = ModbusPDUReadFileRecordResponse(
+ items
+)
+ return modbusPDUReadFileRecordResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
index 9ec3b9287d..78a429265d 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
@@ -25,8 +25,8 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadFileRecordResponseItem(PlcMessage):
- referenceType: short
- data: byte[]
+ referenceType: c_uint8
+ data: []c_byte
@@ -35,10 +35,10 @@ super().__init__( )
- def getReferenceType(self) -> short:
+ def getReferenceType(self) -> c_uint8:
return referenceType
- def getData(self) -> byte[]:
+ def getData(self) -> []c_byte:
return data
@@ -48,7 +48,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadFileRecordResponseItem")
# Implicit Field (dataLength) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short dataLength = (short) ((COUNT(getData())) + (1))
+ c_uint8 dataLength = (c_uint8) ((COUNT(getData())) + (1))
writeImplicitField("dataLength", dataLength, writeUnsignedShort(writeBuffer, 8))
# Simple Field (referenceType)
@@ -92,9 +92,9 @@ super().__init__( )
startPos: int = positionAware.getPos()
curPos: int = 0
- dataLength: short = readImplicitField("dataLength", readUnsignedShort(readBuffer, 8))
+ dataLength: c_uint8 = readImplicitField("dataLength", readUnsignedShort(readBuffer, 8))
- referenceType: short = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
data: byte[] = readBuffer.readByteArray("data", Math.toIntExact((dataLength) - (1)))
@@ -135,3 +135,5 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
index ffb48029a5..3e9f675013 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadHoldingRegistersRequest(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x03
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x03
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadHoldingRegistersRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadHoldingRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUReadHoldingRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUReadHoldingRegistersRequest")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUReadHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
-
- def ModbusPDUReadHoldingRegistersRequestBuilder(
- int startingAddress,
- int quantity
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
-
-
- def build(
- ) -> ModbusPDUReadHoldingRegistersRequest:
- modbusPDUReadHoldingRegistersRequest: ModbusPDUReadHoldingRegistersRequest = ModbusPDUReadHoldingRegistersRequest(
- startingAddress,
- quantity
-)
- return modbusPDUReadHoldingRegistersRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadHoldingRegistersRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
+ self.quantity = quantity
+
+
+ def build(
+ ) -> ModbusPDUReadHoldingRegistersRequest:
+ modbusPDUReadHoldingRegistersRequest: ModbusPDUReadHoldingRegistersRequest = ModbusPDUReadHoldingRegistersRequest(
+ startingAddress,
+ quantity
+)
+ return modbusPDUReadHoldingRegistersRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
index 4465769f54..470a0166bf 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadHoldingRegistersResponse(PlcMessage,ModbusPDU):
- value: byte[]
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x03
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x03
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadHoldingRegistersResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -81,13 +81,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadHoldingRegistersResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadHoldingRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUReadHoldingRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -98,23 +98,6 @@ super().__init__( )
)
- class ModbusPDUReadHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder {
- value: byte[]
-
- def ModbusPDUReadHoldingRegistersResponseBuilder(
- byte[] value
-
- ):
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReadHoldingRegistersResponse:
- modbusPDUReadHoldingRegistersResponse: ModbusPDUReadHoldingRegistersResponse = ModbusPDUReadHoldingRegistersResponse(
- value
-)
- return modbusPDUReadHoldingRegistersResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -144,3 +127,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadHoldingRegistersResponseBuilder( []c_byte value ): self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReadHoldingRegistersResponse:
+ modbusPDUReadHoldingRegistersResponse: ModbusPDUReadHoldingRegistersResponse = ModbusPDUReadHoldingRegistersResponse(
+ value
+)
+ return modbusPDUReadHoldingRegistersResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
index 0176f8cc77..3c96143591 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadInputRegistersRequest(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x04
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x04
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadInputRegistersRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadInputRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUReadInputRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUReadInputRegistersRequest")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUReadInputRegistersRequestBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
-
- def ModbusPDUReadInputRegistersRequestBuilder(
- int startingAddress,
- int quantity
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
-
-
- def build(
- ) -> ModbusPDUReadInputRegistersRequest:
- modbusPDUReadInputRegistersRequest: ModbusPDUReadInputRegistersRequest = ModbusPDUReadInputRegistersRequest(
- startingAddress,
- quantity
-)
- return modbusPDUReadInputRegistersRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadInputRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUReadInputRegistersRequestBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
+ self.quantity = quantity
+
+
+ def build(
+ ) -> ModbusPDUReadInputRegistersRequest:
+ modbusPDUReadInputRegistersRequest: ModbusPDUReadInputRegistersRequest = ModbusPDUReadInputRegistersRequest(
+ startingAddress,
+ quantity
+)
+ return modbusPDUReadInputRegistersRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
index eaac7ed2d7..efcdbd7ff9 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadInputRegistersResponse(PlcMessage,ModbusPDU):
- value: byte[]
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x04
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x04
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadInputRegistersResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -81,13 +81,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadInputRegistersResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadInputRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUReadInputRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -98,23 +98,6 @@ super().__init__( )
)
- class ModbusPDUReadInputRegistersResponseBuilder(ModbusPDUModbusPDUBuilder {
- value: byte[]
-
- def ModbusPDUReadInputRegistersResponseBuilder(
- byte[] value
-
- ):
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReadInputRegistersResponse:
- modbusPDUReadInputRegistersResponse: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(
- value
-)
- return modbusPDUReadInputRegistersResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -144,3 +127,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadInputRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadInputRegistersResponseBuilder( []c_byte value ): self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReadInputRegistersResponse:
+ modbusPDUReadInputRegistersResponse: ModbusPDUReadInputRegistersResponse = ModbusPDUReadInputRegistersResponse(
+ value
+)
+ return modbusPDUReadInputRegistersResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
index 4c7e95eb11..2f7427fc4e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
@@ -25,21 +25,21 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
- readStartingAddress: int
- readQuantity: int
- writeStartingAddress: int
- writeQuantity: int
- value: byte[]
+ readStartingAddress: c_uint16
+ readQuantity: c_uint16
+ writeStartingAddress: c_uint16
+ writeQuantity: c_uint16
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x17
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x17
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -48,19 +48,19 @@ super().__init__( )
- def getReadStartingAddress(self) -> int:
+ def getReadStartingAddress(self) -> c_uint16:
return readStartingAddress
- def getReadQuantity(self) -> int:
+ def getReadQuantity(self) -> c_uint16:
return readQuantity
- def getWriteStartingAddress(self) -> int:
+ def getWriteStartingAddress(self) -> c_uint16:
return writeStartingAddress
- def getWriteQuantity(self) -> int:
+ def getWriteQuantity(self) -> c_uint16:
return writeQuantity
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -82,7 +82,7 @@ super().__init__( )
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)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -121,21 +121,21 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- readStartingAddress: int = readSimpleField("readStartingAddress", readUnsignedInt(readBuffer, 16))
+ readStartingAddress: c_uint16 = readSimpleField("readStartingAddress", readUnsignedInt(readBuffer, 16))
- readQuantity: int = readSimpleField("readQuantity", readUnsignedInt(readBuffer, 16))
+ readQuantity: c_uint16 = readSimpleField("readQuantity", readUnsignedInt(readBuffer, 16))
- writeStartingAddress: int = readSimpleField("writeStartingAddress", readUnsignedInt(readBuffer, 16))
+ writeStartingAddress: c_uint16 = readSimpleField("writeStartingAddress", readUnsignedInt(readBuffer, 16))
- writeQuantity: int = readSimpleField("writeQuantity", readUnsignedInt(readBuffer, 16))
+ writeQuantity: c_uint16 = readSimpleField("writeQuantity", readUnsignedInt(readBuffer, 16))
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -150,39 +150,6 @@ super().__init__( )
)
- class ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder {
- readStartingAddress: int
- readQuantity: int
- writeStartingAddress: int
- writeQuantity: int
- value: byte[]
-
- def ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(
- int readStartingAddress,
- int readQuantity,
- int writeStartingAddress,
- int writeQuantity,
- byte[] value
-
- ):
- self.readStartingAddress = readStartingAddress
- self.readQuantity = readQuantity
- self.writeStartingAddress = writeStartingAddress
- self.writeQuantity = writeQuantity
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReadWriteMultipleHoldingRegistersRequest:
- modbusPDUReadWriteMultipleHoldingRegistersRequest: ModbusPDUReadWriteMultipleHoldingRegistersRequest = ModbusPDUReadWriteMultipleHoldingRegistersRequest(
- readStartingAddress,
- readQuantity,
- writeStartingAddress,
- writeQuantity,
- value
-)
- return modbusPDUReadWriteMultipleHoldingRegistersRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -220,3 +187,23 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: readStartingAddress: c_uint16 readQuantity: c_uint16 writeStartingAddress: c_uint16 writeQuantity: c_uint16 value: []c_bytedef ModbusPDUReadWriteMultipleHoldingRegistersRequestBuilder( c_uint16 readStartingAddress, c_uint16 readQuantity, c_uint16 writeStartingAddress, c_uint16 writeQuantity, []c_byte value ): self.readStartingAddress = readStartingAddress
+ self.readQuantity = readQuantity
+ self.writeStartingAddress = writeStartingAddress
+ self.writeQuantity = writeQuantity
+ self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReadWriteMultipleHoldingRegistersRequest:
+ modbusPDUReadWriteMultipleHoldingRegistersRequest: ModbusPDUReadWriteMultipleHoldingRegistersRequest = ModbusPDUReadWriteMultipleHoldingRegistersRequest(
+ readStartingAddress,
+ readQuantity,
+ writeStartingAddress,
+ writeQuantity,
+ value
+)
+ return modbusPDUReadWriteMultipleHoldingRegistersRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
index 2023093204..1b453003f1 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
- value: byte[]
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x17
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x17
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -81,13 +81,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -98,23 +98,6 @@ super().__init__( )
)
- class ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder {
- value: byte[]
-
- def ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(
- byte[] value
-
- ):
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReadWriteMultipleHoldingRegistersResponse:
- modbusPDUReadWriteMultipleHoldingRegistersResponse: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ModbusPDUReadWriteMultipleHoldingRegistersResponse(
- value
-)
- return modbusPDUReadWriteMultipleHoldingRegistersResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -144,3 +127,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReadWriteMultipleHoldingRegistersResponseBuilder( []c_byte value ): self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReadWriteMultipleHoldingRegistersResponse:
+ modbusPDUReadWriteMultipleHoldingRegistersResponse: ModbusPDUReadWriteMultipleHoldingRegistersResponse = ModbusPDUReadWriteMultipleHoldingRegistersResponse(
+ value
+)
+ return modbusPDUReadWriteMultipleHoldingRegistersResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
index 1581d6a059..e9c45fc5e0 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdRequest.py
@@ -27,14 +27,14 @@ from dataclasses import dataclass
class ModbusPDUReportServerIdRequest(PlcMessage,ModbusPDU):
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x11
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x11
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -62,7 +62,7 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReportServerIdRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReportServerIdRequestBuilder:
readBuffer.pullContext("ModbusPDUReportServerIdRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
@@ -74,19 +74,6 @@ super().__init__( )
)
- class ModbusPDUReportServerIdRequestBuilder(ModbusPDUModbusPDUBuilder {
-
- def ModbusPDUReportServerIdRequestBuilder(
-
- ):
-
-
- def build(
- ) -> ModbusPDUReportServerIdRequest:
- modbusPDUReportServerIdRequest: ModbusPDUReportServerIdRequest = ModbusPDUReportServerIdRequest(
-)
- return modbusPDUReportServerIdRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -114,3 +101,13 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReportServerIdRequestBuilder(ModbusPDUModbusPDUBuilder:def ModbusPDUReportServerIdRequestBuilder( ):
+
+ def build(
+ ) -> ModbusPDUReportServerIdRequest:
+ modbusPDUReportServerIdRequest: ModbusPDUReportServerIdRequest = ModbusPDUReportServerIdRequest(
+)
+ return modbusPDUReportServerIdRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
index 6db466aeb2..98416354ca 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUReportServerIdResponse(PlcMessage,ModbusPDU):
- value: byte[]
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x11
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x11
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUReportServerIdResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -81,13 +81,13 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUReportServerIdResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUReportServerIdResponseBuilder:
readBuffer.pullContext("ModbusPDUReportServerIdResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -98,23 +98,6 @@ super().__init__( )
)
- class ModbusPDUReportServerIdResponseBuilder(ModbusPDUModbusPDUBuilder {
- value: byte[]
-
- def ModbusPDUReportServerIdResponseBuilder(
- byte[] value
-
- ):
- self.value = value
-
-
- def build(
- ) -> ModbusPDUReportServerIdResponse:
- modbusPDUReportServerIdResponse: ModbusPDUReportServerIdResponse = ModbusPDUReportServerIdResponse(
- value
-)
- return modbusPDUReportServerIdResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -144,3 +127,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUReportServerIdResponseBuilder(ModbusPDUModbusPDUBuilder: value: []c_bytedef ModbusPDUReportServerIdResponseBuilder( []c_byte value ): self.value = value
+
+
+ def build(
+ ) -> ModbusPDUReportServerIdResponse:
+ modbusPDUReportServerIdResponse: ModbusPDUReportServerIdResponse = ModbusPDUReportServerIdResponse(
+ value
+)
+ return modbusPDUReportServerIdResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
index 90a303d45e..ce5c7fdb57 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteFileRecordRequest(PlcMessage,ModbusPDU):
- items: List<ModbusPDUWriteFileRecordRequestItem>
+ items: []ModbusPDUWriteFileRecordRequestItem
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x15
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x15
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getItems(self) -> List<ModbusPDUWriteFileRecordRequestItem>:
+ def getItems(self) -> []ModbusPDUWriteFileRecordRequestItem:
return items
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUWriteFileRecordRequest")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (ARRAY_SIZE_IN_BYTES(getItems()))
+ c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -83,15 +83,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteFileRecordRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteFileRecordRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteFileRecordRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
- items: List<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
@@ -100,23 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder {
- items: List<ModbusPDUWriteFileRecordRequestItem>
-
- def ModbusPDUWriteFileRecordRequestBuilder(
- List<ModbusPDUWriteFileRecordRequestItem> items
-
- ):
- self.items = items
-
-
- def build(
- ) -> ModbusPDUWriteFileRecordRequest:
- modbusPDUWriteFileRecordRequest: ModbusPDUWriteFileRecordRequest = ModbusPDUWriteFileRecordRequest(
- items
-)
- return modbusPDUWriteFileRecordRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -146,3 +129,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteFileRecordRequestBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUWriteFileRecordRequestItemdef ModbusPDUWriteFileRecordRequestBuilder( []ModbusPDUWriteFileRecordRequestItem items ): self.items = items
+
+
+ def build(
+ ) -> ModbusPDUWriteFileRecordRequest:
+ modbusPDUWriteFileRecordRequest: ModbusPDUWriteFileRecordRequest = ModbusPDUWriteFileRecordRequest(
+ items
+)
+ return modbusPDUWriteFileRecordRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
index 13426eaeee..76d870827e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
@@ -25,10 +25,10 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
- referenceType: short
- fileNumber: int
- recordNumber: int
- recordData: byte[]
+ referenceType: c_uint8
+ fileNumber: c_uint16
+ recordNumber: c_uint16
+ recordData: []c_byte
@@ -37,16 +37,16 @@ super().__init__( )
- def getReferenceType(self) -> short:
+ def getReferenceType(self) -> c_uint8:
return referenceType
- def getFileNumber(self) -> int:
+ def getFileNumber(self) -> c_uint16:
return fileNumber
- def getRecordNumber(self) -> int:
+ def getRecordNumber(self) -> c_uint16:
return recordNumber
- def getRecordData(self) -> byte[]:
+ def getRecordData(self) -> []c_byte:
return recordData
@@ -65,7 +65,7 @@ super().__init__( )
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)
- int recordLength = (int) ((COUNT(getRecordData())) / (2))
+ c_uint16 recordLength = (c_uint16) ((COUNT(getRecordData())) / (2))
writeImplicitField("recordLength", recordLength, writeUnsignedInt(writeBuffer, 16))
# Array Field (recordData)
@@ -112,13 +112,13 @@ super().__init__( )
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceType: short = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
- fileNumber: int = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
+ fileNumber: c_uint16 = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
- recordNumber: int = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
+ recordNumber: c_uint16 = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
- recordLength: int = readImplicitField("recordLength", readUnsignedInt(readBuffer, 16))
+ recordLength: c_uint16 = readImplicitField("recordLength", readUnsignedInt(readBuffer, 16))
recordData: byte[] = readBuffer.readByteArray("recordData", Math.toIntExact((recordLength) * (2)))
@@ -165,3 +165,5 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
index 6f808a6167..e042bed82e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
@@ -25,17 +25,17 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteFileRecordResponse(PlcMessage,ModbusPDU):
- items: List<ModbusPDUWriteFileRecordResponseItem>
+ items: []ModbusPDUWriteFileRecordResponseItem
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x15
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x15
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -44,7 +44,7 @@ super().__init__( )
- def getItems(self) -> List<ModbusPDUWriteFileRecordResponseItem>:
+ def getItems(self) -> []ModbusPDUWriteFileRecordResponseItem:
return items
@@ -54,7 +54,7 @@ super().__init__( )
writeBuffer.pushContext("ModbusPDUWriteFileRecordResponse")
# Implicit Field (byteCount) (Used for parsing, but its value is not stored as it's implicitly given by the objects content)
- short byteCount = (short) (ARRAY_SIZE_IN_BYTES(getItems()))
+ c_uint8 byteCount = (c_uint8) (ARRAY_SIZE_IN_BYTES(getItems()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (items)
@@ -83,15 +83,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteFileRecordResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteFileRecordResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteFileRecordResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
- items: List<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
@@ -100,23 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder {
- items: List<ModbusPDUWriteFileRecordResponseItem>
-
- def ModbusPDUWriteFileRecordResponseBuilder(
- List<ModbusPDUWriteFileRecordResponseItem> items
-
- ):
- self.items = items
-
-
- def build(
- ) -> ModbusPDUWriteFileRecordResponse:
- modbusPDUWriteFileRecordResponse: ModbusPDUWriteFileRecordResponse = ModbusPDUWriteFileRecordResponse(
- items
-)
- return modbusPDUWriteFileRecordResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -146,3 +129,15 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteFileRecordResponseBuilder(ModbusPDUModbusPDUBuilder: items: []ModbusPDUWriteFileRecordResponseItemdef ModbusPDUWriteFileRecordResponseBuilder( []ModbusPDUWriteFileRecordResponseItem items ): self.items = items
+
+
+ def build(
+ ) -> ModbusPDUWriteFileRecordResponse:
+ modbusPDUWriteFileRecordResponse: ModbusPDUWriteFileRecordResponse = ModbusPDUWriteFileRecordResponse(
+ items
+)
+ return modbusPDUWriteFileRecordResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
index 79661bc68c..f2f0dff289 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
@@ -25,10 +25,10 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
- referenceType: short
- fileNumber: int
- recordNumber: int
- recordData: byte[]
+ referenceType: c_uint8
+ fileNumber: c_uint16
+ recordNumber: c_uint16
+ recordData: []c_byte
@@ -37,16 +37,16 @@ super().__init__( )
- def getReferenceType(self) -> short:
+ def getReferenceType(self) -> c_uint8:
return referenceType
- def getFileNumber(self) -> int:
+ def getFileNumber(self) -> c_uint16:
return fileNumber
- def getRecordNumber(self) -> int:
+ def getRecordNumber(self) -> c_uint16:
return recordNumber
- def getRecordData(self) -> byte[]:
+ def getRecordData(self) -> []c_byte:
return recordData
@@ -65,7 +65,7 @@ super().__init__( )
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)
- int recordLength = (int) ((COUNT(getRecordData())) / (2))
+ c_uint16 recordLength = (c_uint16) ((COUNT(getRecordData())) / (2))
writeImplicitField("recordLength", recordLength, writeUnsignedInt(writeBuffer, 16))
# Array Field (recordData)
@@ -112,13 +112,13 @@ super().__init__( )
startPos: int = positionAware.getPos()
curPos: int = 0
- referenceType: short = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
+ referenceType: c_uint8 = readSimpleField("referenceType", readUnsignedShort(readBuffer, 8))
- fileNumber: int = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
+ fileNumber: c_uint16 = readSimpleField("fileNumber", readUnsignedInt(readBuffer, 16))
- recordNumber: int = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
+ recordNumber: c_uint16 = readSimpleField("recordNumber", readUnsignedInt(readBuffer, 16))
- recordLength: int = readImplicitField("recordLength", readUnsignedInt(readBuffer, 16))
+ recordLength: c_uint16 = readImplicitField("recordLength", readUnsignedInt(readBuffer, 16))
recordData: byte[] = readBuffer.readByteArray("recordData", Math.toIntExact(recordLength))
@@ -165,3 +165,5 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
index 9343968682..bb4870612f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
@@ -25,19 +25,19 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteMultipleCoilsRequest(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
- value: byte[]
+ startingAddress: c_uint16
+ quantity: c_uint16
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x0F
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x0F
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -46,13 +46,13 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -68,7 +68,7 @@ super().__init__( )
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)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -101,17 +101,17 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteMultipleCoilsRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleCoilsRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleCoilsRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -124,31 +124,6 @@ super().__init__( )
)
- class ModbusPDUWriteMultipleCoilsRequestBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
- value: byte[]
-
- def ModbusPDUWriteMultipleCoilsRequestBuilder(
- int startingAddress,
- int quantity,
- byte[] value
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
- self.value = value
-
-
- def build(
- ) -> ModbusPDUWriteMultipleCoilsRequest:
- modbusPDUWriteMultipleCoilsRequest: ModbusPDUWriteMultipleCoilsRequest = ModbusPDUWriteMultipleCoilsRequest(
- startingAddress,
- quantity,
- value
-)
- return modbusPDUWriteMultipleCoilsRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -182,3 +157,19 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteMultipleCoilsRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16 value: []c_bytedef ModbusPDUWriteMultipleCoilsRequestBuilder( c_uint16 startingAddress, c_uint16 quantity, []c_byte value ): self.startingAddress = startingAddress
+ self.quantity = quantity
+ self.value = value
+
+
+ def build(
+ ) -> ModbusPDUWriteMultipleCoilsRequest:
+ modbusPDUWriteMultipleCoilsRequest: ModbusPDUWriteMultipleCoilsRequest = ModbusPDUWriteMultipleCoilsRequest(
+ startingAddress,
+ quantity,
+ value
+)
+ return modbusPDUWriteMultipleCoilsRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
index d6b894c717..ccb3aed568 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteMultipleCoilsResponse(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x0F
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x0F
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteMultipleCoilsResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleCoilsResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleCoilsResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUWriteMultipleCoilsResponse")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteMultipleCoilsResponseBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
-
- def ModbusPDUWriteMultipleCoilsResponseBuilder(
- int startingAddress,
- int quantity
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
-
-
- def build(
- ) -> ModbusPDUWriteMultipleCoilsResponse:
- modbusPDUWriteMultipleCoilsResponse: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(
- startingAddress,
- quantity
-)
- return modbusPDUWriteMultipleCoilsResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteMultipleCoilsResponseBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUWriteMultipleCoilsResponseBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
+ self.quantity = quantity
+
+
+ def build(
+ ) -> ModbusPDUWriteMultipleCoilsResponse:
+ modbusPDUWriteMultipleCoilsResponse: ModbusPDUWriteMultipleCoilsResponse = ModbusPDUWriteMultipleCoilsResponse(
+ startingAddress,
+ quantity
+)
+ return modbusPDUWriteMultipleCoilsResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
index 4bba3f5f26..db6d448a97 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
@@ -25,19 +25,19 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
- value: byte[]
+ startingAddress: c_uint16
+ quantity: c_uint16
+ value: []c_byte
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x10
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x10
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -46,13 +46,13 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
- def getValue(self) -> byte[]:
+ def getValue(self) -> []c_byte:
return value
@@ -68,7 +68,7 @@ super().__init__( )
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)
- short byteCount = (short) (COUNT(getValue()))
+ c_uint8 byteCount = (c_uint8) (COUNT(getValue()))
writeImplicitField("byteCount", byteCount, writeUnsignedShort(writeBuffer, 8))
# Array Field (value)
@@ -101,17 +101,17 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteMultipleHoldingRegistersRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleHoldingRegistersRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleHoldingRegistersRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
- byteCount: short = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
+ byteCount: c_uint8 = readImplicitField("byteCount", readUnsignedShort(readBuffer, 8))
value: byte[] = readBuffer.readByteArray("value", Math.toIntExact(byteCount))
@@ -124,31 +124,6 @@ super().__init__( )
)
- class ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
- value: byte[]
-
- def ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(
- int startingAddress,
- int quantity,
- byte[] value
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
- self.value = value
-
-
- def build(
- ) -> ModbusPDUWriteMultipleHoldingRegistersRequest:
- modbusPDUWriteMultipleHoldingRegistersRequest: ModbusPDUWriteMultipleHoldingRegistersRequest = ModbusPDUWriteMultipleHoldingRegistersRequest(
- startingAddress,
- quantity,
- value
-)
- return modbusPDUWriteMultipleHoldingRegistersRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -182,3 +157,19 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteMultipleHoldingRegistersRequestBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16 value: []c_bytedef ModbusPDUWriteMultipleHoldingRegistersRequestBuilder( c_uint16 startingAddress, c_uint16 quantity, []c_byte value ): self.startingAddress = startingAddress
+ self.quantity = quantity
+ self.value = value
+
+
+ def build(
+ ) -> ModbusPDUWriteMultipleHoldingRegistersRequest:
+ modbusPDUWriteMultipleHoldingRegistersRequest: ModbusPDUWriteMultipleHoldingRegistersRequest = ModbusPDUWriteMultipleHoldingRegistersRequest(
+ startingAddress,
+ quantity,
+ value
+)
+ return modbusPDUWriteMultipleHoldingRegistersRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
index f951075bad..949cd69bd3 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage,ModbusPDU):
- startingAddress: int
- quantity: int
+ startingAddress: c_uint16
+ quantity: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x10
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x10
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getStartingAddress(self) -> int:
+ def getStartingAddress(self) -> c_uint16:
return startingAddress
- def getQuantity(self) -> int:
+ def getQuantity(self) -> c_uint16:
return quantity
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteMultipleHoldingRegistersResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteMultipleHoldingRegistersResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- startingAddress: int = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
+ startingAddress: c_uint16 = readSimpleField("startingAddress", readUnsignedInt(readBuffer, 16))
- quantity: int = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
+ quantity: c_uint16 = readSimpleField("quantity", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUWriteMultipleHoldingRegistersResponse")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder {
- startingAddress: int
- quantity: int
-
- def ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(
- int startingAddress,
- int quantity
-
- ):
- self.startingAddress = startingAddress
- self.quantity = quantity
-
-
- def build(
- ) -> ModbusPDUWriteMultipleHoldingRegistersResponse:
- modbusPDUWriteMultipleHoldingRegistersResponse: ModbusPDUWriteMultipleHoldingRegistersResponse = ModbusPDUWriteMultipleHoldingRegistersResponse(
- startingAddress,
- quantity
-)
- return modbusPDUWriteMultipleHoldingRegistersResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteMultipleHoldingRegistersResponseBuilder(ModbusPDUModbusPDUBuilder: startingAddress: c_uint16 quantity: c_uint16def ModbusPDUWriteMultipleHoldingRegistersResponseBuilder( c_uint16 startingAddress, c_uint16 quantity ): self.startingAddress = startingAddress
+ self.quantity = quantity
+
+
+ def build(
+ ) -> ModbusPDUWriteMultipleHoldingRegistersResponse:
+ modbusPDUWriteMultipleHoldingRegistersResponse: ModbusPDUWriteMultipleHoldingRegistersResponse = ModbusPDUWriteMultipleHoldingRegistersResponse(
+ startingAddress,
+ quantity
+)
+ return modbusPDUWriteMultipleHoldingRegistersResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
index 4e6c8317ed..0f0832698f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteSingleCoilRequest(PlcMessage,ModbusPDU):
- address: int
- value: int
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x05
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x05
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getAddress(self) -> int:
+ def getAddress(self) -> c_uint16:
return address
- def getValue(self) -> int:
+ def getValue(self) -> c_uint16:
return value
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteSingleCoilRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleCoilRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleCoilRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: int = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: int = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUWriteSingleCoilRequest")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteSingleCoilRequestBuilder(ModbusPDUModbusPDUBuilder {
- address: int
- value: int
-
- def ModbusPDUWriteSingleCoilRequestBuilder(
- int address,
- int value
-
- ):
- self.address = address
- self.value = value
-
-
- def build(
- ) -> ModbusPDUWriteSingleCoilRequest:
- modbusPDUWriteSingleCoilRequest: ModbusPDUWriteSingleCoilRequest = ModbusPDUWriteSingleCoilRequest(
- address,
- value
-)
- return modbusPDUWriteSingleCoilRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteSingleCoilRequestBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleCoilRequestBuilder( c_uint16 address, c_uint16 value ): self.address = address
+ self.value = value
+
+
+ def build(
+ ) -> ModbusPDUWriteSingleCoilRequest:
+ modbusPDUWriteSingleCoilRequest: ModbusPDUWriteSingleCoilRequest = ModbusPDUWriteSingleCoilRequest(
+ address,
+ value
+)
+ return modbusPDUWriteSingleCoilRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
index 792aa00811..8cc5045515 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteSingleCoilResponse(PlcMessage,ModbusPDU):
- address: int
- value: int
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x05
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x05
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getAddress(self) -> int:
+ def getAddress(self) -> c_uint16:
return address
- def getValue(self) -> int:
+ def getValue(self) -> c_uint16:
return value
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteSingleCoilResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleCoilResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleCoilResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: int = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: int = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUWriteSingleCoilResponse")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteSingleCoilResponseBuilder(ModbusPDUModbusPDUBuilder {
- address: int
- value: int
-
- def ModbusPDUWriteSingleCoilResponseBuilder(
- int address,
- int value
-
- ):
- self.address = address
- self.value = value
-
-
- def build(
- ) -> ModbusPDUWriteSingleCoilResponse:
- modbusPDUWriteSingleCoilResponse: ModbusPDUWriteSingleCoilResponse = ModbusPDUWriteSingleCoilResponse(
- address,
- value
-)
- return modbusPDUWriteSingleCoilResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteSingleCoilResponseBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleCoilResponseBuilder( c_uint16 address, c_uint16 value ): self.address = address
+ self.value = value
+
+
+ def build(
+ ) -> ModbusPDUWriteSingleCoilResponse:
+ modbusPDUWriteSingleCoilResponse: ModbusPDUWriteSingleCoilResponse = ModbusPDUWriteSingleCoilResponse(
+ address,
+ value
+)
+ return modbusPDUWriteSingleCoilResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
index 401e64f450..f607668f29 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteSingleRegisterRequest(PlcMessage,ModbusPDU):
- address: int
- value: int
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x06
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x06
}
- def Boolean getResponse() {
- return (boolean) false
+ def c_bool getResponse() {
+ return (c_bool) false
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getAddress(self) -> int:
+ def getAddress(self) -> c_uint16:
return address
- def getValue(self) -> int:
+ def getValue(self) -> c_uint16:
return value
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteSingleRegisterRequestBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleRegisterRequestBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleRegisterRequest")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: int = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: int = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUWriteSingleRegisterRequest")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteSingleRegisterRequestBuilder(ModbusPDUModbusPDUBuilder {
- address: int
- value: int
-
- def ModbusPDUWriteSingleRegisterRequestBuilder(
- int address,
- int value
-
- ):
- self.address = address
- self.value = value
-
-
- def build(
- ) -> ModbusPDUWriteSingleRegisterRequest:
- modbusPDUWriteSingleRegisterRequest: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(
- address,
- value
-)
- return modbusPDUWriteSingleRegisterRequest
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteSingleRegisterRequestBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleRegisterRequestBuilder( c_uint16 address, c_uint16 value ): self.address = address
+ self.value = value
+
+
+ def build(
+ ) -> ModbusPDUWriteSingleRegisterRequest:
+ modbusPDUWriteSingleRegisterRequest: ModbusPDUWriteSingleRegisterRequest = ModbusPDUWriteSingleRegisterRequest(
+ address,
+ value
+)
+ return modbusPDUWriteSingleRegisterRequest
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
index ddd9502775..9d225c7802 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
@@ -25,18 +25,18 @@ from dataclasses import dataclass
@dataclass
class ModbusPDUWriteSingleRegisterResponse(PlcMessage,ModbusPDU):
- address: int
- value: int
+ address: c_uint16
+ value: c_uint16
# Accessors for discriminator values.
- def Boolean getErrorFlag() {
- return (boolean) false
+ def c_bool getErrorFlag() {
+ return (c_bool) false
}
- def Short getFunctionFlag() {
- return (short) 0x06
+ def c_uint8 getFunctionFlag() {
+ return (c_uint8) 0x06
}
- def Boolean getResponse() {
- return (boolean) true
+ def c_bool getResponse() {
+ return (c_bool) true
}
@@ -45,10 +45,10 @@ super().__init__( )
- def getAddress(self) -> int:
+ def getAddress(self) -> c_uint16:
return address
- def getValue(self) -> int:
+ def getValue(self) -> c_uint16:
return value
@@ -82,15 +82,15 @@ super().__init__( )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, Boolean response) -> ModbusPDUWriteSingleRegisterResponseBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, c_bool response) -> ModbusPDUWriteSingleRegisterResponseBuilder:
readBuffer.pullContext("ModbusPDUWriteSingleRegisterResponse")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: int = readSimpleField("address", readUnsignedInt(readBuffer, 16))
+ address: c_uint16 = readSimpleField("address", readUnsignedInt(readBuffer, 16))
- value: int = readSimpleField("value", readUnsignedInt(readBuffer, 16))
+ value: c_uint16 = readSimpleField("value", readUnsignedInt(readBuffer, 16))
readBuffer.closeContext("ModbusPDUWriteSingleRegisterResponse")
# Create the instance
@@ -100,27 +100,6 @@ super().__init__( )
)
- class ModbusPDUWriteSingleRegisterResponseBuilder(ModbusPDUModbusPDUBuilder {
- address: int
- value: int
-
- def ModbusPDUWriteSingleRegisterResponseBuilder(
- int address,
- int value
-
- ):
- self.address = address
- self.value = value
-
-
- def build(
- ) -> ModbusPDUWriteSingleRegisterResponse:
- modbusPDUWriteSingleRegisterResponse: ModbusPDUWriteSingleRegisterResponse = ModbusPDUWriteSingleRegisterResponse(
- address,
- value
-)
- return modbusPDUWriteSingleRegisterResponse
-
def equals(self, o: object) -> bool:
if this == o:
@@ -152,3 +131,17 @@ super().__init__( )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusPDUWriteSingleRegisterResponseBuilder(ModbusPDUModbusPDUBuilder: address: c_uint16 value: c_uint16def ModbusPDUWriteSingleRegisterResponseBuilder( c_uint16 address, c_uint16 value ): self.address = address
+ self.value = value
+
+
+ def build(
+ ) -> ModbusPDUWriteSingleRegisterResponse:
+ modbusPDUWriteSingleRegisterResponse: ModbusPDUWriteSingleRegisterResponse = ModbusPDUWriteSingleRegisterResponse(
+ address,
+ value
+)
+ return modbusPDUWriteSingleRegisterResponse
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
index 34b5a3c438..a5a1a43a91 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
@@ -25,10 +25,10 @@ from dataclasses import dataclass
@dataclass
class ModbusRtuADU(PlcMessage,ModbusADU):
- address: short
+ address: c_uint8
pdu: ModbusPDU
# Arguments.
- response: Boolean
+ response: c_bool
# Accessors for discriminator values.
def DriverType getDriverType() {
@@ -41,7 +41,7 @@ super().__init__( self.response )
- def getAddress(self) -> short:
+ def getAddress(self) -> c_uint8:
return address
def getPdu(self) -> ModbusPDU:
@@ -60,7 +60,7 @@ super().__init__( self.response )
writeSimpleField("pdu", pdu, new DataWriterComplexDefault<>(writeBuffer), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
# Checksum Field (checksum) (Calculated)
- writeChecksumField("crc", (int) (modbus.readwrite.utils.StaticHelper.rtuCrcCheck(address, pdu)), writeUnsignedInt(writeBuffer, 16))
+ writeChecksumField("crc", (c_uint16) (modbus.readwrite.utils.StaticHelper.rtuCrcCheck(address, pdu)), writeUnsignedInt(writeBuffer, 16))
writeBuffer.popContext("ModbusRtuADU")
@@ -84,17 +84,17 @@ super().__init__( self.response )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, Boolean response) -> ModbusRtuADUBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, c_bool response) -> ModbusRtuADUBuilder:
readBuffer.pullContext("ModbusRtuADU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- address: short = 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, (boolean) (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: int = readChecksumField("crc", readUnsignedInt(readBuffer, 16), (int) (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
@@ -106,35 +106,6 @@ super().__init__( self.response )
)
- class ModbusRtuADUBuilder(ModbusADUModbusADUBuilder {
- address: short
- pdu: ModbusPDU
- response: Boolean
-
- def ModbusRtuADUBuilder(
- short address,
- ModbusPDU pdu
- ,
- Boolean response
-
- ):
- self.address = address
- self.pdu = pdu
- self.response = response
-
-
- def build(
-
- Boolean response
- ) -> ModbusRtuADU:
- modbusRtuADU: ModbusRtuADU = ModbusRtuADU(
- address,
- pdu
- ,
- response
- )
- return modbusRtuADU
-
def equals(self, o: object) -> bool:
if this == o:
@@ -166,3 +137,22 @@ super().__init__( self.response )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusRtuADUBuilder(ModbusADUModbusADUBuilder: address: c_uint8 pdu: ModbusPDU response: c_booldef ModbusRtuADUBuilder( c_uint8 address, ModbusPDU pdu , c_bool response ): self.address = address
+ self.pdu = pdu
+ self.response = response
+
+
+ def build(
+
+ c_bool response
+ ) -> ModbusRtuADU:
+ modbusRtuADU: ModbusRtuADU = ModbusRtuADU(
+ address,
+ pdu
+ ,
+ response
+ )
+ return modbusRtuADU
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
index ef7ec0b1ab..709677b675 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
@@ -25,12 +25,12 @@ from dataclasses import dataclass
@dataclass
class ModbusTcpADU(PlcMessage,ModbusADU):
- transactionIdentifier: int
- unitIdentifier: short
+ transactionIdentifier: c_uint16
+ unitIdentifier: c_uint8
pdu: ModbusPDU
# Arguments.
- response: Boolean
- PROTOCOLIDENTIFIER: Integer = 0x0000
+ response: c_bool
+ PROTOCOLIDENTIFIER: c_uint16 = 0x0000
# Accessors for discriminator values.
def DriverType getDriverType() {
@@ -43,16 +43,16 @@ super().__init__( self.response )
- def getTransactionIdentifier(self) -> int:
+ def getTransactionIdentifier(self) -> c_uint16:
return transactionIdentifier
- def getUnitIdentifier(self) -> short:
+ def getUnitIdentifier(self) -> c_uint8:
return unitIdentifier
def getPdu(self) -> ModbusPDU:
return pdu
- def getProtocolIdentifier(self) -> int:
+ def getProtocolIdentifier(self) -> c_uint16:
return PROTOCOLIDENTIFIER
@@ -68,7 +68,7 @@ super().__init__( self.response )
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)
- int length = (int) ((getPdu().getLengthInBytes()) + (1))
+ c_uint16 length = (c_uint16) ((getPdu().getLengthInBytes()) + (1))
writeImplicitField("length", length, writeUnsignedInt(writeBuffer, 16))
# Simple Field (unitIdentifier)
@@ -105,21 +105,21 @@ super().__init__( self.response )
return lengthInBits
- def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, Boolean response) -> ModbusTcpADUBuilder:
+ def staticParseBuilder(readBuffer: ReadBuffer, DriverType driverType, c_bool response) -> ModbusTcpADUBuilder:
readBuffer.pullContext("ModbusTcpADU")
positionAware: PositionAware = readBuffer
startPos: int = positionAware.getPos()
curPos: int = 0
- transactionIdentifier: int = readSimpleField("transactionIdentifier", readUnsignedInt(readBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ transactionIdentifier: c_uint16 = readSimpleField("transactionIdentifier", readUnsignedInt(readBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
- protocolIdentifier: int = 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: int = readImplicitField("length", readUnsignedInt(readBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
+ length: c_uint16 = readImplicitField("length", readUnsignedInt(readBuffer, 16), WithOption.WithByteOrder(ByteOrder.BIG_ENDIAN))
- unitIdentifier: short = 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, (boolean) (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
@@ -132,39 +132,6 @@ super().__init__( self.response )
)
- class ModbusTcpADUBuilder(ModbusADUModbusADUBuilder {
- transactionIdentifier: int
- unitIdentifier: short
- pdu: ModbusPDU
- response: Boolean
-
- def ModbusTcpADUBuilder(
- int transactionIdentifier,
- short unitIdentifier,
- ModbusPDU pdu
- ,
- Boolean response
-
- ):
- self.transactionIdentifier = transactionIdentifier
- self.unitIdentifier = unitIdentifier
- self.pdu = pdu
- self.response = response
-
-
- def build(
-
- Boolean response
- ) -> ModbusTcpADU:
- modbusTcpADU: ModbusTcpADU = ModbusTcpADU(
- transactionIdentifier,
- unitIdentifier,
- pdu
- ,
- response
- )
- return modbusTcpADU
-
def equals(self, o: object) -> bool:
if this == o:
@@ -198,3 +165,24 @@ super().__init__( self.response )
return "\n" + writeBufferBoxBased.getBox().toString()+ "\n"
+
+class ModbusTcpADUBuilder(ModbusADUModbusADUBuilder: transactionIdentifier: c_uint16 unitIdentifier: c_uint8 pdu: ModbusPDU response: c_booldef ModbusTcpADUBuilder( c_uint16 transactionIdentifier, c_uint8 unitIdentifier, ModbusPDU pdu , c_bool response ): self.transactionIdentifier = transactionIdentifier
+ self.unitIdentifier = unitIdentifier
+ self.pdu = pdu
+ self.response = response
+
+
+ def build(
+
+ c_bool response
+ ) -> ModbusTcpADU:
+ modbusTcpADU: ModbusTcpADU = ModbusTcpADU(
+ transactionIdentifier,
+ unitIdentifier,
+ pdu
+ ,
+ response
+ )
+ return modbusTcpADU
+
+
diff --git a/sandbox/plc4py/pom.xml b/sandbox/plc4py/pom.xml
index bba9d1c285..c36cd2e4fd 100644
--- a/sandbox/plc4py/pom.xml
+++ b/sandbox/plc4py/pom.xml
@@ -114,31 +114,31 @@
</execution>
<execution>
- <id>python-black</id>
+ <id>python-install</id>
<phase>generate-sources</phase>
<goals>
<goal>exec</goal>
</goals>
<configuration>
- <executable>${python.venv.bin}python3</executable>
+ <executable>${python.venv.bin}pip3</executable>
<arguments>
- <argument>-m</argument>
- <argument>black</argument>
+ <argument>install</argument>
<argument>.</argument>
</arguments>
</configuration>
</execution>
<execution>
- <id>python-install</id>
- <phase>compile</phase>
+ <id>python-black</id>
+ <phase>generate-sources</phase>
<goals>
<goal>exec</goal>
</goals>
<configuration>
- <executable>${python.venv.bin}pip3</executable>
+ <executable>${python.venv.bin}python3</executable>
<arguments>
- <argument>install</argument>
+ <argument>-m</argument>
+ <argument>black</argument>
<argument>.</argument>
</arguments>
</configuration>