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 2023/11/07 23:41:23 UTC
(plc4x) branch feat/plc4py_code_gen created (now 0031670ffe)
This is an automated email from the ASF dual-hosted git repository.
hutcheb pushed a change to branch feat/plc4py_code_gen
in repository https://gitbox.apache.org/repos/asf/plc4x.git
at 0031670ffe feat(plc4y): Still getting the static parse code working
This branch includes the following new commits:
new 0031670ffe feat(plc4y): Still getting the static parse code working
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(plc4x) 01/01: feat(plc4y): Still getting the static parse code working
Posted by hu...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
hutcheb pushed a commit to branch feat/plc4py_code_gen
in repository https://gitbox.apache.org/repos/asf/plc4x.git
commit 0031670ffe58e018ef44e3840b02c46f1d33bf3a
Author: Ben Hutcheson <be...@gmail.com>
AuthorDate: Wed Nov 8 00:41:04 2023 +0100
feat(plc4y): Still getting the static parse code working
---
.../python/PythonLanguageTemplateHelper.java | 34 +-
.../python/complex-type-template.python.ftlh | 80 ++--
.../plc4py/protocols/modbus/readwrite/DataItem.py | 326 ++++++-------
.../plc4py/protocols/modbus/readwrite/ModbusADU.py | 90 ++--
.../protocols/modbus/readwrite/ModbusAsciiADU.py | 25 +-
.../protocols/modbus/readwrite/ModbusConstants.py | 11 +-
.../readwrite/ModbusDeviceInformationObject.py | 20 +-
.../plc4py/protocols/modbus/readwrite/ModbusPDU.py | 504 ++++++---------------
.../modbus/readwrite/ModbusPDUDiagnosticRequest.py | 4 +-
.../readwrite/ModbusPDUDiagnosticResponse.py | 4 +-
.../protocols/modbus/readwrite/ModbusPDUError.py | 6 +-
.../ModbusPDUGetComEventCounterResponse.py | 4 +-
.../readwrite/ModbusPDUGetComEventLogResponse.py | 17 +-
.../ModbusPDUMaskWriteHoldingRegisterRequest.py | 8 +-
.../ModbusPDUMaskWriteHoldingRegisterResponse.py | 8 +-
.../modbus/readwrite/ModbusPDUReadCoilsRequest.py | 6 +-
.../modbus/readwrite/ModbusPDUReadCoilsResponse.py | 9 +-
.../ModbusPDUReadDeviceIdentificationRequest.py | 16 +-
.../ModbusPDUReadDeviceIdentificationResponse.py | 51 +--
.../ModbusPDUReadDiscreteInputsRequest.py | 6 +-
.../ModbusPDUReadDiscreteInputsResponse.py | 9 +-
.../ModbusPDUReadExceptionStatusResponse.py | 2 +-
.../readwrite/ModbusPDUReadFifoQueueRequest.py | 4 +-
.../readwrite/ModbusPDUReadFifoQueueResponse.py | 10 +-
.../readwrite/ModbusPDUReadFileRecordRequest.py | 12 +-
.../ModbusPDUReadFileRecordRequestItem.py | 15 +-
.../readwrite/ModbusPDUReadFileRecordResponse.py | 12 +-
.../ModbusPDUReadFileRecordResponseItem.py | 20 +-
.../ModbusPDUReadHoldingRegistersRequest.py | 6 +-
.../ModbusPDUReadHoldingRegistersResponse.py | 9 +-
.../ModbusPDUReadInputRegistersRequest.py | 6 +-
.../ModbusPDUReadInputRegistersResponse.py | 9 +-
...sPDUReadWriteMultipleHoldingRegistersRequest.py | 23 +-
...PDUReadWriteMultipleHoldingRegistersResponse.py | 9 +-
.../readwrite/ModbusPDUReportServerIdResponse.py | 9 +-
.../readwrite/ModbusPDUWriteFileRecordRequest.py | 12 +-
.../ModbusPDUWriteFileRecordRequestItem.py | 24 +-
.../readwrite/ModbusPDUWriteFileRecordResponse.py | 12 +-
.../ModbusPDUWriteFileRecordResponseItem.py | 24 +-
.../ModbusPDUWriteMultipleCoilsRequest.py | 15 +-
.../ModbusPDUWriteMultipleCoilsResponse.py | 6 +-
...odbusPDUWriteMultipleHoldingRegistersRequest.py | 15 +-
...dbusPDUWriteMultipleHoldingRegistersResponse.py | 6 +-
.../readwrite/ModbusPDUWriteSingleCoilRequest.py | 4 +-
.../readwrite/ModbusPDUWriteSingleCoilResponse.py | 4 +-
.../ModbusPDUWriteSingleRegisterRequest.py | 4 +-
.../ModbusPDUWriteSingleRegisterResponse.py | 4 +-
.../protocols/modbus/readwrite/ModbusRtuADU.py | 24 +-
.../protocols/modbus/readwrite/ModbusTcpADU.py | 34 +-
.../protocols/simulated/readwrite/DataItem.py | 314 ++++++-------
.../plc4py/protocols/simulated/readwrite/Dummy.py | 10 +-
sandbox/plc4py/plc4py/spi/generation/ReadBuffer.py | 9 +-
52 files changed, 870 insertions(+), 1035 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 7d787e6f47..e51d1dda65 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
@@ -207,28 +207,29 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
final Optional<Term> encodingOptional = field.getEncoding();
if (encodingOptional.isPresent()) {
final String encoding = toParseExpression(field, field.getType(), encodingOptional.get(), parserArguments);
- sb.append(", WithOption.WithEncoding(").append(encoding).append(")");
+ sb.append(", encoding='").append(encoding).append("'");
}
final Optional<Term> byteOrderOptional = field.getByteOrder();
if (byteOrderOptional.isPresent()) {
final String byteOrder = toParseExpression(field, field.getType(), byteOrderOptional.get(), parserArguments);
- sb.append(", WithOption.WithByteOrder(").append(byteOrder).append(")");
+ emitRequiredImport("from plc4py.utils.GenericTypes import ByteOrder");
+ sb.append(", byte_order=ByteOrder.").append(byteOrder);
}
return sb.toString();
}
public String getDataReaderCall(TypeReference typeReference) {
- return getDataReaderCall(typeReference, "enumForValue");
+ return getDataReaderCall(typeReference, "enumForValue", false);
}
- public String getDataReaderCall(TypeReference typeReference, String resolverMethod) {
+ public String getDataReaderCall(TypeReference typeReference, String resolverMethod, Boolean isArray) {
if (typeReference.isEnumTypeReference()) {
final String languageTypeName = getLanguageTypeNameForTypeReference(typeReference);
final SimpleTypeReference enumBaseTypeReference = getEnumBaseTypeReference(typeReference);
- return "DataReaderEnumDefault(" + languageTypeName + "." + resolverMethod + ", " + getDataReaderCall(enumBaseTypeReference) + ")";
+ return "read_complex(read_function=" + languageTypeName + ",";
} else if (typeReference.isArrayTypeReference()) {
final ArrayTypeReference arrayTypeReference = typeReference.asArrayTypeReference().orElseThrow();
- return getDataReaderCall(arrayTypeReference.getElementTypeReference(), resolverMethod);
+ return getDataReaderCall(arrayTypeReference.getElementTypeReference(), resolverMethod, true);
} else if (typeReference.isSimpleTypeReference()) {
SimpleTypeReference simpleTypeReference = typeReference.asSimpleTypeReference().orElseThrow(IllegalStateException::new);
return getDataReaderCall(simpleTypeReference);
@@ -251,12 +252,15 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
final TypeReference argumentType = getArgumentType(complexTypeReference, i);
paramsString
.append(", ")
- .append(getLanguageTypeNameForTypeReference(argumentType, true))
- .append("(")
.append(toParseExpression(null, argumentType, paramTerm, null))
- .append(")");
+ .append("=")
+ .append(toParseExpression(null, argumentType, paramTerm, null));
+ }
+ if (isArray) {
+ return parserCallString + ".static_parse, ";
+ } else {
+ return "read_complex(read_function=" + parserCallString + ".static_parse, ";
}
- return "DataReaderComplexDefault(" + parserCallString + ".static_parse(read_buffer" + paramsString + "), read_buffer)";
} else {
throw new IllegalStateException("What is this type? " + typeReference);
}
@@ -1026,7 +1030,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if ((serializerArguments != null) && serializerArguments.stream()
.anyMatch(argument -> argument.getName().equals(variableLiteralName)) && "stringLength".equals(variableLiteralName)) {
tracer = tracer.dive("serialization argument");
- return tracer + variableLiteralName +
+ return tracer + camelCaseToSnakeCase(variableLiteralName) +
variableLiteral.getChild()
.map(child -> "." + camelCaseToSnakeCase(toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess, true)))
.orElse("");
@@ -1041,7 +1045,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if ((parserArguments != null) && parserArguments.stream()
.anyMatch(argument -> argument.getName().equals(variableLiteralName))) {
tracer = tracer.dive("parser argument");
- return tracer + variableLiteralName +
+ return tracer + camelCaseToSnakeCase(variableLiteralName) +
variableLiteral.getChild()
.map(child -> "." + camelCaseToSnakeCase(toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess, true)))
.orElse("");
@@ -1058,7 +1062,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
if (isChild) {
variableAccess = "get_" + camelCaseToSnakeCase(variableAccess) + "()";
}
- return tracer + (serialize ? "self." + camelCaseToSnakeCase(variableLiteralName) + "" : variableAccess) + indexCall +
+ return tracer + (serialize ? "self." + camelCaseToSnakeCase(variableLiteralName) + "" : camelCaseToSnakeCase(variableAccess)) + indexCall +
variableLiteral.getChild()
.map(child -> "." + camelCaseToSnakeCase(toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, false, suppressPointerAccess, true)))
.orElse("");
@@ -1066,7 +1070,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
private String toUppercaseVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean serialize, boolean suppressPointerAccess, Tracer tracer) {
tracer = tracer.dive("toUppercaseVariableExpression");
- StringBuilder sb = new StringBuilder("get_" + camelCaseToSnakeCase(variableLiteral.getName()) + "()");
+ StringBuilder sb = new StringBuilder(variableLiteral.getName().toUpperCase());
if (variableLiteral.getArgs().isPresent()) {
sb.append("(");
boolean firstArg = true;
@@ -1220,7 +1224,7 @@ public class PythonLanguageTemplateHelper extends BaseFreemarkerLanguageTemplate
break;
}
} else {
- sb.append("self." + toVariableExpression(field, typeReference, va, parserArguments, serializerArguments, serialize, suppressPointerAccess));
+ sb.append(toVariableExpression(field, typeReference, va, parserArguments, serializerArguments, serialize, suppressPointerAccess));
}
} else if (arg instanceof StringLiteral) {
tracer = tracer.dive("StringLiteral");
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 e74fa74721..82c6cbfed6 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
@@ -318,7 +318,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
# Reserved Field (reserved)
- write_buffer.${helper.getDataWriterCall(typedField.type, "reserved")}(self.reserved_field_${reservedFieldIndex}!=None?self.reserved_field_${reservedFieldIndex}: ${helper.getReservedValue(reservedField)}, logical_name="reserved")<#assign reservedFieldIndex=reservedFieldIndex+1>
+ write_buffer.${helper.getDataWriterCall(typedField.type, "reserved")}(self.reserved_field_${reservedFieldIndex} if self.reserved_field_${reservedFieldIndex} is not None else ${helper.getReservedValue(reservedField)}, logical_name="reserved")<#assign reservedFieldIndex=reservedFieldIndex+1>
<#break>
<#case "simple">
<#assign simpleField = field.asSimpleField().orElseThrow()>
@@ -369,7 +369,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign arrayElementTypeReference = arrayField.type.asArrayTypeReference().orElseThrow().getElementTypeReference()>
# Array field
- if self.${helper.camelCaseToSnakeCase(arrayField.name)} != None:
+ if self.${helper.camelCaseToSnakeCase(arrayField.name)} is not None:
<#if arrayElementTypeReference.isSimpleTypeReference()>
<#assign simpleTypeReference = arrayElementTypeReference.asSimpleTypeReference().orElseThrow()>
length_in_bits += ${simpleTypeReference.sizeInBits} * len(self.${helper.camelCaseToSnakeCase(arrayField.name)})
@@ -537,29 +537,31 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#-- The parse and serialize methods here are just proxies for forwardning the requests to static counterparts -->
<#if !type.isDiscriminatedChildTypeDefinition()>
<@emitImport import="from plc4py.spi.generation.ReadBuffer import ReadBuffer" />
- def static_parse(self, read_buffer: ReadBuffer , args):
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
<#if parserArguments?has_content>
<@emitImport import="from plc4py.api.exceptions.exceptions import PlcRuntimeException" />
- if args is None:
+
+ if kwargs is None:
raise PlcRuntimeException("Wrong number of arguments, expected ${parserArguments?size}, but got None")
- elif args.length != ${parserArguments?size}:
- raise PlcRuntimeException("Wrong number of arguments, expected ${parserArguments?size}, but got " + str(len(args)))
+ elif len(kwargs) ${parserArguments?size}:
+ raise PlcRuntimeException("Wrong number of arguments, expected ${parserArguments?size}, but got " + str(len(kwargs)))
<#list parserArguments as parserArgument>
<#assign languageName=helper.getLanguageTypeNameForTypeReference(parserArgument.type, false)>
${parserArgument.name}: ${languageName} = ${helper.getNullValueForTypeReference(parserArgument.type)}
- if isinstance(args[${parserArgument?index}], ${languageName}):
- ${parserArgument.name} = ${languageName}(args[${parserArgument?index}])
+ if isinstance(kwargs.get("${parserArgument.name}"), ${languageName}):
+ ${parserArgument.name} = ${languageName}(kwargs.get("${parserArgument.name}"))
<#if parserArgument.type.isSimpleTypeReference() || parserArgument.type.isEnumTypeReference()>
- elif isinstance(args[${parserArgument?index}], str):
- ${parserArgument.name} = ${languageName}(str(args[${parserArgument?index}]))
+ elif isinstance(kwargs.get("${parserArgument.name}"), str):
+ ${parserArgument.name} = ${languageName}(str(kwargs.get("${parserArgument.name}")))
</#if>
else:
- raise PlcRuntimeException("Argument ${parserArgument?index} expected to be of type ${languageName} or a string which is parseable but was " + args[${parserArgument?index}].getClass().getName())
+ raise PlcRuntimeException("Argument ${parserArgument?index} expected to be of type ${languageName} or a string which is parseable but was " + kwargs.get("${parserArgument.name}").getClass().getName())
</#list>
</#if>
- return self.static_parse_context(read_buffer<#if parserArguments?has_content>, <#list parserArguments as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>)
+ return ${type.name}.static_parse_context(read_buffer<#if parserArguments?has_content>, <#list parserArguments as parserArgument>${parserArgument.name}<#sep>, </#sep></#list></#if>)
</#if>
@@ -588,21 +590,24 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
raise ParseException("array fields of type byte only support 'count' and 'length' loop-types.")
</#if>
<@emitImport import="from typing import List" />
- ${helper.camelCaseToSnakeCase(namedField.name)}: List[int] = read_buffer.read_byte_array("${namedField.name}", int(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ <@emitImport import="from typing import Any" />
+ ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field(logical_name="${arrayField.name}", read_function=<#if arrayElementTypeReference.isComplexTypeReference()><#else>read_buffer.</#if>${helper.getDataReaderCall(arrayField.type)}<#if arrayElementTypeReference.isComplexTypeReference()><#else>, </#if>count=${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField [...]
<#else>
<#-- If this is a count array, we can directly initialize an array with the given size -->
<#if field.isCountArrayField()>
<@emitImport import="from typing import List" />
<@emitImport import="from typing import Any" />
- ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field("${arrayField.name}", read_buffer.${helper.getDataReaderCall(arrayField.type)}, count=${helper.camelCaseToSnakeCase(helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments))}${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field(logical_name="${arrayField.name}", read_function=<#if arrayElementTypeReference.isComplexTypeReference()><#else>read_buffer.</#if>${helper.getDataReaderCall(arrayField.type)}<#if arrayElementTypeReference.isComplexTypeReference()><#else>, </#if>count=${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}${helper.getFieldOptions(typedField [...]
<#-- In all other cases do we have to work with a list, that is later converted to an array -->
<#else>
<#-- For a length array, we read data till the read position of the buffer reaches a given position -->
+ <@emitImport import="from typing import List" />
+ <@emitImport import="from typing import Any" />
<#if field.isLengthArrayField()>
- ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field("${arrayField.name}", read_buffer.${helper.getDataReaderCall(arrayField.type)}, length=${helper.camelCaseToSnakeCase(helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments))}${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field(logical_name="${arrayField.name}", read_function=<#if arrayElementTypeReference.isComplexTypeReference()><#else>read_buffer.</#if>${helper.getDataReaderCall(arrayField.type)}<#if arrayElementTypeReference.isComplexTypeReference()><#else>, </#if>length=${helper.camelCaseToSnakeCase(helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments))}${hel [...]
<#-- A terminated array keeps on reading data as long as the termination expression evaluates to false -->
<#elseif field.isTerminatedArrayField()>
- ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field("${arrayField.name}", read_buffer.${helper.getDataReaderCall(arrayField.type)}, terminated=lambda : (c_bool(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}))${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field(logical_name="${arrayField.name}", read_function=<#if arrayElementTypeReference.isComplexTypeReference()><#else>read_buffer.</#if>${helper.getDataReaderCall(arrayField.type)}<#if arrayElementTypeReference.isComplexTypeReference()><#else>, </#if>terminated=lambda : (c_bool(${helper.toParseExpression(arrayField, helper.intTypeReference, arrayField.loopExpression, parserArguments)}))${helper.ge [...]
</#if>
</#if>
</#if>
@@ -612,42 +617,43 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(assertField, assertField.type, assertField.conditionExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_buffer.${helper.getDataReaderCall(assertField.type)}(logical_name="${namedField.name}"${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "checksum">
<#assign checksumField = field.asChecksumField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
+ <@emitImport import="from plc4py.protocols.${protocolName} import StaticHelper" />
- ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, (${helper.getLanguageTypeNameForField(field)}) (${helper.toParseExpression(checksumField, checksumField.type, checksumField.checksumExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_buffer.${helper.getDataReaderCall(checksumField.type)}(logical_name="${namedField.name}"${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "const">
<#assign constField = field.asConstField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- self.${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}, ${type.name}.${namedField.name?upper_case}${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_buffer.${helper.getDataReaderCall(constField.type)}(logical_name="${namedField.name}"${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "discriminator">
<#assign discriminatorField = field.asDiscriminatorField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_buffer.${helper.getDataReaderCall(discriminatorField.type)}(logical_name="${namedField.name}"${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "enum">
<#assign enumField = field.asEnumField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- self.${helper.camelCaseToSnakeCase(namedField.name)} = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", "${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}", readEnum(${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}::firstEnumForField${enumField.fieldName?cap_first}, ${helper.getDataReaderCall(helper.getEnumFieldTypeReference(enumField.type, enumField.fieldName))})${helper.getFieldOptions(typ [...]
+ ${helper.camelCaseToSnakeCase(namedField.name)} = read_buffer.${helper.getDataReaderCall(enumField.type)}(logical_name="${namedField.name}", readEnum(${enumField.type.asNonSimpleTypeReference().orElseThrow().typeDefinition.name}::firstEnumForField${enumField.fieldName?cap_first}, ${helper.getDataReaderCall(helper.getEnumFieldTypeReference(enumField.type, enumField.fieldName))}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "implicit">
<#assign implicitField = field.asImplicitField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForField(field)} = read_buffer.${helper.getDataReaderCall(implicitField.type)}(logical_name="${namedField.name}"${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "manualArray">
<#assign manualArrayField = field.asManualArrayField().orElseThrow()>
@@ -657,9 +663,12 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#if arrayElementTypeReference.isByteBased()>
<@emitImport import="from typing import List" />
- self.${helper.camelCaseToSnakeCase(namedField.name)} = read_manual_byte_array_field("${namedField.name}", read_buffer, lambda _values: bool(${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), lambda : byte(${helper.toParseExpression(manualArrayField, manualArrayField.type, manualArrayField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ <@emitImport import="from typing import Any" />
+ ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field(logical_name="${manualArrayField.name}", read_function=<#if manualArrayField.type.isComplexTypeReference()><#else>read_buffer.</#if>${helper.getDataReaderCall(manualArrayField.type)}manual_start = lambda _values: bool(${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), manual_stop = lambda : byte(${helper.toParseExpressi [...]
<#else>
- self.${helper.camelCaseToSnakeCase(namedField.name)} = read_manual_array_field("${namedField.name}", read_buffer, lambda _values: ${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} : bool(${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, parserArguments)}), lambda : ${helper.getLanguageTypeNameForTypeReference(manualArrayField.type.elementTypeReference)}(${helper.toParseExpression(manualArrayField, manualArray [...]
+ <@emitImport import="from typing import List" />
+ <@emitImport import="from typing import Any" />
+ ${helper.camelCaseToSnakeCase(arrayField.name)}: List[Any] = read_buffer.read_array_field(logical_name="${manualArrayField.name}", read_function=<#if manualArrayField.type.isComplexTypeReference()><#else>read_buffer.</#if>${helper.getDataReaderCall(manualArrayField.type)}manual_start = lambda _values: ${helper.getNonPrimitiveLanguageTypeNameForField(manualArrayField)} : bool(${helper.toParseExpression(manualArrayField, helper.boolTypeReference, manualArrayField.loopExpression, pa [...]
</#if>
<#break>
<#case "manual">
@@ -667,34 +676,34 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- self.${helper.camelCaseToSnakeCase(manualField.name)} = read_manual_field("${namedField.name}", read_buffer, lambda : ${helper.getLanguageTypeNameForField(manualField)}(${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(manualField.name)} = read_buffer.${helper.getDataReaderCall(manualField.type)}(logical_name="${namedField.name}", read_buffer, lambda : ${helper.getLanguageTypeNameForField(manualField)}(${helper.toParseExpression(manualField, manualField.type, manualField.parseExpression, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "optional">
<#assign optionalField = field.asOptionalField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- self.${helper.camelCaseToSnakeCase(namedField.name)} = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if optionalField.conditionExpression.present>, ${helper.toParseExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
+ ${helper.camelCaseToSnakeCase(namedField.name)} = read_buffer.${helper.getDataReaderCall(optionalField.type)}(logical_name="${namedField.name}"<#if optionalField.conditionExpression.present>, ${helper.toParseExpression(optionalField, helper.boolTypeReference, optionalField.conditionExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "padding">
<#assign paddingField = field.asPaddingField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign simpleTypeReference = paddingField.type.asSimpleTypeReference().orElseThrow()>
- read_${helper.camelCaseToSnakeCase(field.typeName)}_field(${helper.getDataReaderCall(typedField.type)}, (int) (${helper.toParseExpression(paddingField, paddingField.type, paddingField.paddingCondition, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
+ read_buffer.${helper.getDataReaderCall(paddingField.type)}(int) (${helper.toParseExpression(paddingField, paddingField.type, paddingField.paddingCondition, parserArguments)})${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "reserved">
<#assign reservedField = field.asReservedField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
- reserved_field_${reservedFieldIndex}: ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)}<#assign reservedFieldIndex=reservedFieldIndex+1> = read_${helper.camelCaseToSnakeCase(field.typeName)}_field("reserved", ${helper.getDataReaderCall(typedField.type)}, ${helper.getReservedValue(reservedField)}${helper.getFieldOptions(typedField, parserArguments)})
+ reserved_field_${reservedFieldIndex}: ${helper.getLanguageTypeNameForTypeReference(reservedField.type, false)}<#assign reservedFieldIndex=reservedFieldIndex+1> = read_buffer.${helper.getDataReaderCall(reservedField.type)}(logical_name="reserved"${helper.getReservedValue(reservedField)}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "simple">
<#assign simpleField = field.asSimpleField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- self.${helper.camelCaseToSnakeCase(namedField.name)}= <#if typedField.type.isEnumTypeReference()>read_enum_field("${namedField.name}", "${helper.getLanguageTypeNameForField(field)}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})<#else>read_${helper.camelCaseToSnakeCase(field.typeName)}_field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})</#if>
+ ${helper.camelCaseToSnakeCase(namedField.name)}: ${helper.getLanguageTypeNameForTypeReference(simpleField.type, false)} = <#if typedField.type.isEnumTypeReference()>read_buffer.${helper.getDataReaderCall(simpleField.type)}logical_name="${namedField.name}"${helper.getFieldOptions(typedField, parserArguments)})<#else><#if simpleField.type.isComplexTypeReference()>read_buffer.${helper.getDataReaderCall(simpleField.type)}logical_name="${namedField.name}"${helper.getFieldOptions(typed [...]
<#break>
<#case "switch">
<#assign switchField = field.asSwitchField().orElseThrow()>
@@ -710,17 +719,16 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#else>
<#assign discriminatorExpression=switchField.discriminatorExpressions[discriminatorValueTerm?index].asLiteral().orElseThrow().asVariableLiteral().orElseThrow()>
<#assign discriminatorType=helper.getDiscriminatorTypes()[discriminatorExpression.discriminatorName]>
- EvaluationHelper.equals(
- ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)},
+ ${helper.toParseExpression(switchField, discriminatorType, discriminatorExpression, parserArguments)} ==
<#if discriminatorType.isEnumTypeReference()>
${helper.getLanguageTypeNameForTypeReference(discriminatorType)}.${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)}
<#else>
${helper.getLanguageTypeNameForTypeReference(discriminatorType, true)}(${helper.toParseExpression(switchField, discriminatorType, discriminatorValueTerm, parserArguments)})
</#if>
</#if>
- <#sep>) and </#sep>
+ <#sep> and </#sep>
</#list>
- ):</...@compress>
+ :</...@compress>
</#if>
builder = <@compress single_line=true>
@@ -738,13 +746,13 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign unknownField = field.asUnknownField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
- read${field.typeName?cap_first}Field("unknown", ${helper.getDataReaderCall(typedField.type)}${helper.getFieldOptions(typedField, parserArguments)})
+ read_buffer.${helper.getDataReaderCall(unknownField.type)}(logical_name="unknown"${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "virtual">
<#assign virtualField = field.asVirtualField().orElseThrow()>
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getLanguageTypeNameForField(field)}.class, ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read_buffer.${helper.getDataReaderCall(virtualField.type)}(logical_name="${namedField.name}", ${helper.getLanguageTypeNameForField(field)}.class, ${helper.toParseExpression(virtualField, virtualField.type, virtualField.valueExpression, parserArguments)}${helper.getFieldOptions(typedField, parserArguments)})
<#break>
<#case "validation">
<#assign validationField = field.asValidationField().orElseThrow()>
@@ -760,7 +768,7 @@ class ${type.name}<#if type.isDiscriminatedParentTypeDefinition()></#if>(<#if ty
<#assign typedField = field.asTypedField().orElseThrow()>
<#assign namedField = field.asNamedField().orElseThrow()>
- ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read${field.typeName?cap_first}Field("${namedField.name}", ${helper.getDataReaderCall(typedField.type)}<#if peekField.offsetExpression.present>, ${helper.toParseExpression(peekField, helper.boolTypeReference, peekField.offsetExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
+ ${namedField.name}: ${helper.getLanguageTypeNameForField(field)} = read_buffer.${helper.getDataReaderCall(peekField.type)}(logical_name="${namedField.name}"<#if peekField.offsetExpression.present>, ${helper.toParseExpression(peekField, helper.boolTypeReference, peekField.offsetExpression.get(), parserArguments)}</#if>${helper.getFieldOptions(typedField, parserArguments)})
<#break>
</#switch>
</#list>
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
index 3b04b71b82..ed1e6be6fc 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/DataItem.py
@@ -29,7 +29,7 @@ class DataItem:
read_buffer: ReadBuffer, data_type: ModbusDataType, number_of_values: int
):
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_bool()
+ data_type, ModbusDataType.BOOL
) and EvaluationHelper.equals(
number_of_values, int(1)
): # BOOL
@@ -48,25 +48,25 @@ class DataItem:
value: bool = read_buffer.read_bit("")
return PlcBOOL(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_bool()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.BOOL): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcBOOL(bool(read_buffer.read_bit(""))))
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_byte()
+ data_type, ModbusDataType.BYTE
) and EvaluationHelper.equals(
number_of_values, int(1)
): # BYTE
@@ -85,40 +85,40 @@ class DataItem:
value: int = read_buffer.read_unsigned_short(8, logical_name="")
return PlcBYTE(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_byte()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.BYTE): # List
# Array field (value)
# Count array
- if numberOfValues * int(8) > Integer.MAX_VALUE:
+ if number_of_values * int(8) > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues * int(8))
+ + (number_of_values * int(8))
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues * int(8))
+ item_count: int = int(number_of_values * int(8))
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcBOOL(bool(read_buffer.read_bit(""))))
return PlcList(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_word()): # WORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.WORD): # WORD
# Simple Field (value)
value: int = read_buffer.read_unsigned_int(16, logical_name="")
return PlcWORD(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_dword()): # DWORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.DWORD): # DWORD
# Simple Field (value)
value: int = read_buffer.read_unsigned_long(32, logical_name="")
return PlcDWORD(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_lword()): # LWORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.LWORD): # LWORD
# Simple Field (value)
value: int = read_buffer.read_unsigned_big_integer(64, logical_name="")
return PlcLWORD(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_sint()
+ data_type, ModbusDataType.SINT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # SINT
@@ -137,18 +137,18 @@ class DataItem:
value: int = read_buffer.read_signed_byte(8, logical_name="")
return PlcSINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_sint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.SINT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -157,7 +157,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_int()
+ data_type, ModbusDataType.INT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # INT
@@ -165,25 +165,25 @@ class DataItem:
value: int = read_buffer.read_short(16, logical_name="")
return PlcINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_int()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.INT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcINT(int(read_buffer.read_short(16, logical_name=""))))
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_dint()
+ data_type, ModbusDataType.DINT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # DINT
@@ -191,25 +191,25 @@ class DataItem:
value: int = read_buffer.read_int(32, logical_name="")
return PlcDINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_dint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.DINT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcDINT(int(read_buffer.read_int(32, logical_name=""))))
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_lint()
+ data_type, ModbusDataType.LINT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # LINT
@@ -217,25 +217,25 @@ class DataItem:
value: int = read_buffer.read_long(64, logical_name="")
return PlcLINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_lint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.LINT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcLINT(int(read_buffer.read_long(64, logical_name=""))))
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_usint()
+ data_type, ModbusDataType.USINT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # USINT
@@ -254,18 +254,18 @@ class DataItem:
value: int = read_buffer.read_unsigned_short(8, logical_name="")
return PlcUSINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_usint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.USINT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -274,7 +274,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_uint()
+ data_type, ModbusDataType.UINT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # UINT
@@ -282,18 +282,18 @@ class DataItem:
value: int = read_buffer.read_unsigned_int(16, logical_name="")
return PlcUINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_uint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.UINT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -302,7 +302,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_udint()
+ data_type, ModbusDataType.UDINT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # UDINT
@@ -310,18 +310,18 @@ class DataItem:
value: int = read_buffer.read_unsigned_long(32, logical_name="")
return PlcUDINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_udint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.UDINT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -330,7 +330,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_ulint()
+ data_type, ModbusDataType.ULINT
) and EvaluationHelper.equals(
number_of_values, int(1)
): # ULINT
@@ -338,18 +338,18 @@ class DataItem:
value: int = read_buffer.read_unsigned_big_integer(64, logical_name="")
return PlcULINT(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_ulint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.ULINT): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -360,7 +360,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_real()
+ data_type, ModbusDataType.REAL
) and EvaluationHelper.equals(
number_of_values, int(1)
): # REAL
@@ -368,18 +368,18 @@ class DataItem:
value: float = read_buffer.read_float(32, logical_name="")
return PlcREAL(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_real()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.REAL): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -388,7 +388,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_lreal()
+ data_type, ModbusDataType.LREAL
) and EvaluationHelper.equals(
number_of_values, int(1)
): # LREAL
@@ -396,18 +396,18 @@ class DataItem:
value: float = read_buffer.read_double(64, logical_name="")
return PlcLREAL(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_lreal()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.LREAL): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -416,7 +416,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_char()
+ data_type, ModbusDataType.CHAR
) and EvaluationHelper.equals(
number_of_values, int(1)
): # CHAR
@@ -424,18 +424,18 @@ class DataItem:
value: str = read_buffer.read_string(8, logical_name="", encoding="")
return PlcCHAR(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_char()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.CHAR): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -446,7 +446,7 @@ class DataItem:
return PlcList(value)
if EvaluationHelper.equals(
- data_type, ModbusDataType.get_wchar()
+ data_type, ModbusDataType.WCHAR
) and EvaluationHelper.equals(
number_of_values, int(1)
): # WCHAR
@@ -454,18 +454,18 @@ class DataItem:
value: str = read_buffer.read_string(16, logical_name="", encoding="")
return PlcWCHAR(value)
- if EvaluationHelper.equals(data_type, ModbusDataType.get_wchar()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.WCHAR): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -497,16 +497,16 @@ class DataItem:
byteOrder: ByteOrder,
) -> None:
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_bool()
+ data_type, ModbusDataType.BOOL
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # BOOL
# Reserved Field
writeBuffer.WriteUint16("int0x0000", 15, int(0x0000))
# Simple Field (value)
value: bool = _value.getBool()
writeBuffer.WriteBit("value", (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_bool()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.BOOL): # List
values: PlcList = _value
for val in values.getList():
@@ -514,45 +514,45 @@ class DataItem:
writeBuffer.WriteBit("value", (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_byte()
+ data_type, ModbusDataType.BYTE
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # BYTE
# Reserved Field
writeBuffer.WriteUint8("int0x00", 8, int(0x00))
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint8("value", 8, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_byte()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.BYTE): # List
values: PlcList = _value
for val in values.getList():
value: bool = val.getBool()
writeBuffer.WriteBit("value", (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_word()): # WORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.WORD): # WORD
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint16("value", 16, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_dword()): # DWORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.DWORD): # DWORD
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint32("value", 32, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_lword()): # LWORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.LWORD): # LWORD
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint64("value", 64, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_sint()
+ data_type, ModbusDataType.SINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # SINT
# Reserved Field
writeBuffer.WriteUint8("int0x00", 8, int(0x00))
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt8("value", 8, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_sint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.SINT): # List
values: PlcList = _value
for val in values.getList():
@@ -560,14 +560,14 @@ class DataItem:
writeBuffer.WriteInt8("value", 8, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_int()
+ data_type, ModbusDataType.INT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # INT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt16("value", 16, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_int()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.INT): # List
values: PlcList = _value
for val in values.getList():
@@ -575,14 +575,14 @@ class DataItem:
writeBuffer.WriteInt16("value", 16, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_dint()
+ data_type, ModbusDataType.DINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # DINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt32("value", 32, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_dint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.DINT): # List
values: PlcList = _value
for val in values.getList():
@@ -590,14 +590,14 @@ class DataItem:
writeBuffer.WriteInt32("value", 32, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_lint()
+ data_type, ModbusDataType.LINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # LINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt64("value", 64, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_lint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.LINT): # List
values: PlcList = _value
for val in values.getList():
@@ -605,16 +605,16 @@ class DataItem:
writeBuffer.WriteInt64("value", 64, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_usint()
+ data_type, ModbusDataType.USINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # USINT
# Reserved Field
writeBuffer.WriteUint8("int0x00", 8, int(0x00))
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint8("value", 8, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_usint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.USINT): # List
values: PlcList = _value
for val in values.getList():
@@ -622,14 +622,14 @@ class DataItem:
writeBuffer.WriteUint8("value", 8, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_uint()
+ data_type, ModbusDataType.UINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # UINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint16("value", 16, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_uint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.UINT): # List
values: PlcList = _value
for val in values.getList():
@@ -637,14 +637,14 @@ class DataItem:
writeBuffer.WriteUint16("value", 16, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_udint()
+ data_type, ModbusDataType.UDINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # UDINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint32("value", 32, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_udint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.UDINT): # List
values: PlcList = _value
for val in values.getList():
@@ -652,14 +652,14 @@ class DataItem:
writeBuffer.WriteUint32("value", 32, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_ulint()
+ data_type, ModbusDataType.ULINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # ULINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint64("value", 64, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_ulint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.ULINT): # List
values: PlcList = _value
for val in values.getList():
@@ -667,14 +667,14 @@ class DataItem:
writeBuffer.WriteUint64("value", 64, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_real()
+ data_type, ModbusDataType.REAL
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # REAL
# Simple Field (value)
value: float = _value.getFloat()
writeBuffer.WriteFloat32("value", 32, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_real()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.REAL): # List
values: PlcList = _value
for val in values.getList():
@@ -682,14 +682,14 @@ class DataItem:
writeBuffer.WriteFloat32("value", 32, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_lreal()
+ data_type, ModbusDataType.LREAL
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # LREAL
# Simple Field (value)
value: float = _value.getFloat()
writeBuffer.WriteFloat64("value", 64, (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_lreal()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.LREAL): # List
values: PlcList = _value
for val in values.getList():
@@ -697,14 +697,14 @@ class DataItem:
writeBuffer.WriteFloat64("value", 64, (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_char()
+ data_type, ModbusDataType.CHAR
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # CHAR
# Simple Field (value)
value: str = _value.getStr()
writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_char()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.CHAR): # List
values: PlcList = _value
for val in values.getList():
@@ -712,14 +712,14 @@ class DataItem:
writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_wchar()
+ data_type, ModbusDataType.WCHAR
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # WCHAR
# Simple Field (value)
value: str = _value.getStr()
writeBuffer.WriteString("value", uint32(16), "UTF-16", (value))
- if EvaluationHelper.equals(dataType, ModbusDataType.get_wchar()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.WCHAR): # List
values: PlcList = _value
for val in values.getList():
@@ -740,160 +740,160 @@ class DataItem:
) -> int:
sizeInBits: int = 0
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_bool()
+ data_type, ModbusDataType.BOOL
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # BOOL
# Reserved Field
sizeInBits += 15
# Simple Field (value)
sizeInBits += 1
- if EvaluationHelper.equals(dataType, ModbusDataType.get_bool()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.BOOL): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 1
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_byte()
+ data_type, ModbusDataType.BYTE
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # BYTE
# Reserved Field
sizeInBits += 8
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, ModbusDataType.get_byte()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.BYTE): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 1
- if EvaluationHelper.equals(dataType, ModbusDataType.get_word()): # WORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.WORD): # WORD
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, ModbusDataType.get_dword()): # DWORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.DWORD): # DWORD
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, ModbusDataType.get_lword()): # LWORD
+ if EvaluationHelper.equals(data_type, ModbusDataType.LWORD): # LWORD
# Simple Field (value)
sizeInBits += 64
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_sint()
+ data_type, ModbusDataType.SINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # SINT
# Reserved Field
sizeInBits += 8
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, ModbusDataType.get_sint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.SINT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 8
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_int()
+ data_type, ModbusDataType.INT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # INT
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, ModbusDataType.get_int()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.INT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 16
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_dint()
+ data_type, ModbusDataType.DINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # DINT
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, ModbusDataType.get_dint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.DINT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 32
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_lint()
+ data_type, ModbusDataType.LINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # LINT
# Simple Field (value)
sizeInBits += 64
- if EvaluationHelper.equals(dataType, ModbusDataType.get_lint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.LINT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 64
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_usint()
+ data_type, ModbusDataType.USINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # USINT
# Reserved Field
sizeInBits += 8
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, ModbusDataType.get_usint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.USINT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 8
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_uint()
+ data_type, ModbusDataType.UINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # UINT
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, ModbusDataType.get_uint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.UINT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 16
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_udint()
+ data_type, ModbusDataType.UDINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # UDINT
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, ModbusDataType.get_udint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.UDINT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 32
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_ulint()
+ data_type, ModbusDataType.ULINT
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # ULINT
# Simple Field (value)
sizeInBits += 64
- if EvaluationHelper.equals(dataType, ModbusDataType.get_ulint()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.ULINT): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 64
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_real()
+ data_type, ModbusDataType.REAL
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # REAL
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, ModbusDataType.get_real()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.REAL): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 32
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_lreal()
+ data_type, ModbusDataType.LREAL
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # LREAL
# Simple Field (value)
sizeInBits += 64
- if EvaluationHelper.equals(dataType, ModbusDataType.get_lreal()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.LREAL): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 64
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_char()
+ data_type, ModbusDataType.CHAR
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # CHAR
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, ModbusDataType.get_char()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.CHAR): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 8
if EvaluationHelper.equals(
- dataType, ModbusDataType.get_wchar()
+ data_type, ModbusDataType.WCHAR
) and EvaluationHelper.equals(
- numberOfValues, int(1)
+ number_of_values, int(1)
): # WCHAR
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, ModbusDataType.get_wchar()): # List
+ if EvaluationHelper.equals(data_type, ModbusDataType.WCHAR): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 16
return sizeInBits
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
index b5376f947a..a351998663 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusADU.py
@@ -27,15 +27,15 @@ from plc4py.protocols.modbus.readwrite.DriverType import DriverType
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
import math
-
-
+
@dataclass
class ModbusADU(ABC, PlcMessage):
# Arguments.
response: bool
+
def __post_init__(self):
- super().__init__()
+ super().__init__( )
# Abstract accessors for discriminator values.
@property
@@ -43,6 +43,7 @@ class ModbusADU(ABC, PlcMessage):
def driver_type(self) -> DriverType:
pass
+
@abstractmethod
def serialize_modbus_adu_child(self, write_buffer: WriteBuffer) -> None:
pass
@@ -55,6 +56,7 @@ class ModbusADU(ABC, PlcMessage):
write_buffer.pop_context("ModbusADU")
+
def length_in_bytes(self) -> int:
return int(math.ceil(float(self.get_length_in_bits() / 8.0)))
@@ -66,70 +68,59 @@ class ModbusADU(ABC, PlcMessage):
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- if args is None:
- raise PlcRuntimeException(
- "Wrong number of arguments, expected 2, but got None"
- )
- elif args.length != 2:
- raise PlcRuntimeException(
- "Wrong number of arguments, expected 2, but got " + str(len(args))
- )
+
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+
+ if kwargs is None:
+ raise PlcRuntimeException("Wrong number of arguments, expected 2, but got None")
+ elif len(kwargs) 2:
+ raise PlcRuntimeException("Wrong number of arguments, expected 2, but got " + str(len(kwargs)))
driverType: DriverType = 0
- if isinstance(args[0], DriverType):
- driverType = DriverType(args[0])
- elif isinstance(args[0], str):
- driverType = DriverType(str(args[0]))
+ if isinstance(kwargs.get("driverType"), DriverType):
+ driverType = DriverType(kwargs.get("driverType"))
+ elif isinstance(kwargs.get("driverType"), str):
+ driverType = DriverType(str(kwargs.get("driverType")))
else:
- raise PlcRuntimeException(
- "Argument 0 expected to be of type DriverType or a string which is parseable but was "
- + args[0].getClass().getName()
- )
+ raise PlcRuntimeException("Argument 0 expected to be of type DriverType or a string which is parseable but was " + kwargs.get("driverType").getClass().getName())
response: bool = False
- if isinstance(args[1], bool):
- response = bool(args[1])
- elif isinstance(args[1], str):
- response = bool(str(args[1]))
+ if isinstance(kwargs.get("response"), bool):
+ response = bool(kwargs.get("response"))
+ elif isinstance(kwargs.get("response"), str):
+ response = bool(str(kwargs.get("response")))
else:
- raise PlcRuntimeException(
- "Argument 1 expected to be of type bool or a string which is parseable but was "
- + args[1].getClass().getName()
- )
+ raise PlcRuntimeException("Argument 1 expected to be of type bool or a string which is parseable but was " + kwargs.get("response").getClass().getName())
+
+ return ModbusADU.static_parse_context(read_buffer, driverType, response)
- return self.static_parse_context(read_buffer, driverType, response)
@staticmethod
- def static_parse_context(
- read_buffer: ReadBuffer, driver_type: DriverType, response: bool
- ):
+ def static_parse_context(read_buffer: ReadBuffer, driver_type: DriverType, response: bool):
read_buffer.push_context("ModbusADU")
# Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
builder: ModbusADUBuilder = None
- if EvaluationHelper.equals(driverType, DriverType.get_modbu_s__tcp()):
+ if driver_type == DriverType.MODBUS_TCP :
+
builder = ModbusTcpADU.staticParseBuilder(read_buffer, driverType, response)
- if EvaluationHelper.equals(driverType, DriverType.get_modbu_s__rtu()):
+ if driver_type == DriverType.MODBUS_RTU :
+
builder = ModbusRtuADU.staticParseBuilder(read_buffer, driverType, response)
- if EvaluationHelper.equals(driverType, DriverType.get_modbu_s__ascii()):
- builder = ModbusAsciiADU.staticParseBuilder(
- read_buffer, driverType, response
- )
+ if driver_type == DriverType.MODBUS_ASCII :
+
+ builder = ModbusAsciiADU.staticParseBuilder(read_buffer, driverType, response)
if builder is None:
- raise ParseException(
- "Unsupported case for discriminated type"
- + " parameters ["
- + "driverType="
- + driverType
- + "]"
- )
+ raise ParseException("Unsupported case for discriminated type"+" parameters ["+"driverType="+driver_type+"]")
+
read_buffer.pop_context("ModbusADU")
# Create the instance
- _modbus_adu: ModbusADU = builder.build(response)
+ _modbus_adu: ModbusADU = builder.build(response )
return _modbus_adu
+
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -152,7 +143,10 @@ class ModbusADU(ABC, PlcMessage):
return "\n" + str(write_buffer_box_based.get_box()) + "\n"
-
class ModbusADUBuilder:
- def build(self, response: bool) -> ModbusADU:
+ def build(self, response: bool ) -> ModbusADU:
pass
+
+
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
index 4e070c7a50..c63f2dc9cd 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusAsciiADU.py
@@ -27,6 +27,7 @@ from plc4py.protocols.modbus.readwrite.ModbusADU import ModbusADUBuilder
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from plc4py.utils.GenericTypes import ByteOrder
import math
@@ -53,8 +54,7 @@ class ModbusAsciiADU(PlcMessage, ModbusADU):
# Checksum Field (checksum) (Calculated)
write_buffer.write_unsigned_byte(
- int(StaticHelper.ascii_lrc_check(self.address, self.pdu)),
- logical_name="crc",
+ int(StaticHelper.ascii_lrc_check(address, pdu)), logical_name="crc"
)
write_buffer.pop_context("ModbusAsciiADU")
@@ -83,23 +83,18 @@ class ModbusAsciiADU(PlcMessage, ModbusADU):
):
read_buffer.push_context("ModbusAsciiADU")
- self.address = read_simple_field(
- "address", read_unsigned_short, WithOption.WithByteOrder(get_bi_g__endian())
+ address: int = read_buffer.read_unsigned_short(
+ logical_name="address", byte_order=ByteOrder.BIG_ENDIAN
)
- self.pdu = read_simple_field(
- "pdu",
- DataReaderComplexDefault(
- ModbusPDU.static_parse(read_buffer, bool(response)), read_buffer
- ),
- WithOption.WithByteOrder(get_bi_g__endian()),
+ pdu: ModbusPDU = read_buffer.read_complex(
+ read_function=ModbusPDU.static_parse,
+ logical_name="pdu",
+ byte_order=ByteOrder.BIG_ENDIAN,
)
- crc: int = read_checksum_field(
- "crc",
- read_unsigned_short,
- (int)(ascii_lrc_check(self.address, self.pdu)),
- WithOption.WithByteOrder(get_bi_g__endian()),
+ crc: int = read_buffer.read_unsigned_short(
+ logical_name="crc", byte_order=ByteOrder.BIG_ENDIAN
)
read_buffer.pop_context("ModbusAsciiADU")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
index 7408555eca..5401ccbecf 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusConstants.py
@@ -54,17 +54,16 @@ class ModbusConstants(PlcMessage):
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- return self.static_parse_context(read_buffer)
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+ return ModbusConstants.static_parse_context(read_buffer)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer):
read_buffer.push_context("ModbusConstants")
- self.modbus_tcp_default_port: int = read_const_field(
- "modbusTcpDefaultPort",
- read_unsigned_int,
- ModbusConstants.MODBUSTCPDEFAULTPORT,
+ modbus_tcp_default_port: int = read_buffer.read_unsigned_int(
+ logical_name="modbusTcpDefaultPort"
)
read_buffer.pop_context("ModbusConstants")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
index 1db6735655..d08db78dea 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusDeviceInformationObject.py
@@ -22,6 +22,7 @@ from dataclasses import dataclass
from plc4py.api.messages.PlcMessage import PlcMessage
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -63,23 +64,30 @@ class ModbusDeviceInformationObject(PlcMessage):
length_in_bits += 8
# Array field
- if self.data != None:
+ if self.data is not None:
length_in_bits += 8 * len(self.data)
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- return self.static_parse_context(read_buffer)
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+ return ModbusDeviceInformationObject.static_parse_context(read_buffer)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer):
read_buffer.push_context("ModbusDeviceInformationObject")
- self.object_id = read_simple_field("objectId", read_unsigned_short)
+ object_id: int = read_buffer.read_unsigned_short(logical_name="objectId")
- object_length: int = read_implicit_field("objectLength", read_unsigned_short)
+ object_length: int = read_buffer.read_unsigned_short(
+ logical_name="objectLength"
+ )
- data: List[int] = read_buffer.read_byte_array("data", int(object_length))
+ data: List[Any] = read_buffer.read_array_field(
+ logical_name="data",
+ read_function=read_buffer.read_byte,
+ count=object_length,
+ )
read_buffer.pop_context("ModbusDeviceInformationObject")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
index e78159b05d..f896e394f1 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDU.py
@@ -26,29 +26,29 @@ from plc4py.api.messages.PlcMessage import PlcMessage
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
import math
-
-
+
@dataclass
class ModbusPDU(ABC, PlcMessage):
+
+
def __post_init__(self):
- super().__init__()
+ super().__init__( )
# Abstract accessors for discriminator values.
@property
@abstractmethod
def error_flag(self) -> bool:
pass
-
@property
@abstractmethod
def function_flag(self) -> int:
pass
-
@property
@abstractmethod
def response(self) -> bool:
pass
+
@abstractmethod
def serialize_modbus_pdu_child(self, write_buffer: WriteBuffer) -> None:
pass
@@ -60,15 +60,14 @@ class ModbusPDU(ABC, PlcMessage):
write_buffer.write_boolean(self.error_flag(), logical_name="errorFlag")
# Discriminator Field (functionFlag) (Used as input to a switch field)
- write_buffer.write_unsigned_byte(
- self.function_flag(), logical_name="functionFlag"
- )
+ write_buffer.write_unsigned_byte(self.function_flag(), logical_name="functionFlag")
# Switch field (Serialize the sub-type)
self.serialize_modbus_pdu_child(write_buffer)
write_buffer.pop_context("ModbusPDU")
+
def length_in_bytes(self) -> int:
return int(math.ceil(float(self.get_length_in_bits() / 8.0)))
@@ -86,371 +85,163 @@ class ModbusPDU(ABC, PlcMessage):
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- if args is None:
- raise PlcRuntimeException(
- "Wrong number of arguments, expected 1, but got None"
- )
- elif args.length != 1:
- raise PlcRuntimeException(
- "Wrong number of arguments, expected 1, but got " + str(len(args))
- )
+
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+
+ if kwargs is None:
+ raise PlcRuntimeException("Wrong number of arguments, expected 1, but got None")
+ elif len(kwargs) 1:
+ raise PlcRuntimeException("Wrong number of arguments, expected 1, but got " + str(len(kwargs)))
response: bool = False
- if isinstance(args[0], bool):
- response = bool(args[0])
- elif isinstance(args[0], str):
- response = bool(str(args[0]))
+ if isinstance(kwargs.get("response"), bool):
+ response = bool(kwargs.get("response"))
+ elif isinstance(kwargs.get("response"), str):
+ response = bool(str(kwargs.get("response")))
else:
- raise PlcRuntimeException(
- "Argument 0 expected to be of type bool or a string which is parseable but was "
- + args[0].getClass().getName()
- )
+ raise PlcRuntimeException("Argument 0 expected to be of type bool or a string which is parseable but was " + kwargs.get("response").getClass().getName())
+
+ return ModbusPDU.static_parse_context(read_buffer, response)
- return self.static_parse_context(read_buffer, response)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDU")
- error_flag: bool = read_discriminator_field("errorFlag", read_bit)
+ error_flag: bool = read_buffer.read_bit(logical_name="errorFlag")
- function_flag: int = read_discriminator_field(
- "functionFlag", read_unsigned_short
- )
+ function_flag: int = read_buffer.read_unsigned_short(logical_name="functionFlag")
# Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
builder: ModbusPDUBuilder = None
- if EvaluationHelper.equals(errorFlag, bool(True)):
+ if error_flag == bool(True) :
+
builder = ModbusPDUError.staticParseBuilder(read_buffer, response)
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x02))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadDiscreteInputsRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x02))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadDiscreteInputsResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x01))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadCoilsRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x01))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadCoilsResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x05))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUWriteSingleCoilRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x05))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUWriteSingleCoilResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x0F))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUWriteMultipleCoilsRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x0F))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUWriteMultipleCoilsResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x04))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadInputRegistersRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x04))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadInputRegistersResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x03))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadHoldingRegistersRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x03))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadHoldingRegistersResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x06))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUWriteSingleRegisterRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x06))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUWriteSingleRegisterResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x10))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUWriteMultipleHoldingRegistersRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x10))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUWriteMultipleHoldingRegistersResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x17))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = (
- ModbusPDUReadWriteMultipleHoldingRegistersRequest.staticParseBuilder(
- read_buffer, response
- )
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x17))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = (
- ModbusPDUReadWriteMultipleHoldingRegistersResponse.staticParseBuilder(
- read_buffer, response
- )
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x16))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUMaskWriteHoldingRegisterRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x16))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUMaskWriteHoldingRegisterResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x18))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadFifoQueueRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x18))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadFifoQueueResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x14))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadFileRecordRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x14))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadFileRecordResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x15))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUWriteFileRecordRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x15))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUWriteFileRecordResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x07))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadExceptionStatusRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x07))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadExceptionStatusResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x08))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUDiagnosticRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x08))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUDiagnosticResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x0B))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUGetComEventCounterRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x0B))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUGetComEventCounterResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x0C))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUGetComEventLogRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x0C))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUGetComEventLogResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x11))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReportServerIdRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x11))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReportServerIdResponse.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x2B))
- and EvaluationHelper.equals(response, bool(False))
- ):
- builder = ModbusPDUReadDeviceIdentificationRequest.staticParseBuilder(
- read_buffer, response
- )
- if (
- EvaluationHelper.equals(errorFlag, bool(False))
- and EvaluationHelper.equals(functionFlag, int(0x2B))
- and EvaluationHelper.equals(response, bool(True))
- ):
- builder = ModbusPDUReadDeviceIdentificationResponse.staticParseBuilder(
- read_buffer, response
- )
+ if error_flag == bool(False) and function_flag == int(0x02) and response == bool(False) :
+
+ builder = ModbusPDUReadDiscreteInputsRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x02) and response == bool(True) :
+
+ builder = ModbusPDUReadDiscreteInputsResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x01) and response == bool(False) :
+
+ builder = ModbusPDUReadCoilsRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x01) and response == bool(True) :
+
+ builder = ModbusPDUReadCoilsResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x05) and response == bool(False) :
+
+ builder = ModbusPDUWriteSingleCoilRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x05) and response == bool(True) :
+
+ builder = ModbusPDUWriteSingleCoilResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x0F) and response == bool(False) :
+
+ builder = ModbusPDUWriteMultipleCoilsRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x0F) and response == bool(True) :
+
+ builder = ModbusPDUWriteMultipleCoilsResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x04) and response == bool(False) :
+
+ builder = ModbusPDUReadInputRegistersRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x04) and response == bool(True) :
+
+ builder = ModbusPDUReadInputRegistersResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x03) and response == bool(False) :
+
+ builder = ModbusPDUReadHoldingRegistersRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x03) and response == bool(True) :
+
+ builder = ModbusPDUReadHoldingRegistersResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x06) and response == bool(False) :
+
+ builder = ModbusPDUWriteSingleRegisterRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x06) and response == bool(True) :
+
+ builder = ModbusPDUWriteSingleRegisterResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x10) and response == bool(False) :
+
+ builder = ModbusPDUWriteMultipleHoldingRegistersRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x10) and response == bool(True) :
+
+ builder = ModbusPDUWriteMultipleHoldingRegistersResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x17) and response == bool(False) :
+
+ builder = ModbusPDUReadWriteMultipleHoldingRegistersRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x17) and response == bool(True) :
+
+ builder = ModbusPDUReadWriteMultipleHoldingRegistersResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x16) and response == bool(False) :
+
+ builder = ModbusPDUMaskWriteHoldingRegisterRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x16) and response == bool(True) :
+
+ builder = ModbusPDUMaskWriteHoldingRegisterResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x18) and response == bool(False) :
+
+ builder = ModbusPDUReadFifoQueueRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x18) and response == bool(True) :
+
+ builder = ModbusPDUReadFifoQueueResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x14) and response == bool(False) :
+
+ builder = ModbusPDUReadFileRecordRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x14) and response == bool(True) :
+
+ builder = ModbusPDUReadFileRecordResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x15) and response == bool(False) :
+
+ builder = ModbusPDUWriteFileRecordRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x15) and response == bool(True) :
+
+ builder = ModbusPDUWriteFileRecordResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x07) and response == bool(False) :
+
+ builder = ModbusPDUReadExceptionStatusRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x07) and response == bool(True) :
+
+ builder = ModbusPDUReadExceptionStatusResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x08) and response == bool(False) :
+
+ builder = ModbusPDUDiagnosticRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x08) and response == bool(True) :
+
+ builder = ModbusPDUDiagnosticResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x0B) and response == bool(False) :
+
+ builder = ModbusPDUGetComEventCounterRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x0B) and response == bool(True) :
+
+ builder = ModbusPDUGetComEventCounterResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x0C) and response == bool(False) :
+
+ builder = ModbusPDUGetComEventLogRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x0C) and response == bool(True) :
+
+ builder = ModbusPDUGetComEventLogResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x11) and response == bool(False) :
+
+ builder = ModbusPDUReportServerIdRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x11) and response == bool(True) :
+
+ builder = ModbusPDUReportServerIdResponse.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x2B) and response == bool(False) :
+
+ builder = ModbusPDUReadDeviceIdentificationRequest.staticParseBuilder(read_buffer, response)
+ if error_flag == bool(False) and function_flag == int(0x2B) and response == bool(True) :
+
+ builder = ModbusPDUReadDeviceIdentificationResponse.staticParseBuilder(read_buffer, response)
if builder is None:
- raise ParseException(
- "Unsupported case for discriminated type"
- + " parameters ["
- + "errorFlag="
- + errorFlag
- + " "
- + "functionFlag="
- + functionFlag
- + " "
- + "response="
- + response
- + "]"
- )
+ raise ParseException("Unsupported case for discriminated type"+" parameters ["+"errorFlag="+error_flag+" "+"functionFlag="+function_flag+" "+"response="+response+"]")
+
read_buffer.pop_context("ModbusPDU")
# Create the instance
_modbus_pdu: ModbusPDU = builder.build()
return _modbus_pdu
+
def equals(self, o: object) -> bool:
if self == o:
return True
@@ -473,9 +264,10 @@ class ModbusPDU(ABC, PlcMessage):
return "\n" + str(write_buffer_box_based.get_box()) + "\n"
-
class ModbusPDUBuilder:
- def build(
- self,
- ) -> ModbusPDU:
+ def build(self, ) -> ModbusPDU:
pass
+
+
+
+
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
index fa0e3b756f..f278b0aa4e 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticRequest.py
@@ -69,9 +69,9 @@ class ModbusPDUDiagnosticRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUDiagnosticRequest")
- self.sub_function = read_simple_field("subFunction", read_unsigned_int)
+ sub_function: int = read_buffer.read_unsigned_int(logical_name="subFunction")
- self.data = read_simple_field("data", read_unsigned_int)
+ data: int = read_buffer.read_unsigned_int(logical_name="data")
read_buffer.pop_context("ModbusPDUDiagnosticRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
index ae121a6d24..fbdb5adfbe 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUDiagnosticResponse.py
@@ -69,9 +69,9 @@ class ModbusPDUDiagnosticResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUDiagnosticResponse")
- self.sub_function = read_simple_field("subFunction", read_unsigned_int)
+ sub_function: int = read_buffer.read_unsigned_int(logical_name="subFunction")
- self.data = read_simple_field("data", read_unsigned_int)
+ data: int = read_buffer.read_unsigned_int(logical_name="data")
read_buffer.pop_context("ModbusPDUDiagnosticResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
index a381fa68ad..f22d4719a5 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUError.py
@@ -65,10 +65,8 @@ class ModbusPDUError(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUError")
- self.exception_code = read_enum_field(
- "exceptionCode",
- "ModbusErrorCode",
- DataReaderEnumDefault(ModbusErrorCode.enumForValue, read_unsigned_short),
+ exception_code: ModbusErrorCode = read_buffer.read_complex(
+ read_function=ModbusErrorCode, logical_name="exceptionCode"
)
read_buffer.pop_context("ModbusPDUError")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
index 75acd0f904..dfc3c8e879 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventCounterResponse.py
@@ -69,9 +69,9 @@ class ModbusPDUGetComEventCounterResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUGetComEventCounterResponse")
- self.status = read_simple_field("status", read_unsigned_int)
+ status: int = read_buffer.read_unsigned_int(logical_name="status")
- self.event_count = read_simple_field("eventCount", read_unsigned_int)
+ event_count: int = read_buffer.read_unsigned_int(logical_name="eventCount")
read_buffer.pop_context("ModbusPDUGetComEventCounterResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
index 3eca6e4924..6241191317 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUGetComEventLogResponse.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -85,7 +86,7 @@ class ModbusPDUGetComEventLogResponse(PlcMessage, ModbusPDU):
length_in_bits += 16
# Array field
- if self.events != None:
+ if self.events is not None:
length_in_bits += 8 * len(self.events)
return length_in_bits
@@ -94,16 +95,18 @@ class ModbusPDUGetComEventLogResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUGetComEventLogResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- self.status = read_simple_field("status", read_unsigned_int)
+ status: int = read_buffer.read_unsigned_int(logical_name="status")
- self.event_count = read_simple_field("eventCount", read_unsigned_int)
+ event_count: int = read_buffer.read_unsigned_int(logical_name="eventCount")
- self.message_count = read_simple_field("messageCount", read_unsigned_int)
+ message_count: int = read_buffer.read_unsigned_int(logical_name="messageCount")
- events: List[int] = read_buffer.read_byte_array(
- "events", int(byte_count - int(6))
+ events: List[Any] = read_buffer.read_array_field(
+ logical_name="events",
+ read_function=read_buffer.read_byte,
+ count=byte_count - int(6),
)
read_buffer.pop_context("ModbusPDUGetComEventLogResponse")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
index 06499483b0..f0c4e832e1 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterRequest.py
@@ -78,13 +78,13 @@ class ModbusPDUMaskWriteHoldingRegisterRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUMaskWriteHoldingRegisterRequest")
- self.reference_address = read_simple_field(
- "referenceAddress", read_unsigned_int
+ reference_address: int = read_buffer.read_unsigned_int(
+ logical_name="referenceAddress"
)
- self.and_mask = read_simple_field("andMask", read_unsigned_int)
+ and_mask: int = read_buffer.read_unsigned_int(logical_name="andMask")
- self.or_mask = read_simple_field("orMask", read_unsigned_int)
+ or_mask: int = read_buffer.read_unsigned_int(logical_name="orMask")
read_buffer.pop_context("ModbusPDUMaskWriteHoldingRegisterRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
index 971214a9ba..4d8421f955 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUMaskWriteHoldingRegisterResponse.py
@@ -78,13 +78,13 @@ class ModbusPDUMaskWriteHoldingRegisterResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUMaskWriteHoldingRegisterResponse")
- self.reference_address = read_simple_field(
- "referenceAddress", read_unsigned_int
+ reference_address: int = read_buffer.read_unsigned_int(
+ logical_name="referenceAddress"
)
- self.and_mask = read_simple_field("andMask", read_unsigned_int)
+ and_mask: int = read_buffer.read_unsigned_int(logical_name="andMask")
- self.or_mask = read_simple_field("orMask", read_unsigned_int)
+ or_mask: int = read_buffer.read_unsigned_int(logical_name="orMask")
read_buffer.pop_context("ModbusPDUMaskWriteHoldingRegisterResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
index c859e440ac..c472b755ef 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsRequest.py
@@ -71,9 +71,11 @@ class ModbusPDUReadCoilsRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadCoilsRequest")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
read_buffer.pop_context("ModbusPDUReadCoilsRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
index 9d16807fb6..b8afc766da 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadCoilsResponse.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -62,7 +63,7 @@ class ModbusPDUReadCoilsResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -71,9 +72,11 @@ class ModbusPDUReadCoilsResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadCoilsResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUReadCoilsResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
index 64da7828db..7a75d295d9 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationRequest.py
@@ -83,21 +83,13 @@ class ModbusPDUReadDeviceIdentificationRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadDeviceIdentificationRequest")
- self.mei_type: int = read_const_field(
- "meiType",
- read_unsigned_short,
- ModbusPDUReadDeviceIdentificationRequest.MEITYPE,
- )
+ mei_type: int = read_buffer.read_unsigned_short(logical_name="meiType")
- self.level = read_enum_field(
- "level",
- "ModbusDeviceInformationLevel",
- DataReaderEnumDefault(
- ModbusDeviceInformationLevel.enumForValue, read_unsigned_short
- ),
+ level: ModbusDeviceInformationLevel = read_buffer.read_complex(
+ read_function=ModbusDeviceInformationLevel, logical_name="level"
)
- self.object_id = read_simple_field("objectId", read_unsigned_short)
+ object_id: int = read_buffer.read_unsigned_short(logical_name="objectId")
read_buffer.pop_context("ModbusPDUReadDeviceIdentificationRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
index 2a7bb70919..e6bc46084f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDeviceIdentificationResponse.py
@@ -135,7 +135,7 @@ class ModbusPDUReadDeviceIdentificationResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.objects != None:
+ if self.objects is not None:
i: int = 0
for element in self.objects:
last: bool = ++i >= len(self.objects)
@@ -147,49 +147,36 @@ class ModbusPDUReadDeviceIdentificationResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadDeviceIdentificationResponse")
- self.mei_type: int = read_const_field(
- "meiType",
- read_unsigned_short,
- ModbusPDUReadDeviceIdentificationResponse.MEITYPE,
- )
+ mei_type: int = read_buffer.read_unsigned_short(logical_name="meiType")
- self.level = read_enum_field(
- "level",
- "ModbusDeviceInformationLevel",
- DataReaderEnumDefault(
- ModbusDeviceInformationLevel.enumForValue, read_unsigned_short
- ),
+ level: ModbusDeviceInformationLevel = read_buffer.read_complex(
+ read_function=ModbusDeviceInformationLevel, logical_name="level"
)
- self.individual_access = read_simple_field("individualAccess", read_bit)
+ individual_access: bool = read_buffer.read_bit(logical_name="individualAccess")
- self.conformity_level = read_enum_field(
- "conformityLevel",
- "ModbusDeviceInformationConformityLevel",
- DataReaderEnumDefault(
- ModbusDeviceInformationConformityLevel.enumForValue, read_unsigned_short
- ),
+ conformity_level: ModbusDeviceInformationConformityLevel = (
+ read_buffer.read_complex(
+ read_function=ModbusDeviceInformationConformityLevel,
+ logical_name="conformityLevel",
+ )
)
- self.more_follows = read_enum_field(
- "moreFollows",
- "ModbusDeviceInformationMoreFollows",
- DataReaderEnumDefault(
- ModbusDeviceInformationMoreFollows.enumForValue, read_unsigned_short
- ),
+ more_follows: ModbusDeviceInformationMoreFollows = read_buffer.read_complex(
+ read_function=ModbusDeviceInformationMoreFollows, logical_name="moreFollows"
)
- self.next_object_id = read_simple_field("nextObjectId", read_unsigned_short)
+ next_object_id: int = read_buffer.read_unsigned_short(
+ logical_name="nextObjectId"
+ )
- number_of_objects: int = read_implicit_field(
- "numberOfObjects", read_unsigned_short
+ number_of_objects: int = read_buffer.read_unsigned_short(
+ logical_name="numberOfObjects"
)
objects: List[Any] = read_buffer.read_array_field(
- "objects",
- read_buffer.DataReaderComplexDefault(
- ModbusDeviceInformationObject.static_parse(read_buffer), read_buffer
- ),
+ logical_name="objects",
+ read_function=ModbusDeviceInformationObject.static_parse,
count=number_of_objects,
)
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
index a29eff9602..90fe4c46a9 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsRequest.py
@@ -71,9 +71,11 @@ class ModbusPDUReadDiscreteInputsRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadDiscreteInputsRequest")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
read_buffer.pop_context("ModbusPDUReadDiscreteInputsRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
index 933e51403d..fc2dfa9197 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadDiscreteInputsResponse.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -62,7 +63,7 @@ class ModbusPDUReadDiscreteInputsResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -71,9 +72,11 @@ class ModbusPDUReadDiscreteInputsResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadDiscreteInputsResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUReadDiscreteInputsResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
index 3208f320a7..9e2eb269f7 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadExceptionStatusResponse.py
@@ -62,7 +62,7 @@ class ModbusPDUReadExceptionStatusResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadExceptionStatusResponse")
- self.value = read_simple_field("value", read_unsigned_short)
+ value: int = read_buffer.read_unsigned_short(logical_name="value")
read_buffer.pop_context("ModbusPDUReadExceptionStatusResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
index f5c975b3be..fa9daee348 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueRequest.py
@@ -64,8 +64,8 @@ class ModbusPDUReadFifoQueueRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadFifoQueueRequest")
- self.fifo_pointer_address = read_simple_field(
- "fifoPointerAddress", read_unsigned_int
+ fifo_pointer_address: int = read_buffer.read_unsigned_int(
+ logical_name="fifoPointerAddress"
)
read_buffer.pop_context("ModbusPDUReadFifoQueueRequest")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
index d494bb3576..6eef53d57c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFifoQueueResponse.py
@@ -72,7 +72,7 @@ class ModbusPDUReadFifoQueueResponse(PlcMessage, ModbusPDU):
length_in_bits += 16
# Array field
- if self.fifo_value != None:
+ if self.fifo_value is not None:
length_in_bits += 16 * len(self.fifo_value)
return length_in_bits
@@ -81,12 +81,14 @@ class ModbusPDUReadFifoQueueResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadFifoQueueResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_int)
+ byte_count: int = read_buffer.read_unsigned_int(logical_name="byteCount")
- fifo_count: int = read_implicit_field("fifoCount", read_unsigned_int)
+ fifo_count: int = read_buffer.read_unsigned_int(logical_name="fifoCount")
fifo_value: List[Any] = read_buffer.read_array_field(
- "fifoValue", read_buffer.read_unsigned_int, count=fifo_count
+ logical_name="fifoValue",
+ read_function=read_buffer.read_unsigned_int,
+ count=fifo_count,
)
read_buffer.pop_context("ModbusPDUReadFifoQueueResponse")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
index d4e8d93e5e..7608972cb0 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequest.py
@@ -28,6 +28,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordRequestItem import
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
from sys import getsizeof
+from typing import Any
from typing import List
import math
@@ -66,7 +67,7 @@ class ModbusPDUReadFileRecordRequest(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.items != None:
+ if self.items is not None:
for element in self.items:
length_in_bits += element.get_length_in_bits()
@@ -76,14 +77,11 @@ class ModbusPDUReadFileRecordRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadFileRecordRequest")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
items: List[Any] = read_buffer.read_array_field(
- "items",
- read_buffer.DataReaderComplexDefault(
- ModbusPDUReadFileRecordRequestItem.static_parse(read_buffer),
- read_buffer,
- ),
+ logical_name="items",
+ read_function=ModbusPDUReadFileRecordRequestItem.static_parse,
length=byte_count,
)
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
index c0911368ae..618c71dc1c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordRequestItem.py
@@ -79,20 +79,23 @@ class ModbusPDUReadFileRecordRequestItem(PlcMessage):
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- return self.static_parse_context(read_buffer)
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+ return ModbusPDUReadFileRecordRequestItem.static_parse_context(read_buffer)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer):
read_buffer.push_context("ModbusPDUReadFileRecordRequestItem")
- self.reference_type = read_simple_field("referenceType", read_unsigned_short)
+ reference_type: int = read_buffer.read_unsigned_short(
+ logical_name="referenceType"
+ )
- self.file_number = read_simple_field("fileNumber", read_unsigned_int)
+ file_number: int = read_buffer.read_unsigned_int(logical_name="fileNumber")
- self.record_number = read_simple_field("recordNumber", read_unsigned_int)
+ record_number: int = read_buffer.read_unsigned_int(logical_name="recordNumber")
- self.record_length = read_simple_field("recordLength", read_unsigned_int)
+ record_length: int = read_buffer.read_unsigned_int(logical_name="recordLength")
read_buffer.pop_context("ModbusPDUReadFileRecordRequestItem")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
index 98a36b7bce..773fa76c14 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponse.py
@@ -28,6 +28,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDUReadFileRecordResponseItem impor
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
from sys import getsizeof
+from typing import Any
from typing import List
import math
@@ -66,7 +67,7 @@ class ModbusPDUReadFileRecordResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.items != None:
+ if self.items is not None:
for element in self.items:
length_in_bits += element.get_length_in_bits()
@@ -76,14 +77,11 @@ class ModbusPDUReadFileRecordResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadFileRecordResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
items: List[Any] = read_buffer.read_array_field(
- "items",
- read_buffer.DataReaderComplexDefault(
- ModbusPDUReadFileRecordResponseItem.static_parse(read_buffer),
- read_buffer,
- ),
+ logical_name="items",
+ read_function=ModbusPDUReadFileRecordResponseItem.static_parse,
length=byte_count,
)
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
index a962fafb6a..1ab3997d24 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadFileRecordResponseItem.py
@@ -22,6 +22,7 @@ from dataclasses import dataclass
from plc4py.api.messages.PlcMessage import PlcMessage
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -65,23 +66,30 @@ class ModbusPDUReadFileRecordResponseItem(PlcMessage):
length_in_bits += 8
# Array field
- if self.data != None:
+ if self.data is not None:
length_in_bits += 8 * len(self.data)
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- return self.static_parse_context(read_buffer)
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+ return ModbusPDUReadFileRecordResponseItem.static_parse_context(read_buffer)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer):
read_buffer.push_context("ModbusPDUReadFileRecordResponseItem")
- data_length: int = read_implicit_field("dataLength", read_unsigned_short)
+ data_length: int = read_buffer.read_unsigned_short(logical_name="dataLength")
- self.reference_type = read_simple_field("referenceType", read_unsigned_short)
+ reference_type: int = read_buffer.read_unsigned_short(
+ logical_name="referenceType"
+ )
- data: List[int] = read_buffer.read_byte_array("data", int(data_length - int(1)))
+ data: List[Any] = read_buffer.read_array_field(
+ logical_name="data",
+ read_function=read_buffer.read_byte,
+ count=data_length - int(1),
+ )
read_buffer.pop_context("ModbusPDUReadFileRecordResponseItem")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
index 4369fb8769..509592eb10 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersRequest.py
@@ -71,9 +71,11 @@ class ModbusPDUReadHoldingRegistersRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadHoldingRegistersRequest")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
read_buffer.pop_context("ModbusPDUReadHoldingRegistersRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
index 38ca927892..d1d52669df 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadHoldingRegistersResponse.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -62,7 +63,7 @@ class ModbusPDUReadHoldingRegistersResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -71,9 +72,11 @@ class ModbusPDUReadHoldingRegistersResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadHoldingRegistersResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUReadHoldingRegistersResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
index f2b8582d9e..576f97509f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersRequest.py
@@ -71,9 +71,11 @@ class ModbusPDUReadInputRegistersRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadInputRegistersRequest")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
read_buffer.pop_context("ModbusPDUReadInputRegistersRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
index 17d11fbdba..9e4f6d7622 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadInputRegistersResponse.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -62,7 +63,7 @@ class ModbusPDUReadInputRegistersResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -71,9 +72,11 @@ class ModbusPDUReadInputRegistersResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadInputRegistersResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUReadInputRegistersResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
index 84b55d0efa..776d1d6172 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersRequest.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -98,7 +99,7 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -107,21 +108,25 @@ class ModbusPDUReadWriteMultipleHoldingRegistersRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
- self.read_starting_address = read_simple_field(
- "readStartingAddress", read_unsigned_int
+ read_starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="readStartingAddress"
)
- self.read_quantity = read_simple_field("readQuantity", read_unsigned_int)
+ read_quantity: int = read_buffer.read_unsigned_int(logical_name="readQuantity")
- self.write_starting_address = read_simple_field(
- "writeStartingAddress", read_unsigned_int
+ write_starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="writeStartingAddress"
)
- self.write_quantity = read_simple_field("writeQuantity", read_unsigned_int)
+ write_quantity: int = read_buffer.read_unsigned_int(
+ logical_name="writeQuantity"
+ )
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUReadWriteMultipleHoldingRegistersRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
index 3e833d0d0f..eec4dce94c 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReadWriteMultipleHoldingRegistersResponse.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -62,7 +63,7 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -71,9 +72,11 @@ class ModbusPDUReadWriteMultipleHoldingRegistersResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUReadWriteMultipleHoldingRegistersResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
index 8494e44275..4cc9645196 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUReportServerIdResponse.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -62,7 +63,7 @@ class ModbusPDUReportServerIdResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -71,9 +72,11 @@ class ModbusPDUReportServerIdResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUReportServerIdResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUReportServerIdResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
index 3440d2c870..00a4c7abff 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequest.py
@@ -28,6 +28,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordRequestItem impor
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
from sys import getsizeof
+from typing import Any
from typing import List
import math
@@ -66,7 +67,7 @@ class ModbusPDUWriteFileRecordRequest(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.items != None:
+ if self.items is not None:
for element in self.items:
length_in_bits += element.get_length_in_bits()
@@ -76,14 +77,11 @@ class ModbusPDUWriteFileRecordRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteFileRecordRequest")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
items: List[Any] = read_buffer.read_array_field(
- "items",
- read_buffer.DataReaderComplexDefault(
- ModbusPDUWriteFileRecordRequestItem.static_parse(read_buffer),
- read_buffer,
- ),
+ logical_name="items",
+ read_function=ModbusPDUWriteFileRecordRequestItem.static_parse,
length=byte_count,
)
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
index 16fd0058d9..ac5cf8ea9a 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordRequestItem.py
@@ -22,6 +22,7 @@ from dataclasses import dataclass
from plc4py.api.messages.PlcMessage import PlcMessage
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -81,28 +82,33 @@ class ModbusPDUWriteFileRecordRequestItem(PlcMessage):
length_in_bits += 16
# Array field
- if self.record_data != None:
+ if self.record_data is not None:
length_in_bits += 8 * len(self.record_data)
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- return self.static_parse_context(read_buffer)
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+ return ModbusPDUWriteFileRecordRequestItem.static_parse_context(read_buffer)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer):
read_buffer.push_context("ModbusPDUWriteFileRecordRequestItem")
- self.reference_type = read_simple_field("referenceType", read_unsigned_short)
+ reference_type: int = read_buffer.read_unsigned_short(
+ logical_name="referenceType"
+ )
- self.file_number = read_simple_field("fileNumber", read_unsigned_int)
+ file_number: int = read_buffer.read_unsigned_int(logical_name="fileNumber")
- self.record_number = read_simple_field("recordNumber", read_unsigned_int)
+ record_number: int = read_buffer.read_unsigned_int(logical_name="recordNumber")
- record_length: int = read_implicit_field("recordLength", read_unsigned_int)
+ record_length: int = read_buffer.read_unsigned_int(logical_name="recordLength")
- record_data: List[int] = read_buffer.read_byte_array(
- "recordData", int(record_length * int(2))
+ record_data: List[Any] = read_buffer.read_array_field(
+ logical_name="recordData",
+ read_function=read_buffer.read_byte,
+ count=record_length * int(2),
)
read_buffer.pop_context("ModbusPDUWriteFileRecordRequestItem")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
index d940c90e94..90babb5aab 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponse.py
@@ -28,6 +28,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDUWriteFileRecordResponseItem impo
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
from sys import getsizeof
+from typing import Any
from typing import List
import math
@@ -66,7 +67,7 @@ class ModbusPDUWriteFileRecordResponse(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.items != None:
+ if self.items is not None:
for element in self.items:
length_in_bits += element.get_length_in_bits()
@@ -76,14 +77,11 @@ class ModbusPDUWriteFileRecordResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteFileRecordResponse")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
items: List[Any] = read_buffer.read_array_field(
- "items",
- read_buffer.DataReaderComplexDefault(
- ModbusPDUWriteFileRecordResponseItem.static_parse(read_buffer),
- read_buffer,
- ),
+ logical_name="items",
+ read_function=ModbusPDUWriteFileRecordResponseItem.static_parse,
length=byte_count,
)
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
index efc5288556..9bad01b99f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteFileRecordResponseItem.py
@@ -22,6 +22,7 @@ from dataclasses import dataclass
from plc4py.api.messages.PlcMessage import PlcMessage
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -81,28 +82,33 @@ class ModbusPDUWriteFileRecordResponseItem(PlcMessage):
length_in_bits += 16
# Array field
- if self.record_data != None:
+ if self.record_data is not None:
length_in_bits += 8 * len(self.record_data)
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- return self.static_parse_context(read_buffer)
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+ return ModbusPDUWriteFileRecordResponseItem.static_parse_context(read_buffer)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer):
read_buffer.push_context("ModbusPDUWriteFileRecordResponseItem")
- self.reference_type = read_simple_field("referenceType", read_unsigned_short)
+ reference_type: int = read_buffer.read_unsigned_short(
+ logical_name="referenceType"
+ )
- self.file_number = read_simple_field("fileNumber", read_unsigned_int)
+ file_number: int = read_buffer.read_unsigned_int(logical_name="fileNumber")
- self.record_number = read_simple_field("recordNumber", read_unsigned_int)
+ record_number: int = read_buffer.read_unsigned_int(logical_name="recordNumber")
- record_length: int = read_implicit_field("recordLength", read_unsigned_int)
+ record_length: int = read_buffer.read_unsigned_int(logical_name="recordLength")
- record_data: List[int] = read_buffer.read_byte_array(
- "recordData", int(record_length)
+ record_data: List[Any] = read_buffer.read_array_field(
+ logical_name="recordData",
+ read_function=read_buffer.read_byte,
+ count=record_length,
)
read_buffer.pop_context("ModbusPDUWriteFileRecordResponseItem")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
index cae30a2575..d1ea6e0190 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsRequest.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -78,7 +79,7 @@ class ModbusPDUWriteMultipleCoilsRequest(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -87,13 +88,17 @@ class ModbusPDUWriteMultipleCoilsRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteMultipleCoilsRequest")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUWriteMultipleCoilsRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
index 01b9d05b45..d0bf4e8e55 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleCoilsResponse.py
@@ -71,9 +71,11 @@ class ModbusPDUWriteMultipleCoilsResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteMultipleCoilsResponse")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
read_buffer.pop_context("ModbusPDUWriteMultipleCoilsResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
index d54cd6e0e2..c9ac7c9a88 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersRequest.py
@@ -24,6 +24,7 @@ from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDUBuilder
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from typing import Any
from typing import List
import math
@@ -78,7 +79,7 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage, ModbusPDU):
length_in_bits += 8
# Array field
- if self.value != None:
+ if self.value is not None:
length_in_bits += 8 * len(self.value)
return length_in_bits
@@ -87,13 +88,17 @@ class ModbusPDUWriteMultipleHoldingRegistersRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteMultipleHoldingRegistersRequest")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
- byte_count: int = read_implicit_field("byteCount", read_unsigned_short)
+ byte_count: int = read_buffer.read_unsigned_short(logical_name="byteCount")
- value: List[int] = read_buffer.read_byte_array("value", int(byte_count))
+ value: List[Any] = read_buffer.read_array_field(
+ logical_name="value", read_function=read_buffer.read_byte, count=byte_count
+ )
read_buffer.pop_context("ModbusPDUWriteMultipleHoldingRegistersRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
index 7c1a2ce8cf..66dbeda367 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteMultipleHoldingRegistersResponse.py
@@ -71,9 +71,11 @@ class ModbusPDUWriteMultipleHoldingRegistersResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteMultipleHoldingRegistersResponse")
- self.starting_address = read_simple_field("startingAddress", read_unsigned_int)
+ starting_address: int = read_buffer.read_unsigned_int(
+ logical_name="startingAddress"
+ )
- self.quantity = read_simple_field("quantity", read_unsigned_int)
+ quantity: int = read_buffer.read_unsigned_int(logical_name="quantity")
read_buffer.pop_context("ModbusPDUWriteMultipleHoldingRegistersResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
index 622dcce936..6d0b1bd121 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilRequest.py
@@ -69,9 +69,9 @@ class ModbusPDUWriteSingleCoilRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteSingleCoilRequest")
- self.address = read_simple_field("address", read_unsigned_int)
+ address: int = read_buffer.read_unsigned_int(logical_name="address")
- self.value = read_simple_field("value", read_unsigned_int)
+ value: int = read_buffer.read_unsigned_int(logical_name="value")
read_buffer.pop_context("ModbusPDUWriteSingleCoilRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
index 7956323311..28aedaa794 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleCoilResponse.py
@@ -69,9 +69,9 @@ class ModbusPDUWriteSingleCoilResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteSingleCoilResponse")
- self.address = read_simple_field("address", read_unsigned_int)
+ address: int = read_buffer.read_unsigned_int(logical_name="address")
- self.value = read_simple_field("value", read_unsigned_int)
+ value: int = read_buffer.read_unsigned_int(logical_name="value")
read_buffer.pop_context("ModbusPDUWriteSingleCoilResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
index 5b8a0ec0a6..9f649af07f 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterRequest.py
@@ -69,9 +69,9 @@ class ModbusPDUWriteSingleRegisterRequest(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteSingleRegisterRequest")
- self.address = read_simple_field("address", read_unsigned_int)
+ address: int = read_buffer.read_unsigned_int(logical_name="address")
- self.value = read_simple_field("value", read_unsigned_int)
+ value: int = read_buffer.read_unsigned_int(logical_name="value")
read_buffer.pop_context("ModbusPDUWriteSingleRegisterRequest")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
index 68f6eb11b9..e4e6c8f711 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusPDUWriteSingleRegisterResponse.py
@@ -69,9 +69,9 @@ class ModbusPDUWriteSingleRegisterResponse(PlcMessage, ModbusPDU):
def static_parse_builder(read_buffer: ReadBuffer, response: bool):
read_buffer.push_context("ModbusPDUWriteSingleRegisterResponse")
- self.address = read_simple_field("address", read_unsigned_int)
+ address: int = read_buffer.read_unsigned_int(logical_name="address")
- self.value = read_simple_field("value", read_unsigned_int)
+ value: int = read_buffer.read_unsigned_int(logical_name="value")
read_buffer.pop_context("ModbusPDUWriteSingleRegisterResponse")
# Create the instance
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
index be244d4dd0..4bd868cd9b 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusRtuADU.py
@@ -27,6 +27,7 @@ from plc4py.protocols.modbus.readwrite.ModbusADU import ModbusADUBuilder
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from plc4py.utils.GenericTypes import ByteOrder
import math
@@ -53,7 +54,7 @@ class ModbusRtuADU(PlcMessage, ModbusADU):
# Checksum Field (checksum) (Calculated)
write_buffer.write_unsigned_short(
- int(StaticHelper.rtu_crc_check(self.address, self.pdu)), logical_name="crc"
+ int(StaticHelper.rtu_crc_check(address, pdu)), logical_name="crc"
)
write_buffer.pop_context("ModbusRtuADU")
@@ -82,23 +83,18 @@ class ModbusRtuADU(PlcMessage, ModbusADU):
):
read_buffer.push_context("ModbusRtuADU")
- self.address = read_simple_field(
- "address", read_unsigned_short, WithOption.WithByteOrder(get_bi_g__endian())
+ address: int = read_buffer.read_unsigned_short(
+ logical_name="address", byte_order=ByteOrder.BIG_ENDIAN
)
- self.pdu = read_simple_field(
- "pdu",
- DataReaderComplexDefault(
- ModbusPDU.static_parse(read_buffer, bool(response)), read_buffer
- ),
- WithOption.WithByteOrder(get_bi_g__endian()),
+ pdu: ModbusPDU = read_buffer.read_complex(
+ read_function=ModbusPDU.static_parse,
+ logical_name="pdu",
+ byte_order=ByteOrder.BIG_ENDIAN,
)
- crc: int = read_checksum_field(
- "crc",
- read_unsigned_int,
- (int)(rtu_crc_check(self.address, self.pdu)),
- WithOption.WithByteOrder(get_bi_g__endian()),
+ crc: int = read_buffer.read_unsigned_int(
+ logical_name="crc", byte_order=ByteOrder.BIG_ENDIAN
)
read_buffer.pop_context("ModbusRtuADU")
diff --git a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
index 6c4b23c692..b759fab337 100644
--- a/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
+++ b/sandbox/plc4py/plc4py/protocols/modbus/readwrite/ModbusTcpADU.py
@@ -26,6 +26,7 @@ from plc4py.protocols.modbus.readwrite.ModbusADU import ModbusADUBuilder
from plc4py.protocols.modbus.readwrite.ModbusPDU import ModbusPDU
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from plc4py.utils.GenericTypes import ByteOrder
import math
@@ -100,35 +101,26 @@ class ModbusTcpADU(PlcMessage, ModbusADU):
):
read_buffer.push_context("ModbusTcpADU")
- self.transaction_identifier = read_simple_field(
- "transactionIdentifier",
- read_unsigned_int,
- WithOption.WithByteOrder(get_bi_g__endian()),
+ transaction_identifier: int = read_buffer.read_unsigned_int(
+ logical_name="transactionIdentifier", byte_order=ByteOrder.BIG_ENDIAN
)
- self.protocol_identifier: int = read_const_field(
- "protocolIdentifier",
- read_unsigned_int,
- ModbusTcpADU.PROTOCOLIDENTIFIER,
- WithOption.WithByteOrder(get_bi_g__endian()),
+ protocol_identifier: int = read_buffer.read_unsigned_int(
+ logical_name="protocolIdentifier", byte_order=ByteOrder.BIG_ENDIAN
)
- length: int = read_implicit_field(
- "length", read_unsigned_int, WithOption.WithByteOrder(get_bi_g__endian())
+ length: int = read_buffer.read_unsigned_int(
+ logical_name="length", byte_order=ByteOrder.BIG_ENDIAN
)
- self.unit_identifier = read_simple_field(
- "unitIdentifier",
- read_unsigned_short,
- WithOption.WithByteOrder(get_bi_g__endian()),
+ unit_identifier: int = read_buffer.read_unsigned_short(
+ logical_name="unitIdentifier", byte_order=ByteOrder.BIG_ENDIAN
)
- self.pdu = read_simple_field(
- "pdu",
- DataReaderComplexDefault(
- ModbusPDU.static_parse(read_buffer, bool(response)), read_buffer
- ),
- WithOption.WithByteOrder(get_bi_g__endian()),
+ pdu: ModbusPDU = read_buffer.read_complex(
+ read_function=ModbusPDU.static_parse,
+ logical_name="pdu",
+ byte_order=ByteOrder.BIG_ENDIAN,
)
read_buffer.pop_context("ModbusTcpADU")
diff --git a/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py b/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py
index 265ce93a11..809018f116 100644
--- a/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py
+++ b/sandbox/plc4py/plc4py/protocols/simulated/readwrite/DataItem.py
@@ -35,15 +35,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_bool"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcBOOL(bool(read_buffer.read_bit(""))))
@@ -59,15 +59,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_byte"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -85,15 +85,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_word"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -111,15 +111,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_dword"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -137,15 +137,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_lword"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -165,15 +165,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_sint"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -191,15 +191,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_int"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcINT(int(read_buffer.read_short(16, logical_name=""))))
@@ -215,15 +215,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_dint"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcDINT(int(read_buffer.read_int(32, logical_name=""))))
@@ -239,15 +239,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_lint"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(PlcLINT(int(read_buffer.read_long(64, logical_name=""))))
@@ -263,15 +263,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_usint"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -289,15 +289,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_uint"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -315,15 +315,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_udint"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -341,15 +341,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_ulint"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -369,15 +369,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_real"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -395,15 +395,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_lreal"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -421,15 +421,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_char"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -449,15 +449,15 @@ class DataItem:
if EvaluationHelper.equals(data_type, "_wchar"): # List
# Array field (value)
# Count array
- if numberOfValues > Integer.MAX_VALUE:
+ if number_of_values > Integer.MAX_VALUE:
raise ParseException(
"Array count of "
- + (numberOfValues)
+ + (number_of_values)
+ " exceeds the maximum allowed count of "
+ Integer.MAX_VALUE
)
- item_count: int = int(numberOfValues)
+ item_count: int = int(number_of_values)
value: List[PlcValue] = []
for cur_item in range(item_count):
value.append(
@@ -495,232 +495,232 @@ class DataItem:
numberOfValues: int,
byteOrder: ByteOrder,
) -> None:
- if EvaluationHelper.equals(dataType, "BOOL") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "BOOL") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # BOOL
# Simple Field (value)
value: bool = _value.getBool()
writeBuffer.WriteBit("value", (value))
- if EvaluationHelper.equals(dataType, "BOOL"): # List
+ if EvaluationHelper.equals(data_type, "BOOL"): # List
values: PlcList = _value
for val in values.getList():
value: bool = val.getBool()
writeBuffer.WriteBit("value", (value))
- if EvaluationHelper.equals(dataType, "BYTE") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "BYTE") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # BYTE
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint8("value", 8, (value))
- if EvaluationHelper.equals(dataType, "BYTE"): # List
+ if EvaluationHelper.equals(data_type, "BYTE"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint8("value", 8, (value))
- if EvaluationHelper.equals(dataType, "WORD") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "WORD") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # WORD
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint16("value", 16, (value))
- if EvaluationHelper.equals(dataType, "WORD"): # List
+ if EvaluationHelper.equals(data_type, "WORD"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint16("value", 16, (value))
- if EvaluationHelper.equals(dataType, "DWORD") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "DWORD") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # DWORD
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "DWORD"): # List
+ if EvaluationHelper.equals(data_type, "DWORD"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "LWORD") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "LWORD") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # LWORD
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "LWORD"): # List
+ if EvaluationHelper.equals(data_type, "LWORD"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "SINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "SINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # SINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt8("value", 8, (value))
- if EvaluationHelper.equals(dataType, "SINT"): # List
+ if EvaluationHelper.equals(data_type, "SINT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteInt8("value", 8, (value))
- if EvaluationHelper.equals(dataType, "INT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "INT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # INT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt16("value", 16, (value))
- if EvaluationHelper.equals(dataType, "INT"): # List
+ if EvaluationHelper.equals(data_type, "INT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteInt16("value", 16, (value))
- if EvaluationHelper.equals(dataType, "DINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "DINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # DINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "DINT"): # List
+ if EvaluationHelper.equals(data_type, "DINT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteInt32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "LINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "LINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # LINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteInt64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "LINT"): # List
+ if EvaluationHelper.equals(data_type, "LINT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteInt64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "USINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "USINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # USINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint8("value", 8, (value))
- if EvaluationHelper.equals(dataType, "USINT"): # List
+ if EvaluationHelper.equals(data_type, "USINT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint8("value", 8, (value))
- if EvaluationHelper.equals(dataType, "UINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "UINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # UINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint16("value", 16, (value))
- if EvaluationHelper.equals(dataType, "UINT"): # List
+ if EvaluationHelper.equals(data_type, "UINT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint16("value", 16, (value))
- if EvaluationHelper.equals(dataType, "UDINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "UDINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # UDINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "UDINT"): # List
+ if EvaluationHelper.equals(data_type, "UDINT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "ULINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "ULINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # ULINT
# Simple Field (value)
value: int = _value.getInt()
writeBuffer.WriteUint64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "ULINT"): # List
+ if EvaluationHelper.equals(data_type, "ULINT"): # List
values: PlcList = _value
for val in values.getList():
value: int = val.getInt()
writeBuffer.WriteUint64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "REAL") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "REAL") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # REAL
# Simple Field (value)
value: float = _value.getFloat()
writeBuffer.WriteFloat32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "REAL"): # List
+ if EvaluationHelper.equals(data_type, "REAL"): # List
values: PlcList = _value
for val in values.getList():
value: float = val.getFloat()
writeBuffer.WriteFloat32("value", 32, (value))
- if EvaluationHelper.equals(dataType, "LREAL") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "LREAL") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # LREAL
# Simple Field (value)
value: float = _value.getFloat()
writeBuffer.WriteFloat64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "LREAL"): # List
+ if EvaluationHelper.equals(data_type, "LREAL"): # List
values: PlcList = _value
for val in values.getList():
value: float = val.getFloat()
writeBuffer.WriteFloat64("value", 64, (value))
- if EvaluationHelper.equals(dataType, "CHAR") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "CHAR") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # CHAR
# Simple Field (value)
value: str = _value.getStr()
writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
- if EvaluationHelper.equals(dataType, "CHAR"): # List
+ if EvaluationHelper.equals(data_type, "CHAR"): # List
values: PlcList = _value
for val in values.getList():
value: str = val.getStr()
writeBuffer.WriteString("value", uint32(8), "UTF-8", (value))
- if EvaluationHelper.equals(dataType, "WCHAR") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "WCHAR") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # WCHAR
# Simple Field (value)
value: str = _value.getStr()
writeBuffer.WriteString("value", uint32(16), "UTF-16", (value))
- if EvaluationHelper.equals(dataType, "WCHAR"): # List
+ if EvaluationHelper.equals(data_type, "WCHAR"): # List
values: PlcList = _value
for val in values.getList():
value: str = val.getStr()
writeBuffer.WriteString("value", uint32(16), "UTF-16", (value))
- if EvaluationHelper.equals(dataType, "STRING"): # STRING
+ if EvaluationHelper.equals(data_type, "STRING"): # STRING
# Simple Field (value)
value: str = _value.getStr()
writeBuffer.WriteString("value", uint32(255), "UTF-8", (value))
- if EvaluationHelper.equals(dataType, "WSTRING"): # STRING
+ if EvaluationHelper.equals(data_type, "WSTRING"): # STRING
# Simple Field (value)
value: str = _value.getStr()
writeBuffer.WriteString("value", uint32(255), "UTF-16", (value))
@@ -736,146 +736,146 @@ class DataItem:
@staticmethod
def get_length_in_bits(_value: PlcValue, dataType: str, numberOfValues: int) -> int:
sizeInBits: int = 0
- if EvaluationHelper.equals(dataType, "BOOL") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "BOOL") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # BOOL
# Simple Field (value)
sizeInBits += 1
- if EvaluationHelper.equals(dataType, "BOOL"): # List
+ if EvaluationHelper.equals(data_type, "BOOL"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 1
- if EvaluationHelper.equals(dataType, "BYTE") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "BYTE") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # BYTE
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, "BYTE"): # List
+ if EvaluationHelper.equals(data_type, "BYTE"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 8
- if EvaluationHelper.equals(dataType, "WORD") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "WORD") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # WORD
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, "WORD"): # List
+ if EvaluationHelper.equals(data_type, "WORD"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 16
- if EvaluationHelper.equals(dataType, "DWORD") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "DWORD") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # DWORD
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, "DWORD"): # List
+ if EvaluationHelper.equals(data_type, "DWORD"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 32
- if EvaluationHelper.equals(dataType, "LWORD") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "LWORD") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # LWORD
# Simple Field (value)
sizeInBits += 64
- if EvaluationHelper.equals(dataType, "LWORD"): # List
+ if EvaluationHelper.equals(data_type, "LWORD"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 64
- if EvaluationHelper.equals(dataType, "SINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "SINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # SINT
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, "SINT"): # List
+ if EvaluationHelper.equals(data_type, "SINT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 8
- if EvaluationHelper.equals(dataType, "INT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "INT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # INT
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, "INT"): # List
+ if EvaluationHelper.equals(data_type, "INT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 16
- if EvaluationHelper.equals(dataType, "DINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "DINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # DINT
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, "DINT"): # List
+ if EvaluationHelper.equals(data_type, "DINT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 32
- if EvaluationHelper.equals(dataType, "LINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "LINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # LINT
# Simple Field (value)
sizeInBits += 64
- if EvaluationHelper.equals(dataType, "LINT"): # List
+ if EvaluationHelper.equals(data_type, "LINT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 64
- if EvaluationHelper.equals(dataType, "USINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "USINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # USINT
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, "USINT"): # List
+ if EvaluationHelper.equals(data_type, "USINT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 8
- if EvaluationHelper.equals(dataType, "UINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "UINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # UINT
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, "UINT"): # List
+ if EvaluationHelper.equals(data_type, "UINT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 16
- if EvaluationHelper.equals(dataType, "UDINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "UDINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # UDINT
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, "UDINT"): # List
+ if EvaluationHelper.equals(data_type, "UDINT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 32
- if EvaluationHelper.equals(dataType, "ULINT") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "ULINT") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # ULINT
# Simple Field (value)
sizeInBits += 64
- if EvaluationHelper.equals(dataType, "ULINT"): # List
+ if EvaluationHelper.equals(data_type, "ULINT"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 64
- if EvaluationHelper.equals(dataType, "REAL") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "REAL") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # REAL
# Simple Field (value)
sizeInBits += 32
- if EvaluationHelper.equals(dataType, "REAL"): # List
+ if EvaluationHelper.equals(data_type, "REAL"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 32
- if EvaluationHelper.equals(dataType, "LREAL") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "LREAL") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # LREAL
# Simple Field (value)
sizeInBits += 64
- if EvaluationHelper.equals(dataType, "LREAL"): # List
+ if EvaluationHelper.equals(data_type, "LREAL"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 64
- if EvaluationHelper.equals(dataType, "CHAR") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "CHAR") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # CHAR
# Simple Field (value)
sizeInBits += 8
- if EvaluationHelper.equals(dataType, "CHAR"): # List
+ if EvaluationHelper.equals(data_type, "CHAR"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 8
- if EvaluationHelper.equals(dataType, "WCHAR") and EvaluationHelper.equals(
- numberOfValues, int(1)
+ if EvaluationHelper.equals(data_type, "WCHAR") and EvaluationHelper.equals(
+ number_of_values, int(1)
): # WCHAR
# Simple Field (value)
sizeInBits += 16
- if EvaluationHelper.equals(dataType, "WCHAR"): # List
+ if EvaluationHelper.equals(data_type, "WCHAR"): # List
values: PlcList = _value
sizeInBits += values.getList().size() * 16
- if EvaluationHelper.equals(dataType, "STRING"): # STRING
+ if EvaluationHelper.equals(data_type, "STRING"): # STRING
# Simple Field (value)
sizeInBits += 255
- if EvaluationHelper.equals(dataType, "WSTRING"): # STRING
+ if EvaluationHelper.equals(data_type, "WSTRING"): # STRING
# Simple Field (value)
sizeInBits += 255
return sizeInBits
diff --git a/sandbox/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py b/sandbox/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py
index 1d949e7cfb..cbae363aee 100644
--- a/sandbox/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py
+++ b/sandbox/plc4py/plc4py/protocols/simulated/readwrite/Dummy.py
@@ -22,6 +22,7 @@ from dataclasses import dataclass
from plc4py.api.messages.PlcMessage import PlcMessage
from plc4py.spi.generation.ReadBuffer import ReadBuffer
from plc4py.spi.generation.WriteBuffer import WriteBuffer
+from plc4py.utils.GenericTypes import ByteOrder
import math
@@ -52,15 +53,16 @@ class Dummy(PlcMessage):
return length_in_bits
- def static_parse(self, read_buffer: ReadBuffer, args):
- return self.static_parse_context(read_buffer)
+ @staticmethod
+ def static_parse(read_buffer: ReadBuffer, **kwargs):
+ return Dummy.static_parse_context(read_buffer)
@staticmethod
def static_parse_context(read_buffer: ReadBuffer):
read_buffer.push_context("Dummy")
- self.dummy = read_simple_field(
- "dummy", read_unsigned_int, WithOption.WithByteOrder(get_bi_g__endian())
+ dummy: int = read_buffer.read_unsigned_int(
+ logical_name="dummy", byte_order=ByteOrder.BIG_ENDIAN
)
read_buffer.pop_context("Dummy")
diff --git a/sandbox/plc4py/plc4py/spi/generation/ReadBuffer.py b/sandbox/plc4py/plc4py/spi/generation/ReadBuffer.py
index 7e46a51f58..c1b7dfd04c 100644
--- a/sandbox/plc4py/plc4py/spi/generation/ReadBuffer.py
+++ b/sandbox/plc4py/plc4py/spi/generation/ReadBuffer.py
@@ -30,7 +30,7 @@ from ctypes import (
c_uint8,
)
from dataclasses import dataclass
-from typing import List, Union
+from typing import List, Union, Any
from bitarray import bitarray
from bitarray.util import zeros, ba2int, ba2base
@@ -119,7 +119,10 @@ class ReadBuffer(ByteOrderAware, PositionAware):
def read_virtual(self, logical_name: str = "", **kwargs) -> str:
raise NotImplementedError
- def read_complex_array(self, logical_name: str = "", **kwargs) -> List[PlcMessage]:
+ def read_complex_array(self, logical_name: str = "", **kwargs) -> List[Any]:
+ raise NotImplementedError
+
+ def read_complex(self, logical_name: str = "", read_function=None, **kwargs) -> Any:
raise NotImplementedError
def read_array_field(
@@ -130,7 +133,7 @@ class ReadBuffer(ByteOrderAware, PositionAware):
length: int = None,
terminated=None,
**kwargs
- ) -> List[PlcMessage]:
+ ) -> List[Any]:
raise NotImplementedError