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:11 UTC
[plc4x] 01/02: feat(plc4py/codegen): More updates for template
This is an automated email from the ASF dual-hosted git repository.
hutcheb pushed a commit to branch plc4py-codegen
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit 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>